flagrm 0.2.1 → 0.4.0

package/dist/core/verify/coverage.js

@@ -0,0 +1,92 @@
+/**
+ * The `coverage` check: a file the removal changed that no build, test or
+ * lint command checks is a warning. A project covers a file inside its path
+ * when it ran a command in this verify (or has one `--skip` left out) and one
+ * of its `covers` globs (relative to its path; default: everything) matches
+ * the file. A file that was already dirty at the baseline and hasn't changed
+ * since is no edit of the removal. Outside every project, deleted files and
+ * documentation have nothing for a command to check.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { excludeMatcher } from "../change-filter.js";
+import { projectCommands } from "../config-snapshot.js";
+import { blobIds } from "../git.js";
+import { RUN_CHECK_ID } from "../types.js";
+import { relativePath } from "../util.js";
+import { checkResult, plural, skippedResult } from "./context.js";
+/** More uncovered files than this are counted per top-level directory instead. */
+const MAX_FILES = 20;
+const UNCHECKED = "no build, test or lint command checks";
+const DOCS = /\.(?:md|mdx|markdown|txt|rst|adoc)$/i;
+export function coverageCheck(v) {
+    if (!v.changedFiles)
+        return skippedResult("coverage", "no baseline commit to diff against");
+    const skipped = Object.keys(RUN_CHECK_ID).filter((kind) => v.skip?.has(RUN_CHECK_ID[kind]));
+    if (skipped.length === 3)
+        return skippedResult("coverage", "build, tests and lint skipped (--skip), so no command ran");
+    const ran = new Set(v.runs.map((r) => r.project));
+    const projects = v.projects.map(({ adapter, ctx }) => {
+        const covers = ctx.project.covers;
+        const commands = projectCommands(adapter, ctx);
+        return {
+            name: ctx.name,
+            root: ctx.root,
+            // A command --skip left out would have checked the file: no reason to warn about the config.
+            ran: ran.has(ctx.name) || skipped.some((kind) => commands[kind]),
+            covers: covers ? excludeMatcher(covers.map(coversGlob)) : () => true,
+        };
+    });
+    const uncovered = [];
+    for (const file of removalFiles(v, v.changedFiles)) {
+        const containing = projects
+            .map((p) => ({ ...p, rel: relativePath(p.root, path.join(v.root, file)) }))
+            .filter((p) => p.rel !== ".." && !p.rel.startsWith("../") && !path.isAbsolute(p.rel));
+        if (containing.some((p) => p.ran && p.covers(p.rel)))
+            continue;
+        // Outside every project, documentation and deleted files have nothing for a command to check.
+        if (containing.length === 0 && (DOCS.test(file) || !fs.existsSync(path.join(v.root, file))))
+            continue;
+        const innermost = containing.sort((a, b) => b.root.length - a.root.length)[0];
+        uncovered.push({ file, project: innermost?.name });
+    }
+    if (uncovered.length === 0)
+        return checkResult("coverage", "every changed file is built, tested or linted", []);
+    const findings = uncovered.length > MAX_FILES
+        ? byDirectory(uncovered)
+        : uncovered.map(({ file, project }) => ({
+            severity: "warn",
+            message: `${file}: ${UNCHECKED} it`,
+            ...(project ? { project } : {}),
+        }));
+    return checkResult("coverage", `${plural(uncovered.length, "changed file")} no command checks`, findings);
+}
+/** The changed files without the ones dirty at the baseline and unchanged since (all of them, for a baseline without their hashes). */
+function removalFiles(v, changed) {
+    const { dirtyFiles = [], dirtyHashes } = v.baseline.git ?? {};
+    const dirty = new Set(dirtyFiles);
+    const candidates = changed.filter((rel) => dirty.has(rel));
+    if (candidates.length === 0)
+        return changed;
+    if (!dirtyHashes)
+        return changed.filter((rel) => !dirty.has(rel));
+    const now = blobIds(v.root, candidates);
+    return changed.filter((rel) => !dirty.has(rel) || !(rel in dirtyHashes) || now[rel] !== dirtyHashes[rel]);
+}
+/** A `covers` entry as a glob: `./src/**` is how the rest of the config writes paths, and `./` or `.` is everything. */
+function coversGlob(glob) {
+    const rel = glob.replace(/^\.\//, "").replace(/\/+$/, "");
+    return rel === "" || rel === "." ? "**" : rel;
+}
+/** One warning per top-level directory (`.` for files in the root) with its count. */
+function byDirectory(uncovered) {
+    const counts = new Map();
+    for (const { file } of uncovered) {
+        const slash = file.indexOf("/");
+        const dir = slash === -1 ? "." : `${file.slice(0, slash)}/`;
+        counts.set(dir, (counts.get(dir) ?? 0) + 1);
+    }
+    return [...counts]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([dir, n]) => ({ severity: "warn", message: `${dir}: ${plural(n, "changed file")} ${UNCHECKED}` }));
+}

