@step-forge/step-forge 0.0.11 → 0.0.13

package/features/analyzer/fixtures/steps.ts

@@ -1,113 +0,0 @@
-import { givenBuilder } from "../../../src/given";
-import { whenBuilder } from "../../../src/when";
-import { thenBuilder } from "../../../src/then";
-
-type GivenState = {
-  user: { type: string; token: string };
-  account: { id: string };
-};
-type WhenState = {
-  user: { type: string; token: string; saved: boolean };
-  result: { success: boolean };
-};
-type ThenState = Record<string, never>;
-
-// --- No dependency steps --- //
-
-givenBuilder<GivenState>()
-  .statement("I started")
-  .step(() => ({}))
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I got here")
-  .step(() => ({}))
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("everything was good")
-  .step(() => {})
-  .register();
-
-// --- Steps that produce state --- //
-
-givenBuilder<GivenState>()
-  .statement("a user")
-  .step(() => {
-    return {
-      user: { type: "person", token: "abc" },
-    };
-  })
-  .register();
-
-givenBuilder<GivenState>()
-  .statement((name: string) => `a user named ${name}`)
-  .step(({ variables: [name] }) => {
-    return {
-      user: { type: "person", token: name },
-    };
-  })
-  .register();
-
-givenBuilder<GivenState>()
-  .statement("an account")
-  .step(() => {
-    return {
-      account: { id: "acct-1" },
-    };
-  })
-  .register();
-
-// --- Ambiguous steps (same expression, two definitions) --- //
-
-givenBuilder<GivenState>()
-  .statement("the system is ready")
-  .step(() => ({}))
-  .register();
-
-givenBuilder<GivenState>()
-  .statement("the system is ready")
-  .step(() => ({}))
-  .register();
-
-// --- When steps with dependencies --- //
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I save the user")
-  .dependencies({ given: { user: "required" } })
-  .step(({ given: { user } }) => {
-    return {
-      user: { ...user, saved: true },
-    };
-  })
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I delete the account")
-  .dependencies({ given: { account: "required" } })
-  .step(() => {
-    return {
-      result: { success: true },
-    };
-  })
-  .register();
-
-// --- Then steps with dependencies --- //
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("there is a user")
-  .dependencies({ when: { user: "required" } })
-  .step(() => {})
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement((name: string) => `the user's name is ${name}`)
-  .dependencies({ when: { user: "required" } })
-  .step(() => {})
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("the account might exist")
-  .dependencies({ given: { account: "optional" } })
-  .step(() => {})
-  .register();

package/features/analyzer/fixtures/undefined-step.feature

@@ -1,5 +0,0 @@
-Feature: Undefined step
-  Scenario: Uses an undefined step
-    Given a user
-    When I do something that does not exist
-    Then everything was good

package/features/analyzer/fixtures/undefined-with-missing-dep.feature

@@ -1,5 +0,0 @@
-Feature: Undefined step with missing dependency
-  Scenario: Has both undefined and missing dependency
-    When I save the user
-    When I do something that does not exist
-    Then everything was good

package/features/analyzer/fixtures/valid-and-but-keywords.feature

@@ -1,8 +0,0 @@
-Feature: And/But keyword resolution
-
-  Scenario: And and But resolve correctly
-    Given a user
-    And an account
-    When I save the user
-    But I delete the account
-    Then there is a user

package/features/analyzer/fixtures/valid-deps.feature

@@ -1,6 +0,0 @@
-Feature: Satisfied dependencies
-
-  Scenario: Full chain with required deps
-    Given a user
-    When I save the user
-    Then there is a user

package/features/analyzer/fixtures/valid-no-deps.feature

@@ -1,6 +0,0 @@
-Feature: No dependencies
-
-  Scenario: Steps with no dependencies
-    Given I started
-    When I got here
-    Then everything was good

package/features/analyzer/fixtures/valid-optional-deps.feature

@@ -1,6 +0,0 @@
-Feature: Optional dependencies
-
-  Scenario: Optional dep not produced is fine
-    Given I started
-    When I got here
-    Then the account might exist

package/features/analyzer/fixtures/valid-variables.feature

@@ -1,6 +0,0 @@
-Feature: Variables with dependencies
-
-  Scenario: Variables and satisfied deps
-    Given a user named "John"
-    When I save the user
-    Then the user's name is "John"

package/features/basic.feature

@@ -1,21 +0,0 @@
-Feature: Steps written in gherkin can be matched to Step Forge steps
-
-    Scenario: Basic feature steps with no dependencies or variables can be run as a cucumber scenario
-        Given I started
-        When I got here
-        Then everything was good
-
-    Scenario: Basic feature steps with dependencies can be run as a cucumber scenario
-        Given a user
-        When I save the user
-        Then there is a user
-
-    Scenario: Basic feature steps with variables can be run as a cucumber scenario
-        Given a user named "John"
-        When I save the user
-        Then there is a user
-
-    Scenario: Basic feature steps with dependencies and variables can be run as a cucumber scenario
-        Given a user
-        When I name the user "John"
-        Then the user's name is "John"

