@cplieger/deadset-ts 7.2.0-dev.4 → 8.0.0-dev.10

package/src/test-support.ts

@@ -1,10 +1,13 @@
 /**
- * Test-support code: the files only tests reach. A test reaches each one through a chain
- * of references, and every reference to a declaration of one, an import for its effects
- * included, is written in a test file or in another such file, so it is judged with the
- * tests: what it references is referenced by test code.
+ * Test-support code: the files only tests reach that carry test evidence of their own. A
+ * test reaches each one through a chain of references, and every reference to a
+ * declaration of one, an import for its effects included, is written in a test file or in
+ * another such file, so it is judged with the tests: what it references is referenced by
+ * test code.
  */
 
+import { CONVENTION_ROWS, TEST_LIBRARIES, TEST_LIBRARY_SCOPES } from "./convention-rows.ts";
+import { packageOfSpecifier } from "./dependencies.ts";
 import type { InventorySymbol } from "./inventory.ts";
 import type { Reference } from "./references.ts";
 import type { Root } from "./roots.ts";
@@ -12,19 +15,144 @@ import type { Root } from "./roots.ts";
 /** The root kind that never takes a file out of test-support code: the skip only withholds. */
 const SKIP_ROOT = "type-error";
 
+/**
+ * The test runners and test libraries an import of which is test evidence: each runner a
+ * convention row reads test files for, and the convention table's test libraries.
+ */
+const TEST_PACKAGES: ReadonlySet<string> = new Set([
+  ...CONVENTION_ROWS.filter((row) => row.testFiles !== undefined).map((row) => row.package),
+  ...TEST_LIBRARIES,
+]);
+
+/**
+ * The Node.js built-in modules a bare specifier names, which are no package. The set is
+ * closed: Node.js adds a new built-in under the `node:` scheme alone
+ * (https://nodejs.org/api/modules.html#built-in-modules-with-mandatory-node-prefix).
+ */
+const NODE_BUILTINS: ReadonlySet<string> = new Set([
+  "assert",
+  "async_hooks",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "diagnostics_channel",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "trace_events",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "wasi",
+  "worker_threads",
+  "zlib",
+]);
+
+/** What a file imports, read for test evidence. */
+export interface TestEvidence {
+  /** Per file below the target root, the module specifiers its imports write. */
+  readonly imports: ReadonlyMap<string, readonly string[]>;
+  /**
+   * Whether the manifest nearest the file, below the target root, that declares the
+   * package declares it under `devDependencies`.
+   */
+  readonly devDependency: (path: string, name: string) => boolean;
+}
+
+/** Whether a specifier names a test runner or a test library. */
+function namesTestPackage(specifier: string): boolean {
+  const name = specifier.startsWith("node:") ? specifier : packageOfSpecifier(specifier);
+  return (
+    name !== undefined &&
+    (TEST_PACKAGES.has(name) || TEST_LIBRARY_SCOPES.some((scope) => name.startsWith(scope)))
+  );
+}
+
+/**
+ * Whether a file carries test evidence: an import of a test runner or a test library, or
+ * package imports, Node built-ins aside, that are all devDependencies no file imports
+ * outside the test files and `onlyTests`, the files only tests reach.
+ */
+function evidenceReader(
+  tests: ReadonlySet<string>,
+  evidence: TestEvidence,
+): (onlyTests: ReadonlySet<string>, path: string) => boolean {
+  const importers = new Map<string, string[]>();
+  for (const [path, specifiers] of evidence.imports) {
+    for (const specifier of specifiers) {
+      const name = packageOfSpecifier(specifier);
+      if (name !== undefined) {
+        importers.set(name, [...(importers.get(name) ?? []), path]);
+      }
+    }
+  }
+  return (onlyTests, path) => {
+    const specifiers = evidence.imports.get(path) ?? [];
+    if (specifiers.some(namesTestPackage)) {
+      return true;
+    }
+    const names = specifiers.flatMap((one) => packageOfSpecifier(one) ?? []);
+    const packages = names.filter((name) => !NODE_BUILTINS.has(name));
+    return (
+      packages.length > 0 &&
+      packages.every(
+        (name) =>
+          evidence.devDependency(path, name) &&
+          (importers.get(name) ?? []).every((one) => tests.has(one) || onlyTests.has(one)),
+      )
+    );
+  };
+}
+
+/** The files only tests reach, split by whether each carries test evidence of its own. */
+interface TestReached {
+  /** The test-support files: test code. */
+  readonly support: ReadonlySet<string>;
+  /** The files only tests reach that are no test-support file: production code only tests use. */
+  readonly testUsed: ReadonlySet<string>;
+}
+
 /**
  * The files of one project that are test-support code, below the target root: the
  * largest set of files a test file reaches, none of them a test file or holding a root,
- * whose every user outside the set is a test file. A root has a caller outside the
- * reference graph: a runtime, a tool, a configuration, or a consumer of a library's
- * published API. `testFiles` are the files the test-file rules classified.
+ * each carrying test evidence of its own, whose every user outside the set is a test
+ * file; and the files only tests reach that are not among them. A root has a caller
+ * outside the reference graph: a runtime, a tool, a configuration, or a consumer of a
+ * library's published API. `testFiles` are the files the test-file rules classified.
  */
 export function testSupportFiles(
   symbols: readonly InventorySymbol[],
   references: readonly Reference[],
   roots: readonly Root[],
   testFiles: readonly string[],
-): ReadonlySet<string> {
+  evidence: TestEvidence,
+): TestReached {
   const fileOf = new Map(symbols.map((symbol) => [symbol.id, symbol.position.path]));
   const users = new Map<string, Set<string>>();
   const uses = new Map<string, Set<string>>();
@@ -59,18 +187,27 @@ export function testSupportFiles(
       }
     }
   }
