cucumber-core 1.3.0 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f56999cf96221b9de93c823a5559efeb56bfb34
-  data.tar.gz: 1e955adc2d60f414a53e6775d0e6adc44b4eafa5
+  metadata.gz: 25825fee710c84b86d2a37eed2006660a2a60df0
+  data.tar.gz: 4515e946a6558a3aa42509da7380f61782b7e43f
 SHA512:
-  metadata.gz: 529edb34199a3bea271b93d0f09de3e4b2c24dc7f4c198ff553fe029b7d0b5c1a7a4a18d744586725351d5e1f9795c6caec1e8e35b64e2c77eab858ad3d8052e
-  data.tar.gz: 42aa0c463801d3aaba42d95c2bbdd0519a8d5344da0ef6c594d7a6bd704329947c5265aea47e3eee601e20c043fac8ca31b25afc5e75a9d1630b85ead562bd80
+  metadata.gz: a1fa91c0ea24501ab7d57a14c456e39eee87ced703456076e9b8dc16c191697d27fbeab1e75bd85bd769983bdbd5f4d14e80aeafb8d04e12175943203f06a24b
+  data.tar.gz: e4aff4a98a4702419bc43a5818ec3253deb5a075c71fcadb9f10826cbd3376199132cf65ad3b16761b11785e45bfffea5c94180756c033231dcb00fee0e20f1e

data/.rspec

@@ -1 +1 @@
---color
+--color --tag ~slow

data/.travis.yml

@@ -1,3 +1,5 @@
+sudo: false
+
 rvm:
   - 2.2
   - 2.1
@@ -13,5 +15,6 @@ branches:
 notifications:
   email:
     - cukes-devs@googlegroups.com
-  irc:
-    - "irc.freenode.org#cucumber"
+  webhooks:
+    urls: # gitter
+      - https://webhooks.gitter.im/e/dc010332f9d40fcc21c4

data/HISTORY.md

