cucumber 0.3.11 → 0.3.90

data/lib/cucumber/ast/step_invocation.rb

@@ -88,7 +88,8 @@ module Cucumber
       end
 
       def actual_keyword
-        if [Cucumber.keyword_hash['and'], Cucumber.keyword_hash['but']].index(@step.keyword) && previous
+        repeat_keywords = [language.but_keywords, language.and_keywords].flatten
+        if repeat_keywords.index(@step.keyword) && previous
           previous.actual_keyword
         else
           keyword
@@ -123,6 +124,10 @@ module Cucumber
         @step.backtrace_line
       end
 
+      def language
+        @step.language
+      end
+
       def to_sexp
         [:step_invocation, @step.line, @step.keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
       end

data/lib/cucumber/ast/table.rb

@@ -7,7 +7,9 @@ module Cucumber
     #
     # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
     #
-    class Table      
+    class Table
+      include Enumerable
+      
       NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
 
       attr_accessor :file
@@ -16,18 +18,19 @@ module Cucumber
         "table"
       end
 
-      def initialize(raw, conversions = NULL_CONVERSIONS.dup)
-        # Verify that it's square
-        raw.transpose
-        @raw = raw
+      def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup)
         @cells_class = Cells
         @cell_class = Cell
-        @conversion_procs = conversions
+
+        # Verify that it's square
+        transposed = raw.transpose
+        create_cell_matrix(raw)
+        @conversion_procs = conversion_procs
       end
 
       # Creates a copy of this table, inheriting the column mappings.
       def dup
-        self.class.new(@raw.dup, @conversion_procs.dup)
+        self.class.new(raw.dup, @conversion_procs.dup)
       end
 
       # Returns a new, transposed table. Example:
@@ -42,7 +45,7 @@ module Cucumber
       # | 4 | 2 |
       #
       def transpose
-        self.class.new(@raw.transpose, @conversion_procs.dup)
+        self.class.new(raw.transpose, @conversion_procs.dup)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -62,7 +65,7 @@ module Cucumber
       def hashes
         @hashes ||= cells_rows[1..-1].map do |row|
           row.to_hash
-        end
+        end.freeze
       end
       
       # Converts this table into a Hash where the first column is
@@ -78,8 +81,9 @@ module Cucumber
       # The table must be exactly two columns wide 
       #
       def rows_hash
+        return @rows_hash if @rows_hash
         verify_table_width(2)
-        @rows_hash = self.transpose.hashes[0]
+        @rows_hash = self.transpose.hashes[0].freeze
       end
 
       # Gets the raw data of this table. For example, a Table built from
@@ -88,17 +92,21 @@ module Cucumber
       #   | a | b |
       #   | c | d |
       #
-      # Get converted into the following:
+      # gets converted into the following:
       #
       #   [['a', 'b], ['c', 'd']]
       #
       def raw
-        @raw
+        cell_matrix.map do |row|
+          row.map do |cell|
+            cell.value
+          end
+        end
       end
 
       # Same as #raw, but skips the first (header) row
       def rows
-        @raw[1..-1]
+        raw[1..-1]
       end
 
       def each_cells_row(&proc)
@@ -117,7 +125,7 @@ module Cucumber
         [:table, *cells_rows.map{|row| row.to_sexp}]
       end
 
-      # Returns a new Table where the headers are redefined. This makes it
+      # Redefines the table headers. This makes it
       # possible to use prettier header names in the features. Example:
       #
       #   | Phone Number | Address |
@@ -130,6 +138,18 @@ module Cucumber
       #   hashes = mapped_table.hashes
       #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
       #
+      def map_headers!(mappings)
+        header_cells = cell_matrix[0]
+        mappings.each_pair do |pre, post|
+          header_cell = header_cells.detect{|cell| cell.value == pre}
+          header_cell.value = post
+          if @conversion_procs.has_key?(pre)
+            @conversion_procs[post] = @conversion_procs.delete(pre)
+          end
+        end
+      end
+
+      # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings)
         table = self.dup
         table.map_headers!(mappings)
@@ -153,11 +173,110 @@ module Cucumber
         @conversion_procs[column_name] = conversion_proc
       end
 
