cucumber/cucumber-ruby

This system is the Cucumber Ruby runtime, a behavior-driven development (BDD) framework that executes feature files written in Gherkin syntax. It provides a modular execution engine with an event-driven architecture, supporting complex test scenarios through hooks, retries, and tag-based filtering. The system features extensive internationalization capabilities, allowing tests to be defined in numerous languages, and includes robust tooling for command-line execution, reporting, and integration with RSpec.

41 changes.

The project underwent a major rebranding from 'Stories' to 'Cucumber', restructuring the core library, build system, and runtime architecture while upgrading underlying dependencies. This period also focused on extensive internationalization support, adding comprehensive localization examples and test coverage for numerous languages including German, French, Spanish, and Arabic.

47 changes.

This period focused on significantly expanding internationalization support by adding comprehensive calculator examples for numerous languages, including Korean, Finnish, Russian, and Hebrew. Concurrently, the codebase underwent structural improvements through the refactoring of the CLI configuration into dedicated classes and the integration of RSpec mocks, accompanied by extensive test coverage for these changes.

35 changes.

This period focused on significantly expanding internationalization support by adding comprehensive calculator examples and step definitions for numerous languages, including Czech, Hindi, Arabic, and Greek. Concurrently, the core execution engine was refactored into a modular filter chain, introducing new components for tag limits, retry logic, and structured data table handling.

17 changes.

This period focused on integrating the Cucumber Compatibility Kit (CCK) to validate the library's conformance with standard Cucumber behaviors. The work involved implementing new event types and structured message envelopes in the Ruby glue layer, alongside extensive additions of step definitions and test suites to cover attachments, hooks, data tables, and various edge cases.

New files \ansi\_escapes.rb\ and \escaping.rb\ have been added to the \lib/cucumber/gherkin/formatter\ directory. The \ansi\_escapes\ module provides a centralized way to handle ANSI color codes for formatter output, allowing users to customize colors via the \GHERKIN\_COLORS\ environment variable. The \escaping\ module introduces an \escape\_cell\ method to properly escape pipes and backslashes in pretty formatter output.

lib/cucumber/gherkin/formatter · high confidence

This change introduces a new example directory for the Hindi (hi) language within the Cucumber i18n examples. It includes a basic Calculator implementation in Ruby, a Rakefile to run the features, and a .gitignore file to exclude generated HTML reports. This allows users to see how Cucumber handles internationalization for Hindi.

examples/i18n/hi · high confidence

Added a new example directory for Uzbek (uz) localization, including a Rakefile to run Cucumber tests and a Ruby Calculator class that implements stack-based arithmetic operations (addition and division) to demonstrate the feature.

examples/i18n/uz · high confidence

Introduces a new TagLimits filter that prevents test suites from exceeding defined limits on the number of occurrences of specific tags. The implementation adds a TestCaseIndex to map tags to test cases and a Verifier that checks these counts against configured limits, raising a TagLimitExceededError with detailed breach information if any limits are surpassed.

_lib/cucumber/filters/tag\limits · high confidence

The 'en-lol' example directory now includes a Rakefile that configures Cucumber for testing, along with Ruby classes (Basket and Belly) that define the example's domain logic for managing 'cukes'.

examples/i18n/en-lol · high confidence

A new Arabic-language example has been added to the examples/i18n/ar directory, providing a working demonstration of internationalization support. This includes a Rakefile for running the examples and a Ruby calculator implementation that exposes a method named 'جمع' (meaning 'add' or 'sum'), allowing users to verify that Cucumber can correctly parse and execute feature files written in Arabic.

examples/i18n/ar · high confidence

A new example feature file has been added to demonstrate Gherkin syntax in Arabic. This file, located in the Arabic i18n examples directory, shows how to define features, scenarios, and examples using Arabic keywords (such as 'خاصية' for Feature and 'سيناريو' for Scenario), allowing users to see how internationalization is handled in test definitions.

examples/i18n/ar/features · high confidence

A new step definition file (calculator\_steps.rb) has been added to the Arabic i18n example suite, enabling the calculator feature to be executed with Arabic-language Gherkin scenarios.

_examples/i18n/ar/features/step\definitions · high confidence

Added a new step definition file for the Bulgarian (bg) localization of the calculator example, enabling users to run the calculator feature tests using Bulgarian language steps.

_examples/i18n/bg/features/step\definitions · high confidence

New support files (env.rb and world.rb) have been added to the Bulgarian (bg) i18n example directory, enabling users to run the calculator feature examples in Bulgarian. The environment setup includes compatibility for both RSpec 2 and older versions of rspec-expectations, loads the Cucumber unicode formatter, and registers a LazyCalc helper module in the world.

examples/i18n/bg/features/support · high confidence

This change introduces a new example demonstrating support for the Bulgarian language within the i18n examples. It includes a Rakefile to run the Cucumber tests and a Ruby-based Calculator class that implements basic stack operations (push, result, addition, and division) to serve as the backend logic for the feature scenarios.

examples/i18n/bg · high confidence

New .feature files have been added to the examples/i18n/bg/features directory, providing Bulgarian translations for calculator scenarios including addition, division, and consecutive calculations. These files utilize the \# language: bg directive to enable users to view and interact with the example scenarios in Bulgarian.

examples/i18n/bg/features · high confidence

A new Catalan language example has been added to the i18n examples directory. This includes a Rakefile for running Cucumber tests, a 'suma' (addition) feature file defining scenarios for a calculator, and the corresponding Ruby implementation of the calculator logic.

examples/i18n/ca · high confidence

An example feature file demonstrating addition scenarios in Simplified Chinese (zh-CN) has been added to the i18n examples directory. This file includes scenarios for adding two and three numbers, utilizing the specified language directive to support localization testing and examples.

examples/i18n/zh-CN/features · high confidence

A new step definition file for the Chinese (zh-CN) localization of the i18n calculator example has been added. This file implements the Gherkin steps using Chinese keywords (假如, 当, 那么) and defines a parameter type to map the Chinese text '按相加按' to the 'add' operation, enabling the calculator feature to be executed with Chinese language scenarios.

