@cplieger/deadset-ts 8.0.0-dev.12 → 8.0.0-dev.13

package/src/vendor/unbash/word.ts

@@ -0,0 +1,50 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import type { Word, WordPart } from "./internal-types.ts";
+import { unescapeBareValue, wordPartsValue } from "./word-value.ts";
+
+export type PartsResolver = (source: string, word: Word, depth: number) => WordPart[] | undefined;
+
+export class WordImpl implements Word {
+  type = "Word" as const;
+  text: string;
+  pos: number;
+  end: number;
+  #source: string | undefined;
+  #resolver: PartsResolver | undefined;
+  #depth: number;
+  #parts: WordPart[] | undefined | null;
+  #value: string | null = null;
+
+  constructor(text: string, pos: number, end: number, source?: string, resolver?: PartsResolver, depth = 0) {
+    this.text = text;
+    this.pos = pos;
+    this.end = end;
+    this.#source = source;
+    this.#resolver = resolver;
+    this.#depth = depth;
+    this.#parts = resolver === undefined ? undefined : null;
+  }
+
+  get value(): string {
+    if (this.#value === null) {
+      const parts = this.#source === undefined && this.#parts === null ? undefined : this.parts;
+      this.#value = parts ? wordPartsValue(parts) : unescapeBareValue(this.text);
+    }
+    return this.#value;
+  }
+
+  get parts(): WordPart[] | undefined {
+    if (this.#parts === null) {
+      this.#parts = this.#resolver?.(this.#source ?? "", this, this.#depth) ?? undefined;
+    }
+    return this.#parts;
+  }
+  set parts(v: WordPart[] | undefined) {
+    this.#parts = v ?? undefined;
+  }
+
+  toJSON() {
+    return { type: this.type, text: this.text, pos: this.pos, end: this.end, parts: this.parts, value: this.value };
+  }
+}

package/src/workflow-steps.ts

@@ -1,60 +1,60 @@
 /**
- * The source files a CI workflow's `run:` steps and the repository's git hooks name by their
- * path from the target root. A workflow or hook file is read as text, line by line, with no
- * YAML parsed.
+ * The command strings beside a target root's packages: a CI workflow's `run:` steps, the git
+ * hooks, the hook managers' commands and the makefile's recipe lines, each with the directory
+ * it runs in. A workflow or hook manager file is read by `text/yaml.ts`, and one it does not
+ * read gives no command; each command is read by `commands/read.ts`.
  */
 
 import type { SourceFile } from "@typescript/native/ast";
+import { pathsNamed, readCommands } from "./commands/read.ts";
 import type { Host } from "./host.ts";
