cucumber 1.3.10 → 2.0.0

data/lib/cucumber/ast/outline_table.rb

@@ -1,194 +0,0 @@
-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_tags
-        @scenario_outline.source_tags
-      end
-
-      def source_tag_names
-        source_tags.map { |tag| tag.name }
-      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
-          source_tags.map { |tag| tag.name }
-        end
-
-        def source_tags
-          @table.source_tags
-        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.runtime.with_hooks(self) do
-              @step_invocations.each do |step_invocation|
-                step_invocation.invoke(visitor.runtime, 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.runtime.with_hooks(self) do
-              @table.visit_scenario_name(visitor, self)
-              @step_invocations.each do |step_invocation|
-                visitor.visit_step(step_invocation)
-                @exception ||= step_invocation.reported_exception
-              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/scenario.rb

@@ -1,103 +0,0 @@
-require 'cucumber/ast/has_steps'
-require 'cucumber/ast/names'
-require 'cucumber/ast/empty_background'
-require 'cucumber/ast/location'
-require 'cucumber/unit'
-
-module Cucumber
-  module Ast
-    class Scenario #:nodoc:
-      include HasSteps
-      include Names
-      include HasLocation
-
-      attr_reader   :feature_tags
-      attr_accessor :feature
-
-      def initialize(language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps)
-        @language, @location, @background, @comment, @tags, @feature_tags, @keyword, @title, @description, @raw_steps = language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps
-        @exception = @executed = nil
-        attach_steps(@raw_steps)
-      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, source_indent(first_line_length))
-
-        skip_invoke! if @background.failed?
-        with_visitor(visitor) do
-          visitor.execute(self, skip_hooks?)
-        end
-        @executed = true
-      end
-
-      def to_units(background)
-        [Unit.new(background.step_invocations + step_invocations)]
-      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 to_sexp
-        sexp = [:scenario, line, @keyword, name]
-        comment = @comment.to_sexp
-        sexp += [comment] if comment
-        tags = @tags.to_sexp
-        sexp += tags if tags.any?
-        sexp += steps.to_sexp if steps.any?
-        sexp
-      end
-
-      def with_visitor(visitor)
-        @current_visitor = visitor
-        yield
-        @current_visitor = nil
-      end
-
-      def skip_invoke!
-        steps.skip_invoke!
-      end
-
-      def steps
-        @steps ||= @background.step_collection(step_invocations)
-      end
-
-      private
-
-      def step_invocations
-        @raw_steps.map{|step| step.step_invocation}
-      end
-
-      def skip_hooks?
-        @background.failed? || @executed
-      end
-
-    end
-  end
-end

data/lib/cucumber/ast/scenario_outline.rb

