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

package/src/run.ts

@@ -1,9 +1,13 @@
-import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
-import { DiscoveryError, renderDiagnostic } from "./discover.ts";
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.ts";
+import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.ts";
+import { REPOSITORY_DOCUMENT, type Document, type Inputs } from "./config.ts";
+import { readTargetDocument } from "./fs/document.ts";
 import type { Host } from "./host.ts";
 import { joinPath, resolvePath } from "./paths.ts";
-import { readScope, ScopeError, scopeForDir, type Scope } from "./scope.ts";
-import { SetupError, setupLine } from "./setup-failure.ts";
+import { renderDiagnostic } from "./load/diagnostics.ts";
+import { FailureExit, failureLines, productFault } from "./failure.ts";
+import { readScope, scopeForDir, type Scope } from "./scope.ts";
+import { UsageError } from "./usage.ts";
 import { openEngine, type Engine, type EngineOptions } from "./session.ts";
 import { printConfigVerb } from "./verbs/print-config.ts";
 import { printProjectsVerb } from "./verbs/print-projects.ts";
@@ -12,8 +16,9 @@ import { printRootsVerb } from "./verbs/print-roots.ts";
 import { ANALYZE_OPTIONS, analyzeVerb } from "./verbs/analyze.ts";
 import { describeVerb } from "./verbs/describe.ts";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.ts";
-import { EXIT_FAILURE, EXIT_USAGE, type Verb, type VerbOptions } from "./verbs/verb.ts";
+import { type Verb, type VerbOptions } from "./verbs/verb.ts";
 import { versionVerb } from "./verbs/version.ts";
