cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/runtime/tag_limits/verifier.rb

@@ -0,0 +1,57 @@
+module Cucumber
+  class Runtime
+    module TagLimits
+      class Verifier
+        def initialize(tag_limits)
+          @tag_limits = tag_limits
+        end
+
+        def verify!(test_case_index)
+          breaches = collect_breaches(test_case_index)
+          raise TagLimitExceededError.new(*breaches) unless breaches.empty?
+        end
+
+        private
+
+        def collect_breaches(test_case_index)
+          tag_limits.reduce([]) do |breaches, (tag_name, limit)|
+            breaches.tap do |breaches|
+              if test_case_index.count_by_tag_name(tag_name) > limit
+                breaches << Breach.new(tag_name, limit, test_case_index.locations_of_tag_name(tag_name))
+              end
+            end
+          end
+        end
+
+        attr_reader :tag_limits
+
+        class Breach
+          INDENT = (" " * 2).freeze
+
+          def initialize(tag_name, limit, locations)
+            @tag_name = tag_name
+            @limit = limit
+            @locations = locations
+          end
+
+          def to_s
+            [
+              "#{tag_name} occurred #{tag_count} times, but the limit was set to #{limit}",
+              *locations.map(&:to_s)
+            ].join("\n#{INDENT}")
+          end
+
+          private
+
+          def tag_count
+            locations.count
+          end
+
+          attr_reader :tag_name
+          attr_reader :limit
+          attr_reader :locations
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/user_interface.rb

@@ -6,6 +6,10 @@ module Cucumber
     module UserInterface
       attr_writer :visitor
 
+      def visitor=(visitor)
+        @visitor = visitor
+      end
+
       # Output +messages+ alongside the formatted output.
       # This is an alternative to using Kernel#puts - it will display
       # nicer, and in all outputs (in case you use several formatters)

data/lib/cucumber/step_match.rb

@@ -12,7 +12,7 @@ module Cucumber
     end
 
     def args
-      @step_arguments.map{|g| g.val}
+      @step_arguments.map{|g| g.val.freeze }
     end
 
     def name
@@ -20,8 +20,8 @@ module Cucumber
     end
 
     def invoke(multiline_arg)
-      all_args = args
-      all_args << multiline_arg.to_step_definition_arg if multiline_arg
+      all_args = args.dup
+      multiline_arg.append_to(all_args)
       @step_definition.invoke(all_args)
     end
 

data/lib/cucumber/term/ansicolor.rb

@@ -78,7 +78,7 @@ module Cucumber
 
 
       def self.included(klass)
-        if version_is_greater_than_18? and klass == String
+        if klass == String
           ATTRIBUTES.delete(:clear)
           ATTRIBUTE_NAMES.delete(:clear)
         end
@@ -105,14 +105,6 @@ module Cucumber
         ATTRIBUTE_NAMES
       end
       extend self
-
-      private
-
-      def version_is_greater_than_18?
-        version = RUBY_VERSION.split('.')
-        version.map! &:to_i
-        version[0] >= 1 && version[1] > 8
-      end
     end
   end
 end

data/lib/cucumber/wire_support/wire_language.rb

@@ -9,26 +9,23 @@ require 'cucumber/wire_support/wire_step_definition'
 module Cucumber
   module WireSupport
 
-    # The wire-protocol (lanugage independent) implementation of the programming
+    # The wire-protocol (language independent) implementation of the programming
     # language API.
     class WireLanguage
       include LanguageSupport::LanguageMethods
 
-      def initialize(runtime)
+      def initialize(_=nil)
         @connections = []
       end
 
-      def alias_adverbs(adverbs)
-      end
-
       def load_code_file(wire_file)
         config = Configuration.from_file(wire_file)
         @connections << Connection.new(config)
       end
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type)
+      def snippet_text(code_keyword, step_name, multiline_arg, snippet_type)
         snippets = @connections.map do |remote|
