@avi2dg/checks 0.26.0 → 0.28.0

package/src/testing/mutation-compare.ts

@@ -2,27 +2,43 @@
 import { Console, Effect, FileSystem, Schema } from "effect";
 import { runMain, Usage } from "../core/main.ts";
 
-export type Location = {
-  readonly start: { readonly line: number; readonly column: number };
-  readonly end: { readonly line: number; readonly column: number };
-};
+const PositionSchema = Schema.Struct({ line: Schema.Finite, column: Schema.Finite });
+const LocationSchema = Schema.Struct({ start: PositionSchema, end: PositionSchema });
+
+export type Location = typeof LocationSchema.Type;
+
+const MutantStatusSchema = Schema.Literals([
+  "Killed",
+  "Survived",
+  "Timeout",
+  "NoCoverage",
+  "Ignored",
+  "CompileError",
+  "RuntimeError",
+  "Pending",
+]);
+
+export type MutantStatus = typeof MutantStatusSchema.Type;
+
+const MutantSchema = Schema.Struct({
+  status: MutantStatusSchema,
+  mutatorName: Schema.String,
+  replacement: Schema.String,
+  killedBy: Schema.optionalKey(Schema.Array(Schema.String)),
+  location: LocationSchema,
+});
 
-export type Mutant = {
-  readonly status: string;
-  readonly mutatorName: string;
-  readonly replacement: string;
-  readonly killedBy?: readonly string[];
-  readonly location: Location;
-};
+export type Mutant = typeof MutantSchema.Type;
 
-export type ReportFile = {
-  readonly source: string;
-  readonly mutants: readonly Mutant[];
-};
+const ReportFileSchema = Schema.Struct({ source: Schema.String, mutants: Schema.Array(MutantSchema) });
 
