@step-forge/step-forge 0.0.12 → 0.0.14

package/src/analyzer/gherkinParser.ts

@@ -1,179 +0,0 @@
-import * as fs from "node:fs";
-import { GherkinClassicTokenMatcher, Parser, AstBuilder } from "@cucumber/gherkin";
-import * as messages from "@cucumber/messages";
-import { ParsedScenario, ParsedStep } from "./types.js";
-
-type GherkinKeyword = "Given" | "When" | "Then" | "And" | "But";
-
-export function parseFeatureFiles(filePaths: string[]): ParsedScenario[] {
-  const scenarios: ParsedScenario[] = [];
-
-  for (const filePath of filePaths) {
-    const content = fs.readFileSync(filePath, "utf-8");
-    const parsed = parseFeatureContent(content, filePath);
-    scenarios.push(...parsed);
-  }
-
-  return scenarios;
-}
-
-export function parseFeatureContent(
-  content: string,
-  filePath: string
-): ParsedScenario[] {
-  const newId = messages.IdGenerator.uuid();
-  const builder = new AstBuilder(newId);
-  const matcher = new GherkinClassicTokenMatcher();
-  const parser = new Parser(builder, matcher);
-
-  const gherkinDocument: messages.GherkinDocument = parser.parse(content);
-  const feature = gherkinDocument.feature;
-  if (!feature) return [];
-
-  // Collect background steps at the feature level
-  const featureBackground: messages.Step[] = [];
-  const scenarios: ParsedScenario[] = [];
-
-  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) {
-      // Rules can have their own backgrounds
-      const ruleBackground: messages.Step[] = [...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: messages.Scenario,
-  backgroundSteps: messages.Step[],
-  filePath: string
-): ParsedScenario[] {
-  const hasExamples =
-    scenario.examples.length > 0 &&
-    scenario.examples.some((e) => e.tableBody.length > 0);
-
-  if (!hasExamples) {
-    // Regular scenario
-    const bgParsed = convertSteps(backgroundSteps);
-    const scenarioParsed = convertSteps(scenario.steps);
-    const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
-
-    return [
-      {
-        name: scenario.name,
-        file: filePath,
-        steps: allSteps,
-      },
-    ];
-  }
-
-  // Scenario Outline — expand with each example row
-  const results: ParsedScenario[] = [];
-  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: Record<string, string> = {};
-      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: readonly messages.Step[]
-): Omit<ParsedStep, "effectiveKeyword">[] {
-  return steps.map((step) => ({
-    keyword: normalizeKeyword(step.keyword),
-    text: step.text,
-    line: step.location.line,
-    // step.location.column points to the keyword start; shift past the
-    // keyword (which includes a trailing space) so column points to the
-    // start of the step text. This makes `column + text.length` produce
-    // the correct end position for diagnostic ranges.
-    column: (step.location.column ?? 1) + step.keyword.length,
-  }));
-}
-
-function normalizeKeyword(keyword: string): GherkinKeyword {
-  const trimmed = keyword.trim();
-  // Gherkin keywords may include trailing space, e.g. "Given "
-  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";
-  // Fallback: treat as Given (shouldn't happen with valid Gherkin)
-  return "Given";
-}
-
-function resolveEffectiveKeywords(
-  steps: Omit<ParsedStep, "effectiveKeyword">[]
-): ParsedStep[] {
-  let lastEffective: "Given" | "When" | "Then" = "Given";
-
-  return steps.map((step) => {
-    let effectiveKeyword: "Given" | "When" | "Then";
-    if (step.keyword === "And" || step.keyword === "But") {
-      effectiveKeyword = lastEffective;
-    } else {
-      effectiveKeyword = step.keyword as "Given" | "When" | "Then";
-    }
-    lastEffective = effectiveKeyword;
-
-    return {
-      ...step,
-      effectiveKeyword,
-    };
-  });
-}
-
-function substituteExampleValues(
-  text: string,
-  substitution: Record<string, string>
-): string {
-  let result = text;
-  for (const [key, value] of Object.entries(substitution)) {
-    result = result.replace(new RegExp(`<${key}>`, "g"), value);
-  }
-  return result;
-}

package/src/analyzer/index.ts

@@ -1,89 +0,0 @@
-import { glob } from "node:fs/promises";
-import * as path from "node:path";
-import { extractStepDefinitions } from "./stepExtractor.js";
-import { parseFeatureFiles, parseFeatureContent } from "./gherkinParser.js";
-import {
-  matchScenarioSteps,
-  findMatchingDefinitions,
-} from "./stepMatcher.js";
-import { defaultRules, runRules } from "./rules/index.js";
-import type {
-  AnalyzerConfig,
-  AnalysisRule,
-  Diagnostic,
-  StepDefinitionMeta,
-  ParsedScenario,
-  MatchedStep,
-  ParsedStep,
-} from "./types.js";
-
-export type {
-  AnalyzerConfig,
-  AnalysisRule,
-  Diagnostic,
-  StepDefinitionMeta,
-  ParsedScenario,
-  MatchedStep,
-  ParsedStep,
-};
-
-export {
-  extractStepDefinitions,
-  parseFeatureFiles,
-  parseFeatureContent,
-  matchScenarioSteps,
-  findMatchingDefinitions,
-  defaultRules,
-};
-
-export interface AnalyzeOptions {
-  rules?: AnalysisRule[];
-}
-
-export async function analyze(
-  config: AnalyzerConfig,
-  options?: AnalyzeOptions
-): Promise<Diagnostic[]> {
-  const rules = options?.rules ?? defaultRules;
-
-  // 1. Resolve file globs to paths
-  const stepFilePaths = await resolveGlobs(config.stepFiles);
-  const featureFilePaths = await resolveGlobs(config.featureFiles);
-
-  if (stepFilePaths.length === 0) {
-    return [];
-  }
-  if (featureFilePaths.length === 0) {
-    return [];
-  }
-
-  // 2. Extract step metadata from step files
-  const stepDefinitions = extractStepDefinitions(
-    stepFilePaths,
-    config.tsConfigPath
-  );
-
-  // 3. Parse feature files
-  const scenarios = parseFeatureFiles(featureFilePaths);
-
-  // 4. For each scenario, match steps and run rules
-  const diagnostics: Diagnostic[] = [];
-  for (const scenario of scenarios) {
-    const matchedSteps = matchScenarioSteps(scenario, stepDefinitions);
-    const scenarioDiags = runRules(rules, scenario, matchedSteps);
-    diagnostics.push(...scenarioDiags);
-  }
-
-  return diagnostics;
-}
-
-async function resolveGlobs(patterns: string[]): Promise<string[]> {
-  const files: string[] = [];
-  for (const pattern of patterns) {
-    for await (const file of glob(pattern)) {
-      files.push(path.resolve(file));
-    }
-  }
-  // Deduplicate
-  return [...new Set(files)];
-}

package/src/analyzer/rules/ambiguousStepRule.ts

@@ -1,36 +0,0 @@
-import {
-  AnalysisRule,
-  Diagnostic,
-  MatchedStep,
-  ParsedScenario,
-} from "../types.js";
-
-export const ambiguousStepRule: AnalysisRule = {
-  name: "ambiguous-step",
-
-  check(
-    scenario: ParsedScenario,
-    matchedSteps: MatchedStep[]
-  ): Diagnostic[] {
-    return matchedSteps
-      .filter((step) => step.definitions.length > 1)
-      .map((step) => {
-        const locations = step.definitions
-          .map((d) => `${d.sourceFile}:${d.line}`)
-          .join(", ");
-        return {
-          file: scenario.file,
-          range: {
-            startLine: step.line,
-            startColumn: step.column,
-            endLine: step.line,
-            endColumn: step.column + step.text.length,
-          },
-          severity: "error" as const,
-          message: `Step "${step.text}" matches multiple step definitions: ${locations}`,
-          rule: "ambiguous-step",
-          source: "step-forge" as const,
-        };
-      });
-  },
-};

package/src/analyzer/rules/dependencyRule.ts

@@ -1,71 +0,0 @@
-import {
-  AnalysisRule,
-  Diagnostic,
-  MatchedStep,
-  ParsedScenario,
-} from "../types.js";
-
-export const dependencyRule: AnalysisRule = {
-  name: "dependency-check",
-
-  check(
-    scenario: ParsedScenario,
-    matchedSteps: MatchedStep[]
-  ): Diagnostic[] {
-    const diagnostics: Diagnostic[] = [];
-    const produced = {
-      given: new Set<string>(),
-      when: new Set<string>(),
-      then: new Set<string>(),
-    };
-
-    for (const step of matchedSteps) {
-      if (step.definitions.length !== 1) continue;
-
-      const { dependencies, produces, stepType } = step.definitions[0];
-
-      // Collect all missing required dependencies for this step
-      const missing: Record<string, string[]> = {};
-      for (const phase of ["given", "when", "then"] as const) {
-        for (const [key, requirement] of Object.entries(dependencies[phase])) {
-          if (requirement === "required" && !produced[phase].has(key)) {
-            if (!missing[phase]) {
-              missing[phase] = [];
-            }
-            missing[phase].push(key);
-          }
-        }
-      }
-
-      if (Object.keys(missing).length > 0) {
-        const lines = Object.entries(missing).map(
-          ([phase, keys]) =>
-            `${phase.charAt(0).toUpperCase() + phase.slice(1)}: ${keys.map((k) => `${phase}.${k}`).join(", ")}`
-        );
-        const message =
-          "Missing required dependencies:\n" + lines.join("\n");
-
-        diagnostics.push({
-          file: scenario.file,
-          range: {
-            startLine: step.line,
-            startColumn: step.column,
-            endLine: step.line,
-            endColumn: step.column + step.text.length,
-          },
-          severity: "error",
-          message,
-          rule: "dependency-check",
-          source: "step-forge",
-        });
-      }
-
-      // Add produced keys for this step
-      for (const key of produces) {
-        produced[stepType].add(key);
-      }
-    }
-
-    return diagnostics;
-  },
-};

package/src/analyzer/rules/index.ts

@@ -1,23 +0,0 @@
-import {
-  AnalysisRule,
-  Diagnostic,
-  MatchedStep,
-  ParsedScenario,
-} from "../types.js";
-import { ambiguousStepRule } from "./ambiguousStepRule.js";
-import { dependencyRule } from "./dependencyRule.js";
-import { undefinedStepRule } from "./undefinedStepRule.js";
-
-export const defaultRules: AnalysisRule[] = [
-  undefinedStepRule,
-  ambiguousStepRule,
-  dependencyRule,
-];
-
-export function runRules(
-  rules: AnalysisRule[],
-  scenario: ParsedScenario,
-  matchedSteps: MatchedStep[]
-): Diagnostic[] {
-  return rules.flatMap((rule) => rule.check(scenario, matchedSteps));
-}

package/src/analyzer/rules/undefinedStepRule.ts

@@ -1,31 +0,0 @@
-import {
-  AnalysisRule,
-  Diagnostic,
-  MatchedStep,
-  ParsedScenario,
-} from "../types.js";
-
-export const undefinedStepRule: AnalysisRule = {
-  name: "undefined-step",
-
-  check(
-    scenario: ParsedScenario,
-    matchedSteps: MatchedStep[]
-  ): Diagnostic[] {
-    return matchedSteps
-      .filter((step) => step.definitions.length === 0)
-      .map((step) => ({
-        file: scenario.file,
-        range: {
-          startLine: step.line,
-          startColumn: step.column,
-          endLine: step.line,
-          endColumn: step.column + step.text.length,
-        },
-        severity: "error" as const,
-        message: `Step "${step.text}" does not match any step definition`,
-        rule: "undefined-step",
-        source: "step-forge" as const,
-      }));
-  },
-};