+import { diagnose, message, PRODUCT } from "./product.ts";
 
 /** One output stream of the command line. `process.stdout` and `process.stderr` satisfy it. */
 export interface Writer {
@@ -36,7 +41,7 @@ const VERBS: readonly {
   { name: "version", run: versionVerb },
 ];
 
-const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
+const USAGE = `usage: ${PRODUCT} <verb> [options]\nverbs: ${VERBS.map((verb) => verb.name).join(", ")}\n`;
 
 /**
  * The tokens whose presence in an option's name makes that option a request to
@@ -46,33 +51,16 @@ const USAGE = `usage: deadset-ts <verb> [options]\nverbs: ${VERBS.map((verb) =>
 const SOURCE_EDIT_TOKENS = ["fix", "edit", "delete", "rewrite"] as const;
 
 /**
- * Maps an option name to the setting of the Contract's configuration schema it supplies,
- * so one entry registers the option, supplies the document resolution reads, and gives
- * the spelling the setting's provenance names. The name is this command's vocabulary and
- * is never derived from the path: a setting reaches the command line only by an entry,
- * and a path names a key the schema declares.
+ * Maps an option name to the setting of the Contract's configuration schema it supplies:
+ * the options contract/settings.json names for a setting this analyzer reads.
  */
-export const SETTING_OPTIONS: ReadonlyMap<string, string> = new Map([
-  ["min-confidence", "analysis.min_confidence"],
-  ["sort", "reporters.sort"],
-  ["cascade", "reporters.cascade"],
-  ["max-findings", "reporters.max_findings"],
-  ["fail-on", "reporters.fail_on"],
-]);
+export const SETTING_OPTIONS: ReadonlyMap<string, string> = new Map(
+  SETTINGS.flatMap((row) => (row.option === undefined ? [] : [[row.option, row.key] as const])),
+);
 
 /** The options that take a value and are not settings. */
 const PLAIN_OPTIONS: ReadonlySet<string> = new Set(["target", "config", "central", "scope"]);
 
-/**
- * The setting options whose value is an integer rather than a string. A value
- * written other than as digits is passed on as the string it is, so resolution
- * refuses it by its type rather than reading `1e2` as 100.
- */
-const INTEGER_OPTIONS: ReadonlySet<string> = new Set(["max-findings"]);
-
-/** An integer as an option writes it: an optional minus sign and digits alone. */
-const INTEGER_TEXT = /^-?[0-9]+$/u;
-
 /** One invocation's options, by name: the last value of each, and every value of a repeatable one. */
 interface Options {
   readonly named: ReadonlyMap<string, string>;
@@ -107,7 +95,7 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
   const repeated = new Map<string, string[]>();
   for (const arg of args) {
     if (!arg.startsWith("-")) {
-      throw new ConfigError("malformed", "", `unexpected argument ${JSON.stringify(arg)}`);
+      throw new UsageError(`unexpected argument ${JSON.stringify(arg)}`);
     }
     const [spelled, ...rest] = arg.split("=");
     const name = (spelled ?? "").replace(/^-+/u, "");
@@ -117,14 +105,10 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
       !own.plain.includes(name) &&
       !own.repeatable.includes(name)
     ) {
-      throw new ConfigError("malformed", "", `unknown option ${JSON.stringify(spelled ?? arg)}`);
+      throw new UsageError(`unknown option ${JSON.stringify(spelled ?? arg)}`);
     }
     if (rest.length === 0) {
-      throw new ConfigError(
-        "malformed",
-        "",
-        `option ${JSON.stringify(spelled ?? arg)} takes a value`,
-      );
+      throw new UsageError(`option ${JSON.stringify(spelled ?? arg)} takes a value`);
     }
     const value = rest.join("=");
     named.set(name, value);
@@ -133,51 +117,56 @@ function readOptions(args: readonly string[], own: VerbOptions): Options {
   return { named, repeated };
 }
 
-function readFileOr(host: Host, path: string, orUndefined: boolean): string | undefined {
+/** The document an option names. */
+function documentAt(host: Host, label: string): Document {
   try {
-    return host.readFile(resolvePath(host.workingDirectory(), path));
+    const path = resolvePath(host.workingDirectory(), label);
+    // A file past the bound reads as one byte more than it, which resolution refuses.
+    return { text: host.readFile(path, CONFIG_MAX_BYTES + 1), label };
   } catch (error: unknown) {
-    if (orUndefined) {
-      return undefined;
-    }
-    throw new ConfigError(
-      "malformed",
-      "",
-      `${path}: ${error instanceof Error ? error.message : String(error)}`,
-    );
+    throw new UsageError(`${label}: ${message(error)}`);
   }
 }
 
 /**
- * The configuration documents one invocation reads: the repository configuration
- * at the target root or the path an option named, the central configuration, and
- * the settings the options supply as one flag document.
+ * The repository configuration at the target root, none where it is absent. One that
+ * cannot be read is a configuration document that cannot be, refused with the usage code.
+ */
+function repositoryAt(host: Host, target: string): Document | undefined {
+  const label = joinPath(target, REPOSITORY_DOCUMENT);
+  const root = resolvePath(host.workingDirectory(), target);
+  const text = readTargetDocument(
+    host,
+    root,
+    REPOSITORY_DOCUMENT,
+    label,
+    (named, reason) => new UsageError(`${named}: ${reason}`),
+  );
+  return text === undefined ? undefined : { text, label };
+}
+
+/**
+ * The configuration sources one invocation carries: the repository configuration at
+ * the target root or the path an option named, the central configuration, and the
+ * text each setting option was given.
  */
 function inputsOf(host: Host, options: Options): Inputs {
-  const target = options.named.get("target") ?? ".";
   const named = options.named.get("config");
-  const repositoryLabel = named ?? joinPath(target, REPOSITORY_DOCUMENT);
-  const repository = readFileOr(host, repositoryLabel, named === undefined);
+  const target = options.named.get("target") ?? ".";
+  const repository = named === undefined ? repositoryAt(host, target) : documentAt(host, named);
   const centralLabel = options.named.get("central");
-  const central = centralLabel === undefined ? undefined : readFileOr(host, centralLabel, false);
-
-  const flat: Record<string, unknown> = {};
-  const flagLabels = new Map<string, string>();
-  for (const [name, path] of SETTING_OPTIONS) {
+  const central = centralLabel === undefined ? undefined : documentAt(host, centralLabel);
+  const flags = new Map<string, string>();
+  for (const [name, key] of SETTING_OPTIONS) {
     const value = options.named.get(name);
-    if (value === undefined) {
-      continue;
+    if (value !== undefined) {
+      flags.set(key, value);
     }
-    flat[path] = INTEGER_OPTIONS.has(name) && INTEGER_TEXT.test(value) ? Number(value) : value;
-    flagLabels.set(path, `--${name}`);
   }
-  const flags = Object.keys(flat).length === 0 ? undefined : JSON.stringify(flat);
-
   return {
-    ...(flags === undefined ? {} : { flags }),
-    ...(repository === undefined ? {} : { repository, repositoryLabel }),
-    ...(central === undefined || centralLabel === undefined ? {} : { central, centralLabel }),
-    flagLabels,
+    flags,
+    ...(repository === undefined ? {} : { repository }),
+    ...(central === undefined ? {} : { central }),
   };
 }
 
@@ -195,9 +184,7 @@ function scopeOf(host: Host, options: Options): Scope {
  * the exit code: 0 for a completed verb, 1 for a finding that fails the run, 2 for a
  * usage error, a requested source edit or a refused configuration, 3 for a failure that
  * produced no answer. It writes nothing outside `out` and `err` and never exits the
- * process. `host` is the platform the run reads, the version it reports included, and
- * `openClient` opens the compiler client; a caller that watches what a run reads
- * supplies its own of either.
+ * process. A caller that watches what a run reads supplies its own `host` or `openClient`.
  */
 export function run(
   args: readonly string[],
@@ -208,9 +195,7 @@ export function run(
 ): number {
   const editing = sourceEditOption(args);
   if (editing !== undefined) {
-    err.write(
-      `deadset-ts: ${editing} is not supported: deadset-ts reports and never edits a source file\n`,
-    );
+    diagnose(err, `${editing} is not supported: ${PRODUCT} reports and never edits a source file`);
     err.write(USAGE);
     return EXIT_USAGE;
   }
@@ -227,7 +212,7 @@ export function run(
     );
   }
   if (name !== undefined) {
-    err.write(`deadset-ts: unknown verb ${JSON.stringify(name)}\n`);
+    diagnose(err, `unknown verb ${JSON.stringify(name)}`);
   }
   err.write(USAGE);
   return EXIT_USAGE;
@@ -259,7 +244,7 @@ function invoke(
       openClient: (config) => {
         opened = openClient({
           collectTiming: false,
-          components: { extensions: config.ts.componentExtensions, host: streams.host },
+          components: { extensions: config.ts.component_extensions, host: streams.host },
         });
         return opened;
       },
@@ -270,29 +255,28 @@ function invoke(
   }
 }
 
-/** Turns one refusal into the exit code the Contract's table gives it. */
+/**
+ * Turns one refusal into the exit code the Contract's table gives it. An error no class names
+ * is a fault of this analyzer, printed with its stack for the maintainers it asks the user to
+ * report it to.
+ */
 function refuse(error: unknown, err: Writer): number {
-  if (error instanceof ConfigError) {
-    err.write(`deadset-ts: ${error.message}\n`);
+  if (error instanceof UsageError) {
+    diagnose(err, error.message);
     err.write(USAGE);
     return EXIT_USAGE;
   }
-  if (error instanceof DiscoveryError) {
-    for (const diagnostic of error.diagnostics) {
-      err.write(`${renderDiagnostic(diagnostic)}\n`);
+  if (!(error instanceof FailureExit)) {
+    if (error instanceof Error && error.stack !== undefined) {
+      err.write(`${error.stack}\n`);
     }
-    err.write(`deadset-ts: ${error.message}\n`);
-    return EXIT_FAILURE;
+    return refuse(productFault(`meets an error none of its classes names: ${message(error)}`), err);
   }
-  if (error instanceof SetupError) {
-    for (const failure of error.failures) {
-      err.write(`${setupLine(failure)}\n`);
-    }
-    return EXIT_FAILURE;
+  for (const diagnostic of error.diagnostics) {
+    err.write(`${renderDiagnostic(diagnostic)}\n`);
   }
-  if (error instanceof ScopeError) {
-    err.write(`deadset-ts: ${error.message}\n`);
-    return EXIT_FAILURE;
+  for (const line of failureLines(error.failures)) {
+    err.write(`${line}\n`);
   }
-  throw error;
+  return EXIT_FAILURE;
 }