kosmas58-cucumber 0.1.99.23 → 0.1.100.5

data/lib/cucumber/ast/step.rb

@@ -4,63 +4,66 @@ 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)
-        name                = replace_name_arguments(delimited_arguments)
-        multiline_args      = replace_multiline_args_arguments(delimited_arguments)
+      def background?
+        false
+      end
 
-        execute_twin(world, previous, visitor, row_line, name, *multiline_args)
+      def step_invocation
+        StepInvocation.new(self, @name, @multiline_arg, [])
       end
-      
-      def execute_as_new(world, previous, visitor, row_line)
-        execute_twin(world, previous, visitor, row_line, @name, *@multiline_args)
+
+      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_arg       = @multiline_arg.nil? ? nil : @multiline_arg.arguments_replaced(delimited_arguments)
+
+        StepInvocation.new(self, name, multiline_arg, matched_cells)
       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 +71,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,77 +88,35 @@ 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)
         name_with_arguments_replaced = @name
         argument_hash.each do |name, value|
+          value ||= ''
           name_with_arguments_replaced = name_with_arguments_replaced.gsub(name, value) if value
         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

data/lib/cucumber/ast/step_collection.rb

@@ -0,0 +1,66 @@
+module Cucumber
+  module Ast
+    # Holds an Array of Step or StepDefinition
+    class StepCollection
+      include Enumerable
+      
+      def initialize(steps)
+        @steps = steps
+        @steps.each{|step| step.step_collection = self}
+      end
+
+      def accept(visitor, &proc)
+        @steps.each do |step|
+          visitor.visit_step(step) if proc.nil? || proc.call(step)
+        end
+      end
+
+      def step_invocations(background = false)
+        StepCollection.new(@steps.map{ |step| 
+          i = step.step_invocation
+          i.background = background
+          i
+        })
+      end
+
+      def step_invocations_from_cells(cells)
+        @steps.map{|step| step.step_invocation_from_cells(cells)}
+      end
+
+      # Duplicates this instance and adds +step_invocations+ to the end
+      def dup(step_invocations = [])
+        StepCollection.new(@steps + step_invocations)
+      end
+
+      def each(&proc)
+        @steps.each(&proc)
+      end
+
+      def previous_step(step)
+        i = @steps.index(step) || -1
+        @steps[i-1]
+      end
+
+      def matches_lines?(lines)
+        @steps.detect {|step| step.matches_lines?(lines)}
+      end
+
+      def empty?
+        @steps.empty?
+      end
+
+      def max_line_length(feature_element)
+        lengths = (@steps + [feature_element]).map{|e| e.text_length}
+        lengths.max
+      end
+
+      def exception
+        @exception ||= ((failed = @steps.detect {|step| step.exception}) && failed.exception)
+      end
+
+      def to_sexp
+        @steps.map{|step| step.to_sexp}
+      end
+    end
+  end
+end

data/lib/cucumber/ast/step_invocation.rb

