tryscript 0.1.6 → 0.1.7

package/dist/{src-Bd9-Y0qp.mjs → src-BQxIhzgF.mjs}

@@ -2,12 +2,13 @@
 import { pathToFileURL } from "node:url";
 import { existsSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
-import { parse } from "yaml";
+import { parse, stringify } from "yaml";
 import { spawn } from "node:child_process";
 import { cp, mkdtemp, realpath, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import treeKill from "tree-kill";
 import stripAnsi from "strip-ansi";
+import { writeFile } from "atomically";
 
 //#region src/lib/config.ts
 /** Default coverage configuration values. */
@@ -91,8 +92,6 @@ function defineConfig(config) {
 //#region src/lib/parser.ts
 /** Regex to match YAML frontmatter at the start of a file */
 const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
-/** Regex to match fenced code blocks with console/bash info string */
-const CODE_BLOCK_REGEX = /```(console|bash)\r?\n([\s\S]*?)```/g;
 /** Regex to match markdown headings (for test names) */
 const HEADING_REGEX = /^#+\s+(?:Test:\s*)?(.+)$/m;
 /** Regex to match skip annotation in heading or nearby HTML comment */
@@ -100,6 +99,55 @@ const SKIP_ANNOTATION_REGEX = /<!--\s*skip\s*-->/i;
 /** Regex to match only annotation in heading or nearby HTML comment */
 const ONLY_ANNOTATION_REGEX = /<!--\s*only\s*-->/i;
 /**
+* Find console/bash fenced code blocks, supporting extended fences (4+ backticks).
+*
+* Extended fences allow embedding triple-backtick blocks in expected output.
+* A closing fence must have at least as many backticks as the opening fence
+* (per CommonMark spec).
+*/
+function findConsoleCodeBlocks(text) {
+	const results = [];
+	const lines = text.split("\n");
+	const offsets = new Array(lines.length);
+	offsets[0] = 0;
+	for (let j = 1; j < lines.length; j++) offsets[j] = offsets[j - 1] + lines[j - 1].length + 1;
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		const trimmed = line.endsWith("\r") ? line.slice(0, -1) : line;
+		const openMatch = /^(`{3,})(console|bash)\s*$/.exec(trimmed);
+		if (!openMatch) {
+			i++;
+			continue;
+		}
+		const fenceLen = openMatch[1].length;
+		const infoString = openMatch[2];
+		const openLineIdx = i;
+		const closingRe = /* @__PURE__ */ new RegExp(`^\`{${fenceLen},}\\s*$`);
+		i++;
+		while (i < lines.length) {
+			const cur = lines[i];
+			const curTrimmed = cur.endsWith("\r") ? cur.slice(0, -1) : cur;
+			if (closingRe.test(curTrimmed)) {
+				const startOffset = offsets[openLineIdx];
+				const endOffset = offsets[i] + lines[i].length;
+				const contentStart = offsets[openLineIdx + 1];
+				const contentEnd = offsets[i];
+				results.push({
+					fullMatch: text.slice(startOffset, endOffset),
+					infoString,
+					content: text.slice(contentStart, contentEnd),
+					index: startOffset
+				});
+				i++;
+				break;
+			}
+			i++;
+		}
+	}
+	return results;
+}
+/**
 * Parse a .tryscript.md file into structured test data.
 */
 function parseTestFile(content, filePath) {
@@ -112,12 +160,11 @@ function parseTestFile(content, filePath) {
 		body = content.slice(frontmatterMatch[0].length);
 	}
 	const blocks = [];
-	CODE_BLOCK_REGEX.lastIndex = 0;
-	let match;
-	while ((match = CODE_BLOCK_REGEX.exec(body)) !== null) {
-		const blockContent = match[2] ?? "";
-		const blockStart = match.index;
-		const lineNumber = content.slice(0, content.indexOf(match[0])).split("\n").length;
+	const codeBlocks = findConsoleCodeBlocks(body);
+	for (const codeBlock of codeBlocks) {
+		const blockContent = codeBlock.content;
+		const blockStart = codeBlock.index;
+		const lineNumber = content.slice(0, content.indexOf(codeBlock.fullMatch)).split("\n").length;
 		const contentBefore = body.slice(0, blockStart);
 		const lastHeadingMatch = [...contentBefore.matchAll(new RegExp(HEADING_REGEX.source, "gm"))].pop();
 		const name = lastHeadingMatch?.[1]?.trim();
@@ -132,7 +179,7 @@ function parseTestFile(content, filePath) {
 			expectedStderr: parsed.expectedStderr,
 			expectedExitCode: parsed.expectedExitCode,
 			lineNumber,
-			rawContent: match[0],
+			rawContent: codeBlock.fullMatch,
 			skip,
 			only
 		});
@@ -507,9 +554,15 @@ function patternToRegex(expected, customPatterns = {}) {
 	const dotdotMarker = getMarker();
 	replacements.set(dotdotMarker, "[^\\n]*");
 	processed = processed.replaceAll("[..]", dotdotMarker);
+	const unknownDotdotMarker = getMarker();
+	replacements.set(unknownDotdotMarker, "[^\\n]*");
+	processed = processed.replaceAll("[??]", unknownDotdotMarker);
 	const ellipsisMarker = getMarker();
 	replacements.set(ellipsisMarker, "(?:[^\\n]*\\n)*");
 	processed = processed.replace(/\.\.\.\n/g, ellipsisMarker);
+	const unknownEllipsisMarker = getMarker();
+	replacements.set(unknownEllipsisMarker, "(?:[^\\n]*\\n)*");
+	processed = processed.replace(/\?\?\?\n/g, unknownEllipsisMarker);
 	const exeMarker = getMarker();
 	const exe = process.platform === "win32" ? "\\.exe" : "";
 	replacements.set(exeMarker, exe);
@@ -552,6 +605,82 @@ function normalizeOutput(output) {
 	return normalized;
 }
 /**
+* Like `patternToRegex()` but wraps each wildcard in a capturing group and
+* returns metadata describing what each group represents.
+*
+* Each occurrence gets a unique marker so that the `groups` array is ordered
+* by position in the string, matching the regex capture group indices.
+*/
+function patternToCapturingRegex(expected, customPatterns = {}) {
+	const replacements = /* @__PURE__ */ new Map();
+	const markerMeta = /* @__PURE__ */ new Map();
+	let markerIndex = 0;
+	const getMarker = () => {
+		return `${MARKER}${markerIndex++}${MARKER}`;
+	};
+	const replaceEach = (processed$1, pattern, regexStr, meta) => {
+		let result = processed$1;
+		if (typeof pattern === "string") while (result.includes(pattern)) {
+			const marker = getMarker();
+			replacements.set(marker, regexStr);
+			markerMeta.set(marker, meta);
+			result = result.replace(pattern, marker);
+		}
+		else {
+			let m;
+			while ((m = pattern.exec(result)) !== null) {
+				const marker = getMarker();
+				replacements.set(marker, regexStr);
+				markerMeta.set(marker, meta);
+				result = result.slice(0, m.index) + marker + result.slice(m.index + m[0].length);
+			}
+		}
+		return result;
+	};
+	let processed = expected;
+	processed = replaceEach(processed, "[..]", "([^\\n]*)", {
+		category: "generic",
+		multiline: false
+	});
+	processed = replaceEach(processed, "[??]", "([^\\n]*)", {
+		category: "unknown",
+		multiline: false
+	});
+	processed = replaceEach(processed, /\.\.\.\n/, "((?:[^\\n]*\\n)*)", {
+		category: "generic",
+		multiline: true
+	});
+	processed = replaceEach(processed, /\?\?\?\n/, "((?:[^\\n]*\\n)*)", {
+		category: "unknown",
+		multiline: true
+	});
+	const exe = process.platform === "win32" ? "\\.exe" : "";
+	processed = replaceEach(processed, "[EXE]", exe, null);
+	for (const [name, pattern] of Object.entries(customPatterns)) {
+		const placeholder = `[${name}]`;
+		const patternStr = pattern instanceof RegExp ? pattern.source : pattern;
+		processed = replaceEach(processed, placeholder, `(${patternStr})`, {
+			category: "named",
+			name,
+			multiline: false
+		});
+	}
+	const sortedEntries = [...replacements.entries()].sort((a, b) => {
+		return processed.indexOf(a[0]) - processed.indexOf(b[0]);
+	});
+	let regex = escapeRegex(processed);
+	const groups = [];
+	for (const [marker, replacement] of sortedEntries) {
+		const meta = markerMeta.get(marker);
+		if (meta) groups.push(meta);
+		regex = regex.replaceAll(escapeRegex(marker), replacement);
+	}
+	return {
+		regex: new RegExp(`^${regex}$`, "s"),
+		groups
+	};
+}
+/**
 * Check if actual output matches expected pattern.
 */
 function matchOutput(actual, expected, context, customPatterns = {}) {
@@ -560,11 +689,308 @@ function matchOutput(actual, expected, context, customPatterns = {}) {
 	if (normalizedExpected === "" && normalizedActual === "") return true;
 	return patternToRegex(preprocessPaths(normalizedExpected, context), customPatterns).test(normalizedActual);
 }
+/**
+* Match actual output against expected pattern and return wildcard captures.
+* Returns `null` if the output does not match.
+*/
+function matchAndCapture(actual, expected, context, customPatterns = {}) {
+	const normalizedActual = normalizeOutput(actual);
+	const normalizedExpected = normalizeOutput(expected);
+	if (normalizedExpected === "" && normalizedActual === "") return { captures: [] };
+	const { regex, groups } = patternToCapturingRegex(preprocessPaths(normalizedExpected, context), customPatterns);
+	const match = regex.exec(normalizedActual);
+	if (!match) return null;
+	return { captures: groups.map((meta, i) => ({
+		category: meta.category,
+		name: meta.name,
+		multiline: meta.multiline,
+		captured: match[i + 1] ?? ""
+	})) };
+}
+
+//#endregion
+//#region src/lib/expander.ts
+/**
+* Whether a wildcard category should be expanded at the given level.
+*
+* The hierarchy is: unknown < generic < all.
+*/
+function shouldExpandCategory(category, level) {
+	switch (level) {
+		case "unknown": return category === "unknown";
+		case "generic": return category === "unknown" || category === "generic";
+		case "all": return true;
+	}
+}
+const WILDCARD_TOKENS = [
+	{
+		token: "[..]",
+		category: "generic",
+		multiline: false
+	},
+	{
+		token: "[??]",
+		category: "unknown",
+		multiline: false
+	},
+	{
+		token: /\.\.\.\n/,
+		category: "generic",
+		multiline: true
+	},
+	{
+		token: /\?\?\?\n/,
+		category: "unknown",
+		multiline: true
+	}
+];
+/**
+* Expand wildcards in expected output by replacing them with captured actual text.
+*
+* Only wildcards whose category is targeted by `level` are replaced; others are
+* left intact. Returns `null` if actual output doesn't match expected pattern.
+*/
+function expandExpectedOutput(expected, actual, context, level, customPatterns) {
+	const normalizedExpected = normalizeOutput(expected);
+	const normalizedActual = normalizeOutput(actual);
+	if (normalizedExpected === "" && normalizedActual === "") return {
+		expandedOutput: "",
+		captures: [],
+		expandedCount: 0
+	};
+	const result = matchAndCapture(actual, expected, context, customPatterns);
+	if (!result) return null;
+	let output = normalizedExpected;
+	let expandedCount = 0;
+	const tokenPositions = [];
+	for (const wt of WILDCARD_TOKENS) {
+		let searchFrom = 0;
+		if (typeof wt.token === "string") while (true) {
+			const pos = output.indexOf(wt.token, searchFrom);
+			if (pos === -1) break;
+			tokenPositions.push({
+				pos,
+				length: wt.token.length
+			});
+			searchFrom = pos + wt.token.length;
+		}
+		else {
+			const re = new RegExp(wt.token.source, "g");
+			let m;
+			while ((m = re.exec(output)) !== null) tokenPositions.push({
+				pos: m.index,
+				length: m[0].length
+			});
+		}
+	}
+	if (customPatterns) for (const name of Object.keys(customPatterns)) {
+		const placeholder = `[${name}]`;
+		let searchFrom = 0;
+		while (true) {
+			const pos = output.indexOf(placeholder, searchFrom);
+			if (pos === -1) break;
+			tokenPositions.push({
+				pos,
+				length: placeholder.length
+			});
+			searchFrom = pos + placeholder.length;
+		}
+	}
+	tokenPositions.sort((a, b) => a.pos - b.pos);
+	const replacements = tokenPositions.map((tp, i) => ({
+		...tp,
+		capture: result.captures[i]
+	}));
+	for (let i = replacements.length - 1; i >= 0; i--) {
+		const r = replacements[i];
+		if (shouldExpandCategory(r.capture.category, level)) {
+			const replacement = r.capture.captured;
+			output = output.slice(0, r.pos) + replacement + output.slice(r.pos + r.length);
+			expandedCount++;
+		}
+	}
+	return {
+		expandedOutput: output,
+		captures: result.captures,
+		expandedCount
+	};
+}
+/**
+* Expand wildcards in a test file in place.
+*
+* Uses the same reverse-order strategy as `updater.ts` to maintain correct
+* string offsets when modifying multiple blocks.
+*/
+async function expandTestFile(file, results, level, context, customPatterns) {
+	let content = file.rawContent;
+	const changes = [];
+	let totalExpanded = 0;
+	const resultByBlock = new Map(results.map((result) => [result.block, result]));
+	const blocksWithResults = [...file.blocks].map((block) => ({
+		block,
+		result: resultByBlock.get(block)
+	})).reverse();
+	for (const { block, result } of blocksWithResults) {
+		if (!result || !block.expectedOutput) continue;
+		const expansion = expandExpectedOutput(block.expectedOutput, result.actualOutput, context, level, customPatterns);
+		if (!expansion || expansion.expandedCount === 0) continue;
+		const fence = "`".repeat(/^(`+)/.exec(block.rawContent)?.[1]?.length ?? 3);
+		const commandLines = block.command.split("\n").map((line, i) => {
+			return i === 0 ? `$ ${line}` : `> ${line}`;
+		});
+		const lines = [`${fence}console`, ...commandLines];
+		const trimmedOutput = expansion.expandedOutput.trimEnd();
+		if (trimmedOutput) lines.push(trimmedOutput);
+		lines.push(`? ${block.expectedExitCode ?? result.actualExitCode}`, fence);
+		const newBlockContent = lines.join("\n");
+		const blockStart = content.indexOf(block.rawContent);
+		if (blockStart !== -1) {
+			content = content.slice(0, blockStart) + newBlockContent + content.slice(blockStart + block.rawContent.length);
+			changes.push(block.name ?? `Line ${block.lineNumber}`);
+			totalExpanded += expansion.expandedCount;
+		}
+	}
+	if (changes.length > 0) await writeFile(file.path, content);
+	return {
+		expanded: changes.length > 0,
+		expandedCount: totalExpanded,
+		changes
+	};
+}
+
+//#endregion
+//#region src/lib/yaml-utils.ts
+/**
+* Manual key order comparator for YAML `sortMapEntries`.
+*
+* Keys listed in `order` appear first (in that order); unlisted keys sort
+* to the end alphabetically. Adapted from tbd sorting patterns
+* (`ordering.manual`).
+*/
+function manualKeyOrder(order) {
+	const orderMap = new Map(order.map((key, index) => [key, index]));
+	return (a, b) => {
+		const indexA = orderMap.get(a.key.value);
+		const indexB = orderMap.get(b.key.value);
+		if (indexA === void 0 && indexB === void 0) return a.key.value.localeCompare(b.key.value);
+		if (indexA === void 0) return 1;
+		if (indexB === void 0) return -1;
+		return indexA - indexB;
+	};
+}
+const DEFAULT_YAML_LINE_WIDTH = 88;
+const YAML_STRINGIFY_OPTIONS = {
+	lineWidth: DEFAULT_YAML_LINE_WIDTH,
+	defaultStringType: "PLAIN",
+	defaultKeyType: "PLAIN"
+};
+function stringifyYaml(data, options) {
+	return stringify(data, {
+		...YAML_STRINGIFY_OPTIONS,
+		...options
+	});
+}
+
+//#endregion
+//#region src/lib/capture-log.ts
+const TOP_LEVEL_ORDER = manualKeyOrder(["generated", "files"]);
+const FILE_ORDER = manualKeyOrder(["path", "blocks"]);
+const BLOCK_ORDER = manualKeyOrder([
+	"name",
+	"command",
+	"expected_exit_code",
+	"actual_exit_code",
+	"expected_output",
+	"actual_output",
+	"captures",
+	"passed"
+]);
+const CAPTURE_ORDER = manualKeyOrder([
+	"category",
+	"name",
+	"multiline",
+	"matched"
+]);
+/**
+* Sort comparator for `yaml.stringify`'s `sortMapEntries`.
+*
+* Dispatches to the correct field ordering based on which keys are present,
+* since the `yaml` package calls this for every map node in the document.
+*/
+const BLOCK_KEYS = new Set([
+	"name",
+	"command",
+	"expected_exit_code",
+	"actual_exit_code",
+	"expected_output",
+	"actual_output",
+	"captures",
+	"passed"
+]);
+const CAPTURE_KEYS = new Set([
+	"category",
+	"name",
+	"multiline",
+	"matched"
+]);
+function captureLogSortMapEntries(a, b) {
+	const aKey = a.key.value;
+	const bKey = b.key.value;
+	if (aKey === "generated" || aKey === "files" || bKey === "generated" || bKey === "files") return TOP_LEVEL_ORDER(a, b);
+	if (aKey === "blocks" || bKey === "blocks") return FILE_ORDER(a, b);
+	if (BLOCK_KEYS.has(aKey) && BLOCK_KEYS.has(bKey)) return BLOCK_ORDER(a, b);
+	if (CAPTURE_KEYS.has(aKey) && CAPTURE_KEYS.has(bKey)) return CAPTURE_ORDER(a, b);
+	return aKey.localeCompare(bKey);
+}
+/**
+* Build the capture log document structure from test results.
+*
+* `customPatterns` can be a static object or a per-file callback.
+* Separated from `writeCaptureLog` for testability.
+*/
+function buildCaptureLogDoc(fileResults, matchContext, customPatterns) {
+	const files = fileResults.map((fr) => {
+		const ctx = matchContext(fr.file);
+		const patterns = typeof customPatterns === "function" ? customPatterns(fr.file) : customPatterns;
+		const blocks = fr.results.map((r) => {
+			const captures = (matchAndCapture(r.actualOutput, r.block.expectedOutput, ctx, patterns)?.captures ?? []).map((c) => ({
+				category: c.category,
+				...c.name ? { name: c.name } : {},
+				multiline: c.multiline,
+				matched: c.captured
+			}));
+			return {
+				name: r.block.name,
+				command: r.block.command,
+				expected_exit_code: r.block.expectedExitCode,
+				actual_exit_code: r.actualExitCode,
+				expected_output: r.block.expectedOutput,
+				actual_output: r.actualOutput,
+				captures,
+				passed: r.passed
+			};
+		});
+		return {
+			path: fr.file.path,
+			blocks
+		};
+	});
+	return {
+		generated: (/* @__PURE__ */ new Date()).toISOString(),
+		files
+	};
+}
+/**
+* Write a YAML capture log file recording wildcard captures and execution metadata.
+*/
+async function writeCaptureLog(path, fileResults, matchContext, customPatterns) {
+	await writeFile(path, "# tryscript capture log\n" + stringifyYaml(buildCaptureLogDoc(fileResults, matchContext, customPatterns), { sortMapEntries: captureLogSortMapEntries }));
+}
 
 //#endregion
 //#region src/index.ts
-const VERSION = "0.1.6";
+const VERSION = "0.1.7";
 
 //#endregion
-export { createExecutionContext as a, parseTestFile as c, mergeConfig as d, resolveCoverageConfig as f, cleanupExecutionContext as i, defineConfig as l, matchOutput as n, runAfterHook as o, normalizeOutput as r, runBlock as s, VERSION as t, loadConfig as u };
-//# sourceMappingURL=src-Bd9-Y0qp.mjs.map
+export { defineConfig as _, stringifyYaml as a, resolveCoverageConfig as b, shouldExpandCategory as c, normalizeOutput as d, cleanupExecutionContext as f, parseTestFile as g, runBlock as h, manualKeyOrder as i, matchAndCapture as l, runAfterHook as m, buildCaptureLogDoc as n, expandExpectedOutput as o, createExecutionContext as p, writeCaptureLog as r, expandTestFile as s, VERSION as t, matchOutput as u, loadConfig as v, mergeConfig as y };
+//# sourceMappingURL=src-BQxIhzgF.mjs.map