cucumber 1.3.20 → 2.0.0.beta.1

data/spec/cucumber/formatter/spec_helper.rb

@@ -1,6 +1,5 @@
 module Cucumber
   module Formatter
-
     module SpecHelperDsl
       attr_reader :feature_content, :step_defs, :feature_filename
 
@@ -14,35 +13,42 @@ module Cucumber
       end
     end
 
+    require 'cucumber/core'
     module SpecHelper
+      include Core
+
       def run_defined_feature
         define_steps
-        features = load_features(self.class.feature_content || raise("No feature content defined!"))
-        run(features)
+        runtime.visitor = report
+        execute [gherkin_doc], mappings, report
+      end
+
+      require 'cucumber/mappings'
+      def mappings
+        @mappings ||= Mappings.new
+      end
+
+      require 'cucumber/reports/legacy_formatter'
+      def report
+        @report ||= Cucumber::Reports::LegacyFormatter.new runtime, [@formatter]
       end
 
-      def step_mother
-        @step_mother ||= Runtime.new
+      require 'cucumber/core/gherkin/document'
+      def gherkin_doc
+        Core::Gherkin::Document.new(self.class.feature_filename, gherkin)
       end
 
-      def load_features(content)
-        feature_file = FeatureFile.new(self.class.feature_filename, content)
-        features = Ast::Features.new
-        filters = []
-        feature = feature_file.parse(filters, {})
-        features.add_feature(feature) if feature
-        features
+      def gherkin
+        self.class.feature_content || raise("No feature content defined!")
       end
 
-      def run(features)
-        configuration = Cucumber::Configuration.default
-        tree_walker = Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
-        tree_walker.visit_features(features)
+      def runtime
+        mappings.runtime
       end
 
       def define_steps
         return unless step_defs = self.class.step_defs
-        rb = step_mother.load_programming_language('rb')
+        rb = runtime.load_programming_language('rb')
         dsl = Object.new
         dsl.extend RbSupport::RbDsl
         dsl.instance_exec &step_defs

data/spec/cucumber/rake/forked_spec.rb

@@ -4,59 +4,50 @@ require 'rake'
 
 module Cucumber
   module Rake
-
     describe Task::ForkedCucumberRunner do
-
       let(:libs) { ['lib'] }
       let(:binary) { Cucumber::BINARY }
       let(:cucumber_opts) { ['--cuke-option'] }
       let(:feature_files) { ['./some.feature'] }
 
       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
-          subject.use_bundler.should be_true
+          expect(subject.use_bundler).to be true
         end
 
         it "uses bundle exec to find cucumber and libraries" do
-          subject.cmd.should == [Cucumber::RUBY_BINARY,
-                                 '-S',
-                                 'bundle',
-                                 'exec',
-                                 'cucumber',
-                                 '--cuke-option'] + feature_files
+          expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
+            '-S',
+            'bundle',
+            'exec',
+            'cucumber',
+            '--cuke-option'] + feature_files
         end
-
       end
 
       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
-          subject.use_bundler.should be_false
+          expect(subject.use_bundler).to be false
         end
 
         it "uses well known cucumber location and specified libraries" do
-          subject.cmd.should == [Cucumber::RUBY_BINARY,
-                                 "-I",
-                                 "\"lib\"",
-                                 "\"#{Cucumber::BINARY }\"",
-                                 "--cuke-option"] + feature_files
+          expect(subject.cmd).to eq [Cucumber::RUBY_BINARY,
+            "-I",
+            "\"lib\"",
+            "\"#{Cucumber::BINARY }\"",
+            "--cuke-option"] + feature_files
         end
-
       end
-
-
     end
-
   end
 end

data/spec/cucumber/rb_support/rb_language_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'cucumber/step_mother'
 require 'cucumber/rb_support/rb_language'
 
 module Cucumber
@@ -19,37 +18,43 @@ module Cucumber
         let(:snippet) { double.as_null_object }
 
         it "creates a regexp Snippet class by default" do
-          Snippet::Regexp.should_receive(:new).and_return(snippet)
+          expect(Snippet::Regexp).to receive(:new) { snippet }
+
           rb.snippet_text('Given', 'A "string" with 4 spaces', nil)
         end
 
         it "creates a regexp Snippet class explicitly" do
