aslakhellesoy-cucumber 0.1.99.23 → 0.1.100.1

data/features/report_called_undefined_steps.feature

@@ -12,11 +12,13 @@ Feature: Cucumber command line
           Given a step definition that calls an undefined step # features/step_definitions/sample_steps.rb:19
             Undefined step: "this does not exist" (Cucumber::Undefined)
             ./features/step_definitions/sample_steps.rb:20:in `/^a step definition that calls an undefined step$/'
+            features/call_undefined_step_from_step_def.feature:4:in `Given a step definition that calls an undefined step'
 
         Scenario: Call via another                                         # features/call_undefined_step_from_step_def.feature:6
           Given call step "a step definition that calls an undefined step" # features/step_definitions/sample_steps.rb:23
             Undefined step: "this does not exist" (Cucumber::Undefined)
             ./features/step_definitions/sample_steps.rb:20:in `/^a step definition that calls an undefined step$/'
+            features/call_undefined_step_from_step_def.feature:7:in `Given call step "a step definition that calls an undefined step"'
 
       2 scenarios
       2 undefined steps

data/gem_tasks/rspec.rake

@@ -31,5 +31,7 @@ if require_spec
   Spec::Rake::SpecTask.new do |t|
     t.spec_opts = ['--options', "spec/spec.opts"]
     t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = ENV['RCOV']
+    t.rcov_opts = %w{--exclude osx\/objc,gems\/,spec\/}
   end
 end

data/lib/cucumber.rb

@@ -44,24 +44,16 @@ module Cucumber
       alias_steps(keywords)
     end
     
-    # Sets up additional aliases for Given, When and Then.
-    # Try adding the following to your <tt>support/env.rb</tt>:
-    #
-    #   # Given When Then in Norwegian
-    #   Cucumber.alias_steps %w{Gitt Naar Saa}
-    #
-    # You cannot use special characters here, because methods
-    # with special characters is not valid Ruby code
+    # Sets up additional method aliases for Given, When and Then.
+    # This does *not* affect how feature files are parsed. If you
+    # want to create aliases in the parser, you have to do this in
+    # languages.yml. For example:
     #
+    # and: And|With
     def alias_steps(keywords)
       keywords.each do |adverb|
-        StepMother.class_eval do
-          alias_method adverb, :register_step_definition
-        end
-
-        StepMother::WorldMethods.class_eval do
-          alias_method adverb, :__cucumber_invoke
-        end
+        StepMother.alias_adverb(adverb)
+        World.alias_adverb(adverb)
       end
     end
   end  

data/lib/cucumber/ast.rb

@@ -2,17 +2,17 @@ require 'cucumber/ast/comment'
 require 'cucumber/ast/tags'
 require 'cucumber/ast/features'
 require 'cucumber/ast/feature'
+require 'cucumber/ast/background'
 require 'cucumber/ast/scenario'
 require 'cucumber/ast/scenario_outline'
-require 'cucumber/ast/background'
-require 'cucumber/ast/steps'
+require 'cucumber/ast/step_invocation'
+require 'cucumber/ast/step_collection'
 require 'cucumber/ast/step'
 require 'cucumber/ast/table'
 require 'cucumber/ast/py_string'
 require 'cucumber/ast/outline_table'
 require 'cucumber/ast/examples'
 require 'cucumber/ast/visitor'
-require 'cucumber/ast/filter'
 
 module Cucumber
   # Classes in this module represent the Abstract Syntax Tree (AST)

data/lib/cucumber/ast/background.rb

@@ -1,88 +1,50 @@
+require 'cucumber/ast/feature_element'
+
 module Cucumber
   module Ast
-    class Background < Scenario
-
-      attr_accessor :world
-      attr_reader :status
+    class Background
+      include FeatureElement
+      attr_writer :feature
 
       def initialize(comment, line, keyword, steps)
-        @record_executed_steps = true
-        super(comment, Tags.new(1, []), line, keyword, "", steps)
+        @comment, @line, @keyword, @steps = comment, line, keyword, StepCollection.new(steps)
+        attach_steps(steps)
+        @step_invocations = @steps.step_invocations(true)
       end
 
-      def accept(visitor)
-        @world = visitor.new_world
-        if already_visited_steps?
-          @status = execute_steps(visitor)
+      def step_collection(step_invocations)
+        unless(@first_collection_created)
+          @first_collection_created = true
+          @step_invocations.dup(step_invocations)
         else
-          @status = visit_background_and_steps(visitor, @steps)
-          @steps_visited = true
+          @steps.step_invocations(true).dup(step_invocations)
         end
       end
 
-      def step_executed(step)
-        @feature.step_executed(step) if @feature && @record_executed_steps
+      def accept(visitor)
+        visitor.visit_comment(@comment)
+        visitor.visit_background_name(@keyword, "", file_colon_line(@line), source_indent(text_length))
+        visitor.step_mother.before_and_after(self)
+        visitor.visit_steps(@step_invocations)
+        @failed = @step_invocations.detect{|step_invocation| step_invocation.exception}
+      end
+
+      def failed?
+        @failed
       end
 