package/dist/core/verify/dead-code.js

@@ -1,14 +1,21 @@
 /**
  * The `dead-code` check: compiler unused-code diagnostics in the changed
  * files that the baseline did not have (fail; warn when the adapter cannot
- * tell which ones are new).
+ * tell which ones are new), and declarations the removal left without
+ * references, which compilers don't flag for public members (warn).
  */
 import fs from "node:fs";
 import path from "node:path";
 import { fileAt } from "../git.js";
 import { checkResult, plural, skippedResult } from "./context.js";
+import { orphanFindings } from "./orphans.js";
 export function deadCodeCheck(v) {
-    const { findings, summary, analyzed } = compilerFindings(v);
+    const { findings, summary: compiler, analyzed } = compilerFindings(v);
+    const orphans = orphanFindings(v);
+    findings.push(...orphans);
+    const summary = orphans.length
+        ? `${compiler}; ${plural(orphans.length, "declaration")} left without references`
+        : compiler;
     // A check that did not look at every changed file must not read as a pass (a found diagnostic still fails it).
     if (!analyzed && !findings.some((f) => f.severity === "fail" || f.severity === "warn")) {
         return skippedResult("dead-code", summary, findings);

package/dist/core/verify/index.js

@@ -6,11 +6,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { flagDir, readBaseline, runChecks, verifyPath } from "../baseline.js";
+import { changeFilter, changeFilterAt } from "../change-filter.js";
 import { configChanges as configChangesSince, configSnapshot } from "../config-snapshot.js";
 import { changedFilesSince, gitState, treeFingerprint } from "../git.js";
-import { CHECK_IDS, JSON_SCHEMA_VERSION, } from "../types.js";
-import { buildCheck, compareTests, testsCheck } from "./commands.js";
+import { dropRuns, findRuns, plannedRuns, reuseRuns, runsKey, saveRuns } from "../run-cache.js";
+import { CHECK_IDS, JSON_SCHEMA_VERSION, RUN_CHECK_ID, } from "../types.js";
+import { buildCheck, compareTests, lintCheck, testsCheck } from "./commands.js";
 import { skippedResult } from "./context.js";
+import { coverageCheck } from "./coverage.js";
 import { deadCodeCheck } from "./dead-code.js";
 import { leftoversCheck } from "./leftovers.js";
 export async function verifyFlag(root, projects, flag, options = {}) {
@@ -19,19 +22,41 @@ export async function verifyFlag(root, projects, flag, options = {}) {
     // Take the git state before running commands: their output (bin/, test
     // results) is not part of the change under review.
     const git = gitState(root);
-    const changedFiles = baseline.git.sha ? changedFilesSince(root, baseline.git.sha) : undefined;
-    const only = [...(skip.has("build") ? [] : ["build"]), ...(skip.has("tests") ? [] : ["test"])];
-    const runs = only.length ? await runChecks(projects, path.join(flagDir(root, flag), "verify"), only) : [];
+    // flagrm's setup files and `exclude`d paths (the config's and --exclude) aren't part of the removal.
+    const ignore = changeFilter(projects[0]?.ctx.config);
+    const changedFiles = baseline.git.sha ? changedFilesSince(root, baseline.git.sha, ignore) : undefined;
+    const only = ["build", "test", "lint"].filter((check) => !skip.has(RUN_CHECK_ID[check]));
+    // Before the commands: the key is the tree they run on.
+    const key = only.length ? runsKey(root, projects) : undefined;
+    const found = key && options.reuse !== false ? findRuns(root, projects, key, plannedRuns(projects, only)) : undefined;
+    const logDir = path.join(flagDir(root, flag), "verify");
+    const runs = found ? reuseRuns(found, logDir) : only.length ? await runChecks(projects, logDir, only) : [];
     // The fingerprint, though, is the tree the Stop hook will see next, so take it
     // after the commands: a test report they write outside .gitignore is part of it.
-    const fingerprint = treeFingerprint(root);
-    const configChanges = configChangesSince(baseline.config, configSnapshot(projects));
-    const v = { root, flag, projects, baseline, changedFiles, runs, configChanges };
+    // The Stop hook compares it with its own, so take it exactly as the hook does: from the config file
+    // alone, without --exclude, which the hook can't know.
+    const fingerprint = treeFingerprint(root, changeFilterAt(root));
+    const now = configSnapshot(projects);
+    const configChanges = configChangesSince(baseline.acceptedConfig ?? baseline.config, now);
+    const originalConfigChanges = baseline.acceptedConfig ? configChangesSince(baseline.config, now) : configChanges;
+    const v = {
+        root,
+        flag,
+        projects,
+        baseline,
+        changedFiles,
+        runs,
+        skip,
+        configChanges,
+        originalConfigChanges,
+    };
     const tests = compareTests(v);
     const run = {
         "dead-code": () => deadCodeCheck(v),
         build: () => buildCheck(v),
         tests: () => testsCheck(v, tests),
+        lint: () => lintCheck(v),
+        coverage: () => coverageCheck(v),
     };
     const checks = [];
     for (const id of CHECK_IDS) {
@@ -57,6 +82,15 @@ export async function verifyFlag(root, projects, flag, options = {}) {
         runs: runs.map(countsOnly),
         tests,
     };
+    // Only a full pass is worth reusing: a failure may be flaky or a stopped service.
+    if (key && report.status === "pass" && report.skipped.length === 0)
+        saveRuns(root, flag, projects, key, runs);
+    // A fresh run that fails on this tree outweighs a saved pass for it (`--no-reuse` after a machine change).
+    else if (key &&
+        !found &&
+        checks.some((c) => (c.id === "build" || c.id === "tests" || c.id === "lint") && c.status === "fail")) {
+        dropRuns(root, key);
+    }
     const file = verifyPath(root, flag);
     fs.mkdirSync(path.dirname(file), { recursive: true });
     fs.writeFileSync(file, `${JSON.stringify(report, null, 2)}\n`, "utf8");

package/dist/core/verify/log-results.js

@@ -0,0 +1,127 @@
+/**
+ * Test results from a test command's log, for a run without result files:
+ * the failing tests' names and the summary counts the common runners print
+ * (Karma, Jest, Vitest, `dotnet test`; Go and pytest failures without
+ * counts). Passing tests aren't in these logs, so only failing ones are named.
+ */
+import { JUNIT_SEPARATOR } from "./test-results.js";
+const vitestName = (name) => name.split(" > ").join(JUNIT_SEPARATOR);
+/** A failing test's name in one log line, per runner. */
+const FAILED = [
+    // Karma: `Chrome Headless 120.0.0.0 (Mac OS 10.15.7) CheckoutComponent places the order FAILED`
+    [/^\S.*? \d[\d.]* \((?:Mac OS|Linux|Windows|Ubuntu)[^)]*\) (.+?) FAILED$/, (m) => m[1]],
+    // Jest: `● CheckoutComponent › places the order`; its notices (`● Console`, `● Multiple configurations found:`) aren't tests
+    [/^● (.+)$/, (m) => (/^(?:Test suite failed to run|Console)$|:$/.test(m[1]) ? undefined : m[1])],
+    // Vitest: `FAIL  src/a.spec.ts > Suite > title` (optionally after a `|project|` tag) and `× Suite > title 12ms`
+    [/^FAIL\s+(?:\|[^|]+\|\s+)?\S+ > (.+)$/, (m) => vitestName(m[1])],
+    [/^[×✗] (.+ > .+?)(?: \d+ms)?$/, (m) => vitestName(m[1])],
+    // dotnet test: `Failed Shop.Tests.CheckoutTests.Quote(express: False) [12 ms]`
+    [/^Failed (\S.*?) \[(?:< ?)?[\d.,]+ (?:ms|s|m)\]$/, (m) => m[1]],
+    // go test: `--- FAIL: TestX (0.00s)`
+    [/^--- FAIL: (\S+)/, (m) => m[1]],
+    // pytest: `FAILED tests/test_a.py::test_x - AssertionError`
+    [/^FAILED (\S+::\S+)/, (m) => m[1]],
+];
+function count(parts, word) {
+    return Number(new RegExp(`(\\d+) ${word}`).exec(parts)?.[1] ?? 0);
+}
+/**
+ * The summary counts in one log line; `sum` for runners that print one
+ * summary per test project, `browser` for Karma's one summary per browser.
+ */
+function summary(line) {
+    // Karma, possibly several `\r`-separated progress updates: the last one counts.
+    const karma = [
+        ...line.matchAll(/(?:^|\r)\s*(?:(\S[^\r]*?):\s+)?Executed (\d+) of (\d+)(?: \((\d+) FAILED\))?(?: \(skipped (\d+)\))?/g),
+    ].pop();
+    if (karma) {
+        const failed = Number(karma[4] ?? 0);
+        return {
+            counts: { total: Number(karma[3]), passed: Number(karma[2]) - failed, failed, skipped: Number(karma[5] ?? 0) },
+            browser: karma[1] ?? "",
+        };
+    }
+    const jest = /^Tests:\s+(.*?)(\d+) total/.exec(line);
+    if (jest) {
+        return {
+            counts: {
+                total: Number(jest[2]),
+                passed: count(jest[1], "passed"),
+                failed: count(jest[1], "failed"),
+                skipped: count(jest[1], "skipped") + count(jest[1], "todo"),
+            },
+        };
+    }
+    const vitest = /^Tests\s+(.+)\((\d+)\)$/.exec(line);
+    if (vitest) {
+        return {
+            counts: {
+                total: Number(vitest[2]),
+                passed: count(vitest[1], "passed"),
+                failed: count(vitest[1], "failed"),
+                skipped: count(vitest[1], "skipped") + count(vitest[1], "todo"),
+            },
+        };
+    }
+    const dotnet = /^(?:Failed|Passed)!\s+-\s+Failed:\s+(\d+), Passed:\s+(\d+), Skipped:\s+(\d+), Total:\s+(\d+)/.exec(line);
+    if (dotnet) {
+        return {
+            counts: {
+                failed: Number(dotnet[1]),
+                passed: Number(dotnet[2]),
+                skipped: Number(dotnet[3]),
+                total: Number(dotnet[4]),
+            },
+            sum: true,
+        };
+    }
+    return undefined;
+}
+const add = (a, b) => ({
+    total: a.total + b.total,
+    passed: a.passed + b.passed,
+    failed: a.failed + b.failed,
+    skipped: a.skipped + b.skipped,
+});
+export function parseTestLog(text) {
+    const failed = new Set();
+    let counts;
+    const browsers = new Map();
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: strips ANSI colors
+    for (const raw of text.replace(/\u001b\[[0-9;]*m/g, "").split(/\r?\n/)) {
+        const line = raw.trim();
+        const found = summary(line);
+        if (found?.browser !== undefined) {
+            // Several browsers each run every test: the last summary per browser counts, summed over browsers.
+            browsers.set(found.browser, found.counts);
+            counts = [...browsers.values()].reduce(add);
+        }
+        else if (found) {
+            counts = found.sum && counts ? add(counts, found.counts) : found.counts;
+        }
+        // Karma's progress updates share a line through `\r`: names are looked for in each part.
+        for (const part of line.split("\r")) {
+            for (const [pattern, name] of FAILED) {
+                const m = pattern.exec(part.trim());
+                const found = m && name(m);
+                if (found) {
+                    failed.add(found);
+                    break;
+                }
+            }
+        }
+    }
+    if (!counts && failed.size === 0)
+        return undefined;
+    const names = [...failed];
+    return {
+        total: counts?.total ?? 0,
+        passed: counts?.passed ?? 0,
+        failed: counts?.failed ?? names.length,
+        skipped: counts?.skipped ?? 0,
+        names,
+        failedNames: [...names],
+        files: [],
+        source: "log",
+    };
+}

package/dist/core/verify/orphans.js

@@ -0,0 +1,175 @@
+/**
+ * Code the removal orphaned without a compiler noticing: a method, property
+ * or class whose last reference was in the deleted OFF path is still
+ * declared, and a public or internal member gets no "unused" diagnostic.
+ *
+ * Lexical: an identifier whose count went down in a changed code file, now
+ * found exactly once across the projects' files (its declaration) and more
+ * than once at the baseline. Comments don't count as references; strings,
+ * templates, Razor views and config files do (DI by name, interpolation,
+ * Angular bindings, options bound from appsettings), so a hit is a warning.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { fileAt } from "../git.js";
+import { commentSyntax, computeLexicalMask, escapeRegExp, LEX_COMMENT } from "../scan.js";
+import { SourceText } from "../source-text.js";
+/** Files whose identifiers can be declarations the removal orphaned. */
+const CODE_FILE = /\.(cs|ts|tsx|js|jsx|mjs|cjs|go|java|kt)$/;
+/** Identifiers of 4+ characters: shorter ones (`id`, `Run`) are too common to mean anything here. */
+const IDENT = /[A-Za-z_]\w{3,}/g;
+/**
+ * Keywords and built-in type names (C#, TypeScript/JavaScript, Go, Java,
+ * Kotlin) of 4+ characters: removing one can leave a single one in the
+ * project, which is no declaration.
+ */
+const KEYWORDS = new Set(("true false null this base void self super class struct record interface enum namespace package import " +
+    "export from default extends implements public private protected internal static readonly const final " +
+    "abstract virtual override sealed async await yield return throw throws break continue switch case else " +
+    "while foreach using lock fixed unsafe checked unchecked params where when select func defer chan range " +
+    "type typeof instanceof keyof infer declare module require function constructor delete void never unknown " +
+    "string bool boolean char byte short long float double decimal object dynamic number bigint symbol " +
+    "Task Void Boolean String Object Unit init operator implicit explicit event delegate goto sizeof stackalloc " +
+    "volatile extern partial global nameof value get set add remove inline data sealed open lateinit companion").split(" "));
+const MODIFIERS = "public|private|protected|internal|static|readonly|virtual|override|abstract|sealed|async|partial|const|extern|" +
+    "unsafe|required|new|final|open|suspend|inline|lateinit|declare|export|default|get|set|accessor";
+/** Words that start a statement, not a declaration's type (`return Foo;`, `await Bar();`). */
+const STATEMENT = new Set([
+    "return",
+    "await",
+    "throw",
+    "yield",
+    "else",
+    "case",
+    "goto",
+    "using",
+    "import",
+    "package",
+    "namespace",
+]);
+/**
+ * Whether `line` declares `name`, by the shape of declarations in the file's
+ * language: what is left of an orphan is its declaration, while the last use
+ * of a library member (`mock.Setup(...)`), an object key or an import is not.
+ */
+export function declares(file, line, name) {
+    const n = escapeRegExp(name);
+    if (/\.(cs|java|kt)$/.test(file)) {
+        if (new RegExp(`\\b(class|interface|record|struct|enum|object|fun|val|var)\\s+${n}\\b`).test(line))
+            return true;
+        const member = new RegExp(`^\\s*(?:\\[[^\\]]*\\]\\s*)*(?:(?:${MODIFIERS})\\s+)*([\\w.?<>\\[\\],]+)\\s+${n}\\s*(?:<[^>]*>)?\\s*(?:\\(|\\{|=>|=|;)`).exec(line);
+        return Boolean(member && !STATEMENT.has(member[1]));
+    }
+    if (/\.(ts|tsx|js|jsx|mjs|cjs)$/.test(file)) {
+        const mods = `(?:(?:${MODIFIERS})\\s+)`;
+        return [
+            new RegExp(`\\b(?:function\\*?|class|interface|enum|type|const|let|var|namespace)\\s+${n}\\b`),
+            new RegExp(`^\\s*${mods}+${n}\\s*[?!]?\\s*(?:\\(|=|:|<)`),
+            new RegExp(`^\\s*${n}\\s*[?!]?\\s*=(?![=>])`),
+            new RegExp(`^\\s*${n}\\s*[?!]?\\s*:[^,]*;\\s*$`),
+            new RegExp(`^\\s*${n}\\s*(?:<[^>]*>)?\\s*\\([^)]*\\)\\s*(?::\\s*[^{;=]+)?\\{\\s*$`),
+        ].some((re) => re.test(line));
+    }
+    if (file.endsWith(".go")) {
+        return new RegExp(`\\bfunc\\s+(?:\\([^)]*\\)\\s*)?${n}\\s*[([]|\\b(?:type|var|const)\\s+${n}\\b`).test(line);
+    }
+    return false;
+}
+/** At most this many findings: the first ones show the pattern. */
+const MAX = 20;
+/** Each identifier's occurrences outside comments (`only`: just these identifiers). */
+function occurrences(file, text, only) {
+    const syntax = commentSyntax(file);
+    const mask = syntax ? computeLexicalMask(text, syntax) : undefined;
+    const out = new Map();
+    for (const m of text.matchAll(IDENT)) {
+        if (only && !only.has(m[0]))
+            continue;
+        if (mask && mask[m.index] === LEX_COMMENT)
+            continue;
+        const seen = out.get(m[0]);
+        if (seen)
+            seen.count++;
+        else
+            out.set(m[0], { count: 1, first: m.index });
+    }
+    return out;
+}
+function read(file) {
+    try {
+        return fs.readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function add(totals, counts) {
+    for (const [name, { count }] of counts)
+        totals.set(name, (totals.get(name) ?? 0) + count);
+}
+export function orphanFindings(v) {
+    const sha = v.baseline.git.sha;
+    if (!sha || !v.changedFiles)
+        return [];
+    const projectFiles = new Map();
+    for (const { ctx } of v.projects)
+        for (const file of ctx.files)
+            if (!projectFiles.has(file))
+                projectFiles.set(file, ctx.name);
+    const roots = v.projects.map(({ ctx }) => ctx.root);
+    const inProject = (file) => projectFiles.has(file) || (!fs.existsSync(file) && roots.some((r) => !path.relative(r, file).startsWith("..")));
+    const changed = v.changedFiles.map((rel) => path.join(v.root, rel)).filter(inProject);
+    const recorded = new Set(v.baseline.names.map((n) => n.name));
+    // Counts in the changed files then and now; unchanged files count the same both times.
+    const before = new Map();
+    const nowInChanged = new Map();
+    const candidates = new Set();
+    for (const file of changed) {
+        const was = occurrences(file, fileAt(v.root, sha, path.relative(v.root, file)) ?? "");
+        const text = read(file);
+        const is = text === undefined ? new Map() : occurrences(file, text);
+        add(before, was);
+        add(nowInChanged, is);
+        if (!CODE_FILE.test(file))
+            continue;
+        for (const [name, { count }] of was) {
+            if (count > (is.get(name)?.count ?? 0) && !recorded.has(name) && !KEYWORDS.has(name))
+                candidates.add(name);
+        }
+    }
+    if (candidates.size === 0)
+        return [];
+    const now = new Map();
+    const where = new Map();
+    for (const [file, project] of projectFiles) {
+        const text = read(file);
+        if (text === undefined)
+            continue;
+        const counts = occurrences(file, text, candidates);
+        add(now, counts);
+        for (const [name, { first }] of counts)
+            if (!where.has(name))
+                where.set(name, { file, offset: first, text, project });
+    }
+    const findings = [];
+    for (const name of [...candidates].sort()) {
+        const total = now.get(name) ?? 0;
+        const wasTotal = total - (nowInChanged.get(name) ?? 0) + (before.get(name) ?? 0);
+        const at = where.get(name);
+        if (total !== 1 || wasTotal < 2 || !at)
+            continue;
+        const source = new SourceText(at.file, at.text);
+        if (!declares(at.file, source.snippet(at.offset), name))
+            continue;
+        findings.push({
+            severity: "warn",
+            message: `${name} is now referenced only where it is declared: delete it if only the OFF path used it`,
+            project: at.project,
+            file: at.file,
+            line: source.position(at.offset).line,
+        });
+        if (findings.length === MAX)
+            break;
+    }
+    return findings;
+}

package/dist/core/verify/removed-tests.js

@@ -2,19 +2,23 @@
  * Why each baseline test no longer runs. Deleting the OFF path's tests and
  * dropping the flag from test names is part of a removal, and a narrower test
  * command leaves tests out on purpose; only the rest needs explaining.
+ * Without result files, the changed test files' declarations stand in for the
+ * names (`declaredTestDiff`).
  */
 import fs from "node:fs";
 import path from "node:path";
 import { flagWords, words } from "../flag-words.js";
 import { fileAt } from "../git.js";
-import { escapeRegExp, isTestPath } from "../scan.js";
+import { computeCodeMask, escapeRegExp, isTestPath } from "../scan.js";
 import { JUNIT_SEPARATOR, testKey } from "./test-results.js";
-/** Sort the tests that no longer run (`removed`) using the new ones (`added`) and the diff. */
-export function classifyRemovedTests(removed, added, afterNames, ctx) {
+/**
+ * Sort the tests that no longer run (`removed`) using the new ones (`added`)
+ * and the diff. `files`: the changed test files when the caller already read them.
+ */
+export function classifyRemovedTests(removed, added, afterNames, ctx, files = changedTestFiles(ctx)) {
     const out = { deleted: [], renamed: [], excludedByConfig: [], unexplained: [] };
     const renamedTo = matchRenames(removed, added, flagWords(ctx.names));
     const stillRuns = new Set(afterNames.map(testKey));
-    const files = changedTestFiles(ctx);
     for (const name of removed) {
         const to = renamedTo.get(testKey(name));
         if (to)
@@ -83,7 +87,7 @@ function matchRenames(removed, added, flag) {
     }
     return out;
 }
-function changedTestFiles(ctx) {
+function changedTestFiles(ctx, includeNew = false) {
     if (!ctx.sha)
         return [];
     const out = [];
@@ -91,7 +95,7 @@ function changedTestFiles(ctx) {
         if (!isTestPath(rel))
             continue;
         const before = fileAt(ctx.root, ctx.sha, rel);
-        if (before === undefined)
+        if (before === undefined && !includeNew)
             continue;
         let now;
         try {
@@ -100,7 +104,7 @@ function changedTestFiles(ctx) {
         catch {
             now = undefined;
         }
-        out.push({ before, now });
+        out.push({ rel, before: before ?? "", now });
     }
     return out;
 }
@@ -123,6 +127,10 @@ function isDeleted(name, keyStillRuns, files) {
 }
 /** xUnit (`InlineData`, `[Bit]AutoData(...)` with values), NUnit and MSTest attributes that each add a data row. */
 const DATA_ROW = /\b(?:\w*InlineData|\w*AutoData|TestCase|DataRow)\s*\(/g;
+/** Whether a test file has data-row attributes or `.each` cases. */
+function hasDataRows(text) {
+    return new RegExp(DATA_ROW.source).test(text) || /\.each\s*[(`]/.test(text);
+}
 /**
  * How many data rows `own` has in `text`: the row attributes between the end
  * of the previous member and its declaration. For JUnit names (`it.each`
@@ -139,3 +147,78 @@ function dataRows(text, own, junit) {
     }
     return rows;
 }
+// --- declarations ----------------------------------------------------------------
+const JS_TEST = /(?<![\w$.])(describe|fdescribe|xdescribe|context|suite|it|fit|xit|test)(?:\.(?:only|skip|todo))?(?:\.each\s*(?:\([\s\S]*?\)|`[\s\S]*?`))?\s*\(\s*(['"`])((?:\\.|(?!\2)[^\\])*)\2/g;
+/** `it`/`test` titles prefixed with the titles of the `describe` blocks around them (by brace depth over code). */
+function jsTests(text) {
+    const code = computeCodeMask(text);
+    const out = [];
+    const open = [];
+    let depth = 0;
+    let pos = 0;
+    for (const m of text.matchAll(JS_TEST)) {
+        if (!code[m.index])
+            continue;
+        for (; pos < m.index; pos++)
+            if (code[pos])
+                depth += text[pos] === "{" ? 1 : text[pos] === "}" ? -1 : 0;
+        while (open.length && open[open.length - 1].depth >= depth)
+            open.pop();
+        if (/describe|context|suite/.test(m[1]))
+            open.push({ title: m[3], depth });
+        else
+            out.push([...open.map((d) => d.title), m[3]].join(JUNIT_SEPARATOR));
+    }
+    return out;
+}
+const CS_TEST = /\[(?:Fact|Theory|Test|TestCase|TestMethod)\b[^\]]*\][\s\S]*?\b(?:void|Task|ValueTask)(?:<[^>]*>)?\s+(\w+)\s*\(/g;
+/** Test methods as TRX names them without data-row arguments: `Namespace.Class.Method`. */
+function csTests(text) {
+    const ns = /^\s*namespace\s+([\w.]+)/m.exec(text)?.[1];
+    return [...text.matchAll(CS_TEST)].map((m) => {
+        const cls = [...text.slice(0, m.index).matchAll(/\bclass\s+(\w+)/g)].pop()?.[1];
+        return [ns, cls, m[1]].filter(Boolean).join(".");
+    });
+}
+/** The tests a test file declares, named as result files name them where the syntax allows. */
+export function declaredTests(text, file) {
+    if (/\.[cm]?[jt]sx?$/.test(file))
+        return jsTests(text);
+    if (file.endsWith(".cs"))
+        return csTests(text);
+    if (file.endsWith(".go"))
+        return [...text.matchAll(/\bfunc (Test\w+)\s*\(/g)].map((m) => m[1]);
+    if (file.endsWith(".py"))
+        return [...text.matchAll(/^\s*def (test_\w+)\s*\(/gm)].map((m) => m[1]);
+    return [];
+}
+/** `from` without the names in `other`, counting duplicates. */
+function minus(from, other) {
+    const left = new Map();
+    for (const name of other)
+        left.set(name, (left.get(name) ?? 0) + 1);
+    return from.filter((name) => {
+        const n = left.get(name) ?? 0;
+        left.set(name, n - 1);
+        return n <= 0;
+    });
+}
+/**
+ * What the changed test files declared at the baseline and don't now, the
+ * new declarations, and all declared now: the stand-in for result files'
+ * names when there are none.
+ */
+export function declaredTestDiff(ctx) {
+    const before = [];
+    const now = [];
+    let rows = false;
+    // A file new since the baseline declared nothing then, so a moved spec's tests cancel out.
+    const files = changedTestFiles(ctx, true);
+    for (const file of files) {
+        rows ||= hasDataRows(file.before) || (file.now !== undefined && hasDataRows(file.now));
+        before.push(...declaredTests(file.before, file.rel));
+        if (file.now !== undefined)
+            now.push(...declaredTests(file.now, file.rel));
+    }
+    return { removed: minus(before, now), added: minus(now, before), now, rows, files };
+}