feat: add gherkin doc string support (#214)

daantimmer · alextech · web-flow · commit 9a4615fbd7cf · 2025-09-16T23:46:27.000+02:00
* Add gherkin doc string support

* Add gherkin doc string support
- string move

* Add gherkin doc string support
- missed doctype parameter in tests

---------

Co-authored-by: Alexander Romanenko &lt;alex@alex-tech-adventures.com&gt;
diff --git a/cucumber_cpp/acceptance_test/features/test_doc_strings.feature b/cucumber_cpp/acceptance_test/features/test_doc_strings.feature
@@ -0,0 +1,8 @@
+Feature: Doc Strings
+
+  Scenario: Multiline doc strings
+    Given Next block of text enclosed in """ characters
+      """
+      Multiline
+      Docstring
+      """
diff --git a/cucumber_cpp/acceptance_test/steps/Steps.cpp b/cucumber_cpp/acceptance_test/steps/Steps.cpp
@@ -54,3 +54,9 @@ THEN("this should be skipped")
 {
     FAIL();
 }
+
+GIVEN("Next block of text enclosed in \"\"\" characters")
+{
+
+    ASSERT_THAT(docString, testing::Eq("Multiline\nDocstring"));
+}
diff --git a/cucumber_cpp/library/StepRegistry.cpp b/cucumber_cpp/library/StepRegistry.cpp
@@ -64,7 +64,7 @@ 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))
+    void StepRegistry::Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString))
     {
         if (matcher.starts_with('^') || matcher.ends_with('$'))
             registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::RegularExpression>, matcher }, factory);
diff --git a/cucumber_cpp/library/StepRegistry.hpp b/cucumber_cpp/library/StepRegistry.hpp
@@ -8,7 +8,6 @@
 #include "cucumber_cpp/library/engine/StepType.hpp"
 #include "cucumber_cpp/library/engine/Table.hpp"
 #include <any>
-#include <cstddef>
 #include <cstdint>
 #include <exception>
 #include <memory>
@@ -22,20 +21,20 @@
 namespace cucumber_cpp::library
 {
     template<class T>
-    std::unique_ptr<Body> StepBodyFactory(Context& context, const engine::Table& table)
+    std::unique_ptr<Body> StepBodyFactory(Context& context, const engine::Table& table, const std::string& docString)
     {
-        return std::make_unique<T>(context, table);
+        return std::make_unique<T>(context, table, docString);
     }
 
     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)
+        StepMatch(std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString), std::variant<std::vector<std::string>, std::vector<std::any>> matches, std::string_view stepRegexStr)
             : factory(factory)
             , matches(std::move(matches))
             , stepRegexStr(stepRegexStr)
         {}
 
-        std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table);
+        std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString);
         std::variant<std::vector<std::string>, std::vector<std::any>> matches{};
         std::string_view stepRegexStr{};
     };
@@ -58,15 +57,15 @@ namespace cucumber_cpp::library
 
         struct Entry
         {
-            Entry(engine::StepType type, cucumber_expression::Matcher regex, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table))
+            Entry(engine::StepType type, cucumber_expression::Matcher regex, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString))
                 : type(type)
                 , regex(std::move(regex))
                 , factory(factory)
             {}
 
             engine::StepType type{};
             cucumber_expression::Matcher regex;
-            std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table);
+            std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString);
 
             std::uint32_t used{ 0 };
         };
@@ -91,7 +90,7 @@ namespace cucumber_cpp::library
         [[nodiscard]] std::vector<EntryView> List() const;
 
     private:
-        void Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(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, const std::string& docString));
 
         std::vector<Entry> registry;
         cucumber_expression::ParameterRegistry& parameterRegistry;
@@ -107,15 +106,15 @@ namespace cucumber_cpp::library
 
         struct Entry
         {
-            Entry(engine::StepType type, std::string regex, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table))
+            Entry(engine::StepType type, std::string regex, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString))
                 : 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);
+            std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString);
         };
 
         template<class T>
diff --git a/cucumber_cpp/library/engine/FeatureFactory.cpp b/cucumber_cpp/library/engine/FeatureFactory.cpp
@@ -124,7 +124,7 @@ namespace cucumber_cpp::library::engine
                 return table;
 
             for (const auto& dataTable = optionalPickleStepArgument.value().data_table.value();
-                 const auto& row : dataTable.rows)
+                const auto& row : dataTable.rows)
             {
                 table.emplace_back();
                 auto& back = table.back();
@@ -136,6 +136,17 @@ namespace cucumber_cpp::library::engine
             return table;
         }
 
+        std::string DocStringFactory(const std::optional<cucumber::messages::pickle_step_argument>& optionalPickleStepArgument)
+        {
+            if (!optionalPickleStepArgument)
+                return "";
+
+            if (!optionalPickleStepArgument.value().doc_string.has_value())
+                return "";
+
+            return optionalPickleStepArgument.value().doc_string.value().content;
+        }
+
         std::set<std::string, std::less<>> TagsFactory(const std::vector<cucumber::messages::tag>& tags)
         {
             const auto range = tags | std::views::transform(&cucumber::messages::tag::name);
@@ -151,10 +162,11 @@ namespace cucumber_cpp::library::engine
         void ConstructStep(const FeatureTreeFactory& featureTreeFactory, ScenarioInfo& scenarioInfo, const cucumber::messages::step& step, const cucumber::messages::pickle_step& pickleStep)
         {
             auto table = TableFactory(pickleStep.argument);
+            auto docString = DocStringFactory(pickleStep.argument);
 
             try
             {
-                scenarioInfo.Children().push_back(featureTreeFactory.CreateStepInfo(stepTypeLut.at(*pickleStep.type), pickleStep.text, scenarioInfo, step.location.line, step.location.column.value_or(0), std::move(table)));
+                scenarioInfo.Children().push_back(featureTreeFactory.CreateStepInfo(stepTypeLut.at(*pickleStep.type), pickleStep.text, scenarioInfo, step.location.line, step.location.column.value_or(0), std::move(table), std::move(docString)));
             }
             catch (const std::out_of_range&)
             {
@@ -287,20 +299,20 @@ namespace cucumber_cpp::library::engine
         : stepRegistry{ stepRegistry }
     {}
 
-    std::unique_ptr<StepInfo> FeatureTreeFactory::CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table) const
+    std::unique_ptr<StepInfo> FeatureTreeFactory::CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString) const
     {
         try
         {
             auto stepMatch = stepRegistry.Query(stepText);
-            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(stepMatch));
+            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString), std::move(stepMatch));
         }
         catch (const StepRegistry::StepNotFoundError&)
         {
-            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table));
+            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString));
         }
         catch (StepRegistry::AmbiguousStepError& ase)
         {
-            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(ase.matches));
+            return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString), std::move(ase.matches));
         }
     }
 
diff --git a/cucumber_cpp/library/engine/FeatureFactory.hpp b/cucumber_cpp/library/engine/FeatureFactory.hpp
@@ -20,7 +20,7 @@ namespace cucumber_cpp::library::engine
     {
         explicit FeatureTreeFactory(StepRegistry& stepRegistry);
 
-        [[nodiscard]] std::unique_ptr<StepInfo> CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table) const;
+        [[nodiscard]] std::unique_ptr<StepInfo> CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString) const;
 
         [[nodiscard]] std::unique_ptr<FeatureInfo> Create(const std::filesystem::path& path, std::string_view tagExpression) const;
 
diff --git a/cucumber_cpp/library/engine/Step.cpp b/cucumber_cpp/library/engine/Step.cpp
@@ -8,9 +8,10 @@
 
 namespace cucumber_cpp::library::engine
 {
-    Step::Step(Context& context, const Table& table)
+    Step::Step(Context& context, const Table& table, const std::string& docString)
         : context{ context }
         , table{ table }
+        , docString{ docString }
     {}
 
     void Step::Given(const std::string& step) const
diff --git a/cucumber_cpp/library/engine/Step.hpp b/cucumber_cpp/library/engine/Step.hpp
@@ -24,7 +24,7 @@ namespace cucumber_cpp::library::engine
             std::source_location sourceLocation;
         };
 
-        Step(Context& context, const Table& table);
+        Step(Context& context, const Table& table, const std::string& docString);
         virtual ~Step() = default;
 
         virtual void SetUp()
@@ -46,6 +46,7 @@ namespace cucumber_cpp::library::engine
 
         Context& context;
         const Table& table;
+        const std::string& docString;
     };
 }
 
diff --git a/cucumber_cpp/library/engine/StepInfo.cpp b/cucumber_cpp/library/engine/StepInfo.cpp
@@ -10,34 +10,37 @@
 
 namespace cucumber_cpp::library::engine
 {
-    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table)
+    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString)
         : scenarioInfo{ scenarioInfo }
         , text{ std::move(text) }
         , type{ type }
         , line{ line }
         , column{ column }
         , table{ std::move(table) }
+        , docString{ std::move(docString) }
     {
     }
 
-    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, struct StepMatch stepMatch)
+    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, struct StepMatch stepMatch)
         : scenarioInfo{ scenarioInfo }
         , text{ std::move(text) }
         , type{ type }
         , line{ line }
         , column{ column }
         , table{ std::move(table) }
+        , docString{ std::move(docString) }
         , stepMatch{ std::move(stepMatch) }
     {
     }
 
-    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::vector<struct StepMatch> stepMatches)
+    StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, std::vector<struct StepMatch> stepMatches)
         : scenarioInfo{ scenarioInfo }
         , text{ std::move(text) }
         , type{ type }
         , line{ line }
         , column{ column }
         , table{ std::move(table) }
+        , docString{ std::move(docString) }
         , stepMatch{ std::move(stepMatches) }
     {
     }
@@ -72,6 +75,11 @@ namespace cucumber_cpp::library::engine
         return table;
     }
 
+    const std::string& StepInfo::DocString() const
+    {
+        return docString;
+    }
+
     const std::variant<std::monostate, struct StepMatch, std::vector<struct StepMatch>>& StepInfo::StepMatch() const
     {
         return stepMatch;
diff --git a/cucumber_cpp/library/engine/StepInfo.hpp b/cucumber_cpp/library/engine/StepInfo.hpp
@@ -16,9 +16,9 @@ namespace cucumber_cpp::library::engine
 
     struct StepInfo
     {
-        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table);
-        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, StepMatch);
-        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::vector<StepMatch>);
+        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString);
+        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, StepMatch);
+        StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, std::vector<StepMatch>);
 
         [[nodiscard]] const struct ScenarioInfo& ScenarioInfo() const;
 
@@ -29,6 +29,7 @@ namespace cucumber_cpp::library::engine
         [[nodiscard]] std::size_t Column() const;
 
         [[nodiscard]] const std::vector<std::vector<TableValue>>& Table() const;
+        [[nodiscard]] const std::string& DocString() const;
         [[nodiscard]] const std::variant<std::monostate, struct StepMatch, std::vector<struct StepMatch>>& StepMatch() const;
 
     private:
@@ -41,6 +42,7 @@ namespace cucumber_cpp::library::engine
         std::size_t column;
 
         std::vector<std::vector<TableValue>> table;
+        std::string docString;
         std::variant<std::monostate, struct StepMatch, std::vector<struct StepMatch>> stepMatch;
     };
 
diff --git a/cucumber_cpp/library/engine/TestExecution.cpp b/cucumber_cpp/library/engine/TestExecution.cpp
@@ -63,7 +63,7 @@ namespace cucumber_cpp::library::engine
         const auto& stepContext = contextManager.StepContext();
         auto& scenarioContext = contextManager.ScenarioContext();
 
-        stepMatch.factory(scenarioContext, stepContext.info.Table())->Execute(stepMatch.matches);
+        stepMatch.factory(scenarioContext, stepContext.info.Table(), stepContext.info.DocString())->Execute(stepMatch.matches);
     }
 
     TestExecutionImpl::TestExecutionImpl(cucumber_cpp::library::engine::ContextManager& contextManager, report::ReportForwarder& reportHandler, HookExecutor& hookExecution, const Policy& executionPolicy)
diff --git a/cucumber_cpp/library/engine/TestRunner.cpp b/cucumber_cpp/library/engine/TestRunner.cpp
@@ -50,7 +50,7 @@ namespace cucumber_cpp::library::engine
 
     void TestRunnerImpl::NestedStep(StepType type, std::string step)
     {
-        const auto nestedStep = featureTreeFactory.CreateStepInfo(type, std::move(step), *currentScenario, 0, 0, {});
+        const auto nestedStep = featureTreeFactory.CreateStepInfo(type, std::move(step), *currentScenario, 0, 0, {}, "");
         testExecution.RunStep(*nestedStep);
     }
 
diff --git a/cucumber_cpp/library/engine/test/TestContextManager.cpp b/cucumber_cpp/library/engine/test/TestContextManager.cpp
@@ -20,7 +20,7 @@ namespace cucumber_cpp::library::engine
         cucumber_cpp::library::engine::FeatureInfo feature{ {}, {}, {}, {}, {}, {} };
         cucumber_cpp::library::engine::RuleInfo rule{ feature, {}, {}, {}, {}, {} };
         cucumber_cpp::library::engine::ScenarioInfo scenario{ rule, {}, {}, {}, {}, {} };
-        cucumber_cpp::library::engine::StepInfo step{ scenario, {}, {}, {}, {}, {} };
+        cucumber_cpp::library::engine::StepInfo step{ scenario, {}, {}, {}, {}, {}, {} };
     };
 
     TEST_F(TestContextManager, Construct)
diff --git a/cucumber_cpp/library/engine/test/TestStep.cpp b/cucumber_cpp/library/engine/test/TestStep.cpp
@@ -33,10 +33,12 @@ namespace cucumber_cpp::library::engine
             std::vector{ TableValue{ "value1" }, TableValue{ "value2}" } }
         };
 
+        const std::string docString = "multiline \n string";
+
         library::engine::test_helper::ContextManagerInstance contextManager;
 
         engine::test_helper::TestRunnerMock testRunnerMock;
-        StepMock step{ contextManager.StepContext(), table };
+        StepMock step{ contextManager.StepContext(), table, docString };
     };
 
     TEST_F(TestStep, StepProvidesAccessToSetUpFunction)
diff --git a/cucumber_cpp/library/engine/test_helper/ContextManagerInstance.hpp b/cucumber_cpp/library/engine/test_helper/ContextManagerInstance.hpp
@@ -28,7 +28,7 @@ namespace cucumber_cpp::library::engine::test_helper
             , feature{ tags, {}, {}, {}, {}, {} }
             , rule{ feature, {}, {}, {}, {}, {} }
             , scenario{ rule, tags, {}, {}, {}, {} }
-            , step{ scenario, {}, {}, {}, {}, {} }
+            , step{ scenario, {}, {}, {}, {}, {}, {} }
         {
         }
 
diff --git a/cucumber_cpp/library/test/TestSteps.cpp b/cucumber_cpp/library/test/TestSteps.cpp
@@ -58,7 +58,7 @@ namespace cucumber_cpp::library
         auto contextStorage{ std::make_shared<ContextStorageFactoryImpl>() };
         Context context{ contextStorage };
 
-        matches.factory(context, {})->Execute(matches.matches);
+        matches.factory(context, {}, "")->Execute(matches.matches);
 
         EXPECT_THAT(context.Contains("float"), testing::IsTrue());
         EXPECT_THAT(context.Contains("std::string"), testing::IsTrue());
@@ -85,7 +85,7 @@ namespace cucumber_cpp::library
         auto contextStorage{ std::make_shared<ContextStorageFactoryImpl>() };
         Context context{ contextStorage };
 
-        matches.factory(context, {})->Execute(matches.matches);
+        matches.factory(context, {}, {})->Execute(matches.matches);
     }
 
     TEST_F(TestSteps, EscapedParenthesis)
diff --git a/external/cucumber/gherkin/CMakeLists.txt b/external/cucumber/gherkin/CMakeLists.txt
@@ -1,6 +1,6 @@
 FetchContent_Declare(cucumber_gherkin
     GIT_REPOSITORY https://github.com/cucumber/gherkin.git
-    GIT_TAG "0022bb07791485cda296e1785f4d0de47a04e5c9"
+    GIT_TAG "7cd0304c39a51ac139a22264ebe2a7ce6c68819d"
 )
 
 FetchContent_MakeAvailable(cucumber_gherkin)

Original file line number	Diff line number	Diff line change
`@@ -54,3 +54,9 @@ THEN("this should be skipped")`
`54`	`54`	`{`
`55`	`55`	`FAIL();`
`56`	`56`	`}`
	`57`	`+`
	`58`	`+GIVEN("Next block of text enclosed in \"\"\" characters")`
	`59`	`+{`
	`60`	`+`
	`61`	`+ ASSERT_THAT(docString, testing::Eq("Multiline\nDocstring"));`
	`62`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ namespace cucumber_cpp::library`
`64`	`64`	`return list;`
`65`	`65`	`}`
`66`	`66`
`67`		`- void StepRegistry::Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table))`
	`67`	`+ void StepRegistry::Register(const std::string& matcher, engine::StepType stepType, std::unique_ptr<Body> (&factory)(Context& context, const engine::Table& table, const std::string& docString))`
`68`	`68`	`{`
`69`	`69`	`if (matcher.starts_with('^') \|\| matcher.ends_with('$'))`
`70`	`70`	`registry.emplace_back(stepType, cucumber_expression::Matcher{ std::in_place_type<cucumber_expression::RegularExpression>, matcher }, factory);`
Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ namespace cucumber_cpp::library::engine`
`124`	`124`	`return table;`
`125`	`125`
`126`	`126`	`for (const auto& dataTable = optionalPickleStepArgument.value().data_table.value();`
`127`		`- const auto& row : dataTable.rows)`
	`127`	`+ const auto& row : dataTable.rows)`
`128`	`128`	`{`
`129`	`129`	`table.emplace_back();`
`130`	`130`	`auto& back = table.back();`
`@@ -136,6 +136,17 @@ namespace cucumber_cpp::library::engine`
`136`	`136`	`return table;`
`137`	`137`	`}`
`138`	`138`
	`139`	`+ std::string DocStringFactory(const std::optional<cucumber::messages::pickle_step_argument>& optionalPickleStepArgument)`
	`140`	`+ {`
	`141`	`+ if (!optionalPickleStepArgument)`
	`142`	`+ return "";`
	`143`	`+`
	`144`	`+ if (!optionalPickleStepArgument.value().doc_string.has_value())`
	`145`	`+ return "";`
	`146`	`+`
	`147`	`+ return optionalPickleStepArgument.value().doc_string.value().content;`
	`148`	`+ }`
	`149`	`+`
`139`	`150`	`std::set<std::string, std::less<>> TagsFactory(const std::vector<cucumber::messages::tag>& tags)`
`140`	`151`	`{`
`141`	`152`	`const auto range = tags \| std::views::transform(&cucumber::messages::tag::name);`
`@@ -151,10 +162,11 @@ namespace cucumber_cpp::library::engine`
`151`	`162`	`void ConstructStep(const FeatureTreeFactory& featureTreeFactory, ScenarioInfo& scenarioInfo, const cucumber::messages::step& step, const cucumber::messages::pickle_step& pickleStep)`
`152`	`163`	`{`
`153`	`164`	`auto table = TableFactory(pickleStep.argument);`
	`165`	`+ auto docString = DocStringFactory(pickleStep.argument);`
`154`	`166`
`155`	`167`	`try`
`156`	`168`	`{`
`157`		`- scenarioInfo.Children().push_back(featureTreeFactory.CreateStepInfo(stepTypeLut.at(*pickleStep.type), pickleStep.text, scenarioInfo, step.location.line, step.location.column.value_or(0), std::move(table)));`
	`169`	`+ scenarioInfo.Children().push_back(featureTreeFactory.CreateStepInfo(stepTypeLut.at(*pickleStep.type), pickleStep.text, scenarioInfo, step.location.line, step.location.column.value_or(0), std::move(table), std::move(docString)));`
`158`	`170`	`}`
`159`	`171`	`catch (const std::out_of_range&)`
`160`	`172`	`{`
`@@ -287,20 +299,20 @@ namespace cucumber_cpp::library::engine`
`287`	`299`	`: stepRegistry{ stepRegistry }`
`288`	`300`	`{}`
`289`	`301`
`290`		`- std::unique_ptr<StepInfo> FeatureTreeFactory::CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table) const`
	`302`	`+ std::unique_ptr<StepInfo> FeatureTreeFactory::CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString) const`
`291`	`303`	`{`
`292`	`304`	`try`
`293`	`305`	`{`
`294`	`306`	`auto stepMatch = stepRegistry.Query(stepText);`
`295`		`- return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(stepMatch));`
	`307`	`+ return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString), std::move(stepMatch));`
`296`	`308`	`}`
`297`	`309`	`catch (const StepRegistry::StepNotFoundError&)`
`298`	`310`	`{`
`299`		`- return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table));`
	`311`	`+ return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString));`
`300`	`312`	`}`
`301`	`313`	`catch (StepRegistry::AmbiguousStepError& ase)`
`302`	`314`	`{`
`303`		`- return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(ase.matches));`
	`315`	`+ return std::make_unique<StepInfo>(scenarioInfo, std::move(stepText), stepType, line, column, std::move(table), std::move(docString), std::move(ase.matches));`
`304`	`316`	`}`
`305`	`317`	`}`
`306`	`318`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ namespace cucumber_cpp::library::engine`
`20`	`20`	`{`
`21`	`21`	`explicit FeatureTreeFactory(StepRegistry& stepRegistry);`
`22`	`22`
`23`		`- [[nodiscard]] std::unique_ptr<StepInfo> CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table) const;`
	`23`	`+ [[nodiscard]] std::unique_ptr<StepInfo> CreateStepInfo(StepType stepType, std::string stepText, const ScenarioInfo& scenarioInfo, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString) const;`
`24`	`24`
`25`	`25`	`[[nodiscard]] std::unique_ptr<FeatureInfo> Create(const std::filesystem::path& path, std::string_view tagExpression) const;`
`26`	`26`
Original file line number	Diff line number	Diff line change
`@@ -10,34 +10,37 @@`
`10`	`10`
`11`	`11`	`namespace cucumber_cpp::library::engine`
`12`	`12`	`{`
`13`		`- StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table)`
	`13`	`+ StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString)`
`14`	`14`	`: scenarioInfo{ scenarioInfo }`
`15`	`15`	`, text{ std::move(text) }`
`16`	`16`	`, type{ type }`
`17`	`17`	`, line{ line }`
`18`	`18`	`, column{ column }`
`19`	`19`	`, table{ std::move(table) }`
	`20`	`+ , docString{ std::move(docString) }`
`20`	`21`	`{`
`21`	`22`	`}`
`22`	`23`
`23`		`- StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, struct StepMatch stepMatch)`
	`24`	`+ StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, struct StepMatch stepMatch)`
`24`	`25`	`: scenarioInfo{ scenarioInfo }`
`25`	`26`	`, text{ std::move(text) }`
`26`	`27`	`, type{ type }`
`27`	`28`	`, line{ line }`
`28`	`29`	`, column{ column }`
`29`	`30`	`, table{ std::move(table) }`
	`31`	`+ , docString{ std::move(docString) }`
`30`	`32`	`, stepMatch{ std::move(stepMatch) }`
`31`	`33`	`{`
`32`	`34`	`}`
`33`	`35`
`34`		`- StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::vector<struct StepMatch> stepMatches)`
	`36`	`+ StepInfo::StepInfo(const struct ScenarioInfo& scenarioInfo, std::string text, StepType type, std::size_t line, std::size_t column, std::vector<std::vector<TableValue>> table, std::string docString, std::vector<struct StepMatch> stepMatches)`
`35`	`37`	`: scenarioInfo{ scenarioInfo }`
`36`	`38`	`, text{ std::move(text) }`
`37`	`39`	`, type{ type }`
`38`	`40`	`, line{ line }`
`39`	`41`	`, column{ column }`
`40`	`42`	`, table{ std::move(table) }`
	`43`	`+ , docString{ std::move(docString) }`
`41`	`44`	`, stepMatch{ std::move(stepMatches) }`
`42`	`45`	`{`
`43`	`46`	`}`
`@@ -72,6 +75,11 @@ namespace cucumber_cpp::library::engine`
`72`	`75`	`return table;`
`73`	`76`	`}`
`74`	`77`
	`78`	`+ const std::string& StepInfo::DocString() const`
	`79`	`+ {`
	`80`	`+ return docString;`
	`81`	`+ }`
	`82`	`+`
`75`	`83`	`const std::variant<std::monostate, struct StepMatch, std::vector<struct StepMatch>>& StepInfo::StepMatch() const`
`76`	`84`	`{`
`77`	`85`	`return stepMatch;`