fix sonar warnings and replace \r\n with \n

Author: daantimmer

compatibility/compatibility.cpp

@@ -93,6 +93,10 @@ namespace compatibility
 
                     ++jsonIter;
                 }
+                else if (key == "data")
+                {
+                    json[key] = std::regex_replace(json[key].get<std::string>(), std::regex(R"(\r\n)"), "\n");
+                }
                 else if (key == "uri")
                 {
                     auto uri = value.get<std::string>();

cucumber_cpp/library/assemble/AssembleTestSuites.cpp

@@ -4,7 +4,9 @@
 #include "cucumber/messages/step_match_arguments_list.hpp"
 #include "cucumber/messages/test_case.hpp"
 #include "cucumber_cpp/library/HookRegistry.hpp"
+#include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/assemble/AssembledTestSuite.hpp"
+#include "cucumber_cpp/library/cucumber_expression/Argument.hpp"
 #include "cucumber_cpp/library/cucumber_expression/Matcher.hpp"
 #include "cucumber_cpp/library/support/SupportCodeLibrary.hpp"
 #include "cucumber_cpp/library/support/Types.hpp"
@@ -22,13 +24,30 @@
 
 namespace cucumber_cpp::library::assemble
 {
+    namespace
+    {
+        auto TransformToMatch(const std::string& text)
+        {
+            return [&text](const StepRegistry::Definition& definition) -> std::pair<std::string, std::optional<std::vector<cucumber_expression::Argument>>>
+            {
+                const auto match = std::visit(cucumber_expression::MatchVisitor{ text }, definition.regex);
+                return { definition.id, match };
+            };
+        }
+
+        bool HasMatch(const std::pair<std::string, std::optional<std::vector<cucumber_expression::Argument>>>& pair)
+        {
+            return pair.second.has_value();
+        }
+    }
+
     std::vector<AssembledTestSuite> AssembleTestSuites(support::SupportCodeLibrary supportCodeLibrary,
         std::string_view testRunStartedId,
         util::Broadcaster& broadcaster,
         const std::list<support::PickleSource>& sourcedPickles,
         cucumber::gherkin::id_generator_ptr idGenerator)
     {
-        std::vector<std::string> testUris;
+        std::list<std::string> testUris;
         std::map<std::string, AssembledTestSuite> assembledTestSuiteMap;
 
         for (const auto& pickleSource : sourcedPickles)
@@ -47,30 +66,24 @@ namespace cucumber_cpp::library::assemble
 
             for (const auto& step : pickleSource.pickle->steps)
             {
-                // auto definitions = supportCodeLibrary.stepRegistry.FindDefinitions(step.text);
                 const auto& stepDefinitions = supportCodeLibrary.stepRegistry.StepDefinitions();
 
-                std::vector<std::string> stepDefinitionIds;
-                std::vector<cucumber::messages::step_match_arguments_list> stepMatchArgumentsLists;
-
-                for (const auto& definition : stepDefinitions)
-                {
-                    const auto match = std::visit(cucumber_expression::MatchVisitor{ step.text }, definition.regex);
-                    if (match)
-                    {
-                        stepDefinitionIds.push_back(definition.id);
-                        auto& argumentList = stepMatchArgumentsLists.emplace_back();
-                        for (const auto& result : *match)
-                            argumentList.step_match_arguments.emplace_back(result.Group(), result.Name().empty() ? std::nullopt : std::make_optional(result.Name()));
-                    }
-                }
-
-                testCase.test_steps.emplace_back(
+                auto& testStep = testCase.test_steps.emplace_back(
                     std::nullopt,
                     idGenerator->next_id(),
                     step.id,
-                    stepDefinitionIds,
-                    stepMatchArgumentsLists);
+                    std::vector<std::string>{},
+                    std::vector<cucumber::messages::step_match_arguments_list>{});
+
+                for (const auto& [id, match] : stepDefinitions |
+                                                   std::views::transform(TransformToMatch(step.text)) |
+                                                   std::views::filter(HasMatch))
+                {
+                    testStep.step_definition_ids.value().push_back(id);
+                    auto& argumentList = testStep.step_match_arguments_lists.value().emplace_back();
+                    for (const auto& result : *match)
+                        argumentList.step_match_arguments.emplace_back(result.Group(), result.Name().empty() ? std::nullopt : std::make_optional(result.Name()));
+                }
             }
 
             for (const auto& hookId : supportCodeLibrary.hookRegistry.FindIds(HookType::after, pickleSource.pickle->tags) | std::views::reverse)

cucumber_cpp/library/cucumber_expression/TreeRegexp.hpp

@@ -35,7 +35,7 @@ namespace cucumber_cpp::library::cucumber_expression
 
     struct TreeRegexp
     {
-        TreeRegexp(std::string_view pattern);
+        explicit TreeRegexp(std::string_view pattern);
 
         const GroupBuilder& RootBuilder() const;
 

cucumber_cpp/library/formatter/PrettyPrinter.cpp

@@ -113,7 +113,9 @@ namespace cucumber_cpp::library::formatter
     }
 
     void PrettyPrinter::HandleAttachment(const cucumber::messages::attachment& attachment)
-    {}
+    {
+        /* TODO implement */
+    }
 
     void PrettyPrinter::HandleTestStepFinished(const cucumber::messages::test_step_finished& testStepFinished)
     {
@@ -133,7 +135,9 @@ namespace cucumber_cpp::library::formatter
     }
 
     void PrettyPrinter::HandleTestRunFinished(const cucumber::messages::test_run_finished& testRunFinished)
-    {}
+    {
+        /* TODO implement */
+    }
 
     void PrettyPrinter::PrintFeatureLine(const cucumber::messages::feature& feature)
     {
@@ -187,7 +191,7 @@ namespace cucumber_cpp::library::formatter
         }
         const auto padding = maxContentLength - title.length();
 
-        if (uri && line)
+        if (uri.has_value() && line.has_value())
             support::print(outputStream, "{:{}}{}{:{}} {}\n", "", indent, formatTitle ? formatTitle(title) : std::string(title), "", padding, ColorFunctions::Location(std::format("# {}:{}", *uri, *line)));
         else
             support::print(outputStream, "{:{}}{}\n", "", indent, formatTitle ? formatTitle(title) : std::string(title));

cucumber_cpp/library/formatter/helper/SummaryHelpers.cpp

@@ -1,5 +1,6 @@
 #include "cucumber_cpp/library/formatter/helper/SummaryHelpers.hpp"
 #include "cucumber/messages/duration.hpp"
+#include "cucumber/messages/test_step.hpp"
 #include "cucumber/messages/test_step_result.hpp"
 #include "cucumber/messages/test_step_result_status.hpp"
 #include "cucumber_cpp/library/formatter/GetColorFunctions.hpp"
@@ -59,6 +60,11 @@ namespace cucumber_cpp::library::formatter::helper
             const auto total = support::DurationToMilliseconds(duration);
             return std::format("{:%Mm %S}s", total);
         }
+
+        bool HasPickleStepId(const cucumber::messages::test_step& testStep)
+        {
+            return testStep.pickle_step_id.has_value();
+        }
     }
 
     std::string FormatSummary(std::span<const TestCaseAttempt> testCaseAttempts, cucumber::messages::duration testRunDuration)
@@ -75,9 +81,10 @@ namespace cucumber_cpp::library::formatter::helper
             if (!testCaseAttempt.willBeRetried)
             {
                 testCaseResults.emplace_back(testCaseAttempt.worstTestStepResult);
-                for (const auto& testStep : testCaseAttempt.testCase.test_steps)
-                    if (testStep.pickle_step_id)
-                        testStepResults.emplace_back(testCaseAttempt.stepResults.at(testStep.id));
+
+                for (const auto& testStep : testCaseAttempt.testCase.test_steps |
+                                                std::views::filter(HasPickleStepId))
+                    testStepResults.emplace_back(testCaseAttempt.stepResults.at(testStep.id));
             }
         }
 