package/features/exported.feature

@@ -1,6 +0,0 @@
-Feature: Builders can be re-exported for ease of use
-
-    Scenario: Exported steps can be used in cucumber scenarios
-        Given a bank user
-        When I deposit "1000" "USD"
-        Then the balance is "1000"

package/features/steps/analyzerSteps.ts

@@ -1,67 +0,0 @@
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { Given, When, Then } from "@cucumber/cucumber";
-import { expect } from "earl";
-import { analyze, Diagnostic } from "../../src/analyzer/index";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const fixturesDir = path.resolve(__dirname, "../analyzer/fixtures");
-
-let fixtureStepFile: string;
-let fixtureFeatureFile: string;
-let diagnostics: Diagnostic[];
-
-Given("step definitions from {string}", function (fileName: string) {
-  fixtureStepFile = path.join(fixturesDir, fileName);
-});
-
-Given("a feature file {string}", function (fileName: string) {
-  fixtureFeatureFile = path.join(fixturesDir, fileName);
-});
-
-When("I analyze the files", async function () {
-  diagnostics = await analyze({
-    stepFiles: [fixtureStepFile],
-    featureFiles: [fixtureFeatureFile],
-  });
-});
-
-Then("there should be no errors", function () {
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  expect(errors).toHaveLength(0);
-});
-
-Then("there should be {int} error/errors", function (count: number) {
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  expect(errors).toHaveLength(count);
-});
-
-Then("an error should mention {string}", function (substring: string) {
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  const found = errors.some((e) => e.message.includes(substring));
-  expect(found).toEqual(true);
-});
-
-Then(
-  "there is/are {int} error/errors for rule {string}",
-  function (count: number, rule: string) {
-    const errors = diagnostics.filter(
-      (d) => d.severity === "error" && d.rule === rule
-    );
-    expect(errors).toHaveLength(count);
-  }
-);
-
-Then(
-  "the error on line {int} should span columns {int} to {int}",
-  function (line: number, startCol: number, endCol: number) {
-    const errors = diagnostics.filter(
-      (d) => d.severity === "error" && d.range.startLine === line
-    );
-    expect(errors.length).toBeGreaterThanOrEqual(1);
-    const error = errors[0];
-    expect(error.range.startColumn).toEqual(startCol);
-    expect(error.range.endColumn).toEqual(endCol);
-    expect(error.range.endLine).toEqual(line);
-  }
-);

package/features/steps/commonSteps.ts

@@ -1,93 +0,0 @@
-import { givenBuilder } from "../../src/given";
-import { whenBuilder } from "../../src/when";
-import { thenBuilder } from "../../src/then";
-import { GivenState, ThenState, WhenState } from "./world";
-import { expect } from "earl";
-
-// --- No dependency no variable steps --- //
-givenBuilder<GivenState>()
-  .statement("I started")
-  .step(() => ({}))
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I got here")
-  .step(() => ({}))
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("everything was good")
-  .step(() => ({}))
-  .register();
-
-// --- Dependency only steps --- //
-givenBuilder<GivenState>()
-  .statement("a user")
-  .step(() => {
-    return {
-      user: {
-        type: "person",
-        token: "random",
-      },
-    };
-  })
-  .register();
-
-whenBuilder<GivenState, WhenState>()
-  .statement("I save the user")
-  .dependencies({ given: { user: "required" } })
-  .step(({ given: { user } }) => {
-    return {
-      user: {
-        ...user,
-        saved: true,
-      },
-    };
-  })
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement("there is a user")
-  .dependencies({ when: { user: "required" } })
-  .step(({ when: { user } }) => {
-    expect(user.saved).toBeTruthy();
-  })
-  .register();
-
-// --- Variable only steps --- //
-givenBuilder<GivenState>()
-  .statement((userName: string) => `a user named ${userName}`)
-  .step(({ variables: [userName] }) => {
-    return {
-      user: {
-        type: "person",
-        token: userName,
-      },
-    };
-  })
-  .register();
-
-// --- More complex steps --- //
-
-whenBuilder<GivenState, WhenState>()
-  .statement((userName: string) => `I name the user ${userName}`)
-  .dependencies({ given: { user: "required" } })
-  .step(({ given: { user }, variables: [userName] }) => {
-    return {
-      user: {
-        ...user,
-        token: userName,
-        saved: true,
-      },
-    };
-  })
-  .register();
-
-thenBuilder<GivenState, WhenState, ThenState>()
-  .statement((userName: string) => `the user's name is ${userName}`)
-  .dependencies({ when: { user: "required" } })
-  .step(({ when: { user }, variables: [userName] }) => {
-    const token = user.token;
-    expect(token).toEqual(userName);
-  })
-  .register();

package/features/steps/exportedSteps.ts

