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()