atmn 2.0.11 → 2.0.13

package/src/surgery/patchFixturePaths.ts

@@ -0,0 +1,204 @@
+import { isDeepStrictEqual } from "node:util";
+import { type Edit, Lang, parse, type SgNode } from "@ast-grep/napi";
+import { appendPropertyEdit } from "./appendPropertyEdit";
+import {
+	type FixtureConstraint,
+	type FixtureShape,
+	findFixtures,
+	fixtureObjectOf,
+} from "./findFixture";
+import {
+	DYNAMIC_VALUE,
+	fixtureArrayElements,
+	fixtureKeyOf,
+	readFixtureValue,
+} from "./readFixtureValue";
+
+type Assignment = { path: (string | number)[]; text: string | null };
+type PatchResult = {
+	source: string;
+	skipped: { path: (string | number)[]; reason: string }[];
+};
+
+const isDynamic = (value: unknown): boolean => {
+	if (value === DYNAMIC_VALUE) return true;
+	if (value === null || typeof value !== "object") return false;
+	return Object.values(value).some(isDynamic);
+};
+
+const matchesLiteral = ({
+	value,
+	text,
+}: {
+	value: unknown;
+	text: string;
+}): boolean => {
+	const root = parse(Lang.TypeScript, `const value = (${text});`).root();
+	if (root.find({ rule: { kind: "ERROR" } }) !== null) return false;
+	const expression = root
+		.find({ rule: { kind: "variable_declarator" } })
+		?.field("value");
+	if (expression?.kind() !== "parenthesized_expression") return false;
+	const literal = expression
+		.namedChildren()
+		.filter((node) => node.kind() !== "comment");
+	if (literal.length !== 1 || literal[0] === undefined) return false;
+	const proposed = readFixtureValue({ node: literal[0] });
+	return !isDynamic(proposed) && isDeepStrictEqual(value, proposed);
+};
+
+const removeMemberEdits = ({ member }: { member: SgNode }): Edit[] => {
+	const siblings = member.parent()?.children() ?? [];
+	const index = siblings.findIndex(
+		(sibling) => sibling.range().start.index === member.range().start.index,
+	);
+	const next = siblings
+		.slice(index + 1)
+		.find((sibling) => sibling.kind() !== "comment");
+	const previous = siblings
+		.slice(0, index)
+		.reverse()
+		.find((sibling) => sibling.kind() !== "comment");
+	const comma =
+		next?.kind() === "," ? next : previous?.kind() === "," ? previous : null;
+	return [member, ...(comma === null ? [] : [comma])].map((node) => ({
+		startPos: node.range().start.index,
+		endPos: node.range().end.index,
+		insertedText: "",
+	}));
+};
+
+const pathEdits = ({
+	source,
+	object,
+	path,
+	text,
+	builders,
+}: {
+	source: string;
+	object: SgNode;
+	builders: readonly string[];
+} & Assignment): Edit[] | string => {
+	let current = object;
+	for (let index = 0; index < path.length; index += 1) {
+		if (
+			current.kind() === "call_expression" &&
+			builders.includes(current.field("function")?.text() ?? "")
+		) {
+			const args = current
+				.field("arguments")
+				?.namedChildren()
+				.filter((child) => child.kind() !== "comment");
+			if (args?.length !== 1 || args[0]?.kind() !== "object")
+				return "dynamic-value";
+			current = args[0];
+		}
+		const segment = path[index];
+		const last = index === path.length - 1;
+		let member: SgNode | undefined;
+		let value: SgNode | null | undefined;
+		if (typeof segment === "number") {
+			if (
+				current.kind() !== "array" ||
+				!Number.isSafeInteger(segment) ||
+				segment < 0
+			)
+				return "invalid-array-path";
+			const elements = fixtureArrayElements({ node: current });
+			if (elements === null) return "dynamic-array";
+			value = elements[segment];
+			if (value === undefined) return "missing-array-element";
+			if (last && text === null) return "array-element-removal";
+		} else {
+			if (current.kind() !== "object") return "non-object-container";
+			if (readFixtureValue({ node: current }) === DYNAMIC_VALUE)
+				return "ambiguous-object";
+			member = current.namedChildren().find((child) => {
+				const key = child.kind() === "pair" ? child.field("key") : child;
+				return key !== null && fixtureKeyOf({ node: key }) === segment;
+			});
+			if (member === undefined) {
+				if (text === null) return [];
+				const remaining = path.slice(index + 1);
+				if (remaining.some((key) => typeof key === "number"))
+					return "missing-array-element";
+				let inserted = text;
+				for (const key of remaining.reverse())
+					inserted = `{ ${JSON.stringify(key)}: ${inserted} }`;
+				const pair = `${JSON.stringify(segment)}: ${inserted}`;
+				const members = current
+					.namedChildren()
+					.filter((child) => child.kind() !== "comment");
+				if (members.length === 0) {
+					const closing = current.range().end.index - 1;
+					return [
+						{ startPos: closing, endPos: closing, insertedText: ` ${pair} ` },
+					];
+				}
+				return [appendPropertyEdit({ source, object: current, pair })];
+			}
+			value = member.field("value");
+		}
+		if (value == null) return "dynamic-value";
+		if (!last) {
+			current = value;
+			continue;
+		}
+		const currentValue = readFixtureValue({ node: value });
+		if (isDynamic(currentValue)) return "dynamic-value";
+		if (text === null)
+			return member === undefined
+				? "array-element-removal"
+				: removeMemberEdits({ member });
+		if (matchesLiteral({ value: currentValue, text })) return [];
+		return [
+			{
+				startPos: value.range().start.index,
+				endPos: value.range().end.index,
+				insertedText: text,
+			},
+		];
+	}
+	return "empty-path";
+};
+
+export const patchFixturePaths = ({
+	source,
+	builder,
+	idField,
+	id,
+	where,
+	assignments,
+	builders = [],
+}: {
+	source: string;
+	builder: FixtureShape;
+	idField: string;
+	id: string;
+	where?: FixtureConstraint[];
+	assignments: Assignment[];
+	builders?: readonly string[];
+}): PatchResult | null => {
+	const selector = { builder, idField, id, where, allowDynamic: true };
+	const initial = findFixtures({ source, ...selector });
+	if (initial.length === 0) return null;
+	const skipped: PatchResult["skipped"] = [];
+	for (const assignment of assignments) {
+		const matches = findFixtures({ source, ...selector });
+		const match = matches[0];
+		const object =
+			matches.length === 1 && match !== undefined
+				? fixtureObjectOf(match)
+				: null;
+		const edits =
+			object === null
+				? "ambiguous-fixture"
+				: pathEdits({ source, object, builders, ...assignment });
+		if (typeof edits === "string") {
+			skipped.push({ path: assignment.path, reason: edits });
+			continue;
+		}
+		source = parse(Lang.TypeScript, source).root().commitEdits(edits);
+	}
+	return { source, skipped };
+};