-          remote.snippet_text(code_keyword, step_name, multiline_arg_class.to_s)
+          remote.snippet_text(code_keyword, step_name, MultilineArgClassName.new(multiline_arg).to_s)
         end
         snippets.flatten.join("\n")
       end
@@ -37,8 +34,6 @@ module Cucumber
         @connections.map{ |c| c.step_matches(step_name, formatted_step_name)}.flatten
       end
 
-      protected
-
       def begin_scenario(scenario)
         @connections.each { |c| c.begin_scenario(scenario) }
         @current_scenario = scenario
@@ -49,6 +44,25 @@ module Cucumber
         @connections.each { |c| c.end_scenario(scenario) }
         @current_scenario = nil
       end
+
+      class MultilineArgClassName
+        def initialize(arg)
+          arg.describe_to(self)
+          @result = ""
+        end
+
+        def data_table(*)
+          @result = "Cucumber::MultilineArgument::DataTable"
+        end
+
+        def doc_string(*)
+          @result = "Cucumber::MultilineArgument::DocString"
+        end
+
+        def to_s
+          @result
+        end
+      end
     end
   end
 end

data/lib/cucumber/wire_support/wire_packet.rb

@@ -23,7 +23,7 @@ module Cucumber
       def to_json
         packet = [@message]
         packet << @params if @params
-        packet.to_json
+        MultiJson.dump(packet)
       end
 
       def handle_with(handler)

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -68,21 +68,29 @@ module Cucumber
           end
 
           def handle_diff!(tables)
-            table1 = Ast::Table.new(tables[0])
-            table2 = Ast::Table.new(tables[1])
+            # TODO: figure out if / how we could get a location for a table from the wire (or make a null location)
+            location = Core::Ast::Location.new('??', '??')
+            table1 = table(tables[0], location)
+            table2 = table(tables[1], location)
             table1.diff!(table2)
           end
 
           def handle_diff(tables)
             begin
               handle_diff!(tables)
-            rescue Cucumber::Ast::Table::Different
+            rescue Cucumber::MultilineArgument::DataTable::Different
               @connection.diff_failed
             end
             @connection.diff_ok
           end
 
           alias :handle_step_failed :handle_fail
+
+          private
+
+          def table(data, location)
+            Cucumber::MultilineArgument.from(Core::Ast::DataTable.new(data, location))
+          end
         end
 
         class DiffFailed < RequestHandler
@@ -95,11 +103,11 @@ module Cucumber
 
         module Tags
           def clean_tag_names(scenario)
-            scenario.source_tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
+            scenario.tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
           end
 
           def request_params(scenario)
-            return nil unless scenario.source_tags.any?
+            return nil unless scenario.tags.any?
             { "tags" => clean_tag_names(scenario) }
           end
         end

data/lib/cucumber/wire_support/wire_step_definition.rb

@@ -11,16 +11,9 @@ module Cucumber
       end
 
       def invoke(args)
-        prepared_args = args.map{ |arg| prepare(arg) }
-        @connection.invoke(@id, prepared_args)
+        @connection.invoke(@id, args)
       end
 
-      private
-
-      def prepare(arg)
-        return arg unless arg.is_a?(Cucumber::Ast::Table)
-        arg.raw
-      end
     end
   end
 end

data/spec/cucumber/cli/configuration_spec.rb

@@ -9,20 +9,22 @@ module Cli
     end
 
     def given_cucumber_yml_defined_as(hash_or_string)
-      File.stub(:exist?).and_return(true)
+      allow(File).to receive(:exist?) { true }
+
       cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
-      IO.stub(:read).with('cucumber.yml').and_return(cucumber_yml)
+
+      allow(IO).to receive(:read).with('cucumber.yml') { cucumber_yml }
     end
 
     def given_the_following_files(*files)
-      File.stub(:directory?).and_return(true)
-      File.stub(:file?).and_return(true)
-      Dir.stub(:[]).and_return(files)
+      allow(File).to receive(:directory?) { true }
+      allow(File).to receive(:file?) { true }
+      allow(Dir).to receive(:[]) { files }
     end
 
     before(:each) do
