cucumber 3.0.0.pre.1 → 3.0.0.pre.2

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -18,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
@@ -27,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'
@@ -42,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

@@ -7,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

data/spec/cucumber/configuration_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 
 module Cucumber
   describe Configuration do
-    describe ".default" do
+    describe '.default' do
       subject { Configuration.default }
 
-      it "has an autoload_code_paths containing the standard support and step_definitions folders" do
+      it 'has an autoload_code_paths containing the standard support and step_definitions folders' do
         expect(subject.autoload_code_paths).to include('features/support')
         expect(subject.autoload_code_paths).to include('features/step_definitions')
       end
     end
 
-    describe "with custom user options" do
+    describe 'with custom user options' do
       let(:user_options) { { :autoload_code_paths => ['foo/bar/baz'] } }
       subject { Configuration.new(user_options) }
 
-      it "allows you to override the defaults" do
+      it 'allows you to override the defaults' do
         expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
       end
     end
 
-    context "selecting files to load" do
+    context 'selecting files to load' do
 
       def given_the_following_files(*files)
         allow(File).to receive(:directory?) { true }
@@ -29,114 +29,114 @@ module Cucumber
         allow(Dir).to receive(:[]) { files }
       end
 
-      it "requires env.rb files first" do
+      it 'requires env.rb files first' do
         configuration = Configuration.new
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
         expect(configuration.support_to_load).to eq [
-          "/features/support/env.rb",
-          "/features/support/a_file.rb"
+          '/features/support/env.rb',
+          '/features/support/a_file.rb'
         ]
       end
 
-      it "does not require env.rb files when dry run" do
+      it 'does not require env.rb files when dry run' do
         configuration = Configuration.new(dry_run: true)
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
         expect(configuration.support_to_load).to eq [
-          "/features/support/a_file.rb"
+          '/features/support/a_file.rb'
         ]
       end
 
-      it "requires step defs 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")
+      it 'requires step defs 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')
 
         configuration = Configuration.new
 
         expect(configuration.step_defs_to_load).to eq [
-          "/vendor/gems/gem_a/cucumber/bar.rb",
-          "/vendor/plugins/plugin_a/cucumber/foo.rb"
+          '/vendor/gems/gem_a/cucumber/bar.rb',
+          '/vendor/plugins/plugin_a/cucumber/foo.rb'
         ]
       end
 
-      describe "--exclude" do
+      describe '--exclude' do
 
-        it "excludes a ruby file from requiring when the name matches exactly" do
-          given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        it 'excludes a ruby file from requiring when the name matches exactly' do
+          given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
           configuration = Configuration.new(excludes: [/a_file.rb/])
 
           expect(configuration.all_files_to_load).to eq [
-            "/features/support/env.rb"
+            '/features/support/env.rb'
           ]
         end
 
-        it "excludes all ruby files that match the provided patterns from requiring" do
-          given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
-                                    "/features/support/food.rb","/features/blah.rb",
-                                    "/features/support/fooz.rb")
+        it 'excludes all ruby files that match the provided patterns from requiring' do
+          given_the_following_files('/features/support/foof.rb','/features/support/bar.rb',
+                                    '/features/support/food.rb','/features/blah.rb',
+                                    '/features/support/fooz.rb')
 
           configuration = Configuration.new(excludes: [/foo[df]/, /blah/])
 
           expect(configuration.all_files_to_load).to eq [
-            "/features/support/bar.rb",
-            "/features/support/fooz.rb"
+            '/features/support/bar.rb',
+            '/features/support/fooz.rb'
           ]
         end
       end
 
     end
 
-    context "selecting feature files" do
+    context 'selecting feature files' do
 
-      it "preserves the order of the feature files" do
+      it 'preserves the order of the feature files' do
         configuration = Configuration.new(paths: %w{b.feature c.feature a.feature})
 
