feat!: full support for cucumber expressions (#180)

* feat: full support for cucumber expressions
Fixes #178

* revert C++ standard to 20 and improve error handling in expression evaluation

* fix: remove unused print include from TestExpression.cpp

* try fix mac build

* fixing mac builds

* add unicode test

* refactor: remove unused regex includes and commented-out code

* feat: add error handling for optional and alternative expressions

* fix: add empty block comment for tuple step definition

* fix: mark NoEligibleParsers constructor as explicit

* feat: add InvalidTokenType exception for better error handling

* fix: correct move semantics for stepRegexStr in StepMatch constructor

* feat: add InvalidNodeType exception and refactor regex handling in Expression class

* refactor: improve parameter passing in ExpressionParser and SubParser methods

* refactor: change character type from char to unsigned char in Token methods for consistency

* fix: include ParameterRegistry header and update converter initialization in Expression class

* refactor: rename InHelper to MatchTokenHelper for clarity and consistency

* refactor: update Node and Token classes for improved encapsulation and consistency

* refactor: simplify Result construction in ExpressionParser methods for clarity

* fix: remove redundant check for line start and end tokens in ParseTokensUntil method

* refactor: enhance Converter constructor for improved clarity and functionality

* refactor: update parser state references for consistency and clarity

* refactor: remove default constructor from ExpressionTokenizer

* fix: update PatternVisitor usage in StepRegistry and remove unused visitor instances in Matcher

* fix: replace 'and' with '&&' for logical operation in ExpressionTokenizer

* refactor: simplify empty expression handling in ExpressionTokenizer

* refactor: update ParseTokensUntil and ParseToken signatures for consistency

* refactor: update Converter constructor signature for consistency

* fix: update ccache key and add crt-version to get-winsdk.sh for consistency

* refactor: update HookExecutor and TestExecution to use optional scopes for feature and scenario starts

* test: test cucumber expressions against official test input files

* fix: update YAML file loading to use string path for consistency

* refactor: update GetTestData function to use std::filesystem::path for improved path handling

* fix: add missing custom command to copy testdata directory for cucumber expression tests

* refactor: remove debug output from parameter registry match function

* fix: add const qualifier to ParseBetweenGenerator method for consistency

* fix: rename variables for clarity and consistency in ExpressionTokenizer

* fix: correct text parameter passing in MatchVisitor to avoid unnecessary move

* fix: remove unnecessary semicolon and improve error message in StringTo function

* fix: remove ContextManager parameter from FeatureStart and ScenarioStart methods for cleaner interface

* fix: correct ignore list in .ls-lint.yml for accurate linting configuration

* fix: add megalinter-reports to ignore list for improved linting configuration

* fix: add excluded directories to .mega-linter.yml for improved linting configuration

* test: add boolean matching tests to TestExpression for improved coverage

* fix: remove debug output from TestExpressionParser for cleaner test output

* test: add Token::NameOf tests for comprehensive coverage in TestExpressionTokenizer

* fix: update .mega-linter.yml to disable REPOSITORY_CHECKOV linter

* fix: add testdata directory to excluded directories in .mega-linter.yml

* fix: update BODY macro to use static_cast for function pointer type in Execute method

* refactor: integrate StepRegistry and FeatureTreeFactory into Application and TestRunner implementations

* refactor: replace std::int64_t with std::int32_t in ParameterRegistry and related steps

* fix: remove commented out add_subdirectory for test_helper in CMakeLists.txt

* fix: improve error message formatting and add test for unknown parameter type

* refactor: improve formatting of error struct definitions for better readability

* fix: optimize match iteration logic in Expression class

* refactor: rename methods for clarity and consistency in Expression class

* chore: only execute hooks when there was no failure previously

* feat: add CurrentContext method to ScopedFeatureContext and ExecutionStatus methods to ProgramScope and FeatureScope

* chore: remove unneccsary complexity

* chore: remove unused includes and commented code in HookExecutor

* refactor: add HasSetUpTearDown concept

* refactor: change FeatureTreeFactory and Application methods to use const references

* feat: enhance error handling in Application and add overloaded GetExitCode method

* refactor: use const references for MatchRange in converter functions

* feat: improve error handling in Application and FeatureFactory with specific exceptions

* refactor: remove unused executeHooks member from ScopedHook

* fix: correct path conversion in UnsupportedAsteriskError exception

* fix: simplify exception handling in CreateStepInfo method

* refactor: consolidate error handling by replacing InternalError with Errors.hpp

* refactor: remove unused functions

Author: daantimmer

.devcontainer/Dockerfile

@@ -1,3 +1,3 @@
-FROM ghcr.io/philips-software/amp-devcontainer-cpp:5.6.2@sha256:a0804f7454d52564f07317f7e09a012261b6d9553dbe8854fcf265dce571cf86
+FROM ghcr.io/philips-software/amp-devcontainer-cpp:6.0.1@sha256:0b238dbdd0e39a9704fc5317269f654b8bfd23868bad9491e806ae417d645352
 
 HEALTHCHECK NONE

.github/workflows/ci.yml

@@ -31,7 +31,7 @@ jobs:
         id: cache-winsdk
         with:
           path: /winsdk
-          key: cache-winsdk
+          key: cache-winsdk-10.0.26100-14.43.17.13
       - if: ${{ steps.cache-winsdk.outputs.cache-hit != 'true' }}
         run: ./get-winsdk.sh
       - uses: hendrikmuhs/ccache-action@a1209f81afb8c005c13b4296c32e363431bffea5 # v1.2.17

.ls-lint.yml

@@ -4,9 +4,11 @@ ls:
   .cpp: PascalCase
 
 ignore:
+  - .build
   - .devcontainer
   - .git
   - .github
   - .vscode
-  - extern
+  - external
   - megalinter-reports
+  - testdata

.mega-linter.yml

@@ -10,12 +10,13 @@ ENABLE:
   - YAML
 DISABLE_LINTERS:
   - CPP_CPPLINT
+  - JSON_V8R
+  - REPOSITORY_CHECKOV
   - REPOSITORY_DEVSKIM
   - REPOSITORY_GITLEAKS
   - REPOSITORY_KICS
   - REPOSITORY_SEMGREP
   - SPELL_CSPELL
-  - JSON_V8R
 DISABLE_ERRORS_LINTERS:
   - MARKDOWN_MARKDOWN_LINK_CHECK
   - SPELL_PROSELINT
@@ -27,3 +28,4 @@ PRINT_ALPACA: false
 SHOW_SKIPPED_LINTERS: false
 REPOSITORY_GOODCHECK_RULES_PATH: .github/linters
 JSON_JSONLINT_ARGUMENTS: --mode cjson
+EXCLUDED_DIRECTORIES: [testdata]

CMakeLists.txt

@@ -33,7 +33,7 @@ if (CCR_BUILD_TESTS)
     ccr_enable_testing()
 endif()
 
-set(CMAKE_CXX_STANDARD 23)
+set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED On)
 set(CMAKE_CXX_EXTENSIONS Off)
 

