aslakhellesoy-cucumber 0.1.99.23 → 0.1.100.1

data/lib/cucumber/ast/py_string.rb

@@ -20,18 +20,23 @@ 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:

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

data/lib/cucumber/ast/step.rb

@@ -4,63 +4,70 @@ require 'cucumber/core_ext/string'
 module Cucumber
   module Ast
     class Step
-      attr_reader :keyword, :name
-      attr_writer :world, :previous, :options
-      attr_accessor :status, :scenario, :exception
+      attr_reader :line, :keyword, :name, :multiline_arg
+      attr_writer :step_collection, :options
+      attr_accessor :feature_element, :exception
 
-      def initialize(line, keyword, name, *multiline_args)
-        @line, @keyword, @name, @multiline_args = line, keyword, name, multiline_args
+      def initialize(line, keyword, name, multiline_arg=nil)
+        @line, @keyword, @name, @multiline_arg = line, keyword, name, multiline_arg
       end
 
-      def execute_with_arguments(argument_hash, world, previous, visitor, row_line)
-        delimited_arguments = delimit_argument_names(argument_hash)
+      def background?
+        false
+      end
+
+      def step_invocation
+        StepInvocation.new(self, @name, @multiline_arg, [])
+      end
+
+      def step_invocation_from_cells(cells)
+        matched_cells = matched_cells(cells)
+
+        delimited_arguments = delimit_argument_names(cells.to_hash)
         name                = replace_name_arguments(delimited_arguments)
-        multiline_args      = replace_multiline_args_arguments(delimited_arguments)
+        multiline_arg       = @multiline_arg.nil? ? nil : @multiline_arg.arguments_replaced(delimited_arguments)
 
-        execute_twin(world, previous, visitor, row_line, name, *multiline_args)
+        StepInvocation.new(self, name, multiline_arg, matched_cells)
       end
-      
-      def execute_as_new(world, previous, visitor, row_line)
-        execute_twin(world, previous, visitor, row_line, @name, *@multiline_args)
+
+      def invoke(step_match, world)
+        step_match.invoke(world, @multiline_arg)
       end
 
       def accept(visitor)
-        execute(visitor)
-
-        if @status == :outline
-          step_definition = find_first_name_and_step_definition_from_examples(visitor)
-        else
-          step_definition = @step_definition
-        end
-        visitor.visit_step_name(@keyword, @name, @status, step_definition, source_indent)
-        @multiline_args.each do |multiline_arg|
-          visitor.visit_multiline_arg(multiline_arg, @status)
-        end
-        @exception
+        # The only time a Step is visited is when it is in a ScenarioOutline.
+        # Otherwise it's always StepInvocation that gest visited instead.
+        visit_step_details(visitor, first_match(visitor), @multiline_arg, :skipped, nil, nil)
+      end
+      
+      def visit_step_details(visitor, step_match, multiline_arg, status, exception, background)
+        visitor.visit_step_name(@keyword, step_match, status, source_indent, background)
+        visitor.visit_multiline_arg(@multiline_arg) if @multiline_arg
+        visitor.visit_exception(exception, status) if exception
       end
 
-      def find_first_name_and_step_definition_from_examples(visitor)
-        # @scenario is always a ScenarioOutline in this case
-        @scenario.each_example_row do |cells|
+      def first_match(visitor)
+        # @feature_element is always a ScenarioOutline in this case
+        @feature_element.each_example_row do |cells|
           argument_hash       = cells.to_hash
           delimited_arguments = delimit_argument_names(argument_hash)
           name                = replace_name_arguments(delimited_arguments)
-          step_definition     = visitor.step_definition(name) rescue nil
-          return step_definition if step_definition
+          step_match          = visitor.step_mother.step_match(name, @name) rescue nil
+          return step_match if step_match
         end
-        nil
+        NoStepMatch.new(self)
       end
 
       def to_sexp
-        [:step, @line, @keyword, @name, *@multiline_args.map{|arg| arg.to_sexp}]
+        [:step, @line, @keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
       end
 
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line) || @multiline_args.detect{|a| a.at_lines?(lines)}
+      def matches_lines?(lines)
+        lines.index(@line) || (@multiline_arg && @multiline_arg.matches_lines?(lines))
       end
 
       def source_indent
-        @scenario.source_indent(text_length)
+        @feature_element.source_indent(text_length)
       end
 
       def text_length
@@ -68,11 +75,11 @@ module Cucumber
       end
 
       def backtrace_line
-        @backtrace_line ||= @scenario.backtrace_line("#{@keyword} #{@name}", @line) unless @scenario.nil?
+        @backtrace_line ||= @feature_element.backtrace_line("#{@keyword} #{@name}", @line) unless @feature_element.nil?
       end
 
-      def file_line
-        @file_line ||= @scenario.file_line(@line) unless @scenario.nil?
+      def file_colon_line
+        @file_colon_line ||= @feature_element.file_colon_line(@line) unless @feature_element.nil?
       end
 
       def actual_keyword
@@ -85,56 +92,25 @@ module Cucumber
 
       protected
 
+      # TODO: Remove when we use StepCollection everywhere
       def previous_step
-        @scenario.previous_step(self)
+        @feature_element.previous_step(self)
       end
 
       private
 
-      def execute(visitor)
-        matched_args = []
-        if @status.nil?
-          begin
-            @step_definition = visitor.step_definition(@name)
-            matched_args = @step_definition.matched_args(@name)
-            if @previous == :passed && !visitor.options[:dry_run]
-              @world.__cucumber_current_step = self
-              @step_definition.execute(@name, @world, *(matched_args + @multiline_args))
-              @status = :passed
-            else
-              @status = :skipped
-            end
-          rescue Undefined => exception
-            if visitor.options[:strict]
-              exception.set_backtrace([])
-              failed(exception)
-            else
-              @status = :undefined
-            end
-          rescue Pending => exception
-            visitor.options[:strict] ? failed(exception) : @status = :pending
-          rescue Exception => exception
-            failed(exception)
-          end
-          @scenario.step_executed(self) if @scenario
+      def matched_cells(cells)
+        cells.select do |cell|
+          @name.index(delimited(cell.header_cell.value))
         end
-        [self, @status, matched_args]
       end
 
-      def execute_twin(world, previous, visitor, line, name, *multiline_args)
-        # We'll create a new step and execute that
-        step = Step.new(line, @keyword, name, *multiline_args)
-        step.scenario = @scenario
-        step.world    = world
-        step.previous = previous
-        step.__send__(:execute, visitor)
+      def delimit_argument_names(argument_hash)
+        argument_hash.inject({}) { |h,(name,value)| h[delimited(name)] = value; h }
       end
 
-      ARGUMENT_START = '<'
-      ARGUMENT_END   = '>'
-
-      def delimit_argument_names(argument_hash)
-        argument_hash.inject({}) { |h,(k,v)| h["#{ARGUMENT_START}#{k}#{ARGUMENT_END}"] = v; h }
+      def delimited(s)
+        "<#{s}>"
       end
 
       def replace_name_arguments(argument_hash)
@@ -144,18 +120,6 @@ module Cucumber
         end
         name_with_arguments_replaced
       end
-
-      def replace_multiline_args_arguments(arguments)
-        @multiline_args.map do |arg|
-          arg.arguments_replaced(arguments)
-        end
-      end
-
-      def failed(exception)
-        @status = :failed
-        @exception = exception
-        @exception.backtrace << backtrace_line unless backtrace_line.nil?
-      end
     end
   end
 end