package/src/surgery/readFixtureValue.ts

@@ -0,0 +1,99 @@
+import type { SgNode } from "@ast-grep/napi";
+import { stringLiteralValue } from "./findFixture";
+
+export const DYNAMIC_VALUE = Symbol("dynamic-fixture-value");
+
+export const fixtureKeyOf = ({ node }: { node: SgNode }): string | null => {
+	if (
+		node.kind() === "property_identifier" ||
+		node.kind() === "shorthand_property_identifier"
+	)
+		return node.text();
+	return stringLiteralValue(node);
+};
+
+export const fixtureArrayElements = ({
+	node,
+}: {
+	node: SgNode;
+}): SgNode[] | null => {
+	const elements: SgNode[] = [];
+	let expectsElement = true;
+	for (const child of node.children()) {
+		const kind = child.kind();
+		if (kind === "[" || kind === "]" || kind === "comment") continue;
+		if (kind === ",") {
+			if (expectsElement) return null;
+			expectsElement = true;
+			continue;
+		}
+		if (!expectsElement || kind === "spread_element") return null;
+		elements.push(child);
+		expectsElement = false;
+	}
+	return elements;
+};
+
+export const readFixtureValue = ({
+	node,
+	builders = [],
+}: {
+	node: SgNode;
+	builders?: readonly string[];
+}): unknown => {
+	const kind = node.kind();
+	if (
+		kind === "call_expression" &&
+		builders.includes(node.field("function")?.text() ?? "")
+	) {
+		const args = node
+			.field("arguments")
+			?.namedChildren()
+			.filter((child) => child.kind() !== "comment");
+		return args?.length === 1 && args[0]?.kind() === "object"
+			? readFixtureValue({ node: args[0], builders })
+			: DYNAMIC_VALUE;
+	}
+	if (kind === "string") return stringLiteralValue(node) ?? DYNAMIC_VALUE;
+	if (kind === "true") return true;
+	if (kind === "false") return false;
+	if (kind === "null") return null;
+	if (
+		kind === "number" ||
+		(kind === "unary_expression" && /^[+-]\s*[\d.]/.test(node.text()))
+	) {
+		const value = Number(node.text().replaceAll("_", "").replace(/\s/g, ""));
+		return Number.isFinite(value) ? value : DYNAMIC_VALUE;
+	}
+	if (kind === "array") {
+		const elements = fixtureArrayElements({ node });
+		return elements === null
+			? DYNAMIC_VALUE
+			: elements.map((element) =>
+					readFixtureValue({ node: element, builders }),
+				);
+	}
+	if (kind !== "object") return DYNAMIC_VALUE;
+	const value: Record<string, unknown> = {};
+	for (const member of node.namedChildren()) {
+		if (member.kind() === "comment") continue;
+		const shorthand = member.kind() === "shorthand_property_identifier";
+		if (member.kind() !== "pair" && !shorthand) return DYNAMIC_VALUE;
+		const keyNode = shorthand ? member : member.field("key");
+		const key = keyNode === null ? null : fixtureKeyOf({ node: keyNode });
+		if (
+			key === null ||
+			Object.getOwnPropertyDescriptor(value, key) !== undefined
+		)
+			return DYNAMIC_VALUE;
+		const child = member.field("value");
+		Object.defineProperty(value, key, {
+			value:
+				child === null
+					? DYNAMIC_VALUE
+					: readFixtureValue({ node: child, builders }),
+			enumerable: true,
+		});
+	}
+	return value;
+};