feat: expose parameter registration interface

Author: daantimmer

cucumber_cpp/library/Application.cpp

@@ -3,6 +3,7 @@
 #include "cucumber_cpp/library/Errors.hpp"
 #include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/cucumber_expression/Errors.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"
@@ -177,6 +178,11 @@ namespace cucumber_cpp::library
         return contextManager.ProgramContext();
     }
 
+    cucumber_expression::ParameterRegistration& Application::ParameterRegistration()
+    {
+        return parameterRegistry;
+    }
+
     void Application::AddReportHandler(const std::string& name, std::unique_ptr<report::ReportHandlerV2>&& reporter)
     {
         reporters.Add(name, std::move(reporter));

cucumber_cpp/library/Application.hpp

@@ -45,6 +45,7 @@ namespace cucumber_cpp::library
 
         CLI::App& CliParser();
         Context& ProgramContext();
+        cucumber_expression::ParameterRegistration& ParameterRegistration();
 
         void AddReportHandler(const std::string& name, std::unique_ptr<report::ReportHandlerV2>&& reporter);
 

cucumber_cpp/library/cucumber_expression/ParameterRegistry.cpp

@@ -69,20 +69,20 @@ namespace cucumber_cpp::library::cucumber_expression
         const static std::string stringSingleRegex{ R"__('([^'\\]*(\\.[^'\\]*)*)')__" };
         const static std::string wordRegex{ R"__([^\s]+)__" };
 
-        AddParameter("int", { integerNegativeRegex, integerPositiveRegex }, CreateStreamConverter<std::int32_t>());
-        AddParameter("float", { floatRegex }, CreateStreamConverter<float>());
-        AddParameter("word", { wordRegex }, CreateStreamConverter<std::string>());
-        AddParameter("string", { stringDoubleRegex, stringSingleRegex }, CreateStringConverter());
-        AddParameter("", { ".*" }, CreateStreamConverter<std::string>());
-        AddParameter("bigdecimal", { floatRegex }, CreateStreamConverter<double>());
-        AddParameter("biginteger", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int64_t>());
-        AddParameter("byte", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int32_t>());
-        AddParameter("short", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int32_t>());
-        AddParameter("long", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int64_t>());
-        AddParameter("double", { floatRegex }, CreateStreamConverter<double>());
+        Add("int", { integerNegativeRegex, integerPositiveRegex }, CreateStreamConverter<std::int32_t>());
+        Add("float", { floatRegex }, CreateStreamConverter<float>());
+        Add("word", { wordRegex }, CreateStreamConverter<std::string>());
+        Add("string", { stringDoubleRegex, stringSingleRegex }, CreateStringConverter());
+        Add("", { ".*" }, CreateStreamConverter<std::string>());
+        Add("bigdecimal", { floatRegex }, CreateStreamConverter<double>());
+        Add("biginteger", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int64_t>());
+        Add("byte", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int32_t>());
+        Add("short", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int32_t>());
+        Add("long", { { integerNegativeRegex, integerPositiveRegex } }, CreateStreamConverter<std::int64_t>());
+        Add("double", { floatRegex }, CreateStreamConverter<double>());
 
         // extension
-        AddParameter("bool", { wordRegex }, CreateStreamConverter<bool>());
+        Add("bool", { wordRegex }, CreateStreamConverter<bool>());
     }
 
     Parameter ParameterRegistry::Lookup(const std::string& name) const
@@ -92,7 +92,7 @@ namespace cucumber_cpp::library::cucumber_expression
         return {};
     }
 
-    void ParameterRegistry::AddParameter(std::string name, std::vector<std::string> regex, std::function<std::any(MatchRange)> converter)
+    void ParameterRegistry::Add(std::string name, std::vector<std::string> regex, std::function<std::any(MatchRange)> converter)
     {
         if (parameters.contains(name))
         {

cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp

@@ -120,12 +120,17 @@ namespace cucumber_cpp::library::cucumber_expression
         std::function<std::any(MatchRange)> converter;
     };
 
-    struct ParameterRegistry
+    struct ParameterRegistration
+    {
+        virtual void Add(std::string name, std::vector<std::string> regex, std::function<std::any(MatchRange)> converter) = 0;
+    };
+
+    struct ParameterRegistry : ParameterRegistration
     {
         ParameterRegistry();
 
         Parameter Lookup(const std::string& name) const;
-        void AddParameter(std::string name, std::vector<std::string> regex, std::function<std::any(MatchRange)> converter);
+        void Add(std::string name, std::vector<std::string> regex, std::function<std::any(MatchRange)> converter) override;
 
     private:
         std::map<std::string, Parameter, std::less<>> parameters{};

cucumber_cpp/library/cucumber_expression/test/TestExpression.cpp

@@ -155,7 +155,7 @@ namespace cucumber_cpp::library::cucumber_expression
             std::optional<std::int64_t> number;
         };
 
-        parameterRegistry.AddParameter("textAndOrNumber", { R"(([A-Z]+)?(?: )?([0-9]+)?)" }, [](MatchRange matches) -> std::any
+        parameterRegistry.Add("textAndOrNumber", { R"(([A-Z]+)?(?: )?([0-9]+)?)" }, [](MatchRange matches) -> std::any
             {
                 std::optional<std::string> text{ matches[1].matched ? StringTo<std::string>(matches[1].str()) : std::optional<std::string>{ std::nullopt } };
                 std::optional<std::int64_t> number{ matches[2].matched ? StringTo<std::int64_t>(matches[2].str()) : std::optional<std::int64_t>{ std::nullopt } };
@@ -221,4 +221,36 @@ namespace cucumber_cpp::library::cucumber_expression
                                                  "Please register a ParameterType for 'doesnotexist'\n"));
         }
     }
+
+    TEST_F(TestExpression, ThrowDuplicateAnonymousParameterError)
+    {
+        try
+        {
+            parameterRegistry.Add("", { ".*" }, [](const MatchRange& matches)
+                {
+                    return StringTo<std::string>(matches.begin()->str());
+                });
+            FAIL() << "Expected CucumberExpressionError to be thrown";
+        }
+        catch (const CucumberExpressionError& e)
+        {
+            EXPECT_THAT(e.what(), testing::StrEq("The anonymous parameter type has already been defined"));
+        }
+    }
+
+    TEST_F(TestExpression, ThrowDuplicateParameterError)
+    {
+        try
+        {
+            parameterRegistry.Add("word", { wordRegex }, [](const MatchRange& matches)
+                {
+                    return StringTo<std::string>(matches.begin()->str());
+                });
+            FAIL() << "Expected CucumberExpressionError to be thrown";
+        }
+        catch (const CucumberExpressionError& e)
+        {
+            EXPECT_THAT(e.what(), testing::StrEq("There is already a parameter with name word"));
+        }
+    }
 }