Implement writer::Repeat (#82, #129, #133)

Additionally:
- propagate Scenario Outline expansion errors
- display file and line of skipped Steps
- fix typos of `indent` term in source code

Author: ilslv

Cargo.toml

@@ -39,6 +39,7 @@ gherkin = { package = "gherkin_rust", version = "0.10" }
 globwalk = "0.8"
 itertools = "0.10"
 linked-hash-map = "0.5"
+once_cell = { version = "1.8", features = ["parking_lot"] }
 regex = "1.5"
 sealed = "0.3"
 

book/src/Getting_Started.md

@@ -88,7 +88,7 @@ fn main() {
 
 If you run this, you should see an output like:
 
-<script id="asciicast-t8ezu3cajA0fBkssIy04LM9pa" src="https://asciinema.org/a/t8ezu3cajA0fBkssIy04LM9pa.js" async data-autoplay="true" data-rows="24"></script>
+<script id="asciicast-loqmDmLvKdp4CG7URpVsLJgkB" src="https://asciinema.org/a/loqmDmLvKdp4CG7URpVsLJgkB.js" async data-autoplay="true" data-rows="23"></script>
 
 You will see a checkmark next to `Given A hungry cat`, which means that test step has been matched and executed.
 
@@ -156,7 +156,7 @@ fn feed_cat(world: &mut AnimalWorld) {
 
 If you run the tests again, you'll see that two lines are green now and the next one is marked as not yet implemented:
 
-<script id="asciicast-aWGpouW2F8lQRQ1O2eUQTRSlE" src="https://asciinema.org/a/aWGpouW2F8lQRQ1O2eUQTRSlE.js" async data-autoplay="true" data-rows="16"></script>
+<script id="asciicast-iyhXabbOv7jdKvbcsyhzqPMfo" src="https://asciinema.org/a/iyhXabbOv7jdKvbcsyhzqPMfo.js" async data-autoplay="true" data-rows="15"></script>
 
 Finally: how do we validate our result? We expect that this will cause some change in the cat and that the cat will no longer be hungry since it has been fed. The `then()` step follows to assert this, as our feature says:
 ```rust

book/src/Test_Modules_Organization.md

@@ -28,4 +28,6 @@ Avoid writing similar step definitions, as they can lead to clutter. While docum
 
 As your test suit grows, it may become harder to notice how minimal changes to `regex`es can lead to mismatched `Step`s. To avoid this, we recommend using [`Cucumber::fail_on_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.fail_on_skipped) combining with `@allow_skipped` tag. This will allow you to mark out `Scenario`s which `Step`s are allowed to skip.
 
-And, as time goes on, total run time of all tests can become overwhelming when you only want to test small subset of `Scenario`s. At least until you discover [`Cucumber::filter_run_and_exit()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.filter_run_and_exit), which will allow you run only `Scenario`s marked with custom [tags](https://cucumber.io/docs/cucumber/api/#tags).
+And, as time goes on, total run time of all tests can become overwhelming when you only want to test small subset of `Scenario`s. At least until you discover [`Cucumber::filter_run_and_exit()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.filter_run_and_exit), which will allow you run only `Scenario`s marked with custom [tags](https://cucumber.io/docs/cucumber/api/#tags). 
+
+We also suggest using [`Cucumber::repeat_failed()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.repeat_failed) and [`Cucumber::repeat_skipped()`](https://docs.rs/cucumber/*/cucumber/struct.Cucumber.html#method.repeat_skipped) to re-output failed or skipped steps for easier navigation.

src/cucumber.rs

@@ -24,8 +24,8 @@ use futures::StreamExt as _;
 use regex::Regex;
 
 use crate::{
-    parser, runner, step, writer, ArbitraryWriter, FailureWriter, Parser,
-    Runner, ScenarioType, Step, World, Writer, WriterExt as _,
+    event, parser, runner, step, writer, ArbitraryWriter, FailureWriter,
+    Parser, Runner, ScenarioType, Step, World, Writer, WriterExt as _,
 };
 
 /// Top-level [Cucumber] executor.
@@ -142,14 +142,14 @@ where
     ///
     /// Output with a regular [`Cucumber::run()`]:
     /// <script
-    ///     id="asciicast-Ar8XAtrZWKMNfe7mffBXbQAFb"
-    ///     src="https://asciinema.org/a/Ar8XAtrZWKMNfe7mffBXbQAFb.js"
-    ///     async data-autoplay="true" data-rows="16">
+    ///     id="asciicast-hMyH3IYbHRFXT1yf84tXDNl2r"
+    ///     src="https://asciinema.org/a/hMyH3IYbHRFXT1yf84tXDNl2r.js"
+    ///     async data-autoplay="true" data-rows="17">
     /// </script>
     ///
     /// To fail all the [`Skipped`] steps setup [`Cucumber`] like this:
-    /// ```rust
-    /// # use std::{convert::Infallible, panic::AssertUnwindSafe};
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
     /// #
     /// # use async_trait::async_trait;
     /// # use cucumber::WorldInit;
@@ -174,7 +174,7 @@ where
     ///     .await;
     /// # };
     /// #
-    /// # futures::executor::block_on(AssertUnwindSafe(fut).catch_unwind());
+    /// # futures::executor::block_on(fut);
     /// ```
     /// <script
     ///     id="asciicast-UsaG9kMnn40nW8y4vcmXOE2tT"
@@ -222,15 +222,15 @@ where
     ///
     /// Output with a regular [`Cucumber::run()`]:
     /// <script
-    ///     id="asciicast-Ar8XAtrZWKMNfe7mffBXbQAFb"
-    ///     src="https://asciinema.org/a/Ar8XAtrZWKMNfe7mffBXbQAFb.js"
-    ///     async data-autoplay="true" data-rows="16">
+    ///     id="asciicast-hMyH3IYbHRFXT1yf84tXDNl2r"
+    ///     src="https://asciinema.org/a/hMyH3IYbHRFXT1yf84tXDNl2r.js"
+    ///     async data-autoplay="true" data-rows="17">
     /// </script>
     ///
     /// Adjust [`Cucumber`] to fail on all [`Skipped`] steps, but the ones
     /// marked with `@dog` tag:
-    /// ```rust
-    /// # use std::{convert::Infallible, panic::AssertUnwindSafe};
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
     /// #
     /// # use async_trait::async_trait;
     /// # use futures::FutureExt as _;
@@ -250,12 +250,12 @@ where
     /// #
     /// # let fut = async {
     /// MyWorld::cucumber()
-    ///     .fail_on_skipped_with(|_, _, sc| sc.tags.iter().any(|t| t == "dog"))
+    ///     .fail_on_skipped_with(|_, _, s| !s.tags.iter().any(|t| t == "dog"))
     ///     .run_and_exit("tests/features/readme")
     ///     .await;
     /// # };
     /// #
-    /// # futures::executor::block_on(AssertUnwindSafe(fut).catch_unwind());
+    /// # futures::executor::block_on(fut);
     /// ```
     /// ```gherkin
     /// Feature: Animal feature
@@ -315,6 +315,285 @@ where
             _parser_input: PhantomData,
         }
     }
+
+    /// Re-outputs [`Skipped`] steps for easier navigation.
+    ///
+    /// # Example
+    ///
+    /// Output with a regular [`Cucumber::run()`]:
+    /// <script
+    ///     id="asciicast-hMyH3IYbHRFXT1yf84tXDNl2r"
+    ///     src="https://asciinema.org/a/hMyH3IYbHRFXT1yf84tXDNl2r.js"
+    ///     async data-autoplay="true" data-rows="17">
+    /// </script>
+    ///
+    /// Adjust [`Cucumber`] to re-output all [`Skipped`] steps at the end:
+    /// ```rust
+    /// # use std::convert::Infallible;
+    /// #
+    /// # use async_trait::async_trait;
+    /// # use futures::FutureExt as _;
+    /// # use cucumber::WorldInit;
+    /// #
+    /// # #[derive(Debug, WorldInit)]
+    /// # struct MyWorld;
+    /// #
+    /// # #[async_trait(?Send)]
+    /// # impl cucumber::World for MyWorld {
+    /// #     type Error = Infallible;
+    /// #
+    /// #     async fn new() -> Result<Self, Self::Error> {
+    /// #         Ok(Self)
+    /// #     }
+    /// # }
+    /// #
+    /// # let fut = async {
+    /// MyWorld::cucumber()
+    ///     .repeat_skipped()
+    ///     .run_and_exit("tests/features/readme")
+    ///     .await;
+    /// # };
+    /// #
+    /// # futures::executor::block_on(fut);
+    /// ```
+    /// <script
+    ///     id="asciicast-BD1mPjYGELD6oWNKW8lTlyvDR"
+    ///     src="https://asciinema.org/a/BD1mPjYGELD6oWNKW8lTlyvDR.js"
+    ///     async data-autoplay="true" data-rows="19">
+    /// </script>
+    ///
+    /// [`Scenario`]: gherkin::Scenario
+    /// [`Skipped`]: crate::event::Step::Skipped
+    #[must_use]
+    pub fn repeat_skipped(self) -> Cucumber<W, P, I, R, writer::Repeat<W, Wr>> {
+        Cucumber {
+            parser: self.parser,
+            runner: self.runner,
+            writer: self.writer.repeat_skipped(),
+            _world: PhantomData,
+            _parser_input: PhantomData,
+        }
+    }
+
+    /// Re-outputs [`Failed`] steps for easier navigation.
+    ///
+    /// # Example
+    ///
+    /// Output with a regular [`Cucumber::fail_on_skipped()`]:
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
+    /// #
+    /// # use async_trait::async_trait;
+    /// # use futures::FutureExt as _;
+    /// # use cucumber::WorldInit;
+    /// #
+    /// # #[derive(Debug, WorldInit)]
+    /// # struct MyWorld;
+    /// #
+    /// # #[async_trait(?Send)]
+    /// # impl cucumber::World for MyWorld {
+    /// #     type Error = Infallible;
+    /// #
+    /// #     async fn new() -> Result<Self, Self::Error> {
+    /// #         Ok(Self)
+    /// #     }
+    /// # }
+    /// #
+    /// # let fut = async {
+    /// MyWorld::cucumber()
+    ///     .fail_on_skipped()
+    ///     .run_and_exit("tests/features/readme")
+    ///     .await;
+    /// # };
+    /// #
+    /// # futures::executor::block_on(fut);
+    /// ```
+    /// <script
+    ///     id="asciicast-mDDqxWHzUaK19P0L2R2g4XRp2"
+    ///     src="https://asciinema.org/a/mDDqxWHzUaK19P0L2R2g4XRp2.js"
+    ///     async data-autoplay="true" data-rows="21">
+    /// </script>
+    ///
+    /// Adjust [`Cucumber`] to re-output all [`Failed`] steps at the end:
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
+    /// #
+    /// # use async_trait::async_trait;
+    /// # use futures::FutureExt as _;
+    /// # use cucumber::WorldInit;
+    /// #
+    /// # #[derive(Debug, WorldInit)]
+    /// # struct MyWorld;
+    /// #
+    /// # #[async_trait(?Send)]
+    /// # impl cucumber::World for MyWorld {
+    /// #     type Error = Infallible;
+    /// #
+    /// #     async fn new() -> Result<Self, Self::Error> {
+    /// #         Ok(Self)
+    /// #     }
+    /// # }
+    /// #
+    /// # let fut = async {
+    /// MyWorld::cucumber()
+    ///     .repeat_failed()
+    ///     .fail_on_skipped()
+    ///     .run_and_exit("tests/features/readme")
+    ///     .await;
+    /// # };
+    /// #
+    /// # futures::executor::block_on(fut);
+    /// ```
+    /// <script
+    ///     id="asciicast-qKp8Hevrb6732mMUT7VduvxJc"
+    ///     src="https://asciinema.org/a/qKp8Hevrb6732mMUT7VduvxJc.js"
+    ///     async data-autoplay="true" data-rows="24">
+    /// </script>
+    ///
+    /// > ⚠️ __WARNING__: [`Cucumber::repeat_failed()`] should be called before
+    ///                   [`Cucumber::fail_on_skipped()`], as events pass from
+    ///                   outer [`Writer`]s to inner ones. So we need to
+    ///                   transform [`Skipped`] to [`Failed`] first, and only
+    ///                   then [`Repeat`] them.
+    ///
+    /// [`Failed`]: crate::event::Step::Failed
+    /// [`Repeat`]: writer::Repeat
+    /// [`Scenario`]: gherkin::Scenario
+    /// [`Skipped`]: crate::event::Step::Skipped
+    #[must_use]
+    pub fn repeat_failed(self) -> Cucumber<W, P, I, R, writer::Repeat<W, Wr>> {
+        Cucumber {
+            parser: self.parser,
+            runner: self.runner,
+            writer: self.writer.repeat_failed(),
+            _world: PhantomData,
+            _parser_input: PhantomData,
+        }
+    }
+
+    /// Re-output steps by the given `filter` predicate.
+    ///
+    /// # Example
+    ///
+    /// Output with a regular [`Cucumber::fail_on_skipped()`]:
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
+    /// #
+    /// # use async_trait::async_trait;
+    /// # use futures::FutureExt as _;
+    /// # use cucumber::WorldInit;
+    /// #
+    /// # #[derive(Debug, WorldInit)]
+    /// # struct MyWorld;
+    /// #
+    /// # #[async_trait(?Send)]
+    /// # impl cucumber::World for MyWorld {
+    /// #     type Error = Infallible;
+    /// #
+    /// #     async fn new() -> Result<Self, Self::Error> {
+    /// #         Ok(Self)
+    /// #     }
+    /// # }
+    /// #
+    /// # let fut = async {
+    /// MyWorld::cucumber()
+    ///     .fail_on_skipped()
+    ///     .run_and_exit("tests/features/readme")
+    ///     .await;
+    /// # };
+    /// #
+    /// # futures::executor::block_on(fut);
+    /// ```
+    /// <script
+    ///     id="asciicast-mDDqxWHzUaK19P0L2R2g4XRp2"
+    ///     src="https://asciinema.org/a/mDDqxWHzUaK19P0L2R2g4XRp2.js"
+    ///     async data-autoplay="true" data-rows="21">
+    /// </script>
+    ///
+    /// Adjust [`Cucumber`] to re-output all [`Failed`] steps ta the end by
+    /// providing a custom `filter` predicate:
+    /// ```rust,should_panic
+    /// # use std::convert::Infallible;
+    /// #
+    /// # use async_trait::async_trait;
+    /// # use futures::FutureExt as _;
+    /// # use cucumber::WorldInit;
+    /// #
+    /// # #[derive(Debug, WorldInit)]
+    /// # struct MyWorld;
+    /// #
+    /// # #[async_trait(?Send)]
+    /// # impl cucumber::World for MyWorld {
+    /// #     type Error = Infallible;
+    /// #
+    /// #     async fn new() -> Result<Self, Self::Error> {
+    /// #         Ok(Self)
+    /// #     }
+    /// # }
+    /// #
+    /// # let fut = async {
+    /// MyWorld::cucumber()
+    ///     .repeat_if(|ev| {
+    ///         use cucumber::event::{Cucumber, Feature, Rule, Scenario, Step};
+    ///
+    ///         matches!(
+    ///             ev,
+    ///             Ok(Cucumber::Feature(
+    ///                 _,
+    ///                 Feature::Rule(
+    ///                     _,
+    ///                     Rule::Scenario(
+    ///                         _,
+    ///                         Scenario::Step(_, Step::Failed(..))
+    ///                             | Scenario::Background(_, Step::Failed(..))
+    ///                     )
+    ///                 ) | Feature::Scenario(
+    ///                     _,
+    ///                     Scenario::Step(_, Step::Failed(..))
+    ///                         | Scenario::Background(_, Step::Failed(..))
+    ///                 )
+    ///             )) | Err(_)
+    ///         )
+    ///     })
+    ///     .fail_on_skipped()
+    ///     .run_and_exit("tests/features/readme")
+    ///     .await;
+    /// # };
+    /// #
+    /// # futures::executor::block_on(fut);
+    /// ```
+    /// <script
+    ///     id="asciicast-qKp8Hevrb6732mMUT7VduvxJc"
+    ///     src="https://asciinema.org/a/qKp8Hevrb6732mMUT7VduvxJc.js"
+    ///     async data-autoplay="true" data-rows="24">
+    /// </script>
+    ///
+    /// > ⚠️ __WARNING__: [`Cucumber::repeat_if()`] should be called before
+    ///                   [`Cucumber::fail_on_skipped()`], as events pass from
+    ///                   outer [`Writer`]s to inner ones. So we need to
+    ///                   transform [`Skipped`] to [`Failed`] first, and only
+    ///                   then [`Repeat`] them.
+    ///
+    /// [`Failed`]: crate::event::Step::Failed
+    /// [`Repeat`]: writer::Repeat
+    /// [`Scenario`]: gherkin::Scenario
+    /// [`Skipped`]: crate::event::Step::Skipped
+    #[must_use]
+    pub fn repeat_if<F>(
+        self,
+        filter: F,
+    ) -> Cucumber<W, P, I, R, writer::Repeat<W, Wr, F>>
+    where
+        F: Fn(&parser::Result<event::Cucumber<W>>) -> bool,
+    {
+        Cucumber {
+            parser: self.parser,
+            runner: self.runner,
+            writer: self.writer.repeat_if(filter),
+            _world: PhantomData,
+            _parser_input: PhantomData,
+        }
+    }
 }
 
 impl<W, P, I, R, Wr> Cucumber<W, P, I, R, Wr>