From 2cb573d5ad8d0b9014065461a2f64bf2dbedda28 Mon Sep 17 00:00:00 2001 From: l0ng-ai Date: Mon, 16 Nov 2026 13:01:44 +0800 Subject: [PATCH] feat(cucumber): navigate between feature steps and step definitions (#3668) Go to Declaration on a .feature step opens the matching JavaScript / TypeScript step definitions (@cucumber/cucumber, playwright-bdd); on a definition's pattern it lists the feature steps using it. Cucumber expressions and regular expressions match; Scenario Outline steps use their first example's values. A cheap backend scan (cucumber_sources) feeds a UI index kept until a feature or script file changes. Refs #797 --- crates/ide-host/src/ops/bdd.rs | 112 +++++++++++++++ crates/ide-host/src/ops/mod.rs | 1 + src-tauri/src/commands/mod.rs | 1 + src-tauri/src/commands/nav.rs | 14 ++ src-tauri/tests/commands.snap | 1 + src/bindings.ts | 9 ++ src/editor/lsp/navigation.ts | 2 +- src/editor/navigationProviders.ts | 3 +- src/features/cucumber/index.ts | 39 ++++++ src/features/cucumber/stepIndex.ts | 84 ++++++++++++ src/features/cucumber/steps.test.ts | 87 ++++++++++++ src/features/cucumber/steps.ts | 205 ++++++++++++++++++++++++++++ src/features/index.ts | 2 + 13 files changed, 558 insertions(+), 2 deletions(-) create mode 100644 crates/ide-host/src/ops/bdd.rs create mode 100644 src/features/cucumber/index.ts create mode 100644 src/features/cucumber/stepIndex.ts create mode 100644 src/features/cucumber/steps.test.ts create mode 100644 src/features/cucumber/steps.ts diff --git a/crates/ide-host/src/ops/bdd.rs b/crates/ide-host/src/ops/bdd.rs new file mode 100644 index 000000000..7413f1a2f --- /dev/null +++ b/crates/ide-host/src/ops/bdd.rs @@ -0,0 +1,112 @@ +//! Cucumber sources: the project's `.feature` files and the JavaScript / TypeScript files +//! that could define steps (`@cucumber/cucumber`, `playwright-bdd`), with their text. The UI +//! owns the Gherkin and step-expression parsing and the index it feeds (as for `routes`), +//! so this side stays a cheap scan. + +use crate::Host; +use ide_core::IdeResult; +use serde::{Deserialize, Serialize}; +use specta::Type; +use std::path::Path; +use std::sync::Mutex; +use std::sync::atomic::{AtomicUsize, Ordering}; + +/// Files handed out at most, and bytes in total: a test suite's features and step +/// files fit well inside these, and the UI indexes them once. +const MAX_FILES: usize = 4096; +const MAX_BYTES: usize = 64 << 20; +/// A single source bigger than this is a bundle, not a step file. +const MAX_FILE_BYTES: u64 = 2 << 20; + +/// What a step definition call starts with (`Given('…'`, `defineStep(/…/`). +const STEP_CALLS: [&str; 5] = ["Given(", "When(", "Then(", "Step(", "defineStep("]; + +#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)] +#[serde(rename_all = "camelCase")] +pub struct StepSource { + pub path: ide_core::IpcPath, + pub text: String, + /// A Gherkin `.feature` file; otherwise a script defining steps. + pub feature: bool, +} + +fn is_feature(path: &Path) -> bool { + path.extension().and_then(|e| e.to_str()).is_some_and(|e| e.eq_ignore_ascii_case("feature")) +} + +fn is_script(path: &Path) -> bool { + matches!( + path.extension().and_then(|e| e.to_str()), + Some("js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts") + ) +} + +/// The feature files and step definition files under `root`. +pub(crate) fn sources_in(root: &Path, excludes: &[String]) -> Vec { + let found: Mutex> = Mutex::new(Vec::new()); + let bytes = AtomicUsize::new(0); + ide_vfs::walk_files(root, excludes, |path| { + let feature = is_feature(path); + if !(feature || is_script(path)) || bytes.load(Ordering::Relaxed) >= MAX_BYTES { + return; + } + if std::fs::metadata(path).map_or(true, |m| m.len() > MAX_FILE_BYTES) { + return; + } + let Ok(text) = std::fs::read_to_string(path) else { return }; + if !feature && !STEP_CALLS.iter().any(|call| text.contains(call)) { + return; + } + let Ok(mut found) = found.lock() else { return }; + if found.len() >= MAX_FILES { + return; + } + bytes.fetch_add(text.len(), Ordering::Relaxed); + found.push(StepSource { path: path.to_path_buf().into(), text, feature }); + }); + let mut files = found.into_inner().unwrap_or_default(); + files.sort_by(|a, b| a.path.cmp(&b.path)); + files +} + +/// Every Cucumber source of the project (its folder and the content roots outside it). +pub fn cucumber_sources(host: &Host, window: &str) -> IdeResult> { + let project = host.project(window)?; + let mut excludes = project.search_excludes(); + // Cucumber's own sources (and every other package's) are not the project's steps. + excludes.push("node_modules".to_owned()); + let mut out = Vec::new(); + for root in std::iter::once(project.root.clone()).chain(project.content_roots()) { + out.extend(sources_in(&root, &excludes)); + } + out.sort_by(|a, b| a.path.cmp(&b.path)); + out.dedup_by(|a, b| a.path == b.path); + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn features_and_step_files_are_read_and_nothing_else() { + let tmp = tempfile::tempdir().unwrap(); + let root = tmp.path(); + for dir in ["features", "steps", "src", "node_modules/@cucumber/cucumber/lib"] { + std::fs::create_dir_all(root.join(dir)).unwrap(); + } + std::fs::write(root.join("features/cart.feature"), "Feature: Cart\n").unwrap(); + std::fs::write(root.join("steps/cart.steps.ts"), "Given('an empty cart', () => {});").unwrap(); + std::fs::write(root.join("steps/bdd.mjs"), "const { When } = createBdd();\nWhen(/^I add (\\d+)$/, f);") + .unwrap(); + std::fs::write(root.join("src/app.ts"), "export const app = 1;").unwrap(); + std::fs::write(root.join("src/notes.md"), "Given('x')").unwrap(); + std::fs::write(root.join("node_modules/@cucumber/cucumber/lib/index.js"), "Given('x')").unwrap(); + let files = sources_in(root, &["node_modules".to_owned()]); + let names: Vec = + files.iter().map(|f| f.path.0.strip_prefix(root).unwrap().to_string_lossy().replace('\\', "/")).collect(); + assert_eq!(names, ["features/cart.feature", "steps/bdd.mjs", "steps/cart.steps.ts"]); + assert!(files[0].feature && !files[1].feature); + assert!(files[2].text.contains("an empty cart")); + } +} diff --git a/crates/ide-host/src/ops/mod.rs b/crates/ide-host/src/ops/mod.rs index 4a9dda601..2e1d41fe5 100644 --- a/crates/ide-host/src/ops/mod.rs +++ b/crates/ide-host/src/ops/mod.rs @@ -4,6 +4,7 @@ pub mod agent; pub mod analysis; +pub mod bdd; pub mod build; pub mod bytes; pub mod coverage; diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs index 60ebde213..c52bd7bf4 100644 --- a/src-tauri/src/commands/mod.rs +++ b/src-tauri/src/commands/mod.rs @@ -248,6 +248,7 @@ pub fn builder() -> tauri_specta::Builder { nav::index_status, nav::index_file_extensions, nav::spring_route_sources, + nav::cucumber_sources, nav::find_files, nav::find_files_named, nav::find_dirs, diff --git a/src-tauri/src/commands/nav.rs b/src-tauri/src/commands/nav.rs index 1125ed8a9..0ffacb800 100644 --- a/src-tauri/src/commands/nav.rs +++ b/src-tauri/src/commands/nav.rs @@ -61,6 +61,20 @@ pub fn spring_route_sources( ide_host::ops::routes::spring_route_sources(&state.host, window.label()) } +/// Cucumber feature files and step definition files, for step navigation. +#[tauri::command] +#[specta::specta] +pub async fn cucumber_sources( + window: Window, + state: State<'_, AppState>, +) -> IdeResult> { + let host = state.host.clone(); + let label = window.label().to_owned(); + tauri::async_runtime::spawn_blocking(move || ide_host::ops::bdd::cucumber_sources(&host, &label)) + .await + .map_err(|e| ide_core::IdeError::internal(e.to_string()))? +} + #[tauri::command] #[specta::specta] pub async fn find_symbols( diff --git a/src-tauri/tests/commands.snap b/src-tauri/tests/commands.snap index c4f8b988c..fc2eb592d 100644 --- a/src-tauri/tests/commands.snap +++ b/src-tauri/tests/commands.snap @@ -81,6 +81,7 @@ close_project always project_host bin coverage_collect trusted project_host bindings async coverage_import always project_host bindings async coverage_prepare trusted project_host bindings async +cucumber_sources trusted desktop bindings async db_apply_edits trusted project_host bindings async db_completion trusted project_host bindings async db_connect trusted project_host bindings async diff --git a/src/bindings.ts b/src/bindings.ts index 267b83691..4218932cd 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -488,6 +488,8 @@ export const commands = { indexFileExtensions: () => typedError(__TAURI_INVOKE("index_file_extensions")), /** Spring Web mapping sources for the request-path index of Search Everywhere. */ springRouteSources: () => typedError(__TAURI_INVOKE("spring_route_sources")), + /** Cucumber feature files and step definition files, for step navigation. */ + cucumberSources: () => typedError(__TAURI_INVOKE("cucumber_sources")), findFiles: (query: string, limit: number) => typedError(__TAURI_INVOKE("find_files", { query, limit })), findFilesNamed: (name: string) => typedError(__TAURI_INVOKE("find_files_named", { name })), /** Folders holding indexed files, for `@` references. */ @@ -10299,6 +10301,13 @@ export type StepInTarget = { export type StepKind = "over" | "into" | "out"; +export type StepSource = { + path: IpcPath, + text: string, + /** A Gherkin `.feature` file; otherwise a script defining steps. */ + feature: boolean, +}; + export type StructuralEvent = { type: "file"; file: StructuralFile } | { type: "done"; summary: StructuralSummary }; /** All matches in one file; streamed as files complete. */ diff --git a/src/editor/lsp/navigation.ts b/src/editor/lsp/navigation.ts index 14bab6787..d9b15fcdc 100644 --- a/src/editor/lsp/navigation.ts +++ b/src/editor/lsp/navigation.ts @@ -209,7 +209,7 @@ export async function locationItems(locs: readonly DeclarationTarget[]): Promise }; return { id: `${i}`, - label: names[i] ?? basename(l.path), + label: l.name ?? names[i] ?? basename(l.path), detail: [indexed.get(i) ?? enclosingType(files.get(l.path), l), where].filter(Boolean).join(" · "), icon: fileIconName(basename(l.path), l.path), location: { path: l.path, line: l.range.start.line }, diff --git a/src/editor/navigationProviders.ts b/src/editor/navigationProviders.ts index 0cb197a16..dd105c8c7 100644 --- a/src/editor/navigationProviders.ts +++ b/src/editor/navigationProviders.ts @@ -6,7 +6,8 @@ import type { Location } from "@/platform/ipc"; export interface NavigationMatch { from: number; to: number; - targets: Location[]; + /** `name`: what the chooser shows for a target (else the word at it). */ + targets: Array; } type Provider = (view: EditorView, offset: number) => Promise; const providers = new Set(); diff --git a/src/features/cucumber/index.ts b/src/features/cucumber/index.ts new file mode 100644 index 000000000..2297cba64 --- /dev/null +++ b/src/features/cucumber/index.ts @@ -0,0 +1,39 @@ +/** + * Cucumber step navigation: Go to Declaration (⌘-click, ⌘B) on a `.feature` step opens its + * JavaScript / TypeScript step definitions, and on a definition's pattern lists the feature + * steps it matches. + */ +import { docOf } from "@/editor/lsp/lsp"; +import { registerNavigationProvider } from "@/editor/navigationProviders"; +import { onIdeEvent } from "@/platform/ipc"; +import { featureSteps, stepDefinitions } from "./steps"; +import { clearStepIndex, definitionsOf, isCucumberSource, usagesOf } from "./stepIndex"; + +const SCRIPT = /\.[cm]?[jt]sx?$/i; + +export function activate(): () => void { + const unregister = registerNavigationProvider(async (view, offset) => { + const doc = docOf(view); + if (!doc || doc.virtual) return null; + const text = view.state.doc.toString(); + if (/\.feature$/i.test(doc.path)) { + const step = featureSteps(text).find((s) => s.from <= offset && offset < s.to); + if (!step) return null; + const targets = await definitionsOf(step); + return targets.length ? { from: step.from, to: step.to, targets } : null; + } + if (!SCRIPT.test(doc.path)) return null; + const definition = stepDefinitions(text).find((d) => d.from <= offset && offset < d.to); + if (!definition) return null; + const targets = await usagesOf(definition); + return targets.length ? { from: definition.from, to: definition.to, targets } : null; + }); + const unsubscribe = onIdeEvent("fsChanged", (e) => { + if ([...e.created, ...e.modified, ...e.removed].some((p) => isCucumberSource(String(p)))) clearStepIndex(); + }); + return () => { + unsubscribe(); + unregister(); + clearStepIndex(); + }; +} diff --git a/src/features/cucumber/stepIndex.ts b/src/features/cucumber/stepIndex.ts new file mode 100644 index 000000000..2ee4f0f1c --- /dev/null +++ b/src/features/cucumber/stepIndex.ts @@ -0,0 +1,84 @@ +/** The project's Cucumber steps and step definitions, scanned once and kept until a source changes. */ +import { call, commands, type Location } from "@/platform/ipc"; +import { ipcPath } from "@/platform/paths"; +import { featureSteps, matchesStep, stepDefinitions, type FeatureStep, type StepDefinition } from "./steps"; + +interface Indexed { + path: string; + text: string; + items: T[]; +} + +interface StepIndex { + definitions: Indexed[]; + steps: Indexed[]; +} + +let cached: Promise | null = null; + +/** Whether a change to `path` can change the index: a feature or script file. */ +export function isCucumberSource(path: string): boolean { + return /\.(feature|[cm]?[jt]sx?)$/i.test(path); +} + +/** Forgets the index, so the next lookup rescans the project. */ +export function clearStepIndex() { + cached = null; +} + +function stepIndex(): Promise { + cached ??= call(commands.cucumberSources()).then( + (sources) => { + const index: StepIndex = { definitions: [], steps: [] }; + for (const s of sources) { + const path = ipcPath(s.path); + if (s.feature) index.steps.push({ path, text: s.text, items: featureSteps(s.text) }); + else { + const items = stepDefinitions(s.text); + if (items.length) index.definitions.push({ path, text: s.text, items }); + } + } + return index; + }, + (e: unknown) => { + cached = null; + throw e; + }, + ); + return cached; +} + +/** The 0-based line and UTF-16 column of `offset` in `text`. */ +function position(text: string, offset: number): { line: number; col: number } { + let line = 0; + let start = 0; + for (let i = text.indexOf("\n"); i >= 0 && i < offset; i = text.indexOf("\n", i + 1)) { + line++; + start = i + 1; + } + return { line, col: offset - start }; +} + +const location = (path: string, text: string, from: number, to: number, name: string) => ({ + path, + range: { start: position(text, from), end: position(text, to) }, + name, +}); + +/** The definitions matching a feature step. */ +export async function definitionsOf(step: FeatureStep): Promise> { + const { definitions } = await stepIndex(); + return definitions.flatMap((file) => + file.items.filter((d) => matchesStep(d, step)).map((d) => location(file.path, file.text, d.from, d.to, d.source)), + ); +} + +/** The feature steps a definition matches. */ +export async function usagesOf(definition: StepDefinition): Promise> { + const { steps } = await stepIndex(); + return steps.flatMap((file) => + file.items + .filter((s) => matchesStep(definition, s)) + .map((s) => location(file.path, file.text, s.from, s.to, `${s.keyword} ${s.text}`)), + ); +} diff --git a/src/features/cucumber/steps.test.ts b/src/features/cucumber/steps.test.ts new file mode 100644 index 000000000..50362c2db --- /dev/null +++ b/src/features/cucumber/steps.test.ts @@ -0,0 +1,87 @@ +import { describe, expect, it } from "vitest"; +import { expressionRegExp, featureSteps, matchesStep, stepDefinitions } from "./steps"; + +const STEPS = `import { Given, When, Then } from "@cucumber/cucumber"; +import { createBdd } from "playwright-bdd"; +const bdd = createBdd(); + +Given('an empty cart', async function () {}); +When("I add {int} {string} to the cart", async (n: number, name: string) => {}); +bdd.Then(/^the total is (\\d+(?:\\.\\d+)?) EUR$/, async () => {}); +Then(\`I see {word} item(s) in my basket/bag\`, () => {}); +When(\`dynamic \${name}\`, () => {}); +const isGiven = (x) => x; isGiven('not a step'); +`; + +const FEATURE = `# language: en +@cart +Feature: Cart + + Background: + Given an empty cart + + Scenario: Add one + When I add 2 "apples" to the cart + Then the total is 3.50 EUR + And I see 1 item in my bag + """ + Given not a step + """ + + Scenario Outline: Add several + When I add "" to the cart + * I see items in my basket + + Examples: + | count | fruit | + | 3 | pears | + | 4 | plums | +`; + +describe("Cucumber steps", () => { + it("reads step definitions of @cucumber/cucumber and playwright-bdd", () => { + const defs = stepDefinitions(STEPS); + expect(defs.map((d) => d.source)).toEqual([ + "an empty cart", + "I add {int} {string} to the cart", + "^the total is (\\d+(?:\\.\\d+)?) EUR$", + "I see {word} item(s) in my basket/bag", + ]); + // The range covers the literal, quotes included. + expect(STEPS.slice(defs[0]!.from, defs[0]!.to)).toBe("'an empty cart'"); + }); + + it("turns Cucumber expressions into anchored regular expressions", () => { + const re = (e: string) => expressionRegExp(e)!; + expect(re("I add {int} {string} to the cart").test('I add 12 "big apples" to the cart')).toBe(true); + expect(re("I add {int} {string} to the cart").test('I add many "apples" to the cart')).toBe(false); + expect(re("I have {float} cucumber(s)").test("I have 1.5 cucumbers")).toBe(true); + expect(re("I have {float} cucumber(s)").test("I have 1 cucumber")).toBe(true); + expect(re("my belly/stomach hurts").test("my stomach hurts")).toBe(true); + expect(re("my belly/stomach hurts").test("my belly/stomach hurts")).toBe(false); + expect(re("a {color} ball").test("a red ball")).toBe(true); + expect(re("it costs \\(about\\) {int}$").test("it costs (about) 5$")).toBe(true); + expect(re("a {} thing").test("a very odd thing")).toBe(true); + expect(re("an empty cart").test("an empty cart today")).toBe(false); + expect(expressionRegExp("broken {int")).toBeNull(); + }); + + it("reads feature steps, skipping doc strings and filling outline placeholders", () => { + const steps = featureSteps(FEATURE); + expect(steps.map((s) => [s.keyword, s.matchText])).toEqual([ + ["Given", "an empty cart"], + ["When", 'I add 2 "apples" to the cart'], + ["Then", "the total is 3.50 EUR"], + ["And", "I see 1 item in my bag"], + ["When", 'I add 3 "pears" to the cart'], + ["*", "I see 3 items in my basket"], + ]); + expect(FEATURE.slice(steps[4]!.from, steps[4]!.to)).toBe('I add "" to the cart'); + }); + + it("matches every step to its definition", () => { + const defs = stepDefinitions(STEPS); + const matched = featureSteps(FEATURE).map((s) => defs.findIndex((d) => matchesStep(d, s))); + expect(matched).toEqual([0, 1, 2, 3, 1, 3]); + }); +}); diff --git a/src/features/cucumber/steps.ts b/src/features/cucumber/steps.ts new file mode 100644 index 000000000..f49ce4e4e --- /dev/null +++ b/src/features/cucumber/steps.ts @@ -0,0 +1,205 @@ +/** + * Cucumber steps, both sides: the step definitions of JavaScript / TypeScript files + * (`Given('a {int} item cart', …)` of `@cucumber/cucumber`, `playwright-bdd`'s `createBdd()` + * functions) and the steps of Gherkin `.feature` files, with Cucumber expression and regular + * expression matching between them. + */ + +/** A step definition: the pattern literal of a `Given` / `When` / `Then` / `Step` call. */ +export interface StepDefinition { + /** Offsets of the literal (quotes or slashes included) in its file. */ + from: number; + to: number; + /** The pattern as written, without quotes. */ + source: string; + regexp: RegExp; +} + +/** A step of a feature file, with the text it is matched by. */ +export interface FeatureStep { + /** Offsets of the step text (after the keyword) in its file. */ + from: number; + to: number; + keyword: string; + /** The text as written. */ + text: string; + /** The text matched against definitions: Scenario Outline placeholders take the first example's values. */ + matchText: string; +} + +const DEFINE = /\b(?:Given|When|Then|And|But|Step|defineStep)\s*(?:<[^<>()]*>\s*)?\(\s*/g; + +/** The step definitions of a script. */ +export function stepDefinitions(text: string): StepDefinition[] { + const out: StepDefinition[] = []; + for (const m of text.matchAll(DEFINE)) { + const at = m.index + m[0].length; + const literal = readLiteral(text, at); + if (!literal) continue; + const regexp = literal.regexp ?? expressionRegExp(literal.value); + if (regexp) out.push({ from: at, to: literal.end, source: literal.value, regexp }); + } + return out; +} + +/** A string, template (without substitutions) or regular expression literal at `at`. */ +function readLiteral(text: string, at: number): { value: string; end: number; regexp?: RegExp } | null { + const quote = text[at]; + if (quote === "'" || quote === '"' || quote === "`") { + let value = ""; + for (let i = at + 1; i < text.length; i++) { + const c = text[i]!; + if (c === "\\") { + const next = text[i + 1] ?? ""; + // An escaped quote is the quote; other escapes stay (a Cucumber expression's `\(`). + value += next === quote ? next : c + next; + i++; + } else if (c === quote) return { value, end: i + 1 }; + else if ((c === "\n" && quote !== "`") || (quote === "`" && c === "$" && text[i + 1] === "{")) return null; + else value += c; + } + return null; + } + if (quote === "/") { + let inClass = false; + for (let i = at + 1; i < text.length; i++) { + const c = text[i]!; + if (c === "\\") i++; + else if (c === "[") inClass = true; + else if (c === "]") inClass = false; + else if (c === "\n") return null; + else if (c === "/" && !inClass) { + const flags = /^[a-z]*/.exec(text.slice(i + 1))![0]; + const value = text.slice(at + 1, i); + try { + return { value, end: i + 1 + flags.length, regexp: new RegExp(value, flags.replace(/[gy]/g, "")) }; + } catch { + return null; + } + } + } + } + return null; +} + +/** Built-in parameter types; a custom one (`defineParameterType`) matches anything. */ +const PARAMETERS: Record = { + int: "-?\\d+", + byte: "-?\\d+", + short: "-?\\d+", + long: "-?\\d+", + biginteger: "-?\\d+", + float: "-?(?:\\d+(?:[.,]\\d*)?|[.,]\\d+)(?:[eE][-+]?\\d+)?", + double: "-?(?:\\d+(?:[.,]\\d*)?|[.,]\\d+)(?:[eE][-+]?\\d+)?", + bigdecimal: "-?(?:\\d+(?:[.,]\\d*)?|[.,]\\d+)(?:[eE][-+]?\\d+)?", + word: "[^\\s]+", + string: "\"(?:[^\"\\\\]|\\\\.)*\"|'(?:[^'\\\\]|\\\\.)*'", + "": ".*", +}; + +const escapeRe = (s: string) => s.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&"); + +/** + * A Cucumber expression as an anchored regular expression: `{type}` parameters, `(optional)` + * text, `a/b` alternatives within a word, `\` escapes. Null when it is malformed. + */ +export function expressionRegExp(expression: string): RegExp | null { + let out = ""; + // Alternatives apply within a run of text without whitespace, parameters or optionals. + let word: string[] = [""]; + const flush = () => { + out += word.length > 1 ? `(?:${word.join("|")})` : word[0]!; + word = [""]; + }; + const add = (re: string) => (word[word.length - 1] += re); + for (let i = 0; i < expression.length; i++) { + const c = expression[i]!; + if (c === "\\" && i + 1 < expression.length) { + add(escapeRe(expression[++i]!)); + } else if (c === "{") { + const end = expression.indexOf("}", i); + if (end < 0) return null; + const name = expression.slice(i + 1, end).trim(); + flush(); + out += `(${PARAMETERS[name] ?? ".*?"})`; + i = end; + } else if (c === "(") { + const end = expression.indexOf(")", i); + if (end < 0) return null; + add(`(?:${escapeRe(expression.slice(i + 1, end))})?`); + i = end; + } else if (c === "/") { + word.push(""); + } else if (/\s/.test(c)) { + flush(); + out += escapeRe(c); + } else { + add(escapeRe(c)); + } + } + flush(); + try { + return new RegExp(`^${out}$`); + } catch { + return null; + } +} + +const STEP = /^(\s*)(Given|When|Then|And|But|\*)(\s+)(\S.*?)\s*$/; +const BLOCK = /^\s*(Feature|Rule|Background|Scenario|Scenario Outline|Scenario Template|Example|Examples|Scenarios):/; + +/** The steps of a feature file (English keywords), placeholders filled from each outline's first example. */ +export function featureSteps(text: string): FeatureStep[] { + const out: FeatureStep[] = []; + let outline: FeatureStep[] = []; + let header: string[] | null = null; + let examples = false; + let docString: string | null = null; + let offset = 0; + for (const line of text.split("\n")) { + const start = offset; + offset += line.length + 1; + const trimmed = line.trim(); + if (docString) { + if (trimmed.startsWith(docString)) docString = null; + continue; + } + if (trimmed.startsWith('"""') || trimmed.startsWith("```")) { + docString = trimmed.slice(0, 3); + continue; + } + if (!trimmed || trimmed.startsWith("#") || trimmed.startsWith("@")) continue; + const block = BLOCK.exec(line); + if (block) { + examples = block[1] === "Examples" || block[1] === "Scenarios"; + if (!examples) outline = []; + header = null; + continue; + } + if (trimmed.startsWith("|")) { + if (!examples) continue; + const cells = trimmed + .replace(/^\||\|$/g, "") + .split("|") + .map((c) => c.trim()); + if (!header) header = cells; + else if (header.length) { + const values = new Map(header.map((h, i) => [h, cells[i] ?? ""])); + for (const step of outline) + step.matchText = step.text.replace(/<([^<>]+)>/g, (all, name: string) => values.get(name) ?? all); + // Later examples rows give the same steps: the first one stands for them. + header = []; + } + continue; + } + const m = STEP.exec(line); + if (!m) continue; + const from = start + m[1]!.length + m[2]!.length + m[3]!.length; + const step = { from, to: from + m[4]!.length, keyword: m[2]!, text: m[4]!, matchText: m[4]! }; + out.push(step); + if (step.text.includes("<")) outline.push(step); + } + return out; +} + +export const matchesStep = (definition: StepDefinition, step: FeatureStep) => definition.regexp.test(step.matchText); diff --git a/src/features/index.ts b/src/features/index.ts index 058cc72f0..db8d9f4b3 100644 --- a/src/features/index.ts +++ b/src/features/index.ts @@ -48,6 +48,7 @@ import { activate as analysis } from "./analysis"; import { activate as services } from "./services"; import { activate as github, activateSettingsPages as githubPages } from "./github"; import { activate as httpClient } from "./http-client"; +import { activate as cucumber } from "./cucumber"; import { activate as database, activateSettingsPages as databasePages } from "./database"; import { activate as graphql } from "./graphql"; import { activate as deployment, activateDeploymentWindow } from "./deployment"; @@ -99,6 +100,7 @@ const features: Array<[string, Activate]> = [ ["services", services], ["github", github], ["http-client", httpClient], + ["cucumber", cucumber], ["database", database], ["graphql", graphql], ["deployment", deployment],