cucumber 0.9.2 → 0.9.3

data/lib/cucumber/step_definitions.rb

@@ -8,9 +8,7 @@ module Cucumber
     end
     
     def to_json
-      @support_code.step_definitions.map do |step_definition|
-        step_definition.regexp_source
-      end.to_json
+      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
     end
   end
 end

data/spec/cucumber/cli/main_spec.rb

@@ -11,6 +11,35 @@ module Cucumber
         File.stub!(:exist?).and_return(false) # When Configuration checks for cucumber.yml
         Dir.stub!(:[]).and_return([]) # to prevent cucumber's features dir to being laoded
       end
+      
+      let(:args)       { [] }
+      let(:out_stream) { nil }
+      let(:err_stream) { nil }
+      subject { Main.new(args, out_stream, err_stream)}
+      
+      describe "#execute!" do
+        context "passed an existing runtime" do
+          let(:existing_runtime) { double('runtime').as_null_object }
+          
+          def do_execute
+            subject.execute!(existing_runtime)
+          end
+          
+          it "configures that runtime" do
+            expected_configuration = double('Configuration', :drb? => false).as_null_object
+            Configuration.stub!(:new => expected_configuration)
+            existing_runtime.should_receive(:configure).with(expected_configuration)
+            do_execute
+          end
+          
+          it "uses that runtime for running and reporting results" do
+            expected_results = double('results', :failure? => true)
+            existing_runtime.should_receive(:run!)
+            existing_runtime.stub!(:results).and_return(expected_results)
+            do_execute.should == expected_results.failure?
+          end
+        end
+      end
 
       describe "verbose mode" do
 
@@ -32,9 +61,7 @@ module Cucumber
       end
 
       describe "--format with class" do
-
-       describe "in module" do
-
+        describe "in module" do
           it "should resolve each module until it gets Formatter class" do
             cli = Main.new(%w{--format ZooModule::MonkeyFormatterClass}, nil)
             mock_module = mock('module')
@@ -48,7 +75,6 @@ module Cucumber
 
             cli.execute!
           end
-
         end
       end
 

data/spec/cucumber/formatter/spec_helper.rb

@@ -35,14 +35,14 @@ module Cucumber
     
       def run(features)
         configuration = Cucumber::Configuration.default
-        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], configuration)
+        tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
         tree_walker.visit_features(features)
       end
     
       def define_steps
         return unless step_defs = self.class.step_defs
-        rb = @step_mother.load_programming_language('rb')
-        dsl = Object.new 
+        rb = step_mother.load_programming_language('rb')
+        dsl = Object.new
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs
       end 

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -6,65 +6,74 @@ require 'cucumber/rb_support/rb_language'
 module Cucumber
   module RbSupport
     describe RbStepDefinition do
-      let(:runtime) { Cucumber::Runtime.new }
-      before do      
-        @rb = runtime.load_programming_language('rb')
+      let(:user_interface) { double('user interface') }
+      let(:rb)             { support_code.load_programming_language('rb')}
+      let(:support_code) do
+        Cucumber::Runtime::SupportCode.new(user_interface, {})
+      end
+      let(:dsl) do 
+        rb
+        Object.new.extend(RbSupport::RbDsl)
       end
 
       def unindented(s)
         s.split("\n")[1..-2].join("\n").indent(-10)
       end
+      
+      describe "snippets" do
     
