@cplieger/deadset-ts 3.3.0 → 3.4.0

package/src/verbs/print-retained.ts

@@ -0,0 +1,24 @@
+import { runSweep } from "../analysis.ts";
+import { retainedLines } from "../exempt.ts";
+import { resolve } from "../resolve.ts";
+import { EXIT_CLEAN, type Verb } from "./verb.ts";
+
+/**
+ * Writes every declaration an exemption held back in the production sweep a report is
+ * built from, one per line, and nothing where no exemption held one back. One fact
+ * several configurations found is one record, so the line names no configuration. The
+ * line shape is this command's own rather than a Contract format, so that sort and cut
+ * read it.
+ */
+export const printRetainedVerb: Verb = ({ out, host, inputs, scope, openClient }) => {
+  const { config } = resolve(inputs());
+  const scoped = scope();
+  const swept = runSweep(openClient(false), host, scoped, config, {
+    marked: [],
+    mode: { production: true },
+  });
+  for (const line of retainedLines(swept.matrix.union.symbols, swept.retained)) {
+    out.write(`${line}\n`);
+  }
+  return EXIT_CLEAN;
+};

package/src/verbs/print-roots.ts

@@ -0,0 +1,38 @@
+import { runRoots, type RunRoot } from "../analysis.ts";
+import { resolve } from "../resolve.ts";
+import { EXIT_CLEAN, EXIT_FINDINGS, type Verb } from "./verb.ts";
+
+/**
+ * One root as a line: the declaration's reference, why it is a root, and the string
+ * that named it, separated by tabs. A run of several configurations adds the ones
+ * whose project holds the root as a fourth field, and writes the third present and
+ * empty where no string named the root, so every line of one run holds the same
+ * fields.
+ */
+function rootLine(root: RunRoot, several: boolean): string {
+  const line = `${root.ref}\t${root.kind}`;
+  if (several) {
+    return `${line}\t${root.source}\t${root.configurations.join(" ")}`;
+  }
+  return root.source === "" ? line : `${line}\t${root.source}`;
+}
+
+/**
+ * Writes the root set of the run, one root per line, and then names on the error
+ * stream, by its issue kind, every configured root or pattern that named nothing;
+ * one such string fails the run. The line shape is this command's own rather than a
+ * Contract format, so that sort and cut read it.
+ */
+export const printRootsVerb: Verb = ({ out, err, host, inputs, scope, openClient }) => {
+  const { config, provenance } = resolve(inputs());
+  const scoped = scope();
+  const answer = runRoots(openClient(false), host, scoped, config, provenance);
+  const several = answer.configurations.length > 1;
+  for (const root of answer.roots) {
+    out.write(`${rootLine(root, several)}\n`);
+  }
+  for (const finding of answer.findings) {
+    err.write(`${finding.code}: roots.patterns names nothing: ${finding.symbol.ref}\n`);
+  }
+  return answer.findings.length > 0 ? EXIT_FINDINGS : EXIT_CLEAN;
+};

package/src/verbs/verb.ts

@@ -0,0 +1,38 @@
+import type { Inputs } from "../config.ts";
+import type { Emitters } from "../findings/emitter.ts";
+import type { Host } from "../host.ts";
+import type { Writer } from "../run.ts";
+import type { Scope } from "../scope.ts";
+import type { Engine } from "../session.ts";
+
+/** The exit codes the Contract's exit-code table names. */
+export const EXIT_CLEAN = 0;
+export const EXIT_FINDINGS = 1;
+export const EXIT_USAGE = 2;
+export const EXIT_FAILURE = 3;
+
+/**
+ * What one verb is handed: the streams it writes, the platform it reads, and the
+ * options that follow its name, read only when the verb asks for what they name, so
+ * a verb that asks for nothing refuses no option.
+ */
+export interface Invocation {
+  readonly out: Writer;
+  readonly err: Writer;
+  readonly host: Host;
+  /** The configuration documents the options name, and the settings they supply. */
+  readonly inputs: () => Inputs;
+  /** The scope the options name: the document `--scope` names, or the target. */
+  readonly scope: () => Scope;
+  /** Opens the compiler client. A client the verb opened is closed if the verb throws. */
+  readonly openClient: (collectTiming: boolean) => Engine;
+  /** The emitter of every kind family, which a verb that reports findings runs. */
+  readonly emitters: Emitters;
+}
+
+/**
+ * One verb of the command line. It returns the exit code, and refuses by throwing a
+ * configuration, discovery or scope error, which the command line writes and turns
+ * into the code the Contract's table gives it.
+ */
+export type Verb = (invocation: Invocation) => number;

package/src/verbs/version.ts

@@ -0,0 +1,8 @@
+import { CONTRACT_VERSION } from "../version.ts";
+import { EXIT_CLEAN, type Verb } from "./verb.ts";
+
+/** Writes the version the host reports and the Contract version this analyzer implements. */
+export const versionVerb: Verb = ({ out, host }) => {
+  out.write(`deadset-ts ${host.analyzerVersion()}\ncontract ${CONTRACT_VERSION}\n`);
+  return EXIT_CLEAN;
+};

package/src/version.ts

@@ -4,4 +4,4 @@
  * independently of the analyzer's own version, which is the one the host answers
  * from the package the analyzer was installed from.
  */
-export const CONTRACT_VERSION = "3.0.0";
+export const CONTRACT_VERSION = "3.1.0";