Merge tags from Feature and Rule with Scenario on filtering (#156)

CHANGELOG.md

@@ -16,6 +16,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th
 - Moved `World` type parameter of `WriterExt` trait to methods. ([#160])
 - Renamed `Normalized` and `Summarized` `Writer`s to `Normalize` and `Summarize`. ([#162])
 - Removed `writer::Basic` `Default` impl and change `writer::Basic::new()` return type to `writer::Normalize<writer::Basic>`. ([#162])
+- Merge tags from `Feature` and `Rule` with `Scenario` on filtering with `--tags` CLI option. ([#166])
 
 ### Added
 
@@ -42,6 +43,7 @@ All user visible changes to `cucumber` crate will be documented in this file. Th
 [#160]: /../../pull/160
 [#162]: /../../pull/162
 [#163]: /../../pull/163
+[#166]: /../../pull/166
 [0110-1]: https://llg.cubic.org/docs/junit
 [0110-2]: https://github.com/cucumber/cucumber-json-schema
 

book/src/Features.md

@@ -448,7 +448,9 @@ OPTIONS:
     -c, --concurrency <int>            Number of scenarios to run concurrently. If not specified, uses the value
                                        configured in tests runner, or 64 by default
     -n, --name <regex>                 Regex to filter scenarios by their name [aliases: scenario-name]
-    -t, --tags <tagexpr>               Tag expression to filter scenarios by [aliases: scenario-tags]
+    -t, --tags <tagexpr>               Tag expression to filter scenarios by.
+                                       Note: Tags from Feature, Rule and Scenario are merged together on filtering, 
+                                       so be careful about conflicting tags on different levels. 
 ```
 
 Example with [tag expressions](https://cucumber.io/docs/cucumber/api#tag-expressions) for filtering `Scenario`s:

src/cli.rs

@@ -113,11 +113,13 @@ where
     pub re_filter: Option<Regex>,
 
     /// Tag expression to filter scenarios by.
+    ///
+    /// Note: Tags from Feature, Rule and Scenario are merged together on
+    /// filtering, so be careful about conflicting tags on different levels.
     #[structopt(
         short = "t",
         long = "tags",
         name = "tagexpr",
-        visible_alias = "scenario-tags",
         conflicts_with = "regex"
     )]
     pub tags_filter: Option<TagOperation>,

src/cucumber.rs

@@ -818,11 +818,22 @@ where
                            s: &gherkin::Scenario| {
             re_filter.as_ref().map_or_else(
                 || {
-                    tags_filter
-                        .as_ref()
-                        .map_or_else(|| filter(f, r, s), |f| f.eval(&s.tags))
+                    tags_filter.as_ref().map_or_else(
+                        || filter(f, r, s),
+                        |tags| {
+                            tags.eval(
+                                f.tags
+                                    .iter()
+                                    .chain(
+                                        r.into_iter()
+                                            .flat_map(|r| r.tags.iter()),
+                                    )
+                                    .chain(s.tags.iter()),
+                            )
+                        },
+                    )
                 },
-                |f| f.is_match(&s.name),
+                |re| re.is_match(&s.name),
             )
         };
 

src/tag.rs

@@ -18,17 +18,24 @@ use sealed::sealed;
 pub trait Ext {
     /// Evaluates this [`TagOperation`] for the given `tags`.
     #[must_use]
-    fn eval(&self, tags: &[String]) -> bool;
+    fn eval<I, S>(&self, tags: I) -> bool
+    where
+        S: AsRef<str>,
+        I: Iterator<Item = S> + Clone;
 }
 
 #[sealed]
 impl Ext for TagOperation {
-    fn eval(&self, tags: &[String]) -> bool {
+    fn eval<I, S>(&self, mut tags: I) -> bool
+    where
+        S: AsRef<str>,
+        I: Iterator<Item = S> + Clone,
+    {
         match self {
-            Self::And(l, r) => l.eval(tags) & r.eval(tags),
-            Self::Or(l, r) => l.eval(tags) | r.eval(tags),
+            Self::And(l, r) => l.eval(tags.clone()) & r.eval(tags),
+            Self::Or(l, r) => l.eval(tags.clone()) | r.eval(tags),
             Self::Not(t) => !t.eval(tags),
-            Self::Tag(t) => tags.iter().any(|tag| tag == t),
+            Self::Tag(t) => tags.any(|tag| tag.as_ref() == t),
         }
     }
 }