-  const support = new Set([...reached].filter((path) => !rooted.has(path)));
-  for (let changed = true; changed;) {
-    changed = false;
-    for (const path of support) {
-      const from = users.get(path) ?? new Set<string>();
-      if (![...from].every((one) => tests.has(one) || support.has(one))) {
-        support.delete(path);
-        changed = true;
+  const withoutOutsideUsers = (files: Set<string>): Set<string> => {
+    for (let changed = true; changed;) {
+      changed = false;
+      for (const path of files) {
+        const from = users.get(path) ?? new Set<string>();
+        if (![...from].every((one) => tests.has(one) || files.has(one))) {
+          files.delete(path);
+          changed = true;
+        }
       }
     }
-  }
-  return support;
+    return files;
+  };
+  // Evidence reads the files only tests reach, evidence or none, so it is fixed before the
+  // files without evidence leave the set.
+  const onlyTests = withoutOutsideUsers(new Set([...reached].filter((path) => !rooted.has(path))));
+  const carries = evidenceReader(tests, evidence);
+  const support = withoutOutsideUsers(
+    new Set([...onlyTests].filter((path) => carries(onlyTests, path))),
+  );
+  return { support, testUsed: new Set([...onlyTests].filter((path) => !support.has(path))) };
 }
 
 /** The references with every one a test-support file makes counted as a test reference. */

package/src/text/compare.ts

@@ -0,0 +1,27 @@
+/**
+ * Two strings in the order of their UTF-8 bytes, the order every set of a run is read in.
+ * That is code point order, which UTF-16 code unit order (`<` on strings) breaks above
+ * U+FFFF: a surrogate unit is below U+E000 while the code point it encodes is above U+FFFF.
+ */
+export function bytewise(a: string, b: string): number {
+  if (a === b) {
+    return 0;
+  }
+  const length = Math.min(a.length, b.length);
+  for (let at = 0; at < length; at += 1) {
+    const x = a.charCodeAt(at);
+    const y = b.charCodeAt(at);
+    if (x !== y) {
+      return ranked(x) < ranked(y) ? -1 : 1;
+    }
+  }
+  return a.length < b.length ? -1 : 1;
+}
+
+/** One UTF-16 unit moved so that a surrogate ranks above every unit of U+E000 to U+FFFF. */
+function ranked(unit: number): number {
+  if (unit >= 0xe000) {
+    return unit - 0x800;
+  }
+  return unit >= 0xd800 ? unit + 0x2000 : unit;
+}

package/src/text/glob.ts

@@ -0,0 +1,210 @@
+/**
+ * Glob patterns over paths in two forms. The configured form (the configuration, convention
+ * rows, bundler entries, workspace member patterns) has `*` and `?` within a segment, `**`
+ * across segments and brace lists. A `.gitignore` line has git's form: bracket expressions
+ * and backslash escapes, no brace lists (https://git-scm.com/docs/gitignore#_pattern_format).
+ * A configured root is not a glob: it names a symbol reference, and is read where it is used.
+ */
+
+type GlobForm = "configured" | "gitignore";
+
+/**
+ * One character of a pattern as the expression syntax reads it literally. The set escaped
+ * is closed: under the unicode flag an escape of any other character is refused outright.
+ */
+function quoted(character: string): string {
+  return /[.*+?^${}()|[\]\\/]/u.test(character) ? `\\${character}` : character;
+}
+
+/**
+ * The ASCII ranges each POSIX class a bracket expression may name holds, as git's own
+ * character table reads them, each range written as its first and last character.
+ */
+const CLASSES: ReadonlyMap<string, string> = new Map([
+  ["alnum", "09AZaz"],
+  ["alpha", "AZaz"],
+  ["blank", "\t\t  "],
+  ["cntrl", "\0\x1f\x7f\x7f"],
+  ["digit", "09"],
+  ["graph", "!~"],
+  ["lower", "az"],
+  ["print", " ~"],
+  ["punct", "!/:@[`{~"],
+  ["space", "\t\n\r\r  "],
+  ["upper", "AZ"],
+  ["xdigit", "09AFaf"],
+]);
+
+/** What a pattern git cannot read matches: nothing, as git aborts the whole match. */
+const NOTHING = "(?!)";
+
+/** One code point as a member of an expression class. */
+function member(point: number): string {
+  return `\\u{${point.toString(16)}}`;
+}
+
+/**
+ * The class a bracket expression opening at `open` denotes, and the index past its `]`,
+ * read as git's wildmatch reads it: a leading `!` or `^` negates it, a `]` first is a
+ * member, `\` escapes one character, `x-y` is a range (one whose `y` is below `x` holds
+ * `x` alone) and `[:name:]` a POSIX class. An unclosed bracket or an unknown class name
+ * matches nothing. Neither form matches the solidus.
+ */
+function bracket(pattern: string, open: number): { source: string; end: number } {
+  let at = open + 1;
+  const negated = pattern[at] === "!" || pattern[at] === "^";
+  if (negated) {
+    at += 1;
+  }
+  const next = (): number | undefined => {
+    const point = pattern.codePointAt(at);
+    at += point !== undefined && point > 0xffff ? 2 : 1;
+    return point;
+  };
+  let members = "";
+  let low: number | undefined;
+  for (let first = true; ; first = false) {
+    let point = next();
+    if (point === undefined) {
+      return { source: NOTHING, end: pattern.length };
+    }
+    if (point === 0x5d && !first) {
+      return { source: negated ? `[^/${members}]` : `(?!/)[${members}]`, end: at };
+    }
+    if (point === 0x2d && low !== undefined && at < pattern.length && pattern[at] !== "]") {
+      let high = next();
+      if (high === 0x5c) {
+        high = next();
+      }
+      if (high === undefined) {
+        return { source: NOTHING, end: pattern.length };
+      }
+      members += high >= low ? `${member(low)}-${member(high)}` : "";
+      low = undefined;
+      continue;
+    }
+    if (point === 0x5b && pattern[at] === ":") {
+      const close = pattern.indexOf("]", at + 1);
+      if (close < 0) {
+        return { source: NOTHING, end: pattern.length };
+      }
+      if (close > at + 1 && pattern[close - 1] === ":") {
+        const ranges = CLASSES.get(pattern.slice(at + 1, close - 1));
+        if (ranges === undefined) {
+          return { source: NOTHING, end: pattern.length };
+        }
+        for (let one = 0; one < ranges.length; one += 2) {
+          members += `${member(ranges.charCodeAt(one))}-${member(ranges.charCodeAt(one + 1))}`;
+        }
+        low = undefined;
+        at = close + 1;
+        continue;
+      }
+    }
+    if (point === 0x5c) {
+      point = next();
+      if (point === undefined) {
+        return { source: NOTHING, end: pattern.length };
+      }
+    }
+    members += member(point);
+    low = point;
+  }
+}
+
+/** The expression source of one pattern with no brace list. */
+function source(pattern: string, form: GlobForm): string {
+  let text = "";
+  let at = 0;
+  while (at < pattern.length) {
+    if (pattern.startsWith("**/", at)) {
+      text += "(?:[^/]*/)*";
+      at += 3;
+      continue;
+    }
+    if (pattern.startsWith("**", at)) {
+      text += ".*";
+      at += 2;
+      continue;
+    }
+    const character = pattern[at] ?? "";
+    if (form === "gitignore" && character === "[") {
+      const read = bracket(pattern, at);
+      text += read.source;
+      at = read.end;
+      continue;
+    }
+    if (form === "gitignore" && character === "\\" && at + 1 < pattern.length) {
+      text += quoted(pattern[at + 1] ?? "");
+      at += 2;
+      continue;
+    }
+    at += 1;
+    text += character === "*" ? "[^/]*" : character === "?" ? "[^/]" : quoted(character);
+  }
+  return text;
+}
+
+/** A pattern with every brace list expanded into its alternatives; a lone `{` stands for itself. */
+export function braceExpanded(pattern: string): readonly string[] {
+  const open = pattern.indexOf("{");
+  const close = open < 0 ? -1 : pattern.indexOf("}", open);
+  if (close < 0) {
+    return [pattern];
+  }
+  const before = pattern.slice(0, open);
+  const after = pattern.slice(close + 1);
+  return pattern
+    .slice(open + 1, close)
+    .split(",")
+    .flatMap((member) => braceExpanded(before + member + after));
+}
+
+/** The expression one whole-path pattern of the configured form denotes. */
+export function globExpression(pattern: string): RegExp {
+  const alternatives = braceExpanded(pattern).map((one) => source(one, "configured"));
+  return new RegExp(`^(?:${alternatives.join("|")})$`, "u");
+}
+
+/** The expression one `.gitignore` pattern denotes over a path below its file's directory. */
+export function gitignoreExpression(pattern: string): RegExp {
+  return new RegExp(`^${source(pattern, "gitignore")}$`, "u");
+}
+
+const SEGMENTS = new Map<string, RegExp>();
+
+/**
+ * Whether one directory name matches one segment of a workspace's member pattern, its brace
+ * lists already expanded. Neither `*` nor `?` matches a leading dot, as npm's workspaces read
+ * them: https://docs.npmjs.com/cli/using-npm/workspaces
+ */
+export function segmentMatches(segment: string, name: string): boolean {
+  if (name.startsWith(".") && !segment.startsWith(".")) {
+    return false;
+  }
+  let expression = SEGMENTS.get(segment);
+  if (expression === undefined) {
+    expression = globExpression(segment);
+    SEGMENTS.set(segment, expression);
+  }
+  return expression.test(name);
+}
+
+/**
+ * Whether one path's segments match a member pattern's, `**` standing for any run of segments
+ * that starts with no dot.
+ */
+export function pathMatches(pattern: readonly string[], path: readonly string[]): boolean {
+  const [head, ...rest] = pattern;
+  if (head === undefined) {
+    return path.length === 0;
+  }
+  if (head === "**") {
+    return (
+      pathMatches(rest, path) ||
+      (path.length > 0 && !(path[0] ?? "").startsWith(".") && pathMatches(pattern, path.slice(1)))
+    );
+  }
+  const [name, ...below] = path;
+  return name !== undefined && segmentMatches(head, name) && pathMatches(rest, below);
+}