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

data/spec/cucumber/formatter/progress_spec.rb

@@ -16,12 +16,12 @@ module Cucumber
         @formatter = Progress.new(actual_runtime.configuration.with_options(out_stream: @out))
       end
 
-      describe "given a single feature" do
+      describe 'given a single feature' do
         before(:each) do
           run_defined_feature
         end
 
-        describe "with a scenario" do
+        describe 'with a scenario' do
           define_feature <<-FEATURE
             Feature: Banana party
 
@@ -29,12 +29,12 @@ module Cucumber
                 Given there are bananas
           FEATURE
 
-          it "outputs the undefined step" do
+          it 'outputs the undefined step' do
             expect(@out.string).to include "U\n"
           end
         end
 
-        describe "with a background" do
+        describe 'with a background' do
           define_feature <<-FEATURE
             Feature: Banana party
 
@@ -45,12 +45,12 @@ module Cucumber
                 Given there are bananas
           FEATURE
 
-          it "outputs the two undefined steps" do
+          it 'outputs the two undefined steps' do
             expect(@out.string).to include "UU\n"
           end
         end
 
-        describe "with a scenario outline" do
+        describe 'with a scenario outline' do
           define_feature <<-FEATURE
             Feature: Fud Pyramid
 
@@ -67,23 +67,23 @@ module Cucumber
                  | carrots  |
           FEATURE
 
-          it "outputs each undefined step" do
+          it 'outputs each undefined step' do
             expect(@out.string).to include "UUUU\n"
           end
 
-          it "has 4 undefined scenarios" do
-            expect(@out.string).to include "4 scenarios (4 undefined)"
+          it 'has 4 undefined scenarios' do
+            expect(@out.string).to include '4 scenarios (4 undefined)'
           end
 
-          it "has 4 undefined steps" do
-            expect(@out.string).to include "4 steps (4 undefined)"
+          it 'has 4 undefined steps' do
+            expect(@out.string).to include '4 steps (4 undefined)'
           end
 
         end
 
-        describe "with hooks" do
+        describe 'with hooks' do
 
-          describe "all hook passes" do
+          describe 'all hook passes' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -100,7 +100,7 @@ module Cucumber
               Given(/^this step passes$/) {}
             end
 
-            it "only steps generate output" do
+            it 'only steps generate output' do
               lines = <<-OUTPUT
               .
               1 scenario (1 passed)
@@ -112,7 +112,7 @@ module Cucumber
             end
           end
 
-          describe "with a failing before hook" do
+          describe 'with a failing before hook' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -121,12 +121,12 @@ module Cucumber
 
             define_steps do
               Before do
-                fail "hook failed" 
+                fail 'hook failed'
               end
               Given(/^this step passes$/) {}
             end
 
-            it "the failing hook generate output" do
+            it 'the failing hook generate output' do
               lines = <<-OUTPUT
               F-
               1 scenario (1 failed)
@@ -138,7 +138,7 @@ module Cucumber
             end
           end
 
-          describe "with a failing after hook" do
+          describe 'with a failing after hook' do
             define_feature <<-FEATURE
           Feature:
             Scenario:
@@ -147,12 +147,12 @@ module Cucumber
 
             define_steps do
               After do
-                fail "hook failed" 
+                fail 'hook failed'
               end
               Given(/^this step passes$/) {}
             end
 
-            it "the failing hook generate output" do
+            it 'the failing hook generate output' do
               lines = <<-OUTPUT
               .F
               1 scenario (1 failed)

data/spec/cucumber/formatter/rerun_spec.rb

@@ -71,7 +71,7 @@ module Cucumber
           execute [foo, bar], [StandardStepActions.new], config.event_bus
           config.event_bus.test_run_finished
 
-          expect(io.string).to eq 'foo.feature:3:6 bar.feature:3'
+          expect(io.string).to eq 'foo.feature:3:6\nbar.feature:3'
         end
       end
 

data/spec/cucumber/formatter/spec_helper.rb

