engineyard-cucumber 0.3.101

data/lib/cucumber/ast/py_string.rb

@@ -0,0 +1,57 @@
+module Cucumber
+  module Ast
+    # Represents an inline argument in a step. Example:
+    #
+    #   Given the message
+    #     """
+    #     I like
+    #     Cucumber sandwich
+    #     """
+    #
+    # The text between the pair of <tt>"""</tt> is stored inside a PyString,
+    # which is yielded to the StepDefinition block as the last argument.
+    #
+    # The StepDefinition can then access the String via the #to_s method. In the
+    # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
+    #
+    # Note how the indentation from the source is stripped away.
+    #
+    class PyString #:nodoc:
+      def self.default_arg_name
+        "string"
+      end
+
+      def initialize(start_line, end_line, string, quotes_indent)
+        @start_line, @end_line = start_line, end_line
+        @string, @quotes_indent = string.gsub(/\\"/, '"'), quotes_indent
+      end
+
+      def to_s
+        @string.indent(-@quotes_indent)
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        visitor.visit_py_string(to_s)
+      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)
+      end
+
+      def has_text?(text)
+        @string.index(text)
+      end
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:py_string, to_s]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/scenario.rb

@@ -0,0 +1,108 @@
+require 'cucumber/ast/feature_element'
+
+module Cucumber
+  module Ast
+    class Scenario #:nodoc:
+      include FeatureElement
+      
+      attr_reader :name, :line
+      
+      class EmptyBackground 
+        def failed?
+          false
+        end
+        
+        def feature_elements
+          []
+        end
+        
+        def step_collection(step_invocations)
+          StepCollection.new(step_invocations)
+        end
+      end
+      
+      def initialize(background, comment, tags, line, keyword, name, steps)
+        @background = background || EmptyBackground.new
+        @comment, @tags, @line, @keyword, @name = comment, tags, line, keyword, name
+        attach_steps(steps)
+
+        step_invocations = steps.map{|step| step.step_invocation}
+        @steps = @background.step_collection(step_invocations)
+        @background.feature_elements << self
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        
+        with_visitor(visitor) do
+          visitor.visit_comment(@comment) unless @comment.empty?
+          visitor.visit_tags(@tags)
+          visitor.visit_scenario_name(@keyword, @name, file_colon_line(@line), source_indent(first_line_length))
+
+          skip_invoke! if @background.failed?
+          visitor.step_mother.before_and_after(self, skip_hooks?) do
+            skip_invoke! if failed?
+            visitor.visit_steps(@steps)
+          end
+          @executed = true
+        end
+      end
+
+      # Returns true if one or more steps failed
+      def failed?
+        @steps.failed? || !!@exception
+      end
+      
+      def fail!(exception)
+        @exception = exception
+        @current_visitor.visit_exception(@exception, :failed)
+      end
+
+      # Returns true if all steps passed
+      def passed?
+        !failed?
+      end
+
+      # Returns the first exception (if any)
+      def exception
+        @exception || @steps.exception
+      end
+
+      # Returns the status
+      def status
+        return :failed if @exception
+        @steps.status
+      end
+
+      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
+        sexp = [:scenario, @line, @keyword, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        steps = @steps.to_sexp
+        sexp += steps if steps.any?
+        sexp
+      end
+      
+      private
+      
+      def with_visitor(visitor)
+        @current_visitor = visitor
+        yield
+        @current_visitor = nil
+      end
+      
+      def skip_hooks?
+        @background.failed? || @executed
+      end
+    end
+  end
+end

data/lib/cucumber/ast/scenario_outline.rb

@@ -0,0 +1,96 @@
+module Cucumber
+  module Ast
+    class ScenarioOutline #:nodoc:
+      include FeatureElement
+
+      module ExamplesArray #:nodoc:
+        def accept(visitor)
+          return if $cucumber_interrupted
+          each do |examples|
+            visitor.visit_examples(examples)
+          end
+        end
+      end
+
+      # 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(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_comment    = example_section[0]
+          examples_line       = example_section[1]
+          examples_keyword    = example_section[2]
+          examples_name       = example_section[3]
+          examples_matrix     = example_section[4]
+
+          examples_table = OutlineTable.new(examples_matrix, self)
+          Examples.new(examples_comment, examples_line, examples_keyword, examples_name, examples_table)
+        end
+        @examples_array.extend(ExamplesArray)
+
+        @background.feature_elements << self if @background
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        visitor.visit_comment(@comment) unless @comment.empty?
+        visitor.visit_tags(@tags)
+        visitor.visit_scenario_name(@keyword, @name, file_colon_line(@line), source_indent(first_line_length))
+        visitor.visit_steps(@steps)
+
+        skip_invoke! if @background && @background.failed?
+        visitor.visit_examples_array(@examples_array) unless @examples_array.empty?
+      end
+
+      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 step_invocations(cells)
+        step_invocations = @steps.step_invocations_from_cells(cells)
+        if @background
+          @background.step_collection(step_invocations)
+        else
+          StepCollection.new(step_invocations)
+        end
+      end
+
+      def each_example_row(&proc)
+        @examples_array.each do |examples|
+          examples.each_example_row(&proc)
+        end
+      end
+
+      def visit_scenario_name(visitor, row)
+        visitor.visit_scenario_name(
+          @feature.language.scenario_keyword,
+          row.name, 
+          file_colon_line(row.line), 
+          source_indent(first_line_length)
+        )
+      end
+
+      def to_sexp
+        sexp = [:scenario_outline, @keyword, @name]
+        comment = @comment.to_sexp
+        sexp += [comment] if comment
+        tags = @tags.to_sexp
+        sexp += tags if tags.any?
+        steps = @steps.to_sexp
+        sexp += steps if steps.any?
+        sexp += @examples_array.map{|e| e.to_sexp}
+        sexp
+      end
+    end
+  end
+end

data/lib/cucumber/ast/step.rb

@@ -0,0 +1,116 @@
+require 'cucumber/core_ext/string'
+require 'cucumber/step_match'
+
+module Cucumber
+  module Ast
+    class Step #:nodoc:
+      attr_reader :line, :keyword, :name, :multiline_arg
+      attr_writer :step_collection, :options
+      attr_accessor :feature_element, :exception
+
+      INDENT = 2
+      
+      def initialize(line, keyword, name, multiline_arg=nil)
+        @line, @keyword, @name, @multiline_arg = line, keyword, name, multiline_arg
+      end
+
+      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_arg       = @multiline_arg.nil? ? nil : @multiline_arg.arguments_replaced(delimited_arguments)
+
+        StepInvocation.new(self, name, multiline_arg, matched_cells)
+      end
+
+      def accept(visitor)
+        return if $cucumber_interrupted
+        # The only time a Step is visited is when it is in a ScenarioOutline.
+        # Otherwise it's always StepInvocation that gets visited instead.
+        visit_step_result(visitor, first_match(visitor), @multiline_arg, :skipped, nil, nil)
+      end
+      
+      def visit_step_result(visitor, step_match, multiline_arg, status, exception, background)
+        visitor.visit_step_result(@keyword, step_match, @multiline_arg, status, exception, source_indent, background)
+      end
+
+      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_match          = visitor.step_mother.step_match(name, @name) rescue nil
+          return step_match if step_match
+        end
+        NoStepMatch.new(self, @name)
+      end
+
+      def to_sexp
+        [:step, @line, @keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
+      end
+
+      def source_indent
+        @feature_element.source_indent(text_length)
+      end
+
+      def text_length(name=@name)
+        @keyword.jlength + name.jlength + INDENT # Add indent as steps get indented more than scenarios
+      end
+
+      def backtrace_line
+        @backtrace_line ||= @feature_element.backtrace_line("#{@keyword} #{@name}", @line) unless @feature_element.nil?
+      end
+
+      def file_colon_line
+        @file_colon_line ||= @feature_element.file_colon_line(@line) unless @feature_element.nil?
+      end
+
+      def language
+        @feature_element.language
+      end
+
+      def dom_id
+        @dom_id ||= file_colon_line.gsub(/\//, '_').gsub(/\./, '_').gsub(/:/, '_')
+      end
+
+      private
+
+      def matched_cells(cells)
+        col_index = 0
+        cells.select do |cell|
+          header_cell = cell.table.header_cell(col_index)
+          col_index += 1
+          delimited = delimited(header_cell.value)
+          @name.index(delimited) || (@multiline_arg && @multiline_arg.has_text?(delimited))
+        end
+      end
+
+      def delimit_argument_names(argument_hash)
+        argument_hash.inject({}) { |h,(name,value)| h[delimited(name)] = value; h }
+      end
+
+      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
+    end
+  end
+end

data/lib/cucumber/ast/step_collection.rb

@@ -0,0 +1,76 @@
+module Cucumber
+  module Ast
+    # Holds an Array of Step or StepDefinition
+    class StepCollection #:nodoc:
+      include Enumerable
+      
+      def initialize(steps)
+        @steps = steps
+        @steps.each{|step| step.step_collection = self}
+      end
+
+      def accept(visitor, &proc)
+        return if $cucumber_interrupted
+        @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 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 failed?
+        status == :failed
+      end
+
+      def passed?
+        status == :passed
+      end
+      
+      def status
+        @steps.each{|step_invocation| return step_invocation.status if step_invocation.status != :passed}
+        :passed
+      end
+
+      def to_sexp
+        @steps.map{|step| step.to_sexp}
+      end
+    end
+  end
+end