cucumber 2.99.0 → 3.0.0

data/spec/cucumber/cli/options_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'yaml'
 require 'cucumber/cli/options'
@@ -48,47 +49,49 @@ module Cucumber
         end
 
         context '-r or --require' do
-          it "collects all specified files into an array" do
+          it 'collects all specified files into an array' do
             after_parsing('--require some_file.rb -r another_file.rb') do
               expect(options[:require]).to eq ['some_file.rb', 'another_file.rb']
             end
           end
         end
 
-        context '--i18n' do
-          context "with LANG specified as 'help'" do
-            include RSpec::WorkInProgress
+        context '--i18n-languages' do
+          include RSpec::WorkInProgress
 
-            it "lists all known languages" do
-              when_parsing '--i18n help' do
-                expect(Kernel).to receive(:exit)
+          it 'lists all known languages' do
+            after_parsing '--i18n-languages' do
+              ::Gherkin::DIALECTS.keys.map do |key|
+                expect(@output_stream.string).to include(key.to_s);
               end
             end
+          end
 
-            it "exits the program" do
-              when_parsing('--i18n help') { expect(Kernel).to receive(:exit) }
-            end
+          it 'exits the program' do
+            when_parsing('--i18n-languages') { expect(Kernel).to receive(:exit) }
           end
+        end
 
-          context "with invalid LANG" do 
+        context '--i18n-keywords' do
+          context 'with invalid LANG' do
             include RSpec::WorkInProgress
 
-            it "exits" do 
-              when_parsing '--i18n foo' do 
+            it 'exits' do
+              when_parsing '--i18n-keywords foo' do
                 expect(Kernel).to receive(:exit)
               end
             end
 
-            it "says the language was invalid" do 
-              after_parsing '--i18n foo' do 
+            it 'says the language was invalid' do
+              after_parsing '--i18n-keywords foo' do
                 expect(@output_stream.string).to include("Invalid language 'foo'. Available languages are:")
               end
             end
 
-            it "displays the language table" do 
-              after_parsing '--i18n foo' do 
+            it 'displays the language table' do
+              after_parsing '--i18n-keywords foo' do
                 ::Gherkin::DIALECTS.keys.map do |key|
-                  expect(@output_stream.string).to include("#{key}");
+                  expect(@output_stream.string).to include(key.to_s);
                 end
               end
             end
@@ -96,75 +99,94 @@ module Cucumber
         end
 
         context '-f FORMAT or --format FORMAT' do
-          it "defaults the output for the formatter to the output stream (STDOUT)" do
-            after_parsing('-f pretty') { expect(options[:formats]).to eq [['pretty', output_stream]] }
+          it 'defaults the output for the formatter to the output stream (STDOUT)' do
+            after_parsing('-f pretty') { expect(options[:formats]).to eq [['pretty', {}, output_stream]] }
+          end
+
+          it 'extracts per-formatter options' do
+            after_parsing('-f pretty,foo=bar,foo2=bar2') do
+              expect(options[:formats]).to eq [['pretty', { 'foo' => 'bar', 'foo2' => 'bar2' }, output_stream]]
+            end
           end
         end
 
         context '-o [FILE|DIR] or --out [FILE|DIR]' do
           it "defaults the formatter to 'pretty' when not specified earlier" do
-            after_parsing('-o file.txt') { expect(options[:formats]).to eq [['pretty', 'file.txt']] }
+            after_parsing('-o file.txt') { expect(options[:formats]).to eq [['pretty', {}, 'file.txt']] }
           end
-          it "sets the output for the formatter defined immediatly before it" do
+          it 'sets the output for the formatter defined immediatly before it' do
             after_parsing('-f profile --out file.txt -f pretty -o file2.txt') do
-              expect(options[:formats]).to eq [['profile', 'file.txt'], ['pretty', 'file2.txt']]
+              expect(options[:formats]).to eq [['profile', {}, 'file.txt'], ['pretty', {}, 'file2.txt']]
             end
           end
         end
 
         context 'handling multiple formatters' do
