@step-forge/step-forge 0.0.19 → 0.0.21

package/dist/step-forge.js

@@ -1,34 +1,41 @@
-import { Given, Then, When } from "@cucumber/cucumber";
+import { o as globalRegistry, r as globalHookRegistry } from "./hooks-CywugMQQ.js";
+import { i as BasicWorld, n as parseFeatureFiles, r as globFiles, t as parseFeatureContent } from "./gherkinParser-CKARHgt4.js";
 import _ from "lodash";
-import { glob } from "node:fs/promises";
-import * as path from "node:path";
 import ts from "typescript";
-import * as fs from "node:fs";
-import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
-import * as messages from "@cucumber/messages";
 //#region src/builderTypeUtils.ts
 const isString = (statement) => typeof statement === "string";
 //#endregion
 //#region src/parsers.ts
-/** Matches a quoted string (`{string}`) and passes the unquoted contents through. */
+/** Matches a quoted string (`{string}`) and strips the surrounding quotes. */
 const stringParser = {
-	parse: (value) => String(value),
-	gherkin: "{string}"
+	name: "string",
+	regexp: [/"([^"\\]*(\\.[^"\\]*)*)"/, /'([^'\\]*(\\.[^'\\]*)*)'/],
+	parse: (value) => {
+		const match = /^"([\s\S]*)"$/.exec(value) ?? /^'([\s\S]*)'$/.exec(value);
+		return match ? match[1].replace(/\\(["'])/g, "$1") : value;
+	}
 };
 /** Matches an unquoted integer (`{int}`). */
 const intParser = {
-	parse: (value) => typeof value === "number" ? value : parseInt(String(value), 10),
-	gherkin: "{int}"
+	name: "int",
+	regexp: /-?\d+/,
+	parse: (value) => parseInt(value, 10)
 };
 /** Matches an unquoted floating point number (`{float}`). */
 const numberParser = {
-	parse: (value) => typeof value === "number" ? value : parseFloat(String(value)),
-	gherkin: "{float}"
+	name: "float",
+	regexp: /-?\d*\.?\d+/,
+	parse: (value) => parseFloat(value)
 };
-/** Matches an unquoted `true`/`false` word (`{word}`) and parses it to a boolean. */
+/**
+* Matches an unquoted `true`/`false` word (`{boolean}`) and parses it to a
+* boolean. Unlike the others this is a genuine custom parameter type — cucumber
+* has no built-in `boolean` — so its `regexp`/`parse` are what the matcher uses.
+*/
 const booleanParser = {
-	parse: (value) => value === true || value === "true",
-	gherkin: "{word}"
+	name: "boolean",
+	regexp: /true|false/,
+	parse: (value) => value === "true"
 };
 //#endregion
 //#region src/utils.ts
@@ -67,187 +74,123 @@ const requireFromThen = (keys, world) => {
 };
 //#endregion
 //#region src/common.ts
-const cucFunctionMap = {
-	given: Given,
-	when: When,
-	then: Then
-};
+/**
+* The runtime core of the builder chain. `addStep` is deliberately phase-agnostic:
+* the calling builder (given/when/then) has already computed the exact type of the
+* step function via its two type parameters:
+*
+* - `StepFnInput`  — the `{ variables, given, when, then }` object the step receives,
+*   with each phase already narrowed to its declared dependencies.
+* - `StepFnOutput` — the phase-appropriate return type (`Partial<State>`, or `void`).
+*
+* Everything else is plain runtime data (a statement function, the step type, the
+* dependency map, the parsers), so `addStep` carries no generics for them.
+*/
 const addStep = (statement, stepType, dependencies = {
 	given: {},
 	when: {},
 	then: {}
 }, declaredParsers) => (stepFunction) => {
-	const statementFunction = statement;
 	const { given: givenDependencies, when: whenDependencies, then: thenDependencies } = dependencies;
-	const argCount = statementFunction.length;
+	const argCount = statement.length;
 	const parsers = declaredParsers ?? Array.from({ length: argCount }, () => stringParser);
-	const expression = statementFunction(...parsers.map((parser) => parser.gherkin));
+	const expression = statement(...parsers.map((parser) => `{${parser.name}}`));
+	const execute = async (world, capturedArgs) => {
+		const requiredKeys = (deps) => Object.entries(deps).filter(([, value]) => value === "required").map(([key]) => key);
+		const result = await stepFunction({
+			variables: capturedArgs,
+			given: {
+				..._.pick(world.given, Object.keys(givenDependencies)),
+				...requireFromGiven(requiredKeys(givenDependencies), world)
+			},
+			when: {
+				..._.pick(world.when, Object.keys(whenDependencies)),
+				...requireFromWhen(requiredKeys(whenDependencies), world)
+			},
+			then: {
+				..._.pick(world.then, Object.keys(thenDependencies)),
+				...requireFromThen(requiredKeys(thenDependencies), world)
+			}
+		});
+		world[stepType].merge({ ...result });
+	};
+	globalRegistry.add({
+		stepType,
+		expression,
+		parsers,
+		execute
+	});
 	return {
 		statement,
 		expression,
 		dependencies,
 		stepType,
-		stepFunction,
-		register: () => {
-			const cucStepFunction = Object.defineProperty(async function(...args) {
-				const coercedArgs = parsers.map((parser, index) => parser.parse(args[index]));
-				const ensuredGivenValues = requireFromGiven(Object.entries(givenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
-				const narrowedGiven = {
-					..._.pick(this.given, Object.keys(givenDependencies ?? {})),
-					...ensuredGivenValues
-				};
-				const ensuredWhenValues = requireFromWhen(Object.entries(whenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
-				const narrowedWhen = {
-					..._.pick(this.when, Object.keys(whenDependencies ?? {})),
-					...ensuredWhenValues
-				};
-				const ensuredThenValues = requireFromThen(Object.entries(thenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
-				const result = await stepFunction({
-					variables: coercedArgs,
-					given: narrowedGiven,
-					when: narrowedWhen,
-					then: {
-						..._.pick(this.then, Object.keys(thenDependencies ?? {})),
-						...ensuredThenValues
-					}
-				});
-				this[stepType].merge({ ...result });
-			}, "length", {
-				value: argCount,
-				configurable: true
-			});
-			const cucStep = cucFunctionMap[stepType];
-			cucStep(expression, cucStepFunction);
-			return {
-				stepType,
-				expression,
-				dependencies,
-				statement: statementFunction,
-				stepFunction
-			};
-		}
+		stepFunction
 	};
 };
 //#endregion
 //#region src/given.ts
-const givenDependencies = (statement, stepType, parsers) => (dependencies) => {
-	return { step: addStep(statement, stepType, {
-		...dependencies,
-		when: {},
-		then: {}
-	}, parsers) };
-};
-const givenParsers = (statement, stepType) => (parsers) => {
-	return {
-		dependencies: givenDependencies(statement, stepType, parsers),
-		step: addStep(statement, stepType, void 0, parsers)
-	};
-};
-const givenStatement = (stepType) => (statement) => {
-	let normalizedStatement;
-	if (isString(statement)) normalizedStatement = (() => statement);
-	else normalizedStatement = statement;
+const GIVEN = "given";
+const givenDependencies = (statement, parsers) => (dependencies) => ({ step: addStep(statement, GIVEN, {
+	...dependencies,
+	when: {},
+	then: {}
+}, parsers) });
+const givenParsers = (statement) => (parsers) => ({
+	dependencies: givenDependencies(statement, parsers),
+	step: addStep(statement, GIVEN, void 0, parsers)
+});
+const givenStatement = () => (statement) => {
+	const normalizedStatement = isString(statement) ? () => statement : statement;
 	return {
-		dependencies: givenDependencies(normalizedStatement, stepType),
-		parsers: givenParsers(normalizedStatement, stepType),
-		step: addStep(normalizedStatement, stepType)
+		dependencies: givenDependencies(normalizedStatement),
+		parsers: givenParsers(normalizedStatement),
+		step: addStep(normalizedStatement, GIVEN)
 	};
 };
-const givenBuilder = () => {
-	return { statement: givenStatement("given") };
-};
+const givenBuilder = () => ({ statement: givenStatement() });
 //#endregion
 //#region src/when.ts
-const whenDependencies = (statement, stepType, parsers) => (dependencies) => {
-	return { step: addStep(statement, stepType, {
-		given: dependencies.given ?? {},
-		when: dependencies.when ?? {},
-		then: {}
-	}, parsers) };
-};
-const whenParsers = (statement, stepType) => (parsers) => {
-	return {
-		dependencies: whenDependencies(statement, stepType, parsers),
-		step: addStep(statement, stepType, void 0, parsers)
-	};
-};
-const whenStatement = (stepType) => (statement) => {
-	let normalizedStatement;
-	if (isString(statement)) normalizedStatement = (() => statement);
-	else normalizedStatement = statement;
+const WHEN = "when";
+const whenDependencies = (statement, parsers) => (dependencies) => ({ step: addStep(statement, WHEN, {
+	given: dependencies.given ?? {},
+	when: dependencies.when ?? {},
+	then: {}
+}, parsers) });
+const whenParsers = (statement) => (parsers) => ({
+	dependencies: whenDependencies(statement, parsers),
+	step: addStep(statement, WHEN, void 0, parsers)
+});
+const whenStatement = () => (statement) => {
+	const normalizedStatement = isString(statement) ? () => statement : statement;
 	return {
-		dependencies: whenDependencies(normalizedStatement, stepType),
-		parsers: whenParsers(normalizedStatement, stepType),
-		step: addStep(normalizedStatement, stepType)
+		dependencies: whenDependencies(normalizedStatement),
+		parsers: whenParsers(normalizedStatement),
+		step: addStep(normalizedStatement, WHEN)
 	};
 };
-const whenBuilder = () => {
-	return { statement: whenStatement("when") };
-};
+const whenBuilder = () => ({ statement: whenStatement() });
 //#endregion
 //#region src/then.ts
-const thenDependencies = (statement, stepType, parsers) => (dependencies) => {
-	return { step: addStep(statement, stepType, {
-		given: dependencies.given ?? {},
-		when: dependencies.when ?? {},
-		then: dependencies.then ?? {}
-	}, parsers) };
-};
-const thenParsers = (statement, stepType) => (parsers) => {
-	return {
-		dependencies: thenDependencies(statement, stepType, parsers),
-		step: addStep(statement, stepType, void 0, parsers)
-	};
-};
-const thenStatement = (stepType) => (statement) => {
-	let normalizedStatement;
-	if (isString(statement)) normalizedStatement = (() => statement);
-	else normalizedStatement = statement;
+const THEN = "then";
+const thenDependencies = (statement, parsers) => (dependencies) => ({ step: addStep(statement, THEN, {
+	given: dependencies.given ?? {},
+	when: dependencies.when ?? {},
+	then: dependencies.then ?? {}
+}, parsers) });
+const thenParsers = (statement) => (parsers) => ({
+	dependencies: thenDependencies(statement, parsers),
+	step: addStep(statement, THEN, void 0, parsers)
+});
+const thenStatement = () => (statement) => {
+	const normalizedStatement = isString(statement) ? () => statement : statement;
 	return {
-		dependencies: thenDependencies(normalizedStatement, stepType),
-		parsers: thenParsers(normalizedStatement, stepType),
-		step: addStep(normalizedStatement, stepType)
+		dependencies: thenDependencies(normalizedStatement),
+		parsers: thenParsers(normalizedStatement),
+		step: addStep(normalizedStatement, THEN)
 	};
 };
-const thenBuilder = () => {
-	return { statement: thenStatement("then") };
-};
-//#endregion
-//#region src/world.ts
-function mergeCustomizer(objValue, srcValue) {
-	if (_.isArray(objValue)) return objValue.concat(srcValue);
-	else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
-	return objValue;
-}
-var BasicWorld = class {
-	givenState = {};
-	whenState = {};
-	thenState = {};
-	get given() {
-		return {
-			...this.givenState,
-			merge: (newState) => {
-				this.givenState = _.merge({ ...this.givenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-	get when() {
-		return {
-			...this.whenState,
-			merge: (newState) => {
-				this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-	get then() {
-		return {
-			...this.thenState,
-			merge: (newState) => {
-				this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
-			}
-		};
-	}
-};
+const thenBuilder = () => ({ statement: thenStatement() });
 //#endregion
 //#region src/analyzer/stepExtractor.ts
 const BUILDER_NAMES = {
@@ -283,7 +226,7 @@ function extractStepDefinitions(filePaths, tsConfigPath) {
 function extractFromSourceFile(sourceFile, checker) {
 	const results = [];
 	function visit(node) {
-		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "register") {
+		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "step") {
 			const meta = extractFromRegisterCall(node, sourceFile, checker);
 			if (meta) results.push(meta);
 		}
@@ -466,105 +409,6 @@ function resolveReExportedCall(chain, checker) {
 	return null;
 }
 //#endregion
-//#region src/analyzer/gherkinParser.ts
-function parseFeatureFiles(filePaths) {
-	const scenarios = [];
-	for (const filePath of filePaths) {
-		const parsed = parseFeatureContent(fs.readFileSync(filePath, "utf-8"), filePath);
-		scenarios.push(...parsed);
-	}
-	return scenarios;
-}
-function parseFeatureContent(content, filePath) {
-	const feature = new Parser(new AstBuilder(messages.IdGenerator.uuid()), new GherkinClassicTokenMatcher()).parse(content).feature;
-	if (!feature) return [];
-	const featureBackground = [];
-	const scenarios = [];
-	for (const child of feature.children) {
-		if (child.background) featureBackground.push(...child.background.steps);
-		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath));
-		if (child.rule) {
-			const ruleBackground = [...featureBackground];
-			for (const ruleChild of child.rule.children) {
-				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
-				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath));
-			}
-		}
-	}
-	return scenarios;
-}
-function expandScenario(scenario, backgroundSteps, filePath) {
-	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
-		const bgParsed = convertSteps(backgroundSteps);
-		const scenarioParsed = convertSteps(scenario.steps);
-		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
-		return [{
-			name: scenario.name,
-			file: filePath,
-			steps: allSteps
-		}];
-	}
-	const results = [];
-	for (const example of scenario.examples) {
-		if (!example.tableHeader || example.tableBody.length === 0) continue;
-		const headers = example.tableHeader.cells.map((c) => c.value);
-		for (const row of example.tableBody) {
-			const values = row.cells.map((c) => c.value);
-			const substitution = {};
-			headers.forEach((h, i) => {
-				substitution[h] = values[i];
-			});
-			const bgParsed = convertSteps(backgroundSteps);
-			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
-				...step,
-				text: substituteExampleValues(step.text, substitution)
-			}));
-			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
-			results.push({
-				name: `${scenario.name} (${values.join(", ")})`,
-				file: filePath,
-				steps: allSteps
-			});
-		}
-	}
-	return results;
-}
-function convertSteps(steps) {
-	return steps.map((step) => ({
-		keyword: normalizeKeyword(step.keyword),
-		text: step.text,
-		line: step.location.line,
-		column: (step.location.column ?? 1) + step.keyword.length
-	}));
-}
-function normalizeKeyword(keyword) {
-	const trimmed = keyword.trim();
-	if (trimmed === "Given") return "Given";
-	if (trimmed === "When") return "When";
-	if (trimmed === "Then") return "Then";
-	if (trimmed === "And") return "And";
-	if (trimmed === "But") return "But";
-	return "Given";
-}
-function resolveEffectiveKeywords(steps) {
-	let lastEffective = "Given";
-	return steps.map((step) => {
-		let effectiveKeyword;
-		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
-		else effectiveKeyword = step.keyword;
-		lastEffective = effectiveKeyword;
-		return {
-			...step,
-			effectiveKeyword
-		};
-	});
-}
-function substituteExampleValues(text, substitution) {
-	let result = text;
-	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
-	return result;
-}
-//#endregion
 //#region src/analyzer/stepMatcher.ts
 function compileDefinitions(definitions) {
 	const compiled = [];
@@ -699,8 +543,8 @@ function runRules(rules, scenario, matchedSteps) {
 //#region src/analyzer/index.ts
 async function analyze(config, options) {
 	const rules = options?.rules ?? defaultRules;
-	const stepFilePaths = await resolveGlobs(config.stepFiles);
-	const featureFilePaths = await resolveGlobs(config.featureFiles);
+	const stepFilePaths = await globFiles(config.stepFiles);
+	const featureFilePaths = await globFiles(config.featureFiles);
 	if (stepFilePaths.length === 0) return [];
 	if (featureFilePaths.length === 0) return [];
 	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
@@ -712,11 +556,6 @@ async function analyze(config, options) {
 	}
 	return diagnostics;
 }
-async function resolveGlobs(patterns) {
-	const files = [];
-	for (const pattern of patterns) for await (const file of glob(pattern)) files.push(path.resolve(file));
-	return [...new Set(files)];
-}
 //#endregion
 //#region src/init.ts
 const createBuilders = () => {
@@ -727,6 +566,65 @@ const createBuilders = () => {
 	};
 };
 //#endregion
+//#region src/hooks.ts
+/**
+* Run before every scenario, with access to that scenario's fresh world. For
+* side effects only (reset a mock, seed an external system) — return values are
+* ignored; seed test *state* with given steps so the dependency graph stays the
+* single source of truth.
+*/
+function beforeScenario(fn) {
+	globalHookRegistry.add({
+		scope: "scenario",
+		timing: "before",
+		fn
+	});
+}
+/**
+* Run after every scenario (even when a step failed), with access to that
+* scenario's world. Runs in reverse registration order so teardown unwinds
+* setup. For cleanup side effects only.
+*/
+function afterScenario(fn) {
+	globalHookRegistry.add({
+		scope: "scenario",
+		timing: "after",
+		fn
+	});
+}
+/** Run once at the start of each feature file. No world exists at this boundary. */
+function beforeFeature(fn) {
+	globalHookRegistry.add({
+		scope: "feature",
+		timing: "before",
+		fn
+	});
+}
+/** Run once at the end of each feature file (reverse registration order). */
+function afterFeature(fn) {
+	globalHookRegistry.add({
+		scope: "feature",
+		timing: "after",
+		fn
+	});
+}
+/** Run once before the entire test run, across all feature files. */
+function beforeAll(fn) {
+	globalHookRegistry.add({
+		scope: "global",
+		timing: "before",
+		fn
+	});
+}
+/** Run once after the entire test run (reverse registration order). */
+function afterAll(fn) {
+	globalHookRegistry.add({
+		scope: "global",
+		timing: "after",
+		fn
+	});
+}
+//#endregion
 //#region src/index.ts
 const analyzer = {
 	analyze,
@@ -738,6 +636,6 @@ const analyzer = {
 	defaultRules
 };
 //#endregion
-export { BasicWorld, analyzer, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
+export { BasicWorld, afterAll, afterFeature, afterScenario, analyzer, beforeAll, beforeFeature, beforeScenario, booleanParser, createBuilders, givenBuilder, intParser, numberParser, stringParser, thenBuilder, whenBuilder };
 
 //# sourceMappingURL=step-forge.js.map