kosmas58-cucumber 0.1.99.23 → 0.1.100.5

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

data/lib/cucumber/ast/py_string.rb

@@ -20,23 +20,29 @@ module Cucumber
       def initialize(start_line, end_line, string, quotes_indent)
         @start_line, @end_line = start_line, end_line
         @string, @quotes_indent = string.gsub(/\\"/, '"'), quotes_indent
+        @status = :passed
+      end
+
+      def status=(status)
+        @status = status
       end
 
       def to_s
         @string.indent(-@quotes_indent)
       end
 
-      def at_lines?(lines)
+      def matches_lines?(lines)
         lines.detect{|l| l >= @start_line && l <= @end_line}
       end
 
-      def accept(visitor, status)
-        visitor.visit_py_string(to_s, status)
+      def accept(visitor)
+        visitor.visit_py_string(to_s, @status)
       end
       
       def arguments_replaced(arguments) #:nodoc:
         string = @string
         arguments.each do |name, value|
+          value ||= ''
           string = string.gsub(name, value)
         end
         PyString.new(@start_line, @end_line, string, @quotes_indent)

data/lib/cucumber/ast/scenario.rb

@@ -1,91 +1,51 @@
+require 'cucumber/ast/feature_element'
+
 module Cucumber
   module Ast
     class Scenario
-      attr_writer :feature, :background
-
-      def initialize(comment, tags, line, keyword, name, steps)
-        @comment, @tags, @line, @keyword, @name = comment, tags, line, keyword, name
-        steps.each {|step| step.scenario = self}
-        @steps = steps
-        @steps_helper = Steps.new(self)
-      end
-
-      def status
-        @steps.map{|step| step.status}
+      include FeatureElement
+      
+      def initialize(background, comment, tags, line, keyword, name, steps)
+        @background, @comment, @tags, @line, @keyword, @name = background, comment, tags, line, keyword, name
+        attach_steps(steps)
+        
+        step_invocations = steps.map{|step| step.step_invocation}
+        if @background
+          @steps = @background.step_collection(step_invocations)
+        else
+          @steps = StepCollection.new(step_invocations)
+        end
       end
 
-      def tagged_with?(tag_names)
-        @tags.among?(tag_names) || @feature.tagged_with?(tag_names, false)
+      def feature=(feature)
+        @feature = feature
+        @background.feature = feature if @background
       end
 
-      def matches_scenario_names?(scenario_names)
-        scenario_names.detect{|name| @name == name}
+      def descend?(visitor)
+        visitor.matches_lines?(self) &&
+        visitor.included_by_tags?(self) &&
+        !visitor.excluded_by_tags?(self) &&
+        visitor.matches_scenario_names?(self)
       end
 
       def accept(visitor)
-        visitor.visit_background(@background) if @background
         visitor.visit_comment(@comment)
         visitor.visit_tags(@tags)
-        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
-        visitor.visit_steps(@steps_helper)
-
-        @feature.scenario_executed(self) if @feature && !@executed
-        @executed = true
-      end
+        visitor.visit_scenario_name(@keyword, @name, file_colon_line(@line), source_indent(text_length))
 
-      def accept_steps(visitor)
-        prior_world = @background ? @background.world : nil
-        visitor.world(self, prior_world) do |world|
-          previous = @background ? @background.status : :passed
-          @steps.each do |step|
-            step.previous = previous
-            step.world    = world
-            visitor.visit_step(step)
-            previous = step.status
-          end
+        skip = @background && @background.failed?
+        skip_invoke! if skip
+        visitor.step_mother.before_and_after(self, skip) do
+          visitor.visit_steps(@steps)
         end
       end
 
-      def source_indent(text_length)
-        max_line_length - text_length
-      end
-
-      def max_line_length
-        lengths = (@steps + [self]).map{|e| e.text_length}
-        lengths.max
-      end
-
-      def text_length
-        @keyword.jlength + @name.jlength
-      end
-
-      def at_lines?(lines)
-        at_header_or_step_lines?(lines)
-      end
-
-      def at_header_or_step_lines?(lines)
-        lines.empty? || lines.index(@line) || @steps.detect {|step| step.at_lines?(lines)} || @tags.at_lines?(lines)
-      end
-
-      def undefined?
-        @steps.empty?
-      end
-
-      def step_executed(step)
-        @feature.step_executed(step) if @feature
-      end
-
-      def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
-        @feature.backtrace_line(name, line) if @feature
-      end
-
-      def file_line(line = @line)
-        @feature.file_line(line) if @feature
-      end
-
-      def previous_step(step)
-        i = @steps.index(step) || -1
-        @steps[i-1]
+      def skip_invoke!
+        @steps.each{|step_invocation| step_invocation.skip_invoke!}
+        @feature.next_feature_element(self) do |next_one|
+          next_one.skip_invoke!
+        end
       end
 
       def to_sexp
@@ -94,10 +54,11 @@ module Cucumber
         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
+
     end
   end
 end

data/lib/cucumber/ast/scenario_outline.rb

@@ -1,15 +1,18 @@
 module Cucumber
   module Ast
-    class ScenarioOutline < Scenario
+    class ScenarioOutline
+      include FeatureElement
+
       # The +example_sections+ argument must be an Array where each element is another array representing
       # an Examples section. This array has 3 elements:
       #
       # * Examples keyword
       # * Examples section name
       # * Raw matrix
-      def initialize(comment, tags, line, keyword, name, steps, example_sections)
-        super(comment, tags, line, keyword, name, steps)
-        steps.each {|step| step.status = :outline}
+      def initialize(background, comment, tags, line, keyword, name, steps, example_sections)
+        @background, @comment, @tags, @line, @keyword, @name = background, comment, tags, line, keyword, name
+        attach_steps(steps)
+        @steps = StepCollection.new(steps)
 
         @examples_array = example_sections.map do |example_section|
           examples_line       = example_section[0]
@@ -22,59 +25,54 @@ module Cucumber
         end
       end
 
-      def at_lines?(lines)
-        super || @examples_array.detect { |examples| examples.at_lines?(lines) }
+      def feature=(feature)
+        @feature = feature
+        @background.feature = feature if @background
+      end
+
+      def descend?(visitor)
+        @examples_array.detect { |examples| examples.descend?(visitor) }
+      end
+
+      def matches_tags_and_name?(visitor)
+        visitor.included_by_tags?(self) &&
+        !visitor.excluded_by_tags?(self) &&
+        visitor.matches_scenario_names?(self)
       end
 
       def accept(visitor)
-        visitor.visit_background(@background) if @background
         visitor.visit_comment(@comment)
         visitor.visit_tags(@tags)
-        visitor.visit_scenario_name(@keyword, @name, file_line(@line), source_indent(text_length))
-        visitor.visit_steps(@steps_helper)
+        visitor.visit_scenario_name(@keyword, @name, file_colon_line(@line), source_indent(text_length))
+        visitor.visit_steps(@steps)
 
+        skip_invoke! if @background && @background.failed?
         @examples_array.each do |examples|
-          visitor.visit_examples(examples)
+          visitor.visit_examples(examples) if examples.descend?(visitor)
         end
       end
 
-      def each_example_row(&proc)
-        @examples_array.each do |examples|
-          examples.each_example_row(&proc)
+      def skip_invoke!
+        @examples_array.each{|examples| examples.skip_invoke!}
+        @feature.next_feature_element(self) do |next_one|
+          next_one.skip_invoke!
         end
       end
 
-      def execute_row(cells, visitor, &proc)
-        exception = nil
-        
-        prior_world = @background ? @background.world : nil
-        visitor.world(self, prior_world) do |world|
-          
-          previous_status = @background ? @background.status : :passed
-          argument_hash = cells.to_hash
-          cell_index = 0
-          @steps.each do |step|
-            executed_step, previous_status, matched_args = 
-              step.execute_with_arguments(argument_hash, world, previous_status, visitor, cells[0].line)
-            # There might be steps that don't have any arguments
-            # If there are no matched args, we'll still iterate once
-            matched_args = [nil] if matched_args.empty?
-
-            matched_args.each do
-              cell = cells[cell_index]
-              if cell
-                proc.call(cell, previous_status)
-                cell_index += 1
-              end
-            end
-            exception ||= executed_step.exception
-          end
+      def step_invocations(cells)
+        step_invocations = @steps.step_invocations_from_cells(cells)
+        if @background
+          @background.step_collection(step_invocations)
+        else
+          StepCollection.new(step_invocations)
         end
-        @feature.scenario_executed(self) if @feature
-        exception
       end
 
-      def pending? ; false ; end
+      def each_example_row(&proc)
+        @examples_array.each do |examples|
+          examples.each_example_row(&proc)
+        end
+      end
 
       def to_sexp
         sexp = [:scenario_outline, @keyword, @name]
@@ -82,7 +80,7 @@ module Cucumber
         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 += @examples_array.map{|e| e.to_sexp}
         sexp