kosmas58-cucumber 0.1.99.21 → 0.1.99.22

data/lib/cucumber/ast/outline_table.rb

@@ -1,49 +0,0 @@
-module Cucumber
-  module Ast
-    class OutlineTable < Table
-      def initialize(raw, scenario_outline)
-        super(raw)
-        @scenario_outline = scenario_outline
-        @cells_class = ExampleCells
-      end
-
-      def accept(visitor, status)
-        cells_rows.each_with_index do |row, n|
-          should_visit = n == 0 || 
-            row.at_lines?(visitor.current_feature_lines) ||
-            @scenario_outline.at_header_or_step_lines?(visitor.current_feature_lines)
-
-          if should_visit
-            visitor.visit_table_row(row, status)
-          end
-        end
-        nil
-      end
-
-      def execute_row(cells, visitor, &proc)
-        @scenario_outline.execute_row(cells, visitor, &proc)
-      end
-
-      class ExampleCells < Cells
-        def accept(visitor, status)
-          if header?
-            @cells.each do |cell|
-              visitor.visit_table_cell(cell, :thead)
-            end
-            nil
-          else
-            exception = @table.execute_row(self, visitor) do |cell, status|
-              visitor.visit_table_cell(cell, status)
-            end
-          end
-        end
-
-        private
-
-        def header?
-          index == 0
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/ast/py_string.rb

@@ -1,52 +0,0 @@
-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
-      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 at_lines?(lines)
-        lines.detect{|l| l >= @start_line && l <= @end_line}
-      end
-
-      def accept(visitor, status)
-        visitor.visit_py_string(to_s, status)
-      end
-      
-      def arguments_replaced(arguments) #:nodoc:
-        string = @string
-        arguments.each do |name, value|
-          string = string.gsub(name, value)
-        end
-        PyString.new(@start_line, @end_line, string, @quotes_indent)
-      end
-      
-      # For testing only
-      def to_sexp #:nodoc:
-        [:py_string, to_s]
-      end
-    
-    end
-  end
-end

data/lib/cucumber/ast/scenario.rb

@@ -1,103 +0,0 @@
-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}
-      end
-
-      def tagged_with?(tag_names)
-        @tags.among?(tag_names) || @feature.tagged_with?(tag_names, false)
-      end
-
-      def matches_scenario_names?(scenario_names)
-        scenario_names.detect{|name| @name == name}
-      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
-
-      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
-        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]
-      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.map{|step| step.to_sexp}
-        sexp += steps if steps.any?
-        sexp
-      end
-    end
-  end
-end

data/lib/cucumber/ast/scenario_outline.rb

@@ -1,92 +0,0 @@
-module Cucumber
-  module Ast
-    class ScenarioOutline < Scenario
-      # 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}
-
-        @examples_array = example_sections.map do |example_section|
-          examples_line       = example_section[0]
-          examples_keyword    = example_section[1]
-          examples_name       = example_section[2]
-          examples_matrix     = example_section[3]
-
-          examples_table = OutlineTable.new(examples_matrix, self)
-          Examples.new(examples_line, examples_keyword, examples_name, examples_table)
-        end
-      end
-
-      def at_lines?(lines)
-        super || @examples_array.detect { |examples| examples.at_lines?(lines) }
-      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)
-
-        @examples_array.each do |examples|
-          visitor.visit_examples(examples)
-        end
-      end
-
-      def each_example_row(&proc)
-        @examples_array.each do |examples|
-          examples.each_example_row(&proc)
-        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
-        end
-        @feature.scenario_executed(self) if @feature
-        exception
-      end
-
-      def pending? ; false ; 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.map{|step| step.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

@@ -1,161 +0,0 @@
-require 'cucumber/step_definition'
-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
-
-      def initialize(line, keyword, name, *multiline_args)
-        @line, @keyword, @name, @multiline_args = line, keyword, name, multiline_args
-      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)
-
-        execute_twin(world, previous, visitor, row_line, name, *multiline_args)
-      end
-      
-      def execute_as_new(world, previous, visitor, row_line)
-        execute_twin(world, previous, visitor, row_line, @name, *@multiline_args)
-      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
-      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|
-          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
-        end
-        nil
-      end
-
-      def to_sexp
-        [:step, @line, @keyword, @name, *@multiline_args.map{|arg| arg.to_sexp}]
-      end
-
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line) || @multiline_args.detect{|a| a.at_lines?(lines)}
-      end
-
-      def source_indent
-        @scenario.source_indent(text_length)
-      end
-
-      def text_length
-        @keyword.jlength + @name.jlength + 2 # Add 2 because steps get indented 2 more than scenarios
-      end
-
-      def backtrace_line
-        @backtrace_line ||= @scenario.backtrace_line("#{@keyword} #{@name}", @line) unless @scenario.nil?
-      end
-
-      def file_line
-        @file_line ||= @scenario.file_line(@line) unless @scenario.nil?
-      end
-
-      def actual_keyword
-        if [Cucumber.keyword_hash['and'], Cucumber.keyword_hash['but']].index(@keyword) && previous_step
-          previous_step.actual_keyword
-        else
-          @keyword
-        end
-      end
-
-      protected
-
-      def previous_step
-        @scenario.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
-        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)
-      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 }
-      end
-
-      def replace_name_arguments(argument_hash)
-        name_with_arguments_replaced = @name
-        argument_hash.each do |name, 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/steps.rb

