kosmas58-cucumber 0.1.99.23 → 0.1.100.5

data/lib/cucumber/version.rb

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

data/lib/cucumber/world.rb

@@ -0,0 +1,53 @@
+module Cucumber
+  # All steps are run in the context of an object that extends this module
+  module World
+    class << self
+      def alias_adverb(adverb)
+        alias_method adverb, :__cucumber_invoke
+      end
+    end
+    
+    attr_writer :__cucumber_step_mother, :__cucumber_visitor, :__cucumber_current_step
+
+    # Call a step from within a step definition
+    def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+      begin
+        step_match = @__cucumber_step_mother.step_match(name)
+        step_match.invoke(self, multiline_argument)
+      rescue Exception => e
+        e.nested! if Undefined === e
+        @__cucumber_current_step.exception = e
+        raise e
+      end
+    end
+    
+    def table(text, file=nil, line_offset=0)
+      @table_parser ||= Parser::TableParser.new
+      @table_parser.parse_or_fail(text.strip, file, line_offset)
+    end
+
+    # Output +announcement+ alongside the formatted output.
+    # This is an alternative to using Kernel#puts - it will display
+    # nicer, and in all outputs (in case you use several formatters)
+    #
+    # Beware that the output will be printed *before* the corresponding
+    # step. This is because the step itself will not be printed until
+    # after it has run, so it can be coloured according to its status.
+    def announce(announcement)
+      @__cucumber_visitor.announce(announcement)
+    end
+
+    def pending(message = "TODO")
+      if block_given?
+        begin
+          yield
+        rescue Exception => e
+          raise Pending.new(message)
+        end
+        raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+      else
+        raise Pending.new(message)
+      end
+    end
+  end
+end

data/rails_generators/cucumber/templates/paths.rb

@@ -2,7 +2,7 @@ module NavigationHelpers
   def path_to(page_name)
     case page_name
     
-    when /the homepage/i
+    when /the homepage/
       root_path
     
     # Add more page name => path mappings here

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -11,25 +11,25 @@ When /^I go to (.+)$/ do |page_name|
   visit path_to(page_name)
 end
 
-When /^I press "(.*)"$/ do |button|
+When /^I press "([^\"]*)"$/ do |button|
   click_button(button)
 end
 
-When /^I follow "(.*)"$/ do |link|
+When /^I follow "([^\"]*)"$/ do |link|
   click_link(link)
 end
 
-When /^I fill in "(.*)" with "(.*)"$/ do |field, value|
+When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
   fill_in(field, :with => value) 
 end
 
-When /^I select "(.*)" from "(.*)"$/ do |value, field|
+When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
   select(value, :from => field) 
 end
 
 # Use this step in conjunction with Rail's datetime_select helper. For example:
 # When I select "December 25, 2008 10:00" as the date and time 
-When /^I select "(.*)" as the date and time$/ do |time|
+When /^I select "([^\"]*)" as the date and time$/ do |time|
   select_datetime(time)
 end
 
@@ -42,7 +42,7 @@ end
 # The following steps would fill out the form:
 # When I select "November 23, 2004 11:20" as the "Preferred" data and time
 # And I select "November 25, 2004 10:30" as the "Alternative" data and time
-When /^I select "(.*)" as the "(.*)" date and time$/ do |datetime, datetime_label|
+When /^I select "([^\"]*)" as the "([^\"]*)" date and time$/ do |datetime, datetime_label|
   select_datetime(datetime, :from => datetime_label)
 end
 
@@ -50,47 +50,47 @@ end
 # When I select "2:20PM" as the time
 # Note: Rail's default time helper provides 24-hour time-- not 12 hour time. Webrat
 # will convert the 2:20PM to 14:20 and then select it. 
-When /^I select "(.*)" as the time$/ do |time|
+When /^I select "([^\"]*)" as the time$/ do |time|
   select_time(time)
 end
 
 # Use this step when using multiple time_select helpers on a page or you want to
 # specify the name of the time on the form.  For example:
 # When I select "7:30AM" as the "Gym" time