cucumber_cpp/acceptance_test/features/test_unicode.feature

@@ -0,0 +1,5 @@
+@unicode
+Feature: Test for unicode characters
+    @result:undefined
+    Scenario: Can match unicode characters
+        Given a ← tuple(4.3, -4.2, 3.1, 1.0)

cucumber_cpp/acceptance_test/steps/Steps.cpp

@@ -1,6 +1,7 @@
 #include "cucumber_cpp/library/Steps.hpp"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
+#include <cstdint>
 #include <iostream>
 #include <string>
 
@@ -45,7 +46,7 @@ THEN("two expectations are raised")
     EXPECT_THAT(1, testing::Eq(0));
 }
 
-WHEN("I print {string} with value {int}", (const std::string& str, std::int32_t value))
+GIVEN("a ← tuple\\({float}, {float}, {float}, {float}\\)", (float /* unused */, float /* unused */, float /* unused */, float /* unused */))
 {
-    std::cout << "print: " << str << " with value " << value;
+    // empty
 }

cucumber_cpp/acceptance_test/test.bats

@@ -181,7 +181,13 @@ teardown() {
 @test "Test error program hook results in error and skipped steps" {
     run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test.custom run --feature cucumber_cpp/acceptance_test/features  --tag "@smoke and @result:OK" --report console --required --failprogramhook
     assert_failure
-    assert_output --partial "skipped Given a given step"
+    refute_output --partial "skipped Given a given step"
     refute_output --partial "should not be executed"
-    # assert_output --partial "tests   : 0/1 passed"
+    assert_output --partial "tests   : 0/0 passed"
+}
+
+@test "Test unicode" {
+    run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test run --feature cucumber_cpp/acceptance_test/features  --tag "@unicode" --report console
+    assert_success
+    assert_output --partial "tests   : 1/1 passed"
 }

cucumber_cpp/library/Application.cpp

@@ -1,5 +1,8 @@
 #include "cucumber_cpp/library/Application.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/Errors.hpp"
+#include "cucumber_cpp/library/StepRegistry.hpp"
+#include "cucumber_cpp/library/cucumber_expression/Errors.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
 #include "cucumber_cpp/library/engine/FeatureInfo.hpp"
@@ -16,6 +19,7 @@
 #include <CLI/impl/App_inl.hpp>
 #include <CLI/impl/Option_inl.hpp>
 #include <algorithm>
+#include <exception>
 #include <filesystem>
 #include <functional>
 #include <iostream>
@@ -27,23 +31,14 @@
 #include <ranges>
 #include <string>
 #include <string_view>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace cucumber_cpp::library
 {
     namespace
     {
-        std::string_view const_char_to_sv(const char* value)
-        {
-            return { value };
-        }
-
-        std::string_view subrange_to_sv(const auto& subrange)
-        {
-            return { std::data(subrange), std::data(subrange) + std::size(subrange) };
-        }
-
         template<class Range>
         std::string Join(const Range& range, std::string_view delim)
         {
@@ -52,26 +47,16 @@ namespace cucumber_cpp::library
 
             return std::accumulate(std::next(range.begin()), range.end(), range.front(), [&delim](const auto& lhs, const auto& rhs)
                 {
-                    std::string join;
-                    join.reserve(lhs.size() + delim.size() + rhs.size());
-                    join.append(lhs);
-                    join.append(delim);
-                    join.append(rhs);
-                    return join;
+                    return std::format("{}{}{}", lhs, delim, rhs);
                 });
         }
 
-        std::string JoinStringWithSpace(const std::string& a, const std::string& b)
-        {
-            return a + ' ' + b;
-        }
-
-        std::filesystem::path to_fs_path(const std::string_view& sv)
+        std::filesystem::path ToFileSystemPath(const std::string_view& sv)
         {
             return { sv };
         }
 
-        bool is_feature_file(const std::filesystem::directory_entry& entry)
+        bool IsFeatureFile(const std::filesystem::directory_entry& entry)
         {
             return std::filesystem::is_regular_file(entry) && entry.path().has_extension() && entry.path().extension() == ".feature";
         }
@@ -80,9 +65,9 @@ namespace cucumber_cpp::library
         {
             std::vector<std::filesystem::path> files;
 
-            for (const auto feature : options.features | std::views::transform(to_fs_path))
+            for (const auto feature : options.features | std::views::transform(ToFileSystemPath))
                 if (std::filesystem::is_directory(feature))
-                    for (const auto& entry : std::filesystem::directory_iterator{ feature } | std::views::filter(is_feature_file))
+                    for (const auto& entry : std::filesystem::directory_iterator{ feature } | std::views::filter(IsFeatureFile))
                         files.emplace_back(entry.path());
                 else
                     files.emplace_back(feature);
@@ -102,26 +87,7 @@ namespace cucumber_cpp::library
                   else
                       return std::string{};
               })
-    {
-    }
-
-    ResultStatus& ResultStatus::operator=(Result result)
-    {
-        if ((resultStatus == Result::undefined || resultStatus == Result::passed) && result != Result::undefined)
-            resultStatus = result;
-
-        return *this;
-    }
-
-    ResultStatus::operator Result() const
-    {
-        return resultStatus;
-    }
-
-    bool ResultStatus::IsSuccess() const
-    {
-        return resultStatus == Result::passed;
-    }
+    {}
 
     Application::Application(std::shared_ptr<ContextStorageFactory> contextStorageFactory)
         : contextManager{ std::move(contextStorageFactory) }
@@ -168,6 +134,35 @@ namespace cucumber_cpp::library
         {
             return cli.exit(e);
         }
+        catch (const InternalError& error)
+        {
+            std::cout << "Internal error:\n\n";
+            std::cout << error.what() << std::endl;
+            return GetExitCode(engine::Result::failed);
+        }
+        catch (const UnsupportedAsteriskError& error)
+        {
+            std::cout << "UnsupportedAsteriskError error:\n\n";
+            std::cout << error.what() << std::endl;
+            return GetExitCode(engine::Result::failed);
+        }
+        catch (const cucumber_expression::Error& error)
+        {
+            std::cout << "Cucumber Expression error:\n\n";
+            std::cout << error.what() << std::endl;
+            return GetExitCode(engine::Result::failed);
+        }
+        catch (const std::exception& error)
+        {
+            std::cout << "Generic error:\n\n";
+            std::cout << error.what() << std::endl;
+            return GetExitCode(engine::Result::failed);
+        }
+        catch (...)
+        {
+            std::cout << "Unknown error";
+            return GetExitCode(engine::Result::failed);
+        }
 
         return GetExitCode();
     }
@@ -194,24 +189,25 @@ namespace cucumber_cpp::library
 
         auto tagExpression = Join(options.tags, " ");
         engine::HookExecutorImpl hookExecution{ contextManager };
-        engine::TestExecutionImpl testExecution{ contextManager, reporters, hookExecution, [this]() -> const engine::TestExecution::Policy&
-            {
-                if (options.dryrun)
-                    return engine::dryRunPolicy;
-                else
-                    return engine::executeRunPolicy;
-            }() };
 
-        engine::TestRunnerImpl testRunner{ testExecution };
+        const auto& runPolicy = (options.dryrun) ? static_cast<const engine::TestExecution::Policy&>(engine::dryRunPolicy)
+                                                 : static_cast<const engine::TestExecution::Policy&>(engine::executeRunPolicy);
+        engine::TestExecutionImpl testExecution{ contextManager, reporters, hookExecution, runPolicy };
+
+        StepRegistry stepRegistry{ parameterRegistry };
+        engine::FeatureTreeFactory featureTreeFactory{ stepRegistry };
 
-        testRunner.Run(GetFeatureTree(tagExpression));
+        engine::TestRunnerImpl testRunner{ featureTreeFactory, testExecution };
+
+        testRunner.Run(GetFeatureTree(featureTreeFactory, tagExpression));
 
         std::cout << '\n'
                   << std::flush;
     }
 