-          Snippet::Regexp.should_receive(:new).and_return(snippet)
+          expect(Snippet::Regexp).to receive(:new) { snippet }
+
           rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :regexp)
         end
 
         it "creates a classic Snippet class" do
-          Snippet::Classic.should_receive(:new).and_return(snippet)
+          expect(Snippet::Classic).to receive(:new) { snippet }
+
           rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :classic)
         end
 
         it "creates a percent Snippet class" do
-          Snippet::Percent.should_receive(:new).and_return(snippet)
+          expect(Snippet::Percent).to receive(:new) { snippet }
+
           rb.snippet_text('Given', 'A "string" with 4 spaces', nil, :percent)
         end
 
         it "passes all parameters to Snippet contructor" do
           code_keyword, pattern, multiline_argument_class = double, double, double
-          Snippet::Regexp.should_receive(:new).with(code_keyword, pattern, multiline_argument_class)
+
+          expect(Snippet::Regexp).to receive(:new).with(code_keyword, pattern, multiline_argument_class)
+
           rb.snippet_text(code_keyword, pattern, multiline_argument_class)
         end
 
         it "renders the snippet" do
-          Snippet::Regexp.stub(:new => snippet)
-          snippet.should_receive(:to_s)
+          allow(Snippet::Regexp).to receive(:new) { snippet }
+          expect(snippet).to receive(:to_s)
+
           rb.snippet_text('Given', 'A "string" with 4 spaces', nil)
         end
-
       end
 
       describe "#load_code_file" do
@@ -69,29 +74,29 @@ module Cucumber
           end
 
           rb.load_code_file('tmp.rb')
-          $foo.should == 1
+          expect($foo).to eq 1
 
           a_file_called('tmp.rb') do
             "$foo = 2"
           end
 
           rb.load_code_file('tmp.rb')
-          $foo.should == 2
+
+          expect($foo).to eq 2
         end
       end
 
       describe "Handling the World" do