-      def already_visited_steps?
-        @steps_visited
+      def text_length
+        @keyword.jlength
       end
 
-      def to_sexp #:nodoc:
+      def to_sexp
         sexp = [:background, @line, @keyword]
         comment = @comment.to_sexp
         sexp += [comment] if comment
-        tags = @tags.to_sexp
-        sexp += tags if tags.any?
-        steps = @steps.map{|step| step.to_sexp}
+        steps = @steps.to_sexp
         sexp += steps if steps.any?
         sexp
       end
-      
-      private
-
-      def visit_background_and_steps(visitor, steps)
-        visitor.visit_comment(@comment)
-        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
-
-        previous = :passed
-        steps.each do |step|
-          step.previous = previous
-          step.world    = @world
-          visitor.visit_step(step)
-          previous = step.status
-        end
-        previous
-      end
-      
-      def execute_steps(visitor)
-        previous = :passed
-        executed_steps = []
-        exception = nil
-        @steps.each do |step|
-          executed_step, previous, _ = step.execute_as_new(@world, previous, visitor, @line)
-          executed_steps << executed_step
-          exception ||= executed_step.exception
-        end
-        @steps = executed_steps
-        
-        if exception && @status != :failed
-          without_recording_steps do
-            @steps_visited = false
-            #Since the steps have already been executed they will not be re-run, they will just be displayed
-            visitor.visit_background(self)
-          end 
-        end
-
-        previous
-      end
-
-      def without_recording_steps
-        @record_executed_steps = false
-        yield
-        @record_executed_steps = true
-      end
-
     end
   end
-end
+end

data/lib/cucumber/ast/examples.rb

@@ -10,12 +10,24 @@ module Cucumber
         visitor.visit_outline_table(@outline_table)
       end
 
+      def descend?(visitor)
+        @outline_table.descend?(visitor)
+      end
+
+      def skip_invoke!
+        @outline_table.skip_invoke!
+      end
+
+      def matches_scenario_names?(scenario_names)
+        scenario_names.detect{|name| name == @name}
+      end
+
       def each_example_row(&proc)
-        @outline_table.each_cells_row(&proc)
+        @outline_table.cells_rows[1..-1].each(&proc)
       end
 
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line) || @outline_table.at_lines?(lines)
+      def matches_lines?(lines)
+        lines.index(@line) || @outline_table.matches_lines?(lines)
       end
 
       def to_sexp

data/lib/cucumber/ast/feature.rb

@@ -5,23 +5,13 @@ module Cucumber
       attr_accessor :file
       attr_writer :features, :lines
 
-      def initialize(comment, tags, name, feature_elements, background = nil)
-        @comment, @tags, @name, @feature_elements, @background = comment, tags, name, feature_elements, background
-        feature_elements.each do |feature_element| 
-          feature_element.feature = self
-          feature_element.background = background if background
-        end
-        background.feature = self if background
+      def initialize(background, comment, tags, name, feature_elements)
+        @background, @comment, @tags, @name, @feature_elements = background, comment, tags, name, feature_elements
         @lines = []
-      end
 
-      def tagged_with?(tag_names, check_elements=true)
-        @tags.among?(tag_names) || 
-        (check_elements && @feature_elements.detect{|e| e.tagged_with?(tag_names)})
-      end
-      
-      def matches_scenario_names?(scenario_names)
-        @feature_elements.detect{|e| e.matches_scenario_names?(scenario_names)}
+        @feature_elements.each do |feature_element|
+          feature_element.feature = self
+        end
       end
 
       def accept(visitor)
@@ -29,25 +19,31 @@ module Cucumber
         visitor.visit_comment(@comment)
         visitor.visit_tags(@tags)
         visitor.visit_feature_name(@name)
-        
+        visitor.visit_background(@background) if @background
         @feature_elements.each do |feature_element|
-          visitor.visit_feature_element(feature_element) if @features.visit?(feature_element, @lines)
+          visitor.visit_feature_element(feature_element) if feature_element.descend?(visitor)
         end
       end
 
-      def scenario_executed(scenario)
-        @features.scenario_executed(scenario) if @features
+      def descend?(visitor)
+        @feature_elements.detect{ |feature_element| feature_element.descend?(visitor) }
+      end
+
+      def has_tags?(tags)
+        @tags.has_tags?(tags)
       end
 
-      def step_executed(step)
-        @features.step_executed(step) if @features
+      def next_feature_element(feature_element, &proc)
+        index = @feature_elements.index(feature_element)
+        next_one = @feature_elements[index+1]
+        proc.call(next_one) if next_one
       end
 
       def backtrace_line(step_name, line)
-        "#{file_line(line)}:in `#{step_name}'"
+        "#{file_colon_line(line)}:in `#{step_name}'"
       end
 
-      def file_line(line)
+      def file_colon_line(line)
         "#{@file}:#{line}"
       end
 