_examples/i18n/zh-CN/features/step\definitions · high confidence

A new step definition file (kalkilatris\_steps.rb) has been added to the i18n/ht (Haitian Creole) example directory. This file implements the test steps for the calculator feature using Creole keywords (Sipoze, Lè, Lèsaa), allowing users to run the calculator example with Haitian Creole translations.

_examples/i18n/ht/features/step\definitions · high confidence

New step definitions have been added to support Cucumber compatibility testing. The \attachments\_steps.rb\ file introduces steps for attaching text, logging messages (including those with ANSI escape codes), attaching binary data, handling PDF documents, and attaching URI links. Additionally, \hooks\_steps.rb\ provides basic Before/After hooks and step definitions for simulating passing and failing steps to facilitate hook-related testing.

compatibility/features/attachments · high confidence

The examples/i18n/cs directory now contains a complete i18n example for the Czech locale, including a Rakefile for running Cucumber tests, a .gitignore file, and a Ruby Calculator class implementation. This provides users with a concrete reference for implementing Czech language support in their own applications.

examples/i18n/cs · high confidence

New feature files have been added to the Czech (cs) i18n examples directory, providing localized Gherkin scenarios for addition and division operations. These files allow users to verify that the application correctly parses and executes calculator logic using Czech keywords and syntax.

examples/i18n/cs/features · high confidence

The Danish (da) i18n example directory now includes a Rakefile for running Cucumber tests, a \lommeregner.rb\ library implementing a stack-based calculator, and a \sammenlaegning.feature\ file demonstrating addition scenarios in Danish. This provides a complete, runnable example for users wanting to test Cucumber's internationalization support with Danish keywords.

examples/i18n/da · high confidence

New example feature files have been added to the English internationalization examples directory. The addition example demonstrates a Scenario Outline with table-driven data for calculator sums, while the division example illustrates the use of the asterisk (\*) as a synonym for Given/When/Then steps in a standard scenario.

examples/i18n/en/features · high confidence

This change introduces a new internationalization example for the Esperanto language. It includes a basic calculator implementation (supporting addition and division) and corresponding Cucumber feature files written in Esperanto to demonstrate how the application handles localization for this specific locale.

examples/i18n/eo · high confidence

A new step definition file (calculator\_steps.rb) has been added to the Esperanto (eo) i18n example directory, enabling users to run the calculator feature tests using Esperanto language steps.

_examples/i18n/eo/features/step\definitions · high confidence

A new step definition file for the Estonian (et) i18n example has been added, implementing the core steps for a calculator feature. Users can now run the Estonian localization example which maps Estonian language steps (such as 'I have entered a number', 'I press an operation', and 'The screen should show') to the underlying Kalkulaator library logic.

_examples/i18n/et/features/step\definitions · high confidence

The Estonian (et) internationalization example now includes a functional calculator library (Kalkulaator) supporting addition (liida) and division (jaga) operations, along with a Rakefile to easily run the associated Cucumber feature files using the pretty formatter.

examples/i18n/et · high confidence

New example feature files have been added to the i18n Estonian (et) examples directory, demonstrating the calculator's addition and division capabilities in Estonian. The 'jagamine.feature' file covers division scenarios, while 'liitmine.feature' includes a scenario outline for addition with multiple input/output cases, allowing users to verify that the framework correctly parses and executes Gherkin syntax in Estonian.

examples/i18n/et/features · high confidence

New Cucumber step definition files have been added for the Finnish (laskin) and Hindi (calculator) localization examples. These files implement the Gherkin step bindings for basic arithmetic operations (add, divide) in their respective languages, enabling users to run and verify the calculator functionality in Finnish and Hindi contexts.

_examples/i18n/fi/features/step\_definitions, examples/i18n/hi/features/step\definitions · high confidence

The examples/i18n/fi directory now contains a complete Finnish-language example featuring a calculator DSL (lib/laskin.rb) and a Rakefile for running Cucumber tests. This addition provides users with a concrete reference implementation for localizing Cucumber features and step definitions into Finnish, including a simple stack-based calculator class (Laskin) with methods for pushing numbers, summing, and dividing.

examples/i18n/fi · high confidence

New example feature files have been added to the Finnish (fi) i18n examples directory, providing localized scenarios for division (jakolasku) and addition (yhteenlasku). These files demonstrate the use of Finnish keywords (such as 'Ominaisuus', 'Tapaus', 'Oletetaan että') to define calculator operations, allowing users to verify that the framework correctly parses and executes scenarios written in Finnish.

examples/i18n/fi/features · high confidence

The French localization example now includes a Rakefile to run the Cucumber scenarios and a new \Calculatrice\ class in \lib/calculatrice.rb\ that provides basic stack-based addition functionality for the feature tests.

examples/i18n/fr · high confidence

New French-language example feature files have been added to the i18n examples directory, demonstrating how to write Gherkin scenarios using French keywords (such as 'Fonctionnalité', 'Soit', 'Etant donné') and how to structure scenario outlines with example tables.

examples/i18n/fr/features · high confidence

The French localization example now includes a dedicated step definition file for the calculator feature, enabling users to run the calculator scenario using French keywords such as 'Soit', 'Etant donné que', 'Lorsqu', and 'Alors'.

_examples/i18n/fr/features/step\definitions · high confidence

A new German-language example has been added to the examples/i18n/de directory. This includes a Rakefile for running Cucumber tests, a .gitignore file to exclude generated HTML reports, and a Ruby Calculator class that supports pushing values, adding them, and dividing the top two stack elements.

examples/i18n/de · high confidence

New German-language feature files have been added to the i18n examples directory, providing localized scenarios for addition and division operations. These files demonstrate the use of the \\# language: de\ directive and German keywords (such as \Funktionalität\, \Szenario\, and \Angenommen\) to support internationalization testing and documentation.

