kosmas58-cucumber 0.1.99.23 → 0.1.100.5

data/lib/cucumber/parser/feature.tt

@@ -17,15 +17,18 @@ module Cucumber
         tags 
         white 
         header:(!(scenario_outline / scenario / background) .)* 
-        background:(background)? 
+        bg:background? 
         feature_elements
         comment? {
           def build
-            if background.respond_to?(:build)
-              Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build, background.build)
-            else
-              Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build)
-            end
+            background = bg.respond_to?(:build) ? bg.build : nil
+            Ast::Feature.new(
+              background, 
+              comment.build, 
+              tags.build, 
+              header.text_value, 
+              feature_elements.build(background)
+            )
           end
         }
       end
@@ -40,7 +43,7 @@ module Cucumber
       end
 
       rule tag
-        '@' tag_name:([^@\n\t ])+
+        '@' tag_name:([^@\r\n\t ])+
       end
 
       rule comment
@@ -70,16 +73,17 @@ module Cucumber
 
       rule feature_elements
         (scenario / scenario_outline)* {
-          def build
-            elements.map{|s| s.build}
+          def build(background)
+            elements.map{|s| s.build(background)}
           end
         }
       end
 
       rule scenario
-        comment tags white scenario_keyword space* name:line_to_eol (white / eof) steps white {
-          def build
+        comment tags white scenario_keyword space* name:line_to_eol white steps white {
+          def build(background)
             Ast::Scenario.new(
+              background,
               comment.build, 
               tags.build,
               scenario_keyword.line,
@@ -93,8 +97,9 @@ module Cucumber
 
       rule scenario_outline
         comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections white {
-          def build
+          def build(background)
             Ast::ScenarioOutline.new(
+              background,
               comment.build, 
               tags.build,
               scenario_outline_keyword.line, 

data/lib/cucumber/parser/treetop_ext.rb

@@ -13,11 +13,11 @@ end
 module Cucumber
   module Parser
     module TreetopExt
-      FILE_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+      FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
 
       # Parses a file and returns a Cucumber::Ast
       def parse_file(file)
-        _, path, lines = *FILE_LINE_PATTERN.match(file)
+        _, path, lines = *FILE_COLON_LINE_PATTERN.match(file)
         if path
           lines = lines.split(':').map { |line| line.to_i }
         else
@@ -35,6 +35,17 @@ module Cucumber
         feature.lines = lines
         feature
       end
+
+      def parse_or_fail(s, file=nil, line_offset=0)
+        parse_tree = parse(s)
+        if parse_tree.nil?
+          raise Cucumber::Parser::SyntaxError.new(self, file, line_offset)
+        else
+          ast = parse_tree.build
+          ast.file = file
+          ast
+        end
+      end
     end
 
     class SyntaxError < StandardError
@@ -59,17 +70,6 @@ module Treetop
     
     class CompiledParser
       include Cucumber::Parser::TreetopExt
-      
-      def parse_or_fail(s, file=nil, line=0)
-        parse_tree = parse(s)
-        if parse_tree.nil?
-          raise Cucumber::Parser::SyntaxError.new(self, file, line)
-        else
-          ast = parse_tree.build
-          ast.file = file
-          ast
-        end
-      end
     end
   end
 end

data/lib/cucumber/platform.rb

@@ -14,5 +14,4 @@ module Cucumber
   RAILS         = defined?(Rails)
   RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
   RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
-  EXCEPTION_STATUS = Hash.new(:failed)
 end

data/lib/cucumber/rails/world.rb

@@ -11,8 +11,8 @@ require 'test/unit/testresult'
 
 # These allow exceptions to come through as opposed to being caught and having non-helpful responses returned.
 ActionController::Base.class_eval do
-  def perform_action_with_rescue
-    perform_action_without_rescue
+  def rescue_action(exception)
+    raise exception
   end
 end
 ActionController::Dispatcher.class_eval do

data/lib/cucumber/rake/task.rb

@@ -14,7 +14,6 @@ module Cucumber
     # To further configure the task, you can pass a block:
     #
     #   Cucumber::Rake::Task.new do |t|
-    #     t.libs << 'lib'
     #     t.cucumber_opts = "--format progress"
     #   end
     #
@@ -54,7 +53,7 @@ module Cucumber
       # Define a Rake
       def initialize(task_name = "features", desc = "Run Features with Cucumber")
         @task_name, @desc = task_name, desc
-        @libs = []
+        @libs = ['lib']
         @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
 
         yield self if block_given?

data/lib/cucumber/step_definition.rb

@@ -1,3 +1,4 @@
+require 'cucumber/step_match'
 require 'cucumber/core_ext/string'
 require 'cucumber/core_ext/proc'
 
@@ -27,12 +28,30 @@ module Cucumber
     def initialize(pattern, &proc)
       raise MissingProc if proc.nil?
       if String === pattern
-        p = pattern.gsub(/\$\w+/, '(.*)')
+        p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
         pattern = Regexp.new("^#{p}$") 
       end
       @regexp, @proc = pattern, proc
     end
 
+    def step_match(name_to_match, name_to_report)
+      if(match = name_to_match.match(@regexp))
+        StepMatch.new(self, name_to_match, name_to_report, match.captures)
+      else
+        nil
+      end
+    end
+
+    def invoke(world, args, step_name)
+      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+      begin
+        world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+      rescue Cucumber::ArityMismatchError => e
+        e.backtrace.unshift(self.backtrace_line)
+        raise e
+      end
+    end
+
     #:stopdoc:
 
     def match(step_name)
@@ -65,17 +84,7 @@ module Cucumber
       step_name.match(@regexp).captures
     end
 
-    def execute(step_name, world, *args)
-      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
-      begin
-        world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
-      rescue Cucumber::ArityMismatchError => e
-        e.backtrace.unshift(self.to_backtrace_line)
-        raise e
-      end
-    end
-
-    def to_backtrace_line
+    def backtrace_line
       "#{file_colon_line}:in `#{@regexp.inspect}'"
     end
 

data/lib/cucumber/step_match.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  class StepMatch
+    attr_reader :step_definition
+    attr_reader :args
+    
+    def initialize(step_definition, step_name, formatted_step_name, args)
+      @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
+    end
+    
+    def invoke(world, multiline_arg)
+      all_args = @args.dup
+      all_args << multiline_arg if multiline_arg
+      @step_definition.invoke(world, all_args, @step_name)
+    end
+
+    def format_args(format)
+      @formatted_step_name || @step_definition.format_args(@step_name, format)
+    end
+    
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      @step_definition.backtrace_line
+    end
+  end
+  
+  class NoStepMatch
+    attr_reader :step_definition
+
+    def initialize(step)
+      @step = step
+    end
+    
+    def format_args(format)
+      @step.name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+  end
+end

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,32 @@ 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)
+        adverb = adverb.gsub(/\s/, '')
+        alias_method adverb, :register_step_definition
+      end
+    end
+
+    attr_writer :snippet_generator, :options, :visitor
+
+    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 +94,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 +110,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 +149,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 +172,43 @@ 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.__cucumber_visitor = @visitor
+
+      @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