@cplieger/deadset-ts 8.0.0-dev.6 → 8.0.0-dev.8

package/src/roots.ts

@@ -43,17 +43,19 @@ import {
 } from "./configuration-files.ts";
 import { conventionEntries, type Conventions } from "./conventions.ts";
 import { entryPoints, type EntryRule } from "./entry-points.ts";
-import { globExpression } from "./glob.ts";
 import type { Host } from "./host.ts";
 import { nodeKey, type Inventory, type InventorySymbol } from "./inventory.ts";
 import type { Manifest, ManifestEntry } from "./manifest.ts";
-import { dirnamePath, joinPath, relativePath, resolvePath } from "./paths.ts";
+import { ancestors, dirnamePath, relativePath, resolvePath } from "./paths.ts";
 import { byPosition } from "./position.ts";
 import { UNANSWERED } from "./query.ts";
 import type { ProjectView } from "./session.ts";
 import type { Symbol as TSSymbol, Type } from "@typescript/native/sync";
 import { sourceFilesOf, type SourceFiles } from "./source-files.ts";
 import { typeQueryAliases } from "./type-query-alias.ts";
+import { bytewise } from "./text/compare.ts";
+import { holdsManifest } from "./fs/manifest.ts";
+import { globExpression } from "./text/glob.ts";
 
 /** Why one declaration is a root. */
 export type RootKind =
@@ -197,15 +199,8 @@ const SOURCE_EXTENSION = /\.(?:d\.)?[cm]?[jt]sx?$/u;
 
 /** Whether no `package.json` sits between one file and the manifest's directory, which holds it. */
 function ofPackage(host: Host, dir: string, file: string): boolean {
-  for (let at = dirnamePath(file); at !== dir; at = dirnamePath(at)) {
-    if (
-      relativePath(dir, at) === undefined ||
-      host.kindOf(joinPath(at, "package.json")) === "file"
-    ) {
-      return false;
-    }
-  }
-  return true;
+  const between = ancestors(dirnamePath(file), dir);
+  return between.length > 0 && !between.slice(0, -1).some((at) => holdsManifest(host, at));
 }
 
 /**
@@ -331,14 +326,6 @@ export function matchRef(pattern: string, ref: string): boolean {
   return matchGlob(Array.from(pattern), Array.from(ref));
 }
 
-/** Two strings ordered bytewise, which is the order every set of a run is read in. */
-function compare(a: string, b: string): number {
-  if (a === b) {
-    return 0;
-  }
-  return a < b ? -1 : 1;
-}
-
 /** The members of one declaration, indexed by the container that holds them. */
 function childrenOf(held: Inventory): ReadonlyMap<string, readonly InventorySymbol[]> {
   const byParent = new Map<string, InventorySymbol[]>();
@@ -561,7 +548,7 @@ export function roots<Brand>(
     const left = sites.get(a.id);
     const right = sites.get(b.id);
     const site = left === undefined || right === undefined ? 0 : byPosition(left, right);
-    return site || compare(a.kind, b.kind) || compare(a.source, b.source);
+    return site || bytewise(a.kind, b.kind) || bytewise(a.source, b.source);
   });
 
   return {

package/src/run.ts

@@ -1,10 +1,13 @@
+import { CONFIG_MAX_BYTES, SETTINGS } from "./contract/config.generated.ts";
 import { EXIT_FAILURE, EXIT_USAGE } from "./contract/contract.generated.ts";
-import { ConfigError, REPOSITORY_DOCUMENT, type Inputs } from "./config.ts";
+import { REPOSITORY_DOCUMENT, type Document, type Inputs } from "./config.ts";
 import { DiscoveryError, renderDiagnostic } from "./discover.ts";
+import { readTargetDocument, TargetDocumentError } 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 { 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";
@@ -15,6 +18,7 @@ import { describeVerb } from "./verbs/describe.ts";
 import { EXPLAIN_OPTIONS, explainVerb } from "./verbs/explain.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 {
@@ -37,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
@@ -47,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>;
@@ -108,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, "");
@@ -118,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);
@@ -134,51 +117,54 @@ 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);
+  try {
+    const text = readTargetDocument(host, root, REPOSITORY_DOCUMENT, label);
+    return text === undefined ? undefined : { text, label };
+  } catch (error: unknown) {
+    throw error instanceof TargetDocumentError ? new UsageError(error.message) : error;
+  }
+}
+
+/**
+ * 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 }),
   };
 }
 
@@ -196,9 +182,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[],
@@ -209,9 +193,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;
   }
@@ -228,7 +210,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;
@@ -260,7 +242,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;
       },
@@ -273,8 +255,8 @@ function invoke(
 
 /** Turns one refusal into the exit code the Contract's table gives it. */
 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;
   }
@@ -282,7 +264,7 @@ function refuse(error: unknown, err: Writer): number {
     for (const diagnostic of error.diagnostics) {
       err.write(`${renderDiagnostic(diagnostic)}\n`);
     }
-    err.write(`deadset-ts: ${error.message}\n`);
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
   if (error instanceof SetupError) {
@@ -291,8 +273,8 @@ function refuse(error: unknown, err: Writer): number {
     }
     return EXIT_FAILURE;
   }
-  if (error instanceof ScopeError) {
-    err.write(`deadset-ts: ${error.message}\n`);
+  if (error instanceof ScopeError || error instanceof TargetDocumentError) {
+    diagnose(err, error.message);
     return EXIT_FAILURE;
   }
   throw error;