+      # Compares +other_table+ to self. If +other_table+ contains columns
+      # and/or rows that are not in self, new columns/rows are added at the
+      # relevant positions, marking the cells in those rows/columns as
+      # <tt>surplus</tt>. Likewise, if +other_table+ lacks columns and/or 
+      # rows that are present in self, these are marked as <tt>missing</tt>.
+      #
+      # <tt>surplus</tt> and <tt>missing</tt> cells are recognised by formatters
+      # and displayed so that it's easy to read the differences.
+      #
+      # Cells that are different, but <em>look</em> identical (for example the
+      # boolean true and the string "true") are converted to their Object#inspect
+      # representation and preceded with (i) - to make it easier to identify
+      # where the difference actually is.
+      #
+      # Since all tables that are passed to StepDefinitions always have String
+      # objects in their cells, you may want to use #map_column! before calling
+      # #diff!
+      #
+      # An exception is raised if there are missing rows or columns, or
+      # surplus rows. An error is <em>not</em> raised for surplus columns.
+      # Whether to raise or not raise can be changed by setting values in
+      # +options+ to true or false:
+      #
+      #   * <tt>missing_row</tt>: Raise on missing rows (defaults to true)
+      #   * <tt>surplus_row</tt>: Raise on surplus rows (defaults to true)
+      #   * <tt>missing_col</tt>: Raise on missing columns (defaults to true)
+      #   * <tt>surplus_col</tt>: Raise on surplus columns (defaults to false)
+      #
+      # The +other_table+ argument can be another Table, an Array of Array or
+      # an Array of Hash (similar to the structure returned by #hashes).
+      #
+      # Calling this method is particularly useful in <tt>Then</tt> steps that take
+      # a Table argument, if you want to compare that table to some actual values. 
+      #
+      def diff!(other_table, options={})
+        options = {:missing_row => true, :surplus_row => true, :missing_col => true, :surplus_col => false}.merge(options)
+
+        other_table = ensure_table(other_table)
+        ensure_green!
+
+        original_width = cell_matrix[0].length
+        other_table_cell_matrix = pad!(other_table.cell_matrix)
+        padded_width = cell_matrix[0].length
+
+        missing_col = cell_matrix[0].detect{|cell| cell.status == :undefined}
+        surplus_col = padded_width > original_width
+
+        require_diff_lcs
+        cell_matrix.extend(Diff::LCS)
+        convert_columns!
+        changes = cell_matrix.diff(other_table_cell_matrix).flatten
+
+        inserted = 0
+        missing  = 0
+
+        row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
+
+        last_change = nil
+        missing_row_pos = nil
+        insert_row_pos  = nil
+        
+        changes.each do |change|
+          if(change.action == '-')
+            missing_row_pos = change.position + inserted
+            cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
+            row_indices.insert(missing_row_pos, nil)
+            missing += 1
+          else # '+'
+            insert_row_pos = change.position + missing
+            inserted_row = change.element
+            inserted_row.each{|cell| cell.status = :comment}
+            cell_matrix.insert(insert_row_pos, inserted_row)
+            row_indices[insert_row_pos] = nil
+            inspect_rows(cell_matrix[missing_row_pos], inserted_row) if last_change && last_change.action == '-'
+            inserted += 1
+          end
+          last_change = change
+        end
+
+        other_table_cell_matrix.each_with_index do |other_row, i|
+          row_index = row_indices.index(i)
+          row = cell_matrix[row_index] if row_index
+          if row
+            (original_width..padded_width).each do |col_index|
+              surplus_cell = other_row[col_index]
+              row[col_index].value = surplus_cell.value if row[col_index]
+            end
+          end
+        end
+        
+        clear_cache!
+        should_raise = 
+          missing_row_pos && options[:missing_row] ||
+          insert_row_pos  && options[:surplus_row] ||
+          missing_col     && options[:missing_col] ||
+          surplus_col     && options[:surplus_col]
+        raise 'Tables were not identical' if should_raise
+      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|
+        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
@@ -169,11 +288,11 @@ module Cucumber
       end
 
       def verify_column(column_name)
-        raise %{The column named "#{column_name}" does not exist} unless @raw[0].include?(column_name)
+        raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name)
       end
       
       def verify_table_width(width)
