Skip to main content

Release Notes

What changed in each release of the SpecBinder IntelliJ plugin. Each version links to its page on the JetBrains Marketplace.

Release notes for the framework itself live under Docs → Release Notes.

2026.17.0Latest

Added

  • Revision markup in spec files is now highlighted in its own colour. Text that SpecBinder strips before generating tests — whatever the stripPatterns option matches — is painted as markup so it stands out from the spec text around it, wherever it appears: in steps, titles, descriptions, table cells and doc strings. Where two patterns match the same text, the one declared first wins, matching the order SpecBinder applies them in. The colour is configurable under Settings > Editor > Color Scheme > Gherkin.
  • A step's Playwright trace can now be opened in your browser from the trace row itself. Pointing at the row reveals a small arrow beside the trace's file name; clicking it opens that same recording full-size in Playwright's own trace viewer, while the row's file name still expands the viewer inline as before. The recording is handed over on a local address and never leaves your machine. Previously this was only reachable by Shift- or Alt-clicking the file name, which still works.
  • Ctrl/Cmd+Click on a step carrying revision markup now opens the same step method as the plain step would: the method name is worked out from the step text with the markup stripped, so annotating a step for traceability never costs you the jump to its implementation.
  • Find Usages on a step method now lists the spec steps that only match once their revision markup is stripped, so a step annotated for traceability is not silently missing from the usage list.
  • A range of spec text can now be marked by its two ends, using the stripBetweenPatterns option: one pattern for where the range opens and one for where it closes. Everything from the opening marker to the closing one is treated as stripped, so a range can wrap whole steps, a whole scenario or rows of a table without either pattern needing to match across lines. Each opening marker is closed by the nearest following one, so a marker written inside a range is part of what the range covers; an opening marker with nothing closing it leaves the text exactly as you wrote it, rather than swallowing the rest of the file. Ranges are applied before the stripPatterns entries, so a range keeps its whole span even when an entry would also have matched inside it.
  • Inside a marked range, only the two markers are highlighted — the spec text between them keeps its ordinary colouring and still reads as Gherkin, so a range wrapping a whole scenario looks like a scenario rather than a block of markup. Everything in the range is still stripped before the tests are generated, so the names, numbering and recorded status of what survives are worked out as if the range were not there: a scenario that gains a range around some of its steps keeps the result already recorded against it.
  • The text inside a marked range can now be given a look of its own, through a new Stripped range content entry under Settings > Editor > Color Scheme > Gherkin. It starts with nothing set, which leaves a range exactly as it reads today. Because each attribute of the entry is set on its own, a style chosen without a colour is laid over the range rather than replacing it — tick Effects > Strikeout and the wrapped text keeps its ordinary Gherkin colours with a line through it, which is a natural way to show wording that no longer reaches the tests. Choosing a foreground instead colours the range outright.
  • A range's two markers can now be coloured apart from a plain stripPatterns match, through a new Stripped range marker entry. It takes its colours from Strip pattern unless you set it, so nothing changes until you ask for it — it is there for authors who want "this whole span is going" to look different from "these tags are going".
  • An unusable stripBetweenPatterns pair is now reported in the editor on the offending pattern — whichever of the two will not compile, or either one left blank, since a pair with only one end cannot mark a range. Until the pair is usable the spec file is highlighted as if no ranges were configured, rather than guessing where you meant the range to close.
  • An unparseable stripPatterns entry is now reported in the editor, on the offending pattern itself, so you find out as you type instead of from a failed build. Until it compiles, the spec file is highlighted as if no patterns were configured.
  • Renaming a step method now updates the matching step in the spec file even when that step carries revision markup: the step is found by its text with the markup stripped, so annotating a step for traceability no longer leaves it behind, out of sync with the method it runs. The rewritten step is written plain — a method name records nothing about where the markers sat — and text a pair of markers wraps and removes goes with them. A marker no configured pattern matches is part of the step text the method name was built from, so it stays put: only the words the rename actually changed are rewritten, leaving the rest of the line exactly as you wrote it.
  • Step completion now suggests steps for a line carrying revision markup: the text you have typed is matched with the markup stripped, so annotating a step part way through typing no longer empties the suggestion list. Text wrapped by a pair of markers is dropped along with them, exactly as it is when the tests are generated.
  • Ctrl/Cmd+Click from generated code back to the spec now lands on the right place when revision markup is involved. Shift+Ctrl/Cmd+Click on a step method call opens the marked-up step it was generated from, and where two steps read alike once their markup is stripped, each call opens its own step rather than both opening the first. Ctrl/Cmd+Click on a generated test method or nested class opens the Scenario or Rule it came from even when that element's title carries markup — titles are matched with the markup stripped, the way SpecBinder writes them into the generated @DisplayName.
  • A scenario keeps its recorded execution status when you annotate it with revision markup. The scenario is matched to its recorded run by its content with the markup stripped — the same way SpecBinder records it — so adding traceability markup no longer blanks the status icon in the gutter, and a scenario beside an annotated one is unaffected. Editing what a step actually says still invalidates the match: the scenario then reads as not executed until the tests are run again.

Changed

  • Reformat Code now pulls doc string lines that start to the left of the opening triple quotes back in line with them, instead of leaving them hanging outside the block. Lines that already start at or beyond the triple quotes keep their own indentation relative to the block, and blank lines are left untouched.
  • A Playwright trace opened in your browser is now named after its own recording file, so a tab full of traces can be told apart. Previously every trace arrived under the same meaningless identifier, leaving the browser tab and the viewer's own heading identical for each one.
  • The doc-string previews and published reporter entries buttons on the editor toolbar now set their panels' left-bar colour from a single "Panel bar colour" swatch in their dropdown, opening the full colour picker in one click. This matches how the failed-step error panels dropdown already worked, so every panel colour is chosen the same way. The grid of preset colours and the separate "Custom…" button are gone from both dropdowns; a colour picked previously is kept.