cucumber_cpp/library/runtime/TestCaseRunner.cpp

@@ -181,7 +181,7 @@ namespace cucumber_cpp::library::runtime
 
     cucumber::messages::test_step_result TestCaseRunner::RunStep(const cucumber::messages::pickle_step& pickleStep, const cucumber::messages::test_step& testStep, Context& testCaseContext, cucumber::messages::test_step_started testStepStarted)
     {
-        auto stepDefinitions = (*testStep.step_definition_ids) | std::views::transform([&](const std::string& id)
+        auto stepDefinitions = (*testStep.step_definition_ids) | std::views::transform([this](const std::string& id)
                                                                      {
                                                                          return supportCodeLibrary.stepRegistry.GetDefinitionById(id);
                                                                      });

cucumber_cpp/library/util/Broadcaster.hpp

@@ -12,6 +12,12 @@ namespace cucumber_cpp::library::util
     struct Listener
     {
         explicit Listener(Broadcaster& broadcaster, const std::function<void(const cucumber::messages::envelope& envelope)>& onEvent);
+
+        Listener(const Listener&) = delete;
+        Listener& operator=(const Listener&) = delete;
+        Listener(Listener&&) = delete;
+        Listener& operator=(Listener&&) = delete;
+
         ~Listener();
 
         void Invoke(const cucumber::messages::envelope& envelope) const;