@step-forge/step-forge 0.0.19 → 0.0.20

package/dist/step-forge.js

@@ -1,4 +1,4 @@
-import { Given, Then, When } from "@cucumber/cucumber";
+import { o as globalRegistry, r as globalHookRegistry } from "./hooks-CywugMQQ.js";
 import _ from "lodash";
 import { glob } from "node:fs/promises";
 import * as path from "node:path";
@@ -10,25 +10,36 @@ import * as messages from "@cucumber/messages";
 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,151 +78,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") };
-};
+const thenBuilder = () => ({ statement: thenStatement() });
 //#endregion
 //#region src/world.ts
 function mergeCustomizer(objValue, srcValue) {
@@ -283,7 +266,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);
 		}
@@ -480,20 +463,27 @@ function parseFeatureContent(content, filePath) {
 	if (!feature) return [];
 	const featureBackground = [];
 	const scenarios = [];
+	const featureTags = tagNames(feature.tags);
 	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.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath, featureTags));
 		if (child.rule) {
 			const ruleBackground = [...featureBackground];
+			const ruleTags = [...featureTags, ...tagNames(child.rule.tags)];
 			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));
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath, ruleTags));
 			}
 		}
 	}
 	return scenarios;
 }
-function expandScenario(scenario, backgroundSteps, filePath) {
+/** Extract tag names (each keeping its leading `@`), deduped in order. */
+function tagNames(tags) {
+	return [...new Set((tags ?? []).map((t) => t.name))];
+}
+function expandScenario(scenario, backgroundSteps, filePath, inheritedTags) {
+	const scenarioTags = [...inheritedTags, ...tagNames(scenario.tags)];
 	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
 		const bgParsed = convertSteps(backgroundSteps);
 		const scenarioParsed = convertSteps(scenario.steps);
@@ -501,13 +491,15 @@ function expandScenario(scenario, backgroundSteps, filePath) {
 		return [{
 			name: scenario.name,
 			file: filePath,
-			steps: allSteps
+			steps: allSteps,
+			tags: scenarioTags
 		}];
 	}
 	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);
+		const exampleTags = [...scenarioTags, ...tagNames(example.tags)];
 		for (const row of example.tableBody) {
 			const values = row.cells.map((c) => c.value);
 			const substitution = {};
@@ -521,9 +513,11 @@ function expandScenario(scenario, backgroundSteps, filePath) {
 			}));
 			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
 			results.push({
-				name: `${scenario.name} (${values.join(", ")})`,
+				name: headers.map((h, i) => `${h}=${values[i]}`).join(", "),
 				file: filePath,
-				steps: allSteps
+				steps: allSteps,
+				tags: exampleTags,
+				outline: { name: scenario.name }
 			});
 		}
 	}
@@ -727,6 +721,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 +791,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