codeql/misc/scripts/shared-code-metrics.py at codeql-cli/v2.25.6 · github/codeql · GitHub

History

executable file

330 lines (270 loc) · 11.4 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

#!/bin/env python3

# Generates a report on the amount of code sharing in this repo

# The purpose of this is

# a) To be able to understand the structure and dependencies

# b) To provide a metric that measures the amount of shared vs non-shared code

import datetime

from pathlib import Path

import json

import yaml

# To add more languages, add them to this list:

languages = ['cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ql', 'ruby', 'rust', 'swift']

repo_location = Path(__file__).parent.parent.parent

# Gets the total number of lines in a file

def linecount(file):

with open(file, 'r') as fp: return len(fp.readlines())

# Gets the language name from the path

def get_language(path):

return path.parts[len(repo_location.parts)]

# Is this path a CodeQL query file

def is_query(path):

return path.suffix == '.ql'

# Is this path a CodeQL library file

def is_library(path):

return path.suffix == '.qll'

# Is this path a relevant CodeQL file

def is_ql(path):

return is_query(path) or is_library(path)

# Is this file a CodeQL package file

def is_package(path):

return path.name == 'qlpack.yml'

# A CodeQL source file

class QlFile:

def __init__(self, path):

self.path = path

self.lines = linecount(path)

shared = False

def language(self):

return get_language(self.path)

def query(self):

return is_query(self.path)

def library(self):

return is_library(self.path)

# Returns if this qlfile is not shared, and is in a pack that is only in one language

def isOnlyInLanguage(self, language):

return not self.shared and (self.package is None or self.package.languages == {language}) and self.language() == language

# Represents a language folder

class Language:

def __init__(self, name):

self.name = name

self.packs = []

self.nonshared_files = 0

self.nonshared_lines = 0

self.imported_files = 0

self.imported_lines = 0

def addQlFile(self, qlfile):

if not qlfile.shared:

self.nonshared_files += 1

self.nonshared_lines += qlfile.lines

def addSharedAsset(self, package):

self.imported_files += package.files

self.imported_lines += package.lines

# A shared package or file

class SharedAsset:

def __init__(self, name):

self.name = name

# A file shared using identical-files.json

class IdenticalFileSet(SharedAsset):

def __init__(self, name, ql_files):

self.name = name

self.languages = set()

self.files = 0

self.lines = 0

for file in ql_files:

file.package = self

file.shared = True

self.files = 1

self.lines = file.lines

self.languages.add(file.language())

# Gets a pretty-printed markdown link

def link(self):

return self.name

# Represents all files shared in `identical-files.json`

# Reads the file and builds a list of assets

class IdenticalFiles:

def __init__(self, repo_location, ql_file_index):

identical_files = repo_location/'config'/'identical-files.json'

with open(identical_files, "r") as fp:

identical_files_json = json.load(fp)

# Create a list of assets

self.assets = []

for group in identical_files_json:

paths = []

for file in identical_files_json[group]:

path = repo_location / file

if is_ql(path):

ql_file_index[path].shared = True

paths.append(ql_file_index[path])

self.assets.append(IdenticalFileSet(group, paths))

# A package created from a `qlpack.yml`` file

class Package(SharedAsset):

def __init__(self, path, ql_file_index):

self.path = path

self.language = get_language(path)

self.lines = 0

self.files = 0

self.languages = set()

self.languages.add(self.language)

self.identical_files_dependencies = set()

with open(path, 'r') as fp:

y = yaml.safe_load(fp)

if 'name' in y:

self.name = y['name']

else:

self.name = path.parent.name

if 'dependencies' in y:

self.deps = y['dependencies']

if self.deps is None:

self.deps = {}

else:

self.deps = {}

# Mark all relevant files with their package

for file in ql_file_index:

if self.containsDirectory(file):

file = ql_file_index[file]

if not file.shared:

file.package = self

self.lines += file.lines

self.files += 1

else:

self.identical_files_dependencies.add(file.package)

self.url = "https://github.com/github/codeql/blob/main/" + str(path.relative_to(repo_location))

# Gets a pretty-printed markdown link

def link(self):

return '[' + self.name + '](' + self.url + ')'

def containsDirectory(self, dir):

return self.path.parent.parts == dir.parts[:len(self.path.parent.parts)]

# dir.startsWith(self.path.parent)

# Constructs a list of transitive depedencies of this package.

def calculateDependencies(self, packageNameMap):

self.transitive_dependencies = set(self.deps)

queue = list(self.deps)

while len(queue):

item = queue.pop()

for dep2 in packageNameMap[item].deps:

if dep2 not in self.transitive_dependencies:

self.transitive_dependencies.add(dep2)

queue.append(dep2)

# Calculate the amount of imported code

self.total_imported_files = 0