-When /^I select "(.*)" as the "(.*)" time$/ do |time, time_label|
+When /^I select "([^\"]*)" as the "([^\"]*)" time$/ do |time, time_label|
   select_time(time, :from => time_label)
 end
 
 # Use this step in conjunction with Rail's date_select helper.  For example:
 # When I select "February 20, 1981" as the date
-When /^I select "(.*)" as the date$/ do |date|
+When /^I select "([^\"]*)" as the date$/ do |date|
   select_date(date)
 end
 
 # Use this step when using multiple date_select helpers on one page or
 # you want to specify the name of the date on the form. For example:
 # When I select "April 26, 1982" as the "Date of Birth" date
-When /^I select "(.*)" as the "(.*)" date$/ do |date, date_label|
+When /^I select "([^\"]*)" as the "([^\"]*)" date$/ do |date, date_label|
   select_date(date, :from => date_label)
 end
 
-When /^I check "(.*)"$/ do |field|
+When /^I check "([^\"]*)"$/ do |field|
   check(field) 
 end
 
-When /^I uncheck "(.*)"$/ do |field|
+When /^I uncheck "([^\"]*)"$/ do |field|
   uncheck(field) 
 end
 
-When /^I choose "(.*)"$/ do |field|
+When /^I choose "([^\"]*)"$/ do |field|
   choose(field)
 end
 
-When /^I attach the file at "(.*)" to "(.*)"$/ do |path, field|
+When /^I attach the file at "([^\"]*)" to "([^\"]*)"$/ do |path, field|
   attach_file(field, path)
 end
 
-Then /^I should see "(.*)"$/ do |text|
+Then /^I should see "([^\"]*)"$/ do |text|
 <% if framework == :rspec -%>
   response.should contain(text)
 <% else -%>
@@ -98,7 +98,7 @@ Then /^I should see "(.*)"$/ do |text|
 <% end -%>
 end
 
-Then /^I should not see "(.*)"$/ do |text|
+Then /^I should not see "([^\"]*)"$/ do |text|
 <% if framework == :rspec -%>
   response.should_not contain(text)
 <% else -%>
@@ -106,7 +106,7 @@ Then /^I should not see "(.*)"$/ do |text|
 <% end -%>
 end
 
-Then /^the "(.*)" checkbox should be checked$/ do |label|
+Then /^the "([^\"]*)" checkbox should be checked$/ do |label|
 <% if framework == :rspec -%>
   field_labeled(label).should be_checked
 <% else -%>

data/rails_generators/feature/feature_generator.rb

@@ -16,7 +16,11 @@ class FeatureGenerator < Rails::Generator::NamedBase
     record do |m|
       m.directory File.join(@features_path, "step_definitions")
       m.template  "feature.erb", File.join(@features_path, "manage_#{plural_name}.feature")
-      m.template  "steps.erb", File.join(@features_path, "step_definitions", "#{singular_name}_steps.rb")    
+      m.template  "steps.erb", File.join(@features_path, "step_definitions", "#{singular_name}_steps.rb")  
+
+      m.gsub_file 'features/support/paths.rb', /root_path/mi do |match|
+        "#{match}\n    when /the new #{singular_name} page/\n      new_#{singular_name}_path\n"
+      end
     end
   end
 

data/rails_generators/feature/templates/steps.erb

@@ -1,7 +1,3 @@
-Given /I am on the new <%= singular_name %> page/ do
-  visit "/<%= plural_name %>/new"
-end
-
 Given /^the following <%= plural_name %>:$/ do |<%= plural_name %>|
   <%= class_name %>.create!(<%= plural_name %>.hashes)
 end

data/spec/cucumber/ast/background_spec.rb

@@ -5,53 +5,44 @@ module Cucumber
   module Ast
     describe Background do
 
