aslakhellesoy-cucumber 0.1.99.23 → 0.1.100.1

data/lib/cucumber/step_mother.rb

@@ -1,4 +1,5 @@
 require 'cucumber/step_definition'
+require 'cucumber/world'
 require 'cucumber/core_ext/instance_exec'
 
 module Cucumber
@@ -9,18 +10,25 @@ module Cucumber
       super %{Undefined step: "#{step_name}"}
       @step_name = step_name
     end
-    Cucumber::EXCEPTION_STATUS[self] = :undefined
+    
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
   end
 
+  # Raised when a StepDefinition's block invokes World#pending
   class Pending < StandardError
-    Cucumber::EXCEPTION_STATUS[self] = :pending
   end
 
   # Raised when a step matches 2 or more StepDefinition
   class Ambiguous < StandardError
     def initialize(step_name, step_definitions)
       message = "Ambiguous match of \"#{step_name}\":\n\n"
-      message << step_definitions.map{|sd| sd.to_backtrace_line}.join("\n")
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
       message << "\n\n"
       super(message)
     end
@@ -30,8 +38,8 @@ module Cucumber
   class Redundant < StandardError
     def initialize(step_def_1, step_def_2)
       message = "Multiple step definitions have the same Regexp:\n\n"
-      message << step_def_1.to_backtrace_line << "\n"
-      message << step_def_2.to_backtrace_line << "\n\n"
+      message << step_def_1.backtrace_line << "\n"
+      message << step_def_2.backtrace_line << "\n\n"
       super(message)
     end
   end
@@ -41,9 +49,31 @@ module Cucumber
   # so #register_step_definition (and more interestingly - its aliases) are
   # available from the top-level.
   module StepMother
-    attr_writer :snippet_generator
-    attr_writer :options
+    class << self
+      def alias_adverb(adverb)
+        alias_method adverb, :register_step_definition
+      end
+    end
+
+    attr_writer :snippet_generator, :options
+
+    def step_visited(step)
+      steps << step unless steps.index(step)
+    end
     
+    def steps(status = nil)
+      @steps ||= []
+      if(status)
+        @steps.select{|step| step.status == status}
+      else
+        @steps
+      end
+    end
+
+    def scenarios
+      @scenarios ||= []
+    end
+
     # Registers a new StepDefinition. This method is aliased
     # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
     #
@@ -63,20 +93,6 @@ module Cucumber
       step_definition
     end
 
-    def world(scenario, prior_world = nil, &proc)
-      world = prior_world || new_world
-      begin
-        (@before_procs ||= []).each do |proc|
-          world.cucumber_instance_exec(false, 'Before', scenario, &proc)
-        end
-        yield world
-      ensure
-        (@after_procs ||= []).each do |proc|
-          world.cucumber_instance_exec(false, 'After', scenario, &proc)
-        end
-      end
-    end
-
     # Registers a Before proc. You can call this method as many times as you
     # want (typically from ruby scripts under <tt>support</tt>).
     def Before(&proc)
@@ -93,37 +109,25 @@ module Cucumber
       (@world_procs ||= []) << proc
     end
 
-    # Creates a new world instance
-    def new_world #:nodoc:
-      world = Object.new
-      (@world_procs ||= []).each do |proc|
-        world = proc.call(world)
-      end
-
-      world.extend(WorldMethods)
-      world.__cucumber_step_mother = self
+    def current_world
+      @current_world
+    end
 
-      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
-      world
+    def step_match(step_name, formatted_step_name=nil)
+      matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
+      raise Undefined.new(step_name) if matches.empty?
+      matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
+      raise Ambiguous.new(step_name, matches) if matches.size > 1
+      matches[0]
     end
 
-    # Looks up the StepDefinition that matches +step_name+
-    def step_definition(step_name) #:nodoc:
-      found = step_definitions.select do |step_definition|
-        step_definition.match(step_name)
-      end
-      raise Undefined.new(step_name) if found.empty?
-      found = best_matches(step_name, found) if found.size > 1 && options[:guess]
-      raise Ambiguous.new(step_name, found) if found.size > 1
-      found[0]
-    end
-
-    def best_matches(step_name, step_definitions)
-      top_group_score = step_definitions.map {|s| s.match(step_name).captures.length }.sort.last
-      top_groups = step_definitions.select {|s| s.match(step_name).captures.length == top_group_score }
-      if top_groups.size > 1
-        shortest_capture_length = top_groups.map {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } }.sort.first
-        top_groups.select {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+    def best_matches(step_name, step_matches)
+      max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+      top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+      if top_groups.length > 1
+        shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } }.min
+        top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
       else
         top_groups
       end
@@ -144,6 +148,19 @@ module Cucumber
       end
     end
 
+    def before_and_after(scenario, skip=false)
+      unless current_world || skip
+        new_world!
+        execute_before(scenario)
+      end
+      if block_given?
+        yield
+        execute_after(scenario) unless skip
+        nil_world!
+        scenario_visited(scenario)
+      end
+    end
+
     private
 
     def max_step_definition_length
@@ -154,41 +171,42 @@ module Cucumber
       @options || {}
     end
 
-    module WorldMethods #:nodoc:
-      attr_writer :__cucumber_step_mother, :__cucumber_current_step
-
-      # Call a step from within a step definition
-      def __cucumber_invoke(name, *multiline_arguments)
-        begin
-          # TODO: Very similar to code in Step. Refactor. Get back StepInvocation?
-          # Make more similar to JBehave?
-          step_definition = @__cucumber_step_mother.step_definition(name)
-          matched_args = step_definition.matched_args(name)
-          args = (matched_args + multiline_arguments)
-          step_definition.execute(name, self, *args)
-        rescue Exception => e
-          @__cucumber_current_step.exception = e
-          raise e
-        end
+    # Creates a new world instance
+    def new_world!
+      @current_world = Object.new
+      (@world_procs ||= []).each do |proc|
+        @current_world = proc.call(@current_world)
       end
-      
-      def table(text, file=nil, line=0)
-        @table_parser ||= Parser::TableParser.new
-        @table_parser.parse_or_fail(text.strip, file, line)
+
+      @current_world.extend(World)
+      @current_world.__cucumber_step_mother = self
+
+      @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      @current_world
+    end
+
+    def nil_world!
+      @current_world = nil
+    end
+
+    def execute_before(scenario)
+      (@before_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'Before', scenario, &proc)
       end
+    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
+    def execute_after(scenario)
+      (@after_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'After', scenario, &proc)
       end
     end
+
+    def scenario_visited(scenario)
+      scenarios << scenario unless scenarios.index(scenario)
+    end
+
+    def options
+      @options || {}
+    end
   end
 end

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 = 1 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/lib/cucumber/world.rb

@@ -0,0 +1,42 @@
+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_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
+
+    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

@@ -5,6 +5,10 @@ class FeatureGenerator < Rails::Generator::NamedBase
       m.directory 'features/step_definitions'
       m.template  'feature.erb', "features/manage_#{plural_name}.feature"
       m.template  'steps.erb', "features/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