examples/i18n/de/features · high confidence

Added a new Greek-language example directory under examples/i18n/el containing Cucumber feature files for addition and division, a corresponding Calculator implementation, and supporting build files (Rakefile, .gitignore). This provides a localized reference implementation for Greek users to understand and run the calculator examples.

examples/i18n/el · high confidence

The calculator example now supports Greek (el) localization by introducing a new step definition file (calculator\_steps.rb) that maps Greek text to the existing calculator logic, enabling users to run the example using Greek-language feature files.

_examples/i18n/el/features/step\definitions · high confidence

New feature files have been added to the examples/i18n/ht/features directory, providing Gherkin scenarios in Haitian Creole for addition and division operations. These files enable users to verify that the parser correctly handles the 'ht' language tag and translates keywords like 'Karakteristik', 'Senaryo', and 'Egzanp' as expected.

examples/i18n/ht/features · high confidence

This change introduces a new internationalization example for Haitian Creole (ht) in the examples/i18n/ht directory. It includes a Rakefile for running Cucumber tests, a .gitignore file, and a Ruby library (lib/kalkilatris.rb) that implements a simple calculator class with methods for pushing values, adding them, and dividing the first two values. This provides a localized example of how the application's core logic can be adapted for different languages.

examples/i18n/ht · high confidence

This change introduces a new example directory for Hebrew (he) localization, allowing users to write and run Cucumber scenarios using Hebrew keywords. The addition includes a Rakefile for task execution, a calculator library with Hebrew method names (such as 'chaber' for addition and 'chalak' for division), and feature files demonstrating addition and division scenarios written entirely in Hebrew. This enables users to verify that the Cucumber runtime correctly parses and executes features defined with the Hebrew language tag.

examples/i18n/he · high confidence

New Cucumber feature files have been added to the examples/i18n/hi/features directory, providing localized examples for addition and division operations in Hindi. These files, marked with \# language: hi, demonstrate how the calculator handles input and output for users interacting with the application in Hindi, supporting the --i18n hi usage flag.

examples/i18n/hi/features · high confidence

New Hungarian-language feature files have been added to the examples directory: 'osszeadas.feature' defines a scenario outline for adding two numbers, and 'osztas.feature' defines a scenario for dividing two numbers. These files provide localized examples for testing the calculator's arithmetic operations in Hungarian.

examples/i18n/hu/features · high confidence

A new step definition file for Hungarian (hu) localization has been added to the examples/i18n directory. This file implements the Cucumber steps required to interact with the calculator feature in Hungarian, including steps for entering numbers, pressing operation buttons, and verifying results.

_examples/i18n/hu/features/step\definitions · high confidence

This change introduces a new example directory for the Hungarian (hu) locale, providing users with a reference implementation for internationalization. The example includes a basic Calculator class with push, add, and divide operations, a Rakefile to run Cucumber tests with pretty formatting, and a .gitignore file to exclude generated HTML reports.

examples/i18n/hu · high confidence

New example feature files have been added to the Indonesian (id) localization set, demonstrating how calculator scenarios for addition and division are written in Indonesian. These files use the \\# language: id\ directive and translate standard Gherkin keywords (such as Feature, Scenario, Given, When, Then) into their Indonesian equivalents (Fitur, Skenario, Dengan, Ketika, Maka), providing a reference for implementing Indonesian language support in the application.

examples/i18n/id/features · high confidence

New example directories for Indonesian (id) and Japanese (ja) have been added, each containing a Calculator implementation, a .gitignore to exclude generated HTML reports, and a Rakefile to run the Cucumber tests. This provides users with ready-to-run, localized example projects that can be executed via standard Rake tasks.

examples/i18n/id, examples/i18n/ja · high confidence

The examples/i18n/it directory now includes a complete, runnable example demonstrating Cucumber's internationalization support in Italian. This addition features a new Rakefile to execute the tests, a calculator implementation (lib/calcolatrice.rb), and a feature file (features/somma.feature) that uses Italian keywords (e.g., 'Funzionalità', 'Scenario', 'Dato') to verify that the framework correctly parses non-English step definitions.

examples/i18n/it · high confidence

A new step definition file for the Japanese (ja) i18n example has been added, implementing the Gherkin steps for a calculator feature. This allows users to run the calculator example with Japanese language support, defining steps to input integers, press operations, and verify displayed results.

_examples/i18n/ja/features/step\definitions · high confidence

New example feature files in Japanese (addition.feature and division.feature) have been added to the i18n examples directory, demonstrating how to write Gherkin scenarios using the Japanese language tag and localized keywords for features, scenarios, and steps.

examples/i18n/ja/features · high confidence

A new Korean (ko) language example has been added to the i18n examples directory. This includes a basic Calculator implementation in Ruby, a Rakefile for running Cucumber tests, and a .gitignore file to exclude generated HTML reports, providing a reference for implementing Korean localization in Cucumber projects.

examples/i18n/ko · high confidence

New Korean (ko) feature files have been added to the examples directory, providing localized translations for addition and division scenarios. These files demonstrate the use of Korean keywords (such as '기능', '시나리오', '조건', '만일', '그러면') within Gherkin syntax, allowing users to see how internationalization is implemented in example projects.

examples/i18n/ko/features · high confidence

New example files have been added to the \examples/i18n/lv\ directory to demonstrate Cucumber's internationalization capabilities in Latvian. This includes a \Rakefile\ for running tests, a \Calculator\ implementation, and feature files (\addition.feature\, \division.feature\) that use Latvian keywords (such as \Funkcionalitāte\, \Scenārijs\, \Kad\, \Un\, \Ja\, \Tad\) to define addition and division scenarios.

examples/i18n/lv · high confidence

New feature files for addition and division operations have been added to the Lithuanian (lt) i18n examples, allowing users to run and verify calculator functionality using Lithuanian keywords such as 'Savybė' (Feature), 'Scenarijus' (Scenario), and 'Duota' (Given).

examples/i18n/lt/features · high confidence

