@cplieger/deadset-ts 8.0.0-dev.7 → 8.0.0-dev.9

package/src/fs/document.ts

@@ -0,0 +1,70 @@
+/**
+ * The one read of a document the target holds at its root, which a checkout under analysis
+ * controls: the repository configuration, the ignore file, the baseline and the edges
+ * document. The read stays inside the target root, takes a regular file alone, and holds no
+ * more of it than the Contract's document bound.
+ */
+
+import { CONFIG_MAX_BYTES } from "../contract/config.generated.ts";
+import type { Host } from "../host.ts";
+import { failureExit } from "../failure.ts";
+import { joinPath, relativePath } from "../paths.ts";
+import { message } from "../product.ts";
+import { utf8Bytes } from "../reporters/sha256.ts";
+import { UsageError } from "../usage.ts";
+
+function unreadable(label: string, reason: string): Error {
+  return failureExit(
+    "unreadable-document",
+    `${label}: ${reason}: make it a regular file inside the target root that the run can read, or remove it`,
+  );
+}
+
+/** Refuses a document past the Contract's bound with the usage code, naming it `label`. */
+export function refuseOverBound(label: string, text: string): void {
+  if (utf8Bytes(text).length > CONFIG_MAX_BYTES) {
+    throw new UsageError(`${label}: holds more than ${String(CONFIG_MAX_BYTES)} bytes`);
+  }
+}
+
+/**
+ * The text of the document `name` at the absolute `targetRoot`, undefined where nothing is
+ * there. One whose name resolves outside the target root or to anything but a regular file,
+ * or whose read fails, is refused by `refuse` naming it `label`, nothing read from it. A
+ * document past the bound is read one byte past it and refused as {@link refuseOverBound} does.
+ */
+export function readTargetDocument(
+  host: Host,
+  targetRoot: string,
+  name: string,
+  label = name,
+  refuse: (label: string, reason: string) => Error = unreadable,
+): string | undefined {
+  const attempt = <T>(read: () => T): T => {
+    try {
+      return read();
+    } catch (error: unknown) {
+      throw refuse(label, message(error));
+    }
+  };
+  const path = joinPath(targetRoot, name);
+  const kind = attempt(() => host.kindOf(path));
+  if (kind === "absent") {
+    return undefined;
+  }
+  const real = attempt(() => host.realPath(path));
+  if (
+    relativePath(
+      attempt(() => host.realPath(targetRoot)),
+      real,
+    ) === undefined
+  ) {
+    throw refuse(label, `resolves to ${real}, outside the target root`);
+  }
+  if (kind !== "file") {
+    throw refuse(label, "is not a regular file");
+  }
+  const text = attempt(() => host.readFile(real, CONFIG_MAX_BYTES + 1));
+  refuseOverBound(label, text);
+  return text;
+}

package/src/fs/manifest.ts

@@ -8,6 +8,14 @@ export const MANIFEST = "package.json";
 /** The directory a package manager installs packages into, whose files are no project's own. */
 export const INSTALLED_PACKAGES = "node_modules";
 