-import { joinPath, relativePath, resolvePath } from "./paths.ts";
+import { isRecord } from "./json-document.ts";
+import { joinPath, 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";
+import { yamlDocument } from "./text/yaml.ts";
 
-/** One file a workflow step names. */
+/** One file a workflow step, git hook or recipe runs or names. */
 interface WorkflowEntry {
   readonly file: SourceFile;
-  /** The token that named it, as the command writes it. */
+  /** The word or the path that named it, as the command writes it. */
   readonly source: string;
 }
 
-const WORKFLOWS = ".github/workflows";
+/** One command string and the directory it runs in. */
+interface CommandString {
+  readonly text: string;
+  /**
+   * The directory it runs in, absolute, or `undefined` where the file does not state what runs
+   * where: a directory holding a `${{ }}` expression, which GitHub Actions evaluates.
+   */
+  readonly dir: string | undefined;
+  /** The directory the file writes for it, as YAML decodes it, which layer 3 holds beside the text. */
+  readonly writtenDirectory: string | undefined;
+}
 
-/** A line holding a run command: indentation and one sequence marker before `run:`. */
-const RUN_LINE = /^(\s*(?:- )?)run:(.*)$/u;
+const WORKFLOWS = ".github/workflows";
 
 /** 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;
+/** The key setting the directory a workflow step, or each step a `defaults.run` covers, runs in. */
+const WORKING_DIRECTORY = "working-directory";
 
-/** 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_FILES.map((name) => [name, RUN_LINE] as const),
+/**
+ * The hook manager files, each with the key its commands are written under and the key of their
+ * directory: lefthook's `root`, https://lefthook.dev/configuration/root/
+ */
+const HOOK_MANAGERS: readonly (readonly [string, string, string | undefined])[] = [
+  [".pre-commit-config.yaml", "entry", undefined],
+  ...["lefthook.yml", "lefthook.yaml", ".lefthook.yml"].map(
+    (name) => [name, "run", "root"] as const,
+  ),
 ];
 
 /** The names GNU make reads a makefile under, in the order it tries them. */
 const MAKEFILES = ["GNUmakefile", "makefile", "Makefile"] as const;
 
-const BLOCK_SCALAR = /^[|>][+-]?$/u;
-
-/** 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`, 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 {
   try {
     return host.readFile(path);
@@ -63,138 +63,150 @@ function readText(host: Host, path: string): string | undefined {
   }
 }
 
-/** 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[] = [];
-  for (let at = 0; at < lines.length; at += 1) {
-    const match = key.exec(lines[at] ?? "");
-    if (match === null) {
-      continue;
-    }
-    const column = (match[1] ?? "").length;
-    const value = unquoted((match[2] ?? "").trim());
-    if (!BLOCK_SCALAR.test(value)) {
-      found.push(value);
-      continue;
-    }
-    for (let next = at + 1; next < lines.length; next += 1) {
-      const line = lines[next] ?? "";
-      if (line.trim() !== "" && (INDENT.exec(line)?.[0].length ?? 0) <= column) {
-        break;
-      }
-      found.push(line);
-    }
-  }
-  return found;
+/** The text a YAML scalar's value stands for, or `undefined` for a collection or a null. */
+function scalarText(value: unknown): string | undefined {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+    ? String(value)
+    : undefined;
 }
 
-/**
- * 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 recipeLines(host: Host, root: string): readonly (readonly string[])[] {
-  const path = MAKEFILES.map((name) => joinPath(root, name)).find(
-    (candidate) => host.kindOf(candidate) === "file",
-  );
-  const text = path === undefined ? undefined : readText(host, path);
-  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, ""))));
+/** The `defaults.run.working-directory` one mapping writes, as YAML decodes it. */
+function defaultDirectory(mapping: Record<string, unknown>): string | undefined {
+  const defaults = mapping["defaults"];
+  const run = isRecord(defaults) ? defaults["run"] : undefined;
+  return isRecord(run) ? scalarText(run[WORKING_DIRECTORY]) : undefined;
 }
 
 /**
- * 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.
+ * Every command one workflow or hook manager file writes under `key`, in every mapping of the
+ * document, each with the directory it runs in: its mapping's `dirKey` value, else, in a workflow
+ * file, the innermost `defaults.run.working-directory` of a mapping holding it, else `root`. A
+ * file `yamlDocument` does not read gives none.
  */
-function recipeTokens(host: Host, root: string): readonly { token: string; dir: string }[] {
-  const found: { token: string; dir: string }[] = [];
-  for (const line of recipeLines(host, root)) {
-    let dir = root;
-    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)) {
-        dir = resolvePath(dir, target);
-        continue;
-      }
-      for (const token of tokens) {
-        found.push({ token, dir: relativePath(root, dir) ?? "" });
+function keyedCommands(
+  text: string,
+  root: string,
+  key: string,
+  dirKey: string | undefined,
+): readonly CommandString[] {
+  const found: CommandString[] = [];
+  const visit = (node: unknown, inherited: string | undefined): void => {
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        visit(item, inherited);
       }
+      return;
     }
-  }
+    if (!isRecord(node)) {
+      return;
+    }
+    const here = (dirKey === WORKING_DIRECTORY ? defaultDirectory(node) : undefined) ?? inherited;
+    const command = scalarText(node[key]);
+    if (command !== undefined && command.trim() !== "") {
+      const written = (dirKey === undefined ? undefined : scalarText(node[dirKey])) ?? here;
+      found.push({
+        text: command,
+        dir:
+          written === undefined
+            ? root
+            : written.includes("${{")
+              ? undefined
+              : resolvePath(root, written),
+        writtenDirectory: written,
+      });
+    }
+    for (const value of Object.values(node)) {
+      visit(value, here);
+    }
+  };
+  visit(yamlDocument(text), undefined);
   return found;
 }
 
