kosmas58-cucumber 0.2.2.1 → 0.2.3.3

data/lib/cucumber/step_mother.rb

@@ -45,6 +45,23 @@ module Cucumber
     end
   end
 
+  class NilWorld < StandardError
+    def initialize
+      super("World procs should never return nil")
+    end
+  end
+
+  class MultipleWorld < StandardError
+    def initialize(first_proc, second_proc)
+      message = "You can only pass a proc to #World once, but it's happening\n"
+      message << "in 2 places:\n\n"
+      message << first_proc.backtrace_line('World') << "\n"
+      message << second_proc.backtrace_line('World') << "\n\n"
+      message << "Use Ruby modules instead to extend your worlds. See the #World RDoc.\n\n"
+      super(message)
+    end
+  end
+
   # This is the main interface for registering step definitions, which is done
   # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
   # so #register_step_definition (and more interestingly - its aliases) are
@@ -105,10 +122,46 @@ module Cucumber
       (@after_procs ||= []).unshift(proc)
     end
 
-    # Registers a World proc. You can call this method as many times as you
-    # want (typically from ruby scripts under <tt>support</tt>).
-    def World(&proc)
-      (@world_procs ||= []) << proc
+    # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+    # The +proc+ will be executed once before each scenario to create an
+    # Object that the scenario's steps will run within. Any +world_modules+
+    # will be mixed into this Object (via Object#extend).
+    #
+    # This method is typically called from one or more Ruby scripts under 
+    # <tt>features/support</tt>. You can call this method as many times as you 
+    # like (to register more modules), but if you try to register more than 
+    # one Proc you will get an error.
+    #
+    # Cucumber will not yield anything to the +proc+ (like it used to do before v0.3).
+    #
+    # In earlier versions of Cucumber (before 0.3) you could not register
+    # any +world_modules+. Instead you would register several Proc objects (by 
+    # calling the method several times). The result of each +proc+ would be yielded 
+    # to the next +proc+. Example:
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     MyClass.new
+    #   end
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     world.extend(MyModule)
+    #   end
+    #
+    # From Cucumber 0.3 the recommended way to do this is:
+    #
+    #    World do
+    #      MyClass.new
+    #    end
+    #
+    #    World(MyModule)
+    #
+    def World(*world_modules, &proc)
+      if(proc)
+        raise MultipleWorld.new(@world_proc, proc) if @world_proc
+        @world_proc = proc
+      end
+      @world_modules ||= []
+      @world_modules += world_modules
     end
 
     def current_world
@@ -139,8 +192,8 @@ module Cucumber
       @step_definitions ||= []
     end
 
-    def snippet_text(step_keyword, step_name)
-      @snippet_generator.snippet_text(step_keyword, step_name)
+    def snippet_text(step_keyword, step_name, multiline_arg_class)
+      @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
     end
 
     def before_and_after(scenario, skip=false)
@@ -168,17 +221,46 @@ module Cucumber
 
     # Creates a new world instance
     def new_world!
-      @current_world = Object.new
-      (@world_procs ||= []).each do |proc|
-        @current_world = proc.call(@current_world)
+      create_world!
+      extend_world
+      connect_world
+      @current_world
+    end
+
+    def create_world!
+      if(@world_proc)
+        @current_world = @world_proc.call
+        check_nil(@current_world, @world_proc)
+      else
+        @current_world = Object.new
       end
+    end
 
+    def extend_world
       @current_world.extend(World)
+      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      (@world_modules || []).each do |mod|
+        @current_world.extend(mod)
+      end
+    end
+
+    def connect_world
       @current_world.__cucumber_step_mother = self
       @current_world.__cucumber_visitor = @visitor
+    end
 
-      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
-      @current_world
+    def check_nil(o, proc)
+      if o.nil?
+        begin
+          raise NilWorld.new
+        rescue NilWorld => e
+          e.backtrace.clear
+          e.backtrace.push(proc.backtrace_line("World"))
+          raise e
+        end
+      else
+        o
+      end
     end
 
     def nil_world!

data/lib/cucumber/version.rb

@@ -2,8 +2,8 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 2
-    TINY  = 2
-    PATCH = 1 # Set to nil for official release
+    TINY  = 3
+    PATCH = 3 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/rails_generators/cucumber/templates/env.rb

@@ -2,7 +2,7 @@
 ENV["RAILS_ENV"] ||= "test"
 require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
 require 'cucumber/rails/world'
-require 'cucumber/formatters/unicode' # Comment out this line if you don't want Cucumber Unicode support
+require 'cucumber/formatter/unicode' # Comment out this line if you don't want Cucumber Unicode support
 Cucumber::Rails.use_transactional_fixtures
 Cucumber::Rails.bypass_rescue # Comment out this line if you want Rails own error handling 
                               # (e.g. rescue_action_in_public / rescue_responses / rescue_from)