@@ -1,13 +0,0 @@
-module Cucumber
-  module Ast
-    class Steps
-      def initialize(scenario)
-        @scenario = scenario
-      end
-
-      def accept(visitor)
-        @scenario.accept_steps(visitor)
-      end
-    end
-  end
-end

data/lib/cucumber/ast/table.rb

@@ -1,218 +0,0 @@
-module Cucumber
-  module Ast
-    # Holds the data of a table parsed from a feature file:
-    #
-    #   | a | b |
-    #   | c | d |
-    #
-    # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
-    #
-    class Table
-      attr_accessor :file
-
-      def initialize(raw)
-        # Verify that it's square
-        raw.transpose
-        @raw = raw
-        @cells_class = Cells
-        @cell_class = Cell
-      end
-
-      def at_lines?(lines)
-        cells_rows.detect { |row| row.at_lines?(lines) }
-      end
-
-      def accept(visitor, status)
-        cells_rows.each do |row|
-          visitor.visit_table_row(row, status)
-        end
-        nil
-      end
-
-      # Converts this table into an Array of Hash where the keys of each
-      # Hash are the headers in the table. For example, a Table built from
-      # the following plain text:
-      #
-      #   | a | b | sum |
-      #   | 2 | 3 | 5   |
-      #   | 7 | 9 | 16  |
-      #
-      # Gets converted into the following:
-      #
-      #   [{'a' => '2', 'b' => '3', 'sum' => '5'}, {'a' => '7', 'b' => '9', 'sum' => '16'}]
-      #
-      def hashes
-        @hashes ||= cells_rows[1..-1].map do |row|
-          row.to_hash
-        end
-      end
-
-      # Gets the raw data of this table. For example, a Table built from
-      # the following plain text:
-      #
-      #   | a | b |
-      #   | c | d |
-      #
-      # Get converted into the following:
-      #
-      #   [['a', 'b], ['c', 'd']]
-      #
-      def raw
-        @raw
-      end
-
-      # Same as #raw, but skips the first (header) row
-      def rows
-        @raw[1..-1]
-      end
-
-      def each_cells_row(&proc)
-        cells_rows.each(&proc)
-      end
-
-      # For testing only
-      def to_sexp #:nodoc:
-        [:table, *cells_rows.map{|row| row.to_sexp}]
-      end
-
-      def to_hash(cells) #:nodoc:
-        hash = {}
-        @raw[0].each_with_index do |key, n|
-          hash[key] = cells.value(n)
-        end
-        hash
-      end
-
-      def index(cells) #:nodoc:
-        cells_rows.index(cells)
-      end
-
-      def arguments_replaced(arguments) #:nodoc:
-        raw_with_replaced_args = raw.map do |row|
-          row.map do |cell|
-            cell_with_replaced_args = cell
-            arguments.each do |name, value|
-              cell_with_replaced_args = cell_with_replaced_args.gsub(name, value)
-            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)}
-      end
-
-      private
-
-      def col_width(col)
-        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)
-        end
-      end
-
-      def cell_matrix
-        row = -1
-        @cell_matrix ||= @raw.map do |raw_row|
-          line = raw_row.line rescue -1
-          row += 1
-          col = -1
-          raw_row.map do |raw_cell|
-            col += 1
-            @cell_class.new(raw_cell, self, row, col, line)
-          end
-        end
-      end
-
-      # Represents a row of cells or columns of cells
-      class Cells
-        include Enumerable
-
-        def initialize(table, cells)
-          @table, @cells = table, cells
-        end
-
-        def accept(visitor, status)
-          each do |cell|
-            visitor.visit_table_cell(cell, status)
-          end
-          nil
-        end
-
-        # For testing only
-        def to_sexp #:nodoc:
-          [:row, *@cells.map{|cell| cell.to_sexp}]
-        end
-
-        def to_hash #:nodoc:
-          @to_hash ||= @table.to_hash(self)
-        end
-
-        def value(n) #:nodoc:
-          self[n].value
-        end
-
-        def [](n)
-          @cells[n]
-        end
-
-        def line
-          @cells[0].line
-        end
-
-        def at_lines?(lines)
-          lines.empty? || lines.index(line)
-        end
-
-        private
-
-        def index
-          @table.index(self)
-        end
-
-        def width
-          map{|cell| cell.value ? cell.value.to_s.jlength : 0}.max
-        end
-
-        def each(&proc)
-          @cells.each(&proc)
-        end
-      end
-
-      class Cell
-        attr_reader :value, :line
-
-        def initialize(value, table, row, col, line)
-          @value, @table, @row, @col, @line = value, table, row, col, line
-        end
-
-        def accept(visitor, status)
-          visitor.visit_table_cell_value(@value, col_width, status)
-        end
-
-        # For testing only
-        def to_sexp #:nodoc:
-          [:cell, @value]
-        end
-
-        private
-
-        def col_width
-          @col_width ||= @table.__send__(:col_width, @col)
-        end
-      end
-    end
-  end
-end