mirror of
https://github.com/jparkerweb/plan2code.git
synced 2026-11-16 20:45:33 -08:00
582 lines
24 KiB
JavaScript
582 lines
24 KiB
JavaScript
#!/usr/bin/env node
|
|
// test-match.mjs: files to tests, in both directions.
|
|
//
|
|
// pr-prep asks which checks cover a branch's changed files; test asks which
|
|
// source files no test covers, and which existing tests to read for style.
|
|
// Both answers come from the same rules, in the same order: the project's
|
|
// test map first, then name, folder and import matching. Anything these rules
|
|
// cannot settle (a path alias, a bare package name) is left unmatched for the
|
|
// agent to judge, never guessed.
|
|
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
import { execFileSync } from "node:child_process";
|
|
import { fileURLToPath } from "node:url";
|
|
import { EXIT, HERE, fail, out, parseArgs, run, readText, isDir, now } from "./common.mjs";
|
|
import { toPosix, matchGlob } from "./glob.mjs";
|
|
import { readTestMap } from "./test-map.mjs";
|
|
|
|
const USAGE = `
|
|
test-match.mjs: match files to tests, both ways. JSON on stdout.
|
|
|
|
node test-match.mjs covers (--files <a,b,...> | --stdin) [--root <dir>]
|
|
Changed files to the checks that cover them. --stdin takes
|
|
review-scope.mjs JSON (files[].path). matched: test map rows that cover
|
|
at least one file, in table order. unmatched: { file, tests, method }
|
|
for every file no row covers; tests and method come from the name,
|
|
folder and import rules (method null when nothing was found).
|
|
sharedHits: { file, why }: why is "row" (a Shared: yes row) or a hint
|
|
for the agent to judge ("config", "test-helper", "fixture").
|
|
|
|
node test-match.mjs gaps --scope branch|all|path [--path <p>] [--base <b>] [--root <dir>]
|
|
Source files no test covers: { file, area, runner, commits90d,
|
|
lastTouched }, newest first, then by commits in the last 90 days.
|
|
branch: the files review-scope.mjs reports; all: every tracked file;
|
|
path: every file under --path. Capped at 2,000 source files (capped).
|
|
|
|
node test-match.mjs nearest --file <f> [--root <dir>]
|
|
Up to 3 existing test files to read for the project's test style.
|
|
|
|
Exit: 0 ok · 2 bad arguments · 3 not a git repository, or review-scope.mjs
|
|
not beside this script (gaps --scope branch).
|
|
`;
|
|
|
|
/* ------------------------------------------------------------- files */
|
|
|
|
const SKIP_DIRS = new Set(["node_modules", ".git", "dist", "build", "vendor", "target", ".venv"]);
|
|
const TEST_DIRS = new Set(["test", "tests", "__tests__", "spec"]);
|
|
const CODE_EXT = new Set(["js", "mjs", "cjs", "ts", "tsx", "jsx", "py", "go", "rs", "java", "kt", "cs", "rb", "php", "swift"]);
|
|
const SOURCE_SKIP = new Set(["node_modules", "vendor", "dist", "build", "target", ".venv", "specs", "specs--completed"]);
|
|
const CAP = 2000;
|
|
|
|
const fold = (s) => (process.platform === "win32" ? s.toLowerCase() : s);
|
|
const extOf = (p) => (path.posix.extname(p).slice(1) || "").toLowerCase();
|
|
const baseOf = (p) => path.posix.basename(p);
|
|
const dirOf = (p) => {
|
|
const d = path.posix.dirname(p);
|
|
return d === "." ? "" : d;
|
|
};
|
|
const segs = (d) => (d ? d.split("/") : []);
|
|
|
|
function git(root, args) {
|
|
try {
|
|
return execFileSync("git", ["-c", "core.quotePath=false", ...args], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 256 * 1024 * 1024 });
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
const inGit = (root) => git(root, ["rev-parse", "--show-toplevel"]) !== null;
|
|
|
|
function walk(root) {
|
|
const found = [];
|
|
const visit = (dir, relDir) => {
|
|
let entries;
|
|
try {
|
|
entries = fs.readdirSync(dir, { withFileTypes: true });
|
|
} catch {
|
|
return;
|
|
}
|
|
for (const e of entries) {
|
|
const r = relDir ? `${relDir}/${e.name}` : e.name;
|
|
if (e.isDirectory()) {
|
|
if (!SKIP_DIRS.has(e.name)) visit(path.join(dir, e.name), r);
|
|
} else if (e.isFile()) found.push(r);
|
|
}
|
|
};
|
|
visit(root, "");
|
|
return found;
|
|
}
|
|
|
|
// Every file in the project, once per run: tracked plus untracked files git
|
|
// does not ignore, or a walk outside git. Paths relative to root.
|
|
const fileLists = new Map();
|
|
function allFiles(root) {
|
|
if (!fileLists.has(root)) {
|
|
let list;
|
|
if (inGit(root)) {
|
|
const tracked = (git(root, ["ls-files"]) || "").split("\n");
|
|
const untracked = (git(root, ["ls-files", "--others", "--exclude-standard"]) || "").split("\n");
|
|
list = [...new Set([...tracked, ...untracked].filter(Boolean))].filter((f) => fs.existsSync(path.join(root, f)));
|
|
} else list = walk(root);
|
|
fileLists.set(root, list.map(toPosix).sort());
|
|
}
|
|
return fileLists.get(root);
|
|
}
|
|
|
|
/** Is this path a test file by name or by folder? */
|
|
export function isTestFile(p) {
|
|
const file = toPosix(p);
|
|
const base = baseOf(file);
|
|
if (/\.(test|spec)\.[^./]+$/i.test(base)) return true;
|
|
if (/^test_.+\.py$/i.test(base) || /_test\.py$/i.test(base) || /_test\.go$/i.test(base)) return true;
|
|
if (/Tests?\.(java|kt|cs)$/.test(base)) return true;
|
|
return segs(dirOf(file)).some((s) => TEST_DIRS.has(s));
|
|
}
|
|
|
|
/** The project's test files with a code extension. */
|
|
export function listTestFiles(root) {
|
|
return allFiles(root).filter((f) => isTestFile(f) && (CODE_EXT.has(extOf(f)) || JS_EXT.has(extOf(f))));
|
|
}
|
|
|
|
/* ------------------------------------------------------- name and folder */
|
|
|
|
// A file's name without its extension and without test markers:
|
|
// foo.test.js, test_foo.py, foo_test.go and FooTests.cs all give "foo"/"Foo".
|
|
function stemOf(p) {
|
|
const base = baseOf(p);
|
|
const dot = base.lastIndexOf(".");
|
|
let stem = dot > 0 ? base.slice(0, dot) : base;
|
|
stem = stem.replace(/\.(test|spec)$/i, "");
|
|
if (/^test_/i.test(stem) && extOf(p) === "py") stem = stem.slice(5);
|
|
stem = stem.replace(/_test$/i, "");
|
|
if (/^(java|kt|cs)$/.test(extOf(p))) stem = stem.replace(/Tests?$/, "");
|
|
return stem;
|
|
}
|
|
|
|
function nameMatch(source, test) {
|
|
const ext = extOf(source);
|
|
const stem = stemOf(source);
|
|
const base = baseOf(test);
|
|
const tdot = base.lastIndexOf(".");
|
|
const tname = tdot > 0 ? base.slice(0, tdot) : base;
|
|
const same = (a, b) => fold(a) === fold(b);
|
|
if (ext === "py") return extOf(test) === "py" && (same(tname, `test_${stem}`) || same(tname, `${stem}_test`));
|
|
if (ext === "go") return same(test, `${dirOf(source) ? `${dirOf(source)}/` : ""}${stem}_test.go`);
|
|
if (ext === "cs" || ext === "java" || ext === "kt") return extOf(test) === ext && (same(tname, `${stem}Tests`) || same(tname, `${stem}Test`));
|
|
const text = extOf(test);
|
|
if (JS_EXT.has(ext) ? !JS_EXT.has(text) : text !== ext) return false;
|
|
return same(tname, `${stem}.test`) || same(tname, `${stem}.spec`);
|
|
}
|
|
|
|
// Does the test file sit in a test folder that mirrors the source file's
|
|
// folder? src/a/b.js mirrors to src/a/__tests__/, tests/a/, test/src/a/ and
|
|
// the like: the part of the path before the test folder must be an ancestor of
|
|
// the source, and the part after it the rest of the source's folder (with a
|
|
// leading src/ or lib/ optional).
|
|
function mirrors(source, test) {
|
|
const sd = segs(dirOf(source)).map(fold);
|
|
const td = segs(dirOf(test)).map(fold);
|
|
const k = td.findIndex((s) => TEST_DIRS.has(s));
|
|
if (k === -1) return false;
|
|
const prefix = td.slice(0, k);
|
|
const rest = td.slice(k + 1);
|
|
if (prefix.some((s, i) => sd[i] !== s)) return false;
|
|
const remaining = sd.slice(prefix.length);
|
|
const eq = (a, b) => a.length === b.length && a.every((s, i) => s === b[i]);
|
|
if (eq(remaining, rest)) return true;
|
|
return (remaining[0] === "src" || remaining[0] === "lib") && eq(remaining.slice(1), rest);
|
|
}
|
|
|
|
const folderMatch = (source, test) => mirrors(source, test) && fold(stemOf(source)) === fold(stemOf(test));
|
|
|
|
/* --------------------------------------------------------------- imports */
|
|
|
|
const JS_EXT = new Set(["js", "mjs", "cjs", "ts", "tsx", "jsx", "mts", "cts"]);
|
|
const JS_TRY = ["", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx"];
|
|
const JS_PATTERNS = [
|
|
/\bimport\s+(?:[\w*{}\s,$]+?\s+from\s+)?["']([^"'\n]+)["']/g,
|
|
/\bexport\s+[\w*{}\s,$]+?\s+from\s+["']([^"'\n]+)["']/g,
|
|
/\brequire\s*\(\s*["']([^"'\n]+)["']\s*\)/g,
|
|
/\bimport\s*\(\s*["']([^"'\n]+)["']\s*\)/g,
|
|
];
|
|
|
|
const isFile = (p) => {
|
|
try {
|
|
return fs.statSync(p).isFile();
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
|
|
// Repo-relative path for `p` (already posix, relative to root), or null when
|
|
// it climbs out of the project.
|
|
const inside = (p) => {
|
|
const n = path.posix.normalize(p);
|
|
return n === ".." || n.startsWith("../") || path.posix.isAbsolute(n) ? null : n;
|
|
};
|
|
|
|
function resolveJs(root, test, spec) {
|
|
if (!spec.startsWith("./") && !spec.startsWith("../")) return [];
|
|
const target = inside(path.posix.join(dirOf(test) || ".", spec));
|
|
if (!target) return [];
|
|
for (const ext of JS_TRY) if (isFile(path.join(root, target + ext))) return [target + ext];
|
|
for (const ext of JS_TRY.slice(1)) if (isFile(path.join(root, `${target}/index${ext}`))) return [`${target}/index${ext}`];
|
|
return [];
|
|
}
|
|
|
|
function resolvePyModule(root, bases, dotted) {
|
|
const rel = dotted.split(".").filter(Boolean).join("/");
|
|
if (!rel) return [];
|
|
for (const base of bases) {
|
|
const p = inside(base ? `${base}/${rel}` : rel);
|
|
if (!p) continue;
|
|
if (isFile(path.join(root, `${p}.py`))) return [`${p}.py`];
|
|
if (isFile(path.join(root, `${p}/__init__.py`))) return [`${p}/__init__.py`];
|
|
}
|
|
return [];
|
|
}
|
|
|
|
function pythonImports(root, test, text) {
|
|
const found = [];
|
|
const own = dirOf(test);
|
|
for (const m of text.matchAll(/^[ \t]*import[ \t]+([\w.]+(?:[ \t]*,[ \t]*[\w.]+)*)/gm)) {
|
|
for (const name of m[1].split(",")) found.push(...resolvePyModule(root, ["", own], name.trim()));
|
|
}
|
|
for (const m of text.matchAll(/^[ \t]*from[ \t]+(\.*)([\w.]*)[ \t]+import[ \t]+\(?([\w\s,]+)/gm)) {
|
|
const dots = m[1].length;
|
|
const mod = m[2];
|
|
const names = m[3].split(",").map((s) => s.trim().split(/\s+/)[0]).filter(Boolean);
|
|
let bases;
|
|
if (dots) {
|
|
let base = own;
|
|
for (let i = 1; i < dots; i++) base = dirOf(base);
|
|
bases = [base];
|
|
} else bases = ["", own];
|
|
if (mod) found.push(...resolvePyModule(root, bases, mod));
|
|
for (const n of names) found.push(...resolvePyModule(root, bases, mod ? `${mod}.${n}` : n));
|
|
}
|
|
return found;
|
|
}
|
|
|
|
// The module path and folder of the go.mod nearest to `file`, walking up.
|
|
const goMods = new Map();
|
|
function goModFor(root, file) {
|
|
let dir = dirOf(file);
|
|
for (;;) {
|
|
const key = `${root}\0${dir}`;
|
|
if (!goMods.has(key)) {
|
|
const text = readText(path.join(root, dir, "go.mod"));
|
|
const m = text && text.match(/^module\s+(\S+)/m);
|
|
goMods.set(key, m ? { module: m[1], dir } : null);
|
|
}
|
|
if (goMods.get(key)) return goMods.get(key);
|
|
if (!dir) return null;
|
|
dir = dirOf(dir);
|
|
}
|
|
}
|
|
|
|
// Go imports name packages: the result is folders, prefixed "dir:".
|
|
function goImports(root, test, text) {
|
|
const mod = goModFor(root, test);
|
|
if (!mod) return [];
|
|
const specs = [];
|
|
for (const m of text.matchAll(/^\s*import\s+(?:[\w.]+\s+)?"([^"]+)"/gm)) specs.push(m[1]);
|
|
for (const m of text.matchAll(/^\s*import\s*\(([\s\S]*?)\)/gm)) {
|
|
for (const l of m[1].matchAll(/(?:^|\n)\s*(?:[\w.]+\s+)?"([^"]+)"/g)) specs.push(l[1]);
|
|
}
|
|
const found = [];
|
|
for (const s of specs) {
|
|
if (s !== mod.module && !s.startsWith(`${mod.module}/`)) continue;
|
|
const sub = s.slice(mod.module.length).replace(/^\//, "");
|
|
const dir = inside([mod.dir, sub].filter(Boolean).join("/") || ".");
|
|
if (dir) found.push(`dir:${dir === "." ? "" : dir}`);
|
|
}
|
|
return found;
|
|
}
|
|
|
|
// Source path (or "dir:<folder>" for Go) to the test files that import it,
|
|
// built once per root from every test file.
|
|
const importIndexes = new Map();
|
|
function importIndex(root, testFiles) {
|
|
if (importIndexes.has(root)) return importIndexes.get(root);
|
|
const index = new Map();
|
|
const add = (target, test) => {
|
|
const k = fold(target);
|
|
if (!index.has(k)) index.set(k, new Set());
|
|
index.get(k).add(test);
|
|
};
|
|
for (const test of testFiles) {
|
|
const ext = extOf(test);
|
|
if (!JS_EXT.has(ext) && ext !== "py" && ext !== "go") continue;
|
|
const text = readText(path.join(root, test));
|
|
if (text === null || text.length > 2 * 1024 * 1024) continue;
|
|
if (JS_EXT.has(ext)) {
|
|
for (const re of JS_PATTERNS) for (const m of text.matchAll(re)) for (const t of resolveJs(root, test, m[1])) add(t, test);
|
|
} else if (ext === "py") for (const t of pythonImports(root, test, text)) add(t, test);
|
|
else for (const t of goImports(root, test, text)) add(t, test);
|
|
}
|
|
importIndexes.set(root, index);
|
|
return index;
|
|
}
|
|
|
|
/**
|
|
* The tests that cover `file` after the test map: by name, then by mirrored
|
|
* folder, then by imports. `{ tests, method }`, method null when none did.
|
|
*/
|
|
export function findTests(root, file, testFiles = listTestFiles(root)) {
|
|
const f = toPosix(file);
|
|
const others = testFiles.filter((t) => fold(t) !== fold(f));
|
|
const byName = others.filter((t) => nameMatch(f, t));
|
|
if (byName.length) return { tests: byName, method: "name" };
|
|
const byFolder = others.filter((t) => folderMatch(f, t));
|
|
if (byFolder.length) return { tests: byFolder, method: "folder" };
|
|
const index = importIndex(root, testFiles);
|
|
const hits = new Set([...(index.get(fold(f)) || [])]);
|
|
if (extOf(f) === "go" && !isTestFile(f)) for (const t of index.get(fold(`dir:${dirOf(f)}`)) || []) hits.add(t);
|
|
hits.delete(f);
|
|
if (hits.size) return { tests: [...hits].sort(), method: "imports" };
|
|
return { tests: [], method: null };
|
|
}
|
|
|
|
/* ---------------------------------------------------------------- covers */
|
|
|
|
const CONFIG_NAMES = new Set(["package.json", "package-lock.json", "pnpm-lock.yaml", "yarn.lock", "jsconfig.json", "pytest.ini", "pyproject.toml", "setup.cfg", "tox.ini", "go.mod", "go.sum", "cargo.toml", "makefile", "directory.build.props"]);
|
|
|
|
/** A shared-ground hint for a file the agent should judge, or null. */
|
|
export function hintFor(file) {
|
|
const f = toPosix(file);
|
|
const base = baseOf(f);
|
|
const lower = base.toLowerCase();
|
|
const dirs = segs(dirOf(f));
|
|
if (CONFIG_NAMES.has(lower) || /^tsconfig.*\.json$/i.test(base) || /\.config\.(js|cjs|mjs|ts)$/i.test(base) || /^\.babelrc/i.test(base) || /\.csproj$/i.test(base)) return "config";
|
|
if (dirs.some((d) => ["fixtures", "__fixtures__", "testdata"].includes(d))) return "fixture";
|
|
if (dirs.some((d) => ["helpers", "test-utils", "testutils", "support"].includes(d))) return "test-helper";
|
|
if (/helpers/i.test(base) && /\.(js|mjs|ts|py|go)$/i.test(base) && dirs.some((d) => TEST_DIRS.has(d))) return "test-helper";
|
|
return null;
|
|
}
|
|
|
|
const rowMatches = (row, file) => row.paths.some((g) => matchGlob(g, file));
|
|
|
|
function covers(root, files) {
|
|
const map = readTestMap(root);
|
|
const rows = map.found ? map.rows : [];
|
|
const matched = rows.map((r) => ({ area: r.area, run: r.run, shared: r.shared, files: [] }));
|
|
const unmatched = [];
|
|
const sharedHits = [];
|
|
let testFiles;
|
|
for (const file of files) {
|
|
let hit = false;
|
|
let sharedRow = false;
|
|
rows.forEach((r, i) => {
|
|
if (!rowMatches(r, file)) return;
|
|
hit = true;
|
|
matched[i].files.push(file);
|
|
if (r.shared) sharedRow = true;
|
|
});
|
|
if (!hit) {
|
|
testFiles ||= listTestFiles(root);
|
|
const { tests, method } = findTests(root, file, testFiles);
|
|
unmatched.push({ file, tests, method });
|
|
}
|
|
const why = sharedRow ? "row" : hintFor(file);
|
|
if (why) sharedHits.push({ file, why });
|
|
}
|
|
return { ok: true, mapFound: map.found, matched: matched.filter((m) => m.files.length), unmatched, sharedHits };
|
|
}
|
|
|
|
function readStdin() {
|
|
try {
|
|
return fs.readFileSync(0, "utf8");
|
|
} catch {
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ gaps */
|
|
|
|
/**
|
|
* The branch's changed files, relative to root, from review-scope.mjs, which
|
|
* every skill that ships this script ships beside it. One list, never a copy
|
|
* of its git commands that could drift from it.
|
|
*/
|
|
export function branchFiles(root, base) {
|
|
const top = git(root, ["rev-parse", "--show-toplevel"]);
|
|
if (top === null) fail(EXIT.NOT_FOUND, "not-a-repo", `${root} is not inside a git repository.`, "Use --scope all or --scope path, or ask which files to look at.");
|
|
const prefix = (git(root, ["rev-parse", "--show-prefix"]) || "").trim();
|
|
const scope = path.join(HERE, "review-scope.mjs");
|
|
if (!fs.existsSync(scope)) fail(EXIT.NOT_FOUND, "review-scope-missing", "review-scope.mjs is not beside test-match.mjs.", "Reinstall the skill, or use --scope all or --scope path.");
|
|
let stdout;
|
|
try {
|
|
stdout = execFileSync(process.execPath, [scope, "--root", root, ...(base ? ["--base", base] : [])], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], maxBuffer: 64 * 1024 * 1024 });
|
|
} catch (err) {
|
|
stdout = err.stdout;
|
|
}
|
|
let json;
|
|
try {
|
|
json = JSON.parse(stdout);
|
|
} catch {
|
|
fail(EXIT.CRASH, "review-scope-failed", "review-scope.mjs printed no JSON.", "Run review-scope.mjs on its own to see why.");
|
|
}
|
|
if (!json.ok) fail(EXIT.NOT_FOUND, json.error, json.message, json.next);
|
|
const list = json.files.map((f) => f.path);
|
|
return [...new Set(list.map(toPosix))]
|
|
.filter((f) => f.startsWith(prefix))
|
|
.map((f) => f.slice(prefix.length))
|
|
.filter((f) => fs.existsSync(path.join(root, f)));
|
|
}
|
|
|
|
function isSource(file) {
|
|
const f = toPosix(file);
|
|
if (!CODE_EXT.has(extOf(f)) || /\.d\.ts$/i.test(f) || isTestFile(f)) return false;
|
|
return !segs(dirOf(f)).some((s) => SOURCE_SKIP.has(s));
|
|
}
|
|
|
|
// Commits in the last 90 days per file, and the newest commit time, from one
|
|
// git log read. Paths relative to root.
|
|
function churn(root) {
|
|
const prefix = (git(root, ["rev-parse", "--show-prefix"]) || "").trim();
|
|
const since = new Date(now().getTime() - 90 * 24 * 3600 * 1000).toISOString();
|
|
const text = git(root, ["log", `--since=${since}`, "--name-only", "--format=%x00%ct"]) || "";
|
|
const stats = new Map();
|
|
for (const chunk of text.split("\0")) {
|
|
const lines = chunk.split("\n");
|
|
const ts = Number(lines[0]);
|
|
if (!ts) continue;
|
|
for (const raw of new Set(lines.slice(1).filter(Boolean))) {
|
|
if (!raw.startsWith(prefix)) continue;
|
|
const f = raw.slice(prefix.length);
|
|
const s = stats.get(f) || { commits: 0, newest: 0 };
|
|
s.commits++;
|
|
s.newest = Math.max(s.newest, ts);
|
|
stats.set(f, s);
|
|
}
|
|
}
|
|
return stats;
|
|
}
|
|
|
|
function gaps(root, { scope, sub, base }) {
|
|
const repo = inGit(root);
|
|
let files;
|
|
if (scope === "branch") files = branchFiles(root, base);
|
|
else {
|
|
files = allFiles(root);
|
|
if (scope === "path") {
|
|
const p = path.posix.normalize(toPosix(sub)).replace(/\/+$/, "");
|
|
// The project root (".") is every file.
|
|
if (p !== "." && p !== "") files = files.filter((f) => fold(f) === fold(p) || fold(f).startsWith(`${fold(p)}/`));
|
|
}
|
|
}
|
|
let sources = [...new Set(files)].filter(isSource).sort();
|
|
const capped = sources.length > CAP;
|
|
if (capped) sources = sources.slice(0, CAP);
|
|
const map = readTestMap(root);
|
|
const rows = map.found ? map.rows : [];
|
|
const testFiles = listTestFiles(root);
|
|
const stats = repo ? churn(root) : null;
|
|
const list = [];
|
|
let covered = 0;
|
|
for (const file of sources) {
|
|
// Any matching row with a run command covers the file, as in covers, so
|
|
// a gap's area is set only by a row that names it without one.
|
|
const row = rows.find((r) => rowMatches(r, file));
|
|
if (rows.some((r) => r.run && rowMatches(r, file)) || findTests(root, file, testFiles).tests.length) {
|
|
covered++;
|
|
continue;
|
|
}
|
|
const s = stats && stats.get(file);
|
|
list.push({
|
|
file,
|
|
area: row ? row.area : null,
|
|
runner: row && row.run ? row.run : null,
|
|
commits90d: stats ? (s ? s.commits : 0) : null,
|
|
lastTouched: s ? new Date(s.newest * 1000).toISOString().slice(0, 10) : null,
|
|
});
|
|
}
|
|
list.sort((a, b) => {
|
|
if (a.lastTouched !== b.lastTouched) {
|
|
if (a.lastTouched === null) return 1;
|
|
if (b.lastTouched === null) return -1;
|
|
return a.lastTouched < b.lastTouched ? 1 : -1;
|
|
}
|
|
if ((b.commits90d || 0) !== (a.commits90d || 0)) return (b.commits90d || 0) - (a.commits90d || 0);
|
|
return a.file < b.file ? -1 : a.file > b.file ? 1 : 0;
|
|
});
|
|
return { ok: true, scope, gaps: list, scanned: sources.length, covered, capped };
|
|
}
|
|
|
|
/* --------------------------------------------------------------- nearest */
|
|
|
|
// Path tokens in a Run command that name a file or folder in the project.
|
|
function runPaths(root, cmd) {
|
|
return (cmd || "")
|
|
.split(/\s+/)
|
|
.map((t) => toPosix(t.replace(/^["']|["']$/g, "")).replace(/\/+$/, ""))
|
|
.filter((t) => t && !t.startsWith("-") && inside(t) && fs.existsSync(path.join(root, t)));
|
|
}
|
|
|
|
function nearest(root, file) {
|
|
const f = toPosix(file);
|
|
const testFiles = listTestFiles(root).filter((t) => fold(t) !== fold(f));
|
|
const picked = [];
|
|
const take = (list) => {
|
|
for (const t of list) {
|
|
if (picked.length >= 3) return;
|
|
if (!picked.includes(t)) picked.push(t);
|
|
}
|
|
};
|
|
take(findTests(root, f, testFiles).tests);
|
|
take(testFiles.filter((t) => fold(dirOf(t)) === fold(dirOf(f))));
|
|
take(testFiles.filter((t) => mirrors(f, t)));
|
|
if (picked.length < 3) {
|
|
const map = readTestMap(root);
|
|
const row = map.found ? map.rows.find((r) => rowMatches(r, f)) : null;
|
|
if (row) {
|
|
for (const p of runPaths(root, row.run)) {
|
|
take(isDir(path.join(root, p)) ? testFiles.filter((t) => t.startsWith(`${p}/`)) : testFiles.filter((t) => t === p));
|
|
}
|
|
}
|
|
}
|
|
if (picked.length < 3) {
|
|
const mine = segs(dirOf(f));
|
|
const shared = (t) => {
|
|
const ts = segs(dirOf(t));
|
|
let n = 0;
|
|
while (n < mine.length && n < ts.length && fold(mine[n]) === fold(ts[n])) n++;
|
|
return n;
|
|
};
|
|
// Same language first: a Python test teaches nothing about a JS file's style.
|
|
const lang = (p) => (JS_EXT.has(extOf(p)) ? "js" : extOf(p));
|
|
const other = (t) => (lang(t) === lang(f) ? 0 : 1);
|
|
take([...testFiles].sort((a, b) => other(a) - other(b) || shared(b) - shared(a) || (a < b ? -1 : a > b ? 1 : 0)));
|
|
}
|
|
return { ok: true, file: f, tests: picked };
|
|
}
|
|
|
|
/* ------------------------------------------------------------------ main */
|
|
|
|
const listArg = (s) => String(s).split(",").map((x) => toPosix(x.trim())).filter(Boolean);
|
|
|
|
async function main(argv) {
|
|
const args = parseArgs(argv, { values: ["root", "files", "scope", "path", "base", "file"], booleans: ["stdin"] });
|
|
const root = path.resolve(args.root || ".");
|
|
const cmd = args._[0];
|
|
if (cmd === "covers") {
|
|
let files;
|
|
if (args.files) files = listArg(args.files);
|
|
else if (args.stdin) {
|
|
let json;
|
|
try {
|
|
json = JSON.parse(readStdin());
|
|
} catch {
|
|
fail(EXIT.USAGE, "bad-stdin", "--stdin needs review-scope.mjs JSON.", "Pipe review-scope.mjs output in, or pass --files.");
|
|
}
|
|
if (!json || !Array.isArray(json.files)) fail(EXIT.USAGE, "bad-stdin", "The JSON on stdin has no files list.", "Pipe review-scope.mjs output in, or pass --files.");
|
|
files = json.files.filter((f) => f && typeof f.path === "string" && f.path).map((f) => toPosix(f.path)).filter(Boolean);
|
|
} else fail(EXIT.USAGE, "missing-files", "covers needs --files <a,b,...> or --stdin.", "Run with --help for usage.");
|
|
out(covers(root, [...new Set(files)]));
|
|
return;
|
|
}
|
|
if (cmd === "gaps") {
|
|
if (!["branch", "all", "path"].includes(args.scope)) fail(EXIT.USAGE, "bad-scope", "gaps needs --scope branch, all or path.", "Run with --help for usage.");
|
|
if (args.scope === "path" && !args.path) fail(EXIT.USAGE, "missing-path", "--scope path needs --path <p>.", "Run with --help for usage.");
|
|
out(gaps(root, { scope: args.scope, sub: args.path, base: args.base }));
|
|
return;
|
|
}
|
|
if (cmd === "nearest") {
|
|
if (!args.file) fail(EXIT.USAGE, "missing-file", "nearest needs --file <f>.", "Run with --help for usage.");
|
|
out(nearest(root, args.file));
|
|
return;
|
|
}
|
|
fail(EXIT.USAGE, "unknown-command", cmd ? `Unknown command "${cmd}".` : "No command given.", "Commands: covers, gaps, nearest. Run with --help.");
|
|
}
|
|
|
|
const isMain = (() => {
|
|
try {
|
|
return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
|
|
} catch {
|
|
return false;
|
|
}
|
|
})();
|
|
if (isMain) run(USAGE, main);
|