data/rails_generators/cucumber/templates/paths.rb

@@ -1,4 +1,16 @@
 module NavigationHelpers
+  # Maps a static name to a static route.
+  #
+  # This method is *not* designed to map from a dynamic name to a 
+  # dynamic route like <tt>post_comments_path(post)</tt>. For dynamic 
+  # routes like this you should *not* rely on #path_to, but write 
+  # your own step definitions instead. Example:
+  #
+  #   Given /I am on the comments page for the "(.+)" post/ |name|
+  #     post = Post.find_by_name(name)
+  #     visit post_comments_path(post)
+  #   end
+  #
   def path_to(page_name)
     case page_name
     
@@ -8,12 +20,10 @@ module NavigationHelpers
     # Add more page name => path mappings here
     
     else
-      raise "Can't find mapping from \"#{page_name}\" to a path."
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in features/support/paths.rb"
     end
   end
 end
 
-World do |world|
-  world.extend NavigationHelpers
-  world
-end
+World(NavigationHelpers)

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -113,3 +113,11 @@ Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
   assert field_labeled(label).checked?
 <% end -%>
 end
+
+Then /^I should be on (.+)$/ do |page_name|
+<% if framework == :rspec -%>
+  URI.parse(current_url).path.should == path_to(page_name)
+<% else -%>
+  assert_equal path_to(page_name), URI.parse(current_url).path
+<% end -%>
+end

data/spec/cucumber/ast/background_spec.rb

@@ -26,6 +26,7 @@ module Cucumber
           comment=Comment.new(''),
           line=2,
           keyword="", 
+          name="",
           steps=[
             Step.new(7, "Given", "y is 5")
           ])

data/spec/cucumber/ast/feature_factory.rb

@@ -30,7 +30,7 @@ module Cucumber
           Cucumber sandwich
         }, 10)
         
-        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:",
+        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "",
           [
             Step.new(3, "Given", "a passing step")
           ]

data/spec/cucumber/ast/feature_spec.rb

