square-cucumber 0.3.12.2 → 0.3.93.1

data/lib/cucumber/ast/examples.rb

@@ -6,6 +6,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         visitor.visit_examples_name(@keyword, @name)
         visitor.visit_outline_table(@outline_table)
       end

data/lib/cucumber/ast/feature.rb

@@ -16,6 +16,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         visitor.visit_comment(@comment) unless @comment.empty?
         visitor.visit_tags(@tags)
         visitor.visit_feature_name(@name)
@@ -43,6 +44,15 @@ module Cucumber
         "#{@file}:#{line}"
       end
 
+      def short_name
+        first_line = name.split(/\n/)[0]
+        if first_line =~ /#{language.keywords('feature', true)}:(.*)/
+          $1.strip
+        else
+          first_line
+        end
+      end
+
       def to_sexp
         sexp = [:feature, @file, @name]
         comment = @comment.to_sexp

data/lib/cucumber/ast/features.rb

@@ -9,6 +9,10 @@ module Cucumber
         @features = []
       end
 
+      def [](index)
+        @features[index]
+      end
+
       def each(&proc)
         @features.each(&proc)
       end
@@ -19,8 +23,9 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         start = Time.now
-        @features.each do |feature|
+        self.each do |feature|
           visitor.visit_feature(feature)
         end
         @duration = Time.now - start

data/lib/cucumber/ast/outline_table.rb

@@ -9,6 +9,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         cells_rows.each_with_index do |row, n|
           if(visitor.options[:expand])
             row.accept(visitor)
@@ -44,7 +45,8 @@ module Cucumber
       end
 
       class ExampleRow < Cells
-        
+        attr_reader :scenario_outline # https://rspec.lighthouseapp.com/projects/16211/tickets/342
+
         def create_step_invocations!(scenario_outline)
           @scenario_outline = scenario_outline
           @step_invocations = scenario_outline.step_invocations(self)
@@ -57,6 +59,7 @@ module Cucumber
         end
 
         def accept(visitor)
+          return if $cucumber_interrupted
           visitor.options[:expand] ? accept_expand(visitor) : accept_plain(visitor)
         end
 

data/lib/cucumber/ast/py_string.rb

@@ -17,7 +17,6 @@ module Cucumber
     # Note how the indentation from the source is stripped away.
     #
     class PyString
-
       def self.default_arg_name
         "string"
       end
@@ -32,6 +31,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         visitor.visit_py_string(to_s)
       end
       

data/lib/cucumber/ast/scenario.rb

@@ -21,6 +21,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         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))

data/lib/cucumber/ast/scenario_outline.rb

@@ -5,6 +5,7 @@ module Cucumber
 
       module ExamplesArray
         def accept(visitor)
+          return if $cucumber_interrupted
           each do |examples|
             visitor.visit_examples(examples)
           end
@@ -37,6 +38,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         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))

data/lib/cucumber/ast/step.rb

@@ -33,6 +33,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         # 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)
@@ -85,8 +86,11 @@ module Cucumber
       private
 
       def matched_cells(cells)
+        col_index = 0
         cells.select do |cell|
-          delimited = delimited(cell.header_cell.value)
+          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

data/lib/cucumber/ast/step_collection.rb

@@ -10,6 +10,7 @@ module Cucumber
       end
 
       def accept(visitor, &proc)
+        return if $cucumber_interrupted
         @steps.each do |step|
           visitor.visit_step(step) if proc.nil? || proc.call(step)
         end

data/lib/cucumber/ast/step_invocation.rb

@@ -19,6 +19,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         invoke(visitor.step_mother, visitor.options)
         visit_step_result(visitor)
       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
@@ -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)
@@ -106,6 +114,7 @@ module Cucumber
       end
 
       def accept(visitor)
+        return if $cucumber_interrupted
         cells_rows.each do |row|
           visitor.visit_table_row(row)
         end
@@ -117,19 +126,38 @@ module Cucumber
         [: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:
+      # Redefines the table headers. This makes it possible to use
+      # prettier and more flexible header names in the features.  The
+      # keys of +mappings+ are Strings or regular expressions
+      # (anything that responds to #=== will work) that may match
+      # column headings in the table.  The values of +mappings+ are
+      # desired names for the columns.
+      #
+      # Example:
       #
       #   | Phone Number | Address |
       #   | 123456       | xyz     |
       #   | 345678       | abc     |
       #
-      # A StepDefinition receiving this table can then map the columns:
+      # A StepDefinition receiving this table can then map the columns 
+      # with both Regexp and String:
       #
-      #   mapped_table = table.map_columns('Phone Number' => :phone, 'Address' => :address)
-      #   hashes = mapped_table.hashes
+      #   table.map_headers!(/phone( number)?/i => :phone, 'Address' => :address)
+      #   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| pre === cell.value}
+          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 +181,111 @@ 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!. You can use #map_column! on either of the tables.
+      #
+      # 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)
+        other_table.convert_columns!
+        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 +297,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:
@@ -198,33 +326,88 @@ module Cucumber
       def cells_rows
         @rows ||= cell_matrix.map do |cell_row|
           @cells_class.new(self, cell_row)
-        end.freeze
+        end
       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
@@ -233,17 +416,78 @@ module Cucumber
         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
-        end.freeze
+          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_or_array = enumerable_to_array(table_or_array) unless Array == 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 enumerable_to_array(rows)
+        rows.map{|row| row.map{|cell| cell}}
+      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
 
       # Represents a row of cells or columns of cells
@@ -256,6 +500,7 @@ module Cucumber
         end
 
         def accept(visitor)
+          return if $cucumber_interrupted
           each do |cell|
             visitor.visit_table_cell(cell)
           end
@@ -303,30 +548,39 @@ 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)
+          return if $cucumber_interrupted
+          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).freeze
+        def ==(o)
+          true
         end
       end
     end