@@ -25,7 +25,7 @@ module Cucumber
         receiver = Test::Runner.new(event_bus)
         filters = [
           Filters::ActivateSteps.new(
-            StepMatchSearch.new(actual_runtime.support_code.ruby.method(:step_matches), actual_runtime.configuration),
+            StepMatchSearch.new(actual_runtime.support_code.registry.method(:step_matches), actual_runtime.configuration),
             actual_runtime.configuration
           ),
           Filters::ApplyAfterStepHooks.new(actual_runtime.support_code),
@@ -52,7 +52,7 @@ module Cucumber
       end
 
       def gherkin
-        self.class.feature_content || raise("No feature content defined!")
+        self.class.feature_content || raise('No feature content defined!')
       end
 
       def runtime
@@ -68,10 +68,11 @@ module Cucumber
       end
 
       def define_steps
-        return unless step_defs = self.class.step_defs
-        rb = runtime.support_code.ruby
+        step_defs = self.class.step_defs
+
+        return unless step_defs
         dsl = Object.new
-        dsl.extend RbSupport::RbDsl
+        dsl.extend Glue::Dsl
         dsl.instance_exec &step_defs
       end
 

data/spec/cucumber/{rb_support/rb_world_spec.rb → glue/proto_world_spec.rb}

@@ -4,12 +4,27 @@ require 'cucumber/formatter/spec_helper'
 require 'cucumber/formatter/pretty'
 
 module Cucumber
-  module RbSupport
-    describe RbWorld do
-      extend Cucumber::Formatter::SpecHelperDsl
-      include Cucumber::Formatter::SpecHelper
+  module Glue
+    describe ProtoWorld do
+
+      let(:runtime) { double('runtime') }
+      let(:language) { double('language') }
+      let(:world) { Object.new.extend(ProtoWorld.for(runtime, language)) }
+
+      describe '#table' do
+        it 'produces Ast::Table by #table' do
+          expect(world.table(%{
+        | account | description | amount |
+        | INT-100 | Taxi        | 114    |
+        | CUC-101 | Peeler      | 22     |
+          })).to be_kind_of(MultilineArgument::DataTable)
+        end
+      end
 
       describe 'Handling puts in step definitions' do
+        extend Cucumber::Formatter::SpecHelperDsl
+        include Cucumber::Formatter::SpecHelper
+
         before(:each) do
           Cucumber::Term::ANSIColor.coloring = false
           @out = StringIO.new
@@ -35,7 +50,7 @@ module Cucumber
           end
 
           it 'prints the variable value at the time puts was called' do
-            expect( @out.string ).to include <<OUTPUT
+            expect(@out.string).to include <<OUTPUT
     When puts is called twice for the same variable
       a
       A

data/spec/cucumber/glue/registry_and_more_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'cucumber/glue/registry_and_more'
+
+module Cucumber
+  module Glue
+    describe StepDefinition do
+      let(:user_interface) { double('user interface') }
+      let(:registry)       { support_code.registry }
+      let(:support_code) do
+        Cucumber::Runtime::SupportCode.new(user_interface)
+      end
+      let(:dsl) do
+        registry
+        Object.new.extend(Glue::Dsl)
+      end
+
+      describe '#load_code_file' do
+        after do
+          FileUtils.rm_rf('tmp.rb')
+          FileUtils.rm_rf('docs.md')
+        end
+
+        def a_file_called(name)
+          File.open(name, 'w') do |f|
+            f.puts yield
+          end
+        end
+
+        it 're-loads the file when called multiple times' do
+          a_file_called('tmp.rb') do
+            '$foo = 1'
+          end
+
+          registry.load_code_file('tmp.rb')
+          expect($foo).to eq 1
+
+          a_file_called('tmp.rb') do
+            '$foo = 2'
+          end
+
+          registry.load_code_file('tmp.rb')
+
+          expect($foo).to eq 2
+        end
+
+        it 'only loads ruby files' do
+          a_file_called('docs.md') do
+            'yo'
+          end
+          registry.load_code_file('docs.md')
+        end
+      end
+
+      describe 'Handling the World' do
+        it 'raises an error if the world is nil' do
+          dsl.World {}
+
+          begin
+            registry.begin_scenario(nil)
+            raise 'Should fail'
+          rescue Glue::NilWorld => e
+            expect(e.message).to eq 'World procs should never return nil'
+            expect(e.backtrace.length).to eq 1
+            expect(e.backtrace[0]).to match(/spec\/cucumber\/glue\/registry_and_more_spec\.rb\:\d+\:in `World'/)
+          end
+        end
+
+        module ModuleOne
+        end
+
+        module ModuleTwo
+        end
+
+        class ClassOne
+        end
+
+        it 'implicitlys extend world with modules' do
+          dsl.World(ModuleOne, ModuleTwo)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+
+            expect(included_modules.inspect).to match(/ModuleOne/) # Workaround for RSpec/Ruby 1.9 issue with namespaces
+            expect(included_modules.inspect).to match(/ModuleTwo/)
+          end
+          expect(registry.current_world.class).to eq Object
+        end
+
+        it 'raises error when we try to register more than one World proc' do
+          expected_error = %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/glue/registry_and_more_spec.rb:\\d+:in `World'
+spec/cucumber/glue/registry_and_more_spec.rb:\\d+:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::Glue::Dsl#World RDoc
+or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
+
+}
+          dsl.World { Hash.new }
+
+          expect(-> {
+            dsl.World { Array.new }
+          }).to raise_error(Glue::MultipleWorld, /#{expected_error}/)
+        end
+      end
+
+      describe 'Handling namespaced World' do
+        module ModuleOne
+          def method_one
+            1
+          end
+        end
+
+        module ModuleMinusOne
+          def method_one
+            -1
+          end
+        end
+
+        module ModuleTwo
+          def method_two
+            2
+          end
+        end
+
+        module ModuleThree
+          def method_three
+            3
+          end
+        end
+
+        it 'extends the world with namespaces' do
+          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+            expect(included_modules.inspect).to match(/ModuleOne/)
+          end
+          expect(registry.current_world.class).to eq Object
+          expect(registry.current_world).to respond_to(:method_one)
+
+          expect(registry.current_world.module_two.class).to eq Object
+          expect(registry.current_world.module_two).to respond_to(:method_two)
+
+          expect(registry.current_world.module_three.class).to eq Object
+          expect(registry.current_world.module_three).to respond_to(:method_three)
+        end
+
+        it 'allows to inspect the included modules' do
+          dsl.World(ModuleOne, module_two: ModuleTwo, module_three: ModuleThree)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.inspect).to match(/ModuleOne/)
+          expect(registry.current_world.inspect).to include('ModuleTwo (as module_two)')
+          expect(registry.current_world.inspect).to include('ModuleThree (as module_three)')
+        end
+
+        it 'merges methods when assigning different modules to the same namespace' do
+          dsl.World(namespace: ModuleOne)
+          dsl.World(namespace: ModuleTwo)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.namespace).to respond_to(:method_one)
+          expect(registry.current_world.namespace).to respond_to(:method_two)
+        end
+
+        it 'resolves conflicts when assigning different modules to the same namespace' do
+          dsl.World(namespace: ModuleOne)
+          dsl.World(namespace: ModuleMinusOne)
+          registry.begin_scenario(double('scenario').as_null_object)
+          class << registry.current_world
+            extend RSpec::Matchers
+          end
+          expect(registry.current_world.namespace).to respond_to(:method_one)
+          expect(registry.current_world.namespace.method_one).to eql(-1)
+        end
+      end
+
+      describe 'hooks' do
+        it 'finds before hooks' do
+          fish = dsl.Before('@fish'){}
+          meat = dsl.Before('@meat'){}
+
+          scenario = double('Scenario')
+
+          expect(scenario).to receive(:accept_hook?).with(fish) { true }
+          expect(scenario).to receive(:accept_hook?).with(meat) { false }
+          expect(registry.hooks_for(:before, scenario)).to eq [fish]
+        end
+
+        it 'finds around hooks' do
+          a = dsl.Around do |scenario, block|
+          end
+
+          b = dsl.Around('@tag') do |scenario, block|
+          end
+
+          scenario = double('Scenario')
+
+          expect(scenario).to receive(:accept_hook?).with(a) { true }
+          expect(scenario).to receive(:accept_hook?).with(b) { false }
+          expect(registry.hooks_for(:around, scenario)).to eq [a]
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/{rb_support → glue}/snippet_spec.rb

