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

data/spec/cucumber/project_initializer_spec.rb

@@ -10,7 +10,7 @@ module Cucumber
       allow(command_line_config).to receive(:puts)
     end
 
-    context "no files created" do
+    context 'no files created' do
       around(:example) do |example|
 
         dir = Dir.mktmpdir
@@ -24,29 +24,29 @@ module Cucumber
         end
       end
 
-      it "should create features directory" do
+      it 'should create features directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features$)
         command_line_config.run
       end
 
-      it "should create step_definitions directory" do
+      it 'should create step_definitions directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/step_definitions$)
         command_line_config.run
       end
 
-      it "should create support directory" do
+      it 'should create support directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support$)
         command_line_config.run
       end
 
-      it "should create env.rb directory" do
+      it 'should create env.rb directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+create\s+features/support/env.rb$)
         command_line_config.run
       end
 
     end
 
-    context "files created" do
+    context 'files created' do
       around(:example) do |example|
         dir = Dir.mktmpdir
         FileUtils.mkdir_p "#{dir}/features"
@@ -63,22 +63,22 @@ module Cucumber
         end
       end
 
-      it "should not create features directory" do
+      it 'should not create features directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features$)
         command_line_config.run
       end
 
-      it "should not create step_definitions directory" do
+      it 'should not create step_definitions directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/step_definitions$)
         command_line_config.run
       end
 
-      it "should not create support directory" do
+      it 'should not create support directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support$)
         command_line_config.run
       end
 
-      it "should not create env.rb directory" do
+      it 'should not create env.rb directory' do
         expect(command_line_config).to receive(:puts).with %r(^\s+exist\s+features/support/env.rb$)
         command_line_config.run
       end

data/spec/cucumber/rake/forked_spec.rb

@@ -11,17 +11,17 @@ module Cucumber
       let(:cucumber_opts) { ['--cuke-option'] }
       let(:feature_files) { ['./some.feature'] }
 
-      context "when running with bundler" do
+      context 'when running with bundler' do
         let(:bundler) { true }
 
         subject { Task::ForkedCucumberRunner.new(
             libs, binary, cucumber_opts, bundler, feature_files) }
 
-        it "does use bundler if bundler is set to true" do
+        it 'does use bundler if bundler is set to true' do
           expect(subject.use_bundler).to be true
         end
 
-        it "uses bundle exec to find cucumber and libraries" do
+        it 'uses bundle exec to find cucumber and libraries' do
           expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
             '-S',
             'bundle',
@@ -31,22 +31,22 @@ module Cucumber
         end
       end
 
-      context "when running without bundler" do
+      context 'when running without bundler' do
         let(:bundler) { false }
 
         subject { Task::ForkedCucumberRunner.new(
             libs, binary, cucumber_opts, bundler, feature_files) }
 
-        it "does not use bundler if bundler is set to false" do
+        it 'does not use bundler if bundler is set to false' do
           expect(subject.use_bundler).to be false
         end
 
-        it "uses well known cucumber location and specified libraries" do
+        it 'uses well known cucumber location and specified libraries' do
           expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
-            "-I",
-            "\"lib\"",
-            "\"#{Cucumber::BINARY }\"",
-            "--cuke-option"] + feature_files
+            '-I',
+            '"lib"',
+            "\"#{Cucumber::BINARY}\"",
+            '--cuke-option'] + feature_files
         end
       end
     end

data/spec/cucumber/rake/task_spec.rb

@@ -7,75 +7,75 @@ module Cucumber
   module Rake
     describe Task do
 
-      describe "#cucumber_opts" do
+      describe '#cucumber_opts' do
         before { subject.cucumber_opts = opts }
 
-        context "when set via array" do
+        context 'when set via array' do
           let(:opts) { %w[ foo bar ] }
           it { expect(subject.cucumber_opts).to be opts }
         end
 