Fixed

  • The execution report status counts now retire a scenario that was changed outside the IDE. A spec file rewritten on disk by another tool, a script, or a branch switch never saves through the editor, so its edited scenarios kept their recorded pass or fail; they are now counted as not executed as soon as the change reaches the file, exactly as they are after an in-editor save. Scenarios the change left alone keep their recorded status, and restoring the original content brings the recorded status back.
  • Scenarios and Rules that follow spec text removed by revision markup are no longer mapped onto the wrong generated test. A scenario after a removed one is numbered the way SpecBinder numbers it, so its gutter Run icon starts the right test, Ctrl/Cmd+Click from the generated class lands on the right scenario, Find Usages lists the right steps, and execution report statuses are drawn against the scenario that produced them.
  • Reformat Code now leaves a line that begins with revision markup exactly where it is. Previously a table row wrapped in markup was pushed out to the left margin; it now keeps its indentation and its own spacing, while the rows around it are aligned as if it were not there.
  • The spell checker no longer flags revision markup as typos, while still checking the words the markup wraps.
  • A spec file that was already open while the project was still loading could show "No execution report" for the rest of the session, even after the spec had been run and its report was on disk. The report is now picked up as soon as it is written.
  • The inline preview of an SVG doc string now draws the graphic on a high-resolution display. The preview opened at the right size but painted little or nothing of the picture, so a fine-lined graphic looked like an empty panel. The image preview is drawn the same way.
  • Approving a failed step's Actual value no longer stops the other open error panels from approving theirs. Accepting a value makes the spec file longer and pushes every step below it further down, and the panels still open carried on pointing at the lines their steps used to occupy — so from the second approval onwards the button reported "Cannot locate the expected value as a parameter on this step", and a run with several failures had to be approved one panel at a time, closing and reopening each. Each panel now follows the step it was opened on however far that step has moved, so the failures can be worked through in a single pass, in any order. Editing the file by hand while panels are open is handled the same way, and a failed step's gutter icon still closes that step's own panel after the step has shifted.

2026.16.0

Changed

  • The Step Implementation tool window no longer draws an icon in the loaded editor's gutter next to the linked method. The highlighted line already marks it, and dropping the icon keeps the gutter at its normal width.

Fixed

  • The Step Implementation tool window now reliably scrolls the linked method into view when it loads a class: previously the newly loaded file could appear scrolled to the top instead of centred on the method. The loaded file is also kept aligned to the left edge, so it no longer scrolls sideways to reveal the indented method name.
  • The step implementation preview (Quick Documentation on a step) and the Step Implementation tool window now show the actual step method body — the concrete implementation in your test class — instead of the empty abstract declaration, for steps whose implementation lives in a subclass of the generated test class. Ctrl/Cmd+Click on a step lands on the same concrete implementation.

2026.15.0

Fixed

  • The step implementation preview (Quick Documentation on a step) and the Step Implementation tool window now show the actual step method body — the concrete implementation in your test class — instead of the empty abstract declaration, for steps whose implementation lives in a subclass of the generated test class. Ctrl/Cmd+Click on a step lands on the same concrete implementation.

2026.14.0

