@avi2dg/checks 0.6.0 → 0.9.0

package/scripts/mutation-compare.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
-import { readFile } from "node:fs/promises";
+import { Console, Effect, FileSystem, Schema } from "effect";
+import { runMain, Usage } from "./main.ts";
 
 export type Tally = {
   readonly killed: number;
@@ -25,42 +26,31 @@ export type Options = {
   readonly advisory: boolean;
 };
 
-export class ReportError extends Error {}
+export class ReportError extends Schema.TaggedError<ReportError>()("ReportError", {
+  message: Schema.String,
+}) {}
 
 const DETECTED = new Set(["Killed", "Timeout"]);
 const UNDETECTED = new Set(["Survived", "NoCoverage"]);
 const USAGE = "usage: mutation-compare.ts [--advisory] <base-report> <head-report>";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-export function parseReport(text: string): Map<string, readonly string[]> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new ReportError("mutation-compare: report is not valid JSON");
-  }
-  if (!isRecord(parsed) || !isRecord(parsed["files"])) {
-    throw new ReportError("mutation-compare: report has no files table");
-  }
-  const files = new Map<string, readonly string[]>();
-  for (const [path, entry] of Object.entries(parsed["files"])) {
-    if (!isRecord(entry) || !Array.isArray(entry["mutants"])) {
-      throw new ReportError(`mutation-compare: ${path} has no mutants list`);
-    }
-    const statuses: string[] = [];
-    for (const mutant of entry["mutants"]) {
-      if (!isRecord(mutant) || typeof mutant["status"] !== "string") {
-        throw new ReportError(`mutation-compare: ${path} carries a mutant without a status`);
-      }
-      statuses.push(mutant["status"]);
-    }
-    files.set(path, statuses);
-  }
-  return files;
-}
+const Report = Schema.fromJsonString(
+  Schema.Struct({
+    files: Schema.Record(
+      Schema.String,
+      Schema.Struct({ mutants: Schema.Array(Schema.Struct({ status: Schema.String })) }),
+    ),
+  }),
+);
+const decodeReport = Schema.decodeUnknownEffect(Report);
+
+export const parseReport = (source: string, text: string): Effect.Effect<Map<string, readonly string[]>, ReportError> =>
+  decodeReport(text).pipe(
+    Effect.map(
+      ({ files }) => new Map(Object.entries(files).map(([path, { mutants }]) => [path, mutants.map(({ status }) => status)])),
+    ),
+    Effect.mapError((cause) => new ReportError({ message: `${source} is not a Stryker mutation report: ${cause.message}` })),
+  );
 
 function tally(statuses: readonly string[]): Tally {
   let killed = 0;
@@ -136,38 +126,34 @@ export function formatComparison(comparison: Comparison, advisory: boolean): str
   return lines.join("\n");
 }
 