-      it "should visit a step on the first background run" do
-        step = Step.new(7, "Given", "passing")
+      before do
+        @step_mother = Object.new
+        @step_mother.extend(StepMother)
+        $x = $y = nil
+        @step_mother.Before do
+          $x = 2
+        end
+        @step_mother.Given /y is (\d+)/ do |n|
+          $y = $x * n.to_i
+        end
+        @visitor = Visitor.new(@step_mother)
+        @visitor.options = {}
+
+        @feature = mock('feature', :visit? => true).as_null_object
+      end
+
+      it "should execute Before blocks before background steps" do
         background = Background.new(
-          comment=Comment.new(""), 
-          line=99,
+          comment=Comment.new(''),
+          line=2,
           keyword="", 
           steps=[
-            step
+            Step.new(7, "Given", "y is 5")
           ])
-          visitor = mock('visitor', :null_object => true)
 
-          visitor.should_receive(:visit_step).with(step)
-          
-          background.accept(visitor)
-      end
-      
-      describe "having already visited background once" do
-
-        before(:each) do
-          @mock_step = mock('step', :null_object => true, :text_length => 1)
-          @background = Background.new(
-            comment=Comment.new(""), 
-            line=99,
-            keyword="", 
-            steps=[
-              @mock_step
-            ])
-            
-          @visitor = mock('visitor', :null_object => true)
-          @background.accept(@visitor)
-        end
-      
-        it "should execute the steps" do
-          @mock_step.should_receive(:execute_as_new).and_return(mock('executed step', :null_object => true))
-        
-          @background.accept(@visitor)
-        end
-        
-        it "should visit the background if there was a exception when executing a step" do
-          mock_executed_step = mock('executed step', :null_object => true, :exception => Exception.new)
-          @mock_step.stub!(:execute_as_new).and_return(mock_executed_step)
-        
-          @visitor.should_receive(:visit_background).with(@background)
+        scenario = Scenario.new(
+          background,
+          comment=Comment.new(""), 
+          tags=Tags.new(98,[]),
+          line=99,
+          keyword="", 
+          name="", 
+          steps=[])
+        background.feature = @feature
         
-          @background.accept(@visitor)
-        end
-
+        @visitor.visit_background(background)
+        $x.should == 2
+        $y.should == 10
       end
     end
   end

data/spec/cucumber/ast/feature_factory.rb

@@ -29,11 +29,20 @@ module Cucumber
            I like
           Cucumber sandwich
         }, 10)
+        
+        background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:",
+          [
+            Step.new(3, "Given", "a passing step")
+          ]
+        )
+        
         f = Ast::Feature.new(
+          background,
           Ast::Comment.new("# My feature comment\n"),
           Ast::Tags.new(6, ['one', 'two']),
           "Pretty printing",
           [Ast::Scenario.new(
+            background,
             Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
             Ast::Tags.new(8, ['three', 'four']),
             9,
@@ -46,7 +55,7 @@ module Cucumber
           )]
         )
         f.file = 'features/pretty_printing.feature'
-        f.features = Features.new(Filter.new({:tags => []}))
+        f.features = Features.new
         f
       end
     end

data/spec/cucumber/ast/feature_spec.rb

@@ -14,46 +14,23 @@ module Cucumber
           [:comment, "# My feature comment\n"], 
           [:tag, "one"], 
           [:tag, "two"], 