-    std::vector<std::unique_ptr<engine::FeatureInfo>> Application::GetFeatureTree(std::string_view tagExpression)
+    std::vector<std::unique_ptr<engine::FeatureInfo>> Application::GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression)
     {
+
         const auto featureFiles = GetFeatureFiles(options);
         std::vector<std::unique_ptr<engine::FeatureInfo>> vec;
         vec.reserve(featureFiles.size());
@@ -224,10 +220,11 @@ namespace cucumber_cpp::library
 
     int Application::GetExitCode() const
     {
-        if (contextManager.ProgramContext().EffectiveExecutionStatus() == engine::Result::passed)
-            return 0;
-        else
-            return 1;
+        return GetExitCode(contextManager.ProgramContext().ExecutionStatus());
     }
 
+    int Application::GetExitCode(engine::Result result) const
+    {
+        return static_cast<std::underlying_type_t<engine::Result>>(result) - static_cast<std::underlying_type_t<engine::Result>>(engine::Result::passed);
+    }
 }

cucumber_cpp/library/Application.hpp

@@ -3,6 +3,7 @@
 
 #include "cucumber/gherkin/app.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
 #include "cucumber_cpp/library/engine/FeatureInfo.hpp"
@@ -24,19 +25,6 @@ namespace cucumber_cpp::library
         explicit ReportHandlerValidator(const report::Reporters& reporters);
     };
 
-    struct ResultStatus
-    {
-        using Result = engine::Result;
-
-        ResultStatus& operator=(Result result);
-        explicit operator Result() const;
-
-        [[nodiscard]] bool IsSuccess() const;
-
-    private:
-        Result resultStatus{ Result::undefined };
-    };
-
     struct Application
     {
         struct Options
@@ -62,9 +50,10 @@ namespace cucumber_cpp::library
 
     private:
         [[nodiscard]] int GetExitCode() const;
+        [[nodiscard]] int GetExitCode(engine::Result result) const;
         void DryRunFeatures();
         void RunFeatures();
-        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(std::string_view tagExpression);
+        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression);
         [[nodiscard]] engine::Result RunFeature(const std::filesystem::path& path, std::string_view tagExpression, report::ReportHandlerV2& reportHandler);
 
         Options options;
@@ -78,7 +67,7 @@ namespace cucumber_cpp::library
 
         cucumber::gherkin::app gherkin;
 
-        engine::FeatureTreeFactory featureTreeFactory{};
+        cucumber_expression::ParameterRegistry parameterRegistry;
     };
 }