feat!: follow the Gherkin standard by not differentiating between step types (#199)

Previously a each type of step definition (`Given`, `When` and `Then`) was given its own category. That means the following steps were considered different:
```cpp
GIVEN("I am different"){}
When("I am different"){}
Then("I am different"){}
```
With this change the above are now considered duplicate steps and they'll result in an ambiguous error. This is considered a breaking change.

Author: daantimmer

cucumber_cpp/acceptance_test/features/test_scenarios.feature

@@ -18,7 +18,5 @@ Feature: Simple feature file
 
   @result:UNDEFINED
   Scenario: A scenario with undefined step
-    Given a given step
-    When a when step
-    Then a when step
-    Then a then step
+    Given a missing step
+    Then this should be skipped

cucumber_cpp/acceptance_test/steps/Steps.cpp

@@ -50,3 +50,8 @@ GIVEN("a ← tuple\\({float}, {float}, {float}, {float}\\)", (float /* unused */
 {
     // empty
 }
+
+THEN("this should be skipped")
+{
+    FAIL();
+}

cucumber_cpp/acceptance_test/test.bats

@@ -30,7 +30,7 @@ teardown() {
     run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test run --tag "@result:UNDEFINED" --feature cucumber_cpp/acceptance_test/features --report console
     assert_failure
     assert_output --partial "undefined \"cucumber_cpp/acceptance_test/features/test_scenarios.feature\""
-    assert_output --partial "skipped Then a then step"
+    assert_output --partial "skipped Then this should be skipped"
 }
 
 @test "No tests" {
@@ -127,7 +127,7 @@ teardown() {
     run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test run --feature cucumber_cpp/acceptance_test/features --tag "@result:UNDEFINED" --report console --dry
     assert_failure
     assert_output --partial "undefined \"cucumber_cpp/acceptance_test/features/test_scenarios.feature\""
-    assert_output --partial "skipped Then a then step"
+    assert_output --partial "skipped Then this should be skipped"
 }
 
 @test "Test the and keyword" {

cucumber_cpp/library/StepRegistry.cpp

@@ -7,10 +7,8 @@
 #include "cucumber_cpp/library/cucumber_expression/RegularExpression.hpp"
 #include "cucumber_cpp/library/engine/StepType.hpp"
 #include "cucumber_cpp/library/engine/Table.hpp"
-#include <algorithm>
 #include <cstddef>
 #include <memory>
-#include <ranges>
 #include <span>
 #include <string>
 #include <utility>
@@ -19,29 +17,18 @@
 
 namespace cucumber_cpp::library
 {
-    namespace
-    {
-        auto TypeFilter(engine::StepType stepType)
-        {
-            return [stepType](const StepRegistry::Entry& entry)
-            {
-                return entry.type == stepType || entry.type == engine::StepType::any;
-            };
-        };
-    }
-
     StepRegistry::StepRegistry(cucumber_expression::ParameterRegistry& parameterRegistry)
         : parameterRegistry{ parameterRegistry }
     {
         for (const auto& matcher : StepStringRegistration::Instance().GetEntries())
             Register(matcher.regex, matcher.type, matcher.factory);
     }
 
-    StepMatch StepRegistry::Query(engine::StepType stepType, const std::string& expression)
+    StepMatch StepRegistry::Query(const std::string& expression)
     {
         std::vector<StepMatch> matches;
 
-        for (Entry& entry : registry | std::views::filter(TypeFilter(stepType)))
+        for (Entry& entry : registry)
         {
             auto match = std::visit(cucumber_expression::MatchVisitor{ expression }, entry.regex);
             if (match)
@@ -65,11 +52,6 @@ namespace cucumber_cpp::library
         return registry.size();
     }
 
-    std::size_t StepRegistry::Size(engine::StepType stepType) const
-    {
-        return std::ranges::count(registry, stepType, &Entry::type);
-    }
-
     std::vector<StepRegistry::EntryView> StepRegistry::List() const
     {
         std::vector<StepRegistry::EntryView> list;

cucumber_cpp/library/StepRegistry.hpp

@@ -84,10 +84,9 @@ namespace cucumber_cpp::library
 
         explicit StepRegistry(cucumber_expression::ParameterRegistry& parameterRegistry);
 
-        [[nodiscard]] StepMatch Query(engine::StepType stepType, const std::string& expression);
+        [[nodiscard]] StepMatch Query(const std::string& expression);
 
         [[nodiscard]] std::size_t Size() const;
-        [[nodiscard]] std::size_t Size(engine::StepType stepType) const;
 
         [[nodiscard]] std::vector<EntryView> List() const;
 

cucumber_cpp/library/engine/FeatureFactory.cpp

@@ -158,7 +158,6 @@ namespace cucumber_cpp::library::engine
             }
             catch (const std::out_of_range&)
             {
-
                 throw UnsupportedAsteriskError{ std::format("{}:{}: * steps are not supported", scenarioInfo.FeatureInfo().Path().string(), step.location.line) };
             }
         }
@@ -292,7 +291,7 @@ namespace cucumber_cpp::library::engine
     {
         try
         {
-            auto stepMatch = stepRegistry.Query(stepType, stepText);
+            auto stepMatch = stepRegistry.Query(stepText);
             return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(stepMatch));
         }
         catch (const StepRegistry::StepNotFoundError&)

cucumber_cpp/library/test/TestSteps.cpp

@@ -1,7 +1,6 @@
 #include "cucumber_cpp/library/Context.hpp"
 #include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
-#include "cucumber_cpp/library/engine/StepType.hpp"
 #include "gtest/gtest.h"
 #include <cstdint>
 #include <gmock/gmock.h>
@@ -22,43 +21,19 @@ namespace cucumber_cpp::library
     TEST_F(TestSteps, RegisterThroughPreregistration)
     {
         EXPECT_THAT(stepRegistry.Size(), testing::Ge(1));
-        EXPECT_THAT(stepRegistry.Size(engine::StepType::given), testing::Ge(1));
-        EXPECT_THAT(stepRegistry.Size(engine::StepType::when), testing::Ge(1));
-        EXPECT_THAT(stepRegistry.Size(engine::StepType::then), testing::Ge(1));
-        EXPECT_THAT(stepRegistry.Size(engine::StepType::any), testing::Ge(1));
     }
 
     TEST_F(TestSteps, GetGivenStep)
     {
-        const auto matches = stepRegistry.Query(engine::StepType::given, "This is a GIVEN step");
-
-        EXPECT_THAT(matches.stepRegexStr, testing::StrEq("^This is a GIVEN step$"));
-    }
-
-    TEST_F(TestSteps, GetWhenStep)
-    {
-        const auto matches = stepRegistry.Query(engine::StepType::when, "This is a WHEN step");
-
-        EXPECT_THAT(matches.stepRegexStr, testing::StrEq("^This is a WHEN step$"));
-    }
-
-    TEST_F(TestSteps, GetThenStep)
-    {
-        const auto matches = stepRegistry.Query(engine::StepType::then, "This is a THEN step");
-
-        EXPECT_THAT(matches.stepRegexStr, testing::StrEq("^This is a THEN step$"));
-    }
-
-    TEST_F(TestSteps, GetAnyStep)
-    {
-        const auto matches = stepRegistry.Query(engine::StepType::given, "This is a STEP step");
-
-        EXPECT_THAT(matches.stepRegexStr, testing::StrEq("^This is a STEP step$"));
+        EXPECT_THAT(stepRegistry.Query("This is a GIVEN step").stepRegexStr, testing::StrEq("^This is a GIVEN step$"));
+        EXPECT_THAT(stepRegistry.Query("This is a WHEN step").stepRegexStr, testing::StrEq("^This is a WHEN step$"));
+        EXPECT_THAT(stepRegistry.Query("This is a THEN step").stepRegexStr, testing::StrEq("^This is a THEN step$"));
+        EXPECT_THAT(stepRegistry.Query("This is a STEP step").stepRegexStr, testing::StrEq("^This is a STEP step$"));
     }
 
     TEST_F(TestSteps, GetStepWithMatches)
     {
-        const auto matches = stepRegistry.Query(engine::StepType::when, "This is a step with a 10s delay");
+        const auto matches = stepRegistry.Query("This is a step with a 10s delay");
 
         EXPECT_THAT(matches.stepRegexStr, testing::StrEq("^This is a step with a ([0-9]+)s delay$"));
 
@@ -68,20 +43,17 @@ namespace cucumber_cpp::library
 
     TEST_F(TestSteps, GetInvalidStep)
     {
-        EXPECT_THROW((void)stepRegistry.Query(engine::StepType::when, "This step does not exist"), StepRegistry::StepNotFoundError);
+        EXPECT_THROW((void)stepRegistry.Query("This step does not exist"), StepRegistry::StepNotFoundError);
     }
 
     TEST_F(TestSteps, GetAmbiguousStep)
     {
-        EXPECT_NO_THROW((void)stepRegistry.Query(engine::StepType::given, "an ambiguous step"));
-        EXPECT_NO_THROW((void)stepRegistry.Query(engine::StepType::when, "an ambiguous step"));
-
-        EXPECT_THROW((void)stepRegistry.Query(engine::StepType::then, "an ambiguous step"), StepRegistry::AmbiguousStepError);
+        EXPECT_THROW((void)stepRegistry.Query("an ambiguous step"), StepRegistry::AmbiguousStepError);
     }
 
     TEST_F(TestSteps, InvokeTestWithCucumberExpressions)
     {
-        const auto matches = stepRegistry.Query(engine::StepType::when, R"(Step with cucumber expression syntax 1.5 "abcdef" 10)");
+        const auto matches = stepRegistry.Query(R"(Step with cucumber expression syntax 1.5 "abcdef" 10)");
 
         auto contextStorage{ std::make_shared<ContextStorageFactoryImpl>() };
         Context context{ contextStorage };
@@ -99,16 +71,16 @@ namespace cucumber_cpp::library
 
     TEST_F(TestSteps, EscapedCucumberExpression)
     {
-        const auto matchesParens = stepRegistry.Query(engine::StepType::then, R"(An expression with (parenthesis) should remain as is)");
+        const auto matchesParens = stepRegistry.Query(R"(An expression with (parenthesis) should remain as is)");
         EXPECT_THAT(matchesParens.stepRegexStr, testing::StrEq(R"(^An expression with \(parenthesis\) should remain as is$)"));
 
-        const auto matchesBrace = stepRegistry.Query(engine::StepType::then, R"(An expression with {braces} should remain as is)");
+        const auto matchesBrace = stepRegistry.Query(R"(An expression with {braces} should remain as is)");
         EXPECT_THAT(matchesBrace.stepRegexStr, testing::StrEq(R"(^An expression with \{braces\} should remain as is$)"));
     }
 
     TEST_F(TestSteps, FunctionLikeStep)
     {
-        const auto matches = stepRegistry.Query(engine::StepType::then, R"(An expression that looks like a function func(1, 2) should keep its parameters)");
+        const auto matches = stepRegistry.Query(R"(An expression that looks like a function func(1, 2) should keep its parameters)");
 
         auto contextStorage{ std::make_shared<ContextStorageFactoryImpl>() };
         Context context{ contextStorage };
@@ -118,7 +90,7 @@ namespace cucumber_cpp::library
 
     TEST_F(TestSteps, EscapedParenthesis)
     {
-        const auto matches1 = stepRegistry.Query(engine::StepType::then, R"(An expression with \(escaped parenthesis\) should keep the slash)");
-        const auto matches2 = stepRegistry.Query(engine::StepType::then, R"(An expression with \{escaped braces\} should keep the slash)");
+        const auto matches1 = stepRegistry.Query(R"(An expression with \(escaped parenthesis\) should keep the slash)");
+        const auto matches2 = stepRegistry.Query(R"(An expression with \{escaped braces\} should keep the slash)");
     }
 }