This change introduces a new Lithuanian (lt) localization for the i18n examples, specifically providing the calculator feature set. The update includes the necessary project structure files, such as a Rakefile for running tests and a .gitignore to exclude generated artifacts, alongside the core calculator implementation logic in lib/calculator.rb.

examples/i18n/lt · high confidence

A new step definition file for Norwegian (no) localization has been added, providing Gherkin steps for a calculator feature. Users can now interact with the calculator using Norwegian language scenarios, including steps for entering numbers, summing them, and verifying the result.

_examples/i18n/no/features/step\definitions · high confidence

A new support environment file (env.rb) has been added for the Norwegian (no) i18n example suite. This file configures the runtime by requiring RSpec expectations (with a fallback for older versions), enabling Cucumber's unicode formatter, and adding the project library path to load the 'kalkulator' component.

examples/i18n/no/features/support · high confidence

A new example feature file (summering.feature) has been added to the Norwegian i18n examples, demonstrating how to write Gherkin scenarios in Norwegian using the \# language: no directive. This file includes scenarios for summing two and three numbers, utilizing Norwegian keywords such as Egenskap, For å, Som, Vil, Gitt, Og, Når, and Så, along with support for the @iterasjon3 tag.

examples/i18n/no/features · high confidence

This change introduces a new example directory for the Polish language, providing users with a reference implementation for localizing Cucumber features. It includes a Rakefile for running tests, a .gitignore file, and specific feature files (addition.feature, division.feature) demonstrating Polish keywords such as 'Właściwość', 'Scenariusz', 'Zakładając', and 'Wtedy'. The example also provides a corresponding Ruby calculator implementation (lib/calculator.rb) with methods like 'dodaj' and 'podziel' to support the localized step definitions.

examples/i18n/pl · high confidence

A new support environment file (env.rb) has been added for the Polish (pl) i18n example. This file configures the test environment by loading RSpec expectations (with a fallback for older versions), enabling Unicode formatting, and ensuring the calculator library is available for the Polish language feature tests.

examples/i18n/pl/features/support · high confidence

A new step definition file for the Portuguese i18n example has been added, implementing steps for a calculator feature. Users can now run the Portuguese localization example which verifies basic arithmetic operations (addition) using Portuguese language steps (e.g., 'Dado que eu digitei', 'Quando eu aperto o botão de soma', 'Então o resultado...').

_examples/i18n/pt/features/step\definitions · high confidence

A new support environment file (env.rb) was added for the Portuguese (pt) i18n example suite. This file configures the runtime by requiring RSpec expectations (with a fallback for older versions), enabling Cucumber's Unicode formatter, and adding the project library path to load the 'calculadora' module.

examples/i18n/pt/features/support · high confidence

A new example feature file (adicao.feature) has been added to the Portuguese i18n examples directory, demonstrating how to specify the scenario language directly within the .feature file using the \# language: pt directive. This file contains a basic addition scenario written in Portuguese, illustrating the syntax for keywords like Funcionalidade, Cenário, Dado, E, Quando, and Então in the target language.

examples/i18n/pt/features · high confidence

The Chinese localization example now includes a Rakefile to facilitate running the associated Cucumber tests, along with a new calculator.rb library that provides a basic stack-based calculator implementation used within the example.

examples/i18n/zh-CN · high confidence

A new Romanian (ro) feature file has been added for the addition calculator example, providing localized Gherkin syntax for the 'Addition' functionality. This allows users interacting with the Romanian locale to see test scenarios and steps translated into their language, specifically covering the scenario of summing two numbers.

examples/i18n/ro/features · high confidence

The Russian localization example directory now includes a Rakefile for running Cucumber tests and a calculator library implementation, providing a concrete reference for implementing step definitions in Russian.

examples/i18n/ru · high confidence

A new step definition file (calculator\_steps.rb) has been added to the Russian i18n examples, enabling users to interact with the calculator feature using Russian language steps such as entering numbers, performing operations, and verifying results.

_examples/i18n/ru/features/step\definitions · high confidence

New .feature files have been added to the Russian localization examples (examples/i18n/ru/features) to demonstrate calculator functionality in Russian. These include addition (addition.feature), consecutive calculations with background steps (consecutive\_calculations.feature), and division using scenario outlines (division.feature), providing users with localized reference implementations for these specific features.

examples/i18n/ru/features · high confidence

A new support environment file (env.rb) has been added for the Serbian (Cyrillic) i18n example, initializing the load path and requiring the calculator library to enable the feature.

examples/i18n/sr-Cyrl/features/support · high confidence

A new example directory for Serbian (Cyrillic) localization has been added, containing a Cucumber feature file for a calculator's addition functionality, a corresponding Ruby implementation, and a Rakefile to run the tests.

examples/i18n/sr-Cyrl · high confidence

Added a new step definition file for the Serbian Cyrillic (sr-Cyrl) localization of the calculator example, enabling users to run BDD tests using Serbian Cyrillic text for calculator operations.

_examples/i18n/sr-Cyrl/features/step\definitions · high confidence

Introduced a new example directory for the Serbian Latin (sr-Latn) locale, including a Rakefile for running Cucumber tests and a Calculator class implementation. This provides a concrete example of how the i18n library handles this specific locale in a testable application context.

examples/i18n/sr-Latn · high confidence

A new Gherkin feature file has been added for the Serbian Latin locale (sr-Latn) demonstrating an addition scenario. This file defines a 'Sabiranje' (Addition) feature with a structured scenario that takes two input numbers and verifies the correct sum is displayed on the calculator screen, including specific test cases for various number combinations.

examples/i18n/sr-Latn/features · high confidence

A new Slovak (sk) localization example has been added to the examples directory, providing translated feature files for addition and division operations. This includes the necessary project scaffolding (Rakefile, .gitignore) and the underlying Ruby calculator implementation to support the new language scenario.

examples/i18n/sk · high confidence