-          it "catches multiple command line formatters using the same stream" do
-            expect{ options.parse!(prepare_args('-f pretty -f progress')) }.to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+          it 'catches multiple command line formatters using the same stream' do
+            expect{ options.parse!(prepare_args('-f pretty -f progress')) }.to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
           end
 
-          it "catches multiple profile formatters using the same stream" do
+          it 'catches multiple profile formatters using the same stream' do
             given_cucumber_yml_defined_as({'default' => '-f progress -f pretty'})
             options = Options.new(output_stream, error_stream, :default_profile => 'default')
 
-            expect{ options.parse!(%w{}) }.to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+            expect{ options.parse!(%w{}) }.to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
           end
 
-          it "profiles does not affect the catching of multiple command line formatters using the same stream" do
+          it 'profiles does not affect the catching of multiple command line formatters using the same stream' do
             given_cucumber_yml_defined_as({'default' => '-q'})
             options = Options.new(output_stream, error_stream, :default_profile => 'default')
 
-            expect{ options.parse!(%w{-f progress -f pretty}) }.to raise_error("All but one formatter must use --out, only one can print to each stream (or STDOUT)")
+            expect{ options.parse!(%w{-f progress -f pretty}) }.to raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
           end
 
-          it "merges profile formatters and command line formatters" do
+          it 'merges profile formatters and command line formatters' do
             given_cucumber_yml_defined_as({'default' => '-f junit -o result.xml'})
             options = Options.new(output_stream, error_stream, :default_profile => 'default')
 
             options.parse!(%w{-f pretty})
-            
-            expect(options[:formats]).to eq [['pretty', output_stream], ["junit", "result.xml"]]
+
+            expect(options[:formats]).to eq [['pretty', {}, output_stream], ['junit', {}, 'result.xml']]
           end
         end
 
         context '-t TAGS --tags TAGS' do
-          it "designates tags prefixed with ~ as tags to be excluded" do
-            after_parsing('--tags ~@foo,@bar') { expect(options[:tag_expressions]).to eq ['~@foo,@bar'] }
+          it 'handles tag expressions as argument' do
+            after_parsing(['--tags', 'not @foo or @bar']) { expect(options[:tag_expressions]).to eq ['not @foo or @bar'] }
           end
 
-          it "stores tags passed with different --tags seperately" do
+          it 'stores tags passed with different --tags seperately' do
             after_parsing('--tags @foo --tags @bar') { expect(options[:tag_expressions]).to eq ['@foo', '@bar'] }
           end
+
+          it 'strips tag limits from the tag expressions stored' do
+            after_parsing(['--tags', 'not @foo:2 or @bar:3']) { expect(options[:tag_expressions]).to eq ['not @foo or @bar'] }
+          end
+
+          it 'stores tag limits separately' do
+            after_parsing(['--tags', 'not @foo:2 or @bar:3']) { expect(options[:tag_limits]).to eq Hash('@foo' => 2, '@bar' => 3) }
+          end
+
+          it 'raise exception for inconsistent tag limits' do
+            expect{ after_parsing('--tags @foo:2 --tags @foo:3') }.to raise_error(RuntimeError, 'Inconsistent tag limits for @foo: 2 and 3')
+
+          end
         end
 
         context '-n NAME or --name NAME' do
-          it "stores the provided names as regular expressions" do
+          it 'stores the provided names as regular expressions' do
             after_parsing('-n foo --name bar') { expect(options[:name_regexps]).to eq [/foo/,/bar/] }
           end
         end
 
         context '-e PATTERN or --exclude PATTERN' do
-          it "stores the provided exclusions as regular expressions" do
+          it 'stores the provided exclusions as regular expressions' do
             after_parsing('-e foo --exclude bar') { expect(options[:excludes]).to eq [/foo/,/bar/] }
           end
         end
 
         context '-l LINES or --lines LINES' do
-          it "adds line numbers to args" do
+          it 'adds line numbers to args' do
             options.parse!(%w{-l24 FILE})
 
             expect(options.instance_variable_get(:@args)).to eq ['FILE:24']
@@ -172,7 +194,7 @@ module Cucumber
         end
 
         context '-p PROFILE or --profile PROFILE' do