-        context "when set via space-delimited string" do
-          let(:opts) { "foo bar" }
+        context 'when set via space-delimited string' do
+          let(:opts) { 'foo bar' }
           it { expect(subject.cucumber_opts).to eq %w[ foo bar ] }
         end
       end
 
-      describe "#cucumber_opts_with_profile" do
+      describe '#cucumber_opts_with_profile' do
         before do
           subject.cucumber_opts = opts
           subject.profile = profile
         end
 
-        context "with cucumber_opts" do
+        context 'with cucumber_opts' do
           let(:opts) { %w[ foo bar ] }
 
-          context "without profile" do
+          context 'without profile' do
             let(:profile) { nil }
 
-            it "should return just cucumber_opts" do
+            it 'should return just cucumber_opts' do
               expect(subject.cucumber_opts_with_profile).to be opts
             end
           end
 
-          context "with profile" do
-            let(:profile) { "fancy" }
+          context 'with profile' do
+            let(:profile) { 'fancy' }
 
-            it "should combine opts and profile into an array, prepending --profile option" do
+            it 'should combine opts and profile into an array, prepending --profile option' do
               expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy ]
             end
           end
 
-          context "with multiple profiles" do
+          context 'with multiple profiles' do
             let(:profile) { %w[ fancy pants ] }
 
-            it "should combine opts and each profile into an array, prepending --profile option" do
+            it 'should combine opts and each profile into an array, prepending --profile option' do
               expect(subject.cucumber_opts_with_profile).to eq %w[ foo bar --profile fancy --profile pants ]
             end
           end
         end
 
-        context "without cucumber_opts" do
+        context 'without cucumber_opts' do
           let(:opts) { nil }
 
-          context "without profile" do
+          context 'without profile' do
             let(:profile) { nil }
 
             it { expect(subject.cucumber_opts_with_profile).to eq [] }
           end
 
-          context "with profile" do
-            let(:profile) { "fancy" }
+          context 'with profile' do
+            let(:profile) { 'fancy' }
 
-            it "should combine opts and profile into an array, prepending --profile option" do
+            it 'should combine opts and profile into an array, prepending --profile option' do
               expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy ]
             end
           end
 
-          context "with multiple profiles" do
+          context 'with multiple profiles' do
             let(:profile) { %w[ fancy pants ] }
 
-            it "should combine opts and each profile into an array, prepending --profile option" do
+            it 'should combine opts and each profile into an array, prepending --profile option' do
               expect(subject.cucumber_opts_with_profile).to eq %w[ --profile fancy --profile pants ]
             end
           end

data/spec/cucumber/running_test_case_spec.rb

@@ -21,42 +21,42 @@ module Cucumber
       compile [gherkin_doc], receiver
     end
 
-    context "for a regular scenario" do
+    context 'for a regular scenario' do
       let(:gherkin_doc) do
         gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "passing"
+          feature 'feature name' do
+            scenario 'scenario name' do
+              step 'passing'
             end
           end
         end
       end
 
-      it "sets the scenario name correctly" do
-        expect(wrapped_test_case.name).to eq "scenario name"
+      it 'sets the scenario name correctly' do
+        expect(wrapped_test_case.name).to eq 'scenario name'
       end
 
-      it "sets the feature name correctly" do
-        expect(wrapped_test_case.feature.name).to eq "feature name"
+      it 'sets the feature name correctly' do
+        expect(wrapped_test_case.feature.name).to eq 'feature name'
       end
 
-      it "exposes properties of the test_case" do
+      it 'exposes properties of the test_case' do
         expect(wrapped_test_case.location).to eq core_test_case.location
         expect(wrapped_test_case.source).to eq core_test_case.source
         expect(wrapped_test_case.keyword).to eq core_test_case.keyword
       end
 
-      it "exposes properties of the result" do
+      it 'exposes properties of the result' do
         expect(wrapped_test_case.status).to eq result.to_sym
       end
     end
 