New example feature files have been added for the Slovak (sk) locale, demonstrating the use of localized keywords for addition and division scenarios. These files illustrate how scenario language can be specified directly within the .feature file using the \# language directive, providing concrete examples of Slovak translations for Gherkin keywords such as 'Požiadavka' (Requirement), 'Scenár' (Scenario), and 'Príklady' (Examples).

examples/i18n/sk/features · high confidence

The Spanish localization example directory now includes a complete set of files to demonstrate internationalization support. This includes a new Rakefile to run the examples, a step-definition library (calculador.rb) implementing a calculator class, and a feature file (adicion.feature) that defines addition scenarios using Spanish keywords. Users can now run these examples to see how Cucumber handles Spanish language features and step definitions.

examples/i18n/es · high confidence

Introduced a new Swedish (sv) localization example under examples/i18n/sv, including a Rakefile for running Cucumber tests, a 'summering' (summation) feature file with scenarios for adding two and three numbers, and a Kalkulator class implementation that manages a stack and performs addition.

examples/i18n/sv · high confidence

New example feature files for Traditional Chinese (zh-TW) have been added to the examples directory, including addition.feature and division.feature. These files demonstrate the use of localized keywords for scenarios and scenario outlines, allowing users to verify that the tool correctly parses and executes BDD tests written in Traditional Chinese.

examples/i18n/zh-TW/features · high confidence

This change introduces a new Turkish (tr) localization example within the examples/i18n directory. It includes Cucumber feature files (toplama.feature for addition and bolme.feature for division) written in Turkish, along with the corresponding Ruby implementation (hesap\_makinesi.rb) and supporting configuration files (Rakefile, .gitignore). This allows users to see how the calculator application's behavior is described and tested using Turkish keywords and terminology.

examples/i18n/tr · high confidence

New support files (env.rb and world.rb) were added to the Ukrainian i18n example suite. The environment setup now loads the calculator library, and a LazyCalc module is introduced to provide a cached calculator instance to the test world, enabling the Ukrainian language examples to execute correctly.

examples/i18n/uk/features/support · high confidence

A new Ukrainian localization example has been added to the project, featuring a Rakefile for running Cucumber tests and a Ruby-based Calculator class that implements stack-based arithmetic operations (addition and division).

examples/i18n/uk · high confidence

New feature files have been added to the Ukrainian (uk) i18n examples directory, providing localized Gherkin scenarios for addition, division, and consecutive calculations. This allows users to view and test the calculator's core arithmetic operations using Ukrainian language labels and instructions.

examples/i18n/uk/features · high confidence

New example feature files have been added to the Uzbek (uz) localization directory, providing translated Gherkin scenarios for addition, division, and consecutive calculations. These files allow users to view and test the calculator's functionality using Uzbek language keywords and descriptions.

examples/i18n/uz/features · high confidence

New support files have been added for the Uzbek (uz) i18n example set, enabling users to run feature tests in that language. The \env.rb\ file configures the load path to include the local library and requires the calculator module, while \world.rb\ defines a \LazyCalc\ helper that provides a calculator instance to the test world.

examples/i18n/uz/features/support · high confidence

A new step definition file for the 'empty' compatibility feature has been introduced to handle CCK scenarios that contain no executable steps. This ensures that scenarios consisting solely of a scenario name (producing a single pickle without step-level pickles) are correctly processed.

compatibility/features/empty · high confidence

The i18n example directory now includes a Rakefile to run Cucumber tests with the pretty formatter, a .gitignore to exclude generated HTML output, and a Calculator class implementation in lib/calculator.rb that supports push, add, and divide operations.

examples/i18n/en · high confidence

New Cucumber step definition files have been added for the calculator example across 16 languages (Catalan, Czech, Danish, German, English, Spanish, Hebrew, Indonesian, Korean, Lithuanian, Latvian, Polish, Slovak, Serbian Latin, Turkish, and Traditional Chinese). These files provide localized Gherkin step implementations (Given/When/Then) that allow users to run the calculator example using their native language.

(repo-wide) · high confidence

New Cucumber step definition files have been added for the Italian (calcolatrice), Romanian (calculator), and Swedish (kalkulator) example applications. These files implement the Gherkin step bindings required to run the internationalized calculator feature scenarios in their respective languages, enabling users to execute the example tests in Italian, Romanian, and Swedish.

_examples/i18n/it/features/step\_definitions, examples/i18n/ro/features/step\_definitions, examples/i18n/sv/features/step\definitions · high confidence

New step definition files have been added for the Ukrainian (uk) and Uzbek (uz) language examples, enabling the execution of calculator-related feature tests in these locales. The Ukrainian steps define actions for entering numbers, pressing operators, and verifying results, while the Uzbek steps similarly define input, operation, and result verification steps, allowing users to run i18n tests for these specific languages.

_examples/i18n/uk/features/step\_definitions, examples/i18n/uz/features/step\definitions · high confidence

The 'en-lol' internationalization example now includes step definitions that map Lolspeak-style Gherkin scenarios (such as 'IN TEH BEGINNIN', 'I EAT', and 'I HAS') to the underlying test logic, enabling users to run and verify this specific language variant.

_examples/i18n/en-lol/features/step\definitions · high confidence

A new support file (env.rb) has been added to the en-lol internationalization example. This file initializes the environment by requiring RSpec expectations (with a fallback for older versions), enabling Cucumber's unicode formatter, and loading the example's specific library components (basket and belly).

examples/i18n/en-lol/features/support · high confidence

The zh-TW example directory now includes a Rakefile for running Cucumber tasks, a .gitignore to exclude generated features.html files, and a lib/calculator.rb file implementing a basic stack-based calculator with push, add, and divide operations.

examples/i18n/zh-TW · high confidence

Cucumber now supports RSpec test doubles by automatically including RSpec::Mocks::ExampleMethods and managing the mock setup/teardown lifecycle via Before/After hooks. Additionally, a new OptionParser class is introduced to neutralize RSpec's command-line argument parsing, preventing conflicts when Cucumber runs.

