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

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,

package/src/print.ts

@@ -1,97 +1,16 @@
-import {
-  renderOrigin,
-  type Config,
-  type DeclarationEntry,
-  type Provenance,
-  type Provider,
-} from "./config.ts";
+import { renderOrigin, type Provenance, type ResolvedConfig } from "./config.ts";
 import { bytewise } from "./text/compare.ts";
 
-/** One declaration entry as a document writes it: the members of its shape alone. */
-function declarationOf(entry: DeclarationEntry): Record<string, string> {
-  switch (entry.shape) {
-    case "symbol":
-      return { symbol: entry.symbol };
-    case "module":
-      return { module: entry.module, name: entry.name };
-    case "global":
-      return { global: entry.global };
-  }
-}
-
-/** One provider entry as a document writes it: the members of its shape alone. */
-function providerOf(entry: Provider): Record<string, unknown> {
-  const installed = { name: entry.name, languages: entry.languages, command: entry.command };
-  if (entry.shape === "installed") {
-    return installed;
-  }
-  return { ...installed, source: entry.source, version: entry.version, digest: entry.digest };
-}
-
 /**
- * The resolved configuration and its provenance as one JSON object, indented,
- * ending in a newline.
- *
- * The output is an instance of the closed key list, so reading it back as a
- * repository configuration resolves to the same configuration: the provenance
- * object is a declared key resolution ignores. Keys are written in the schema's
- * order and the severity and provenance objects in ascending key order, so one
- * configuration renders to one string whatever order a source named its settings
- * in.
+ * The resolved configuration and its provenance as one JSON object, indented, ending
+ * in a newline: the configuration in the order resolution gives it, then the provenance
+ * object in ascending key order. Read back as a repository configuration it resolves to
+ * the same configuration, because resolution checks the provenance object and then
+ * ignores it.
  */
-export function printConfig(config: Config, provenance: Provenance): string {
-  const document = {
-    contract_version: config.contractVersion,
-    target: { kind: config.targetKind },
-    analysis: {
-      languages: config.analysis.languages,
-      min_confidence: config.analysis.minConfidence,
-      generated_files: config.analysis.generatedFiles,
-      consumer_tests: config.analysis.consumerTests,
-      configurations: config.analysis.configurations.map((entry) =>
-        entry.shape === "project"
-          ? { id: entry.id, project: entry.project }
-          : { id: entry.id, os: entry.os, arch: entry.arch, tags: entry.tags },
-      ),
-      matrix: { complete: config.analysis.matrixComplete },
-      template_dirs: config.analysis.templateDirs,
-      template_delimiters: {
-        left: config.analysis.templateDelimiters.left,
-        right: config.analysis.templateDelimiters.right,
-      },
-    },
-    consumers: { complete: config.consumersComplete },
-    roots: { patterns: config.rootPatterns },
-    severity: Object.fromEntries([...config.severity].sort(([a], [b]) => bytewise(a, b))),
-    exemptions: { disabled: config.exemptionsDisabled },
-    reporters: {
-      formats: config.reporters.formats,
-      sort: config.reporters.sort,
-      cascade: config.reporters.cascade,
-      max_findings: config.reporters.maxFindings,
-      fail_on: config.reporters.failOn,
-    },
-    providers: { analyzers: config.providers.analyzers.map(providerOf) },
-    go: {},
-    ts: {
-      test_files: config.ts.testFiles,
-      entry_files: config.ts.entryFiles,
-      component_extensions: config.ts.componentExtensions,
-      disabled_conventions: config.ts.disabledConventions,
-      injection_registrations: config.ts.injectionRegistrations.map(declarationOf),
-      lifecycle_contracts: config.ts.lifecycleContracts.map((entry) => ({
-        components: entry.components.map(declarationOf),
-        bases: entry.bases.map(declarationOf),
-        members: entry.members,
-      })),
-      serializers: config.ts.serializers.map(declarationOf),
-      roots_complete: config.ts.rootsComplete,
-    },
-    provenance: Object.fromEntries(
-      [...provenance]
-        .sort(([a], [b]) => bytewise(a, b))
-        .map(([path, origin]) => [path, renderOrigin(origin)]),
-    ),
-  };
-  return `${JSON.stringify(document, undefined, 2)}\n`;
+export function printConfig(config: ResolvedConfig, provenance: Provenance): string {
+  const origins = [...provenance]
+    .sort(([a], [b]) => bytewise(a, b))
+    .map(([path, origin]): [string, string] => [path, renderOrigin(origin)]);
+  return `${JSON.stringify({ ...config, provenance: Object.fromEntries(origins) }, undefined, 2)}\n`;
 }