Added

  • A new Auto-Enable Remote Control (Claude Code only) toggle in the Launch AI agent button's dropdown (below Auto-Select This Spec's Terminal Tab, off by default and remembered). When on, Claude Code sessions you start from the button launch with remote control enabled, so you can drive or watch each session from claude.ai or the mobile app without turning it on by hand. It only affects Claude Code launches — Copilot CLI sessions are unaffected — and whether a session actually connects for remote control depends on your Claude sign-in.
  • A new Step Implementation tool window (right dock) shows the Java implementation of the step under your caret in a spec file, and follows the caret: as you move through steps, it loads the step method's owning class and scrolls to that method, highlighting the linked method's line with a gutter marker so it stands out. It hosts a real editor, so you can read, edit, and refactor the class directly in the pane; the pane header shows the loaded file's name and icon, and a colour swatch there lets you choose the highlight colour for the linked method. When the caret is not on a step, nothing resolves, or the focused file is not a spec, it simply keeps showing the last class rather than blanking. It resolves to the same method Ctrl/Cmd+Click and Quick Documentation open.
  • Quick Documentation (Cmd+Q) on a step in a spec file now previews that step's Java implementation inline in the documentation popup, syntax-highlighted, so you can review what a step does without jumping to the generated test class. It appears only when you invoke the shortcut — not automatically on mouse-hover — and resolves to the same method Ctrl/Cmd+Click navigates to. When a step has no implementation yet (its generated test class isn't compiled, or no matching class was found), the popup says so instead of showing nothing.
  • When a step's execution recorded a Playwright trace, an expandable Playwright trace row now appears beneath that step — in both the spec editor and the Execution Report preview — alongside any published-reporter entries and controlled by the same toolbar toggle that shows those entries. Clicking the row opens the recorded trace inline in the embedded Playwright trace viewer (screenshots, DOM snapshots, network, console, and the action timeline); collapsing it releases the viewer. Shift- or Alt-clicking the row instead opens the trace full-size in your system browser. The viewer loads from trace.playwright.dev, so it needs an internet connection — the trace file itself stays on your machine and is served to the viewer locally. The trace is matched to its step from the recorded report, so the row keeps showing the run even after the spec file is edited.
  • New "Show Playwright traces" toggle (Execution results, nested under "Show published JUnit reporter entries", off by default) controls whether that recorded trace becomes the expandable trace-viewer row. When turned off, the trace is instead shown as an ordinary published-reporter entry — a plain specbinder.playwright.trace: <path> row with no embedded viewer.
  • Doc strings opened with an """xhtml fence are now treated the same as """html ones: their body gets HTML syntax highlighting, the body is foldable (and honours the "Collapse HTML doc strings" setting), a gutter icon renders an inline preview of the markup, and selecting the body and running Reformat Code pretty-prints it with the HTML formatter.
  • Selecting the body lines of a typed doc string (one opened with a content-type fence such as """json or """html) and running Reformat Code now pretty-prints that content in its own language — JSON, YAML, HTML, XML, and SVG — and re-indents the result under the doc string's fence. Only the selected doc string is affected: reformatting with nothing selected (or the caret elsewhere in the file) leaves every doc-string body untouched, and a doc string with no content type, or one whose type has no formatter, is left unchanged.
  • The Execution Report preview now reproduces a Scenario Outline (or Scenario Template) by rebuilding its heading and placeholder steps, then listing one nested Example per row of its examples table with each row's values substituted into the step text. The rebuilt heading and placeholder steps come from the recorded report; the Examples table itself is not repeated. Reports produced without the outline's template steps (older runs) instead show the substituted rows alone, without a rebuilt heading. As with the rest of the preview, the rows come from the recorded report, so the pane keeps showing the run even after the spec file is edited.
  • A doc string or data table attached to a Scenario Outline step is now reproduced in the Execution Report preview too: it appears once beneath the rebuilt placeholder step with its <> placeholders left in place, and again beneath each expanded Example with that row's values substituted in. As with the outline's step text, both come from the recorded report.
  • The active-pair link highlight now pairs a Scenario Outline with the template block the Execution Report pane rebuilds for it: putting the caret on the outline heading frames the rebuilt heading together with any description lines beneath it, on a Scenario Outline step frames its rebuilt placeholder step together with any doc string or data table attached to it, and on an examples table row frames just that row's expanded Example — each with a connecting divider polygon. The pairing works both ways: in the report pane, putting the caret on a rebuilt Example heading frames the examples table row it was expanded from, on a rebuilt placeholder step frames the outline step in the editor, and on a step inside an expanded Example frames the outline template step that row ran from. The Examples keyword and the table header row have no counterpart, so they highlight nothing.
  • The <> placeholders in a Scenario Outline's rebuilt heading and template steps now carry the same outline-parameter colour in the Execution Report preview that they have in the spec editor, so the parameterised template reads the same on both sides.
  • The active-pair link highlight now links a Background step with the copies the Execution Report pane inlines ahead of each scenario. Because a background step is repeated once per scenario in the report, putting the caret on the Background heading or one of its steps in the editor highlights nothing; instead, putting the caret on one of those inlined report lines frames just that line and, across the divider, the single Background step in the editor it came from — even when other scenarios inline the same step.
  • The Execution Report preview now shows each scenario's Background steps inline as its leading steps — the feature-level, and for a scenario under a Rule the rule-level, steps that ran before it, in run order — taken from the recorded report. There is no separate Background heading in the preview; the steps simply precede the scenario's own steps. This also applies to the per-row scenarios a Scenario Outline expands into.
  • Changing a Java step method's parameters with IntelliJ's Change Signature refactoring now updates the matching step text in associated feature files. Adding a parameter inserts the default value you give it as a quoted value at the corresponding position in each step; removing a parameter drops its quoted value (keeping any doc string or data table attached to the step); reordering parameters rearranges the quoted values to match the new order. Each quoted value follows its parameter, so this works even when the same change also renames the method.

