stefl-cucumber 0.10.1

data/lib/cucumber/ast/features.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Ast
+    class Features #:nodoc:
+      include Enumerable
+
+      attr_reader :duration
+
+      def initialize
+        @features = []
+      end
+
+      def [](index)
+        @features[index]
+      end
+
+      def each(&proc)
+        @features.each(&proc)
+      end
+
+      def add_feature(feature)
+        feature.features = self
+        @features << feature
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        start = Time.now
+        self.each do |feature|
+          visitor.visit_feature(feature)
+        end
+        @duration = Time.now - start
+      end
+    end
+  end
+end

data/lib/cucumber/ast/outline_table.rb

@@ -0,0 +1,187 @@
+module Cucumber
+  module Ast
+    class OutlineTable < Table #:nodoc:
+      def initialize(raw, scenario_outline)
+        super(raw)
+        @scenario_outline = scenario_outline
+        @cells_class = ExampleRow
+        init
+      end
+
+      def init
+        create_step_invocations_for_example_rows!(@scenario_outline)
+      end
+
+      def to_sexp
+        init
+        super
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        init
+        cells_rows.each_with_index do |row, n|
+          if(visitor.configuration.expand?)
+            row.accept(visitor)
+          else
+            visitor.visit_table_row(row)
+          end
+        end
+        nil
+      end
+
+      def accept_hook?(hook)
+        @scenario_outline.accept_hook?(hook)
+      end
+      
+      def source_tag_names
+        @scenario_outline.source_tag_names
+      end
+
+      def skip_invoke!
+        init
+        example_rows.each do |cells|
+          cells.skip_invoke!
+        end
+      end
+
+      def create_step_invocations_for_example_rows!(scenario_outline)
+        return if @dunit
+        @dunit = true
+        example_rows.each do |cells|
+          cells.create_step_invocations!(scenario_outline)
+        end
+      end
+      
+      def example_rows
+        cells_rows[1..-1]
+      end
+
+      def visit_scenario_name(visitor, row)
+        @scenario_outline.visit_scenario_name(visitor, row)
+      end
+
+      def language
+        @scenario_outline.language
+      end
+
+      class ExampleRow < Cells #:nodoc:        
+        class InvalidForHeaderRowError < NoMethodError
+          def initialize(*args)
+            super 'This is a header row and cannot pass or fail'
+          end
+        end
+        
+        attr_reader :scenario_outline # https://rspec.lighthouseapp.com/projects/16211/tickets/342
+
+        def initialize(table, cells)
+          super
+          @scenario_exception = nil
+        end
+        
+        def source_tag_names
+          @table.source_tag_names
+        end
+
+        def create_step_invocations!(scenario_outline)
+          @scenario_outline = scenario_outline
+          @step_invocations = scenario_outline.step_invocations(self)
+        end
+        
+        def skip_invoke!
+          @step_invocations.each do |step_invocation|
+            step_invocation.skip_invoke!
+          end
+        end
+
+        def accept(visitor)
+          return if Cucumber.wants_to_quit
+          visitor.configuration.expand? ? accept_expand(visitor) : accept_plain(visitor)
+        end
+
+        def accept_plain(visitor)
+          if header?
+            @cells.each do |cell|
+              cell.status = :skipped_param
+              visitor.visit_table_cell(cell)
+            end
+          else
+            visitor.step_mother.with_hooks(self) do
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.step_mother, visitor.configuration)
+                @exception ||= step_invocation.reported_exception
+              end
+
+              @cells.each do |cell|
+                visitor.visit_table_cell(cell)
+              end
+              
+              visitor.visit_exception(@scenario_exception, :failed) if @scenario_exception
+            end
+          end
+        end
+
+        def accept_expand(visitor)
+          if header?
+          else
+            visitor.step_mother.with_hooks(self) do
+              @table.visit_scenario_name(visitor, self)
+              @step_invocations.each do |step_invocation|
+                step_invocation.invoke(visitor.step_mother, visitor.configuration)
+                @exception ||= step_invocation.reported_exception
+                step_invocation.visit_step_result(visitor)
+              end
+            end
+          end
+        end
+
+        def accept_hook?(hook)
+          @table.accept_hook?(hook)
+        end
+        
+        def exception
+          @exception || @scenario_exception
+        end
+        
+        def fail!(exception)
+          @scenario_exception = exception
+        end
+        
+        # Returns true if one or more steps failed
+        def failed?
+          raise InvalidForHeaderRowError if header?
+          @step_invocations.failed? || !!@scenario_exception
+        end
+
+        # Returns true if all steps passed
+        def passed?
+          !failed?
+        end
+
+        # Returns the status
+        def status
+          return :failed if @scenario_exception
+          @step_invocations.status
+        end
+
+        def backtrace_line
+          @scenario_outline.backtrace_line(name, line)
+        end
+
+        def name
+          "| #{@cells.collect{|c| c.value }.join(' | ')} |"
+        end
+
+        def language
+          @table.language
+        end
+
+        private
+
+        def header?
+          index == 0
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/ast/py_string.rb