lib/cucumber/rspec · high confidence

This change introduces the \Cucumber::MultilineArgument::DataTable\ class, which provides a structured way to handle table arguments in step definitions, including methods like \hashes\, \symbolic\_hashes\, and \rows\_hash\ for data access. It also adds the \Cucumber::MultilineArgument::DocString\ class to handle multiline string arguments. These classes form the foundation for parsing and manipulating multiline arguments in Cucumber step definitions.

_lib/cucumber/multiline\argument · high confidence

Added three new classes to the Gherkin module: DataTableParser, StepsParser, and I18n helpers. DataTableParser and StepsParser now handle parsing of data tables and step definitions respectively by wrapping the Gherkin library, while the I18n module provides utilities for mapping Gherkin keywords to code keywords.

lib/cucumber/gherkin · high confidence

The gem\_tasks directory now includes four new Rake tasks to streamline testing and example execution. The \cck\ task runs RSpec against the Cucumber Compatibility Kit, the \cov\ task collects code coverage using SimpleCov, the \examples\ task iterates through example directories to run their respective Cucumber suites, and the \rspec\ task runs the main RSpec suite while excluding CCK tests.

_gem\tasks · high confidence

The event system in lib/cucumber/events now exposes new event classes to allow formatters and integrations to react to previously unobservable moments: AttachCalled fires when a step definition calls attach; HookTestStepCreated signals when a step is generated from a Before/After hook; GherkinSourceRead and GherkinSourceParsed provide access to the raw file content and the parsed AST; and Envelope wraps cucumber-messages envelopes for direct consumption. These additions complement the existing test lifecycle events (TestRunStarted/Finished, TestCaseStarted/Finished/Ready, TestStepStarted/Finished/Started, TestStepCreated, TestCaseCreated, StepActivated, StepDefinitionRegistered, TestRunHookStarted/Finished, UndefinedParameterType) by filling gaps around attachments, hook-driven steps, and source-level Gherkin processing.

lib/cucumber/events · high confidence

The project has removed the \config/hoe.rb\ and \config/requirements.rb\ files, eliminating the dependency on the Hoe gem for build automation and gem specification. This change removes the legacy Rake task generation and RubyForge publishing configuration previously handled by Hoe, simplifying the build setup.

config · high confidence

The project has removed its legacy Rake task suite, eliminating the ability to perform local deployments, generate or upload the website to RubyForge, and run RSpec tests via the old \spec\ gem. Users can no longer use commands like \rake deploy\, \rake website\, or \rake spec\ as these files (\deployment.rake\, \environment.rake\, \rspec.rake\, \website.rake\) have been deleted.

tasks · high confidence

The \script/\ directory has been cleaned up by removing several legacy executable scripts: \console\ and \console.cmd\ (IRB helpers), \generate\/\destroy\ and their \.cmd\ wrappers (RubiGen scaffolding tools), and \txt2html\/\txt2html.cmd\ (a custom text-to-HTML converter that included a \Fixnum\ ordinal extension). These files are no longer present, indicating the removal of these specific development and build-time utilities from the project.

script · high confidence

The website directory's static assets and build infrastructure have been removed. This includes the placeholder \index.html\ and \index.txt\ files, the \template.html.erb\ view used for generating pages, the \screen.css\ stylesheet, and the \rounded\_corners\_lite.inc.js\ library. Users will no longer have access to the generated website content or the underlying files used to build it.

website · high confidence

The Cucumber runtime has been significantly refactored to use a centralized \Configuration\ object for managing settings (such as dry-run, fail-fast, and retry options) and an event bus for internal communication. This change introduces new modules for handling file specifications, step match searching with caching, and a cleaner separation of concerns in the runtime execution flow, while maintaining backward compatibility for existing feature files and step definitions.

lib/cucumber · high confidence

The internal logic for comparing and diffing Cucumber data tables has been moved from the main DataTable class into a new, dedicated \DiffMatrices\ class. This refactoring isolates the complex diffing behavior (including column matching, row insertion/deletion handling, and error raising) into its own file, improving code organization without changing the external behavior of data table comparisons.

_lib/cucumber/multiline\_argument/data\table · high confidence

The formatter subsystem now includes several new helper modules to support the event-based architecture. A new \ANSIColor\ module provides customizable ANSI escape sequences for terminal output, allowing users to override colors via the \CUCUMBER\_COLORS\ environment variable. Supporting infrastructure includes \AstLookup\ for mapping test events to Gherkin source locations, \BacktraceFilter\ for cleaning up exception traces (with specific handling for Ruby 3.4+), and \CurlOptionParser\ for parsing HTTP options. Additionally, \Console\ and \ConsoleCounts\ modules centralize terminal formatting logic and summary statistics, while \ConsoleIssues\ handles the reporting of failing and flaky scenarios.

lib/cucumber/formatter · high confidence

The compatibility support layer now uses a new Cucumber Compatibility Kit (CCK) to validate generated messages against expected outputs. This kit includes a \MessagesComparator\ that checks for structural consistency, specifically ensuring that generated message types match the original set and that the \testRunStartedId\ remains consistent across the test run. The implementation also handles specific message types (like \GherkinDocument\, \Pickle\, \Timestamp\, and \Duration\) by ignoring them during comparison to avoid false positives from size or timestamp differences, and it includes a \KeysChecker\ to detect extra or missing keys in detected messages.

compatibility/support · high confidence

The project now includes dedicated \bin/cucumber\ and \bin/rspec\ scripts to serve as the primary command-line entry points. The Cucumber script initializes the load path, integrates SimpleCov for code coverage, disables RSpec's option parser to prevent conflicts, and instantiates the CLI with a duplicate of \ARGV\ to ensure debugging tools like ruby-debug can correctly respawn processes. The RScript is a standard Bundler-generated binstub that loads the \rspec-core\ executable, facilitating consistent execution of RSpec tests within the project environment.

bin · high confidence