-export type TestFile = {
-  readonly tests: readonly { readonly id: string; readonly name: string }[];
-};
+export type ReportFile = typeof ReportFileSchema.Type;
+
+const TestFileSchema = Schema.Struct({
+  tests: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String })),
+});
+
+export type TestFile = typeof TestFileSchema.Type;
 
 export type KillRun = {
   readonly files: ReadonlyMap<string, ReportFile>;
@@ -35,8 +51,8 @@ export type MutantChange = {
   readonly location: Location;
   readonly mutatorName: string;
   readonly replacement: string;
-  readonly from: string;
-  readonly to: string;
+  readonly from: MutantStatus;
+  readonly to: MutantStatus;
 };
 
 export type UnmatchedMutant = {
@@ -44,7 +60,7 @@ export type UnmatchedMutant = {
   readonly location: Location;
   readonly mutatorName: string;
   readonly replacement: string;
-  readonly status: string;
+  readonly status: MutantStatus;
 };
 
 export type Comparison = {
@@ -65,35 +81,25 @@ export class ReportError extends Schema.TaggedError<ReportError>()("ReportError"
   message: Schema.String,
 }) {}
 
-const DETECTED = new Set(["Killed", "Timeout"]);
-const UNDETECTED = new Set(["Survived", "NoCoverage"]);
-const LEAVES_SCORE = new Set(["CompileError", "RuntimeError", "Ignored", "Pending"]);
+const OUTCOME = {
+  Killed: "detected",
+  Timeout: "detected",
+  Survived: "undetected",
+  NoCoverage: "undetected",
+  CompileError: "leaves-score",
+  RuntimeError: "leaves-score",
+  Ignored: "leaves-score",
+  Pending: "leaves-score",
+} as const satisfies Record<MutantStatus, "detected" | "undetected" | "leaves-score">;
 const USAGE = "usage: mutation-compare.ts [--advisory] <base-report> <head-report>";
 
-const Files = Schema.Record(
-  Schema.String,
-  Schema.Struct({
-    source: Schema.String,
-    mutants: Schema.Array(
-      Schema.Struct({
-        status: Schema.String,
-        mutatorName: Schema.String,
-        replacement: Schema.String,
-        killedBy: Schema.optionalKey(Schema.Array(Schema.String)),
-        location: Schema.Struct({
-          start: Schema.Struct({ line: Schema.Finite, column: Schema.Finite }),
-          end: Schema.Struct({ line: Schema.Finite, column: Schema.Finite }),
-        }),
-      }),
-    ),
-  }),
-);
+const Files = Schema.Record(Schema.String, ReportFileSchema);
 const decodeReport = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ files: Files })));
 const decodeKillRun = Schema.decodeUnknownEffect(
   Schema.fromJsonString(
     Schema.Struct({
       files: Files,
-      testFiles: Schema.Record(Schema.String, Schema.Struct({ tests: Schema.Array(Schema.Struct({ id: Schema.String, name: Schema.String })) })),
+      testFiles: Schema.Record(Schema.String, TestFileSchema),
       config: Schema.optionalKey(Schema.Struct({ disableBail: Schema.optionalKey(Schema.Boolean) })),
     }),
   ),
@@ -211,9 +217,9 @@ function judgeMatch(path: string, mutant: UnmatchedMutant, counterpart: Unmatche
     from: mutant.status,
     to: counterpart.status,
   };
-  if (mutant.status !== counterpart.status && (LEAVES_SCORE.has(mutant.status) || LEAVES_SCORE.has(counterpart.status))) {
+  if (mutant.status !== counterpart.status && (OUTCOME[mutant.status] === "leaves-score" || OUTCOME[counterpart.status] === "leaves-score")) {
     findings.moves.push(change);
-  } else if (DETECTED.has(mutant.status) && UNDETECTED.has(counterpart.status)) {
+  } else if (OUTCOME[mutant.status] === "detected" && OUTCOME[counterpart.status] === "undetected") {
     findings.regressions.push(change);
   }
 }

package/src/testing/quarantine-clock.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { Console, Effect, Schema } from "effect";
-import { commitOf, git, isShallowBoundary, refArgs } from "../core/git.ts";
+import { commitOf, git, isShallowBoundary, refArgs, writtenAt } from "../core/git.ts";
 import { runMain } from "../core/main.ts";
 import { TEST_FILE } from "./test-layout.ts";
 
@@ -125,19 +125,10 @@ const entryAt = Effect.fn("entryAt")(function* (root: string, head: string, file
   return { file, at: entry.at, day: entry.day };
 });
 
-const headAt = Effect.fn("headAt")(function* (root: string, head: string) {
-  const shown = yield* git(["show", "-s", "--format=%at %ct", head], root);
-  const dates = shown.trim().split(" ").map(Number);
-  if (dates.length !== 2 || !dates.every(Number.isInteger)) {
-    return yield* new QuarantineError({ message: `cannot read when ${head} was written` });
-  }
-  return Math.max(...dates);
-});
-
 export const runHead = Effect.fn("runHead")(function* (root: string, head: string) {
   const files = yield* filesAt(root, head);
   const entries = yield* Effect.forEach(files, (file) => entryAt(root, head, file));
-  return { checked: files.length, overdue: overdueOf(entries, yield* headAt(root, head)) } satisfies ClockResult;
+  return { checked: files.length, overdue: overdueOf(entries, yield* writtenAt(head, root)) } satisfies ClockResult;
 });
 
 const clock = Effect.gen(function* () {

package/src/testing/test-layout.ts

@@ -177,7 +177,7 @@ function callUse(node: Record<string, unknown>): string | undefined {
   const callee = node["callee"];
   const calleeName = identifierName(callee);
   if (calleeName !== undefined && BANNED_GLOBAL_CALLS.includes(calleeName)) return `calls ${calleeName}`;
-  const argument = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
+  const argument: unknown = Array.isArray(node["arguments"]) ? node["arguments"][0] : undefined;
   const specifier = isRecord(argument) ? stringValue(argument["expression"]) : undefined;
   const banned = specifier === undefined ? undefined : bannedModule(specifier);
   if (banned === undefined) return undefined;

package/ts-reset.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="@total-typescript/ts-reset/is-array" />
+/// <reference types="@total-typescript/ts-reset/json-parse" />

package/tsconfig.effect.json

@@ -1,6 +1,9 @@
 {
+  "files": ["./ts-reset.d.ts"],
+  "include": ["${configDir}/**/*", "./ts-reset.d.ts"],
   "compilerOptions": {
     "erasableSyntaxOnly": true,
+    "exactOptionalPropertyTypes": true,
     "plugins": [
       {
         "name": "@effect/language-service",