@@ -1,19 +1,24 @@
 # frozen_string_literal: true
 require 'spec_helper'
-require 'cucumber/rb_support/snippet'
+require 'cucumber/cucumber_expressions/parameter_type_registry'
+require 'cucumber/cucumber_expressions/parameter_type'
+require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/glue/snippet'
 
 module Cucumber
-  module RbSupport
+  module Glue
     describe Snippet do
-      let(:code_keyword) { "Given" }
+      let(:code_keyword) { 'Given' }
 
       before do
-        @pattern = 'we have a missing step'
+        @step_text = 'we have a missing step'
         @multiline_argument = Core::Ast::EmptyMultilineArgument.new
+        @registry = CucumberExpressions::ParameterTypeRegistry.new
+        @cucumber_expression_generator = CucumberExpressions::CucumberExpressionGenerator.new(@registry)
       end
 
       let(:snippet) do
-        snippet_class.new(code_keyword, @pattern, @multiline_argument)
+        snippet_class.new(@cucumber_expression_generator, code_keyword, @step_text, @multiline_argument)
       end
 
       def unindented(s)
@@ -24,8 +29,8 @@ module Cucumber
         let(:snippet_class) { Snippet::Regexp }
         let(:snippet_text) { snippet.to_s }
 
-        it "wraps snippet patterns in parentheses" do
-          @pattern = 'A "string" with 4 spaces'
+        it 'wraps snippet patterns in parentheses' do
+          @step_text = 'A "string" with 4 spaces'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" with (\\d+) spaces$/) do |arg1, arg2|
@@ -34,8 +39,8 @@ module Cucumber
           })
         end
 