-      File.stub(:exist?).and_return(false) # Meaning, no cucumber.yml exists
-      Kernel.stub(:exit).and_return(nil)
+      allow(File).to receive(:exist?) { false } # Meaning, no cucumber.yml exists
+      allow(Kernel).to receive(:exit)
     end
 
     def config
@@ -35,34 +37,34 @@ module Cli
 
     attr_reader :out, :error
 
-    it "should require env.rb files first" do
+    it "requires env.rb files first" do
       given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
 
       config.parse!(%w{--require /features})
 
-      config.support_to_load.should == [
+      expect(config.support_to_load).to eq [
         "/features/support/env.rb",
         "/features/support/a_file.rb"
       ]
     end
 
-    it "should not require env.rb files when --dry-run" do
+    it "does not require env.rb files when --dry-run" do
       given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
 
       config.parse!(%w{--require /features --dry-run})
 
-      config.support_to_load.should == [
+      expect(config.support_to_load).to eq [
         "/features/support/a_file.rb"
       ]
     end
 
-    it "should require files in vendor/{plugins,gems}/*/cucumber/*.rb" do
+    it "requires files in vendor/{plugins,gems}/*/cucumber/*.rb" do
       given_the_following_files("/vendor/gems/gem_a/cucumber/bar.rb",
                                 "/vendor/plugins/plugin_a/cucumber/foo.rb")
 
       config.parse!(%w{--require /features})
 
-      config.step_defs_to_load.should == [
+      expect(config.step_defs_to_load).to eq [
         "/vendor/gems/gem_a/cucumber/bar.rb",
         "/vendor/plugins/plugin_a/cucumber/foo.rb"
       ]
@@ -75,7 +77,7 @@ module Cli
 
         config.parse!(%w{--require /features --exclude a_file.rb})
 
-        config.all_files_to_load.should == [
+        expect(config.all_files_to_load).to eq [
           "/features/support/env.rb"
         ]
       end
@@ -87,43 +89,19 @@ module Cli
 
         config.parse!(%w{--require /features --exclude foo[df] --exclude blah})
 
-        config.all_files_to_load.should == [
+        expect(config.all_files_to_load).to eq [
           "/features/support/bar.rb",
           "/features/support/fooz.rb"
         ]
       end
     end
 
-    describe '#drb?' do
-      it "indicates whether the --drb flag was passed in or not" do
-        config.parse!(%w{features})
-        config.should_not be_drb
-
-
-        config.parse!(%w{features --drb})
-        config.should be_drb
-      end
-    end
-
-    describe "#drb_port" do
-      it "is nil when not configured" do
-        config.parse!([])
-        config.drb_port.should be_nil
-      end
-
-      it "is numeric when configured" do
-        config.parse!(%w{features --port 1000})
-        config.drb_port.should == 1000
-      end
-
-
-    end
-
     it "uses the default profile when no profile is defined" do
       given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
       config.parse!(%w{--format progress})
-      config.options[:require].should include('some_file')
+
+      expect(config.options[:require]).to include('some_file')
     end
 
     context '--profile' do
@@ -133,29 +111,33 @@ module Cli
         given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
 
         config.parse!(%w{--format progress --profile bongo})
-        config.options[:formats].should == [['progress', out]]
-        config.options[:require].should == ['from/yml']
+
+        expect(config.options[:formats]).to eq [['progress', out]]
+        expect(config.options[:require]).to eq ['from/yml']
       end
 
       it "expands args from the default profile when no flags are provided" do
         given_cucumber_yml_defined_as({'default' => '--require from/yml'})
 
         config.parse!([])
-        config.options[:require].should == ['from/yml']
+
+        expect(config.options[:require]).to eq ['from/yml']
       end
 
       it "allows --strict to be set by a profile" do
         given_cucumber_yml_defined_as({'bongo' => '--strict'})
 
         config.parse!(%w{--profile bongo})
-        config.options[:strict].should be_true
+
+        expect(config.options[:strict]).to be true
       end
 
       it "parses ERB syntax in the cucumber.yml file" do
         given_cucumber_yml_defined_as("---\ndefault: \"<%=\"--require some_file\"%>\"\n")
 
         config.parse!([])
-        config.options[:require].should include('some_file')
+
+        expect(config.options[:require]).to include('some_file')
       end
 
       it "parses ERB in cucumber.yml that makes uses nested ERB sessions" do
@@ -165,7 +147,8 @@ module Cli
 ERB_YML
 
         config.parse!(%w(-p standard))
-        config.options[:require].should include('some_file')
+
+        expect(config.options[:require]).to include('some_file')
       end
 
       it "provides a helpful error message when a specified profile does not exists in cucumber.yml" do
@@ -179,23 +162,23 @@ Defined profiles in cucumber.yml:
   * html_report
 END_OF_MESSAGE
 
-        lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(ProfileNotFound, expected_message)
+        expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(ProfileNotFound, expected_message)
       end
 
       it "allows profiles to be defined in arrays" do
         given_cucumber_yml_defined_as({'foo' => ['-f','progress']})
 
         config.parse!(%w{--profile foo})
-        config.options[:formats].should == [['progress', out]]
+
+        expect(config.options[:formats]).to eq [['progress', out]]
       end
 
       it "disregards default STDOUT formatter defined in profile when another is passed in (via cmd line)" do
         given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
         config.parse!(%w{--format progress --profile foo})
-        config.options[:formats].should == [['progress', out]]#, ['pretty', 'pretty.txt']]
-      end
-
 
+        expect(config.options[:formats]).to eq [['progress', out]]
+      end
 
       ["--no-profile", "-P"].each do |flag|
         context 'when none is specified with #{flag}' do
@@ -203,14 +186,16 @@ END_OF_MESSAGE
             given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
 
             config.parse!("#{flag} --require some_file.rb".split(" "))
-            config.options[:require].should == ['some_file.rb']
+
+            expect(config.options[:require]).to eq ['some_file.rb']
           end
 
           it "notifies the user that the profiles are being disabled" do
             given_cucumber_yml_defined_as({'default' => '-v'})
 
             config.parse!("#{flag} --require some_file.rb".split(" "))
-            out.string.should =~ /Disabling profiles.../
+
+            expect(out.string).to match /Disabling profiles.../
           end
         end
       end
@@ -220,15 +205,17 @@ END_OF_MESSAGE
           given_cucumber_yml_defined_as({'foo' => bad_input})
 
           expected_error = /The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./
-          lambda{config.parse!(%w{--profile foo})}.should raise_error(expected_error)
+
+          expect(-> { config.parse!(%w{--profile foo}) }).to raise_error(expected_error)
         end
       end
 
       it "issues a helpful error message when no YAML file exists and a profile is specified" do
-        File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+        expect(File).to receive(:exist?).with('cucumber.yml') { false }
 
         expected_error = /cucumber\.yml was not found/
-        lambda{config.parse!(%w{--profile i_do_not_exist})}.should raise_error(expected_error)
+
+        expect(-> { config.parse!(%w{--profile i_do_not_exist}) }).to raise_error(expected_error)
       end
 
       it "issues a helpful error message when cucumber.yml is blank or malformed" do
@@ -236,7 +223,9 @@ END_OF_MESSAGE
 
         ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
           given_cucumber_yml_defined_as(bad_input)
-          lambda{config.parse!([])}.should raise_error(expected_error_message)
+
+          expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
+
           reset_config
         end
       end
@@ -245,104 +234,109 @@ END_OF_MESSAGE
         expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage./
 
         given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
-        YAML.should_receive(:load).and_raise ArgumentError
 
-        lambda{config.parse!([])}.should raise_error(expected_error_message)
+        expect(YAML).to receive(:load).and_raise(ArgumentError)
+        expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
       end
 
       it "issues a helpful error message when cucumber.yml can not be parsed by ERB" do
         expected_error_message = /cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage./
         given_cucumber_yml_defined_as("<% this_fails %>")
 
-        lambda{config.parse!([])}.should raise_error(expected_error_message)
+        expect(-> { config.parse!([]) }).to raise_error(expected_error_message)
       end
     end
 
-
-    it "should accept --dry-run option" do
+    it "accepts --dry-run option" do
       config.parse!(%w{--dry-run})
-      config.options[:dry_run].should be_true
+
+      expect(config.options[:dry_run]).to be true
     end
 
-    it "should accept --no-source option" do
+    it "accepts --no-source option" do
       config.parse!(%w{--no-source})
 
-      config.options[:source].should be_false
+      expect(config.options[:source]).to be false
     end
 
-    it "should accept --no-snippets option" do
+    it "accepts --no-snippets option" do
       config.parse!(%w{--no-snippets})
 
-      config.options[:snippets].should be_false
+      expect(config.options[:snippets]).to be false
     end
 
-    it "should set snippets and source to false with --quiet option" do
+    it "sets snippets and source to false with --quiet option" do
       config.parse!(%w{--quiet})
 
-      config.options[:snippets].should be_false
-      config.options[:source].should be_false
+      expect(config.options[:snippets]).to be false
+      expect(config.options[:source]).to be false
     end
 
-    it "should accept --verbose option" do
+    it "accepts --verbose option" do
       config.parse!(%w{--verbose})
 
-      config.options[:verbose].should be_true
+      expect(config.options[:verbose]).to be true
     end
 
-    it "should accept --out option" do
+    it "accepts --out option" do
       config.parse!(%w{--out jalla.txt})
-      config.formats.should == [['pretty', 'jalla.txt']]
+
+      expect(config.formats).to eq [['pretty', 'jalla.txt']]
     end
 
-    it "should accept multiple --out options" do
+    it "accepts multiple --out options" do
       config.parse!(%w{--format progress --out file1 --out file2})
-      config.formats.should == [['progress', 'file2']]
+
+      expect(config.formats).to eq [['progress', 'file2']]
     end
 
-    it "should accept multiple --format options and put the STDOUT one first so progress is seen" do
+    it "accepts multiple --format options and put the STDOUT one first so progress is seen" do
       config.parse!(%w{--format pretty --out pretty.txt --format progress})
-      config.formats.should == [['progress', out], ['pretty', 'pretty.txt']]
+
+      expect(config.formats).to eq [['progress', out], ['pretty', 'pretty.txt']]
     end
 
-    it "should not accept multiple --format options when both use implicit STDOUT" do
-      lambda do
-        config.parse!(%w{--format pretty --format progress})
-      end.should raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+    it "does not accept multiple --format options when both use implicit STDOUT" do
+      expect(-> { config.parse!(%w{--format pretty --format progress}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
     end
 
-    it "should accept same --format options with implicit STDOUT, and keep only one" do
+    it "accepts same --format options with implicit STDOUT, and keep only one" do
       config.parse!(%w{--format pretty --format pretty})
-      config.formats.should == [["pretty", out]]
+
+      expect(config.formats).to eq [["pretty", out]]
     end
 
-    it "should not accept multiple --out streams pointing to the same place" do
-      lambda do
-        config.parse!(%w{--format pretty --out file1 --format progress --out file1})
-      end.should raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+    it "does not accept multiple --out streams pointing to the same place" do
+      expect(-> { config.parse!(%w{--format pretty --out file1 --format progress --out file1}) }).to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
     end
 
-    it "should associate --out to previous --format" do
+    it "associates --out to previous --format" do
       config.parse!(%w{--format progress --out file1 --format profile --out file2})
-      config.formats.should == [["progress", "file1"], ["profile" ,"file2"]]
+
+      expect(config.formats).to eq [["progress", "file1"], ["profile" ,"file2"]]
     end
 
-    it "should accept same --format options with same --out streams and keep only one" do
+    it "accepts same --format options with same --out streams and keep only one" do
       config.parse!(%w{--format html --out file --format pretty --format html --out file})
-      config.formats.should == [["pretty", out], ["html", "file"]]
+
+      expect(config.formats).to eq [["pretty", out], ["html", "file"]]
     end
 
-    it "should accept same --format options with different --out streams" do
+    it "accepts same --format options with different --out streams" do
       config.parse!(%w{--format html --out file1 --format html --out file2})
-      config.formats.should == [["html", "file1"], ["html", "file2"]]
+
+      expect(config.formats).to eq [["html", "file1"], ["html", "file2"]]
     end
 
-    it "should accept --color option" do
-      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(true)
+    it "accepts --color option" do
+      expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(true)
+
       config.parse!(['--color'])
     end
 
-    it "should accept --no-color option" do
-      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(false)
+    it "accepts --no-color option" do
+      expect(Cucumber::Term::ANSIColor).to receive(:coloring=).with(false)
+
       config = Configuration.new(StringIO.new)
       config.parse!(['--no-color'])
     end
@@ -352,12 +346,12 @@ END_OF_MESSAGE
         Cucumber.use_full_backtrace = false
       end
 
-      it "should show full backtrace when --backtrace is present" do
-        config = Main.new(['--backtrace'])
+      it "shows full backtrace when --backtrace is present" do
+        Main.new(['--backtrace'])
         begin
-          "x".should == "y"
-        rescue => e
-          e.backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
+          expect("x").to eq "y"
+        rescue RSpec::Expectations::ExpectationNotMetError => e
+          expect(e.backtrace[0]).not_to eq "#{__FILE__}:#{__LINE__ - 2}"
         end
       end
 
@@ -366,72 +360,57 @@ END_OF_MESSAGE
       end
     end
 
-    it "should accept multiple --name options" do
+    it "accepts multiple --name options" do
       config.parse!(['--name', "User logs in", '--name', "User signs up"])
 
-      config.options[:name_regexps].should include(/User logs in/)
-      config.options[:name_regexps].should include(/User signs up/)
+      expect(config.options[:name_regexps]).to include(/User logs in/)
+      expect(config.options[:name_regexps]).to include(/User signs up/)
     end
 
-    it "should accept multiple -n options" do
+    it "accepts multiple -n options" do
       config.parse!(['-n', "User logs in", '-n', "User signs up"])
 
-      config.options[:name_regexps].should include(/User logs in/)
-      config.options[:name_regexps].should include(/User signs up/)
+      expect(config.options[:name_regexps]).to include(/User logs in/)
+      expect(config.options[:name_regexps]).to include(/User signs up/)
     end
 
-    it "should preserve the order of the feature files" do
+    it "preserves the order of the feature files" do
       config.parse!(%w{b.feature c.feature a.feature})
 
-      config.feature_files.should == ["b.feature", "c.feature", "a.feature"]
+      expect(config.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
     end
 
-    it "should search for all features in the specified directory" do
-      File.stub(:directory?).and_return(true)
-      Dir.stub(:[]).with("feature_directory/**/*.feature").
-        and_return(["cucumber.feature"])
+    it "searchs for all features in the specified directory" do
+      allow(File).to receive(:directory?) { true }
+      allow(Dir).to receive(:[]).with("feature_directory/**/*.feature") { ["cucumber.feature"] }
 
       config.parse!(%w{feature_directory/})
 
-      config.feature_files.should == ["cucumber.feature"]
+      expect(config.feature_files).to eq ["cucumber.feature"]
     end
 
     it "defaults to the features directory when no feature file are provided" do
-      File.stub(:directory?).and_return(true)
-      Dir.stub(:[]).with("features/**/*.feature").
-        and_return(["cucumber.feature"])
+      allow(File).to receive(:directory?) { true }
+      allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
 
       config.parse!(%w{})
 
-      config.feature_files.should == ["cucumber.feature"]
-    end
-
-    it "should get the feature files from the rerun file" do
-      File.stub(:directory?).and_return(false)
-      File.stub(:file?).and_return(true)
-      IO.stub(:read).and_return(
-        "cucumber.feature:1:3 cucumber space.feature:134 domain folder/cuke.feature:1 domain folder/different cuke:4:5" )
-
-      config.parse!(%w{@rerun.txt})
-
-      config.feature_files.should == [
-        "cucumber.feature:1:3",
-        "cucumber space.feature:134",
-        "domain folder/cuke.feature:1",
-        "domain folder/different cuke:4:5"]
+      expect(config.feature_files).to eq ["cucumber.feature"]
     end
 
-    it "should allow specifying environment variables on the command line" do
+    it "allows specifying environment variables on the command line" do
       config.parse!(["foo=bar"])
-      ENV["foo"].should == "bar"
-      config.feature_files.should_not include('foo=bar')
+
+      expect(ENV["foo"]).to eq "bar"
+      expect(config.feature_files).not_to include('foo=bar')
     end
 
-    it "should allow specifying environment variables in profiles" do
+    it "allows specifying environment variables in profiles" do
       given_cucumber_yml_defined_as({'selenium' => 'RAILS_ENV=selenium'})
       config.parse!(["--profile", "selenium"])
-      ENV["RAILS_ENV"].should == "selenium"
-      config.feature_files.should_not include('RAILS_ENV=selenium')
+
+      expect(ENV["RAILS_ENV"]).to eq "selenium"
+      expect(config.feature_files).not_to include('RAILS_ENV=selenium')
     end
 
     describe "#tag_expression" do
@@ -439,47 +418,69 @@ END_OF_MESSAGE
 
       it "returns an empty expression when no tags are specified" do
         config.parse!([])
-        config.tag_expression.should be_empty
+
+        expect(config.tag_expression).to be_empty
       end
 
       it "returns an expression when tags are specified" do
         config.parse!(['--tags','@foo'])
-        config.tag_expression.should_not be_empty
+
+        expect(config.tag_expression).not_to be_empty
+      end
+    end
+
+    describe '#tag_limits' do
+      it "returns an empty hash when no limits are specified" do
+        config.parse!([])
+
+        expect(config.tag_limits).to eq({ })
+      end
+
+      it "returns a hash of limits when limits are specified" do
+        config.parse!(['--tags','@foo:1'])
+
+        expect(config.tag_limits).to eq({ "@foo" => 1 })
       end
     end
 
     describe "#dry_run?" do
       it "returns true when --dry-run was specified on in the arguments" do
         config.parse!(['--dry-run'])
-        config.dry_run?.should be_true
+
+        expect(config.dry_run?).to be true
       end
 
       it "returns true when --dry-run was specified in yaml file" do
         given_cucumber_yml_defined_as({'default' => '--dry-run'})
         config.parse!([])
-        config.dry_run?.should be_true
+
+        expect(config.dry_run?).to be true
       end
 
       it "returns false by default" do
         config.parse!([])
-        config.dry_run?.should be_false
+
+        expect(config.dry_run?).to be false
       end
     end
 
     describe "#snippet_type" do
       it "returns the snippet type when it was set" do
         config.parse!(["--snippet-type", "classic"])
-        config.snippet_type.should eql :classic
+
+        expect(config.snippet_type).to eq :classic
       end
 
       it "returns the snippet type when it was set with shorthand option" do
         config.parse!(["-I", "classic"])
-        config.snippet_type.should eql :classic
+
+        expect(config.snippet_type).to eq :classic
       end
 
       it "returns the default snippet type if it was not set" do
         config.parse!([])
-        config.snippet_type.should eql :regexp
+
+        expect(config.snippet_type).to eq :regexp
       end
     end
   end