@@ -0,0 +1,110 @@
+module Cucumber
+  module Ast
+    class StepInvocation
+      attr_writer :step_collection, :background
+      attr_reader :name, :matched_cells, :status
+      attr_accessor :exception
+
+      def initialize(step, name, multiline_arg, matched_cells)
+        @step, @name, @multiline_arg, @matched_cells = step, name, multiline_arg, matched_cells
+        status!(:skipped)
+      end
+
+      def background?
+        @background
+      end
+
+      def skip_invoke!
+        @skip_invoke = true
+      end
+
+      def accept(visitor)
+        invoke(visitor.step_mother, visitor.options)
+        @step.visit_step_details(visitor, @step_match, @multiline_arg, @status, @exception, @background)
+      end
+
+      def invoke(step_mother, options)
+        find_step_match!(step_mother)
+        unless @skip_invoke || options[:dry_run] || exception || @step_collection.exception
+          @skip_invoke = true
+          begin
+            step_mother.current_world.__cucumber_current_step = self
+            @step_match.invoke(step_mother.current_world, @multiline_arg)
+            status!(:passed)
+          rescue Pending => e
+            failed(e, false)
+            status!(:pending)
+          rescue Undefined => e
+            failed(e, false)
+            status!(:undefined)
+          rescue Exception => e
+            failed(e, false)
+            status!(:failed)
+          end
+        end
+      end
+
+      def find_step_match!(step_mother)
+        return if @step_match
+        begin
+          @step_match = step_mother.step_match(@name)
+        rescue Undefined => e
+          failed(e, true)
+          status!(:undefined)
+          @step_match = NoStepMatch.new(@step)
+        rescue Ambiguous => e
+          failed(e, false)
+          status!(:failed)
+          @step_match = NoStepMatch.new(@step)
+        end
+        step_mother.step_visited(self)
+      end
+
+      def failed(exception, clear_backtrace)
+        @exception = exception
+        @exception.set_backtrace([]) if clear_backtrace
+        @exception.backtrace << @step.backtrace_line unless @step.backtrace_line.nil?
+      end
+
+      def status!(status)
+        @status = status
+        @multiline_arg.status = status if @multiline_arg
+        @matched_cells.each do |cell|
+          cell.status = status
+        end
+      end
+
+      def previous
+        @step_collection.previous_step(self)
+      end
+
+      def actual_keyword
+        if [Cucumber.keyword_hash['and'], Cucumber.keyword_hash['but']].index(@keyword) && previous
+          previous.actual_keyword
+        else
+          @step.keyword
+        end
+      end
+
+      def matches_lines?(lines)
+        @step.matches_lines?(lines)
+      end
+
+      def text_length
+        @step.text_length
+      end
+
+      def file_colon_line
+        @step.file_colon_line
+      end
+
+      def backtrace_line
+        @step.backtrace_line
+      end
+
+      def to_sexp
+        [:step_invocation, @step.line, @step.keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
+      end
+    end
+  end
+end

data/lib/cucumber/ast/table.rb

@@ -7,7 +7,7 @@ module Cucumber
     #
     # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
     #
-    class Table
+    class Table      
       NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
 
       attr_accessor :file
@@ -84,17 +84,23 @@ module Cucumber
         cells_rows.each(&proc)
       end
 
-      def at_lines?(lines)
-        cells_rows.detect { |row| row.at_lines?(lines) }
+      def matches_lines?(lines)
+        cells_rows.detect{|row| row.matches_lines?(lines)}
       end
 
-      def accept(visitor, status)
+      def accept(visitor)
         cells_rows.each do |row|
-          visitor.visit_table_row(row, status)
+          visitor.visit_table_row(row)
         end
         nil
       end
 
+      def status=(status)
+        cells_rows.each do |row|
+          row.status = status
+        end
+      end
+
       # For testing only
       def to_sexp #:nodoc:
         [:table, *cells_rows.map{|row| row.to_sexp}]
@@ -152,17 +158,24 @@ module Cucumber
           row.map do |cell|
             cell_with_replaced_args = cell
             arguments.each do |name, value|
-              cell_with_replaced_args = value && !cell.nil? ? cell_with_replaced_args.gsub(name, value) : nil
+              if cell_with_replaced_args && cell_with_replaced_args.include?(name)
+                cell_with_replaced_args = value ? cell_with_replaced_args.gsub(name, value) : nil
+              end
             end
             cell_with_replaced_args
           end
         end
-
         Table.new(raw_with_replaced_args)
       end
 
-      def at_lines?(lines)
-        cells_rows.detect{|row| row.at_lines?(lines)}
+      def cells_rows
+        @rows ||= cell_matrix.map do |cell_row|
+          @cells_class.new(self, cell_row)
+        end
+      end
+
+      def header_cell(col)
+        cells_rows[0][col]
       end
 
       protected
@@ -183,12 +196,6 @@ module Cucumber
         columns[col].__send__(:width)
       end
 
-      def cells_rows
-        @rows ||= cell_matrix.map do |cell_row|
-          @cells_class.new(self, cell_row)
-        end
-      end
-
       def columns
         @columns ||= cell_matrix.transpose.map do |cell_row|
           @cells_class.new(self, cell_row)
@@ -211,14 +218,19 @@ module Cucumber
       # Represents a row of cells or columns of cells
       class Cells
         include Enumerable
+        attr_reader :exception
 
         def initialize(table, cells)
           @table, @cells = table, cells
         end
 
-        def accept(visitor, status)
+        def matches_lines?(lines)
+          lines.index(line)
+        end
+
+        def accept(visitor)
           each do |cell|
-            visitor.visit_table_cell(cell, status)
+            visitor.visit_table_cell(cell)
           end
           nil
         end
@@ -244,8 +256,10 @@ module Cucumber
           @cells[0].line
         end
 
-        def at_lines?(lines)
-          lines.empty? || lines.index(line)
+        def status=(status)
+          each do |cell|
+            cell.status = status
+          end
         end
 
         private
@@ -265,13 +279,19 @@ module Cucumber
 
       class Cell
         attr_reader :value, :line
+        attr_writer :status
 
         def initialize(value, table, row, col, line)
           @value, @table, @row, @col, @line = value, table, row, col, line
+          @status = :passed
+        end
+
+        def accept(visitor)
+          visitor.visit_table_cell_value(@value, col_width, @status)
         end
 
-        def accept(visitor, status)
-          visitor.visit_table_cell_value(@value, col_width, status)
+        def header_cell
+          @table.header_cell(@col)
         end
 
         # For testing only