-          it "uses the default profile passed in during initialization if none are specified by the user" do
+          it 'uses the default profile passed in during initialization if none are specified by the user' do
             given_cucumber_yml_defined_as({'default' => '--require some_file'})
 
             options = Options.new(output_stream, error_stream, :default_profile => 'default')
@@ -181,7 +203,7 @@ module Cucumber
             expect(options[:require]).to include('some_file')
           end
 
-          it "merges all uniq values from both cmd line and the profile" do
+          it 'merges all uniq values from both cmd line and the profile' do
             given_cucumber_yml_defined_as('foo' => %w[--verbose])
             options.parse!(%w[--wip --profile foo])
 
@@ -196,77 +218,90 @@ module Cucumber
             expect(options[:paths]).to eq %w[my.feature]
           end
 
-          it "combines the require files of both" do
+          it 'combines the require files of both' do
             given_cucumber_yml_defined_as('bar' => %w[--require features -r dog.rb])
             options.parse!(%w[--require foo.rb -p bar])
 
             expect(options[:require]).to eq %w[foo.rb features dog.rb]
           end
 
-          it "combines the tag names of both" do
+          it 'combines the tag names of both' do
             given_cucumber_yml_defined_as('baz' => %w[-t @bar])
             options.parse!(%w[--tags @foo -p baz])
 
-            expect(options[:tag_expressions]).to eq ["@foo", "@bar"]
+            expect(options[:tag_expressions]).to eq ['@foo', '@bar']
           end
 
-          it "only takes the paths from the original options, and disgregards the profiles" do
+          it 'combines the tag limits of both' do
+            given_cucumber_yml_defined_as('baz' => %w[-t @bar:2])
+            options.parse!(%w[--tags @foo:3 -p baz])
+
+            expect(options[:tag_limits]).to eq Hash('@foo' => 3, '@bar' => 2)
+          end
+
+          it 'raise exceptions for inconsistent tag limits' do
+            given_cucumber_yml_defined_as('baz' => %w[-t @bar:2])
+
+            expect{ options.parse!(%w[--tags @bar:3 -p baz]) }.to raise_error(RuntimeError, 'Inconsistent tag limits for @bar: 3 and 2')
+          end
+
+          it 'only takes the paths from the original options, and disgregards the profiles' do
             given_cucumber_yml_defined_as('baz' => %w[features])
             options.parse!(%w[my.feature -p baz])
 
             expect(options[:paths]).to eq ['my.feature']
           end
 
-          it "uses the paths from the profile when none are specified originally" do
+          it 'uses the paths from the profile when none are specified originally' do
             given_cucumber_yml_defined_as('baz' => %w[some.feature])
             options.parse!(%w[-p baz])
 
             expect(options[:paths]).to eq ['some.feature']
           end
 
-          it "combines environment variables from the profile but gives precendene to cmd line args" do
+          it 'combines environment variables from the profile but gives precendene to cmd line args' do
             given_cucumber_yml_defined_as('baz' => %w[FOO=bar CHEESE=swiss])
             options.parse!(%w[-p baz CHEESE=cheddar BAR=foo])
 
             expect(options[:env_vars]).to eq({ 'BAR' => 'foo', 'FOO' => 'bar', 'CHEESE' => 'cheddar' })
           end
 
-          it "disregards STDOUT formatter defined in profile when another is passed in (via cmd line)" do
+          it 'disregards STDOUT formatter defined in profile when another is passed in (via cmd line)' do
             given_cucumber_yml_defined_as({'foo' => %w[--format pretty]})
             options.parse!(%w{--format progress --profile foo})
 
-            expect(options[:formats]).to eq [['progress', output_stream]]
+            expect(options[:formats]).to eq [['progress', {}, output_stream]]
           end
 
-          it "includes any non-STDOUT formatters from the profile" do
+          it 'includes any non-STDOUT formatters from the profile' do
             given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html]})
             options.parse!(%w{--format progress --profile html})
 
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
+            expect(options[:formats]).to eq [['progress', {}, output_stream], ['html', {}, 'features.html']]
           end
 