@@ -25,9 +25,9 @@ module Cucumber
             [:step_invocation, 3, "Given", "a passing step"], # From the background
             [:step_invocation, 10, "Given", "a passing step with an inline arg:",
               [:table, 
-                [:row, 
+                [:row, -1,
                   [:cell, "1"], [:cell, "22"], [:cell, "333"]], 
-                [:row, 
+                [:row, -1,
                   [:cell, "4444"], [:cell, "55555"], [:cell, "666666"]]]], 
             [:step_invocation, 11, "Given", "a happy step with an inline arg:", 
               [:py_string, "\n I like\nCucumber sandwich\n"]], 

data/spec/cucumber/ast/scenario_spec.rb

@@ -33,33 +33,6 @@ module Cucumber
         $y.should == nil
       end
 
-      it "should be at exact line" do
-        s = Scenario.new(background=nil, comment=Comment.new(""), 
-          tags=Tags.new(44, []), 45, keyword="", name="", steps=[])
-
-        s.should be_matches_lines([44])
-        s.should be_matches_lines([45])
-      end
-
-      it "should be at line if tags or steps are" do
-        s = Scenario.new(
-          background=nil,
-          comment=Comment.new(""), 
-          tags=Tags.new(43, []), 
-          line=45,
-          keyword="",
-          name="", 
-          steps=[
-            Step.new(46, "Given", ""),
-            Step.new(47, "Given", ""),
-            Step.new(48, "Given", ""),
-          ]
-        )
-
-        s.should be_matches_lines([43])
-        s.should be_matches_lines([47])
-        s.should_not be_matches_lines([49])
-      end
     end
   end
 end

data/spec/cucumber/ast/table_spec.rb

@@ -69,6 +69,27 @@ module Cucumber
           @table.transpose.hashes[0].should == {'one' => '1111', 'two' => '22222'}
         end
       end
+      
+      describe ".rows_hash" do
+                
+        it "should return a hash of the rows" do
+          table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
+        end
+        
+        it "should fail if the table doesn't have two columns" do
+          faulty_table = Table.new([
+            %w{one 1111 abc},
+            %w{two 22222 def}
+          ])
+          lambda {
+            faulty_table.rows_hash
+          }.should raise_error('The table must have exactly 2 columns')
+        end
+      end
         
       it "should allow renaming columns" do
         table2 = @table.map_headers('one' => :three)
@@ -134,12 +155,12 @@ module Cucumber
       it "should convert to sexp" do
         @table.to_sexp.should == 
           [:table, 
-            [:row, 
+            [:row, -1,
               [:cell, "one"], 
               [:cell, "four"],
               [:cell, "seven"]
             ],
-            [:row, 
+            [:row, -1,
               [:cell, "4444"], 
               [:cell, "55555"],
               [:cell, "666666"]]]

data/spec/cucumber/core_ext/proc_spec.rb

@@ -2,36 +2,53 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/core_ext/instance_exec'
 
 describe Proc do
+  it "should remove extraneous path info for file" do
+    proc = lambda {|a,b|}
+    proc.file_colon_line.should =~ /^spec\/cucumber\/core_ext\/proc_spec\.rb:6/
+  end
+  
   it "should raise ArityMismatchError for too many args (expecting 0)" do
     lambda {
       Object.new.cucumber_instance_exec(true, 'foo', 1) do
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "expected 0 block argument(s), got 1")
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
   end
 
   it "should raise ArityMismatchError for too many args (expecting 1)" do
     lambda {
       Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "expected 1 block argument(s), got 2")
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
   end
 
   it "should raise ArityMismatchError for too few args (expecting 1)" do
     lambda {
       Object.new.cucumber_instance_exec(true, 'foo') do |a|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "expected 1 block argument(s), got 0")
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
   end
 
   it "should raise ArityMismatchError for too few args (expecting 2)" do
     lambda {
       Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
       end
-    }.should raise_error(Cucumber::ArityMismatchError, "expected 2 block argument(s), got 1")
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
   end
-  
-  it "should remove extraneous path info for file" do
-    proc = lambda {|a,b|}
-    proc.file_colon_line.should == "spec/cucumber/core_ext/proc_spec.rb:34"
+
+  if Cucumber::RUBY_1_9
+    it "should allow varargs" do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should_not raise_error(Cucumber::ArityMismatchError)
+    end
+  else
+    # Ruby 1.8
+    it "should not allow varargs because Ruby 1.8 reports same arity as with no args, so we can't really tell the difference." do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+    end
   end
 end

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -13,19 +13,11 @@ module Cucumber
       end
 
       def parse_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file, {})
       end
 
       def parse_example_file(file)
-        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file)
-      end
-
-      describe "Header" do
-        it "should parse Feature with blurb" do
-          parse(%{Feature: hi
-with blurb
-})
-        end
+        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file, {})
       end
 
       describe "Comments" do
@@ -36,23 +28,6 @@ Feature: hi
           [:feature, nil, "Feature: hi\n",
             [:comment, "# My comment\n"]]
         end
-        
-        it "should parse a comment within a scenario" do
-          pending "Store comment in node and output it in pretty formatter"
-          parse(%{Feature: Hi
-  Scenario: Hello
-    Given foo
-    # When bar
-    Then baz
-}).to_sexp.should == 
-          [:feature, nil, "Feature: Hi", 
-            [:scenario, 2, "Scenario:", "Hello", 
-              [:step, 3, "Given", "foo"],
-              [:comment, "# When bar\n"], 
-              [:step, 5, "Then", "baz"] 
-            ]
-          ]
-        end
 
         it "should parse a file with only a multiline comment" do
           parse(%{# Hello
@@ -149,7 +124,7 @@ Given I have a table
             [:scenario, 2, "Scenario:", "Hello",
               [:step_invocation, 3, "Given", "I have a table",
                 [:table,
-                  [:row,
+                  [:row, 4,
                     [:cell, "a"],
                     [:cell, "b"]]]]]]
         end
@@ -187,9 +162,10 @@ Examples:
               [:step, 3, "Given", "a <what> cucumber"],
               [:examples, "Examples:", "",
                 [:table, 
-                  [:row, 
+                  [:row, 5,
                     [:cell, "what"]], 
-                    [:row, [:cell, "green"]]]]]]
+                  [:row, 6,
+                    [:cell, "green"]]]]]]
         end
 
         it "should have line numbered steps with inline table" do