@@ -0,0 +1,80 @@
+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:
+      class Builder
+        attr_reader :string
+
+        def initialize
+          @string = ''
+        end
+
+        def py_string(string, line_number)
+          @string = string
+        end
+
+        def eof
+        end
+      end
+
+      attr_accessor :file
+
+      def self.default_arg_name
+        "string"
+      end
+
+      def self.parse(text)
+        builder = Builder.new
+        lexer = Gherkin::I18nLexer.new(builder)
+        lexer.scan(text)
+        new(builder.string)
+      end
+
+      def initialize(string)
+        @string = string
+      end
+
+      def to_step_definition_arg
+        @string
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        visitor.visit_py_string(@string)
+      end
+      
+      def arguments_replaced(arguments) #:nodoc:
+        string = @string
+        arguments.each do |name, value|
+          value ||= ''
+          string = string.gsub(name, value)
+        end
+        PyString.new(string)
+      end
+
+      def has_text?(text)
+        @string.index(text)
+      end
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:py_string, to_step_definition_arg]
+      end
+    end
+  end
+end

data/lib/cucumber/ast/scenario.rb

@@ -0,0 +1,117 @@
+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
+        
+        def init
+        end
+      end
+      
+      def initialize(background, comment, tags, line, keyword, name, raw_steps)
+        @background = background || EmptyBackground.new
+        @comment, @tags, @line, @keyword, @name, @raw_steps = comment, tags, line, keyword, name, raw_steps
+        @exception = @executed = nil
+      end
+
+      def init
+        return if @steps
+        @background.init
+        @background.feature_elements << self
+        attach_steps(@raw_steps)
+        step_invocations = @raw_steps.map{|step| step.step_invocation}
+        @steps = @background.step_collection(step_invocations)
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        
+        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.with_hooks(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
+      
+      
+      def with_visitor(visitor)
+        @current_visitor = visitor
+        yield
+        @current_visitor = nil
+      end
+      
+      private
+      
+      def skip_hooks?
+        @background.failed? || @executed
+      end
+    end
+  end
+end

data/lib/cucumber/ast/scenario_outline.rb

@@ -0,0 +1,122 @@
+module Cucumber
+  module Ast
+    class ScenarioOutline #:nodoc:
+      include FeatureElement
+      
+      attr_reader :name
+
+      module ExamplesArray #:nodoc:
+        def accept(visitor)
+          return if Cucumber.wants_to_quit
+          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, raw_steps, example_sections)
+        @background, @comment, @tags, @line, @keyword, @name, @raw_steps, @example_sections = background, comment, tags, line, keyword, name, raw_steps, example_sections
+      end
+
+      def add_examples(example_section, gherkin_examples)
+        @example_sections << [example_section, gherkin_examples]
+      end
+
+      def init
+        return if @steps
+        attach_steps(@raw_steps)
+        @steps = StepCollection.new(@raw_steps)
+
+        @examples_array = @example_sections.map do |example_section_and_gherkin_examples|
+          example_section = example_section_and_gherkin_examples[0]
+          gherkin_examples = example_section_and_gherkin_examples[1]
+          
+          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)
+          ex = Examples.new(examples_comment, examples_line, examples_keyword, examples_name, examples_table)
+          ex.gherkin_statement(gherkin_examples)
+          ex
+        end
+
+        @examples_array.extend(ExamplesArray)
+
+        @background.feature_elements << self if @background
+      end
+
+      def accept(visitor)
+        return if Cucumber.wants_to_quit
+        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 fail!(exception)
+        # Just a hack for https://rspec.lighthouseapp.com/projects/16211/tickets/413-scenario-outlines-that-fail-with-exception-exit-process
+        # Also see http://groups.google.com/group/cukes/browse_thread/thread/41cd567cb9df4bc3
+      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.keywords('scenario')[0],
+          row.name, 
+          file_colon_line(row.line), 
+          source_indent(first_line_length)
+        )
+      end
+
+      def failed?
+        @examples_array.select{|examples| examples.failed?}.any?
+      end
+
+      def to_sexp
+        init
+        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