-
-        it "should raise an error if the world is nil" do
+        it "raises 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'/
+            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\/rb_support\/rb_language_spec\.rb\:\d+\:in `World'/)
           end
         end
 
@@ -104,17 +109,19 @@ module Cucumber
         class ClassOne
         end
 
-        it "should implicitly extend world with modules" do
+        it "implicitlys extend world with modules" do
           dsl.World(ModuleOne, ModuleTwo)
           rb.before(double('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/
+            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
-          rb.current_world.class.should == Object
+          expect(rb.current_world.class).to eq Object
         end
 
-        it "should raise error when we try to register more than one World proc" do
+        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:
 
@@ -126,47 +133,47 @@ or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
 
 }
           dsl.World { Hash.new }
-          lambda do
-            dsl.World { Array.new }
-          end.should raise_error(RbSupport::MultipleWorld, /#{expected_error}/)
 
+          expect(-> {
+            dsl.World { Array.new }
+          }).to 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
+            expect(-> {
               dsl.Transform('^abc$')
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when registering with a zero-arg transform block" do
-            lambda do
+            expect(-> {
               dsl.Transform('^abc$') {42}
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when registering with a splat-arg transform block" do
-            lambda do
+            expect(-> {
               dsl.Transform('^abc$') {|*splat| 42 }
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when transforming with an arity mismatch" do
-            lambda do
+            expect(-> {
               dsl.Transform('^abc$') {|one, two| 42 }
               rb.execute_transforms(['abc'])
-            end.should raise_error(Cucumber::ArityMismatchError)
+            }).to 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]
+
+            expect(rb.execute_transforms(['ab'])).to eq ['ab']
+            expect(rb.execute_transforms(['ac'])).to eq [42]
+            expect(rb.execute_transforms(['abc'])).to eq [42]
+            expect(rb.execute_transforms(['abbc'])).to eq [42]
           end
 
           it "transforms times" do
@@ -174,83 +181,86 @@ or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
             dsl.Transform(/^(\d\d-\d\d-\d\d\d\d)$/) do |arg|
               Time.parse(arg)
             end
-            rb.execute_transforms(['10-0E-1971']).should == ['10-0E-1971']
-            rb.execute_transforms(['10-03-1971']).should == [Time.parse('10-03-1971')]
+            expect(rb.execute_transforms(['10-0E-1971'])).to eq ['10-0E-1971']
+            expect(rb.execute_transforms(['10-03-1971'])).to eq [Time.parse('10-03-1971')]
           end
         end
 
         describe "with capture groups" do
           it "complains when registering with a with no transform block" do
-            lambda do
+            expect(-> {
               dsl.Transform('^a(.)c$')
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when registering with a zero-arg transform block" do
-            lambda do
+            expect(-> {
               dsl.Transform('^a(.)c$') { 42 }
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when registering with a splat-arg transform block" do
-            lambda do
+            expect(-> {
               dsl.Transform('^a(.)c$') {|*splat| 42 }
-            end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
+            }).to raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
           end
 
           it "complains when transforming with an arity mismatch" do
-            lambda do
+            expect(-> {
               dsl.Transform('^a(.)c$') {|one, two| 42 }
               rb.execute_transforms(['abc'])
-            end.should raise_error(Cucumber::ArityMismatchError)
+            }).to 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']
+
+            expect(rb.execute_transforms(['shape: circle, color: blue'])).to eq [{:circle => :blue}]
+            expect(rb.execute_transforms(['shape: square, color: red'])).to eq [{:square => :red}]
+            expect(rb.execute_transforms(['not shape: square, not color: red'])).to eq ['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]
+
+          expect(rb.execute_transforms(['ab'])).to eq ['ab']
+          expect(rb.execute_transforms(['ac'])).to eq [42]
+          expect(rb.execute_transforms(['abc'])).to eq [42]
+          expect(rb.execute_transforms(['abbc'])).to eq [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]
+
+          expect(rb.execute_transforms(['transform_me'])).to eq [: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]
+
+          expect(rb.execute_transforms(['ab'])).to eq ['ab']
+          expect(rb.execute_transforms(['ac'])).to eq [nil]
         end
       end
 
       describe "hooks" do
-
-        it "should find before hooks" do
+        it "finds before hooks" do
           fish = dsl.Before('@fish'){}
           meat = dsl.Before('@meat'){}
 
           scenario = double('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]
+          expect(scenario).to receive(:accept_hook?).with(fish) { true }
+          expect(scenario).to receive(:accept_hook?).with(meat) { false }
+          expect(rb.hooks_for(:before, scenario)).to eq [fish]
         end
 
-        it "should find around hooks" do
+        it "finds around hooks" do
           a = dsl.Around do |scenario, block|
           end
 
@@ -258,13 +268,12 @@ or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.
           end
 
           scenario = double('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]
+          expect(scenario).to receive(:accept_hook?).with(a) { true }
+          expect(scenario).to receive(:accept_hook?).with(b) { false }
+          expect(rb.hooks_for(:around, scenario)).to eq [a]
         end
       end
-
     end
   end
 end

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -1,6 +1,4 @@
 require 'spec_helper'
-require 'cucumber/ast'
-require 'cucumber/step_mother'
 require 'cucumber/rb_support/rb_language'
 
 module Cucumber
@@ -20,104 +18,127 @@ module Cucumber
       end
 
       def run_step(text)
-        support_code.step_match(text).invoke(nil)
+        support_code.step_match(text).invoke(MultilineArgument::None.new)
       end
 
-      it "should allow calling of other steps" do
-        dsl.Given /Outside/ do
+      it "allows calling of other steps" do
+        dsl.Given(/Outside/) do
           step "Inside"
         end
-        dsl.Given /Inside/ do
+        dsl.Given(/Inside/) do
           $inside = true
         end
 
         run_step "Outside"
-        $inside.should == true
+
+        expect($inside).to be true
       end
 
-      it "should allow calling of other steps with inline arg" do
-        dsl.Given /Outside/ do
-          step "Inside", Cucumber::Ast::Table.new([['inside']])
+      it "allows calling of other steps with inline arg" do
+        dsl.Given(/Outside/) do
+          location = Core::Ast::Location.new(__FILE__, __LINE__)
+          step "Inside", MultilineArgument.from(Cucumber::Core::Ast::DataTable.new([['inside']], location))
         end
-        dsl.Given /Inside/ do |table|
+        dsl.Given(/Inside/) do |table|
           $inside = table.raw[0][0]
         end
 
         run_step "Outside"
-        $inside.should == 'inside'
+
+        expect($inside).to eq 'inside'
       end
 
       context "mapping to world methods" do
-        it "should call a method on the world when specified with a symbol" do
-          rb.current_world.should_receive(:with_symbol)
-          dsl.Given /With symbol/, :with_symbol
+        it "calls a method on the world when specified with a symbol" do
+          expect(rb.current_world).to receive(:with_symbol)
+
+          dsl.Given(/With symbol/, :with_symbol)
 
           run_step "With symbol"
         end
 
-        it "should call a method on a specified object" do
+        it "calls a method on a specified object" do
           target = double('target')
-          rb.current_world.stub(:target => target)
-          dsl.Given /With symbol on block/, :with_symbol, :on => lambda { target }
 
-          target.should_receive(:with_symbol)
+          allow(rb.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on block/, :with_symbol, :on => lambda { target })
+
+          expect(target).to receive(:with_symbol)
+
           run_step "With symbol on block"
         end
 
-        it "should call a method on a specified world attribute" do
+        it "calls a method on a specified world attribute" do
           target = double('target')
-          rb.current_world.stub(:target => target)
-          dsl.Given /With symbol on symbol/, :with_symbol, :on => :target
 
-          target.should_receive(:with_symbol)
+          allow(rb.current_world).to receive(:target) { target }
+
+          dsl.Given(/With symbol on symbol/, :with_symbol, :on => :target)
+
+          expect(target).to receive(:with_symbol)
+
           run_step "With symbol on symbol"
         end
       end
 
-      it "should raise Undefined when inside step is not defined" do
-        dsl.Given /Outside/ do
+      it "raises Undefined when inside step is not defined" do
+        dsl.Given(/Outside/) do
           step 'Inside'
         end
 
-        lambda { run_step "Outside" }.
-          should raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::Undefined, 'Undefined step: "Inside"')
       end
 
-      it "should allow forced pending" do
-        dsl.Given /Outside/ do
+      it "allows forced pending" do
+        dsl.Given(/Outside/) do
           pending("Do me!")
         end
 
-        lambda { run_step "Outside" }.
-          should raise_error(Cucumber::Pending, "Do me!")
+        expect(-> {
+          run_step "Outside"
+        }).to raise_error(Cucumber::Pending, "Do me!")
+      end
+
+      it "raises ArityMismatchError when the number of capture groups differs from the number of step arguments" do
+        dsl.Given(/No group: \w+/) do |arg|
+        end
+
+        expect(-> {
+          run_step "No group: arg"
+        }).to raise_error(Cucumber::ArityMismatchError)
       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|
+      it "does not allow modification of args since it messes up pretty formatting" do
+        dsl.Given(/My car is (.*)/) do |colour|
+          colour << "xxx"
         end
 
-        lambda { run_step "No group: arg" }.
-          should raise_error(Cucumber::ArityMismatchError)
+        expect(-> {
+          run_step "My car is white"
+        }).to raise_error(RuntimeError, /can't modify frozen String/i)
       end
 
-      it "should allow puts" do
-        user_interface.should_receive(:puts).with('wasup')
-        dsl.Given /Loud/ do
+      it "allows puts" do
+        expect(user_interface).to  receive(:puts).with('wasup')
+        dsl.Given(/Loud/) do
           puts 'wasup'
         end
         run_step "Loud"
       end
 
-      it "should recognize $arg style captures" do
+      it "recognizes $arg style captures" do
         arg_value = "wow!"
         dsl.Given "capture this: $arg" do |arg|
-          arg.should == arg_value
+          expect(arg).to eq arg_value
         end
         run_step "capture this: wow!"
       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'}
+      it "has a JSON representation of the signature" do
+        expect(RbStepDefinition.new(rb, /I CAN HAZ (\d+) CUKES/i, lambda{}, {}).to_hash).to eq({ 'source' => "I CAN HAZ (\\d+) CUKES", 'flags' => 'i' })
       end
     end
   end