-        raise %{The table must have exactly #{width} columns} unless @raw[0].size == width
+        raise %{The table must have exactly #{width} columns} unless raw[0].size == width
       end
 
       def arguments_replaced(arguments) #:nodoc:
@@ -202,47 +321,158 @@ module Cucumber
       end
 
       def headers
-        @raw.first
+        raw.first
       end
 
       def header_cell(col)
         cells_rows[0][col]
       end
 
+      def cell_matrix
+        @cell_matrix
+      end
+
+      def col_width(col)
+        columns[col].__send__(:width)
+      end
+
+      def to_s(options = {})
+        options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
+        io = StringIO.new
+
+        c = Term::ANSIColor.coloring?
+        Term::ANSIColor.coloring = options[:color]
+        f = Formatter::Pretty.new(nil, io, options)
+        f.instance_variable_set('@indent', options[:indent])
+        f.visit_multiline_arg(self)
+        Term::ANSIColor.coloring = c
+
+        io.rewind
+        s = "\n" + io.read + (" " * (options[:indent] - 2))
+        s
+      end
+
+      private
+
+      TO_S_PREFIXES = Hash.new('    ')
+      TO_S_PREFIXES[:comment]   = ['(+) ']
+      TO_S_PREFIXES[:undefined] = ['(-) ']
+
       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)
+      def inspect_rows(missing_row, inserted_row)
+        missing_row.each_with_index do |missing_cell, col|
+          inserted_cell = inserted_row[col]
+          if(missing_cell.value != inserted_cell.value && (missing_cell.value.to_s == inserted_cell.value.to_s))
+            missing_cell.inspect!
+            inserted_cell.inspect!
           end
         end
       end
 
-      private
+      def create_cell_matrix(raw)
+        @cell_matrix = raw.map do |raw_row|
+          line = raw_row.line rescue -1
+          raw_row.map do |raw_cell|
+            new_cell(raw_cell, line)
+          end
+        end
+      end
 
-      def col_width(col)
-        columns[col].__send__(:width)
+      def convert_columns!
+        cell_matrix.transpose.each do |col|
+          conversion_proc = @conversion_procs[col[0].value]
+          col[1..-1].each do |cell|
+            cell.value = conversion_proc.call(cell.value)
+          end
+        end
+      end
+
+      def require_diff_lcs
+        begin
+          require 'diff/lcs'
+        rescue LoadError => e
+          e.message << "\n Please gem install diff-lcs\n"
+          raise e
+        end
+      end
+
+      def clear_cache!
+        @hashes = @rows_hash = @rows = @columns = nil
       end
 
       def columns
         @columns ||= cell_matrix.transpose.map do |cell_row|
           @cells_class.new(self, cell_row)
-        end
+        end.freeze
       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)
+      def new_cell(raw_cell, line)
+        @cell_class.new(raw_cell, self, line)
+      end
+
+      # Pads our own cell_matrix and returns a cell matrix of same
+      # column width that can be used for diffing
+      def pad!(other_cell_matrix)
+        clear_cache!
+        cols = cell_matrix.transpose
+        unmapped_cols = other_cell_matrix.transpose
+
+        mapped_cols = []
+
+        cols.each_with_index do |col, col_index|
+          header = col[0]
+          candidate_cols, unmapped_cols = unmapped_cols.partition do |other_col|
+            other_col[0] == header
           end
+          raise "More than one column has the header #{header}" if candidate_cols.size > 2
+
+          other_padded_col = if candidate_cols.size == 1
+            # Found a matching column
+            candidate_cols[0]
+          else
+            mark_as_missing(cols[col_index])
+            (0...other_cell_matrix.length).map do |row|
+              val = row == 0 ? header.value : nil
+              SurplusCell.new(val, self, -1)
+            end
+          end
+          mapped_cols.insert(col_index, other_padded_col)
+        end
+
+        unmapped_cols.each_with_index do |col, col_index|
+          empty_col = (0...cell_matrix.length).map do |row| 
+            SurplusCell.new(nil, self, -1)
+          end
+          cols << empty_col
+        end
+
+        @cell_matrix = cols.transpose
+        (mapped_cols + unmapped_cols).transpose
+      end
+
+      def ensure_table(table_or_array)
+        return table_or_array if Table === table_or_array
+        table_or_array = hashes_to_array(table_or_array) if Hash === table_or_array[0]
+        Table.new(table_or_array)
+      end
+
+      def hashes_to_array(hashes)
+        header = hashes[0].keys
+        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
+      end
+
+      def ensure_green!
+        each_cell{|cell| cell.status = :passed}
+      end
+
+      def each_cell(&proc)
+        cell_matrix.each{|row| row.each(&proc)}
+      end
+
+      def mark_as_missing(col)
+        col.each do |cell|
+          cell.status = :undefined
         end
       end
 
@@ -268,7 +498,7 @@ module Cucumber
         end
 
         def to_hash #:nodoc:
-          @to_hash ||= @table.to_hash(self)
+          @to_hash ||= @table.to_hash(self).freeze
         end
 
         def value(n) #:nodoc:
@@ -303,30 +533,38 @@ module Cucumber
       end
 
       class Cell
-        attr_reader :value, :line
-        attr_writer :status
+        attr_reader :line, :table
+        attr_accessor :status, :value
 
-        def initialize(value, table, row, col, line)
-          @value, @table, @row, @col, @line = value, table, row, col, line
+        def initialize(value, table, line)
+          @value, @table, @line = value, table, line
         end
 
         def accept(visitor)
-          visitor.visit_table_cell_value(@value, col_width, @status)
+          visitor.visit_table_cell_value(value, status)
+        end
+
+        def inspect!
+          @value = "(i) #{value.inspect}"
         end
 
-        def header_cell
-          @table.header_cell(@col)
+        def ==(o)
+          SurplusCell === o || value == o.value
         end
 
         # For testing only
         def to_sexp #:nodoc:
           [:cell, @value]
         end
+      end
+      
+      class SurplusCell < Cell
+        def status
+          :comment
+        end
 
-        private
-
-        def col_width
-          @col_width ||= @table.__send__(:col_width, @col)
+        def ==(o)
+          true
         end
       end
     end