@@ -207,15 +183,15 @@ Examples:
             [:scenario_outline, "Scenario Outline:", "Hello",
               [:step, 4, "Given", "I have a table",
                 [:table, 
-                  [:row, 
+                  [:row, 6,
                     [:cell, "<a>"], 
                     [:cell, "<b>"]]]],
             [:examples, "Examples:", "",
               [:table,
-                [:row, 
+                [:row, 8,
                   [:cell, "a"], 
                   [:cell, "b"]],
-                [:row, 
+                [:row, 9,
                   [:cell, "c"], 
                   [:cell, "d"]]]]]]
         end
@@ -237,23 +213,18 @@ Examples:
             [:scenario_outline, "Scenario Outline:", "Hello",
               [:step, 5, "Given", "I have a table",
                 [:table,
-                  [:row,
+                  [:row, 6, 
                     [:cell, "1"],
                     [:cell, "2"]]]],
               [:examples, "Examples:", "",
                 [:table,
-                  [:row,
+                  [:row, 9,
                     [:cell, "x"],
                     [:cell, "y"]],
-                  [:row,
+                  [:row, 10,
                     [:cell, "5"],
                     [:cell, "6"]]]]]]
         end
-
-        it "should set line numbers on feature" do
-          feature = parse_file("empty_feature.feature:11:12")
-          feature.instance_variable_get('@lines').should == [11, 12]
-        end
       end
 
       describe "Syntax" do
@@ -277,6 +248,37 @@ Examples:
           parse_file("scenario_outline.feature")
         end
       end
+
+      describe "Filtering" do
+        it "should filter outline tables" do
+          f = parse_example_file('self_test/features/outline_sample.feature:12')
+          f.to_sexp.should ==
+          [:feature,
+           "./spec/cucumber/parser/../../../examples/self_test/features/outline_sample.feature",
+           "Feature: Outline Sample",
+           [:scenario_outline,
+            "Scenario Outline:",
+            "Test state",
+            [:step, 6, "Given", "<state> without a table"],
+            [:step, 7, "Given", "<other_state> without a table"],
+            [:examples,
+             "Examples:",
+             "Rainbow colours",
+             [:table,
+              [:row, 9, [:cell, "state"], [:cell, "other_state"]],
+#              [:row, 10, [:cell, "missing"], [:cell, "passing"]],
+#              [:row, 11, [:cell, "passing"], [:cell, "passing"]],
+              [:row, 12, [:cell, "failing"], [:cell, "passing"]]]]
+            # ,
+            # [:examples,
+            #  "Examples:",
+            #  "Only passing",
+            #  [:table,
+            #   [:row, 14, [:cell, "state"], [:cell, "other_state"]],
+            #   [:row, 15, [:cell, "passing"], [:cell, "passing"]]]]]
+              ]]
+        end
+      end
     end
   end
 end

data/spec/cucumber/step_definition_spec.rb

@@ -82,6 +82,14 @@ module Cucumber
       })
     end
 
+    it "should recognise several quoted words in name and make according regexp and args" do
+      StepDefinition.snippet_text('Given', 'A "first" and "second" arg').should == unindented(%{
+        Given /^A "([^\\"]*)" and "([^\\"]*)" arg$/ do |arg1, arg2|
+          pending
+        end
+      })
+    end
+
     it "should not use quote group when there are no quotes" do
       StepDefinition.snippet_text('Given', 'A first arg').should == unindented(%{
         Given /^A first arg$/ do

data/spec/cucumber/step_mother_spec.rb

@@ -85,5 +85,53 @@ spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
         @step_mother.Given(/Three (.*) mice/) {|disability|}
       end.should raise_error(Redundant)
     end
+
+    it "should raise an error if the world is nil" do
+      @step_mother.World do
+      end
+
+      begin
+        @step_mother.before_and_after(nil)
+        raise "Should fail"
+      rescue NilWorld => e
+        e.message.should == "World procs should never return nil"
+        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:90:in `World'"]
+      end
+    end
+
+    module ModuleOne
+    end
+
+    module ModuleTwo
+    end
+
+    class ClassOne
+    end
+
+    it "should implicitly extend world with modules" do
+      @step_mother.World(ModuleOne, ModuleTwo)
+
+      w = @step_mother.__send__(:new_world!)
+      class << w
+        included_modules.index(ModuleOne).should_not == nil
+        included_modules.index(ModuleTwo).should_not == nil
+      end
+      w.class.should == Object
+    end
+
+    it "should raise error when we try to register more than one World proc" do
+      @step_mother.World { Hash.new }
+      lambda do
+        @step_mother.World { Array.new }
+      end.should raise_error(MultipleWorld, %{You can only pass a proc to #World once, but it's happening
+in 2 places:
+
+spec/cucumber/step_mother_spec.rb:123:in `World'
+spec/cucumber/step_mother_spec.rb:125:in `World'
+
+Use Ruby modules instead to extend your worlds. See the #World RDoc.
+
+})
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,21 +1,12 @@
 require 'rubygems'
 gem 'rspec'
-require 'spec/expectations'
+require 'spec'
+require 'spec/autorun'
 
 ENV['CUCUMBER_COLORS']=nil
-$KCODE='u'
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'cucumber'
 Cucumber.load_language('en')
 $:.unshift(File.dirname(__FILE__))
 
 ::Term::ANSIColor.coloring = true
-
-# Open up the tree classes a little for easier inspection.
-module Cucumber
-  module Tree
-    class Feature
-      attr_reader :header, :scenarios
-    end
-  end
-end