-export function parseArgs(argv: readonly string[]): Options {
+export const parseArgs = Effect.fnUntraced(function* (argv: readonly string[]): Effect.fn.Return<Options, Usage> {
   let advisory = false;
   const paths: string[] = [];
   for (const arg of argv) {
     if (arg === "--advisory") advisory = true;
-    else if (arg.startsWith("--")) throw new ReportError(`${USAGE}: unknown flag ${arg}`);
+    else if (arg.startsWith("--")) return yield* new Usage({ message: `${USAGE}: unknown flag ${arg}` });
     else paths.push(arg);
   }
-  if (paths.length !== 2 || paths[0] === undefined || paths[1] === undefined) throw new ReportError(USAGE);
-  return { basePath: paths[0], headPath: paths[1], advisory };
-}
+  const [basePath, headPath, ...extra] = paths;
+  if (basePath === undefined || headPath === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+  return { basePath, headPath, advisory };
+});
 
-export function exitFor(comparison: Comparison, advisory: boolean): number {
-  return comparison.regression && !advisory ? 1 : 0;
+export function passes(comparison: Comparison, advisory: boolean): boolean {
+  return advisory || !comparison.regression;
 }
 
-async function load(path: string): Promise<string> {
-  try {
-    return await readFile(path, "utf8");
-  } catch {
-    throw new ReportError(`mutation-compare: cannot read ${path}`);
-  }
-}
+const load = Effect.fn("load")(function* (path: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const text = yield* fs.readFileString(path).pipe(Effect.mapError(() => new ReportError({ message: `cannot read ${path}` })));
+  return yield* parseReport(path, text);
+});
 
-if (import.meta.main) {
-  try {
-    const options = parseArgs(process.argv.slice(2));
-    const comparison = compareReports(parseReport(await load(options.basePath)), parseReport(await load(options.headPath)));
-    console.log(formatComparison(comparison, options.advisory));
-    process.exit(exitFor(comparison, options.advisory));
-  } catch (error) {
-    console.error(error instanceof ReportError ? error.message : `mutation-compare: ${String(error)}`);
-    process.exit(2);
-  }
-}
+const compare = Effect.gen(function* () {
+  const options = yield* parseArgs(process.argv.slice(2));
+  const comparison = compareReports(yield* load(options.basePath), yield* load(options.headPath));
+  yield* Console.log(formatComparison(comparison, options.advisory));
+  return passes(comparison, options.advisory);
+});
+
+if (import.meta.main) runMain("mutation-compare", compare);

package/scripts/suppressions-ratchet.ts

@@ -1,4 +1,8 @@
 #!/usr/bin/env bun
+import { Console, Effect, Schema } from "effect";
+import { git, parentOrEmptyTree } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+
 export const SUPPRESSIONS = "oxlint-suppressions.json";
 
 export type Suppressions = ReadonlyMap<string, ReadonlyMap<string, number>>;
@@ -13,44 +17,37 @@ export type Ratchet = {
   readonly rises: readonly Rise[];
 };
 
-export class SuppressionsError extends Error {}
+export class SuppressionsError extends Schema.TaggedError<SuppressionsError>()("SuppressionsError", {
+  message: Schema.String,
+}) {}
 
 const USAGE = "usage: suppressions-ratchet.ts <ref> | <base-ref> <head-ref>";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isCount(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-
-export function parseSuppressions(text: string, where: string): Suppressions {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new SuppressionsError(`suppressions-ratchet: ${where} is not valid JSON`);
-  }
-  if (!isRecord(parsed)) {
-    throw new SuppressionsError(`suppressions-ratchet: ${where} is not an object of files`);
-  }
-  const files = new Map<string, ReadonlyMap<string, number>>();
-  for (const [file, rules] of Object.entries(parsed)) {
-    if (!isRecord(rules)) {
-      throw new SuppressionsError(`suppressions-ratchet: ${where} holds ${file} without an object of rules`);
-    }
+const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+const decodeEntry = Schema.decodeUnknownEffect(Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }));
+
+export const parseSuppressions = Effect.fn("parseSuppressions")(function* (
+  text: string,
+  where: string,
+): Effect.fn.Return<Suppressions, SuppressionsError> {
+  const refuse = (reason: string) => () => new SuppressionsError({ message: `${where} ${reason}` });
+  const parsed = yield* parseJson(text).pipe(Effect.mapError(refuse("is not valid JSON")));
+  const files = yield* decodeObject(parsed).pipe(Effect.mapError(refuse("is not an object of files")));
+  const suppressions = new Map<string, ReadonlyMap<string, number>>();
+  for (const [file, rules] of Object.entries(files)) {
+    const entries = yield* decodeObject(rules).pipe(Effect.mapError(refuse(`holds ${file} without an object of rules`)));
     const counts = new Map<string, number>();
-    for (const [rule, entry] of Object.entries(rules)) {
-      if (!isRecord(entry) || !isCount(entry["count"])) {
-        throw new SuppressionsError(`suppressions-ratchet: ${where} holds ${file} ${rule} without a whole count`);
-      }
-      counts.set(rule, entry["count"]);
+    for (const [rule, entry] of Object.entries(entries)) {
+      const { count } = yield* decodeEntry(entry).pipe(
+        Effect.mapError(refuse(`holds ${file} ${rule} without a whole count`)),
+      );
+      counts.set(rule, count);
     }
-    files.set(file, counts);
+    suppressions.set(file, counts);
   }
-  return files;
-}
+  return suppressions;
+});
 
 export function compareSuppressions(base: Suppressions, head: Suppressions): Ratchet {
   const rises: Rise[] = [];
@@ -91,52 +88,43 @@ export function report({ counted, lowered, rises }: Ratchet): string {
   ].join("\n");
 }
 
-function die(message: string): never {
-  console.error(message);
-  process.exit(2);
-}
-
-function git(...args: readonly string[]): string {
-  const result = Bun.spawnSync(["git", ...args], { stdout: "pipe", stderr: "pipe" });
-  if (!result.success) {
-    die(`suppressions-ratchet: git ${args.join(" ")}: ${result.stderr.toString().trim()}`);
-  }
-  return result.stdout.toString();
-}
-
-function commitOf(rev: string): string {
-  return git("rev-parse", "--verify", `${rev}^{commit}`).trim();
-}
-
-function mergeBase(base: string, head: string): string {
-  const result = Bun.spawnSync(["git", "merge-base", base, head], { stdout: "pipe", stderr: "pipe" });
-  if (!result.success) die(`suppressions-ratchet: ${base} and ${head} share no commit`);
-  return result.stdout.toString().trim();
-}
-
-function suppressionsAt(commit: string): Suppressions {
-  const blob = git("ls-tree", "--object-only", commit, "--", SUPPRESSIONS).trim();
-  if (blob === "") return new Map();
-  try {
-    return parseSuppressions(git("cat-file", "blob", blob), `${SUPPRESSIONS} at ${commit}`);
-  } catch (error) {
-    return die(error instanceof SuppressionsError ? error.message : `suppressions-ratchet: ${String(error)}`);
-  }
-}
-
-export function runRange(base: string, head: string): Ratchet {
-  const headCommit = commitOf(head);
+const commitOf = Effect.fn("commitOf")(function* (rev: string) {
+  return (yield* git(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
+});
+
+const mergeBase = Effect.fn("mergeBase")(function* (base: string, head: string) {
+  const commit = yield* git(["merge-base", base, head]).pipe(
+    Effect.mapError(() => new SuppressionsError({ message: `${base} and ${head} share no commit` })),
+  );
+  return commit.trim();
+});
+
+const suppressionsAt = Effect.fn("suppressionsAt")(function* (treeish: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", treeish, "--", SUPPRESSIONS])).trim();
+  if (blob === "") return new Map() satisfies Suppressions;
+  return yield* parseSuppressions(yield* git(["cat-file", "blob", blob]), `${SUPPRESSIONS} at ${treeish}`);
+});
+
+export const runRange = Effect.fn("runRange")(function* (base: string, head: string) {
+  const headCommit = yield* commitOf(head);
   // At the base tip, a count the base branch lowered after the head branched off would read as a rise at the head.
-  const branchPoint = mergeBase(commitOf(base), headCommit);
-  return compareSuppressions(suppressionsAt(branchPoint), suppressionsAt(headCommit));
-}
+  const branchPoint = yield* mergeBase(yield* commitOf(base), headCommit);
+  return compareSuppressions(yield* suppressionsAt(branchPoint), yield* suppressionsAt(headCommit));
+});
 
-if (import.meta.main) {
+export const runTip = Effect.fn("runTip")(function* (tip: string) {
+  const tipCommit = yield* commitOf(tip);
+  return compareSuppressions(yield* suppressionsAt(yield* parentOrEmptyTree(tipCommit)), yield* suppressionsAt(tipCommit));
+});
+
+const ratchet = Effect.gen(function* () {
   const [first, second, ...extra] = process.argv.slice(2);
-  if (first === undefined || extra.length > 0) die(USAGE);
+  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
 
-  const ratchet = second !== undefined ? runRange(first, second) : runRange(`${first}^`, first);
+  const result = second !== undefined ? yield* runRange(first, second) : yield* runTip(first);
 
-  console.log(report(ratchet));
-  process.exit(ratchet.rises.length === 0 ? 0 : 1);
-}
+  yield* Console.log(report(result));
+  return result.rises.length === 0;
+});
+
+if (import.meta.main) runMain("suppressions-ratchet", ratchet);

package/scripts/test-layout.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env bun
-import { parseSync } from "@swc/core";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { parse } from "@swc/core";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
+import { git } from "./git.ts";
+import { runMain } from "./main.ts";
+import { ENTRY_POINT } from "./gates.ts";
 
 export type Violation = {
   readonly file: string;
@@ -44,11 +45,21 @@ const REQUIRED_TEST_TABLE: Record<string, unknown> = {
 };
 export const LAYOUT_CHECK_MARK = "scripts/test-layout.ts";
 export const LAYOUT_CHECK_BIN = "checks-test-layout";
+const OWN_ENTRY_POINT = `scripts/${ENTRY_POINT.script}`;
+
+export class LayoutError extends Schema.TaggedError<LayoutError>()("LayoutError", {
+  message: Schema.String,
+}) {}
 
 function isRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null;
 }
 
+function runsLayoutCheck(lint: string): boolean {
+  if (lint.includes(LAYOUT_CHECK_MARK) || lint.includes(LAYOUT_CHECK_BIN)) return true;
+  return lint.split(/[\s|&;()]+/).some((word) => word === ENTRY_POINT.bin || word === OWN_ENTRY_POINT);
+}
+
 function startsWithAny(file: string, prefixes: readonly string[]): boolean {
   return prefixes.some((prefix) => file.startsWith(prefix));
 }
@@ -177,8 +188,11 @@ function outOfProcessUse(node: Record<string, unknown>): string | undefined {
   return undefined;
 }
 
-export function isolationViolations(file: string, source: string): readonly Violation[] {
-  const module = parseSync(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" });
+export const isolationViolations = Effect.fn("isolationViolations")(function* (file: string, source: string) {
+  const module = yield* Effect.tryPromise({
+    try: () => parse(source, { syntax: "typescript", tsx: file.endsWith(".tsx"), target: "esnext" }),
+    catch: (error) => new LayoutError({ message: `cannot parse ${file}: ${String(error)}` }),
+  });
   const violations: Violation[] = [];
   const seen = new Set<unknown>();
 
@@ -204,7 +218,7 @@ export function isolationViolations(file: string, source: string): readonly Viol
 
   visit(module);
   return violations;
-}
+});
 
 export function scriptViolations(manifest: unknown): readonly Violation[] {
   const file = "package.json";
@@ -219,11 +233,11 @@ export function scriptViolations(manifest: unknown): readonly Violation[] {
       message: `scripts.test must be exactly "${REQUIRED_TEST_SCRIPT}", found ${JSON.stringify(test ?? null)}`,
     });
   }
-  if (typeof lint !== "string" || (!lint.includes(LAYOUT_CHECK_MARK) && !lint.includes(LAYOUT_CHECK_BIN))) {
+  if (typeof lint !== "string" || !runsLayoutCheck(lint)) {
     violations.push({
       file,
       line: undefined,
-      message: `scripts.lint must run the layout check: add "${LAYOUT_CHECK_BIN}"`,
+      message: `scripts.lint must run the layout check: add "${ENTRY_POINT.bin}"`,
     });
   }
   return violations;
@@ -255,30 +269,38 @@ export function bunfigViolations(consumer: unknown, preset: unknown): readonly V
   return violations;
 }
 
-async function workingTreeFiles(root: string): Promise<readonly string[]> {
-  const listed = Bun.spawnSync(["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: root });
-  if (listed.exitCode !== 0) {
-    throw new Error(`test-layout: git ls-files failed in ${root}: ${listed.stderr.toString()}`);
-  }
-  const listedFiles = listed.stdout.toString().split("\0").filter(Boolean);
-  const present = await Promise.all(listedFiles.map((file) => Bun.file(join(root, file)).exists()));
-  return listedFiles.filter((_, index) => present[index]);
-}
-
-async function parsedToml(path: string): Promise<unknown> {
-  const imported: unknown = await import(path);
-  return isRecord(imported) ? (imported["default"] ?? imported) : imported;
-}
-
-async function readManifest(root: string): Promise<unknown> {
-  const text = await readFile(join(root, "package.json"), "utf8");
-  return JSON.parse(text) as unknown;
-}
+const workingTreeFiles = Effect.fn("workingTreeFiles")(function* (root: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const listed = yield* git(["ls-files", "-z", "--cached", "--others", "--exclude-standard"], root);
+  return yield* Effect.filter(listed.split("\0").filter(Boolean), (file) => fs.exists(path.join(root, file)), {
+    concurrency: "unbounded",
+  });
+});
+
+const parsedToml = Effect.fn("parsedToml")(function* (file: string) {
+  const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
+  return yield* Effect.try({
+    try: (): unknown => Bun.TOML.parse(text),
+    catch: (error) => new LayoutError({ message: `cannot parse ${file}: ${String(error)}` }),
+  });
+});
+
+const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+
+const readManifest = Effect.fn("readManifest")(function* (file: string) {
+  const text = yield* (yield* FileSystem.FileSystem).readFileString(file);
+  return yield* parseJson(text).pipe(
+    Effect.mapError((cause) => new LayoutError({ message: `cannot read ${file} as JSON: ${cause.message}` })),
+  );
+});
 
 export type Result = { readonly files: number; readonly violations: readonly Violation[] };
 
-export async function run(root: string, presetPath: string): Promise<Result> {
-  const files = await workingTreeFiles(root);
+export const run = Effect.fn("run")(function* (root: string, presetPath: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const path = yield* Path.Path;
+  const files = yield* workingTreeFiles(root);
   const violations: Violation[] = [...placementViolations(files)];
 
   const inProcess = files.filter(
@@ -289,19 +311,18 @@ export async function run(root: string, presetPath: string): Promise<Result> {
       !file.startsWith(DATA_DIR),
   );
   for (const file of inProcess) {
-    const source = await readFile(join(root, file), "utf8");
-    violations.push(...isolationViolations(file, source));
+    const source = yield* fs.readFileString(path.join(root, file));
+    violations.push(...(yield* isolationViolations(file, source)));
   }
 
-  violations.push(...scriptViolations(await readManifest(root)));
+  violations.push(...scriptViolations(yield* readManifest(path.join(root, "package.json"))));
 
-  const consumerBunfig = (await Bun.file(join(root, "bunfig.toml")).exists())
-    ? await parsedToml(join(root, "bunfig.toml"))
-    : undefined;
-  violations.push(...bunfigViolations(consumerBunfig, await parsedToml(presetPath)));
+  const bunfig = path.join(root, "bunfig.toml");
+  const consumerBunfig = (yield* fs.exists(bunfig)) ? yield* parsedToml(bunfig) : undefined;
+  violations.push(...bunfigViolations(consumerBunfig, yield* parsedToml(presetPath)));
 
   return { files: files.length, violations };
-}
+});
 
 export function report({ files, violations }: Result): string {
   if (violations.length === 0) return `test-layout: ${files} files satisfy the layout`;
@@ -312,10 +333,12 @@ export function report({ files, violations }: Result): string {
   return [`test-layout: ${violations.length} violation(s)`, ...lines].join("\n");
 }
 
-if (import.meta.main) {
+const layout = Effect.gen(function* () {
+  const path = yield* Path.Path;
   const root = process.argv[2] ?? process.cwd();
-  const preset = fileURLToPath(new URL("../bunfig.toml", import.meta.url));
-  const result = await run(root, preset);
-  console.log(report(result));
-  process.exit(result.violations.length === 0 ? 0 : 1);
-}
+  const result = yield* run(root, path.join(import.meta.dir, "..", "bunfig.toml"));
+  yield* Console.log(report(result));
+  return result.violations.length === 0;
+});
+
+if (import.meta.main) runMain("test-layout", layout);