@@ -58,7 +54,7 @@ module Cucumber
         tags = @tags.to_sexp
         sexp += tags if tags.any?
         sexp += [@background.to_sexp] if @background
-        sexp += @feature_elements.map{|e| e.to_sexp}
+        sexp += @feature_elements.map{|fe| fe.to_sexp}
         sexp
       end
     end

data/lib/cucumber/ast/feature_element.rb

@@ -0,0 +1,46 @@
+module Cucumber
+  module FeatureElement
+    def attach_steps(steps)
+      steps.each {|step| step.feature_element = self}
+    end
+
+    def file_colon_line(line = @line)
+      @feature.file_colon_line(line) if @feature
+    end
+
+    def text_length
+      @keyword.jlength + @name.jlength
+    end
+
+    def matches_lines?(lines)
+      lines.index(@line) || @steps.matches_lines?(lines) || @tags.matches_lines?(lines)
+    end
+
+    def has_tags?(tags)
+      @tags.has_tags?(tags) || @feature.has_tags?(tags)
+    end
+
+    def matches_scenario_names?(scenario_names)
+      scenario_names.detect{|name| name == @name}
+    end
+
+    def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
+      @feature.backtrace_line(name, line) if @feature
+    end
+
+    def source_indent(text_length)
+      max_line_length - text_length
+    end
+
+    def max_line_length
+      @steps.max_line_length(self)
+    end
+
+    # TODO: Remove when we use StepCollection everywhere
+    def previous_step(step)
+      i = @steps.index(step) || -1
+      @steps[i-1]
+    end
+    
+  end
+end

data/lib/cucumber/ast/features.rb

@@ -1,14 +1,8 @@
 module Cucumber
   module Ast
     class Features
-      attr_reader :steps, :scenarios
-
-      def initialize(filter)
-        @filter = filter
-
+      def initialize
         @features = []
-        @scenarios = []
-        @steps = Hash.new{|steps, status| steps[status] = []}
       end
 
       def add_feature(feature)
@@ -16,22 +10,9 @@ module Cucumber
         @features << feature
       end
 
-      def visit?(node, lines)
-        @filter.matched?(node) &&
-        (lines.empty? ? true : node.at_lines?(lines))
-      end
-
-      def scenario_executed(scenario)
-        @scenarios << scenario
-      end
-      
-      def step_executed(step)
-        @steps[step.status] << step
-      end
-
       def accept(visitor)
         @features.each do |feature|
-          visitor.visit_feature(feature) if visit?(feature, [])
+          visitor.visit_feature(feature) if feature.descend?(visitor)
         end
       end
     end

data/lib/cucumber/ast/outline_table.rb

@@ -5,35 +5,67 @@ module Cucumber
         super(raw)
         @scenario_outline = scenario_outline
         @cells_class = ExampleCells
+        
+        cells_rows.each do |cells|
+          cells.create_step_invocations!(scenario_outline)
+        end
       end
 
-      def accept(visitor, status)
+      def accept(visitor)
         cells_rows.each_with_index do |row, n|
-          should_visit = n == 0 || 
-            row.at_lines?(visitor.current_feature_lines) ||
-            @scenario_outline.at_header_or_step_lines?(visitor.current_feature_lines)
-
-          if should_visit
-            visitor.visit_table_row(row, status)
+          if n == 0 || matches?(visitor, row)
+            visitor.visit_table_row(row)
           end
         end
         nil
       end
 
-      def execute_row(cells, visitor, &proc)
-        @scenario_outline.execute_row(cells, visitor, &proc)
+      def descend?(visitor)
+        cells_rows.detect{|cells_row| cells_row.descend?(visitor)}
+      end
+      
+      def matches?(visitor, cells)
+        @scenario_outline.matches_tags_and_name?(visitor) &&
+        (visitor.matches_lines?(cells) || visitor.matches_lines?(@scenario_outline))
+      end
+      
+      def skip_invoke!
+        cells_rows.each do |cells|
+          cells.skip_invoke!
+        end
       end
 
       class ExampleCells < Cells
-        def accept(visitor, status)
+        def create_step_invocations!(scenario_outline)
+          @step_invocations = scenario_outline.step_invocations(self)
+        end
+        
+        def descend?(visitor)
+          @table.matches?(visitor, self)
+        end
+
+        def skip_invoke!
+          @step_invocations.each do |step_invocation|
+            step_invocation.skip_invoke!
+          end
+        end
+
+        def accept(visitor)
           if header?
             @cells.each do |cell|
-              visitor.visit_table_cell(cell, :thead)
+              cell.status = :skipped
+              visitor.visit_table_cell(cell)
             end
-            nil
           else
-            exception = @table.execute_row(self, visitor) do |cell, status|
-              visitor.visit_table_cell(cell, status)
+            visitor.step_mother.before_and_after(self) do
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.step_mother, visitor.options)
+                @exception ||= step_invocation.exception
+              end
+
+              @cells.each do |cell|
+                visitor.visit_table_cell(cell)
+              end
             end
           end
         end