@cplieger/deadset-ts 7.0.0-dev.1 → 7.0.0-dev.2

package/src/analysis.ts

@@ -62,11 +62,7 @@ import { globExpression } from "./glob.ts";
 import type { Finding } from "./finding.ts";
 import { findingsPass, recordedFindings, rowKey, type PassResult } from "./findings-pass.ts";
 import type { EmitterInput } from "./findings/emitter.ts";
-import {
-  NO_SELF_CHECK,
-  unmatchedRootFindings,
-  type SelfCheckFacts,
-} from "./findings/self-check.ts";
+import { unmatchedRootFindings, type SelfCheckFacts } from "./findings/self-check.ts";
 import { frameworkLifecycle } from "./framework-lifecycle.ts";
 import type { Host } from "./host.ts";
 import { implementations, mergeImplementations } from "./implementations.ts";
@@ -194,6 +190,8 @@ interface ProjectRead {
   readonly skipped: readonly SkippedUnit[];
   /** The project's generated files, by path below the target root, each with the detail its retentions name. */
   readonly generated: ReadonlyMap<string, string>;
+  /** The files, absolute, an applied convention row names as test files. */
+  readonly testFileNames: ReadonlySet<string>;
 }
 
 /** One target project the run analyzes, as its stage is handed it. */