-      it "should recognise numbers in name and make according regexp" do
-        @rb.snippet_text('Given', 'Cloud 9 yeah', nil).should == unindented(%{
+        it "should recognise numbers in name and make according regexp" do
+          rb.snippet_text('Given', 'Cloud 9 yeah', nil).should == unindented(%{
           Given /^Cloud (\\d+) yeah$/ do |arg1|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise a mix of ints, strings and why not a table too" do
-        @rb.snippet_text('Given', 'I have 9 "awesome" cukes in 37 "boxes"', Cucumber::Ast::Table).should == unindented(%{
+        it "should recognise a mix of ints, strings and why not a table too" do
+          rb.snippet_text('Given', 'I have 9 "awesome" cukes in 37 "boxes"', Cucumber::Ast::Table).should == unindented(%{
           Given /^I have (\\d+) "([^"]*)" cukes in (\\d+) "([^"]*)"$/ do |arg1, arg2, arg3, arg4, table|
             # table is a Cucumber::Ast::Table
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise quotes in name and make according regexp" do
-        @rb.snippet_text('Given', 'A "first" arg', nil).should == unindented(%{
+        it "should recognise quotes in name and make according regexp" do
+          rb.snippet_text('Given', 'A "first" arg', nil).should == unindented(%{
           Given /^A "([^"]*)" arg$/ do |arg1|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should recognise several quoted words in name and make according regexp and args" do
-        @rb.snippet_text('Given', 'A "first" and "second" arg', nil).should == unindented(%{
+        it "should recognise several quoted words in name and make according regexp and args" do
+          rb.snippet_text('Given', 'A "first" and "second" arg', nil).should == unindented(%{
           Given /^A "([^"]*)" and "([^"]*)" arg$/ do |arg1, arg2|
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
       
-      it "should not use quote group when there are no quotes" do
-        @rb.snippet_text('Given', 'A first arg', nil).should == unindented(%{
+        it "should not use quote group when there are no quotes" do
+          rb.snippet_text('Given', 'A first arg', nil).should == unindented(%{
           Given /^A first arg$/ do
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
 
-      it "should be helpful with tables" do
-        @rb.snippet_text('Given', 'A "first" arg', Cucumber::Ast::Table).should == unindented(%{
+        it "should be helpful with tables" do
+          rb.snippet_text('Given', 'A "first" arg', Cucumber::Ast::Table).should == unindented(%{
           Given /^A "([^"]*)" arg$/ do |arg1, table|
             # table is a Cucumber::Ast::Table
             pending # express the regexp above with the code you wish you had
           end
-        })
-      end
+          })
+        end
       
+      end
+    
       describe "#load_code_file" do
         after do
           FileUtils.rm_rf('tmp.rb')
@@ -81,17 +90,194 @@ module Cucumber
             "$foo = 1"
           end
           
-          @rb.load_code_file('tmp.rb')
+          rb.load_code_file('tmp.rb')
           $foo.should == 1
           
           a_file_called('tmp.rb') do
             "$foo = 2"
           end
           
-          @rb.load_code_file('tmp.rb')
+          rb.load_code_file('tmp.rb')
           $foo.should == 2
         end
       end
+
+      describe "Handling the World" do
+
+        it "should raise an error if the world is nil" do
+          dsl.World {}
+
+          begin
+            rb.before(nil)
+            raise "Should fail"
+          rescue RbSupport::NilWorld => e
+            e.message.should == "World procs should never return nil"
+            e.backtrace.length.should == 1
+            e.backtrace[0].should =~ /spec\/cucumber\/rb_support\/rb_language_spec\.rb\:\d+\:in `World'/
+          end
+        end
+
+        module ModuleOne
+        end
+
+        module ModuleTwo
+        end
+
+        class ClassOne
+        end
+
+        it "should implicitly extend world with modules" do
+          dsl.World(ModuleOne, ModuleTwo)
+          rb.before(mock('scenario').as_null_object)
+          class << rb.current_world
+            included_modules.inspect.should =~ /ModuleOne/ # Workaround for RSpec/Ruby 1.9 issue with namespaces
+            included_modules.inspect.should =~ /ModuleTwo/
+          end
+          rb.current_world.class.should == Object
+        end
+
+        it "should raise 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/rb_support/rb_language_spec.rb:\\d+:in `World'
+spec/cucumber/rb_support/rb_language_spec.rb:\\d+:in `World'
+
+Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
+or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
+
+}
+          dsl.World { Hash.new }
+          lambda do
+            dsl.World { Array.new }
+          end.should raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
+
+        end
+      end
+
+      describe "step argument transformations" do
+
+        describe "without capture groups" do
+          it "complains when registering with a with no transform block" do
+            lambda do
+              dsl.Transform('^abc$')
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a zero-arg transform block" do
+            lambda do
+              dsl.Transform('^abc$') {42}
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a splat-arg transform block" do
+            lambda do
+              dsl.Transform('^abc$') {|*splat| 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when transforming with an arity mismatch" do
+            lambda do
+              dsl.Transform('^abc$') {|one, two| 42 }
+              rb.execute_transforms(['abc'])
+            end.should raise_error(Cucumber::ArityMismatchError)
+          end
+
+          it "allows registering a regexp pattern that yields the step_arg matched" do
+            dsl.Transform(/^ab*c$/) {|arg| 42}
+            rb.execute_transforms(['ab']).should == ['ab']
+            rb.execute_transforms(['ac']).should == [42]
+            rb.execute_transforms(['abc']).should == [42]
+            rb.execute_transforms(['abbc']).should == [42]
+          end
+        end
+
+        describe "with capture groups" do
+          it "complains when registering with a with no transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$')
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a zero-arg transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$') { 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when registering with a splat-arg transform block" do
+            lambda do
+              dsl.Transform('^a(.)c$') {|*splat| 42 }
+            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+          end
+
+          it "complains when transforming with an arity mismatch" do
+            lambda do
+              dsl.Transform('^a(.)c$') {|one, two| 42 }
+              rb.execute_transforms(['abc'])
+            end.should raise_error(Cucumber::ArityMismatchError)
+          end
+
+          it "allows registering a regexp pattern that yields capture groups" do
+            dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+              {shape.to_sym => color.to_sym}
+            end
+            rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
+            rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
+            rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+          end
+        end
+
+        it "allows registering a string pattern" do
+          dsl.Transform('^ab*c$') {|arg| 42}
+          rb.execute_transforms(['ab']).should == ['ab']
+          rb.execute_transforms(['ac']).should == [42]
+          rb.execute_transforms(['abc']).should == [42]
+          rb.execute_transforms(['abbc']).should == [42]
+        end
+
+        it "gives match priority to transforms defined last" do
+          dsl.Transform(/^transform_me$/) {|arg| :foo }
+          dsl.Transform(/^transform_me$/) {|arg| :bar }
+          dsl.Transform(/^transform_me$/) {|arg| :baz }
+          rb.execute_transforms(['transform_me']).should == [:baz]
+        end
+
+        it "allows registering a transform which returns nil" do
+          dsl.Transform('^ac$') {|arg| nil}
+          rb.execute_transforms(['ab']).should == ['ab']
+          rb.execute_transforms(['ac']).should == [nil]
+        end
+      end
+
+      describe "hooks" do
+
+        it "should find before hooks" do
+          fish = dsl.Before('@fish'){}
+          meat = dsl.Before('@meat'){}
+
+          scenario = mock('Scenario')
+          scenario.should_receive(:accept_hook?).with(fish).and_return(true)
+          scenario.should_receive(:accept_hook?).with(meat).and_return(false)
+
+          rb.hooks_for(:before, scenario).should == [fish]
+        end
+
+        it "should find around hooks" do
+          a = dsl.Around do |scenario, block|
+          end
+
+          b = dsl.Around('@tag') do |scenario, block|
+          end
+
+          scenario = mock('Scenario')
+          scenario.should_receive(:accept_hook?).with(a).and_return(true)
+          scenario.should_receive(:accept_hook?).with(b).and_return(false)
+
+          rb.hooks_for(:around, scenario).should == [a]
+        end
+      end
+
     end
   end
 end

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -7,86 +7,92 @@ require 'cucumber/rb_support/rb_language'
 module Cucumber
   module RbSupport
     describe RbStepDefinition do
+      let(:user_interface) { double('user interface') }
+      let(:support_code) { Cucumber::Runtime::SupportCode.new(user_interface) }
+      let(:rb)      { support_code.load_programming_language('rb')}
+      let(:dsl) do 
+        rb
+        Object.new.extend(Cucumber::RbSupport::RbDsl)
+      end
+      
       before do      
-        @step_mother = Cucumber::Runtime.new
-        @rb = @step_mother.load_programming_language('rb')
-        @dsl = Object.new 
-        @dsl.extend Cucumber::RbSupport::RbDsl
-        @step_mother.before(mock('scenario').as_null_object)
+        rb.before(mock('scenario').as_null_object)
 
         $inside = nil
       end
       
       it "should allow calling of other steps" do
-        @dsl.Given /Outside/ do
+        dsl.Given /Outside/ do
           Given "Inside"
         end
-        @dsl.Given /Inside/ do
+        dsl.Given /Inside/ do
           $inside = true
         end
 
-        @step_mother.step_match("Outside").invoke(nil)
+        support_code.step_match("Outside").invoke(nil)
         $inside.should == true
       end
 
       it "should allow calling of other steps with inline arg" do
-        @dsl.Given /Outside/ do
+        dsl.Given /Outside/ do
           Given "Inside", Cucumber::Ast::Table.new([['inside']])
         end
-        @dsl.Given /Inside/ do |table|
+        dsl.Given /Inside/ do |table|
           $inside = table.raw[0][0]
         end
 
-        @step_mother.step_match("Outside").invoke(nil)
+        support_code.step_match("Outside").invoke(nil)
         $inside.should == 'inside'
       end
 
       it "should raise Undefined when inside step is not defined" do
-        @dsl.Given /Outside/ do
+        dsl.Given /Outside/ do
           Given 'Inside'
         end
 
         lambda do
-          @step_mother.step_match('Outside').invoke(nil)
+          support_code.step_match('Outside').invoke(nil)
         end.should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
       end
 
       it "should allow forced pending" do
-        @dsl.Given /Outside/ do
+        dsl.Given /Outside/ do
           pending("Do me!")
         end
 
         lambda do
-          @step_mother.step_match("Outside").invoke(nil)
+          support_code.step_match("Outside").invoke(nil)
         end.should raise_error(Cucumber::Pending, "Do me!")
       end
 
       it "should raise ArityMismatchError when the number of capture groups differs from the number of step arguments" do
-        @dsl.Given /No group: \w+/ do |arg|
+        dsl.Given /No group: \w+/ do |arg|
         end
 
         lambda do
-          @step_mother.step_match("No group: arg").invoke(nil)
+          support_code.step_match("No group: arg").invoke(nil)
         end.should raise_error(Cucumber::ArityMismatchError)
       end
 
       it "should allow announce" do
-        v = mock('visitor')
-        v.should_receive(:announce).with('wasup')
-        @step_mother.visitor = v
-        @dsl.Given /Loud/ do
+        user_interface.should_receive(:announce).with('wasup')
+        dsl.Given /Loud/ do
           announce 'wasup'
         end
         
-        @step_mother.step_match("Loud").invoke(nil)
+        support_code.step_match("Loud").invoke(nil)
       end
       
       it "should recognize $arg style captures" do
-        @dsl.Given "capture this: $arg" do |arg|
+        dsl.Given "capture this: $arg" do |arg|
           arg.should == 'this'
         end
 
-       @step_mother.step_match('capture this: this').invoke(nil)
+       support_code.step_match('capture this: this').invoke(nil)
+      end
+
+      it "should have a JSON representation of the signature" do
+        RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}).to_hash.should == {'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i'}
       end
     end
   end