Expand docstrings and names in Scenario Outline (#178, #172)

CHANGELOG.md

@@ -39,6 +39,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th
 
 - Template regex in `Scenario Outline` expansion from `<(\S+)>` to `<([^>\s]+)>`. ([#163])
 - Multiple `Examples` in `Scenario Outline`. ([#165], [#164])
+- Docstring and name expansion in `Scenario Outline`. ([#178], [#172])
 
 [#147]: /../../pull/147
 [#151]: /../../pull/151
@@ -51,6 +52,8 @@ All user visible changes to `cucumber` crate will be documented in this file. Th
 [#165]: /../../pull/165
 [#166]: /../../pull/166
 [#168]: /../../pull/168
+[#172]: /../../pull/172
+[#178]: /../../pull/178
 [cef3d480]: /../../commit/cef3d480579190425461ddb04a1248675248351e
 [rev]: /../../commit/rev-full
 [0110-1]: https://llg.cubic.org/docs/junit

codegen/src/attribute.rs

@@ -546,6 +546,8 @@ impl<'p> Parameters<'p> {
                         // In case we encounter default parameter, we should
                         // assert that corresponding argument's type __doesn't__
                         // implement a `Parameter` trait.
+                        // TODO: Try to use autoderef-based specialization with
+                        //       readable assertion message.
                         #[automatically_derived]
                         const _: fn() = || {
                             // Generic trait with a blanket impl over `()` for
@@ -589,8 +591,6 @@ impl<'p> Parameters<'p> {
                         // In case we encounter a custom parameter, we should
                         // assert that the corresponding type implements
                         // `Parameter` and has correct `Parameter::NAME`.
-                        // TODO: Panic here, once `const_panic` is stabilized.
-                        //       https://github.com/rust-lang/rust/pull/89508
                         #[automatically_derived]
                         const _: () = ::std::assert!(
                             ::cucumber::codegen::str_eq(

src/feature.rs

@@ -143,51 +143,51 @@ fn expand_scenario(
                 .zip(iter::repeat((example.position, example.tags.iter())))
         })
         .map(|((id, row), (position, tags))| {
-            let mut modified = scenario.clone();
+            let replace_templates = |str: &str, pos| {
+                let mut err = None;
+                let replaced = TEMPLATE_REGEX
+                    .replace_all(str, |cap: &regex::Captures<'_>| {
+                        let name = cap.get(1).unwrap().as_str();
+
+                        row.clone()
+                            .find_map(|(k, v)| (name == k).then(|| v.as_str()))
+                            .unwrap_or_else(|| {
+                                err = Some(ExpandExamplesError {
+                                    pos,
+                                    name: name.to_owned(),
+                                    path: path.cloned(),
+                                });
+                                ""
+                            })
+                    })
+                    .into_owned();
+
+                err.map_or_else(|| Ok(replaced), Err)
+            };
+
+            let mut expanded = scenario.clone();
 
             // This is done to differentiate `Hash`es of
             // scenario outlines with the same examples.
-            modified.position = position;
-            modified.position.line += id + 1;
-
-            modified.tags.extend(tags.cloned());
+            expanded.position = position;
+            expanded.position.line += id + 1;
 
-            for s in &mut modified.steps {
-                let mut err = None;
+            expanded.tags.extend(tags.cloned());
 
-                let to_replace = iter::once(&mut s.value).chain(
-                    s.table.iter_mut().flat_map(|t| {
+            expanded.name =
+                replace_templates(&expanded.name, expanded.position)?;
+            for s in &mut expanded.steps {
+                for value in iter::once(&mut s.value)
+                    .chain(s.docstring.iter_mut())
+                    .chain(s.table.iter_mut().flat_map(|t| {
                         t.rows.iter_mut().flat_map(|r| r.iter_mut())
-                    }),
-                );
-
-                for value in to_replace {
-                    *value = TEMPLATE_REGEX
-                        .replace_all(value, |c: &regex::Captures<'_>| {
-                            let name = c.get(1).unwrap().as_str();
-
-                            row.clone()
-                                .find_map(|(k, v)| {
-                                    (name == k).then(|| v.as_str())
-                                })
-                                .unwrap_or_else(|| {
-                                    err = Some(ExpandExamplesError {
-                                        pos: s.position,
-                                        name: name.to_owned(),
-                                        path: path.cloned(),
-                                    });
-                                    ""
-                                })
-                        })
-                        .into_owned();
-                }
-
-                if let Some(e) = err {
-                    return Err(e);
+                    }))
+                {
+                    *value = replace_templates(value, s.position)?;
                 }
             }
 
-            Ok(modified)
+            Ok(expanded)
         })
         .collect()
 }

tests/features/output/background_rule_background_outline.feature

@@ -8,7 +8,7 @@ Feature: Outline
     Background:
       Given foo is 1
 
-    Scenario Outline: foo
+    Scenario Outline: foo <bar1>
       Given foo is <bar1>
       When foo is <bar2>
       Then foo is <bar3>

tests/features/output/scenario_outline_with_basic_dosctring.feature

@@ -0,0 +1,13 @@
+Feature: Outline
+
+  Scenario Outline: foo
+    Given foo is <bar1>
+    When foo is <bar2>
+    """
+    Nothing to replace here
+    """
+    Then foo is <bar3>
+
+    Examples:
+      | bar1 | bar2 | bar3 |
+      |  0   |  1   |  2   |