refactor: integrate StepRegistry and FeatureTreeFactory into Application and TestRunner implementations

Author: daantimmer

cucumber_cpp/library/Application.cpp

@@ -1,5 +1,6 @@
 #include "cucumber_cpp/library/Application.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
 #include "cucumber_cpp/library/engine/FeatureInfo.hpp"
@@ -202,16 +203,20 @@ namespace cucumber_cpp::library
                     return engine::executeRunPolicy;
             }() };
 
-        engine::TestRunnerImpl testRunner{ testExecution };
+        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(engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression)
     {
+
         const auto featureFiles = GetFeatureFiles(options);
         std::vector<std::unique_ptr<engine::FeatureInfo>> vec;
         vec.reserve(featureFiles.size());

cucumber_cpp/library/Application.hpp

@@ -3,6 +3,8 @@
 
 #include "cucumber/gherkin/app.hpp"
 #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/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
 #include "cucumber_cpp/library/engine/FeatureInfo.hpp"
@@ -64,7 +66,7 @@ namespace cucumber_cpp::library
         [[nodiscard]] int GetExitCode() 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(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 +80,7 @@ namespace cucumber_cpp::library
 
         cucumber::gherkin::app gherkin;
 
-        engine::FeatureTreeFactory featureTreeFactory{};
+        cucumber_expression::ParameterRegistry parameterRegistry;
     };
 }
 

cucumber_cpp/library/StepRegistry.cpp

@@ -1,9 +1,17 @@
 #include "cucumber_cpp/library/StepRegistry.hpp"
+#include "cucumber_cpp/library/Body.hpp"
+#include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/cucumber_expression/Expression.hpp"
 #include "cucumber_cpp/library/cucumber_expression/Matcher.hpp"
+#include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
+#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>
 #include <variant>
@@ -22,13 +30,14 @@ namespace cucumber_cpp::library
         };
     }
 
-    StepRegistry& StepRegistry::Instance()
+    StepRegistry::StepRegistry(cucumber_expression::ParameterRegistry& parameterRegistry)
+        : parameterRegistry{ parameterRegistry }
     {
-        static StepRegistry instance;
-        return instance;
+        for (const auto& matcher : StepStringRegistration::Instance().GetEntries())
+            Register(matcher.regex, matcher.type, matcher.factory);
     }
 
-    StepMatch StepRegistryBase::Query(engine::StepType stepType, const std::string& expression)
+    StepMatch StepRegistry::Query(engine::StepType stepType, const std::string& expression)
     {
         std::vector<StepMatch> matches;
 
@@ -51,19 +60,19 @@ namespace cucumber_cpp::library
         return std::move(matches.front());
     }
 
-    std::size_t StepRegistryBase::Size() const
+    std::size_t StepRegistry::Size() const
     {
         return registry.size();
     }
 
-    std::size_t StepRegistryBase::Size(engine::StepType stepType) const
+    std::size_t StepRegistry::Size(engine::StepType stepType) const
     {
         return std::ranges::count(registry, stepType, &Entry::type);
     }
 
-    std::vector<StepRegistryBase::EntryView> StepRegistryBase::List() const
+    std::vector<StepRegistry::EntryView> StepRegistry::List() const
     {
-        std::vector<StepRegistryBase::EntryView> list;
+        std::vector<StepRegistry::EntryView> list;
 
         list.reserve(registry.size());
 
@@ -72,4 +81,28 @@ namespace cucumber_cpp::library
 
         return list;
     }
+
+    void StepRegistry::Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table))
+    {
+        if (matcher.starts_with('^') || matcher.ends_with('$'))
+            registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::RegularExpression>, matcher }, factory);
+        else
+            registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::Expression>, matcher, parameterRegistry }, factory);
+    }
+
+    StepStringRegistration& StepStringRegistration::Instance()
+    {
+        static StepStringRegistration instance;
+        return instance;
+    }
+
+    std::span<StepStringRegistration::Entry> StepStringRegistration::GetEntries()
+    {
+        return registry;
+    }
+
+    std::span<const StepStringRegistration::Entry> StepStringRegistration::GetEntries() const
+    {
+        return registry;
+    }
 }

cucumber_cpp/library/StepRegistry.hpp

@@ -3,17 +3,16 @@
 
 #include "cucumber_cpp/library/Body.hpp"
 #include "cucumber_cpp/library/Context.hpp"