+/** The path of each git hook script at `root`, every file in {@link HOOK_DIRS}. */
+function hookScripts(host: Host, root: string): readonly string[] {
+  return HOOK_DIRS.flatMap((dir) =>
+    filesIn(host, joinPath(root, dir), () => true).map((name) => joinPath(root, dir, name)),
+  );
+}
+
+/** The makefile make reads at `root`, the first of {@link MAKEFILES} there. */
+function makefileAt(host: Host, root: string): string | undefined {
+  return MAKEFILES.map((name) => joinPath(root, name)).find(
+    (candidate) => host.kindOf(candidate) === "file",
+  );
+}
+
 /**
- * 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.
+ * Each recipe line of the target root's makefile: a line that starts with a tab, joined with
+ * the lines a trailing `\` continues it onto, less the `@`, `-` and `+` make reads before it.
+ * Make runs each line in a shell of its own.
  */
-export function workflowCommands(host: Host, targetRoot: string): readonly string[] {
-  const root = resolvePath(host.workingDirectory(), targetRoot);
-  return [...stepCommands(host, root), ...recipeLines(host, root).flat()];
+function recipeLines(host: Host, root: string): readonly CommandString[] {
+  const path = makefileAt(host, root);
+  const text = path === undefined ? undefined : readText(host, path);
+  return (text ?? "")
+    .replace(/\\\r?\n/gu, " ")
+    .split(/\r?\n/u)
+    .filter((line) => line.startsWith("\t"))
+    .map((line) => ({
+      text: line.slice(1).replace(/^[@+-]+/u, ""),
+      dir: root,
+      writtenDirectory: undefined,
+    }));
 }
 
 /**
- * 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.
+ * Every command the target root's workflow steps, git hooks, hook managers and makefile run:
+ * the `run:` steps of the workflow files in `.github/workflows`, each file in `.husky` and
+ * `.githooks` as one shell script, the `entry:` commands of `.pre-commit-config.yaml`, the
+ * `run:` commands of a lefthook file and the makefile's recipe lines.
  */
-export function commandDirectories(host: Host, targetRoot: string): readonly string[] {
+export function workflowCommands(host: Host, targetRoot: string): readonly CommandString[] {
   const root = resolvePath(host.workingDirectory(), targetRoot);
+  const workflows = filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name));
   return [
-    ...workflowFiles(host, root).flatMap((path) =>
-      runCommands(readText(host, path) ?? "", WORKING_DIRECTORY),
+    ...workflows.flatMap((name) =>
+      keyedCommands(
+        readText(host, joinPath(root, WORKFLOWS, name)) ?? "",
+        root,
+        "run",
+        WORKING_DIRECTORY,
+      ),
     ),
-    ...LEFTHOOK_FILES.flatMap((name) =>
-      runCommands(readText(host, joinPath(root, name)) ?? "", LEFTHOOK_ROOT),
+    ...hookScripts(host, root).map((path): CommandString => ({
+      text: readText(host, path) ?? "",
+      dir: root,
+      writtenDirectory: undefined,
+    })),
+    ...HOOK_MANAGERS.flatMap(([name, key, dirKey]) =>
+      keyedCommands(readText(host, joinPath(root, name)) ?? "", root, key, dirKey),
     ),
+    ...recipeLines(host, 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[] {
+/**
+ * The whole text of each file {@link workflowCommands} reads a command from, each workflow file,
+ * git hook, hook manager file and makefile at the target root. Layer 3 holds it whole, so a part
+ * no command is read from, a comment included, or one the reading of the structure misses, still
+ * holds every file it names.
+ */
+export function commandFileTexts(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 workflowFiles(host, root)) {
-    commands.push(...runCommands(readText(host, path) ?? ""));
-  }
-  for (const dir of HOOK_DIRS) {
-    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;
+    ...filesIn(host, joinPath(root, WORKFLOWS), (name) => /\.ya?ml$/u.test(name)).map((name) =>
+      joinPath(root, WORKFLOWS, name),
+    ),
+    ...hookScripts(host, root),
+    ...HOOK_MANAGERS.map(([name]) => joinPath(root, name)),
+    ...[makefileAt(host, root) ?? []].flat(),
+  ].flatMap((path) => readText(host, path) ?? []);
 }
 
 /**
- * The own files the target root's workflow steps and git hooks name, as
- * {@link workflowTokens} reads them: a token equal to a file's path below the target root,
- * with or without a leading `./`, whatever directory the step runs in.
+ * The own files the target root's workflow steps, git hooks and recipes run or name, as
+ * `pathsNamed` reads each command.
  */
 export function workflowEntries(
   host: Host,
@@ -202,24 +214,11 @@ export function workflowEntries(
   files: SourceFiles,
 ): readonly WorkflowEntry[] {
   const found: WorkflowEntry[] = [];
-  for (const token of workflowTokens(host, targetRoot)) {
-    if (COMPUTED.test(token)) {
-      continue;
-    }
-    const file = files.byPath.get(token.startsWith("./") ? token.slice(2) : token);
-    if (file !== undefined) {
-      found.push({ file, source: token });
-    }
-  }
-  const root = resolvePath(host.workingDirectory(), targetRoot);
-  for (const { token, dir } of recipeTokens(host, root)) {
-    const below =
-      COMPUTED.test(token) || dir === ""
-        ? undefined
-        : relativePath(root, resolvePath(joinPath(root, dir), token));
-    const file = below === undefined ? undefined : files.byPath.get(below);
-    if (file !== undefined) {
-      found.push({ file, source: token });
+  for (const { text, dir } of workflowCommands(host, targetRoot)) {
+    for (const { path, written } of pathsNamed(readCommands(text, dir))) {
+      for (const file of files.named(path)) {
+        found.push({ file, source: written });
+      }
     }
   }
   return found;

package/dist/src/text/shell.js

@@ -1,159 +0,0 @@
-/**
- * Shell command lines read as text, never run: the commands a line runs, the tokens the
- * Contract splits a command into, and the words POSIX token recognition reads.
- */
-/**
- * The shell's list and pipeline operators, each of which ends one command. An `&` beside a
- * redirection's `<` or `>` (`2>&1`, and bash's `&>log`) is part of the redirection.
- */
-const COMMAND_OPERATORS = /&&|\|\||;|\||(?<![<>])&(?!>)/u;
-/** Where a command splits into tokens: white space and the operators the Contract names. */
-const TOKEN_SEPARATORS = /\s+|&&|\|\||;|\|/u;
-/** A text written inside one pair of quotes. */
-const QUOTED = /^(["'])(.*)\1$/su;
-/** The commands one line runs, the text between two of the shell's list and pipeline operators. */
-export function commandsOf(line) {
-    return line.split(COMMAND_OPERATORS);
-}
-/** One text with one pair of enclosing quotes removed. */
-export function unquoted(text) {
-    return text.replace(QUOTED, "$2");
-}
-/**
- * Every token one script's command line holds, each with one pair of enclosing quotes
- * removed. A token holding a wildcard is a pattern rather than a path, and names no
- * entry point.
- */
-export function scriptTokens(command) {
-    return command
-        .split(TOKEN_SEPARATORS)
-        .map(unquoted)
-        .filter((token) => token !== "" && !token.includes("*"));
-}
-/** One shell line up to its comment: a `#` that starts a word outside quotes. */
-export function withoutComment(line) {
-    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;
-}
-/** The characters that end a word outside quotes and separate nothing: blanks. */
-// Stryker disable next-line Regex: its \v to \V mutant is no valid escape under the u flag, so the whole module fails to parse
-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.
- */
-export function shellWords(command) {
-    const words = [];
-    let word;
-    let computed = false;
-    const end = () => {
-        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) {
-    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, open) {
-    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;
-}