self.total_imported_lines = 0

self.all_dependencies = set(self.identical_files_dependencies)

for dep in self.transitive_dependencies:

self.all_dependencies.add(packageNameMap[dep])

for dep in self.all_dependencies:

self.total_imported_files += dep.files

self.total_imported_lines += dep.lines

dep.languages.add(self.language)

# Create a big index of all files and their line counts.

# Map from path to line count

ql_file_index = {}

package_files = []

# Queue of directories to read

directories_to_scan = [repo_location]

while len(directories_to_scan)!=0:

dir = directories_to_scan.pop()

for p in dir.iterdir():

if p.is_dir():

directories_to_scan.append(p)

elif is_ql(p):

ql_file_index[p] = QlFile(p)

elif is_package(p):

package_files.append(p)

# Create identical_files_json

identical_files = IdenticalFiles(repo_location, ql_file_index)

# Create packages

# Do this after identical_files so that we can figure out the package sizes

# Do this after getting the ql_file_index fully built

packages = []

for file in package_files:

packages.append(Package(file, ql_file_index))

# List all shared assets

shared_assets = packages + identical_files.assets

# Construct statistics for each language

language_info = {}

for l in languages:

language_info[l] = Language(l)

for qlfile in ql_file_index.values():

lang = qlfile.language()

if lang in language_info:

info = language_info[lang]

if qlfile.isOnlyInLanguage(lang):

info.addQlFile(qlfile)

# Determine all package dependencies

packageNameMap = {}

for package in packages:

packageNameMap[package.name] = package

for package in packages:

package.calculateDependencies(packageNameMap)

for asset in shared_assets:

if len(asset.languages)>1:

for lang in asset.languages:

if lang in language_info:

language_info[lang].addSharedAsset(asset)

# Functions to output the results

def list_assets(shared_assets, language_info):

print('| Asset | Files | Lines |', end='')

for lang in language_info:

print('', lang, '|', end='')

print()

print('| ----- | ----- | ----- |', end='')

for lang in language_info:

print(' ---- |', end='')

print()

for asset in shared_assets:

print('|', asset.link(), '|', asset.files ,'|', asset.lines, '|', end=' ')

for lang in language_info:

if lang in asset.languages:

print('yes |', end=' ')

else:

print(' |', end=' ');

print()

def list_package_dependencies(package):

print("Package", package.path, package.name, package.files, package.lines, package.total_imported_files, package.total_imported_lines)

for dep in package.all_dependencies:

print(" ", dep.name, dep.files, dep.lines)

def print_package_dependencies(packages):

print('| ------------ | ---------------- | ------------------------ | -------------- | ---------------------- | ------------- |')

for package in packages:

nlines = package.lines + package.total_imported_lines

shared_percentage = 100 * package.total_imported_lines / nlines if nlines>0 else 0

# ','.join([p.name for p in package.all_dependencies]),

"%.2f" % shared_percentage, '|')

print()

def print_language_dependencies(packages):

print_package_dependencies([p for p in packages if p.name.endswith('-all') and p.name.count('-')==1])

def list_shared_code_by_language(language_info):

# For each language directory, list the files that are (1) inside the directory and not shared,

# (2) packages from outside the directory, plus identical files

print('| -------- | ---------------- | ------------------------ | -------------- | ---------------------- | ------------- |')

for lang in language_info:

info = language_info[lang]

total = info.imported_lines + info.nonshared_lines

shared_percentage = 100 * info.imported_lines / total if total>0 else 0

print()

# Output reports

print('# Report on CodeQL code sharing\n')

print('Generated on', datetime.datetime.now())

print()

print('## Shared code by language\n')

list_shared_code_by_language(language_info)

print('''

* *Non-shared files*: The number of CodeQL files (`.ql`/`.qll`) that are only used within this language folder. Excludes `identical-files.json` that are shared between multiple languages.

* *Non-shared lines of code*: The number of lines of code in the non-shared files.

* *Imported files*: All CodeQL files (`.ql`/`.qll`) files that are transitively used in this language folder, either via packages or `identical-files.json`

* *Imported lines of code*: The number of lines of code in the imported files

* *Shared code %*: The proportion of imported lines / total lines (nonshared + imported).

## Shared packages use by language

A package is *used* if it is a direct or indirect dependency, or a file shared via `identical-files.json`.

''')

list_assets(shared_assets, language_info)

print('## Shared code by language pack\n')

print_language_dependencies(packages)

print('## Shared code by package\n')

print_package_dependencies(packages)

codeql/misc/scripts/shared-code-metrics.py at codeql-cli/v2.25.6 · github/codeql · GitHub

Uh oh!

Expand file tree

Breadcrumbs

shared-code-metrics.py

Latest commit

History

Breadcrumbs

shared-code-metrics.py

File metadata and controls