+/** The manifest members a package declares the packages it depends on under. */
+export const DEPENDENCY_SECTIONS = [
+  "dependencies",
+  "devDependencies",
+  "peerDependencies",
+  "optionalDependencies",
+] as const;
+
 /** Whether one path passes through an installed-packages directory. */
 export function inInstalledPackages(path: string): boolean {
   return path.split("/").includes(INSTALLED_PACKAGES);

package/src/host.ts

@@ -1,5 +1,5 @@
-/** What one path names. */
-export type PathKind = "file" | "directory" | "absent";
+/** What one path names: `"other"` is anything else there, a named pipe, a device or a socket. */
+export type PathKind = "file" | "directory" | "other" | "absent";
 
 /** One entry of a directory. */
 export interface DirectoryEntry {
@@ -17,11 +17,18 @@ export interface DirectoryEntry {
 export interface Host {
   /** The directory a relative path resolves against. */
   workingDirectory(): string;
-  /** The text of one file, or a throw naming why it cannot be read. */
-  readFile(path: string): string;
+  /**
+   * The text of one file, or a throw naming why it cannot be read. Given `limit`, the
+   * text of no more than the file's first `limit` bytes, so a caller bounding a document
+   * asks for one byte past its bound and never holds a larger file whole.
+   */
+  readFile(path: string, limit?: number): string;
   /** The entries of one directory, or a throw naming why it cannot be read. */
   readDirectory(path: string): readonly DirectoryEntry[];
-  /** What one path names, `"absent"` where nothing is there. */
+  /**
+   * What one path names once every symbolic link along it is followed, `"absent"` where
+   * nothing is there, or a throw naming why it cannot be known, as for a link loop.
+   */
   kindOf(path: string): PathKind;
   /**
    * The path one path names once every symbolic link along it is followed, or a throw

package/src/injection-container.ts

@@ -53,7 +53,7 @@ function isInjected(node: Node): boolean {
 /** The classes of the target a call whose callee an entry names passes, with that call's entry. */
 function registrations<Brand>(input: DetectorInput<Brand>): readonly Registration[] {
   const { project, held } = input;
-  const resolved = resolveEntries(project, held, input.ts.injectionRegistrations);
+  const resolved = resolveEntries(project, held, input.ts.injection_registrations);
   if (!resolved.some(namesADeclaration)) {
     return [];
   }

package/src/json-document.ts

@@ -1,122 +1,276 @@
+import type { Position } from "./position.ts";
+
+/** A place inside a document: each member name a string, each array index a number. */
+export type Place = readonly (string | number)[];
+
 /**
- * A read of a strict JSON document beside its parse: what a parse into a value cannot
- * report, the offset of each record of one array and a member written twice.
+ * A text that is not one strict JSON document: a syntax error, data after the value, a
+ * member one object writes twice, or nesting past {@link MAX_DEPTH}. `place` is the
+ * value the fault is in, followed by the member written twice.
  */
+export class StrictJSONError extends Error {
+  readonly offset: number;
+  readonly place: Place;
 
-import type { Position } from "./position.ts";
+  constructor(reason: string, offset: number, place: Place) {
+    super(reason);
+    this.name = "StrictJSONError";
+    this.offset = offset;
+    this.place = place;
+  }
+}
 
-/** The token walk over a document `JSON.parse` accepted, so every token is well formed. */
-class Walk {
-  readonly starts: number[] = [];
-  /** The member written twice, where one is, as the offset of its name. */
-  twice: { readonly name: string; readonly offset: number } | undefined;
-  private readonly text: string;
-  private readonly array: string;
+/** One strict JSON document, read whole. */
+interface StrictDocument {
+  readonly value: unknown;
+  /**
+   * The text of every number written with a fraction or an exponent, by its JSON
+   * Pointer: a value reads `100.0` as the integer 100, so only the text tells them apart.
+   */
+  readonly fractions: ReadonlyMap<string, string>;
+  /**
+   * The offset of each value inside the top-level member a read names, by its index or
+   * its member name, in document order.
+   */
+  readonly starts: ReadonlyMap<string | number, number>;
+}
+
+/**
+ * How deep values may nest. A document this analyzer reads nests a few levels, and a
+ * bound turns a document built to exhaust the stack into a refusal.
+ */
+const MAX_DEPTH = 1000;
+
+const SPACE = /[ \t\n\r]*/uy;
+const STRING =
+  /"(?:[ !#$%&'()*+,\-./0-9:;<=>?@A-Z[\]-\u{10FFFF}]|\\(?:["\\/bfnrt]|u[0-9A-Fa-f]{4}))*"/uy;
+const NUMBER = /-?(?:0|[1-9][0-9]*)(\.[0-9]+)?([eE][+-]?[0-9]+)?/uy;
+const LITERALS: ReadonlyMap<string, unknown> = new Map<string, unknown>([
+  ["true", true],
+  ["false", false],
+  ["null", null],
+]);
+
+/** One member name spelled as a JSON Pointer token. */
+const escaped = (name: string): string => name.replaceAll("~", "~0").replaceAll("/", "~1");
+
+/** The member names and indexes a JSON Pointer holds, unescaped. */
+export function pointerSegments(pointer: string): string[] {
+  return pointer === ""
+    ? []
+    : pointer
+        .slice(1)
+        .split("/")
+        .map((token) => token.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+
+/** The JSON Pointer of a place written as segments. */
+export function pointerOf(segments: readonly string[]): string {
+  return segments.map((segment) => `/${escaped(segment)}`).join("");
+}
+
+/**
+ * The place a JSON Pointer names inside `value`, followed by `member` where it is not
+ * empty: a pointer's text does not say whether a segment of digits is an index, so the
+ * value it points into does.
+ */
+export function placeIn(value: unknown, pointer: string, member = ""): (string | number)[] {
+  const place: (string | number)[] = [];
+  let held = value;
+  for (const segment of pointerSegments(pointer)) {
+    if (Array.isArray(held)) {
+      place.push(Number(segment));
+      held = held[Number(segment)];
+    } else {
+      place.push(segment);
+      held = isRecord(held) ? held[segment] : undefined;
+    }
+  }
+  return member === "" ? place : [...place, member];
+}
+
+/**
+ * A place as a refusal names it: member names joined by full stops and an index in
+ * square brackets, as `ts.serializers[0].returns`.
+ */
+export function dotted(place: Place): string {
+  let path = "";
+  for (const segment of place) {
+    path +=
+      typeof segment === "number" ? `[${String(segment)}]` : path === "" ? segment : `.${segment}`;
+  }
+  return path;
+}
+
+class Reader {
   private at = 0;
+  private readonly path: (string | number)[] = [];
+  readonly fractions = new Map<string, string>();
+  readonly starts = new Map<string | number, number>();
+  private readonly text: string;
+  private readonly records: string | undefined;
 
-  constructor(text: string, array: string) {
+  constructor(text: string, records: string | undefined) {
     this.text = text;
-    this.array = array;
+    this.records = records;
   }
 
-  run(): void {
-    this.value("document");
+  read(): unknown {
+    const value = this.value(0);
+    this.match(SPACE);
+    if (this.at < this.text.length) {
+      this.fail("data follows the document's value");
+    }
+    return value;
   }
 
-  private skip(): void {
-    while (/[ \t\r\n]/u.test(this.text[this.at] ?? "")) {
-      this.at += 1;
-    }
+  private fail(reason: string, offset = this.at, member = ""): never {
+    throw new StrictJSONError(
+      reason,
+      offset,
+      member === "" ? [...this.path] : [...this.path, member],
+    );
   }
 
-  private string(): string {
-    const start = this.at;
-    this.at += 1;
-    while (this.text[this.at] !== '"') {
-      this.at += this.text[this.at] === "\\" ? 2 : 1;
+  private match(pattern: RegExp): string | undefined {
+    pattern.lastIndex = this.at;
+    const found = pattern.exec(this.text)?.[0];
+    this.at = found === undefined ? this.at : pattern.lastIndex;
+    return found;
+  }
+
+  private expect(char: string, what: string): void {
+    this.match(SPACE);
+    if (this.text[this.at] !== char) {
+      this.fail(`${what} is expected`);
     }
     this.at += 1;
-    return JSON.parse(this.text.slice(start, this.at)) as string;
   }
 
-  private value(role: "document" | "array" | "record" | "other"): void {
-    this.skip();
-    if (role === "record") {
-      this.starts.push(this.at);
+  private value(depth: number): unknown {
+    this.match(SPACE);
+    if (depth > MAX_DEPTH) {
+      this.fail(`values nest deeper than ${String(MAX_DEPTH)} levels`);
     }
     const char = this.text[this.at];
     if (char === "{") {
-      this.object(role);
-    } else if (char === "[") {
-      this.list(role === "array" ? "record" : "other");
-    } else if (char === '"') {
-      this.string();
-    } else {
-      while (this.at < this.text.length && !/[,\]} \t\r\n]/u.test(this.text[this.at] ?? "")) {
-        this.at += 1;
+      return this.object(depth);
+    }
+    if (char === "[") {
+      return this.array(depth);
+    }
+    const string = this.match(STRING);
+    if (string !== undefined) {
+      return JSON.parse(string) as string;
+    }
+    NUMBER.lastIndex = this.at;
+    const number = NUMBER.exec(this.text);
+    if (number !== null) {
+      this.at = NUMBER.lastIndex;
+      if (number[1] !== undefined || number[2] !== undefined) {
+        this.fractions.set(pointerOf(this.path.map(String)), number[0]);
+      }
+      return Number(number[0]);
+    }
+    for (const [literal, held] of LITERALS) {
+      if (this.text.startsWith(literal, this.at)) {
+        this.at += literal.length;
+        return held;
       }
     }
+    return this.fail(
+      char === undefined ? "the document ends where a value is expected" : "a value is expected",
+    );
   }
 
-  private object(role: string): void {
-    const seen = new Set<string>();
+  private object(depth: number): Record<string, unknown> {
+    const held: Record<string, unknown> = {};
     this.at += 1;
+    this.match(SPACE);
+    if (this.text[this.at] === "}") {
+      this.at += 1;
+      return held;
+    }
     for (;;) {
-      this.skip();
-      if (this.text[this.at] === "}") {
-        this.at += 1;
-        return;
+      this.match(SPACE);
+      const offset = this.at;
+      const spelled = this.match(STRING);
+      if (spelled === undefined) {
+        return this.fail("a member name is expected");
       }
-      if (this.text[this.at] === ",") {
-        this.at += 1;
-        this.skip();
+      const name = JSON.parse(spelled) as string;
+      if (Object.hasOwn(held, name)) {
+        this.fail(
+          `the member ${JSON.stringify(name)} is written twice, so neither value is chosen`,
+          offset,
+          name,
+        );
       }
-      const offset = this.at;
-      const name = this.string();
-      if (seen.has(name) && this.twice === undefined) {
-        this.twice = { name, offset };
+      this.expect(":", "a colon after the member name");
+      if (depth === 1 && this.path[0] === this.records) {
+        this.match(SPACE);
+        this.starts.set(name, this.at);
       }
-      seen.add(name);
-      this.skip();
+      this.path.push(name);
+      Object.defineProperty(held, name, {
+        value: this.value(depth + 1),
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+      this.path.pop();
+      this.match(SPACE);
+      const next = this.text[this.at];
       this.at += 1;
-      this.value(role === "document" && name === this.array ? "array" : "other");
+      if (next === "}") {
+        return held;
+      }
+      if (next !== ",") {
+        this.at -= 1;
+        this.fail("a comma or a closing brace is expected");
+      }
     }
   }
 
-  private list(element: "record" | "other"): void {
+  private array(depth: number): unknown[] {
+    const held: unknown[] = [];
+    const records = depth === 1 && this.path[0] === this.records;
     this.at += 1;
+    this.match(SPACE);
+    if (this.text[this.at] === "]") {
+      this.at += 1;
+      return held;
+    }
     for (;;) {
-      this.skip();
-      if (this.text[this.at] === "]") {
-        this.at += 1;
-        return;
+      this.match(SPACE);
+      if (records) {
+        this.starts.set(held.length, this.at);
+      }
+      this.path.push(held.length);
+      held.push(this.value(depth + 1));
+      this.path.pop();
+      this.match(SPACE);
+      const next = this.text[this.at];
+      this.at += 1;
+      if (next === "]") {
+        return held;
       }
-      if (this.text[this.at] === ",") {
-        this.at += 1;
+      if (next !== ",") {
+        this.at -= 1;
+        this.fail("a comma or a closing bracket is expected");
       }
-      this.value(element);
     }
   }
 }
 
-/** What a walk of one document found. */
-interface DocumentWalk {
-  /** The offset of each element of the document's array member, in order: an object's `{`. */
-  readonly starts: readonly number[];
-  /** The first member one object writes twice, at any depth, as the offset of its name. */
-  readonly twice: { readonly name: string; readonly offset: number } | undefined;
-}
-
 /**
- * Walks a document `JSON.parse` accepted, whose top-level member `array` holds the
- * records. A member one object writes twice reads as though it were written once, its
- * later value silently replacing the earlier one, so a document holding one is one a
- * reader names rather than reads.
+ * Reads `text` as one strict JSON document, or throws a {@link StrictJSONError}.
+ * `records` names the top-level member whose values' offsets the read keeps.
  */
-export function walkDocument(text: string, array: string): DocumentWalk {
-  const walk = new Walk(text, array);
-  walk.run();
-  return { starts: walk.starts, twice: walk.twice };
+export function readStrict(text: string, records?: string): StrictDocument {
+  const reader = new Reader(text, records);
+  const value = reader.read();
+  return { value, fractions: reader.fractions, starts: reader.starts };
 }
 
 /**
@@ -129,6 +283,12 @@ export function positionAt(text: string, file: string, offset: number): Position
   return { path: file, line: before.split("\n").length, column: offset - lineStart + 1 };
 }
 
+/** A strict read's fault with the line and column it is at, as a refusal states it. */
+export function locatedFault(text: string, error: StrictJSONError): string {
+  const { line, column } = positionAt(text, "", error.offset);
+  return `line ${String(line)}, column ${String(column)}: ${error.message}`;
+}
+
 /** Whether a decoded JSON value is an object: not `null` and not an array. */
 export function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);

package/src/kinds.ts

@@ -5,14 +5,6 @@ export const KINDS: ReadonlyMap<string, KindRow> = new Map(
   KIND_ROWS.map((one): [string, KindRow] => [one.code, one]),
 );
 
-/**
- * The code of every live issue kind, in ascending order. A severity key names one of
- * them or a family prefix whose range holds one; a key naming a retired code, an
- * unassigned code or a range holding no live kind is an unimplemented key, so every
- * severity a configuration sets is one some analyzer reports under.
- */
-export const LIVE_CODES: readonly string[] = KIND_ROWS.map((one) => one.code);
-
 /** The issue-kind codes whose severity the Contract fixes, in ascending order. */
 export const FIXED_SEVERITY_CODES: readonly string[] = KIND_ROWS.filter((one) => one.fixed).map(
   (one) => one.code,