@cplieger/deadset-ts 8.0.0-dev.1 → 8.0.0-dev.11

package/src/verbs/print-projects.ts

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runProjects } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
-import { resolveUnkinded } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { resolvePartial } from "../resolve.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes the name of every project one run analyzes, one per line: the identifier the
@@ -12,7 +14,7 @@ import { EXIT_CLEAN, type Verb } from "./verb.ts";
  * instead, and one that fails the analysis fails this command the same way.
  */
 export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
-  const config = resolveUnkinded(inputs());
+  const config = resolvePartial(inputs());
   const scoped = scope();
   const answer = runProjects(openClient(config), host, scoped, config);
   for (const id of answer.configurations) {
@@ -23,7 +25,7 @@ export const printProjectsVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-retained.ts

@@ -1,9 +1,11 @@
+import { EXIT_CLEAN } from "../contract/contract.generated.ts";
 import { runSweep } from "../analysis.ts";
 import { retainedLines } from "../exempt.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * Writes every declaration an exemption held back in the production sweep a report is
@@ -27,7 +29,7 @@ export const printRetainedVerb: Verb = ({ out, err, host, inputs, scope, openCli
     unanswered: swept.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return EXIT_CLEAN;
 };

package/src/verbs/print-roots.ts

@@ -1,8 +1,10 @@
+import { EXIT_CLEAN, EXIT_FINDINGS } from "../contract/contract.generated.ts";
 import { runRoots, type RunRoot } from "../analysis.ts";
 import { partialNotes } from "../partial.ts";
 import { resolvePath } from "../paths.ts";
 import { resolve } from "../resolve.ts";
-import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
+import { type Verb } from "./verb.ts";
+import { diagnose } from "../product.ts";
 
 /**
  * One root as a line: the declaration's reference, why it is a root, and the string
@@ -41,7 +43,7 @@ export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient
     unanswered: answer.unanswered,
     targetRoot: resolvePath(host.workingDirectory(), scoped.target.path),
   })) {
-    err.write(`deadset-ts: ${note}\n`);
+    diagnose(err, note);
   }
   return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
 };

package/src/verbs/verb.ts

@@ -1,15 +1,9 @@
-import type { Config, Inputs } from "../config.ts";
+import type { Inputs, PartialConfig } from "../config.ts";
 import type { Host } from "../host.ts";
 import type { Writer } from "../run.ts";
 import type { Scope } from "../scope.ts";
 import type { Engine } from "../session.ts";
 
-/** The exit codes the Contract's exit-code table names. */
-export const EXIT_CLEAN = 0;
-export const EXIT_FINDINGS = 1;
-export const EXIT_USAGE = 2;
-export const EXIT_FAILURE = 3;
-
 /**
  * What one verb is handed: the streams it writes, the platform it reads, and the
  * options that follow its name, read only when the verb asks for what they name, so
@@ -27,7 +21,7 @@ interface Invocation {
    * Opens the compiler client for a run under `config`. A client the verb opened is
    * closed if the verb throws.
    */
-  readonly openClient: (config: Config) => Engine;
+  readonly openClient: (config: PartialConfig) => Engine;
   /** The arguments after the verb's name, as written. */
   readonly args: readonly string[];
   /** The last value one of the verb's own options was given, undefined where none was. */

package/src/verbs/version.ts

@@ -1,8 +1,20 @@
-import { CONTRACT_VERSION } from "../version.ts";
-import { EXIT_CLEAN, type Verb } from "./verb.ts";
+import { CONTRACT_VERSION, EXIT_CLEAN } from "../contract/contract.generated.ts";
+import { productFault } from "../failure.ts";
+import type { Host } from "../host.ts";
+import { type Verb } from "./verb.ts";
+import { message, PRODUCT } from "../product.ts";
+
+/** The version the host reports for this analyzer; one it cannot read is a fault of the analyzer. */
+export function ownVersion(host: Host): string {
+  try {
+    return host.analyzerVersion();
+  } catch (error: unknown) {
+    throw productFault(`cannot read its own version: ${message(error)}`);
+  }
+}
 
 /** Writes the version the host reports and the Contract version this analyzer implements. */
 export const versionVerb: Verb = ({ out, host }) => {
-  out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+  out.write(`${PRODUCT} ${ownVersion(host)}\ncontract ${CONTRACT_VERSION}\n`);
   return EXIT_CLEAN;
 };

package/src/workflow-steps.ts

@@ -6,9 +6,10 @@
 
 import type { SourceFile } from "@typescript/native/ast";
 import type { Host } from "./host.ts";
-import { scriptTokens } from "./manifest.ts";
 import { joinPath, relativePath, resolvePath } from "./paths.ts";
 import type { SourceFiles } from "./source-files.ts";
+import { filesIn } from "./fs/tree.ts";
+import { commandsOf, scriptTokens, unquoted, withoutComment } from "./text/shell.ts";
 
 /** One file a workflow step names. */
 interface WorkflowEntry {
@@ -25,41 +26,33 @@ const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
 /** The directories whose every file is a git hook script, run as the shell runs it. */
 const HOOK_DIRS = [".husky", ".githooks"] as const;
 
+/** A line setting the directory a workflow step, or each step a `defaults.run` covers, runs in. */
+const WORKING_DIRECTORY = /^(\s*(?:- )?)working-directory:(.*)$/u;
+
+const LEFTHOOK_FILES = ["lefthook.yml", "lefthook.yaml", ".lefthook.yml"] as const;
+
+/** A line setting the directory a lefthook command runs in. */
+const LEFTHOOK_ROOT = /^(\s*(?:- )?)root:(.*)$/u;
+
 /** The hook manager files whose commands are written under a key, with that key. */
 const HOOK_MANAGERS: readonly (readonly [string, RegExp])[] = [
   [".pre-commit-config.yaml", /^(\s*(?:- )?)entry:(.*)$/u],
-  ["lefthook.yml", RUN_LINE],
-  ["lefthook.yaml", RUN_LINE],
-  [".lefthook.yml", RUN_LINE],
+  ...LEFTHOOK_FILES.map((name) => [name, RUN_LINE] as const),
 ];
 
 /** The names GNU make reads a makefile under, in the order it tries them. */
 const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"] as const;
 
-/** The operators that end one shell command of a recipe line. */
-const COMMAND_SEPARATORS = /&&|\|\||;|\|/u;
-
 const BLOCK_SCALAR = /^[|>][+-]?$/u;
 
-const QUOTED = /^(["'])(.*)\1$/su;
-
 /** A token holding one of these is computed or a pattern, so it names no file. */
 const COMPUTED = /[${*?[]/u;
 
 const INDENT = /^\s*/u;
 
-/** The files directly in one directory whose name `accepts`, in name order. */
-function filesIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
-  let entries;
-  try {
-    entries = host.readDirectory(dir);
-  } catch {
-    return [];
-  }
-  return entries
-    .filter((entry) => !entry.directory && accepts(entry.name))
-    .map((entry) => joinPath(dir, entry.name))
-    .sort();
+/** The files directly in one directory whose name `accepts`, by path in name order. */
+function pathsIn(host: Host, dir: string, accepts: (name: string) => boolean): readonly string[] {
+  return filesIn(host, dir, accepts).map((name) => joinPath(dir, name));
 }
 
 function readText(host: Host, path: string): string | undefined {
@@ -70,7 +63,7 @@ function readText(host: Host, path: string): string | undefined {
   }
 }
 
-/** Every command line one workflow file's `run:` steps, or the steps under `key`, hold. */
+/** Every line one workflow file's `run:` steps hold, or every line of the values written under `key`. */
 export function runCommands(text: string, key: RegExp = RUN_LINE): readonly string[] {
   const lines = text.split(/\r?\n/u);
   const found: string[] = [];
@@ -80,7 +73,7 @@ export function runCommands(text: string, key: RegExp = RUN_LINE): readonly stri
       continue;
     }
     const column = (match[1] ?? "").length;
-    const value = (match[2] ?? "").trim().replace(QUOTED, "$2");
+    const value = unquoted((match[2] ?? "").trim());
     if (!BLOCK_SCALAR.test(value)) {
       found.push(value);
       continue;
@@ -97,12 +90,11 @@ export function runCommands(text: string, key: RegExp = RUN_LINE): readonly stri
 }
 
 /**
- * Every token the recipe lines of the target root's makefile hold, each with the directory
- * below the root it is read against: a recipe line is one that starts with a tab, joined
- * with the lines a trailing `\` continues it onto, and make runs each in a shell of its
- * own, so a `cd` moves the directory of the later commands of its line alone.
+ * The commands of the recipe lines of the target root's makefile, each line's in order: a
+ * recipe line is one that starts with a tab, joined with the lines a trailing `\`
+ * continues it onto.
  */
-function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
+function recipeLines(host: Host, root: string): readonly (readonly string[])[] {
   const path = MAKEFILES.map((name) => joinPath(root, name)).find(
     (candidate) => host.kindOf(candidate) === "file",
   );
@@ -110,15 +102,23 @@ function recipeTokens(host: Host, root: string): readonly { token: string; dir:
   if (text === undefined) {
     return [];
   }
+  return text
+    .replace(/\\\r?\n/gu, " ")
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith("\t"))
+    .map((line) => commandsOf(withoutComment(line.slice(1).replace(/^[@+-]+/u, ""))));
+}
+
+/**
+ * Every token the recipe lines of the target root's makefile hold, each with the directory
+ * below the root it is read against: make runs each line in a shell of its own, so a `cd`
+ * moves the directory of the later commands of its line alone.
+ */
+function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
   const found: { token: string; dir: string }[] = [];
-  for (const line of text.replace(/\\\r?\n/gu, " ").split(/\r?\n/u)) {
-    if (!line.startsWith("\t")) {
-      continue;
-    }
+  for (const line of recipeLines(host, root)) {
     let dir = root;
-    for (const command of withoutComment(line.slice(1).replace(/^[@+-]+/u, "")).split(
-      COMMAND_SEPARATORS,
-    )) {
+    for (const command of line) {
       const tokens = scriptTokens(command);
       const [first, target, ...rest] = tokens;
       if (first === "cd" && target !== undefined && rest.length === 0 && !COMPUTED.test(target)) {
@@ -133,52 +133,62 @@ function recipeTokens(host: Host, root: string): readonly { token: string; dir:
   return found;
 }
 
-/** One shell line up to its comment: a `#` that starts a word outside quotes. */
-function withoutComment(line: string): string {
-  let quote = "";
-  for (let at = 0; at < line.length; at += 1) {
-    const char = line[at];
-    if (quote !== "") {
-      if (char === quote) {
-        quote = "";
-      } else if (char === "\\" && quote === '"') {
-        at += 1;
-      }
-    } else if (char === "'" || char === '"') {
-      quote = char;
-    } else if (char === "\\") {
-      at += 1;
-    } else if (char === "#" && (at === 0 || /\s/u.test(line[at - 1] ?? ""))) {
-      return line.slice(0, at);
-    }
-  }
-  return line;
-}
-
 /**
- * Every token the target root's workflow steps, git hooks and makefile hold: the `run:`
+ * Every command the target root's workflow steps, git hooks and makefile run: the `run:`
  * steps of the workflow files in `.github/workflows`, every line of each file in `.husky`
  * and `.githooks`, the `entry:` commands of `.pre-commit-config.yaml`, the `run:` commands
  * of a lefthook file and the makefile's recipe lines.
  */
+export function workflowCommands(host: Host, targetRoot: string): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+}
+
+/**
+ * Every directory the target root's workflow steps and lefthook commands are set to run in, as
+ * written: each `working-directory` of a workflow file and each `root` of a lefthook file.
+ */
+export function commandDirectories(host: Host, targetRoot: string): readonly string[] {
+  const root = resolvePath(host.workingDirectory(), targetRoot);
+  return [
+    ...workflowFiles(host, root).flatMap((path) =>
+      runCommands(readText(host, path) ?? "", WORKING_DIRECTORY),
+    ),
+    ...LEFTHOOK_FILES.flatMap((name) =>
+      runCommands(readText(host, joinPath(root, name)) ?? "", LEFTHOOK_ROOT),
+    ),
+  ];
+}
+
+/** The workflow files in `.github/workflows` at one root, by path in name order. */
+function workflowFiles(host: Host, root: string): readonly string[] {
+  return pathsIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name));
+}
+
+/** Every token the commands {@link workflowCommands} reads hold. */
 export function workflowTokens(host: Host, targetRoot: string): readonly string[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
+  return [
+    ...stepCommands(host, root).flatMap((command) => scriptTokens(command)),
+    ...recipeTokens(host, root).map(({ token }) => token),
+  ];
+}
+
+/** The commands of the workflow steps, git hooks and hook managers at one root. */
+function stepCommands(host: Host, root: string): readonly string[] {
   const commands: string[] = [];
-  for (const path of filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name))) {
+  for (const path of workflowFiles(host, root)) {
     commands.push(...runCommands(readText(host, path) ?? ""));
   }
   for (const dir of HOOK_DIRS) {
-    for (const path of filesIn(host, joinPath(root, dir), () => true)) {
+    for (const path of pathsIn(host, joinPath(root, dir), () => true)) {
       commands.push(...(readText(host, path) ?? "").split(/\r?\n/u).map(withoutComment));
     }
   }
   for (const [name, key] of HOOK_MANAGERS) {
     commands.push(...runCommands(readText(host, joinPath(root, name)) ?? "", key));
   }
-  return [
-    ...commands.flatMap((command) => scriptTokens(command)),
-    ...recipeTokens(host, root).map(({ token }) => token),
-  ];
+  return commands;
 }
 
 /**

package/dist/src/base-url.js

@@ -1,18 +0,0 @@
-import { resolvePath } from "./paths.js";
-/**
- * The `paths` one configuration's resolved options map under the compilers before version
- * 7, each target absolute: a target is read against the effective `baseUrl`, and a specifier
- * no other pattern maps is looked up below it. Undefined where no `baseUrl` is set, so the
- * options' own `paths` stand. Version 7 reads no `baseUrl`:
- * https://github.com/microsoft/TypeScript/issues/62207
- */
-export function baseUrlPaths(options) {
-    const baseUrl = Reflect.get(options, "baseUrl");
-    if (typeof baseUrl !== "string") {
-        return undefined;
-    }
-    return Object.fromEntries(Object.entries({ "*": ["*"], ...options.paths }).map(([key, targets]) => [
-        key,
-        targets.map((target) => resolvePath(baseUrl, target)),
-    ]));
-}