The test suite now uses a new internal support library located in \features/lib/support\ to manage test execution and assertions. This includes a \CommandLine\ helper that captures stdout/stderr and exit codes via RSpec mocks, replacing previous mechanisms for running Cucumber, Ruby, and Rake commands. A \FeatureFactory\ module allows tests to programmatically generate Gherkin features and scenarios, while \output.rb\ provides utilities to clean and compare command output by stripping colors, paths, and variable durations. Additional helpers handle JSON normalization, JUnit time replacement, and custom parameter types.

features/lib/support · high confidence

The Cucumber Rake task has changed its default execution mode: it now forks a new Ruby process by default (previously it ran in-process). This improves stability for users who experienced issues with in-process execution, though you can set \fork = false\ in your Rake task configuration to revert to the previous behavior if needed.

lib/cucumber/rake · high confidence

The library has been renamed from 'Stories' to 'Cucumber', removing the old \lib/stories.rb\ and \lib/stories/version.rb\ files. A new \lib/cucumber.rb\ entry point is introduced, which loads core components such as the runtime, CLI, formatters, and step definitions, and provides a \Cucumber\ module with configuration options for logging and deprecation warnings. Additionally, \lib/simplecov\_setup.rb\ has been added to the lib folder to handle code coverage setup when the \SIMPLECOV\ environment variable is set.

lib · high confidence

The command-line interface logic has been restructured to improve maintainability and separation of concerns. A new \Cucumber::Cli::Configuration\ class now centralizes the parsing of command-line arguments and the management of runtime settings, replacing the previous monolithic approach. Profile loading from \cucumber.yml\ has been extracted into a dedicated \ProfileLoader\ class, which handles ERB processing and YAML parsing. Additionally, a new \RerunFile\ class manages the reading and parsing of rerun files, and the \Main\ entry point has been updated to utilize these new components for a cleaner execution flow.

lib/cucumber/cli · high confidence

The Ruby glue layer has been restructured to support named hooks and structured message envelopes. Users can now assign names to Before, After, Around, and AfterStep hooks via the new \name:\ keyword argument, and two new global lifecycle hooks, \BeforeAll\ and \AfterAll\, are available for setup and teardown tasks that run outside the scenario context. The underlying implementation now wraps hooks and step definitions in dedicated classes that emit structured \Cucumber::Messages::Envelope\ objects, providing unique IDs and source references for better traceability in test reports. Additionally, the \World\ API now supports namespaced modules, allowing users to extend specific world instances with distinct modules based on a namespace key.

lib/cucumber/glue · high confidence

The terminal formatting logic has been reorganized into specific modules: \Cucumber::Term::ANSIColor\ now handles ANSI color codes and text styling, while \Cucumber::Term::Banner\ manages the display of the startup banner with customizable border styles. This change allows users and formatters to include \Cucumber::Term::ANSIColor\ for granular text coloring and utilizes the new \Banner\ module to render the banner with configurable modifiers (such as bold green borders), replacing the previous monolithic implementation.

lib/cucumber/term · high confidence

The test execution engine has been restructured from a monolithic core into a series of distinct, composable filters. This change introduces specific components for managing the test lifecycle: \ActivateSteps\ handles step matching and ambiguity detection, while \ApplyBeforeHooks\, \ApplyAfterHooks\, \ApplyAroundHooks\, and \ApplyAfterStepHooks\ manage hook execution at the appropriate stages. Lifecycle management is now handled by \FireBeforeAllHooks\ and \PrepareWorld\, which ensure proper setup and teardown. The chain also includes \BroadcastTestRunStartedEvent\ and \BroadcastTestCaseReadyEvent\ to emit standardized events, and \GatedReceiver\ to control flow. Additionally, new filters provide features like \Randomizer\ for platform-independent test shuffling, \Reverser\ for execution order control, \Retry\ for handling flaky tests with a circuit breaker, and \TagLimits\ for enforcing execution constraints.

lib/cucumber/filters · high confidence

The runtime now executes Before and After hooks as distinct step types with reversed After-hook ordering, ensuring they are properly tracked in the event bus. The interactive \ask\ method is deprecated for removal in v12, and the legacy \embed\ method is replaced by \attach\ for attaching media. Additionally, the runtime facade for programming languages has been simplified to delegate only essential methods, and meta-data reporting now uses the standard CI environment detection.

lib/cucumber/runtime · high confidence

The Russian localization examples (examples/i18n/ru) now rely on RSpec's expectation library (with a fallback to the legacy spec/expectations) and include a dedicated support world module. This world module introduces a LazyCalc helper that instantiates the Calculator only when first accessed, changing how the example steps interact with the calculator instance.

examples/i18n/ru/features/support · high confidence

Users can now define the language dialect directly within a .feature file using the \# language directive, as demonstrated by the new en-lol (LOLCAT) example. This allows feature files to use non-standard or custom language keywords, enabling localized or themed syntax without relying solely on external configuration.

examples/i18n/en-lol/features · high confidence

New \env.rb\ support files have been added for the French (\examples/i18n/fr\) and Japanese (\examples/i18n/ja\) example directories. These files configure the test environment by requiring \rspec/expectations\ (with a fallback to \spec/expectations\ for older versions), enabling the Cucumber Unicode formatter, and loading the respective application libraries (\calculatrice\ for French and \calculator\ for Japanese).

examples/i18n/fr/features/support, examples/i18n/ja/features/support · high confidence

Added CCK v26 conformance tests; Added Cucumber compatibility step definitions for feature conformance; Added Cucumber compatibility test step definitions; Added Cucumber conformance tests for skipped scenarios; Added Cucumber v22 compatibility test fixtures; Added compatibility test steps for attachment and hook scenarios; Added comprehensive tests for CLI configuration, options, and profile loading; Added comprehensive tests for DataTable functionality; Added test coverage for Cucumber configuration, runtime, and query components; Added test coverage for Cucumber filter components; Added test coverage for runtime hooks, meta message building, and support code; Added test fixtures and support helpers for Cucumber core specs; Added tests for Cucumber Rake task and forked runner; Added tests for TagLimits filter components; Added tests for compatibility kit message comparison and support code resolution; Added tests for glue layer components; Added tests for pending step behavior; Added tests for the Cucumber Term Banner module; Added unit tests for formatter components; New standard step definitions for Cucumber feature tests; Retry feature step definitions for conformance testing; Updated RSpec configuration and removed legacy spec files.

