File size: 15,915 Bytes
8a62fa4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 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 | #!/usr/bin/env python3
"""Select DESIGN.md specifications and write three JSONL files to a new directory.
Requires Node.js and the external public @google/design.md 0.4.0 linter.
Original bytes must round-trip through UTF-8; raw files that cannot are counted
separately and omitted. No source files or existing output directories are changed.
"""
import argparse
import hashlib
import json
import os
import re
import subprocess
import sys
import tempfile
from pathlib import Path
from urllib.parse import unquote, urlsplit
FILE_FIELDS = ("sha256", "repo_id", "content", "path", "commit_sha", "source_url")
REPOSITORY_FIELDS = (
"repo_id", "full_name", "storage_full_name", "default_branch", "commit_sha",
"pinned_at", "metadata_fetched_at", "primary_language", "license_spdx_id",
"license_name", "stars", "created_at", "pushed_at", "languages", "description", "topics",
)
# One persistent Node process evaluates each distinct content. The public API's
# findings are serialized directly, preserving their order and optional fields.
NODE_LINTER = r"""
import fs from 'node:fs';
import path from 'node:path';
import { createHash } from 'node:crypto';
import { pathToFileURL } from 'node:url';
import { createInterface } from 'node:readline';
const digest = bytes => createHash('sha256').update(bytes).digest('hex');
const modulePath = fs.realpathSync(process.argv[1]);
const moduleHash = digest(fs.readFileSync(modulePath));
const metadata = {
module_path: modulePath, module_sha256: moduleHash,
official_package: '@google/design.md', official_package_version: '0.4.0',
public_api: '@google/design.md/linter:lint',
};
if (moduleHash === '6aaa4fd8bb979fa6d95d856ab72baf2d3643522e569f21eef9a9b91f5af37247') {
metadata.identity_check = 'historical_bundle_sha256';
metadata.source_commit = '6e5da5382f41edbba9d73b2c62f33f32e9971f15';
} else {
const packageRoot = path.resolve(path.dirname(modulePath), '../..');
const manifestPath = path.join(packageRoot, 'package.json');
const entrypoint = path.join(packageRoot, 'dist/linter/index.js');
const manifest = fs.existsSync(manifestPath)
? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : null;
if (manifest?.name !== '@google/design.md' || manifest.version !== '0.4.0' ||
!fs.existsSync(entrypoint) || modulePath !== fs.realpathSync(entrypoint)) {
throw new Error('Expected @google/design.md@0.4.0/dist/linter/index.js or the verified historical bundle.');
}
metadata.identity_check = 'npm_package_manifest_and_public_entrypoint';
metadata.package_manifest = manifestPath;
metadata.package_manifest_sha256 = digest(fs.readFileSync(manifestPath));
}
const { lint } = await import(pathToFileURL(modulePath).href);
if (typeof lint !== 'function') throw new Error('The official module must export public lint().');
console.log(JSON.stringify(metadata));
const groups = ['colors', 'typography', 'spacing', 'rounded', 'components'];
for await (const line of createInterface({ input: process.stdin, crlfDelay: Infinity })) {
const content = JSON.parse(line);
const lines = content.replace(/^\uFEFF/, '').split(/\r?\n/);
const header = lines[0] === '---' && lines.slice(1).includes('---');
try {
const report = lint(content);
if (!report || !Array.isArray(report.findings) || !report.summary ||
['errors', 'warnings', 'infos'].some(key =>
!Number.isSafeInteger(report.summary[key]) || report.summary[key] < 0)) {
throw new Error('Official lint() returned an invalid report.');
}
const design = report.designSystem ?? {};
const named = typeof design.name === 'string' && design.name.trim().length > 0;
const tokens = groups.some(group => design[group] instanceof Map && design[group].size > 0);
const accepted = header && named && tokens && report.summary.errors === 0;
console.log(JSON.stringify({ accepted, findings: accepted ? report.findings : [] }));
} catch (error) {
console.log(JSON.stringify({ accepted: false, findings: [], exception: String(error.message ?? error) }));
}
}
"""
def read_jsonl(path):
with path.open(encoding="utf-8") as stream:
for number, line in enumerate(stream, 1):
try:
row = json.loads(line)
if not isinstance(row, dict):
raise ValueError("Expected a JSON object")
except ValueError as error:
raise ValueError(f"{path}:{number}: {error}") from error
yield row
def read_json(path):
return json.loads(path.read_text(encoding="utf-8"))
def require(condition, message):
if not condition:
raise ValueError(message)
def safe_parts(value):
require(isinstance(value, str) and value and "\x00" not in value, "Invalid repository path")
parts = value.split("/")
require(all(part not in ("", ".", "..") for part in parts), "Unsafe repository path")
return parts
def raw_candidates(root):
"""Read verified downloads, including successful files from partial snapshots."""
require((root / "_metadata").is_dir(), "Raw collection has no _metadata directory")
for snapshot_path in sorted((root / "_metadata").glob("*/*/snapshot.json")):
snapshot = read_json(snapshot_path)
if (snapshot.get("status") == "excluded_fork" or snapshot.get("public") is not True
or snapshot.get("fork") is not False):
continue
storage = safe_parts(snapshot["storage_full_name"])
require(len(storage) == 2 and snapshot_path.parent == root / "_metadata" / Path(*storage),
"Snapshot storage name does not match its location")
metadata = read_json(snapshot_path.parent / "repository.json")
require(metadata["id"] == snapshot["repo_id"], "Repository metadata identity mismatch")
if metadata.get("private") is not False or metadata.get("fork") is not False:
continue
license_info = metadata.get("license") or {}
languages_path = snapshot_path.parent / "languages.json"
repository = {
"repo_id": snapshot["repo_id"], "full_name": snapshot["canonical_full_name"],
"storage_full_name": snapshot["storage_full_name"],
"default_branch": snapshot.get("default_branch"), "commit_sha": snapshot.get("commit_sha"),
"pinned_at": snapshot.get("pinned_at"),
"metadata_fetched_at": snapshot.get("repository_metadata_fetched_at"),
"primary_language": metadata.get("language"), "license_spdx_id": license_info.get("spdx_id"),
"license_name": license_info.get("name"), "stars": metadata.get("stargazers_count"),
"created_at": metadata.get("created_at"), "pushed_at": metadata.get("pushed_at"),
"languages": read_json(languages_path) if languages_path.exists() else {},
"description": metadata.get("description"), "topics": metadata.get("topics") or [],
}
records_path = snapshot_path.parent / "files.jsonl"
if not records_path.exists():
continue
for record in read_jsonl(records_path):
if record.get("status") != "downloaded":
continue
path = safe_parts(record["path"])
expected_path = "data/" + "/".join(storage + path)
require(record["data_path"] == expected_path, "Download path does not match its provenance")
target = root / expected_path
require(target.resolve().is_relative_to(root.resolve()), "Download resolves outside collection root")
data = target.read_bytes()
blob = hashlib.sha1(b"blob " + str(len(data)).encode("ascii") + b"\0" + data).hexdigest()
require(record["size"] == len(data) and record["blob_sha"] == blob,
f"Downloaded byte size or Git blob hash mismatch: {target}")
yield {"sha256": record["sha256"], "repo_id": record["repo_id"],
"path": record["path"], "commit_sha": record["commit_sha"],
"source_url": record.get("source_url")}, repository, data
def dataset_candidates(root):
"""Re-evaluate a materialized dataset while preserving its recorded metadata."""
repositories = {}
for record in read_jsonl(root / "repositories.jsonl"):
repository = {field: record[field] for field in REPOSITORY_FIELDS}
require(repository["repo_id"] not in repositories, "Duplicate repository ID")
repositories[repository["repo_id"]] = repository
contents = {}
for record in read_jsonl(root / "contents.jsonl"):
data = record["content"].encode("utf-8", errors="strict")
require(hashlib.sha256(data).hexdigest() == record["sha256"], "Content SHA-256 mismatch")
require(record["sha256"] not in contents, "Duplicate content SHA-256")
contents[record["sha256"]] = record["content"]
for record in read_jsonl(root / "files.jsonl"):
row = {field: record[field] for field in FILE_FIELDS}
require(row["repo_id"] in repositories, "File refers to an unknown repository")
require(row["sha256"] in contents and contents[row["sha256"]] == row["content"],
"File does not match its content record")
row["content"] = contents[row["sha256"]]
yield row, repositories[row["repo_id"]], row["content"].encode("utf-8", errors="strict")
def node_reply(process):
line = process.stdout.readline()
if not line:
raise RuntimeError("The official linter process stopped; see its error above")
return json.loads(line)
def filter_dataset(mode, source, output, module):
require(not output.exists(), f"Output already exists: {output}")
rows = raw_candidates(source) if mode == "raw" else dataset_candidates(source)
counts = {"input_files": 0, "selected_files": 0, "rejected_files": 0,
"invalid_utf8_files": 0, "linter_invocation_failures": 0}
decisions, contents, repositories, files, identities = {}, {}, {}, [], set()
with subprocess.Popen(["node", "--input-type=module", "-e", NODE_LINTER, str(module)],
stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True,
encoding="utf-8") as process:
linter = node_reply(process)
try:
for row, repository, data in rows:
counts["input_files"] += 1
if counts["input_files"] % 2000 == 0:
print(f"Checked {counts['input_files']} files", file=sys.stderr)
sha = row["sha256"]
require(hashlib.sha256(data).hexdigest() == sha, "File SHA-256 mismatch")
require(type(row["repo_id"]) is int and row["repo_id"] == repository["repo_id"],
"File repository identity mismatch")
require(row["commit_sha"] == repository["commit_sha"]
and re.fullmatch(r"[0-9a-f]{40}", row["commit_sha"]), "File commit mismatch")
require(safe_parts(row["path"])[-1].casefold() == "design.md", "Unexpected filename")
if row["source_url"] is not None:
url = urlsplit(row["source_url"])
names = {repository["full_name"], repository["storage_full_name"]}
expected = {f"/{name}/blob/{row['commit_sha']}/{row['path']}" for name in names}
require(url.scheme == "https" and url.netloc == "github.com"
and not url.query and not url.fragment and unquote(url.path) in expected,
"File source URL does not match its repository, commit and path")
identity = (row["repo_id"], row["commit_sha"], row["path"])
require(identity not in identities, f"Duplicate file identity: {identity}")
identities.add(identity)
try:
content = row.get("content")
if content is None:
content = data.decode("utf-8", errors="strict")
except UnicodeDecodeError:
if mode != "raw":
raise
counts["invalid_utf8_files"] += 1
continue
if sha not in decisions:
# An exact header is necessary. Skip unrelated Markdown
# before invoking the linter, without changing the rule.
start = content.removeprefix("\ufeff")
if not start.startswith(("---\n", "---\r\n")):
result = {"accepted": False, "findings": []}
else:
process.stdin.write(json.dumps(content, ensure_ascii=False) + "\n")
process.stdin.flush()
result = node_reply(process)
decisions[sha] = result
counts["linter_invocation_failures"] += "exception" in result
result = decisions[sha]
if not result["accepted"]:
counts["rejected_files"] += 1
continue
if sha in contents:
require(contents[sha] == content, "Different contents have the same SHA-256")
else:
contents[sha] = content
if row["repo_id"] in repositories:
require(repositories[row["repo_id"]] == repository, "Inconsistent repository metadata")
repositories[row["repo_id"]] = repository
row["content"] = contents[sha]
row["linter_diagnostics"] = result["findings"]
files.append(row)
counts["selected_files"] += 1
finally:
process.stdin.close()
require(process.wait() == 0, "The official linter process failed")
# Publish only after all input and linter checks finish. Reserve a new empty
# destination so even an output created during filtering is never replaced.
output.parent.mkdir(parents=True, exist_ok=True)
with tempfile.TemporaryDirectory(prefix=".designspecs-filter-", dir=output.parent) as temporary:
stage = Path(temporary)
tables = {
"contents": ({"sha256": sha, "content": contents[sha]} for sha in sorted(contents)),
"files": sorted(files, key=lambda row: (row["repo_id"], row["commit_sha"], row["path"])),
"repositories": (repositories[key] for key in sorted(repositories)),
}
for table, records in tables.items():
with (stage / f"{table}.jsonl").open("x", encoding="utf-8", newline="\n") as stream:
for record in records:
stream.write(json.dumps(record, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + "\n")
output.mkdir()
os.replace(stage, output)
return {**counts, "unique_contents": len(contents), "repositories": len(repositories),
"linter": linter, "output": str(output)}
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("mode", choices=("raw", "dataset"), help="Input is a raw collection or three JSONL files")
parser.add_argument("source", type=Path)
parser.add_argument("--output", type=Path, required=True, help="New directory for the three JSONL files")
parser.add_argument("--linter-module", type=Path, default=os.environ.get("DESIGNMD_LINTER_MODULE"),
help="Official 0.4.0 dist/linter/index.js or verified historical bundle; defaults to DESIGNMD_LINTER_MODULE")
args = parser.parse_args()
if args.linter_module is None:
parser.error("Set --linter-module or DESIGNMD_LINTER_MODULE")
result = filter_dataset(args.mode, args.source.resolve(), args.output.resolve(), args.linter_module)
print(json.dumps(result, ensure_ascii=False, indent=2))
if __name__ == "__main__":
main()
|