-#include "cucumber_cpp/library/cucumber_expression/Expression.hpp"
 #include "cucumber_cpp/library/cucumber_expression/Matcher.hpp"
 #include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
-#include "cucumber_cpp/library/cucumber_expression/RegularExpression.hpp"
 #include "cucumber_cpp/library/engine/StepType.hpp"
 #include "cucumber_cpp/library/engine/Table.hpp"
 #include <any>
 #include <cstddef>
 #include <cstdint>
 #include <exception>
 #include <memory>
+#include <span>
 #include <string>
 #include <string_view>
 #include <utility>
@@ -22,6 +21,12 @@
 
 namespace cucumber_cpp::library
 {
+    template<class T>
+    std::unique_ptr<Body> StepBodyFactory(Context& context, const engine::Table& table)
+    {
+        return std::make_unique<T>(context, table);
+    }
+
     struct StepMatch
     {
         StepMatch(std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table), std::variant<std::vector<std::string>, std::vector<std::any>> matches, std::string_view stepRegexStr)
@@ -35,7 +40,7 @@ namespace cucumber_cpp::library
         std::string_view stepRegexStr{};
     };
 
-    struct StepRegistryBase
+    struct StepRegistry
     {
         struct StepNotFoundError : std::exception
         {
@@ -77,62 +82,63 @@ namespace cucumber_cpp::library
             const std::uint32_t& used;
         };
 
+        explicit StepRegistry(cucumber_expression::ParameterRegistry& parameterRegistry);
+
         [[nodiscard]] StepMatch Query(engine::StepType stepType, 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;
 
-    protected:
-        template<class T>
-        std::size_t
-        Register(const std::string& matcher, engine::StepType stepType);
-
     private:
-        template<class T>
-        static std::unique_ptr<Body> Construct(Context& context, const engine::Table& table);
+        void Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table));
 
         std::vector<Entry> registry;
-        cucumber_expression::ParameterRegistry parameterRegistry;
+        cucumber_expression::ParameterRegistry& parameterRegistry;
     };
 
-    struct StepRegistry : StepRegistryBase
+    struct StepStringRegistration
     {
     private:
-        StepRegistry() = default;
+        StepStringRegistration() = default;
 
     public:
-        static StepRegistry& Instance();
+        static StepStringRegistration& Instance();
+
+        struct Entry
+        {
+            Entry(engine::StepType type, std::string regex, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table))
+                : type(type)
+                , regex(std::move(regex))
+                , factory(factory)
+            {}
+
+            engine::StepType type{};
+            std::string regex;
+            std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table);
+        };
 
         template<class T>
         static std::size_t Register(const std::string& matcher, engine::StepType stepType);
+
+        std::span<Entry> GetEntries();
+        [[nodiscard]] std::span<const Entry> GetEntries() const;
+
+    private:
+        std::vector<Entry> registry;
     };
 
     //////////////////////////
     //    implementation    //
     //////////////////////////
 
     template<class T>
-    std::size_t StepRegistryBase::Register(const std::string& matcher, engine::StepType stepType)
+    std::size_t StepStringRegistration::Register(const std::string& matcher, engine::StepType stepType)
     {
-        if (matcher.starts_with('^') || matcher.ends_with('$'))
-            registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::RegularExpression>, matcher }, Construct<T>);
-        else
-            registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::Expression>, matcher, parameterRegistry }, Construct<T>);
-        return registry.size();
-    }
-
-    template<class T>
-    std::unique_ptr<Body> StepRegistryBase::Construct(Context& context, const engine::Table& table)
-    {
-        return std::make_unique<T>(context, table);
-    }
+        Instance().registry.emplace_back(stepType, matcher, StepBodyFactory<T>);
 
-    template<class T>
-    std::size_t StepRegistry::Register(const std::string& matcher, engine::StepType stepType)
-    {
-        return Instance().StepRegistryBase::Register<T>(matcher, stepType);
+        return Instance().registry.size();
     }
 }
 

cucumber_cpp/library/Steps.hpp

@@ -5,7 +5,7 @@
 #include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/engine/Step.hpp"
 
-#define STEP_(matcher, type, args, fixture) BODY(matcher, type, args, cucumber_cpp::library::StepRegistry::Register, fixture)
+#define STEP_(matcher, type, args, fixture) BODY(matcher, type, args, cucumber_cpp::library::StepStringRegistration::Register, fixture)
 
 #define STEP_TYPE_(fixture, type, ...)  \
     STEP_(                              \