Implement tag filtering with limits

lib/cucumber/core/test/filters.rb

@@ -1,3 +1,4 @@
+require 'cucumber/core/test/filters/tag_filter'
 module Cucumber
   module Core
     module Test
@@ -42,23 +43,6 @@ def accept?(test_case)
           name_regexps.empty? || name_regexps.any? { |name_regexp| test_case.match_name?(name_regexp) }
         end
       end
-
-      class TagFilter
-        include Cucumber.initializer(:filter_expressions, :receiver)
-
-        def test_case(test_case)
-          if test_case.match_tags?(filter_expressions)
-            test_case.describe_to(receiver)
-          end
-          self
-        end
-
-        def done
-          @receiver.done
-          self
-        end
-      end
-
     end
   end
 end

lib/cucumber/core/test/filters/tag_filter.rb

@@ -0,0 +1,110 @@
+module Cucumber
+  module Core
+    module Test
+      class TagFilter
+        include Cucumber.initializer(:filter_expressions, :receiver)
+
+        def test_case(test_case)
+          test_cases << test_case
+          if test_case.match_tags?(filter_expressions)
+            test_case.describe_to(receiver)
+          end
+          self
+        end
+
+        def done
+          tag_limits.enforce(test_cases)
+          receiver.done
+          self
+        end
+
+        private
+        def test_cases
+          @test_cases ||= TestCases.new
+        end
+
+        def tag_limits
+          @tag_limits ||= TagLimits.new(filter_expressions)
+        end
+
+        class TestCases
+          attr_reader :test_cases_by_tag_name
+          private :test_cases_by_tag_name
+          def initialize
+            @test_cases_by_tag_name = Hash.new { [] }
+          end
+
+          def <<(test_case)
+            test_case.tags.each do |tag|
+              test_cases_by_tag_name[tag.name] += [test_case]
+            end
+            self
+          end
+
+          def with_tag_name(tag_name)
+            test_cases_by_tag_name[tag_name]
+          end
+        end
+
+        class TagLimits
+          TAG_MATCHER = /^
+            (?:~)?                 #The tag negation symbol "~". This is optional and not captured.
+            (?<tag_name>\@[\w\d]+) #Captures the tag name including the "@" symbol.
+            \:                     #The seperator, ":", between the tag name and the limit.
+            (?<limit>\d+)          #Caputres the limit number.
+          $/x
+
+          attr_reader :limit_list
+          private :limit_list
+          def initialize(filter_expressions)
+            @limit_list = Array(filter_expressions).flat_map do |raw_expression|
+              raw_expression.split(/\s*,\s*/)
+            end.map do |filter_expression|
+              TAG_MATCHER.match(filter_expression)
+            end.compact.each_with_object({}) do |matchdata, limit_list|
+              limit_list[matchdata[:tag_name]] = Integer(matchdata[:limit])
+            end
+          end
+
+          def enforce(test_cases)
+            limit_breaches = limit_list.reduce([]) do |breaches, (tag_name, limit)|
+              tag_count = test_cases.with_tag_name(tag_name).count
+              if tag_count > limit
+                tag_locations = test_cases.with_tag_name(tag_name).map(&:location)
+                breaches << TagLimitBreach.new(
+                  tag_count,
+                  limit,
+                  tag_name,
+                  tag_locations
+                )
+              end
+              breaches
+            end
+            raise TagExcess.new(limit_breaches) if limit_breaches.any?
+            self
+          end
+        end
+
+        TagLimitBreach = Struct.new(
+          :tag_count,
+          :tag_limit,
+          :tag_name,
+          :tag_locations
+        ) do
+
+          def message
+            "#{tag_name} occurred #{tag_count} times, but the limit was set to #{tag_limit}\n  " +
+              tag_locations.map(&:to_s).join("\n  ")
+          end
+          alias :to_s :message
+        end
+
+        class TagExcess < StandardError
+          def initialize(limit_breaches)
+            super(limit_breaches.map(&:to_s).join("\n"))
+          end
+        end
+      end
+    end
+  end
+end

spec/cucumber/core_spec.rb

@@ -82,6 +82,127 @@ module Cucumber
 
         compile [gherkin], visitor, [[Cucumber::Core::Test::TagFilter, [['@a', '@b']]]]
       end
+
+      describe 'with tag filters that have limits' do
+        let(:visitor) { double.as_null_object }
+        let(:gherkin_doc) do
+          gherkin do
+            feature tags: '@feature' do
+              scenario tags: '@one @three' do
+                step
+              end
+
+              scenario tags: '@one' do
+                step
+              end
+
+              scenario_outline  do
+                step '<arg>'
+
+                examples tags: '@three'do
+                  row 'arg'
+                  row 'x'
+                end
+              end
+
+              scenario tags: '@ignore' do
+                step
+              end
+            end
+          end
+        end
+
+        require 'unindent'
+        def expect_tag_excess(error_message)
+          expect {
+            compile [gherkin_doc], visitor, tag_filters
+          }.to raise_error(
+            Cucumber::Core::Test::TagFilter::TagExcess, error_message.unindent.chomp
+          )
+        end
+
+        context 'on scenarios' do
+          let(:tag_filters) {
+            [[Cucumber::Core::Test::TagFilter, [['@one:1']]]]
+          }
+
+          it 'raises a tag excess error with the location of the test cases' do
+            expect_tag_excess <<-STR
+              @one occurred 2 times, but the limit was set to 1
+                features/test.feature:5
+                features/test.feature:9
+            STR
+          end
+        end
+
+        context 'on scenario outlines' do
+          let(:tag_filters) {
+            [[Cucumber::Core::Test::TagFilter, [['@three:1']]]]
+          }
+
+          it 'raises a tag excess error with the location of the test cases' do
+            expect_tag_excess <<-STR
+              @three occurred 2 times, but the limit was set to 1
+                features/test.feature:5
+                features/test.feature:18
+            STR
+          end
+        end
+
+        context 'on a feature with scenarios' do
+          let(:tag_filters) {
+            [[Cucumber::Core::Test::TagFilter, [['@feature:2']]]]
+          }
+
+          it 'raises a tag excess error with the location of the test cases' do
+            expect_tag_excess <<-STR
+              @feature occurred 4 times, but the limit was set to 2
+                features/test.feature:5
+                features/test.feature:9
+                features/test.feature:18
+                features/test.feature:21
+            STR
+          end
+        end
+
+        context 'with negated tags' do
+          let(:tag_filters) {
+            [[Cucumber::Core::Test::TagFilter, [['~@one:1']]]]
+          }
+
+          it 'raises a tag excess error with the location of the test cases' do
+            expect_tag_excess <<-STR
+              @one occurred 2 times, but the limit was set to 1
+                features/test.feature:5
+                features/test.feature:9
+            STR
+          end
+        end
+
+        context 'whith multiple tag limits' do
+          let(:tag_filters) {
+            [[Cucumber::Core::Test::TagFilter, [['@one:1, @three:1', '~@feature:3']]]]
+          }
+
+          it 'raises a tag excess error with the location of the test cases' do
+            expect_tag_excess <<-STR
+              @one occurred 2 times, but the limit was set to 1
+                features/test.feature:5
+                features/test.feature:9
+              @three occurred 2 times, but the limit was set to 1
+                features/test.feature:5
+                features/test.feature:18
+              @feature occurred 4 times, but the limit was set to 3
+                features/test.feature:5
+                features/test.feature:9
+                features/test.feature:18
+                features/test.feature:21
+            STR
+          end
+        end
+
+      end
+
     end
 
     describe "executing a test suite" do