-    context "for a failed scenario" do
+    context 'for a failed scenario' do
       let(:gherkin_doc) do
         gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "failed"
+          feature 'feature name' do
+            scenario 'scenario name' do
+              step 'failed'
             end
           end
         end
@@ -68,21 +68,21 @@ module Cucumber
         self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Failed.new(0, exception))
       end
 
-      it "is failed?" do
+      it 'is failed?' do
         expect(wrapped_test_case.failed?).to be_truthy
       end
 
-      it "exposes the exception" do
+      it 'exposes the exception' do
         expect(wrapped_test_case.exception).to eq exception
       end
     end
 
-    context "for a passing scenario" do
+    context 'for a passing scenario' do
       let(:gherkin_doc) do
         gherkin do
-          feature "feature name" do
-            scenario "scenario name" do
-              step "passing"
+          feature 'feature name' do
+            scenario 'scenario name' do
+              step 'passing'
             end
           end
         end
@@ -92,25 +92,25 @@ module Cucumber
         self.wrapped_test_case = self.wrapped_test_case.with_result(Core::Test::Result::Passed.new(0))
       end
 
-      it "is not failed?" do
+      it 'is not failed?' do
         expect(wrapped_test_case.failed?).to be_falsey
       end
 
-      it "#exception is nil" do
+      it '#exception is nil' do
         expect(wrapped_test_case.exception).to be_nil
       end
     end
 
-    context "for a scenario outline" do
+    context 'for a scenario outline' do
       let(:gherkin_doc) do
         gherkin do
-          feature "feature name" do
-            scenario_outline "scenario outline name" do
-              step "passing with <arg1> <arg2>"
+          feature 'feature name' do
+            scenario_outline 'scenario outline name' do
+              step 'passing with <arg1> <arg2>'
 
-              examples "examples name" do
-                row "arg1", "arg2"
-                row "a", "b"
+              examples 'examples name' do
+                row 'arg1', 'arg2'
+                row 'a', 'b'
               end
             end
           end
@@ -118,21 +118,21 @@ module Cucumber
       end
 
       it "sets the test case's name correctly" do
-        expect(wrapped_test_case.name).to eq "scenario outline name, examples name (#1)"
+        expect(wrapped_test_case.name).to eq 'scenario outline name, examples name (#1)'
       end
 
-      it "sets the feature name correctly" do
-        expect(wrapped_test_case.feature.name).to eq "feature name"
+      it 'sets the feature name correctly' do
+        expect(wrapped_test_case.feature.name).to eq 'feature name'
       end
 
-      it "exposes properties of the test_case" do
+      it 'exposes properties of the test_case' do
         expect(wrapped_test_case.location).to eq core_test_case.location
         expect(wrapped_test_case.source).to eq core_test_case.source
         expect(wrapped_test_case.keyword).to eq core_test_case.keyword
       end
 
-      it "exposes the examples table row cell values" do
-        expect(wrapped_test_case.cell_values).to eq ["a", "b"]
+      it 'exposes the examples table row cell values' do
+        expect(wrapped_test_case.cell_values).to eq %w(a b)
       end
 
     end

data/spec/cucumber/runtime/for_programming_languages_spec.rb

@@ -3,35 +3,6 @@ require 'spec_helper'
 
 module Cucumber
   describe Runtime::ForProgrammingLanguages do