-        expect(configuration.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
+        expect(configuration.feature_files).to eq ['b.feature', 'c.feature', 'a.feature']
       end
 
-      it "searchs for all features in the specified directory" do
+      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"] }
+        allow(Dir).to receive(:[]).with('feature_directory/**/*.feature') { ['cucumber.feature'] }
 
         configuration = Configuration.new(paths: %w{feature_directory/})
 
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
+        expect(configuration.feature_files).to eq ['cucumber.feature']
       end
 
-      it "defaults to the features directory when no feature file are provided" do
+      it 'defaults to the features directory when no feature file are provided' do
         allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
+        allow(Dir).to receive(:[]).with('features/**/*.feature') { ['cucumber.feature'] }
 
         configuration = Configuration.new(paths: [])
 
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
+        expect(configuration.feature_files).to eq ['cucumber.feature']
       end
 
-      it "gets the feature files from the rerun file" do
+      it 'gets the feature files from the rerun file' do
         allow(File).to receive(:directory?).and_return(false)
         allow(File).to receive(:file?).and_return(true)
         allow(IO).to receive(:read).and_return(
           "cucumber.feature:1:3\ncucumber.feature:5 cucumber.feature:10\n"\
           "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
-          "domain folder/different cuke.feature:4:5 bar.feature")
+          'domain folder/different cuke.feature:4:5 bar.feature')
 
         configuration = Configuration.new(paths: %w{@rerun.txt})
 
         expect(configuration.feature_files).to eq [
-          "cucumber.feature:1:3",
-          "cucumber.feature:5",
-          "cucumber.feature:10",
-          "domain folder/different cuke.feature:134",
-          "domain folder/cuke.feature:1",
-          "domain folder/different cuke.feature:4:5",
-          "bar.feature"]
+          'cucumber.feature:1:3',
+          'cucumber.feature:5',
+          'cucumber.feature:10',
+          'domain folder/different cuke.feature:134',
+          'domain folder/cuke.feature:1',
+          'domain folder/different cuke.feature:4:5',
+          'bar.feature']
       end
     end
 
-    describe "#with_options" do
-      it "returns a copy of the configuration with new options" do
+    describe '#with_options' do
+      it 'returns a copy of the configuration with new options' do
         old_out_stream = double('Old out_stream')
         new_out_stream = double('New out_stream')
         config = Configuration.new(out_stream: old_out_stream).with_options(out_stream: new_out_stream)

data/spec/cucumber/constantize_spec.rb

@@ -7,13 +7,13 @@ module Cucumber
   describe Constantize do
     include Constantize
 
-    it "loads html formatter" do
+    it 'loads html formatter' do
       clazz = constantize('Cucumber::Formatter::Html')
 
       expect(clazz.name).to eq 'Cucumber::Formatter::Html'
     end
 
-    it "fails to load a made up class" do
+    it 'fails to load a made up class' do
       expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
     end
   end

data/spec/cucumber/events_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cucumber
+  describe Events do
+    it 'builds a registry without failing' do
+      expect { described_class.registry }.not_to raise_error
+    end
+  end
+end

data/spec/cucumber/file_specs_spec.rb

@@ -3,57 +3,57 @@ require 'cucumber/file_specs'
 
 module Cucumber
   describe FileSpecs do
-    let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
+    let(:file_specs) { FileSpecs.new(['features/foo.feature:1:2:3', 'features/bar.feature:4:5:6']) }
     let(:locations) { file_specs.locations }
     let(:files) { file_specs.files }
 
-    it "parses locations from multiple files" do
+    it 'parses locations from multiple files' do
       expect(locations.length).to eq 6
       expect(locations).to eq [
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 2),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 3),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 4),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 5),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 6),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 1),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 2),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 3),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 4),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 5),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 6)
       ]
     end
 
-    it "parses file names from multiple file specs" do
+    it 'parses file names from multiple file specs' do
       expect(files.length).to eq 2
       expect(files).to eq [
-        "features/foo.feature",
-        "features/bar.feature",
+        'features/foo.feature',
+        'features/bar.feature'
       ]
     end
 
-    context "when files are not unique" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
+    context 'when files are not unique' do
+      let(:file_specs) { FileSpecs.new(['features/foo.feature:4', 'features/foo.feature:34']) }
 
-      it "parses unique file names" do
+      it 'parses unique file names' do
         expect(files.length).to eq 1
-        expect(files).to eq ["features/foo.feature"]
+        expect(files).to eq ['features/foo.feature']
       end
     end
 