-        it "recognises numbers in name and make according regexp" do
-          @pattern = 'Cloud 9 yeah'
+        it 'recognises numbers in name and make according regexp' do
+          @step_text = 'Cloud 9 yeah'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^Cloud (\\d+) yeah$/) do |arg1|
@@ -44,8 +49,8 @@ module Cucumber
           })
         end
 
-        it "recognises a mix of ints, strings and why not a table too" do
-          @pattern = 'I have 9 "awesome" cukes in 37 "boxes"'
+        it 'recognises a mix of ints, strings and why not a table too' do
+          @step_text = 'I have 9 "awesome" cukes in 37 "boxes"'
           @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
@@ -56,8 +61,8 @@ module Cucumber
           })
         end
 
-        it "recognises quotes in name and make according regexp" do
-          @pattern = 'A "first" arg'
+        it 'recognises quotes in name and make according regexp' do
+          @step_text = 'A "first" arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" arg$/) do |arg1|
@@ -66,8 +71,8 @@ module Cucumber
           })
         end
 
-        it "recognises several quoted words in name and make according regexp and args" do
-          @pattern = 'A "first" and "second" arg'
+        it 'recognises several quoted words in name and make according regexp and args' do
+          @step_text = 'A "first" and "second" arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" and "([^"]*)" arg$/) do |arg1, arg2|
@@ -76,8 +81,8 @@ module Cucumber
           })
         end
 
-        it "does not use quote group when there are no quotes" do
-          @pattern = 'A first arg'
+        it 'does not use quote group when there are no quotes' do
+          @step_text = 'A first arg'
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A first arg$/) do
@@ -86,9 +91,9 @@ module Cucumber
           })
         end
 
-        it "is helpful with tables" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(""))
+        it 'is helpful with tables' do
+          @step_text = 'A "first" arg'
+          @multiline_argument = Core::Ast::DataTable.new([[]], Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" arg$/) do |arg1, table|
@@ -98,9 +103,9 @@ module Cucumber
           })
         end
 
-        it "is helpful with doc string" do
-          @pattern = 'A "first" arg'
-          @multiline_argument = MultilineArgument.from("", Core::Ast::Location.new(""))
+        it 'is helpful with doc string' do
+          @step_text = 'A "first" arg'
+          @multiline_argument = MultilineArgument.from('', Core::Ast::Location.new(''))
 
           expect(snippet_text).to eq unindented(%{
           Given(/^A "([^"]*)" arg$/) do |arg1, string|
@@ -113,7 +118,7 @@ module Cucumber
       describe Snippet::Classic do
         let(:snippet_class) { Snippet::Classic }
 
-        it "renders snippet as unwrapped regular expression" do
+        it 'renders snippet as unwrapped regular expression' do
           expect(snippet.to_s).to eq unindented(%{
           Given /^we have a missing step$/ do
             pending # Write code here that turns the phrase above into concrete actions
@@ -125,7 +130,7 @@ module Cucumber
       describe Snippet::Percent do
         let(:snippet_class) { Snippet::Percent }
 
-        it "renders snippet as percent-style regular expression" do
+        it 'renders snippet as percent-style regular expression' do
           expect(snippet.to_s).to eq unindented(%{
           Given %r{^we have a missing step$} do
             pending # Write code here that turns the phrase above into concrete actions
@@ -133,6 +138,37 @@ module Cucumber
           })
         end
       end
+
+      describe Snippet::CucumberExpression do
+        let(:snippet_class) { Snippet::CucumberExpression }
+
+        it 'renders snippet as cucumber expression' do
+          @step_text = 'I have 2.3 cukes in my belly'
+          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
+                                            'veg',
+                                            /(cuke|banana)s?/,
+                                            Object,
+                                            ->(s) { s},
+                                            true,
+                                            false
+          ))
+          @registry.define_parameter_type(CucumberExpressions::ParameterType.new(
+                                            'cucumis',
+                                            /(bella|cuke)s?/,
+                                            Object,
+                                            ->(s) { s},
+                                            true,
+                                            false
+          ))
+
+          expect(snippet.to_s).to eq unindented(%{
+          Given("I have {float} {cucumis} in my belly") do |float, cucumis|
+          # Given("I have {float} {veg} in my belly") do |float, veg|
+            pending # Write code here that turns the phrase above into concrete actions
+          end
+          })
+        end
+      end
     end
   end
 end