+          [:background, 2, 'Background:',
+            [:step, 3, "Given", "a passing step"]],
           [:scenario, 9, "Scenario:", 
             "A Scenario", 
             [:comment, "    # My scenario comment  \n# On two lines \n"], 
             [:tag, "three"], 
-            [:tag, "four"], 
-            [:step, 10, "Given", "a passing step with an inline arg:",
+            [:tag, "four"],
+            [:step_invocation, 3, "Given", "a passing step"], # From the background
+            [:step_invocation, 10, "Given", "a passing step with an inline arg:",
               [:table, 
                 [:row, 
                   [:cell, "1"], [:cell, "22"], [:cell, "333"]], 
                 [:row, 
                   [:cell, "4444"], [:cell, "55555"], [:cell, "666666"]]]], 
-            [:step, 11, "Given", "a happy step with an inline arg:", 
+            [:step_invocation, 11, "Given", "a happy step with an inline arg:", 
               [:py_string, "\n I like\nCucumber sandwich\n"]], 
-            [:step, 12, "Given", "a failing step"]]]
-      end
-
-      it "should only visit scenarios that match" do
-        s1 = mock("Scenario 1")
-        s2 = mock("Scenario 2")
-        s3 = mock("Scenario 3")
-        [s1, s2, s3].each{|s| s.should_receive(:feature=)}
-        f = Ast::Feature.new(
-          Ast::Comment.new(""),
-          Ast::Tags.new(22, []),
-          "My feature",
-          [s1, s2, s3]
-        )
-        features = mock('Features')
-        f.features = features
-
-        f.lines = [33]
-
-        features.should_receive(:visit?).with(s1, [33]).and_return(false)
-        features.should_receive(:visit?).with(s2, [33]).and_return(true)
-        features.should_receive(:visit?).with(s3, [33]).and_return(false)
-
-        s2.should_receive(:accept)
-
-        visitor = Visitor.new(nil)
-        visitor.visit_feature(f)
+            [:step_invocation, 12, "Given", "a failing step"]]]
       end
     end
   end

data/spec/cucumber/ast/py_string_spec.rb

@@ -33,6 +33,13 @@ module Cucumber
           @ps.to_s.should_not include("Life is elsewhere")
         end
 
+        it "should replaced nil with empty string" do
+          ps = PyString.new(10, 13, "'<book>'", 0)
+          py_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
+          
+          py_string_with_replaced_arg.to_s.should == "''"
+        end
+
       end
       
     end

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -9,6 +9,7 @@ module Cucumber
       before do
         @step_mother = Object.new
         @step_mother.extend(StepMother)
+
         @step_mother.Given(/^there are (\d+) cucumbers$/) do |n|
           @initial = n.to_i
         end
@@ -23,6 +24,7 @@ module Cucumber
         end
 
         @scenario_outline = ScenarioOutline.new(
+          background=nil,
           Comment.new(""),
           Tags.new(18, []),
           19,
@@ -45,6 +47,7 @@ module Cucumber
               ]
             ]
           ]
+          
         )
       end
 

data/spec/cucumber/ast/scenario_spec.rb

@@ -9,9 +9,6 @@ module Cucumber
         @step_mother = Object.new
         @step_mother.extend(StepMother)
         $x = $y = nil
-        @step_mother.Before do
-          $x = 3
-        end
         @step_mother.Given /y is (\d+)/ do |n|
           $y = n.to_i
         end
@@ -19,23 +16,9 @@ module Cucumber
         @visitor.options = {}
       end
 
-      it "should execute Before blocks before steps" do
-        scenario = Scenario.new(
-          comment=Comment.new(""), 
-          tags=Tags.new(98,[]),
-          line=99,
-          keyword="", 
-          name="", 
-          steps=[
-            Step.new(7, "Given", "y is 5")
-          ])
-        @visitor.visit_feature_element(scenario)
-        $x.should == 3
-        $y.should == 5
-      end
-
       it "should skip steps when previous is not passed" do
         scenario = Scenario.new(
+          background=nil,
           comment=Comment.new(""),
           tags=Tags.new(98, []), 
           line=99,
@@ -47,20 +30,20 @@ module Cucumber
           ])
         @visitor.visit_feature_element(scenario)
 
-        $x.should == 3
         $y.should == nil
       end
 
       it "should be at exact line" do
-        s = Scenario.new(comment=Comment.new(""), 
+        s = Scenario.new(background=nil, comment=Comment.new(""), 
           tags=Tags.new(44, []), 45, keyword="", name="", steps=[])
 
-        s.should be_at_lines([44])
-        s.should be_at_lines([45])
+        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,
@@ -73,9 +56,9 @@ module Cucumber
           ]
         )
 
-        s.should be_at_lines([43])
-        s.should be_at_lines([47])
-        s.should_not be_at_lines([49])
+        s.should be_matches_lines([43])
+        s.should be_matches_lines([47])
+        s.should_not be_matches_lines([49])
       end
     end
   end