notch8-cucumber 0.1.99.23

data/lib/cucumber/ast/py_string.rb

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,103 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,290 @@
+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
+      NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
+
+      attr_accessor :file
+
+      def initialize(raw, conversions = NULL_CONVERSIONS.dup)
+        # Verify that it's square
+        raw.transpose
+        @raw = raw
+        @cells_class = Cells
+        @cell_class = Cell
+        @conversion_procs = conversions
+      end
+
+      # Creates a copy of this table, inheriting the column mappings.
+      def dup
+        self.class.new(@raw.dup, @conversion_procs.dup)
+      end
+
+      # Returns a new, transposed table. Example:
+      #
+      # | a | 7 | 4 |
+      # | b | 9 | 2 |
+      #
+      # Gets converted into the following:
+      #
+      # | a | b |
+      # | 7 | 9 |
+      # | 4 | 2 |
+      #
+      def transpose
+        self.class.new(@raw.transpose, @conversion_procs.dup)
+      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'}]
+      #
+      # Use #map_column! to specify how values in a column are converted.
+      #
+      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
+
+      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
+
+      # For testing only
+      def to_sexp #:nodoc:
+        [:table, *cells_rows.map{|row| row.to_sexp}]
+      end
+
+      # Returns a new Table where the headers are redefined. This makes it
+      # possible to use prettier header names in the features. Example:
+      #
+      #   | Phone Number | Address |
+      #   | 123456       | xyz     |
+      #   | 345678       | abc     |
+      #
+      # A StepDefinition receiving this table can then map the columns:
+      #
+      #   mapped_table = table.map_columns('Phone Number' => :phone, 'Address' => :address)
+      #   hashes = mapped_table.hashes
+      #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
+      #
+      def map_headers(mappings)
+        table = self.dup
+        table.map_headers!(mappings)
+        table
+      end
+
+      # Change how #hashes converts column values. The +column_name+ argument identifies the column
+      # and +conversion_proc+ performs the conversion for each cell in that column. If +strict+ is 
+      # true, an error will be raised if the column named +column_name+ is not found. If +strict+ 
+      # is false, no error will be raised.
+      def map_column!(column_name, strict=true, &conversion_proc)
+        verify_column(column_name) if strict
+        @conversion_procs[column_name] = conversion_proc
+      end
+
+      def to_hash(cells) #:nodoc:
+        hash = Hash.new do |hash, key|
+          hash[key.to_s] if key.is_a?(Symbol)
+        end
+        @raw[0].each_with_index do |column_name, column_index|
+          value = @conversion_procs[column_name].call(cells.value(column_index))
+          hash[column_name] = value
+        end
+        hash
+      end
+
+      def index(cells) #:nodoc:
+        cells_rows.index(cells)
+      end
+
+      def verify_column(column_name)
+        raise %{The column named "#{column_name}" does not exist} unless @raw[0].include?(column_name)
+      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 = value && !cell.nil? ? cell_with_replaced_args.gsub(name, value) : nil
+            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
+
+      protected
+
+      def map_headers!(mappings)
+        headers = @raw[0]
+        mappings.each_pair do |pre, post|
+          headers[headers.index(pre)] = post
+          if @conversion_procs.has_key?(pre)
+            @conversion_procs[post] = @conversion_procs.delete(pre)
+          end
+        end
+      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