@shivaedev/quality 0.31.0 → 0.32.0

package/src/engine/baselineFile.ts

@@ -2,6 +2,7 @@ import { join } from "node:path";
 import { Effect, type FileSystem } from "effect";
 import { type BaselineEntry, decodeBaseline } from "#baseline/format.ts";
 import { LEGACY_BASELINE } from "#baseline/legacy.ts";
+import { type Shard, shardOf, shardPaths } from "#baseline/shards.ts";
 import type { ResolvedConfig } from "#config/load.ts";
 import { validOrFail } from "#decoded.ts";
 import { SetupFailure } from "#failure.ts";
@@ -9,7 +10,7 @@ import { readOptionalText } from "#inventory/filesystem.ts";
 
 export interface BaselineFile {
 	readonly entries: readonly BaselineEntry[];
-	readonly raw: string | undefined;
+	readonly files: ReadonlyMap<string, Shard>;
 }
 
 export function readInput(root: string, path: string): Effect.Effect<string | undefined, SetupFailure, FileSystem.FileSystem> {
@@ -19,11 +20,27 @@ export function readInput(root: string, path: string): Effect.Effect<string | un
 export const readBaseline = Effect.fn("Engine.readBaseline")(function* (
 	config: ResolvedConfig,
 ): Effect.fn.Return<BaselineFile, SetupFailure, FileSystem.FileSystem> {
-	const raw = yield* readInput(config.root, config.baseline);
-	if (raw === undefined && config.baseline !== LEGACY_BASELINE && (yield* readInput(config.root, LEGACY_BASELINE)) !== undefined) {
-		return yield* new SetupFailure({
-			message: `${LEGACY_BASELINE} holds a baseline in the earlier JSON format. Run \`quality baseline migrate\` to move it to ${config.baseline}.`,
-		});
+	const files = new Map<string, Shard>();
+	for (const path of yield* shardPaths(config).pipe(Effect.mapError((error) => new SetupFailure({ message: error.message })))) {
+		const raw = yield* readInput(config.root, path);
+		if (raw === undefined) {
+			continue;
+		}
+		const entries = yield* validOrFail(path, yield* Effect.promise(() => decodeBaseline(raw)));
+		for (const entry of entries) {
+			const expected = shardOf(entry.file, config.baseline);
+			if (expected !== path) {
+				return yield* new SetupFailure({ message: `${entry.file} belongs in ${expected}, not ${path}.` });
+			}
+		}
+		files.set(path, { entries, raw });
 	}
-	return { entries: yield* validOrFail(config.baseline, yield* Effect.promise(() => decodeBaseline(raw))), raw };
+	for (const source of ["quality/baseline.jsonl", LEGACY_BASELINE]) {
+		if (source !== config.baseline && (yield* readInput(config.root, source)) !== undefined) {
+			return yield* new SetupFailure({
+				message: `${source} holds an earlier baseline. Run \`quality baseline migrate --from ${source}\` to move it to ${config.baseline} and package shards.`,
+			});
+		}
+	}
+	return { entries: [...files.values()].flatMap((file) => file.entries), files };
 });

package/src/imports/fences/reach.ts

@@ -2,8 +2,9 @@ import type { ImportEdge } from "#imports/graph.ts";
 import type { Endpoint } from "#imports/resolve.ts";
 import type { Matcher } from "./match.ts";
 
-export interface Reached {
+export interface Reached<TMatch = unknown> {
 	readonly line: number;
+	readonly match: TMatch;
 	readonly path: readonly string[];
 	readonly target: Endpoint;
 }
@@ -31,32 +32,37 @@ export function outgoing(edges: readonly ImportEdge[]): ReadonlyMap<string, read
 	return from;
 }
 
-interface Walk {
-	readonly forbidden: Matcher;
+interface Walk<TMatch> {
+	readonly forbidden: (endpoint: Endpoint) => TMatch | undefined;
 	readonly queue: string[];
-	readonly reached: Map<string, Reached>;
+	readonly reached: Map<string, Reached<TMatch>>;
 	readonly trails: Map<string, Trail>;
 }
 
-function follow(walk: Walk, before: Trail, edge: ImportEdge): void {
+function follow<TMatch>(walk: Walk<TMatch>, before: Trail, edge: ImportEdge): void {
 	const label = labelOf(edge.to);
 	const trail = { line: before.path.length === 1 ? edge.line : before.line, path: [...before.path, label] };
-	if (walk.forbidden(edge.to)) {
-		walk.reached.set(label, walk.reached.get(label) ?? { ...trail, target: edge.to });
+	const match = walk.forbidden(edge.to);
+	if (match) {
+		walk.reached.set(label, walk.reached.get(label) ?? { ...trail, match, target: edge.to });
 	} else if (edge.to.kind === "file" && !walk.trails.has(edge.to.path)) {
 		walk.trails.set(edge.to.path, trail);
 		walk.queue.push(edge.to.path);
 	}
 }
 
-export interface Walked {
-	readonly reached: readonly Reached[];
+export interface Walked<TMatch = unknown> {
+	readonly reached: readonly Reached<TMatch>[];
 	readonly visited: ReadonlyMap<string, Trail>;
 }
 
 // A breadth-first walk that stops at each forbidden endpoint, so a finding names the shortest path to the first forbidden step.
-export function walkFrom(start: string, edgesFrom: ReadonlyMap<string, readonly ImportEdge[]>, forbidden: Matcher): Walked {
-	const walk: Walk = { forbidden, queue: [start], reached: new Map(), trails: new Map([[start, { line: 0, path: [start] }]]) };
+export function walkFrom<TMatch>(
+	start: string,
+	edgesFrom: ReadonlyMap<string, readonly ImportEdge[]>,
+	forbidden: (endpoint: Endpoint) => TMatch | undefined,
+): Walked<TMatch> {
+	const walk: Walk<TMatch> = { forbidden, queue: [start], reached: new Map(), trails: new Map([[start, { line: 0, path: [start] }]]) };
 	for (const node of walk.queue) {
 		const before = walk.trails.get(node) ?? { line: 0, path: [node] };
 		for (const edge of edgesFrom.get(node) ?? []) {

package/src/rules/stories/unitTests.ts

@@ -29,11 +29,11 @@ function repair(path: readonly string[]): string {
 		: `split ${first}: move the pure code under test into its own module that reaches no engine, and test that module in the .unit file.`;
 }
 
-function reachFinding(file: string, reached: Reached): Finding {
+function reachFinding(file: string, reached: Reached<string>): Finding {
 	return {
 		file,
 		line: reached.line,
-		message: `Is a unit test but reaches ${engineOf(reached.target) ?? "an engine"} (${labelOf(reached.target)}) through ${reached.path.join(" -> ")}. A unit test reaches no engine, directly or through what it imports. ${KIT} ${repair(reached.path)}`,
+		message: `Is a unit test but reaches ${reached.match} (${labelOf(reached.target)}) through ${reached.path.join(" -> ")}. A unit test reaches no engine, directly or through what it imports. ${KIT} ${repair(reached.path)}`,
 	};
 }
 
@@ -76,7 +76,7 @@ export function unitTests(graph: ImportGraph, sources: readonly SourceFile[]): (
 	const edgesFrom = runtimeEdges(graph);
 	const byPath = new Map(sources.map((source) => [source.path, source]));
 	return (file) => {
-		const walked = walkFrom(file, edgesFrom, (endpoint) => engineOf(endpoint) !== undefined);
+		const walked = walkFrom(file, edgesFrom, engineOf);
 		const checked = [...walked.visited].filter(([module]) => module === file || isTestSupport(module));
 		return [
 			...[...walked.reached].sort((a, b) => a.line - b.line).map((reached) => reachFinding(file, reached)),

package/src/rules/test-names/usesDom.ts

@@ -6,17 +6,24 @@ const DOM_GLOBALS: ReadonlySet<string> = new Set(["document", "window"]);
 
 const TESTING_LIBRARY = "@testing-library/";
 
-function touchesDom(node: ts.Node): boolean {
+function touchesDom(node: ts.Node, checker: ts.TypeChecker): boolean {
 	if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
 		return node.moduleSpecifier.text.startsWith(TESTING_LIBRARY);
 	}
 	if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && DOM_GLOBALS.has(node.expression.text)) {
-		return true;
+		return (checker.getSymbolAtLocation(node.expression)?.declarations ?? []).length === 0;
 	}
-	return ts.forEachChild(node, touchesDom) ?? false;
+	return ts.forEachChild(node, (child) => touchesDom(child, checker)) ?? false;
 }
 
 export function usesDom(file: SourceFile): boolean {
 	const source = parse(file);
-	return source === undefined ? false : touchesDom(source);
+	if (source === undefined) {
+		return false;
+	}
+	const options: ts.CompilerOptions = { allowJs: true, noLib: true, noResolve: true };
+	const host = ts.createCompilerHost(options);
+	host.getSourceFile = (path) => (path === source.fileName ? source : undefined);
+	const checker = ts.createProgram([source.fileName], options, host).getTypeChecker();
+	return touchesDom(source, checker);
 }