-
-    let(:user_interface)  { double('user interface') }
-    subject               { Runtime::SupportCode.new(user_interface) }
-    let(:runtime_facade)  { Runtime::ForProgrammingLanguages.new(subject, user_interface) }
-
-    describe "#doc_string" do
-
-      it 'defaults to a blank content-type' do
-        str = runtime_facade.doc_string('DOC')
-        expect(str).to be_kind_of(MultilineArgument::DocString)
-        expect(str.content_type).to eq('')
-      end
-
-      it 'can have a content type' do
-        str = runtime_facade.doc_string('DOC','ruby')
-        expect(str.content_type).to eq('ruby')
-      end
-
-    end
-
-    describe "#table" do
-
-      it 'produces Ast::Table by #table' do
-        expect(runtime_facade.table(%{
-      | account | description | amount |
-      | INT-100 | Taxi        | 114    |
-      | CUC-101 | Peeler      | 22     |
-        })).to be_kind_of(MultilineArgument::DataTable)
-      end
-    end
+    it 'should probably be inlined'
   end
 end

data/spec/cucumber/runtime_spec.rb

@@ -6,10 +6,10 @@ module Cucumber
     subject { Runtime.new(options) }
     let(:options) { {} }
 
-    describe "#features_paths" do
+    describe '#features_paths' do
       let(:options) { {:paths => ['foo/bar/baz.feature', 'foo/bar/features/baz.feature', 'other_features'] } }
 
-      it "returns the value from configuration.paths" do
+      it 'returns the value from configuration.paths' do
         expect(subject.features_paths).to eq options[:paths]
       end
     end

data/spec/cucumber/step_argument_spec.rb

@@ -4,16 +4,16 @@ require 'cucumber/step_argument'
 
 module Cucumber
   describe StepArgument do
-    it "creates 2 arguments" do
-      arguments = StepArgument.arguments_from(/I (\w+) (\w+)/, "I like fish")
+    it 'creates 2 arguments' do
+      arguments = StepArgument.arguments_from(/I (\w+) (\w+)/, 'I like fish')
 
-      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [["like", 2], ["fish", 7]]
+      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [['like', 2], ['fish', 7]]
     end
 
-    it "creates 2 arguments when first group is optional" do
+    it 'creates 2 arguments when first group is optional' do
       arguments = StepArgument.arguments_from(/should( not)? be flashed '([^']*?)'$/, "I should be flashed 'Login failed.'")
 
-      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ["Login failed.", 21]]
+      expect(arguments.map{|argument| [argument.val, argument.offset]}).to eq [[nil, nil], ['Login failed.', 21]]
     end
   end
 end

data/spec/cucumber/step_match_search_spec.rb

@@ -1,42 +1,42 @@
 # frozen_string_literal: true
 require 'cucumber/step_match_search'
-require 'cucumber/rb_support/rb_dsl'
-require 'cucumber/rb_support/rb_language'
+require 'cucumber/glue/dsl'
+require 'cucumber/glue/registry_and_more'
 require 'cucumber/configuration'
 
 module Cucumber
   describe StepMatchSearch do
 
-    let(:search) { StepMatchSearch.new(rb_language.method(:step_matches), configuration) }
-    let(:rb_language) { RbSupport::RbLanguage.new(runtime, configuration) }
+    let(:search) { StepMatchSearch.new(registry.method(:step_matches), configuration) }
+    let(:registry) { Glue::RegistryAndMore.new(runtime, configuration) }
     let(:runtime) do
-      # TODO: break out step definitions collection from RbLanguage so we don't need this
+      # TODO: break out step definitions collection from Glue::RegistryAndMore so we don't need this
       :unused
     end
     let(:configuration) { Configuration.new(options) }
     let(:options) { {} }
     let(:dsl) do
       # TODO: stop relying on implicit global state
-      rb_language
-      Object.new.extend(RbSupport::RbDsl)
+      registry
+      Object.new.extend(Glue::Dsl)
     end
 
     context 'caching' do
-      it "caches step match results" do
+      it 'caches step match results' do
         dsl.Given(/it (.*) in (.*)/) { |what, month| }
 
-        step_match = search.call("it snows in april").first
+        step_match = search.call('it snows in april').first
 
-        expect(rb_language).not_to receive(:step_matches)
-        second_step_match = search.call("it snows in april").first
+        expect(registry).not_to receive(:step_matches)
+        second_step_match = search.call('it snows in april').first
 
         expect(step_match).to equal(second_step_match)
       end
     end
 