-          it "does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line" do
+          it 'does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line' do
             given_cucumber_yml_defined_as({'html' => %w[--format html -o features.html --format pretty]})
             options.parse!(%w{--format progress --profile html})
 
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
+            expect(options[:formats]).to eq [['progress', {}, output_stream], ['html', {}, 'features.html']]
           end
 
-          it "includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line" do
+          it 'includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line' do
             given_cucumber_yml_defined_as({'html' => %w[--format html]})
             options.parse!(%w{--format rerun -o rerun.txt --profile html})
 
-            expect(options[:formats]).to eq [['html', output_stream], ['rerun', 'rerun.txt']]
+            expect(options[:formats]).to eq [['html', {}, output_stream], ['rerun', {}, 'rerun.txt']]
           end
 
-          it "assumes all of the formatters defined in the profile when none are specified on cmd line" do
+          it 'assumes all of the formatters defined in the profile when none are specified on cmd line' do
             given_cucumber_yml_defined_as({'html' => %w[--format progress --format html -o features.html]})
             options.parse!(%w{--profile html})
 
-            expect(options[:formats]).to eq [['progress', output_stream], ['html', 'features.html']]
+            expect(options[:formats]).to eq [['progress', {}, output_stream], ['html', {}, 'features.html']]
           end
 
-          it "only reads cucumber.yml once" do
+          it 'only reads cucumber.yml once' do
             original_parse_count = $cucumber_yml_read_count
             $cucumber_yml_read_count = 0
 
@@ -275,7 +310,7 @@ module Cucumber
               <% $cucumber_yml_read_count += 1 %>
               default: --format pretty
               END
-              )
+                                           )
               options = Options.new(output_stream, error_stream, :default_profile => 'default')
               options.parse!(%w(-f progress))
 
@@ -285,7 +320,7 @@ module Cucumber
             end
           end
 
-          it "respects --quiet when defined in the profile" do
+          it 'respects --quiet when defined in the profile' do
             given_cucumber_yml_defined_as('foo' => '-q')
             options.parse!(%w[-p foo])
 
@@ -293,8 +328,8 @@ module Cucumber
             expect(options[:source]).to be false
             expect(options[:duration]).to be false
           end
-          
-          it "uses --no-duration when defined in the profile" do
+
+          it 'uses --no-duration when defined in the profile' do
             given_cucumber_yml_defined_as('foo' => '--no-duration')
             options.parse!(%w[-p foo])
 
@@ -303,18 +338,18 @@ module Cucumber
         end
 
         context '-P or --no-profile' do
-          it "disables profiles" do
+          it 'disables profiles' do
             given_cucumber_yml_defined_as({'default' => '-v --require file_specified_in_default_profile.rb'})
 
-            after_parsing("-P --require some_file.rb") do
+            after_parsing('-P --require some_file.rb') do
               expect(options[:require]).to eq ['some_file.rb']
             end
           end
 
-          it "notifies the user that the profiles are being disabled" do
+          it 'notifies the user that the profiles are being disabled' do
             given_cucumber_yml_defined_as({'default' => '-v'})
 
-            after_parsing("--no-profile --require some_file.rb") do
+            after_parsing('--no-profile --require some_file.rb') do
               expect(output_stream.string).to match(/Disabling profiles.../)
             end
           end
@@ -322,7 +357,7 @@ module Cucumber
 
         context '-b or --backtrace' do
           it "turns on cucumber's full backtrace" do
-            when_parsing("-b") do
+            when_parsing('-b') do
               expect(Cucumber).to receive(:use_full_backtrace=).with(true)
             end
           end
@@ -335,13 +370,13 @@ module Cucumber
             end
           end
 
-          it "exits the program" do
+          it 'exits the program' do
             when_parsing('--version') { expect(Kernel).to receive(:exit) }
           end
         end
 
         context 'environment variables (i.e. MODE=webrat)' do
-          it "places all of the environment variables into a hash" do
+          it 'places all of the environment variables into a hash' do
             after_parsing('MODE=webrat FOO=bar') do
               expect(options[:env_vars]).to eq({ 'MODE' => 'webrat', 'FOO' => 'bar' })
             end