@@ -460,6 +458,7 @@ function readProjects<Answer>(
             .filter((file) => referenceOnly(file.fileName))
             .flatMap((file) => relativePath(absoluteRoot, file.fileName) ?? []),
           generated: generatedFilesOf(own, generatedFiles(conventions, own)),
+          testFileNames: conventions.testFiles,
         };
       };
       for (const file of project.ownSourceFiles()) {
@@ -649,7 +648,7 @@ export interface ComponentWarning {
 }
 
 /** The exemption classes this analyzer detects, each by its detector; any other retains nothing. */
-const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
+export const DETECTORS: Detectors = new Map<TSExemptionClass, Detector>([
   ["interface-satisfaction", interfaceSatisfaction],
   ["enum-group", enumGroup],
   ["generated-file", generatedFile],
@@ -739,6 +738,7 @@ function readRun<Extra>(
     const projectRead = opened.read();
     const resolved = references(project, projectRead.held, targetRoot, {
       testFiles: config.ts.testFiles,
+      testFileNames: projectRead.testFileNames,
     });
     const evidence = evidenceRecords(
       {
@@ -799,7 +799,6 @@ function readRun<Extra>(
     const { projectRead } = one;
     const satisfied = settled[index];
     const detected = heldRecords(satisfied?.evidence ?? one.evidence, {
-      disabled,
       mode,
       testFiles: new Set([...one.testFiles, ...support]),
     });
@@ -1049,7 +1048,7 @@ interface EmitterExtra {
 }
 
 /** Reads a run's projects with every per-project fact an emitter reads. */
-function readEmitterRun(
+export function readEmitterRun(
   engine: Engine,
   host: Host,
   scope: Scope,
@@ -1135,7 +1134,7 @@ function nearestManifestDir(host: Host, root: string, file: string): string {
  * The input every emitter reads over one sweep of a read run: the facts beside the sweep
  * each kind family reads, every per-project one read in the same session as the sweep.
  */
-function emitterInputOver(
+export function emitterInputOver(
   host: Host,
   scope: Scope,
   config: Config,
@@ -1190,25 +1189,6 @@ function emitterInputOver(
   };
 }
 
-/**
- * What every emitter reads of the run the scope and the configuration describe, swept
- * under the caller's marks: the run's sweep, the facts beside it each kind family reads,
- * and the sides of the target's declared cross-language edges that name a symbol of this
- * language. The run reads no suppression document, so the self-check family has nothing
- * to report.
- */
-export function runEmitterInput(
-  engine: Engine,
-  host: Host,
-  scope: Scope,
-  config: Config,
-  input: Pick<SweepInput, "marked" | "mode">,
-  detectors: Detectors = DETECTORS,
-): EmitterInput {
-  const read = readEmitterRun(engine, host, scope, config, input.mode, detectors);
-  return emitterInputOver(host, scope, config, read, input, NO_SELF_CHECK);
-}
-
 /** One run read for its findings: the input swept with and without its suppressions' marks. */
 export interface AnalysisInputs {
   /** The run swept under the marks of every bound suppression record. */
@@ -1338,7 +1318,7 @@ export interface RunProject {
 }
 
 /** What a report states about the run beside its findings. */
-export interface RunFacts {
+interface RunFacts {
   /** The projects the run analyzed, in the run's order. */
   readonly projects: readonly RunProject[];
   /** The rules that classified files as test files, each counted over every project at once. */
@@ -1360,7 +1340,7 @@ export interface RunFacts {
 }
 
 /** One configuration whose component files a run cannot read. */
-export interface ComponentsUnread {
+interface ComponentsUnread {
   readonly configFile: string;
   readonly reason: string;
 }

package/src/calls.ts

@@ -30,7 +30,7 @@ import { must } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 
 /** One value written where a call passes it, and the node its declaration is resolved from. */
-export interface PassedValue {
+interface PassedValue {
   /** Where the value is written, which is where a record of it sits. */
   readonly site: Node;
   /** The name the value is resolved through, or the shorthand assignment that holds it. */
@@ -39,7 +39,7 @@ export interface PassedValue {
 }
 
 /** One class of the target a call passes or a decorator is attached to, and where. */
-export interface ClassUse {
+interface ClassUse {
   /** The inventory's identifier of the class. */
   readonly id: string;
   readonly site: Node;
@@ -182,7 +182,7 @@ export function classesPassed<Brand>(
 }
 
 /** One class declaration of the target and the decorators written on it. */
-export interface DecoratedClass {
+interface DecoratedClass {
   readonly id: string;
   readonly decorators: readonly Decorator[];
 }

package/src/component-files.ts

@@ -7,10 +7,10 @@
  */
 
 /** The language one block is written in, as the module's virtual extension spells it. */
-export type BlockLanguage = "ts" | "tsx" | "js" | "jsx";
+type BlockLanguage = "ts" | "tsx" | "js" | "jsx";
 
 /** One block the module holds, the frontmatter included. */
-export interface Block {
+interface Block {
   /** The offset the block's markup starts at: the `<` of its start tag, or 0 for frontmatter. */
   readonly tagStart: number;
   readonly contentStart: number;
@@ -20,7 +20,7 @@ export interface Block {
 }
 
 /** One file a `<script src>` element names, which the module imports whole. */
-export interface SourceImport {
+interface SourceImport {
   /** The specifier the module imports, relative to the component file. */
   readonly specifier: string;
   /** The offsets of the `src` attribute, name and value. */
@@ -29,14 +29,14 @@ export interface SourceImport {
 }
 
 /** A `<script` start tag beginning a line that the module holds no block for. */
-export interface ComponentWarning {
+interface ComponentWarning {
   /** The offset of the tag's `<`. */
   readonly offset: number;
   readonly reason: string;
 }
 
 /** One run of markup an expression or an attribute value is written in. */
-export interface MarkupAction {
+interface MarkupAction {
   /** The offset of the run's first code unit. */
   readonly start: number;
   readonly text: string;
@@ -45,7 +45,7 @@ export interface MarkupAction {
 }
 
 /** What one component file's text is read as. */
-export interface ComponentFile {
+interface ComponentFile {
   readonly blocks: readonly Block[];
   readonly imports: readonly SourceImport[];
   readonly warnings: readonly ComponentWarning[];
@@ -54,7 +54,7 @@ export interface ComponentFile {
 }
 
 /** The module the compiler reads in place of one component file. */
-export interface ComponentModule {
+interface ComponentModule {
   /** The module's text: the file's length, then what the module appends. */
   readonly text: string;
   /** The virtual extension: the strongest language any block names, `.ts` for none. */

package/src/component-layer.ts

@@ -11,10 +11,10 @@ import type { Host } from "./host.ts";
 import { dirnamePath, joinPath } from "./paths.ts";
 
 /** The name the mapper's manifest declares and every configuration's entry names. */
-export const MAPPER_PACKAGE = "deadset-ts-component-files";
+const MAPPER_PACKAGE = "deadset-ts-component-files";
 
 /** The file system one snapshot is created with. */
-export type SnapshotFileSystem = NonNullable<CreateSnapshotParams["fileSystem"]>;
+type SnapshotFileSystem = NonNullable<CreateSnapshotParams["fileSystem"]>;
 
 /** The manifest of the mapper's package, which runs `command`. */
 export function mapperManifest(command: readonly string[]): string {

package/src/components.ts

@@ -42,7 +42,7 @@ export interface Component {
 }
 
 /** What a report carries for one dead component under one cascade mode. */
-export interface Listing {
+interface Listing {
   readonly roots: readonly string[];
   /** Every member under the full mode, and nothing under the default one. */
   readonly members: readonly string[];

package/src/config.ts

@@ -50,7 +50,7 @@ export type Cascade = "roots" | "full";
  * tags in effect. It is the shape a language built under build constraints reads,
  * and this analyzer leaves it to that analysis.
  */
-export interface PlatformConfiguration {
+interface PlatformConfiguration {
   readonly shape: "platform";
   readonly id: string;
   readonly os: string;
@@ -97,7 +97,7 @@ export interface Analysis {
 }
 
 /** How findings are rendered. */
-export interface Reporters {
+interface Reporters {
   readonly formats: readonly Format[];
   readonly sort: Sort;
   readonly cascade: Cascade;
@@ -154,7 +154,7 @@ export type Provider =
     };
 
 /** The analyzers the orchestrator runs. */
-export interface Providers {
+interface Providers {
   readonly analyzers: readonly Provider[];
 }
 
@@ -293,7 +293,7 @@ export interface Inputs {
 }
 
 /** Which refusal a {@link ConfigError} carries. */
-export type ErrorKind =
+type ErrorKind =
   /**
    * A document that is not one JSON instance of the closed key list: a syntax
    * error, a value of the wrong type, a value outside the closed set a key

package/src/configuration-files.ts

@@ -69,11 +69,19 @@ export const RESOLVED_EXTENSIONS = [
   ".cjs",
 ] as const;
 
+/** The directory a package manager installs packages into, whose files are no project's own. */
+const MODULES_DIR = "node_modules";
+
 /** The file's name, the last segment of its path. */
 function basename(path: string): string {
   return path.slice(path.lastIndexOf("/") + 1);
 }
 
+/** Whether one path is the project's own: below the target root and in no `node_modules`. */
+function isProjectPath(root: string, path: string): boolean {
+  return relativePath(root, path)?.split("/").includes(MODULES_DIR) === false;
+}
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -92,6 +100,8 @@ export function isConfigurationDocumentName(name: string): boolean {
 interface ConfigurationDocument {
   /** The file, absolute. */
   readonly path: string;
+  /** The directories of the manifests whose dependencies the strings are read against. */
+  readonly manifestDirs: readonly string[];
   /** Every string value at any depth, in document order; a member's name is no value. */
   readonly strings: readonly string[];
 }
@@ -100,11 +110,169 @@ interface ConfigurationDocument {
 export type ParseFile = (fileName: string, text: string) => SourceFile;
 
 /** One file no program holds that a configuration module outside the program leads to. */
-export interface OutsideModule {
+interface OutsideModule {
   /** The file, parsed alone. */
   readonly file: SourceFile;
-  /** The directory of the configuration module the file was reached from, which holds its manifest. */
-  readonly manifestDir: string;
+  /** The directories of the manifests of the configuration files the file was reached from. */
+  readonly manifestDirs: readonly string[];
+}
+
+/** The flags a tool's command line names its configuration file with. */
+const CONFIG_FLAGS: ReadonlySet<string> = new Set(["--config", "-c"]);
+
+/** The extensions of a module a configuration flag may name. */
+const MODULE_EXTENSIONS = [".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"] as const;
+
+/** The characters that end a word outside quotes and separate nothing: blanks. */
+const BLANK = /[ \t\r\f\v]/u;
+
+/** The characters that end a word outside quotes and begin an operator: newline included. */
+const OPERATOR = /[\n;&|()<>]/u;
+
+/** The characters a backslash escapes inside double quotes; before any other it stands for itself. */
+const DOUBLE_QUOTE_ESCAPES = new Set(["$", "`", '"', "\\"]);
+
+/**
+ * The words of one command line, as POSIX token recognition reads quotes, backslashes,
+ * line continuations, comments and operators. A word an expansion may change (an unquoted
+ * `$`, backquote, glob character or leading `~`, or a `$` or backquote in double quotes)
+ * is computed, and so is the rest of a line whose quote is never closed. A computed word
+ * and each operator are undefined, so a flag's file is never read across them.
+ */
+function shellWords(command: string): readonly (string | undefined)[] {
+  const words: (string | undefined)[] = [];
+  let word: string | undefined;
+  let computed = false;
+  const end = (): void => {
+    if (word !== undefined) {
+      words.push(computed ? undefined : word);
+    }
+    word = undefined;
+    computed = false;
+  };
+  for (let at = 0; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === "\\" && command.charAt(at + 1) === "\n") {
+      at += 1;
+    } else if (BLANK.test(char)) {
+      end();
+    } else if (OPERATOR.test(char)) {
+      end();
+      words.push(undefined);
+    } else if (char === "#" && word === undefined) {
+      const newline = command.indexOf("\n", at);
+      at = newline < 0 ? command.length : newline - 1;
+    } else if (char === "\\") {
+      at += 1;
+      word = (word ?? "") + command.charAt(at);
+    } else if (char === "'" || char === '"') {
+      const close = closingQuote(command, at);
+      if (close < 0) {
+        word ??= "";
+        computed = true;
+        break;
+      }
+      const quoted =
+        char === "'"
+          ? { text: command.slice(at + 1, close), computed: false }
+          : doubleQuoted(command.slice(at + 1, close));
+      word = (word ?? "") + quoted.text;
+      computed ||= quoted.computed;
+      at = close;
+    } else {
+      computed ||= /[$`*?[]/u.test(char) || (char === "~" && word === undefined);
+      word = (word ?? "") + char;
+    }
+  }
+  end();
+  return words;
+}
+
+/** The text between one pair of double quotes, unescaped, and whether an expansion may change it. */
+function doubleQuoted(inner: string): { readonly text: string; readonly computed: boolean } {
+  let text = "";
+  let computed = false;
+  for (let at = 0; at < inner.length; at += 1) {
+    const char = inner.charAt(at);
+    const next = inner.charAt(at + 1);
+    if (char === "\\" && next === "\n") {
+      at += 1;
+    } else if (char === "\\" && DOUBLE_QUOTE_ESCAPES.has(next)) {
+      text += next;
+      at += 1;
+    } else {
+      computed ||= char === "$" || char === "`";
+      text += char;
+    }
+  }
+  return { text, computed };
+}
+
+/** The index of the quote that closes the one at `open`, or -1 where none does. */
+function closingQuote(command: string, open: number): number {
+  const quote = command.charAt(open);
+  for (let at = open + 1; at < command.length; at += 1) {
+    const char = command.charAt(at);
+    if (char === quote) {
+      return at;
+    }
+    if (quote === '"' && char === "\\") {
+      at += 1;
+    }
+  }
+  return -1;
+}
+
+/**
+ * The files the scripts of the manifest in one directory name after a configuration flag,
+ * `--config <file>`, `-c <file>` or `--config=<file>`, each a JSON file or a module below
+ * the target root and in no `node_modules`.
+ */
+function scriptConfigurations(host: Host, root: string, dir: string): readonly string[] {
+  let scripts: unknown;
+  try {
+    const manifest: unknown = JSON.parse(host.readFile(joinPath(dir, MANIFEST)));
+    scripts = isRecord(manifest) ? manifest["scripts"] : undefined;
+  } catch {
+    return [];
+  }
+  if (!isRecord(scripts)) {
+    return [];
+  }
+  const found: string[] = [];
+  for (const command of Object.values(scripts)) {
+    if (typeof command !== "string") {
+      continue;
+    }
+    const words = shellWords(command);
+    words.forEach((word, at) => {
+      const named =
+        word !== undefined && CONFIG_FLAGS.has(word)
+          ? words[at + 1]
+          : word === undefined
+            ? undefined
+            : /^--config=(.+)$/su.exec(word)?.[1];
+      const path = named === undefined ? undefined : resolvePath(dir, named);
+      if (
+        path !== undefined &&
+        [".json", ...MODULE_EXTENSIONS].some((extension) => path.endsWith(extension)) &&
+        isProjectPath(root, path) &&
+        host.kindOf(path) === "file"
+      ) {
+        found.push(path);
+      }
+    });
+  }
+  return found;
+}
+
+/** The decoded value of one JSON file, or undefined where it cannot be read or parsed. */
+function readDocument(host: Host, path: string): unknown {
+  try {
+    return JSON.parse(host.readFile(path)) as unknown;
+  } catch {
+    return undefined;
+  }
 }
 
 /** The configuration files one project holds and sits beside. */
@@ -117,7 +285,12 @@ interface ConfigurationFiles {
    * the program does not hold either, read where a parser is given.
    */
   readonly outside: readonly OutsideModule[];
-  /** Every JSON configuration file in a directory of the project's files or above one. */
+  /**
+   * Every JSON configuration file in a directory of the project's files or above one, every
+   * JSON file a script's configuration flag names, and every JSON file below the target
+   * root and in no `node_modules` a relative string of either names, read against each
+   * manifest whose chain reaches it.
+   */
   readonly documents: readonly ConfigurationDocument[];
 }
 
@@ -187,7 +360,8 @@ export function configurationFiles(
     }
   }
 
-  const documents: ConfigurationDocument[] = [];
+  const pending: { path: string; manifestDir: string }[] = [];
+  const named: { path: string; manifestDir: string }[] = [];
   for (const dir of [...dirs].sort()) {
     if (!holdsManifest(dir)) {
       continue;
@@ -200,24 +374,59 @@ export function configurationFiles(
         .map((entry) => entry.name)
         .sort();
     } catch {
+      names = [];
+    }
+    pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
+    for (const path of scriptConfigurations(host, root, dir)) {
+      const held = files.byName.get(path);
+      if (path.endsWith(".json")) {
+        pending.push({ path, manifestDir: dir });
+      } else if (held !== undefined) {
+        modules.push({ file: held, form: "a script's configuration flag" });
+      } else {
+        named.push({ path, manifestDir: dir });
+      }
+    }
+  }
+
+  // A document reached from two manifests is read against each, so a chain is keyed by both.
+  const documents = new Map<string, { path: string; manifestDirs: string[]; strings: string[] }>();
+  const unreadable = new Set<string>();
+  for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
+    let document = documents.get(next.path);
+    if (unreadable.has(next.path) || document?.manifestDirs.includes(next.manifestDir) === true) {
       continue;
     }
-    for (const name of names) {
-      const path = joinPath(dir, name);
-      let value: unknown;
-      try {
-        value = JSON.parse(host.readFile(path));
-      } catch {
+    if (document === undefined) {
+      const value = readDocument(host, next.path);
+      if (value === undefined) {
+        unreadable.add(next.path);
         continue;
       }
-      documents.push({ path, strings: documentStrings(value) });
+      document = { path: next.path, manifestDirs: [], strings: documentStrings(value) };
+      documents.set(next.path, document);
+    }
+    document.manifestDirs.push(next.manifestDir);
+    for (const text of document.strings) {
+      const path = RELATIVE_PREFIXES.some((prefix) => text.startsWith(prefix))
+        ? resolvePath(dirnamePath(next.path), text)
+        : undefined;
+      if (
+        path?.endsWith(".json") === true &&
+        isProjectPath(root, path) &&
+        host.kindOf(path) === "file"
+      ) {
+        pending.push({ path, manifestDir: next.manifestDir });
+      }
     }
   }
   return {
     modules,
-    documents,
+    documents: [...documents.values()],
     outside:
-      parse === undefined ? [] : outsideModules(host, [...dirs], files, holdsManifest, parse),
+      parse === undefined
+        ? []
+        : outsideModules(host, [...dirs], files, holdsManifest, parse, named),
   };
 }
 
@@ -280,8 +489,9 @@ function outsideModules(
   files: SourceFiles,
   holdsManifest: (dir: string) => boolean,
   parse: ParseFile,
+  named: readonly { readonly path: string; readonly manifestDir: string }[],
 ): readonly OutsideModule[] {
-  const pending: { path: string; manifestDir: string }[] = [];
+  const pending: { path: string; manifestDir: string }[] = [...named];
   for (const dir of [...dirs].sort()) {
     if (!holdsManifest(dir)) {
       continue;
@@ -298,29 +508,37 @@ function outsideModules(
     }
     pending.push(...names.map((name) => ({ path: joinPath(dir, name), manifestDir: dir })));
   }
-  const found: OutsideModule[] = [];
-  const seen = new Set<string>();
+  const found = new Map<string, { file: SourceFile; manifestDirs: string[] }>();
+  const unreadable = new Set<string>();
   for (let next = pending.shift(); next !== undefined; next = pending.shift()) {
-    if (seen.has(next.path) || files.byName.has(next.path)) {
+    let outside = found.get(next.path);
+    if (
+      unreadable.has(next.path) ||
+      files.byName.has(next.path) ||
+      outside?.manifestDirs.includes(next.manifestDir) === true
+    ) {
       continue;
     }
-    seen.add(next.path);
-    let text: string;
-    try {
-      text = host.readFile(next.path);
-    } catch {
-      continue;
+    if (outside === undefined) {
+      let text: string;
+      try {
+        text = host.readFile(next.path);
+      } catch {
+        unreadable.add(next.path);
+        continue;
+      }
+      outside = { file: parse(next.path, text), manifestDirs: [] };
+      found.set(next.path, outside);
     }
-    const file = parse(next.path, text);
-    found.push({ file, manifestDir: next.manifestDir });
-    for (const specifier of relativeSpecifiers(file)) {
+    outside.manifestDirs.push(next.manifestDir);
+    for (const specifier of relativeSpecifiers(outside.file)) {
       const reached = resolveRelativeSpecifier(host, dirnamePath(next.path), specifier);
       if (reached !== undefined) {
         pending.push({ path: reached, manifestDir: next.manifestDir });
       }
     }
   }
-  return found;
+  return [...found.values()];
 }
 
 /** Every dependency the manifest in one directory declares, or none where it holds none to read. */