-    context "when no line number is specified" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature", "features/bar.feature:34"]) }
+    context 'when no line number is specified' do
+      let(:file_specs) { FileSpecs.new(['features/foo.feature', 'features/bar.feature:34']) }
 
-      it "returns a wildcard location for that file" do
+      it 'returns a wildcard location for that file' do
         expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature"),
-          Cucumber::Core::Ast::Location.new("features/bar.feature", 34),
+          Cucumber::Core::Ast::Location.new('features/foo.feature'),
+          Cucumber::Core::Ast::Location.new('features/bar.feature', 34)
         ]
       end
     end
 
-    context "when the same file is referenced more than once" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:10", "features/foo.feature:1"]) }
+    context 'when the same file is referenced more than once' do
+      let(:file_specs) { FileSpecs.new(['features/foo.feature:10', 'features/foo.feature:1']) }
 
-      it "returns locations in the order specified" do
+      it 'returns locations in the order specified' do
         expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 10),
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
+          Cucumber::Core::Ast::Location.new('features/foo.feature', 10),
+          Cucumber::Core::Ast::Location.new('features/foo.feature', 1)
         ]
       end
     end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -14,7 +14,7 @@ describe Cucumber::Filters::ActivateSteps do
   let(:step_match_search) { Proc.new { [step_match] } }
   let(:configuration) { double(dry_run?: false, notify: nil) }
 
-  context "a scenario with a single step" do
+  context 'a scenario with a single step' do
     let(:doc) do
       gherkin do
         feature do
@@ -25,16 +25,16 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step" do
+    it 'activates each step' do
       expect(step_match).to receive(:activate) do |test_step|
         expect(test_step.name).to eq 'a passing step'
       end
       compile [doc], receiver, [filter]
     end
 
-    it "notifies with a StepMatch event" do
+    it 'notifies with a StepActivated event' do
       expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_match
+        expect(message).to eq :step_activated
         expect(test_step.name).to eq 'a passing step'
         expect(step_match).to eq step_match
       end
@@ -42,7 +42,7 @@ describe Cucumber::Filters::ActivateSteps do
     end
   end
 
-  context "a scenario outline" do
+  context 'a scenario outline' do
     let(:doc) do
       gherkin do
         feature do
@@ -58,7 +58,7 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step" do
+    it 'activates each step' do
       expect(step_match).to receive(:activate) do |test_step|
         expect(test_step.name).to eq 'a passing step'
       end
@@ -66,7 +66,7 @@ describe Cucumber::Filters::ActivateSteps do
     end
   end
 
-  context "undefined step" do
+  context 'undefined step' do
     let(:step_match_search) { Proc.new { [] } }
 
     let(:doc) do
@@ -79,20 +79,20 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "does not activate the step" do
+    it 'does not activate the step' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_undefined
       end
       compile [doc], receiver, [filter]
     end
 
-    it "does not notify" do
+    it 'does not notify' do
       expect(configuration).not_to receive(:notify)
       compile [doc], receiver, [filter]
     end
   end
 
-  context "dry run" do
+  context 'dry run' do
     let(:configuration) { double(dry_run?: true, notify: nil) }
 
     let(:doc) do
@@ -105,16 +105,16 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step with a skipping action" do
+    it 'activates each step with a skipping action' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_skipped
       end
       compile [doc], receiver, [filter]
     end
 
-    it "notifies with a StepMatch event" do
+    it 'notifies with a StepActivated event' do
       expect(configuration).to receive(:notify) do |message, test_step, step_match|
-        expect(message).to eq :step_match
+        expect(message).to eq :step_activated
         expect(test_step.name).to eq 'a passing step'
         expect(step_match).to eq step_match
       end
@@ -122,7 +122,7 @@ describe Cucumber::Filters::ActivateSteps do
     end
   end
 
-  context "undefined step in a dry run" do
+  context 'undefined step in a dry run' do
     let(:step_match_search) { Proc.new { [] } }
     let(:configuration) { double(dry_run?: true, notify: nil) }
 
@@ -136,14 +136,14 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "does not activate the step" do
+    it 'does not activate the step' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_undefined
       end
       compile [doc], receiver, [filter]
     end
 
-    it "does not notify" do
+    it 'does not notify' do
       expect(configuration).not_to receive(:notify)
       compile [doc], receiver, [filter]
     end