@shivaedev/quality 0.6.0 → 0.7.0

package/src/baseline/guard.ts

@@ -1,48 +0,0 @@
-import { covers, groupBy, keyOf } from "../engine/violation.ts";
-import type { BaselineEntry } from "./format.ts";
-
-export type GuardProblem =
-	| { readonly _tag: "Added"; readonly entry: BaselineEntry }
-	| { readonly _tag: "Raised"; readonly entry: BaselineEntry; readonly base: BaselineEntry }
-	| { readonly _tag: "Unadopted"; readonly rule: string; readonly entries: number }
-	| { readonly _tag: "NothingAdopted"; readonly rule: string };
-
-export interface GuardResult {
-	readonly adopted: readonly string[];
-	readonly moved: number;
-	readonly problems: readonly GuardProblem[];
-}
-
-export const guardBaseline = (
-	base: readonly BaselineEntry[],
-	working: readonly BaselineEntry[],
-	renames: ReadonlyMap<string, string>,
-	adopt: readonly string[],
-): GuardResult => {
-	const before = new Map(base.map((entry) => [keyOf(entry.rule, entry.file), entry]));
-	const covered = new Set(base.map((entry) => entry.rule));
-	const byRule = groupBy(working, (entry) => entry.rule);
-	const problems: GuardProblem[] = [];
-	let moved = 0;
-	for (const entry of working.filter((candidate) => covered.has(candidate.rule))) {
-		const exact = before.get(keyOf(entry.rule, entry.file));
-		const origin = renames.get(entry.file);
-		const matched = exact ?? (origin === undefined ? undefined : before.get(keyOf(entry.rule, origin)));
-		if (matched === undefined) {
-			problems.push({ _tag: "Added", entry });
-		} else if (entry.count > matched.count) {
-			problems.push({ _tag: "Raised", base: matched, entry });
-		} else if (exact === undefined) {
-			moved += 1;
-		}
-	}
-	const adopted = (rule: string): boolean => adopt.some((name) => covers(name, rule));
-	const fresh = [...byRule.entries()].filter(([rule]) => !covered.has(rule));
-	for (const [rule, entries] of fresh.filter(([rule]) => !adopted(rule))) {
-		problems.push({ _tag: "Unadopted", entries: entries.length, rule });
-	}
-	for (const name of adopt.filter((candidate) => ![...byRule.keys()].some((rule) => covers(candidate, rule)))) {
-		problems.push({ _tag: "NothingAdopted", rule: name });
-	}
-	return { adopted: fresh.map(([rule]) => rule).filter(adopted), moved, problems };
-};

package/src/cli/check.ts

@@ -1,51 +0,0 @@
-import { relative } from "node:path";
-import { Console, Effect, type FileSystem } from "effect";
-import { type BaselineEntry, decodeBaseline } from "../baseline/format.ts";
-import { guardBaseline } from "../baseline/guard.ts";
-import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE, measured } from "../baseline/legacy.ts";
-import { loadConfig, type ResolvedConfig } from "../config/load.ts";
-import { validOrFail } from "../decoded.ts";
-import { readBaseline } from "../engine/baseline-file.ts";
-import { scan } from "../engine/session.ts";
-import { GateFailed, type SetupFailure } from "../failure.ts";
-import { type Base, resolveBase } from "../git/base.ts";
-import type { Git } from "../git/command.ts";
-import { changesSince, readAt } from "../git/history.ts";
-import { renderGuard } from "../report/guard.ts";
-
-const baseEntries = (
-	config: ResolvedConfig,
-	base: Base,
-	path: string,
-): Effect.Effect<readonly BaselineEntry[], SetupFailure, FileSystem.FileSystem | Git> =>
-	Effect.gen(function* () {
-		const raw = yield* readAt(config.root, base.commit, path);
-		if (raw !== undefined) {
-			return yield* validOrFail(`${path} at ${base.ref}`, yield* Effect.promise(() => decodeBaseline(raw)));
-		}
-		const legacyRaw = yield* readAt(config.root, base.commit, LEGACY_BASELINE);
-		if (legacyRaw === undefined) {
-			return [];
-		}
-		const legacy = yield* validOrFail(`${LEGACY_BASELINE} at ${base.ref}`, yield* Effect.promise(() => decodeLegacyBaseline(legacyRaw)));
-		return measured(legacy) ? convertLegacy(legacy, (yield* scan(config)).violations) : legacy;
-	});
-
-export const checkBaseline = (
-	cwd: string,
-	configPath: string | undefined,
-	against: string | undefined,
-): Effect.Effect<void, SetupFailure | GateFailed, FileSystem.FileSystem | Git> =>
-	Effect.gen(function* () {
-		const config = yield* loadConfig(cwd, configPath);
-		const working = yield* readBaseline(config);
-		const base = yield* resolveBase(config.root, against);
-		const { moves } = yield* changesSince(config.root, [base.commit]);
-		const renames = new Map([...moves].map(([from, to]) => [to, from]));
-		const before = yield* baseEntries(config, base, renames.get(config.baseline) ?? config.baseline);
-		const result = guardBaseline(before, working.entries, renames, config.adopt);
-		yield* Console.log(renderGuard(result, { base, baseline: config.baseline, config: relative(config.root, config.file) }));
-		if (result.problems.length > 0) {
-			return yield* new GateFailed();
-		}
-	});

package/src/report/guard.ts

@@ -1,46 +0,0 @@
-import type { GuardProblem, GuardResult } from "../baseline/guard.ts";
-import type { Base } from "../git/base.ts";
-import { plural } from "./plural.ts";
-
-export interface GuardContext {
-	readonly base: Base;
-	readonly baseline: string;
-	readonly config: string;
-}
-
-const problemLine = (problem: GuardProblem, context: GuardContext): string => {
-	switch (problem._tag) {
-		case "Added":
-			return `${problem.entry.rule} ${problem.entry.file} is new, at ${problem.entry.count}.`;
-		case "Raised":
-			return `${problem.entry.rule} ${problem.entry.file} rose to ${problem.entry.count} from ${problem.base.count}.`;
-		case "Unadopted":
-			return `${problem.rule} is newly baselined in ${plural(problem.entries, "file")} without being named under \`adopt\` in ${context.config}.`;
-		case "NothingAdopted":
-			return `\`adopt\` in ${context.config} names ${problem.rule}, which has nothing baselined. Remove it.`;
-	}
-};
-
-const against = (base: Base): string => `${base.ref} (merge base ${base.commit.slice(0, 12)})`;
-
-const held = (result: GuardResult): string =>
-	[
-		...(result.moved > 0 ? [`${plural(result.moved, "entry", "entries")} followed moved files`] : []),
-		...(result.adopted.length > 0 ? [`adopted ${result.adopted.join(", ")}`] : []),
-	]
-		.map((part) => `; ${part}`)
-		.join("");
-
-export const renderGuard = (result: GuardResult, context: GuardContext): string => {
-	if (result.problems.length === 0) {
-		return `quality: ${context.baseline} holds against ${against(context.base)}${held(result)}.`;
-	}
-	return [
-		[
-			`error ${context.baseline} grew against ${against(context.base)}`,
-			"  The baseline only shrinks. Fix new violations instead of baselining them; a rule enters the baseline for the first time only while `adopt` names it.",
-			...result.problems.map((problem) => `  ${problemLine(problem, context)}`),
-		].join("\n"),
-		`quality: baseline check failed with ${plural(result.problems.length, "problem")}.`,
-	].join("\n\n");
-};