-    describe "resolving step defintion matches" do
+    describe 'resolving step defintion matches' do
 
-      it "raises Ambiguous error with guess hint when multiple step definitions match" do
+      it 'raises Ambiguous error with guess hint when multiple step definitions match' do
         expected_error = %{Ambiguous match of "Three blind mice":
 
 spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three (.*) mice/'
@@ -48,14 +48,14 @@ You can run again with --guess to make Cucumber be more smart about it
         dsl.Given(/Three blind (.*)/) {|animal|}
 
         expect(-> {
-          search.call("Three blind mice").first
+          search.call('Three blind mice').first
         }).to raise_error(Ambiguous, /#{expected_error}/)
       end
 
-      describe "when --guess is used" do
+      describe 'when --guess is used' do
         let(:options) { {:guess => true} }
 
-        it "does not show --guess hint" do
+        it 'does not show --guess hint' do
         expected_error = %{Ambiguous match of "Three cute mice":
 
 spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three (.*) mice/'
@@ -66,48 +66,39 @@ spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three cute (.*)/'
           dsl.Given(/Three cute (.*)/) {|animal|}
 
           expect(-> {
-            search.call("Three cute mice").first
+            search.call('Three cute mice').first
           }).to raise_error(Ambiguous, /#{expected_error}/)
         end
 
-        it "does not raise Ambiguous error when multiple step definitions match" do
+        it 'does not raise Ambiguous error when multiple step definitions match' do
           dsl.Given(/Three (.*) mice/) {|disability|}
           dsl.Given(/Three (.*)/) {|animal|}
 
           expect(-> {
-            search.call("Three blind mice").first
+            search.call('Three blind mice').first
           }).not_to raise_error
         end
 
-        it "does not raise NoMethodError when guessing from multiple step definitions with nil fields" do
-          dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
-          dsl.Given(/Three (.*)?/) {|animal|}
+        it 'picks right step definition when an equal number of capture groups' do
+          right  = dsl.Given(/Three (.*) mice/) {|disability|}
+          _wrong = dsl.Given(/Three (.*)/) {|animal|}
 
-          expect(-> {
-            search.call("Three blind mice").first
-          }).not_to raise_error
-        end
-
-        it "picks right step definition when an equal number of capture groups" do
-          right = dsl.Given(/Three (.*) mice/) {|disability|}
-          wrong = dsl.Given(/Three (.*)/) {|animal|}
-
-          expect(search.call("Three blind mice").first.step_definition).to eq right
+          expect(search.call('Three blind mice').first.step_definition).to eq right
         end
 
-        it "picks right step definition when an unequal number of capture groups" do
-          right = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          wrong = dsl.Given(/Three (.*)/) {|animal|}
+        it 'picks right step definition when an unequal number of capture groups' do
+          right  = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+          _wrong = dsl.Given(/Three (.*)/) {|animal|}
 
-          expect(search.call("Three blind mice ran far").first.step_definition).to eq right
+          expect(search.call('Three blind mice ran far').first.step_definition).to eq right
         end
 
-        it "picks most specific step definition when an unequal number of capture groups" do
-          general       = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-          specific      = dsl.Given(/Three blind mice ran far/) do; end
+        it 'picks most specific step definition when an unequal number of capture groups' do
+          _general      = dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+          _specific     = dsl.Given(/Three blind mice ran far/) do; end
           more_specific = dsl.Given(/^Three blind mice ran far$/) do; end
 
-          expect(search.call("Three blind mice ran far").first.step_definition).to eq more_specific
+          expect(search.call('Three blind mice ran far').first.step_definition).to eq more_specific
         end
       end
 
@@ -120,4 +111,3 @@ spec/cucumber/step_match_search_spec.rb:\\d+:in `/Three cute (.*)/'
     end
   end
 end
-