Changed

  • Every option on the Execution results settings page now starts turned off, so all execution-report-driven features are opt-in: gutter and toolbar status indicators, failed-step error icons and their inline panel, Project-view spec file icons and folder status chevrons, the published-reporter-entry panels (and Playwright traces), and the Execution Report split view. Turn on the ones you want under Settings → Tools → SpecBinder → Execution results.
  • The editor "Collapse on open" folding option for HTML doc strings is now labelled "HTML/XHTML doc strings", reflecting that it also collapses """xhtml doc strings on open.
  • Outline placeholders (<name>) inside a Scenario Outline are now always shown in the single outline-parameter colour, whether or not the placeholder's name matches a column in the Examples table. The separate colour previously used for an unmatched placeholder has been removed, along with its "unresolved outline parameter" entry in Settings → Editor → Color Scheme → Gherkin.
  • Navigation, Find Usages, and step completion now recognise the renamed feature-level Background setup method in SpecBinder-generated test code, keeping Ctrl/Cmd+Click and Find Usages between a feature file's Background and its generated method working with the current generator output.
  • Ctrl/Cmd+Click on a step now goes to the step method itself in the generated test — its concrete implementation, or the abstract declaration when there is no implementation yet — and Ctrl/Cmd+Click on a step's quoted parameter, doc string, or data table goes to the matching parameter of that method. To jump to the step's call site inside the generated test method instead (the previous Ctrl/Cmd+Click destination), use Ctrl/Cmd+Shift+Click, which mirrors Ctrl/Cmd+Shift+Click from a generated call site back to its step. Both directions show the usual navigation link on hover. Call-site navigation lands on the whole step's call statement, not an individual argument.

Fixed

  • The agent status badge (the diamond drawn over a spec file's icon to show whether its linked agent is working, needs input, or has finished) now appears on a freshly installed IDE. Previously, on a machine where the plugin had not yet created its internal status folder, the launched agent's state was never recorded and no badge ever showed; the folder is now created when an agent is launched, and each state update recreates it if it has since been removed, so the badge lights up reliably.
  • The inline Playwright trace row no longer traps the editor's vertical scroll: hovering the collapsed row and using the mouse wheel now scrolls the editor as usual (previously scrolling stopped until the pointer moved off the row). The expanded trace viewer keeps its own scrolling, and once its content reaches the top or bottom the wheel continues scrolling the surrounding editor. The row also shows the normal pointer instead of a text cursor.
  • The failed-step error icon on a Scenario Outline's expanded example steps in the Execution Report pane is now clickable: clicking it (or opening all panels from the toolbar's error-panels button) reveals the inline error panel with that example's failure detail beneath the step, matching how it already works for a plain scenario's failed steps. Previously the icon appeared but did nothing. When the example step recorded Expected and Actual values, the panel also offers the Show diff (and, for HTML or image doc-string values, Visual diff) actions; Approve is not offered for an example step, because its expected value lives in the shared outline template.
  • Angle-bracket text such as <name> is now highlighted as an outline placeholder only where it can actually be one: inside a Scenario Outline or Scenario Template, and never inside an html, xml, or svg doc string (where <…> is the markup's own tags). In a plain Scenario, a Background, or a markup doc string the same <…> is shown as ordinary text — step text, a literal table value, or plain doc-string content — instead of the bold outline-parameter styling.
  • Report-driven gutter status icons now treat a Scenario Outline's example rows that the execution report never recorded as not executed: such a row, the Scenario Outline heading, and the Rule and Feature above it show the amber not-executed chevron instead of leaving the row without an icon and the heading passed. An outline that already has a failed row still shows failed.
  • Find Usages on a Java step method now lists its occurrences in steps belonging to scenarios nested under a Rule, not only scenarios at the top level of a spec file.
  • Reduced the chance of a spurious "stub index" error being reported when opening a project in a Gradle module, by reusing a cached lookup for the spec file's generated test class instead of re-running a project-wide search on every toolbar refresh.
  • Enabling, disabling, or updating the plugin now prompts to restart the IDE instead of reloading it in place. This avoids a rare crash where opening a spec file after re-enabling the plugin failed with an internal class-loading error.
  • Pressing Esc while a failed step's Visual diff window (the rendered HTML comparison or the image comparison) is open now closes it and returns to the editor, matching how the standalone text diff window already behaved. Previously Esc only refocused the main IDE window and left the Visual diff window open.

2026.13.0

Added

  • The left spec-editor toolbar now has a report section (after the collapse / expand buttons) showing the date and time the displayed Execution Report was generated, with an "Auto-reload" checkbox and a "Reload" link. With auto-reload off (the default) the pane keeps showing the current report when a newer one is written to disk and the "Reload" link appears to load it on demand; with auto-reload on, newer reports load automatically (the setting is global and also lives in Settings > Tools > SpecBinder > Execution results). Switching to editor-only view and back to a report view reloads the latest report automatically.
  • Every right-pane colour palette (failed-step error panels, image and HTML doc-string previews, published reporter entries, and the split-view link highlight) now shows a swatch of your last-picked custom colour next to the "Custom…" button, so the custom colour stays visible at a glance; clicking the swatch re-applies it.
  • Two new buttons on the left spec-editor toolbar (after the status lozenges) collapse or expand every Scenario and Background section in the file at once. They act on whichever editors are visible — both the spec editor and the Execution Report pane in split view, the spec editor alone in editor-only mode, and the report pane alone in preview-only mode.
  • A new "Show Previews" split button on the right-pane toolbar: its main button opens the inline preview for every previewable doc string in the file at once — image, HTML, and SVG alike — and clicking it again closes them; its dropdown arrow opens a colour palette (with a "Custom…" option) for the single shared colour of each preview's left bar. It acts on whichever editors are visible — both panes in split view, the spec editor in editor-only mode, the report pane in preview-only mode.
  • A new "show all error panels" split button on the right-pane toolbar (second from the left): its main button opens an inline error panel under every failed step at once, and clicking it again closes them all; its dropdown arrow opens a colour palette (with a "Custom…" option) for the colour of each panel's left bar. The panels appear in the Execution Report pane in split/preview modes and in the spec editor in editor-only mode. Whether inline error panels are available at all remains controlled by the SpecBinder settings.
  • New master "Use SpecBinder execution reports" checkbox (Execution results): when off, no execution-report data is read and all dependent features (gutter icons, failed-step error icons, inline error panel, split-view) are disabled. On by default.
  • New "Show inline error panel" toggle (Execution results): when on (default), clicking a failed-step error icon opens the inline error panel; when off, the icon is indicator-only.
  • New "Show HTML previews" and "Show image previews" toggles for the inline error panel's Expected / Actual values (both on by default).
  • The SpecBinder landing page now has shortcut links that jump to the Gherkin "Color scheme" and "Code style" pages (under the IDE's standard Editor sections).
  • Long lines in spec files can be kept on one line with a horizontal scrollbar instead of wrapping ("Don't wrap long lines in spec files", under Editor); also applies to the Execution Report view in split mode, and takes effect on next file open.
  • Clicking the gutter Run icon on a Feature, Rule, or Scenario keyword in a .specb / .feature file now creates a Gradle test run configuration (equivalent to ./gradlew :test --tests "<class>" or …--tests "<class>.<method>") when the file lives in a Gradle-managed module, so test execution flows through the Gradle build with the matching task graph, system properties, and IDE / build classpath rather than IntelliJ's direct JUnit runner. Maven and non-Gradle projects continue to use the existing JUnit run configuration.
  • The Execution Report preview now shows data tables and doc strings inline beneath each step, formatted in the same Gherkin shape as the source file (pipe-aligned table rows; triple-quoted doc string blocks)
  • The Execution Report preview now renders Feature, Rule, and Scenario description text inline beneath each heading, mirroring its position in the source file. Description text is taken from the JSON report when the test was generated with description-as-annotation support, and is silently omitted for older reports
  • A toolbar above the left editor pane shows coloured execution-status lozenges for the current Execution Report — an overall-status pill plus passed / failed / skipped / unexecuted scenario counts (a status with no scenarios is hidden). Clicking a count lozenge moves the caret to the next scenario of that status, wrapping after the last; clicking the overall pill steps through the scenarios that share the run's overall status
  • A toolbar above the right Execution Report pane provides a toggle for showing or hiding published reporter entries (off by default)
  • The right-pane toolbar now has a toggle for synchronising the Execution Report's scroll position with the editor (on by default); when on, scrolling either pane drives the other
  • The right-pane toolbar now has a toggle for showing the active-pair link highlight — the divider polygon together with the line tints on either pane — on by default; the toggle disables itself when the editor is in editor-only or preview-only mode where there's no divider to draw into
  • The right-pane toolbar now has a colour swatch button that opens a colour picker for the active-pair link colour used by the divider polygon and the line tints on either pane
  • Click the red error icon in the Execution Report pane's gutter next to a failed step to toggle an inline error panel showing the message, Expected vs Actual, and stack trace — the same affordance available on the spec editor pane, with independent open / closed state per pane
  • The body of a plain """ doc string (no media-type identifier) is now foldable from the editor gutter, the same way HTML / JSON / XML / YAML doc strings already are. A new "Collapse plain doc strings" checkbox under Settings > Tools > SpecBinder > Code folding controls whether plain doc-string bodies are collapsed by default when a feature file opens.
  • Doc-string bodies are now foldable in the Execution Report preview pane too, mirroring the editor-side behaviour: every doc string is foldable regardless of its media-type identifier, and the initial collapsed state respects the matching "Collapse … doc strings" setting (plain, HTML, JSON, XML, or YAML).
  • The HTML doc-string preview gutter icon now appears in the Execution Report preview pane next to every """html opening fence. Clicking it toggles the same inline rendered preview beneath the closing fence that the editor pane already offers.
  • The image doc-string preview gutter icon now appears in the Execution Report preview pane next to every """image (and """img) opening fence. Clicking it toggles the same inline rendered image preview beneath the closing fence that the editor pane already offers.
  • A new """image content-type identifier for doc strings: clicking the gutter preview icon next to a """image opening fence toggles an inline rendered preview of the base64-encoded image (PNG, JPEG, GIF, WebP, BMP — format auto-detected from the decoded bytes) beneath the closing fence, with the same thin frame, step-keyword-aligned indent, and editor background as the """html preview. An empty body, invalid base64, or bytes that aren't a recognised image format surface a red error icon and explanatory message in place of the preview. Spell-checking is automatically disabled inside """image bodies so the IDE's typo quick-fix can't silently corrupt the encoded bytes.
  • Two new checkboxes under Settings > Tools > SpecBinder for the """image doc-string family: "Auto-open image previews" (under Doc string previews) renders every image preview automatically when a feature file opens, and "Collapse image doc strings" (under Code folding) folds """image (and """img) doc-string bodies by default — both mirror the equivalent toggles already available for """html doc strings.
  • When a step fails comparing two """image (or """img) doc-string values, the inline error panel now embeds a decoded image preview beneath each of the Expected and Actual base64 rows, the same way it already does for """html doc strings, so the two images can be compared side by side without copy-pasting the base64 into an external viewer.
  • The inline error panel's action row now treats """image (and """img) doc-string parameters the same way as """html: the Approve button rewrites the failing step's doc-string body with the Actual base64 verbatim, and the Show diff button opens the textual diff viewer. The Visual diff button is omitted for """image step parameters (image rendering is already shown inline beneath each value row).

Changed

  • The Execution Report preview now renders Feature, Rule, Scenario, and step rows from the text recorded in the JSON report — Scenario Outline rows show parameter values exactly as they were executed, and the preview keeps working when the source file has uncommitted edits since the run. Older reports continue to render using the source file's text as a fallback.
  • Failed-step gutter icons now use a red circle with an X cut-out, visually distinct from the red circle with a white exclamation mark used on the Execution Report preview's aggregate failure rows for Feature, Rule, and Scenario — making it easy to tell at a glance which row is the actual failing step (and the clickable affordance for the inline error panel) versus the rows that summarise a descendant failure
  • When the caret sits anywhere inside a step block — its keyword line, its data table rows, or its doc string content — the active-pair link (line tint on both panes and connector polygon in the divider) now spans the full step block on both sides, rather than just the keyword line
  • When the caret sits on a description line of a Feature, Rule, or Scenario — or on its heading — the active-pair link now spans the full heading-plus-description block on both panes, the same way step blocks already widen for their data tables and doc strings
  • Published reporter entries (the indented "↳ key: value" rows under steps) are now hidden by default in the Execution Report preview and can be turned on from the new right-pane toolbar toggle
  • The Execution Report preview now shows DocString media-type identifiers (e.g. """html) on the opening fence and uses source-verbatim column headings (e.g. | User Name |) for data tables, matching how the spec was originally written rather than the sanitized field names used inside the row data
  • The Execution Report preview now applies the same per-language doc string support as the editor: a """html body is rendered with HTML syntax highlighting (and other supported media-type identifiers render with their respective languages). The run / re-run gutter icons remain editor-only and are not painted in the report preview
  • When a failed step has a doc string or data table argument, the inline error panel is now rendered immediately below that argument block instead of between the step keyword line and the argument rows, so the step and its argument stay visually together. This applies to both the spec editor pane and the Execution Report preview
  • Published reporter entries in the Execution Report preview are now shown in a dedicated inline panel under the step (a block with a teal left stripe) instead of inserting extra lines into the preview. Entry text inside the panel is selectable and can be copied like any other editor content, the panel adds vertical breathing space above, below, and between individual entries so the rows do not look squashed, the text scales with the editor's font zoom (Cmd / Ctrl + scroll or Increase / Decrease Font Size actions) to stay consistent with the surrounding right-pane text, the right-pane toolbar toggle still controls whether these panels are visible, the entry rendering rules and ordering are unchanged, and on a failed step the published-entries panel sits between the step row and the inline error panel so the contextual data the step recorded is read before the failure detail
  • The inline error panel for failed steps now scales with the editor's font zoom — increasing or decreasing the font size in the spec editor or the Execution Report preview also resizes the panel's Message, Expected, Actual, and stack-trace content text, so it stays consistent with the surrounding editor text on both panes
  • The inline panels under steps — the failed-step error panel on both panes and the published reporter entries panel on the Execution Report preview — are now indented so their coloured left stripe sits two columns to the right of the owning step keyword instead of starting flush against the editor's left edge. The indent stays aligned with the step keyword's column at every font zoom level, and in both single-pane editor and split editor / preview view modes
  • The inline rendered HTML preview for """html doc strings now uses the same step-keyword-aligned horizontal indent on both panes, and stays aligned in both single-pane editor and split editor / preview view modes; when the step also has published reporter entries and / or a failed-step error panel, the HTML preview is rendered first immediately under the doc-string closing fence, with the published-entries panel below it and the error panel at the bottom
  • The inline rendered HTML preview panel for """html doc strings now uses the editor's own background colour around its embedded browser — replacing the previous subtle grey panel background — so the preview blends seamlessly into the surrounding editor on both the spec editor and the Execution Report preview, in all view modes (editor-only, preview-only, and split editor / preview)
  • The inline rendered HTML preview panel for """html doc strings now draws a thin frame around its embedded browser, matching the frame the failed-step inline error panel draws around its Expected / Actual HTML previews, so both surfaces present rendered HTML with the same visual affordance
  • The toolbar row above the editor (failed-scenario counter + prev / next arrows on the left, rendering-option toggles on the right) is now shown in editor-only view as well, not only in split editor / preview and preview-only views — so the failed-scenario navigation arrows and the preview-related toggles remain reachable without having to switch the view mode first
  • The blank vertical strip between the spec editor and the Execution Report preview in split editor / preview view is now half as wide, giving more horizontal room to the editor panes themselves while still leaving space for the active-pair link connector polygon

Fixed

  • The active-pair link connector polygon in the split editor's divider no longer drifts out of alignment with the line tints on either pane after clicking inside an inline panel (published reporter entries, error panel, HTML preview) or after focus shifts between panes without a caret move; the polygon and the line tints now always reflect the same anchor element
  • Resolved an internal IDE exception that was raised on every repaint of the split editor's divider when the Execution Report preview was open
  • Opening a .specb or .feature file in split view no longer occasionally leaves the editor's gutter on its default left side; it now consistently sits next to the central divider from the first paint, without requiring a manual toggle of the view mode to fix it
  • The Execution Report preview no longer shows two stacked HTML preview toggle icons next to """html doc string fences; only the preview's own native toggle (wired to the right pane's inlay) is shown
  • Hovering the HTML preview toggle in the Execution Report preview's gutter now changes the mouse pointer to the hand cursor, matching the affordance shown for the same icon on the editor side
  • The "Message", "Expected", "Actual", and "Stack trace" field labels in the inline error panel for failed steps now use the same font size as their values, instead of the smaller UI font that made the labels read as a different rank
  • Published reporter entries in the Execution Report preview no longer occasionally appear twice under the same step; each step's published-entries panel is now installed exactly once
  • The inline error panel's action buttons (Approve, Show diff, Visual diff) and the diff viewers they open no longer fail silently in the released plugin — internal helper classes are now correctly preserved through obfuscation so the panel and its actions load reliably

Removed

  • The "Fold long values" setting (fold mode + line-count threshold) has been removed from the inline error panel options. Long values now always start collapsed to their first line — every multi-line value, plus any single line longer than 140 characters — with a chevron to expand. This is no longer configurable.

2026.11.0

Removed

  • Compatibility with IntelliJ IDEA 2024.2 — the minimum supported IDE build is now 2024.3 (243.0). Users still on 2024.2 should upgrade their IDE to install future versions of the plugin.

2026.10.0

Added

  • In the inline error panel, the cursor now reads as a hand-pointer when hovering the chevron and as a text I-beam when hovering the value text, so clickable and selectable regions of a Message, Expected, Actual, or Stack trace row are visually distinct at a glance.
  • The inline error panel's Stack trace now mirrors the same row layout as the Message, Expected, and Actual rows: the first line of the stack trace (typically the exception class plus message) is shown in the row header alongside a chevron, and the remaining frames are revealed when the row is expanded. Single-line stack traces render plainly with no chevron.
  • Navigation support for Gherkin keyword aliases: Ability, Business Need, Narrative (Feature), Example (Scenario), and Scenario Template (Scenario Outline)
  • Code Style settings page under Editor > Code Style > Gherkin (SpecBinder) with configurable tabs and indents, commenting, and blank line options
  • Step auto-completion now uses fuzzy word matching: typing any word will suggest every step whose text contains that word at any position; typing multiple words requires every word to appear in the step text, in any order
  • Gutter icons in feature files now reflect the latest execution state of the corresponding test: Feature, Rule, and Scenario keywords show a green check when the matching test has passed, or a red mark when the matching test has failed
  • Breakpoints can now be set directly on Gherkin step lines in feature files; running the test in debug mode pauses the JVM at the corresponding generated call site, and the editor highlights the step in the feature file rather than the generated Java source
  • HTML doc-string parameters (opened with """html) now show a preview icon in the editor gutter on the line of the opening fence
  • Clicking the HTML doc-string gutter preview icon displays an inline preview of the rendered markup below the closing fence of the doc string; clicking it again removes the preview
  • Open HTML doc-string previews update automatically and live-reload as you edit the markup, with rapid keystrokes debounced to avoid flicker
  • Gutter icons can now reflect per-scenario pass/fail outcomes recorded by the SpecBinder execution reporter's JSON files, including per-row icons on Scenario Outline data rows; failing scenarios get a tooltip naming the failing step
  • When the recorded outcome no longer matches the current spec content (e.g. the scenario was edited since the last run), the stale pass/fail icon is hidden by default so a green checkmark cannot mislead; an opt-in setting renders the stale outcome as a desaturated icon with a warning overlay instead
  • New "JSON-report results" section under Settings > Tools > SpecBinder with two checkboxes: a master toggle (off by default) to enable JSON-based gutter icons, and a "Hide stale icons" toggle (on by default) to control how stale outcomes are visualised
  • Failed steps now also show a red error icon in the gutter, anchored on the step keyword, with a tooltip carrying the recorded error type and message; only steps recorded as failed are decorated, passed and skipped steps remain untouched
  • Failed-step gutter icons are also subject to the existing staleness rules: when the recorded outcome no longer matches the current spec content (e.g. the scenario was edited since the last run), the failed-step icon is hidden by default so a stale red error icon cannot mislead
  • Stack-trace frames in the inline error panel are now clickable hyperlinks: each (FileName.java:line) reference becomes a link that opens the source file at the given line, mirroring the navigation experience of IntelliJ's run/debug console output. Frames without a navigable source location (Native Method, Unknown Source) stay as plain text. Frames pointing at a nested class (e.g. a SpecBinder-generated @Nested Rule class) navigate correctly even though the stack trace uses the JVM Outer$Inner form
  • Stack-trace frames whose class lives outside the project's source files (JDK, JUnit, and other library frames) are now rendered in a softened, lower-contrast colour, while frames pointing at the project's own source files are rendered with a teal accent in bold by default — together making user-code frames immediately spottable in long stack traces, matching the IntelliJ run/debug console convention
  • New "Inline error panel — in-module stack trace styling" section under Settings > Tools > SpecBinder lets you pick the colour and font style (Normal / Italic / Bold) used for in-module stack trace frames in the inline error panel
  • Doc strings tagged with an HTML fence (e.g. """html) are now treated as HTML by the editor: the contained markup gets HTML syntax highlighting, fold markers on multi-line elements, and HTML completion proposals — the same language services you would see in a standalone .html file. The fence identifier and surrounding Gherkin keep their normal Gherkin colours, and the doc-string indentation is removed before the content is handed to the HTML language services so embedded markup is parsed as if written at column zero. Editing inside the highlighted region is read-only in this release.
  • New "Collapse HTML doc strings" option under Settings > Tools > SpecBinder > Code folding: when enabled, the body of every """html doc string is folded by default when a feature file is opened, mirroring the existing Collapse Rules / Collapse Scenarios options.
  • Doc strings tagged with a """json, """xml, or """yaml (also """yml) fence are now treated as JSON / XML / YAML by the editor, with the same language services as HTML — syntax highlighting, fold markers on multi-line structures, and language-specific completion proposals — and matching "Collapse JSON / XML / YAML doc strings" toggles under Settings > Tools > SpecBinder > Code folding that fold their bodies on file open.
  • New "Auto-open HTML previews" option under Settings > Tools > SpecBinder > Doc string previews: when enabled, all """html doc strings are automatically rendered inline when a feature file is opened, without needing to click each gutter icon individually.
  • The HTML doc-string preview gutter icon now reflects the preview state at a glance: a neutral grey eye while the preview is hidden and a green eye while the preview is visible, so it is easy to see which """html doc strings are currently rendered.
  • When a failed step's execution report carries both expected and actual values, the inline error panel now shows a "Show diff" link beneath the Expected and Actual blocks. Clicking the link opens IntelliJ's standalone diff viewer on the two values, with line-level highlighting, so the comparison can be reviewed without leaving the editor.
  • The inline error panel now shows a "Visual diff" link beneath the Expected and Actual blocks when the failing step's parameter is an HTML-tagged doc string ("""html). Clicking it opens a side-by-side rendered HTML diff viewer in a separate frame: each side renders inside a sandboxed iframe (CSS-isolated), and a parallel DOM walk outlines differing elements with dashed coloured boxes — green for modified, red for elements only in Actual, and orange for elements only in Expected. Indicators are off by default; an "Indicators" toggle button in the toolbar reveals them. The toolbar adapts to the IDE theme (white in light themes, dark in dark themes), shows the colour-key legend on the right, and on the left provides up / down arrow buttons that step through differing elements in the Actual pane and ring the current element with a non-displacing blue halo (a box-shadow ring so layout is unaffected); when the Actual element has a positional counterpart in the Expected pane that pane's matching element is also ringed so the user can compare both sides at a glance plus a "Hide indicators" / "Show indicators" toggle that hides or restores all of the highlight boxes in both panes. The viewer supports zoom via keyboard (Ctrl/Cmd + =, Ctrl/Cmd + -, Ctrl/Cmd + 0 to reset) and Ctrl/Cmd + mouse wheel, scaling the rendered HTML in both panes between 50% and 300%.
  • The inline error panel now shows an "Approve" link next to "Show diff" when a failed step's execution report carries both expected and actual values. Clicking it writes the runtime Actual value directly into the failing step's matching parameter ("..." literal or """...""" doc string) — the same edit "Apply Expected to Step" performs in the diff viewer, but in one click and without opening the diff window. If the rewrite cannot be applied (no matching parameter, ambiguous match, or shape mismatch), the matcher's reason is shown as an editor hint so the failure is visible.
  • After a successful "Approve" or "Apply Expected to Step" rewrite, the editor caret is now placed at the end of the replaced value: just before the closing " for a simple parameter, or at the end of the last content line of a doc-string parameter. Editor focus is restored to the spec file so the user can keep typing.
  • When the failing step's parameter is an HTML-tagged doc string ("""html), the inline error panel now renders a live HTML preview directly below the Expected and Actual values. Each preview is hosted in its own sandboxed iframe with full DOM and CSS isolation so the two snapshots cannot interfere with each other or with the panel's own styling, and the iframe auto-resizes to fit its content.
  • New "Inline error panel — Message / Expected / Actual folding" section under Settings > Tools > SpecBinder lets you choose the *initial* state of multi-line Message, Expected, and Actual values in the inline error panel: Never (start expanded), Always (start collapsed to the first line with an ellipsis), or When longer than N lines (default 10) — the new default, so short multi-line values stop starting collapsed. The fold/unfold affordance is always available on multi-line values regardless of this setting; the setting only controls whether they start expanded or collapsed. Single-line values (including values with only a trailing newline) always render in full as non-foldable.
  • The standalone diff viewer opened from the error panel detects the failing step's doc-string fence ("""html, """json, """xml, """yaml, …) and applies language-aware syntax highlighting, matched-bracket highlighting, and folding to both panes; doc strings without a fence and simple "..." parameters continue to render as plain text.
  • The standalone diff viewer opened from the error panel makes the Expected side editable while keeping Actual as a read-only runtime snapshot, so the standard gutter chunk-arrows are usable for copying differing pieces from Actual into Expected and the Expected pane can also be hand-edited. Two actions are contributed to the diff toolbar: "Copy Actual to Expected" overwrites the Expected pane with the runtime Actual value (equivalent to pressing every chunk-arrow at once) without touching the spec file or closing the viewer, and "Apply Expected to Step" writes the current Expected pane contents into the failing step's matching parameter ("..." literal or """...""" doc string) and closes the viewer. The apply-to-step action is enabled only when exactly one parameter on the step has a literal value equal to the original expected and the candidate replacement legally fits the parameter shape; otherwise it is disabled with a tooltip explaining why.
  • New "Make Rules foldable" option under Settings > Tools > SpecBinder > Code folding: when enabled, multi-line Rule blocks show a fold marker in the editor gutter and can be collapsed; when disabled (the default) Rule blocks stay non-foldable so the gutter stays uncluttered. The "Collapse Rules" option is only available while Rules are foldable.

Changed

  • The embedded HTML previews under Expected and Actual in the inline error panel now align flush with the value text above them — the preview's left edge sits at exactly the same x-coordinate as the value column instead of starting one chevron-column further left
  • The Approve / Show diff / Visual diff action buttons row in the inline error panel now starts flush with the value column too, so its left edge lines up with the value text rows above and the embedded HTML previews below — previously the row started one chevron-column further left
  • HTML doc-string previews no longer show the IDE's CSS color-preview gutter swatches beside style="..." attributes that contain color literals, so the gutter stays clean and the preview's own gutter icon is the only marker on those lines
  • Long Message, Expected, and Actual values in the inline error panel now collapse to their first line by default, with an ellipsis (…) indicator at the end of the line; clicking the value expands it to reveal the remaining lines, and clicking it again collapses it back. Single-line values continue to render plainly without any disclosure affordance, so terse failures stay terse
  • Folding typed doc strings ("""html, """json, """xml, """yaml) now collapses the entire block into a single line showing the opening fence with a placeholder (e.g. """html...), with the fold/unfold gutter marker on the opening fence line — matching the standard IDE folding convention for other languages
  • Switched to calendar-year-based versioning (major version now reflects the release year)
  • Step auto-completion now always shows the suggestion popup, even when only one step matches, so the suggestion (including any parameter placeholders) can be reviewed before inserting
  • Text wrapped in <...> inside a doc string that does not match any Examples table column header is now rendered as plain doc-string text instead of being highlighted as an unresolved outline parameter

Fixed

  • Failed-step error gutter icons are now always hidden when the recorded outcome is stale, regardless of the "Show stale icons" setting; the setting continues to govern scenario, rule, and feature level icons
  • Indentation detection no longer overrides configured code style settings for .specb files, which could cause incorrect formatting (e.g., table rows moving to column 0)
  • Picking a step suggestion from the autocompletion popup now replaces the already typed step text instead of appending the chosen pattern to it
  • Gutter icons for Scenarios inside a Rule now correctly reflect the test execution state when the generated test class is abstract and a separate concrete subclass runs the tests
  • Feature and Rule gutter icons now stay red whenever any child scenario is recorded as failed, even after re-running only the passing siblings (which previously caused the container icon to incorrectly turn green)
  • The inline error panel and the inline HTML doc-string preview no longer show a spinner indefinitely when the embedded browser fails to render: a 5-second watchdog reveals the content at a fallback height, and an in-panel error message is surfaced if the browser reports a load failure

Removed

  • The "Duration" field has been dropped from the inline error panel; the error message, expected/actual values, and stack trace remain the on-demand failure summary, with the step's run time available in the standard run tool window if needed

0.9.0

Added

  • Re-running individual scenarios from the test results tree now correctly redirects to the concrete subclass when the test method is declared in an abstract generated class
  • Gutter run icons in feature files now also redirect to the concrete subclass when the generated test class is abstract
  • Run configuration names from feature files now show the Scenario/Rule/Feature title instead of the Java method name
  • Support for escaped double quotes (\") inside quoted step parameters, matching SpecBinder's escaping rules
  • Rename refactoring for annotation patterns with regex capture groups preserves captured values in step text

0.8.0

Added

  • Rename refactoring for Scenario Outline parameters — invoke Rename on a <parameter> placeholder or Examples table header to rename all occurrences within the same Scenario Outline

Fixed

  • Fix rename of step annotation patterns not propagating changes to matching step text in feature files

0.7.0

Changed

  • Updated Marketplace plugin description with comprehensive feature list

0.6.0

Fixed

  • Remove usage of deprecated IntelliJ Platform API

0.5.0

Added

  • Added autocompletion for Gherkin keywords
  • testing automated release process

0.2.1

Fixed

  • Fix crash when installed alongside the Cucumber/Gherkin plugin caused by conflicting TextAttributesKey names

0.2.0

Added

  • Ctrl/Cmd+Click navigation from feature file elements to SpecBinder-generated test classes
  • Ctrl/Cmd+Click navigation from Java test methods back to Gherkin steps
  • Auto-complete step text from Cucumber annotations and method names
  • Find Usages on Java step methods shows matching steps in feature files
  • Shift+F6 rename on Cucumber annotation strings updates step patterns across feature files
  • Gutter run icons on Feature/Rule/Scenario keywords with JUnit run configuration support
  • Structure tool window showing Feature/Rule/Scenario/Step outline
  • Code folding for Feature, Rule, Scenario, Background, Examples blocks
  • Code formatting with 2-space Gherkin indentation (Cmd+Alt+L)

0.1.0

Added

  • Gherkin syntax highlighting with per-keyword color customization
  • Color settings page (Settings > Editor > Color Scheme > Gherkin)