@@ -349,33 +384,33 @@ module Cucumber
         end
 
         context '--retry ATTEMPTS' do
-          it 'is 0 by default' do 
-            after_parsing("") do 
+          it 'is 0 by default' do
+            after_parsing('') do
               expect(options[:retry]).to eql 0
             end
           end
 
-          it 'sets the options[:retry] value' do 
-            after_parsing("--retry 4") do 
+          it 'sets the options[:retry] value' do
+            after_parsing('--retry 4') do
               expect(options[:retry]).to eql 4
             end
           end
         end
 
-        it "assigns any extra arguments as paths to features" do
+        it 'assigns any extra arguments as paths to features' do
           after_parsing('-f pretty my_feature.feature my_other_features') do
             expect(options[:paths]).to eq ['my_feature.feature', 'my_other_features']
           end
         end
 
-        it "does not mistake environment variables as feature paths" do
+        it 'does not mistake environment variables as feature paths' do
           after_parsing('my_feature.feature FOO=bar') do
             expect(options[:paths]).to eq ['my_feature.feature']
           end
         end
 
         context '--snippet-type' do
-          it "parses the snippet type argument" do
+          it 'parses the snippet type argument' do
             after_parsing('--snippet-type classic') do
               expect(options[:snippet_type]).to eq :classic
             end
@@ -383,22 +418,22 @@ module Cucumber
         end
       end
 
-      describe "dry-run" do
-        it "has the default value for snippets" do
+      describe 'dry-run' do
+        it 'has the default value for snippets' do
           given_cucumber_yml_defined_as({'foo' => %w[--dry-run]})
           options.parse!(%w{--dry-run})
 
           expect(options[:snippets]).to be true
         end
 
-        it "sets snippets to false when no-snippets provided after dry-run" do
+        it 'sets snippets to false when no-snippets provided after dry-run' do
           given_cucumber_yml_defined_as({'foo' => %w[--dry-run --no-snippets]})
           options.parse!(%w{--dry-run --no-snippets})
 
           expect(options[:snippets]).to be false
         end
 
-        it "sets snippets to false when no-snippets provided before dry-run" do
+        it 'sets snippets to false when no-snippets provided before dry-run' do
           given_cucumber_yml_defined_as({'foo' => %w[--no-snippet --dry-run]})
           options.parse!(%w{--no-snippets --dry-run})
 

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 require 'yaml'
 
@@ -17,8 +18,8 @@ module Cucumber
         ProfileLoader.new
       end
 
-      it "treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)" do
-        given_cucumber_yml_defined_as({'default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22'})
+      it 'treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)' do
+        given_cucumber_yml_defined_as('default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22')
         if(Cucumber::WINDOWS)
           expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
         else
@@ -26,13 +27,13 @@ module Cucumber
         end
       end
 
-      it "treats forward slashes as literals" do
-        given_cucumber_yml_defined_as({'default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22'})
+      it 'treats forward slashes as literals' do
+        given_cucumber_yml_defined_as('default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22')
 
         expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
       end
 
-      it "treats percent sign as ERB code block after YAML directive" do
+      it 'treats percent sign as ERB code block after YAML directive' do
         yml = <<-HERE
 ---
 % x = '--format "pretty" features/sync_imap_mailbox.feature:16:22'
@@ -41,6 +42,25 @@ default: <%= x %>
         given_cucumber_yml_defined_as yml
         expect(loader.args_from('default')).to eq ['--format','pretty','features/sync_imap_mailbox.feature:16:22']
       end