@@ -1,146 +0,0 @@
-require 'cucumber/ast/has_steps'
-require 'cucumber/ast/names'
-require 'cucumber/ast/empty_background'
-
-module Cucumber
-  module Ast
-    class ScenarioOutline #:nodoc:
-      include HasSteps
-      include Names
-      include HasLocation
-
-      attr_accessor :feature
-      attr_reader :feature_tags
-
-      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(language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps, example_sections)
-        @language, @location, @background, @comment, @tags, @feature_tags, @keyword, @title, @description, @raw_steps, @example_sections = language, location, background, comment, tags, feature_tags, keyword, title, description, raw_steps, example_sections
-        attach_steps(@raw_steps)
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        raise_missing_examples_error unless @example_sections
-
-        visitor.visit_comment(@comment) unless @comment.empty?
-        visitor.visit_tags(@tags)
-        visitor.visit_scenario_name(@keyword, name, file_colon_line, source_indent(first_line_length))
-        visitor.visit_steps(steps)
-
-        skip_invoke! if @background.failed?
-        visitor.visit_examples_array(examples_array) unless examples_array.empty?
-      end
-
-      def to_units(background)
-        raise ArgumentError.new("#{background} != #{@background}") unless background == @background # maybe we don't need this argument, but it seems like the leaf AST nodes would be better not being aware of their parents. However step_invocations uses the ivar at the moment, so we'll just do this check to make sure its OK.
-        result = []
-        each_example_row do |row|
-          result << Unit.new(step_invocations(row))
-        end
-        result
-      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! }
-      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(
-          language.keywords('scenario')[0],
-          row.name,
-          Location.new(file, row.line).to_s,
-          source_indent(first_line_length)
-        )
-      end
-
-      def failed?
-        examples_array.select { |examples| examples.failed? }.any?
-      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?
-        sexp += steps.to_sexp if steps.any?
-        sexp += examples_array.map{|e| e.to_sexp}
-        sexp
-      end
-
-      private
-
-      attr_reader :line
-
-      def examples_array
-        return @examples_array if @examples_array
-        @examples_array = @example_sections.map do |section|
-          create_examples_table(section)
-        end
-        @examples_array.extend(ExamplesArray)
-        @examples_array
-      end
-
-      def create_examples_table(example_section_and_gherkin_examples)
-        example_section = example_section_and_gherkin_examples[0]
-        gherkin_examples = example_section_and_gherkin_examples[1]
-
-        examples_location    = example_section[0]
-        examples_comment     = example_section[1]
-        examples_keyword     = example_section[2]
-        examples_title       = example_section[3]
-        examples_description = example_section[4]
-        examples_matrix      = example_section[5]
-
-        examples_table = OutlineTable.new(examples_matrix, self)
-        ex = Examples.new(examples_location, examples_comment, examples_keyword, examples_title, examples_description, examples_table)
-        ex.gherkin_statement(gherkin_examples)
-        ex
-      end
-
-      def steps
-        @steps ||= StepCollection.new(@raw_steps)
-      end
-
-      def raise_missing_examples_error
-        raise MissingExamples, "Missing Example Section for Scenario Outline at #{@location}"
-      end
-
-      MissingExamples = Class.new(StandardError)
-    end
-  end
-end

data/lib/cucumber/ast/step.rb

@@ -1,122 +0,0 @@
-require 'cucumber/core_ext/string'
-require 'cucumber/step_match'
-require 'cucumber/ast/location'
-
-module Cucumber
-  module Ast
-    class Step #:nodoc:
-      include HasLocation
-
-      attr_reader :keyword, :name, :language
-      attr_writer :step_collection, :options
-      attr_accessor :feature_element, :exception, :multiline_arg
-
-      INDENT = 2
-
-      def initialize(language, location, keyword, name, multiline_arg=nil)
-        @language, @location, @keyword, @name, @multiline_arg = language, location, keyword, name, multiline_arg
-        @language || raise("Language is required!")
-      end
-
-      attr_reader :gherkin_statement
-      def gherkin_statement(statement=nil)
-        @gherkin_statement ||= statement
-      end
-
-      def background?
-        false
-      end
-
-      def status
-        # Step always has status skipped, because Step is always in a ScenarioOutline
-        :skipped
-      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.wants_to_quit
-        # 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, file_colon_line)
-      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_to_match       = replace_name_arguments(delimited_arguments)
-          step_match          = visitor.runtime.step_match(name_to_match, 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)
-        INDENT + INDENT + keyword.unpack('U*').length + name.unpack('U*').length
-      end
-
-      def backtrace_line
-        @backtrace_line ||= feature_element.backtrace_line("#{keyword}#{name}", line) unless feature_element.nil?
-      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 |key, value|
-          value ||= ''
-          name_with_arguments_replaced = name_with_arguments_replaced.gsub(key, value)
-        end
-        name_with_arguments_replaced
-      end
-    end
-  end
-end

data/lib/cucumber/ast/step_collection.rb

@@ -1,92 +0,0 @@
-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 inspect
-        @steps.map { |s| [s.class, s.object_id] }.join(', ')
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        @steps.each do |step|
-          visitor.visit_step(step)
-        end
-      end
-
-      def step_invocations(background = false)
-        StepCollection.new(@steps.map{ |step|
-          i = step.step_invocation
-          i.background = background
-          i
-        })
-      end
-
-      def skip_invoke!
-        @steps.each{|step_invocation| step_invocation.skip_invoke!}
-      end
-
-      def step_invocations_from_cells(cells)
-        @steps.map{|step| step.step_invocation_from_cells(cells)}
-      end
-
-      def +(step_invocations)
-        dup(step_invocations)
-      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 length
-        @steps.length
-      end
-
-      def to_sexp
-        @steps.map{|step| step.to_sexp}
-      end
-    end
-  end
-end