@@ -1,42 +0,0 @@
-import { expect } from "earl";
-import { givenBuilder } from "../../src/given";
-import { thenBuilder } from "../../src/then";
-import { whenBuilder } from "../../src/when";
-import { GivenState, ThenState, WhenState } from "./world";
-
-const Given = givenBuilder<GivenState>().statement;
-const When = whenBuilder<GivenState, WhenState>().statement;
-const Then = thenBuilder<GivenState, WhenState, ThenState>().statement;
-
-Given("a bank user")
-  .step(() => {
-    return {
-      user: {
-        type: "customer",
-        token: "random",
-      },
-    };
-  })
-  .register();
-
-When((amount: string, currency: string) => `I deposit ${amount} ${currency}`)
-  .dependencies({ given: { user: "required" } })
-  .step(({ variables: [rawAmount, currency], given: { user } }) => {
-    const amount = parseFloat(rawAmount);
-    return {
-      deposit: {
-        amount,
-        currency,
-        user,
-      },
-    };
-  })
-  .register();
-
-Then((amount: string) => `the balance is ${amount}`)
-  .dependencies({ when: { deposit: "required" } })
-  .step(({ when: { deposit }, variables: [rawAmount] }) => {
-    const amount = parseFloat(rawAmount);
-    expect(deposit.amount).toEqual(amount);
-  })
-  .register();

package/features/steps/world.ts

@@ -1,29 +0,0 @@
-import { setWorldConstructor } from "@cucumber/cucumber";
-import { BasicWorld } from "../../src/world";
-
-export interface GivenState {
-  user: {
-    type: string;
-    token: string;
-  };
-}
-
-export interface WhenState {
-  user: {
-    type: string;
-    token: string;
-    saved: boolean;
-  };
-  deposit: {
-    amount: number;
-    currency: string;
-    user: {
-      type: string;
-      token: string;
-    };
-  };
-}
-
-export interface ThenState {}
-
-setWorldConstructor(BasicWorld<GivenState, WhenState, ThenState>);

package/src/analyzer/cli.ts

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-
-import { analyze } from "./index.js";
-import type { AnalyzerConfig, Diagnostic } from "./types.js";
-
-function parseArgs(args: string[]): AnalyzerConfig {
-  const config: AnalyzerConfig = {
-    stepFiles: [],
-    featureFiles: [],
-  };
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const next = args[i + 1];
-
-    if ((arg === "--steps" || arg === "-s") && next) {
-      config.stepFiles.push(next);
-      i++;
-    } else if ((arg === "--features" || arg === "-f") && next) {
-      config.featureFiles.push(next);
-      i++;
-    } else if (arg === "--tsconfig" && next) {
-      config.tsConfigPath = next;
-      i++;
-    } else if (arg === "--help" || arg === "-h") {
-      printUsage();
-      process.exit(0);
-    }
-  }
-
-  return config;
-}
-
-function printUsage() {
-  console.log(`Usage: step-forge-analyze [options]
-
-Options:
-  -s, --steps <glob>      Glob pattern for step definition files (repeatable)
-  -f, --features <glob>   Glob pattern for feature files (repeatable)
-  --tsconfig <path>       Path to tsconfig.json (default: auto-detect)
-  -h, --help              Show this help message
-
-Example:
-  step-forge-analyze --steps "features/steps/**/*.ts" --features "features/**/*.feature"
-`);
-}
-
-function formatDiagnostic(diag: Diagnostic): string {
-  const location = `${diag.file}:${diag.range.startLine}:${diag.range.startColumn}`;
-  return `${location} - ${diag.severity}: ${diag.message}`;
-}
-
-async function main() {
-  const args = process.argv.slice(2);
-  const config = parseArgs(args);
-
-  if (config.stepFiles.length === 0 || config.featureFiles.length === 0) {
-    console.error(
-      "Error: Both --steps and --features are required.\n"
-    );
-    printUsage();
-    process.exit(1);
-  }
-
-  const diagnostics = await analyze(config);
-
-  if (diagnostics.length === 0) {
-    console.log("No issues found.");
-    process.exit(0);
-  }
-
-  const errors = diagnostics.filter((d) => d.severity === "error");
-  const warnings = diagnostics.filter((d) => d.severity === "warning");
-
-  for (const diag of diagnostics) {
-    console.log(formatDiagnostic(diag));
-  }
-
-  console.log(
-    `\nFound ${errors.length} error(s) and ${warnings.length} warning(s).`
-  );
-  process.exit(errors.length > 0 ? 1 : 0);
-}
-
-// Only run when invoked directly (not when imported by Cucumber or other tools)
-const isDirectRun =
-  import.meta.url === `file://${process.argv[1]}` ||
-  process.argv[1]?.endsWith("analyzer-cli.js") ||
-  process.argv[1]?.endsWith("analyzer-cli.ts");
-
-if (isDirectRun) {
-  main().catch((err) => {
-    console.error("Analyzer failed:", err);
-    process.exit(1);
-  });
-}