This change introduces the foundational dependency management files for the Cucumber Ruby gem. The \cucumber.gemspec\ defines the runtime dependencies required for execution, including \cucumber-core\ (versions \> 18, \< 20), \cucumber-cucumber-expressions\ (\> 17, \< 21), \cucumber-html-formatter\ (\> 21, \< 25), and \cucumber-query\ (\~\> 16.1), alongside utility gems like \builder\, \diff-lcs\, and \mini\_mime\. It also specifies development dependencies for testing and linting, such as \rspec\, \rubocop\, and \simplecov\. The \Gemfile\ is added to support local development by allowing developers to override these dependencies with local paths to sibling monorepo projects (e.g., \cucumber-ruby-core\, \gherkin/ruby\).

(dependencies) · high confidence

The core parsing and messaging infrastructure has been upgraded to Gherkin v13, Messages v12, and Tag-Expressions v10. This update brings new JSON schema messages and Data Transfer Objects (DTOs) to the system, ensuring compatibility with the latest Gherkin specification and improving the underlying message envelope format used for test execution.

(repo-wide) · high confidence

The debug log file previously located at log/debug.log has been removed and replaced with a .keep file in the compatibility/features/markdown directory. This change cleans up the repository structure by removing temporary debug artifacts from the markdown feature area.

compatibility/features/markdown · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 59 → 73 (+13.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 99 → 95 (-4.4)
• Architecture 92 → 98 (+5.9)
• Maturity 60 → 58 (-2.3)
• Readiness 47 → 91 (+44.6)
• Security 70 → 81 (+11.1)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Main.execute! (cognitive 24) (Main)
• No exposed public API
• No tests found
• Test reliability not included

• Change coupling: pretty.rb ↔ progress.rb (lib/cucumber/formatter/pretty.rb)
• Duplicated block (13 lines × 22) (examples/i18n/ca/lib/calculadora.rb)
• Duplicated block (23 lines × 4) (examples/i18n/bg/lib/calculator.rb)
• Duplicated block (6 lines × 2) (lib/cucumber/runtime/after_hooks.rb)
• Duplicated block (7 lines × 2) (lib/cucumber/formatter/message_builder.rb)
• Further sole-owners (lower concentration)
• Inconsistent access to stream properties. The class definition lists Property: Configuration.out_stream and Property: Configuration.error_stream in the constructor arguments, but also lists Method: Configuration.out_stream() and Method: Configuration.error_stream(). In Ruby, properties are typically accessed via methods. If these are truly properties (attributes), the method signatures should not be listed separately unless they are distinct from the attribute readers. If they are just attribute readers, listing them as both properties and methods is redundant documentation, but if they are distinct methods with logic, the property declaration is misleading.
• Inconsistent naming convention for execution entry points. execute and execute! are overloaded with different signatures (one takes args, one takes an existing runtime). This is confusing for users who might expect execute! to be a 'bang' version of execute with the same signature but different behavior (e.g., raising errors), rather than a completely different operational mode.
• Job token omits the contents scope its checkout needs
• Main.execute! (cognitive 24) (lib/cucumber/cli/main.rb)
• Medium: security finding (details withheld)
• Off-boarding risk: anonymized user #1
• Orphaned files with no living knowledge
• Redundant and inconsistent parsing logic. Cucumber.Cli.Options exposes both parse and parse!, while Cucumber.Cli.Configuration exposes parse!. It is unclear if Configuration.parse! delegates to Options.parse! or performs its own logic. The existence of two distinct configuration/option classes with overlapping parsing responsibilities suggests a split in concern that leads to API duplication.
• Secret: slack-webhook-url (appveyor.yml)
• Significant duplication of accessor methods between Cucumber.Cli.Configuration and Cucumber.Cli.Options. Both classes expose methods to retrieve filters, formats, paths, to_hash, etc. This implies that Options (likely the parsed argument structure) and Configuration (likely the runtime config) are exposing the same data sources, leading to confusion about which object to query for CLI settings.
• TodoComment (compatibility/support/cucumber/compatibility_kit/keys_checker.rb)
• TodoComment (compatibility/support/cucumber/compatibility_kit/messages_comparator.rb)
• TodoComment (lib/cucumber/configuration.rb)
• TodoComment (lib/cucumber/errors.rb)
• …and 22 more

• 22 commits — 22 feature/other, 0 fixes

• .github/workflows — 14 commits
• (root) — 4 commits
• lib/cucumber — 4 commits

• change: Allow diff-lcs 2.0 (#1909)
• change: Extract query to cucumber query (#1889)
• change: Refactor/bump core (#1904)
• change: Refactor/remove fake queries (#1903)
• change: Update CHANGELOG.md
• change: Update CHANGELOG.md
• change: Update MessageBuilder when runner generate messages (#1882)
• change: Update github/codeql-action action to v4.37.7
• change: Update github/codeql-action action to v4.37.8
• change: Update github/codeql-action action to v4.37.9
• change: Update github/codeql-action action to v4.38.0
• change: Update github/codeql-action action to v4.38.1
• change: Update github/codeql-action action to v4.38.2
• change: Update repository in MessageBuilder on envelopes first (#1906)
• change: Update ruby/setup-ruby action to v1.322.0
• change: Update ruby/setup-ruby action to v1.323.0
• change: Update ruby/setup-ruby action to v1.324.0
• change: Update ruby/setup-ruby action to v1.325.0
• change: Update ruby/setup-ruby action to v1.326.0
• change: Update ruby/setup-ruby action to v1.327.0
• …and 2 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

cucumber/cucumber-ruby was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.