+
+      it 'correctly parses a profile that uses tag expressions (with double quotes)' do
+        given_cucumber_yml_defined_as('default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22 --tags "not @jruby"')
+        if(Cucumber::WINDOWS)
+          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22','--tags','not @jruby']
+        else
+          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22','--tags','not @jruby']
+        end
+      end
+
+      it 'correctly parses a profile that uses tag expressions (with single quotes)' do
+        given_cucumber_yml_defined_as('default' => "--format 'pretty' features\\sync_imap_mailbox.feature:16:22 --tags 'not @jruby'")
+        if(Cucumber::WINDOWS)
+          expect(loader.args_from('default')).to eq ['--format','pretty','features\sync_imap_mailbox.feature:16:22','--tags','not @jruby']
+        else
+          expect(loader.args_from('default')).to eq ['--format','pretty','featuressync_imap_mailbox.feature:16:22','--tags','not @jruby']
+        end
+      end
+
     end
   end
 end

data/spec/cucumber/cli/rerun_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 module Cucumber
@@ -6,77 +7,77 @@ module Cucumber
 
       let(:rerun_file) { RerunFile.new('@rerun.txt') }
 
-      it "expects rerun files to have a leading @" do
+      it 'expects rerun files to have a leading @' do
         allow(File).to receive(:file?) { true }
         expect(RerunFile.can_read?('rerun.txt')).to eq false
         expect(RerunFile.can_read?('@rerun.txt')).to eq true
       end
 
-      it "does not treat directories as rerun files" do
+      it 'does not treat directories as rerun files' do
         allow(File).to receive(:file?) { false }
         expect(RerunFile.can_read?('@rerun.txt')).to eq false
       end
 
-      it "removes leading @ character from filename" do
+      it 'removes leading @ character from filename' do
         expect(rerun_file.path).to eq 'rerun.txt'
       end
 
-      context "rerun file containing single feature" do
+      context 'rerun file containing single feature' do
         before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature")
+          allow(IO).to receive(:read).and_return('cucumber.feature')
         end
 
-        it "produces an array containing a single feature file path" do
+        it 'produces an array containing a single feature file path' do
           expect(rerun_file.features).to eq %w(cucumber.feature)
         end
       end
 
-      context "contains multiple features on multiple lines" do
+      context 'contains multiple features on multiple lines' do
         before(:each) do
           allow(IO).to receive(:read).and_return("cucumber.feature\nfoo.feature")
         end
 
-        it "produces an array containing multiple feature file paths" do
+        it 'produces an array containing multiple feature file paths' do
           expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
         end
       end
 
-      context "contains multiple features on same line" do
+      context 'contains multiple features on same line' do
         before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature foo.feature")
+          allow(IO).to receive(:read).and_return('cucumber.feature foo.feature')
         end
 
-        it "produces an array containing multiple feature file paths" do
+        it 'produces an array containing multiple feature file paths' do
           expect(rerun_file.features).to eq %w(cucumber.feature foo.feature)
         end
       end
 
-      context "contains multiple scenarios on same line" do
+      context 'contains multiple scenarios on same line' do
         before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber.feature:8 foo.feature:8:16")
+          allow(IO).to receive(:read).and_return('cucumber.feature:8 foo.feature:8:16')
         end
 
-        it "produces an array containing multiple feature file paths with scenario lines" do
+        it 'produces an array containing multiple feature file paths with scenario lines' do
           expect(rerun_file.features).to eq %w(cucumber.feature:8 foo.feature:8:16)
         end
       end
 
-      context "contains features with spaces in file names" do
+      context 'contains features with spaces in file names' do
         before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber test.feature:8 foo.feature:8:16")
+          allow(IO).to receive(:read).and_return('cucumber test.feature:8 foo.feature:8:16')
         end
 
-        it "produces an array containing multiple feature file paths with scenario lines" do
+        it 'produces an array containing multiple feature file paths with scenario lines' do
           expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
         end
       end
 
-      context "contains multiple scenarios without spaces between them" do
+      context 'contains multiple scenarios without spaces between them' do
         before(:each) do
-          allow(IO).to receive(:read).and_return("cucumber test.feature:8foo.feature:8:16")
+          allow(IO).to receive(:read).and_return('cucumber test.feature:8foo.feature:8:16')
         end
 
-        it "produces an array containing multiple feature file paths with scenario lines" do
+        it 'produces an array containing multiple feature file paths with scenario lines' do
           expect(rerun_file.features).to eq ['cucumber test.feature:8', 'foo.feature:8:16']
         end
       end