@@ -1,4 +1,18 @@
-## [In Git](https://github.com/cucumber/cucumber-ruby-core/compare/v1.2.0...master)
+## [In Git](https://github.com/cucumber/cucumber-ruby-core/compare/v1.3.0...master)
+
+### New Features
+
+### Bugfixes
+
+## [v1.3.1](https://github.com/cucumber/cucumber-ruby-core/compare/v1.3.0...v1.3.1)
+
+### New Features
+
+### Bugfixes
+
+ * Speed up location filtering ([99](https://github.com/cucumber/cucumber-ruby-core/issues/99) @mattwynne @akostadinov @brasmusson)
+
+## [v1.3.0](https://github.com/cucumber/cucumber-ruby-core/compare/v1.2.0...v1.3.0)
 
 ### New Features
 

data/README.md

@@ -1,11 +1,12 @@
 # cucumber-core
 
+[![Chat with us](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/cucumber/cucumber-ruby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Build Status](https://secure.travis-ci.org/cucumber/cucumber-ruby-core.png)](http://travis-ci.org/cucumber/cucumber-ruby-core)
 [![Code Climate](https://codeclimate.com/github/cucumber/cucumber-ruby-core.png)](https://codeclimate.com/github/cucumber/cucumber-ruby-core)
 [![Coverage Status](https://coveralls.io/repos/cucumber/cucumber-ruby-core/badge.png?branch=master)](https://coveralls.io/r/cucumber/cucumber-ruby-core?branch=master)
 [![Dependency Status](https://gemnasium.com/cucumber/cucumber-ruby-core.png)](https://gemnasium.com/cucumber/cucumber-ruby-core)
 
-Cucumber Core is the [inner hexagon](http://alistair.cockburn.us/Hexagonal+architecture) for the [Ruby flavour of Cucumber](https://github.com/cucumber/cucumber).
+Cucumber Core is the [inner hexagon](http://alistair.cockburn.us/Hexagonal+architecture) for the [Ruby flavour of Cucumber](https://github.com/cucumber/cucumber-ruby).
 
 It contains the core domain logic to execute Cucumber features. It has no user interface, just a Ruby API. If you're interested in how Cucumber works, or in building other tools that work with Gherkin documents, you've come to the right place.
 

data/Rakefile

@@ -8,7 +8,6 @@ $:.unshift File.expand_path("../lib", __FILE__)
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec) do |t|
   t.ruby_opts  = %w[-r./spec/coverage -w]
-  t.rspec_opts = %w[--color]
 end
 
 require_relative 'spec/capture_warnings'
@@ -19,6 +18,11 @@ namespace :spec do
       Rake::Task['spec'].invoke
     end
   end
+
+  desc "run (slow) performance tests"
+  RSpec::Core::RakeTask.new(:slow) do |t|
+    t.rspec_opts = %w[--tag slow]
+  end
 end
 
-task default: ['spec:warnings']
+task default: ['spec:warnings', 'spec:slow']

data/lib/cucumber/core/ast/empty_multiline_argument.rb

@@ -18,8 +18,8 @@ module Cucumber
           self
         end
 
-        def match_locations?(*args)
-          false
+        def all_locations
+          []
         end
 
         def to_sexp

data/lib/cucumber/core/ast/feature.rb

@@ -66,6 +66,7 @@ module Cucumber
         end
       end
 
+      require 'delegate'
       class LanguageDelegator < SimpleDelegator
         attr_reader :iso_code
 

data/lib/cucumber/core/ast/location.rb

@@ -3,15 +3,9 @@ require 'cucumber/core/platform'
 module Cucumber
   module Core
     module Ast
-      class Location < Struct.new(:filepath, :lines)
-        WILDCARD = :*
+      IncompatibleLocations = Class.new(StandardError)
 
-        extend Forwardable
-
-        def_delegator :lines,    :include?
-        def_delegator :lines,    :line
-        def_delegator :filepath, :same_as?
-        def_delegator :filepath, :filename, :file
+      module Location
 
         def self.of_caller(additional_depth = 0)
           from_file_colon_line(*caller[1 + additional_depth])
@@ -34,62 +28,100 @@ module Cucumber
           new(file, line)
         end
 
-        def initialize(filepath, raw_lines=WILDCARD)
-          filepath || raise(ArgumentError, "file is mandatory")
-          super(FilePath.new(filepath), Lines.new(raw_lines))
+        def self.new(file, raw_lines=nil)
+          file || raise(ArgumentError, "file is mandatory")
+          if raw_lines
+            Precise.new(file, Lines.new(raw_lines))
+          else
+            Wildcard.new(file)
+          end
         end
 
-        def match?(other)
-          other.same_as?(filepath) && other.include?(lines)
+        def self.merge(*locations)
+          locations.reduce do |a, b|
+            a + b
+          end
         end
 
-        def to_s
-          [filepath.to_s, lines.to_s].reject { |v| v == WILDCARD.to_s }.join(":")
-        end
+        class Wildcard < Struct.new(:file)
+          def to_s
+            file
+          end
 
-        def hash
-          self.class.hash ^ to_s.hash
-        end
+          def match?(other)
+            other.file == file
+          end
 
-        def to_str
-          to_s
+          def include?(lines)
+            true
+          end
         end
 
-        def on_line(new_line)
-          Location.new(filepath.filename, new_line)
-        end
+        class Precise < Struct.new(:file, :lines)
+          def include?(other_lines)
+            lines.include?(other_lines)
+          end
 
-        def inspect
-          "<#{self.class}: #{to_s}>"
-        end
+          def line
+            lines.first
+          end
 
-        class FilePath < Struct.new(:filename)
-          def same_as?(other)
-            filename == other.filename
+          def match?(other)
+            return false unless other.file == file
+            other.include?(lines)
           end
 
           def to_s
-            filename
+            [file, lines.to_s].join(":")
+          end
+
+          def hash
+            self.class.hash ^ to_s.hash
+          end
+
+          def to_str
+            to_s
+          end
+
+          def on_line(new_line)
+            Location.new(file, new_line)
+          end
+
+          def +(other)
+            raise IncompatibleLocations if file != other.file
+            Precise.new(file, lines + other.lines)
+          end
+
+          def inspect
+            "<#{self.class}: #{to_s}>"
           end
         end
 
         require 'set'
         class Lines < Struct.new(:data)
           protected :data
-          attr_reader :line
 
           def initialize(raw_data)
             super Array(raw_data).to_set
-            @line = data.first
+          end
+
+          def first
+            data.first
           end
 
           def include?(other)
-            return true if (data|other.data).include?(WILDCARD)
             other.data.subset?(data) || data.subset?(other.data)
           end
 
+          def +(more_lines)
+            new_data = data + more_lines.data
+            self.class.new(new_data)
+          end
+
           def to_s
-            boundary.join('..')
+            return first.to_s if data.length == 1
+            return "#{data.min}..#{data.max}" if range?
+            data.to_a.join(":")
           end
 
           def inspect
@@ -98,20 +130,8 @@ module Cucumber
 
           protected
 
-          def boundary
-            first_and_last(value).uniq
-          end
-
-          def at_index(idx)
-            data.to_a[idx]
-          end
-
-          def value
-            method :at_index
-          end
-
-          def first_and_last(something)
-            [0, -1].map(&something)
+          def range?
+            data.size == (data.max - data.min + 1)
           end
         end
       end
@@ -134,9 +154,8 @@ module Cucumber
           @location
         end
 
-        def match_locations?(queried_locations)
-          return true if attributes.any? { |node| node.match_locations? queried_locations }
-          queried_locations.any? { |queried_location| queried_location.match? location }
+        def all_locations
+          @all_locations ||= Location.merge([location] + attributes.map { |node| node.all_locations }.flatten)
         end
 
         def attributes

data/lib/cucumber/core/ast/names.rb

@@ -4,11 +4,6 @@ module Cucumber
       module Names
         attr_reader :description, :name
 
-        def title
-          warn("deprecated. Use #name")
-          name
-        end
-
         def legacy_conflated_name_and_description
           s = name
           s += "\n#{@description}" if @description != ""

data/lib/cucumber/core/ast/step.rb

@@ -56,11 +56,8 @@ module Cucumber
           @outline_step, @language, @location, @comments, @keyword, @name, @multiline_arg = outline_step, language, location, comments, keyword, name, multiline_arg
         end
 
-        alias :self_match_locations? :match_locations?
-
-        def match_locations?(queried_locations)
-          return true if self_match_locations?(queried_locations) 
-          @outline_step.match_locations?(queried_locations)
+        def all_locations
+          @outline_step.all_locations
         end
 
         alias :step_backtrace_line :backtrace_line

data/lib/cucumber/core/test/case.rb

@@ -1,5 +1,6 @@
 require 'cucumber/core/test/result'
 require 'cucumber/core/gherkin/tag_expression'
+require 'cucumber/core/ast/location'
 
 module Cucumber
   module Core
@@ -73,8 +74,21 @@ module Cucumber
         end
 
         def match_locations?(queried_locations)
-          return true if source.any? { |s| s.match_locations?(queried_locations) }
-          test_steps.any? { |node| node.match_locations? queried_locations }
+          queried_locations.any? { |queried_location|
+            all_source.any? { |node|
+              node.all_locations.any? { |location|
+                queried_location.match? location
+              }
+            }
+          }
+        end
+
+        def all_locations
+          @all_locations ||= Ast::Location.merge(all_source.map(&:all_locations).flatten)
+        end
+
+        def all_source
+          @all_source ||= (source + test_steps.map(&:source)).flatten.uniq
         end
 
         def inspect

data/lib/cucumber/core/test/filters/locations_filter.rb

@@ -5,10 +5,10 @@ module Cucumber
     module Test
 
       # Sorts and filters scenarios based on a list of locations
-      class LocationsFilter < Filter.new(:locations)
+      class LocationsFilter < Filter.new(:filter_locations)
 
         def test_case(test_case)
-          test_cases << test_case
+          test_cases[test_case.location.file] << test_case
           self
         end
 
@@ -23,19 +23,16 @@ module Cucumber
         private
 
         def sorted_test_cases
-          locations.map { |location| test_cases_matching(location) }.flatten
-        end
-
-        def test_cases_matching(location)
-          test_cases.select do |test_case|
-            test_case.match_locations?([location])
-          end
+          filter_locations.map { |filter_location|
+            test_cases[filter_location.file].select { |test_case| 
+              test_case.all_locations.any? { |location| filter_location.match?(location) }
+            }
+          }.flatten.uniq
         end
 
         def test_cases
-          @test_cases ||= []
+          @test_cases ||= Hash.new { |hash, key| hash[key] = [] }
         end
-
       end
     end
   end

data/lib/cucumber/core/test/step.rb

@@ -47,11 +47,6 @@ module Cucumber
           @action.location
         end
 
-        def match_locations?(queried_locations)
-          return true if queried_locations.include? location
-          source.any? { |s| s.match_locations?(queried_locations) }
-        end
-
         def inspect
           "#<#{self.class}: #{location}>"
         end

data/lib/cucumber/core/version.rb

@@ -2,7 +2,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "1.3.0"
+        "1.3.1"
       end
     end
   end

data/spec/cucumber/core/ast/location_spec.rb

@@ -30,14 +30,6 @@ module Cucumber::Core::Ast
       end
     end
 
-    describe "line" do
-      it "is an integer" do
-        expect(Location.new(file, line).line).to be_kind_of(Integer)
-        expect(Location.new(file, 1..2).line).to be_kind_of(Integer)
-        expect(Location.of_caller.line).to be_kind_of(Integer)
-      end
-    end
-
     describe "to_s" do
       it "is file:line for a precise location" do
         expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"
@@ -50,6 +42,10 @@ module Cucumber::Core::Ast
       it "is file:first_line..last_line for a ranged location" do
         expect( Location.new("foo.feature", 13..19).to_s ).to eq "foo.feature:13..19"
       end
+
+      it "is file:line:line:line for an arbitrary set of lines" do
+        expect( Location.new("foo.feature", [1,3,5]).to_s ).to eq "foo.feature:1:3:5"
+      end
     end
 
     describe "matches" do
@@ -120,6 +116,22 @@ module Cucumber::Core::Ast
           expect( range ).not_to be_match(other)
         end
       end
+
+      context "an arbitrary list of lines" do
+        let(:location) { Location.new("foo.feature", [1,5,6,7]) }
+
+        it "matches any of the given lines" do
+          [1,5,6,7].each do |line|
+            other = Location.new("foo.feature", line)
+            expect(location).to be_match(other)
+          end
+        end
+
+        it "does not match another line" do
+          other = Location.new("foo.feature", 2)
+          expect(location).not_to be_match(other)
+        end
+      end
     end
 
     describe "created from source location" do
@@ -160,6 +172,27 @@ module Cucumber::Core::Ast
       end
     end
 
+    describe ".merge" do
+      it "merges locations from the same file" do
+        file = "test.feature"
+        location = Location.merge(
+          Location.new(file, 1),
+          Location.new(file, 6),
+          Location.new(file, 7)
+        )
+        expect(location.to_s).to eq "test.feature:1:6:7"
+      end
+
+      it "raises an error when the locations are from different files" do
+        expect {
+          Location.merge(
+            Location.new("one.feature", 1),
+            Location.new("two.feature", 1)
+          )
+        }.to raise_error(IncompatibleLocations)
+      end
+    end
+
   end
 end
 

data/spec/cucumber/core/ast/step_spec.rb

@@ -148,16 +148,6 @@ module Cucumber
           end
         end
 
-        describe "matching location" do
-          let(:location) { double }
-
-          it "also match the outline steps location" do
-            allow( location).to receive(:any?).and_return(nil)
-            expect( outline_step ).to receive(:match_locations?).with(location)
-            step.match_locations?(location)
-          end
-        end
-
         describe "backtrace line" do
           let(:outline_step) { OutlineStep.new(double, "path/file.feature:5", double, "Given ", "this step <state>", double) }
           let(:step) { ExpandedOutlineStep.new(outline_step, double, "path/file.feature:10", double, "Given ", "this step passes", double) }

data/spec/cucumber/core/test/case_spec.rb

@@ -232,196 +232,6 @@ module Cucumber
           end
         end
 
-        describe "matching location" do
-          let(:file) { 'features/path/to/the.feature' }
-          let(:test_cases) do
-            receiver = double.as_null_object
-            result = []
-            allow( receiver ).to receive(:test_case) { |test_case| result << test_case }
-            compile [source], receiver
-            result
-          end
-
-          context "for a scenario" do
-            let(:source) do
-              Gherkin::Document.new(file, <<-END.unindent)
-                Feature:
-
-                  Scenario: one
-                    Given one a
-
-                  # comment
-                  @tags
-                  Scenario: two
-                    Given two a
-                    And two b
-
-                  Scenario: three
-                    Given three b
-
-                  Scenario: with docstring
-                    Given a docstring
-                      """
-                      this is a docstring
-                      """
-
-                  Scenario: with a table
-                    Given a table
-                      | a | b |
-                      | 1 | 2 |
-
-                  Scenario: empty
-              END
-            end
-
-            let(:test_case) do
-              test_cases.find { |c| c.name == 'two' }
-            end
-
-            it 'matches the precise location of the scenario' do
-              location = Ast::Location.new(file, 8)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it 'matches the precise location of an empty scenario' do
-              empty_scenario_test_case = test_cases.find { |c| c.name == 'empty' }
-              location = Ast::Location.new(file, 26)
-              expect( empty_scenario_test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it 'matches multiple locations' do
-              good_location = Ast::Location.new(file, 8)
-              bad_location = Ast::Location.new(file, 5)
-              expect( test_case.match_locations?([good_location, bad_location]) ).to be_truthy
-            end
-
-            it 'matches a location on the last step of the scenario' do
-              location = Ast::Location.new(file, 10)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "matches a location on the scenario's comment" do
-              location = Ast::Location.new(file, 6)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "matches a location on the scenario's tags" do
-              location = Ast::Location.new(file, 7)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "doesn't match a location after the last step of the scenario" do
-              location = Ast::Location.new(file, 11)
-              expect( test_case.match_locations?([location]) ).to be_falsey
-            end
-
-            it "doesn't match a location before the scenario" do
-              location = Ast::Location.new(file, 5)
-              expect( test_case.match_locations?([location]) ).to be_falsey
-            end
-
-            context "with a docstring" do
-              let(:test_case) do
-                test_cases.find { |c| c.name == 'with docstring' }
-              end
-
-              it "matches a location at the start the docstring" do
-                location = Ast::Location.new(file, 17)
-                expect( test_case.match_locations?([location]) ).to be_truthy
-              end
-
-              it "matches a location in the middle of the docstring" do
-                location = Ast::Location.new(file, 18)
-                expect( test_case.match_locations?([location]) ).to be_truthy
-              end
-
-              it "matches a location at the end of the docstring" do
-                location = Ast::Location.new(file, 19)
-                expect( test_case.match_locations?([location]) ).to be_truthy
-              end
-
-              it "does not match a location after the docstring" do
-                location = Ast::Location.new(file, 20)
-                expect( test_case.match_locations?([location]) ).to be_falsy
-              end
-            end
-
-            context "with a table" do
-              let(:test_case) do
-                test_cases.find { |c| c.name == 'with a table' }
-              end
-
-              it "matches a location on the first table row" do
-                location = Ast::Location.new(file, 23)
-                expect( test_case.match_locations?([location]) ).to be_truthy
-              end
-            end
-          end
-
-          context "for a scenario outline" do
-            let(:source) do
-              Gherkin::Document.new(file, <<-END.unindent)
-                Feature:
-
-                  Scenario: one
-                    Given one a
-
-                  # comment on line 6
-                  @tags-on-line-7
-                  Scenario Outline: two
-                    Given two a
-                    And two <arg>
-
-                    # comment on line 12
-                    @tags-on-line-13
-                    Examples: x1
-                      | arg |
-                      | b   |
-
-                    Examples: x2
-                      | arg |
-                      | c   |
-
-                  Scenario: three
-                    Given three b
-              END
-            end
-
-            let(:test_case) do
-              test_cases.find { |c| c.name == "two, x1 (#1)" }
-            end
-
-            it 'matches the precise location of the scenario outline examples table row' do
-              location = Ast::Location.new(file, 16)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it 'matches a location on a step of the scenario outline' do
-              location = Ast::Location.new(file, 10)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "matches a location on the scenario outline's comment" do
-              location = Ast::Location.new(file, 6)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "matches a location on the scenario outline's tags" do
-              location = Ast::Location.new(file, 7)
-              expect( test_case.match_locations?([location]) ).to be_truthy
-            end
-
-            it "doesn't match a location after the last row of the examples table" do
-              location = Ast::Location.new(file, 17)
-              expect( test_case.match_locations?([location]) ).to be_falsey
-            end
-
-            it "doesn't match a location before the scenario outline" do
-              location = Ast::Location.new(file, 5)
-              expect( test_case.match_locations?([location]) ).to be_falsey
-            end
-          end
-        end
       end
     end
   end

data/spec/cucumber/core/test/filters/locations_filter_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
 require 'cucumber/core/gherkin/writer'
 require 'cucumber/core'
 require 'cucumber/core/test/filters/locations_filter'
 require 'timeout'
+require 'cucumber/core/ast/location'
 
-module Cucumber::Core::Test
-  describe LocationsFilter do
+module Cucumber::Core
+  describe Test::LocationsFilter do
     include Cucumber::Core::Gherkin::Writer
     include Cucumber::Core
 
@@ -26,35 +28,317 @@ module Cucumber::Core::Test
 
     it "sorts by the given locations" do
       locations = [
-        Cucumber::Core::Ast::Location.new('features/test.feature', 6),
-        Cucumber::Core::Ast::Location.new('features/test.feature', 3)
+        Ast::Location.new('features/test.feature', 6),
+        Ast::Location.new('features/test.feature', 3)
       ]
-      filter = LocationsFilter.new(locations)
+      filter = Test::LocationsFilter.new(locations)
       compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq ["features/test.feature:6", "features/test.feature:3"]
+      expect(receiver.test_case_locations).to eq locations
     end
 
     it "works with wildcard locations" do
       locations = [
-        Cucumber::Core::Ast::Location.new('features/test.feature')
+        Ast::Location.new('features/test.feature')
       ]
-      filter = LocationsFilter.new(locations)
+      filter = Test::LocationsFilter.new(locations)
       compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq ["features/test.feature:3", "features/test.feature:6"]
+      expect(receiver.test_case_locations).to eq [
+        Ast::Location.new('features/test.feature', 3),
+        Ast::Location.new('features/test.feature', 6)
+      ]
     end
 
     it "filters out scenarios that don't match" do
       locations = [
-        Cucumber::Core::Ast::Location.new('features/test.feature', 3)
+        Ast::Location.new('features/test.feature', 3)
       ]
-      filter = LocationsFilter.new(locations)
+      filter = Test::LocationsFilter.new(locations)
       compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq ["features/test.feature:3"]
+      expect(receiver.test_case_locations).to eq locations
+    end
+
+    describe "matching location" do
+      let(:file) { 'features/path/to/the.feature' }
+
+      let(:test_cases) do
+        receiver = double.as_null_object
+        result = []
+        allow(receiver).to receive(:test_case) { |test_case| result << test_case }
+        compile [doc], receiver
+        result
+      end
+
+      context "for a scenario" do
+        let(:doc) do
+          Gherkin::Document.new(file, <<-END)
+            Feature:
+
+              Scenario: one
+                Given one a
+
+              # comment
+              @tags
+              Scenario: two
+                Given two a
+                And two b
+
+              Scenario: three
+                Given three b
+
+              Scenario: with docstring
+                Given a docstring
+                  """
+                  this is a docstring
+                  """
+
+              Scenario: with a table
+                Given a table
+                  | a | b |
+                  | 1 | 2 |
+
+              Scenario: empty
+          END
+        end
+
+        def test_case_named(name)
+          test_cases.find { |c| c.name == name }
+        end
+
+        it 'matches the precise location of the scenario' do
+          location = test_case_named('two').location
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
+        end
+
+        it 'matches the precise location of an empty scenario' do
+          location = test_case_named('empty').location
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('empty').location]
+        end
+
+        it 'matches multiple locations' do
+          good_location = Ast::Location.new(file, 8)
+          bad_location = Ast::Location.new(file, 5)
+          filter = Test::LocationsFilter.new([good_location, bad_location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
+        end
+
+        it 'matches a location on the last step of the scenario' do
+          location = Ast::Location.new(file, 10)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
+        end
+
+        it "matches a location on the scenario's comment" do
+          location = Ast::Location.new(file, 6)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
+        end
+
+        it "matches a location on the scenario's tags" do
+          location = Ast::Location.new(file, 7)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
+        end
+
+        it "doesn't match a location after the last step of the scenario" do
+          location = Ast::Location.new(file, 11)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq []
+        end
+
+        it "doesn't match a location before the scenario" do
+          location = Ast::Location.new(file, 5)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq []
+        end
+
+        context "with a docstring" do
+          let(:test_case) do
+            test_cases.find { |c| c.name == 'with docstring' }
+          end
+
+          it "matches a location at the start the docstring" do
+            location = Ast::Location.new(file, 17)
+            filter = Test::LocationsFilter.new([location])
+            compile [doc], receiver, [filter]
+            expect(receiver.test_case_locations).to eq [test_case.location]
+          end
+
+          it "matches a location in the middle of the docstring" do
+            location = Ast::Location.new(file, 18)
+            filter = Test::LocationsFilter.new([location])
+            compile [doc], receiver, [filter]
+            expect(receiver.test_case_locations).to eq [test_case.location]
+          end
+
+          it "matches a location at the end of the docstring" do
+            location = Ast::Location.new(file, 19)
+            filter = Test::LocationsFilter.new([location])
+            compile [doc], receiver, [filter]
+            expect(receiver.test_case_locations).to eq [test_case.location]
+          end
+
+          it "does not match a location after the docstring" do
+            location = Ast::Location.new(file, 20)
+            filter = Test::LocationsFilter.new([location])
+            compile [doc], receiver, [filter]
+            expect(receiver.test_case_locations).to eq []
+          end
+        end
+
+        context "with a table" do
+          let(:test_case) do
+            test_cases.find { |c| c.name == 'with a table' }
+          end
+
+          it "matches a location on the first table row" do
+            location = Ast::Location.new(file, 23)
+            expect( test_case.match_locations?([location]) ).to be_truthy
+          end
+        end
+
+        context "with duplicate locations in the filter" do
+          it "matches each test case only once" do
+            location_tc_two = test_case_named('two').location
+            location_tc_one = test_case_named('one').location
+            location_last_step_tc_two = Ast::Location.new(file, 10)
+            filter = Test::LocationsFilter.new([location_tc_two, location_tc_one, location_last_step_tc_two])
+            compile [doc], receiver, [filter]
+            expect(receiver.test_case_locations).to eq [test_case_named('two').location, location_tc_one = test_case_named('one').location]
+          end
+        end
+      end
+
+      context "for a scenario outline" do
+        let(:doc) do
+          Gherkin::Document.new(file, <<-END)
+            Feature:
+
+              Scenario: one
+                Given one a
+
+              # comment on line 6
+              @tags-on-line-7
+              Scenario Outline: two
+                Given two a
+                And two <arg>
+                  """
+                  docstring
+                  """
+
+                # comment on line 15
+                @tags-on-line-16
+                Examples: x1
+                  | arg |
+                  | b   |
+
+                Examples: x2
+                  | arg |
+                  | c   |
+                  | d   |
+
+              Scenario: three
+                Given three b
+          END
+        end
+
+        let(:test_case) do
+          test_cases.find { |c| c.name == "two, x1 (#1)" }
+        end
+
+        it "matches row location to the test case of the row" do
+          locations = [
+            Ast::Location.new(file, 19),
+          ]
+          filter = Test::LocationsFilter.new(locations)
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq [test_case.location]
+        end
+
+        it "matches examples location with all test cases of the table" do
+          locations = [
+            Ast::Location.new(file, 21),
+          ]
+          filter = Test::LocationsFilter.new(locations)
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations.map(&:line)).to eq [23, 24]
+        end
+
+        it "matches outline location with the all test cases of all the tables" do
+          locations = [
+            Ast::Location.new(file, 8),
+          ]
+          filter = Test::LocationsFilter.new(locations)
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations.map(&:line)).to eq [19, 23, 24]
+        end
+
+        it "matches outline step location the all test cases of all the tables" do
+          locations = [
+            Ast::Location.new(file, 10)
+          ]
+          filter = Test::LocationsFilter.new(locations)
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations.map(&:line)).to eq [19, 23, 24]
+        end
+
+        it 'matches a location on a step of the scenario outline' do
+          location = Ast::Location.new(file, 10)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to include test_case.location
+        end
+
+        it 'matches a location on the docstring of a step of the scenario outline' do
+          location = Ast::Location.new(file, 12)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to include test_case.location
+        end
+
+        it "matches a location on the scenario outline's comment" do
+          location = Ast::Location.new(file, 6)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to include test_case.location
+        end
+
+        it "matches a location on the scenario outline's tags" do
+          location = Ast::Location.new(file, 7)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to include test_case.location
+        end
+
+        it "doesn't match a location after the last row of the examples table" do
+          location = Ast::Location.new(file, 20)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq []
+        end
+
+        it "doesn't match a location before the scenario outline" do
+          location = Ast::Location.new(file, 5)
+          filter = Test::LocationsFilter.new([location])
+          compile [doc], receiver, [filter]
+          expect(receiver.test_case_locations).to eq []
+        end
+      end
     end
 
-    num_features = 1
-    num_scenarios_per_feature = 300
-    context "under load" do
+    context "under load", slow: true do
+      num_features = 50
+      num_scenarios_per_feature = 50
+
       let(:docs) do
         (1..num_features).map do |i|
           gherkin("features/test_#{i}.feature") do
@@ -74,14 +358,14 @@ module Cucumber::Core::Test
         (1..num_locations).map do |i|
           (1..num_scenarios_per_feature).map do |j|
             line = 3 + (j - 1) * 3
-            Cucumber::Core::Ast::Location.new("features/test_#{i}.feature", line)
+            Ast::Location.new("features/test_#{i}.feature", line)
           end
         end.flatten
       end
 
       max_duration_ms = 10000
       it "filters #{num_features * num_scenarios_per_feature} test cases within #{max_duration_ms}ms" do
-        filter = LocationsFilter.new(locations)
+        filter = Test::LocationsFilter.new(locations)
         Timeout.timeout(max_duration_ms / 1000.0) do
           compile docs, receiver, [filter]
         end
@@ -89,23 +373,23 @@ module Cucumber::Core::Test
       end
 
     end
+  end
 
-    class SpyReceiver
-      def test_case(test_case)
-        test_cases << test_case
-      end
-
-      def done
-      end
+  class SpyReceiver
+    def test_case(test_case)
+      test_cases << test_case
+    end
 
-      def test_case_locations
-        test_cases.map(&:location).map(&:to_s)
-      end
+    def done
+    end
 
-      def test_cases
-        @test_cases ||= []
-      end
+    def test_case_locations
+      test_cases.map(&:location)
+    end
 
+    def test_cases
+      @test_cases ||= []
     end
+
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-core
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.3.1
 platform: ruby
 authors:
 - Aslak Hellesøy
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-11 00:00:00.000000000 Z
+date: 2015-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gherkin3
@@ -219,7 +219,7 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: cucumber-core-1.3.0
+summary: cucumber-core-1.3.1
 test_files:
 - spec/capture_warnings.rb
 - spec/coverage.rb