cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/load_path.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Cucumber
   module LoadPath
     def add_dirs(*dirs)

data/lib/cucumber/multiline_argument.rb

@@ -1,26 +1,24 @@
+# frozen_string_literal: true
+
 require 'delegate'
 require 'cucumber/multiline_argument/data_table'
 require 'cucumber/multiline_argument/doc_string'
-require 'gherkin/rubify'
 
 module Cucumber
   module MultilineArgument
-    extend Gherkin::Rubify
-
     class << self
       def from_core(node)
         builder.wrap(node)
       end
 
-      def from(argument, location=nil)
-        location ||= Core::Ast::Location.of_caller
-        argument = rubify(argument)
+      def from(argument, location = nil, content_type = nil)
+        location ||= Core::Test::Location.of_caller
         case argument
         when String
-          doc_string(argument, 'text/plain', location)
+          builder.doc_string(Core::Test::DocString.new(argument, content_type, location))
         when Array
           location = location.on_line(argument.first.line..argument.last.line)
-          data_table(argument.map{ |row| row.cells }, location)
+          builder.data_table(argument.map(&:cells), location)
         when DataTable, DocString, None
           argument
         when nil
@@ -30,14 +28,6 @@ module Cucumber
         end
       end
 
-      def doc_string(argument, content_type, location)
-        builder.doc_string(Core::Ast::DocString.new(argument, content_type, location))
-      end
-
-      def data_table(data, location)
-        builder.data_table(Core::Ast::DataTable.new(data, location))
-      end
-
       private
 
       def builder
@@ -51,24 +41,20 @@ module Cucumber
           @result
         end
 
-        def doc_string(node, *args)
+        def doc_string(node, *_args)
           @result = DocString.new(node)
         end
 
-        def data_table(node, *args)
+        def data_table(node, *_args)
           @result = DataTable.new(node)
         end
       end
     end
 
     class None
-      def append_to(array)
-      end
+      def append_to(array); end
 
-      def describe_to(visitor)
-      end
+      def describe_to(visitor); end
     end
   end
 end
-
-require 'cucumber/ast'

data/lib/cucumber/multiline_argument/data_table.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 require 'forwardable'
-require 'gherkin/formatter/escaping'
-require 'cucumber/core/ast/describes_itself'
+require 'cucumber/gherkin/data_table_parser'
+require 'cucumber/gherkin/formatter/escaping'
+require 'cucumber/multiline_argument/data_table/diff_matrices'
 
 module Cucumber
   module MultilineArgument
@@ -24,72 +27,62 @@ module Cucumber
     # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
     #
     class DataTable
-      class Different < StandardError
-        def initialize(table)
-          super("Tables were not identical:\n#{table}")
-        end
-      end
-
-      class Builder
-        attr_reader :rows
-
-        def initialize
-          @rows = []
-        end
-
-        def row(row, line_number)
-          @rows << row
-        end
-
-        def eof
-        end
+      def self.default_arg_name #:nodoc:
+        'table'
       end
 
-      include Enumerable
-      include Core::Ast::DescribesItself
-      extend Forwardable
-
-      NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
-
-      attr_accessor :file
-      def_delegator :@ast_table, :location
-
-      def self.default_arg_name #:nodoc:
-        "table"
+      def describe_to(visitor, *args)
+        visitor.legacy_table(self, *args)
       end
 
       class << self
-        def from(data, location = Core::Ast::Location.of_caller)
+        def from(data, location = Core::Test::Location.of_caller)
           case data
           when Array
             from_array(data, location)
           when String
             parse(data, location)
           else
-            raise ArgumentError, "expected data to be a String or an Array."
+            raise ArgumentError, 'expected data to be a String or an Array.'
           end
         end
 
         private
-        def parse(text, location = Core::Ast::Location.of_caller)
+
+        def parse(text, location = Core::Test::Location.of_caller)
           builder = Builder.new
-          lexer = Gherkin::Lexer::I18nLexer.new(builder)
-          lexer.scan(text)
+          parser = Cucumber::Gherkin::DataTableParser.new(builder)
+          parser.parse(text)
           from_array(builder.rows, location)
         end
 
-        def from_array(data, location = Core::Ast::Location.of_caller)
-          new Core::Ast::DataTable.new(data, location)
+        def from_array(data, location = Core::Test::Location.of_caller)
+          new Core::Test::DataTable.new(data, location)
         end
       end
 
+      class Builder
+        attr_reader :rows
 
-      # @param data [Core::Ast::DataTable] the data for the table
+        def initialize
+          @rows = []
+        end
+
+        def row(row)
+          @rows << row
+        end
+
+        def eof; end
+      end
+
+      NULL_CONVERSIONS = Hash.new(strict: false, proc: ->(cell_value) { cell_value }).freeze
+
+      # @param data [Core::Test::DataTable] the data for the table
       # @param conversion_procs [Hash] see map_columns!
       # @param header_mappings [Hash] see map_headers!
       # @param header_conversion_proc [Proc] see map_headers!
       def initialize(data, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
-        raise ArgumentError, "data must be a Core::Ast::DataTable" unless data.kind_of? Core::Ast::DataTable
+        raise ArgumentError, 'data must be a Core::Test::DataTable' unless data.is_a? Core::Test::DataTable
         ast_table = data
         # Verify that it's square
         ast_table.transpose
@@ -108,11 +101,17 @@ module Cucumber
         dup
       end
 
+      attr_accessor :file
+
+      def location
+        @ast_table.location
+      end
+
       # Creates a copy of this table, inheriting any column and header mappings
       # registered with #map_column! and #map_headers!.
       #
       def dup
-        self.class.new(Core::Ast::DataTable.new(raw, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Test::DataTable.new(raw, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Returns a new, transposed table. Example:
@@ -127,7 +126,7 @@ module Cucumber
       #   | 4 | 2 |
       #
       def transpose
-        self.class.new(Core::Ast::DataTable.new(raw.transpose, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Test::DataTable.new(raw.transpose, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -148,6 +147,24 @@ module Cucumber
         @hashes ||= build_hashes
       end
 
+      # Converts this table into an Array of Hashes where the keys are symbols.
+      # For example, a Table built from the following plain text:
+      #
+      #   | foo | Bar | Foo Bar |
+      #   | 2   | 3   | 5       |
+      #   | 7   | 9   | 16      |
+      #
+      # Gets converted into the following:
+      #
+      #   [{:foo => '2', :bar => '3', :foo_bar => '5'}, {:foo => '7', :bar => '9', :foo_bar => '16'}]
+      #
+      def symbolic_hashes
+        @symbolic_hashes ||=
+          hashes.map do |string_hash|
+            Hash[string_hash.map { |a, b| [symbolize_key(a), b] }]
+          end
+      end
+
       # Converts this table into a Hash where the first column is
       # used as keys and the second column is used as values
       #
@@ -163,7 +180,7 @@ module Cucumber
       def rows_hash
         return @rows_hash if @rows_hash
         verify_table_width(2)
-        @rows_hash = self.transpose.hashes[0]
+        @rows_hash = transpose.hashes[0]
       end
 
       # Gets the raw data of this table. For example, a Table built from
@@ -178,14 +195,12 @@ module Cucumber
       #
       def raw
         cell_matrix.map do |row|
-          row.map do |cell|
-            cell.value
-          end
+          row.map(&:value)
         end
       end
 
       def column_names #:nodoc:
-        @col_names ||= cell_matrix[0].map { |cell| cell.value }
+        @column_names ||= cell_matrix[0].map(&:value)
       end
 
       def rows
@@ -245,7 +260,7 @@ module Cucumber
       #   table.hashes.keys
       #   # => ['phone number', 'ADDRESS']
       #
-      def map_headers!(mappings={}, &block)
+      def map_headers!(mappings = {}, &block)
         # TODO: Remove this method for 2.0
         clear_cache!
         @header_mappings = mappings
@@ -253,8 +268,8 @@ module Cucumber
       end
 
       # Returns a new Table where the headers are redefined. See #map_headers!
-      def map_headers(mappings={}, &block)
-        self.class.new(Core::Ast::DataTable.new(raw, location), @conversion_procs.dup, mappings, block)
+      def map_headers(mappings = {}, &block)
+        self.class.new(Core::Test::DataTable.new(raw, location), @conversion_procs.dup, mappings, block)
       end
 
       # Change how #hashes converts column values. The +column_name+ argument identifies the column
@@ -269,17 +284,17 @@ module Cucumber
       #     end
       #   end
       #
-      def map_column!(column_name, strict=true, &conversion_proc)
+      def map_column!(column_name, strict = true, &conversion_proc)
         # TODO: Remove this method for 2.0
-        @conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc }
+        @conversion_procs[column_name.to_s] = { strict: strict, proc: conversion_proc }
         self
       end
 
       # Returns a new Table with an additional column mapping. See #map_column!
-      def map_column(column_name, strict=true, &conversion_proc)
+      def map_column(column_name, strict = true, &conversion_proc)
         conversion_procs = @conversion_procs.dup
-        conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc }
-        self.class.new(Core::Ast::DataTable.new(raw, location), conversion_procs, @header_mappings.dup, @header_conversion_proc)
+        conversion_procs[column_name.to_s] = { strict: strict, proc: conversion_proc }
+        self.class.new(Core::Test::DataTable.new(raw, location), conversion_procs, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Compares +other_table+ to self. If +other_table+ contains columns
@@ -318,86 +333,28 @@ module Cucumber
       # 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,
-          :misplaced_col => false
-        }.merge(options)
-
+      def diff!(other_table, options = {})
         other_table = ensure_table(other_table)
         other_table.convert_headers!
         other_table.convert_columns!
-        ensure_green!
 
         convert_headers!
         convert_columns!
 
-        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
-        misplaced_col = cell_matrix[0] != other_table.cell_matrix[0]
-
-        require_diff_lcs
-        cell_matrix.extend(Diff::LCS)
-        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
+        DiffMatrices.new(cell_matrix, other_table.cell_matrix, options).call
+      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
+      class Different < StandardError
+        attr_reader :table
+        def initialize(table)
+          @table = table
+          super("Tables were not identical:\n#{table}")
         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] ||
-          misplaced_col   && options[:misplaced_col]
-        raise Different.new(self) if should_raise
       end
 
       def to_hash(cells) #:nodoc:
-        hash = Hash.new do |hash, key|
-          hash[key.to_s] if key.is_a?(Symbol)
+        hash = Hash.new do |hash_inner, key|
+          hash_inner[key.to_s] if key.is_a?(Symbol)
         end
         column_names.each_with_index do |column_name, column_index|
           hash[column_name] = cells.value(column_index)
@@ -410,19 +367,21 @@ module Cucumber
       end
 
       def verify_column(column_name) #:nodoc:
-        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) #:nodoc:
-        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 has_text?(text) #:nodoc:
-        raw.flatten.compact.detect{|cell_value| cell_value.index(text)}
+      # TODO: remove the below function if it's not actually being used.
+      # Nothing else in this repo calls it.
+      def text?(text) #:nodoc:
+        raw.flatten.compact.detect { |cell_value| cell_value.index(text) }
       end
 
       def cells_rows #:nodoc:
-        @rows ||= cell_matrix.map do |cell_row|
+        @rows ||= cell_matrix.map do |cell_row| # rubocop:disable Naming/MemoizedInstanceVariableName
           Cells.new(self, cell_row)
         end
       end
@@ -435,34 +394,55 @@ module Cucumber
         cells_rows[0][col]
       end
 
-      def cell_matrix #:nodoc:
-        @cell_matrix
-      end
+      attr_reader :cell_matrix
 
       def col_width(col) #:nodoc:
         columns[col].__send__(:width)
       end
 
       def to_s(options = {}) #:nodoc:
-        # TODO: factor out this code so we don't depend on such a big lump of old cruft
-        require 'cucumber/formatter/pretty'
-        require 'cucumber/formatter/legacy_api/adapter'
-        options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
-        io = StringIO.new
-
-        c = Cucumber::Term::ANSIColor.coloring?
-        Cucumber::Term::ANSIColor.coloring = options[:color]
-        formatter = Formatter::Pretty.new(nil, io, options)
-        formatter.instance_variable_set('@indent', options[:indent])
-        Formatter::LegacyApi::Ast::MultilineArg.for(self).accept(Formatter::Fanout.new([formatter]))
-        Cucumber::Term::ANSIColor.coloring = c
-        io.rewind
-        s = "\n" + io.read + (" " * (options[:indent] - 2))
-        s
+        indentation = options.key?(:indent) ? options[:indent] : 2
+        prefixes = options.key?(:prefixes) ? options[:prefixes] : TO_S_PREFIXES
+        DataTablePrinter.new(self, indentation, prefixes).to_s
       end
 
-      def description_for_visitors
-        :legacy_table
+      class DataTablePrinter #:nodoc:
+        include Cucumber::Gherkin::Formatter::Escaping
+        attr_reader :data_table, :indentation, :prefixes
+        private :data_table, :indentation, :prefixes
+
+        def initialize(data_table, indentation, prefixes)
+          @data_table = data_table
+          @indentation = indentation
+          @prefixes = prefixes
+        end
+
+        def to_s
+          leading_row = "\n"
+          end_indentation = indentation - 2
+          trailing_row = "\n" + (' ' * end_indentation)
+          table_rows = data_table.cell_matrix.map { |row| format_row(row) }
+          leading_row + table_rows.join("\n") + trailing_row
+        end
+
+        private
+
+        def format_row(row)
+          row_start = (' ' * indentation) + '| '
+          row_end = '|'
+          cells = row.map.with_index do |cell, i|
+            format_cell(cell, data_table.col_width(i))
+          end
+          row_start + cells.join('| ') + row_end
+        end
+
+        def format_cell(cell, col_width)
+          cell_text = escape_cell(cell.value.to_s)
+          cell_text_width = cell_text.unpack('U*').length
+          padded_text = cell_text + (' ' * (col_width - cell_text_width))
+          prefix = prefixes[cell.status]
+          "#{prefix}#{padded_text} "
+        end
       end
 
       def columns #:nodoc:
@@ -475,35 +455,26 @@ module Cucumber
         raw.to_json(*args)
       end
 
-      private
-
       TO_S_PREFIXES = Hash.new('    ')
       TO_S_PREFIXES[:comment]   = '(+) '
       TO_S_PREFIXES[:undefined] = '(-) '
+      private_constant :TO_S_PREFIXES
 
       protected
 
       def build_hashes
         convert_headers!
         convert_columns!
-        cells_rows[1..-1].map do |row|
-          row.to_hash
-        end
-      end
-
-      def inspect_rows(missing_row, inserted_row) #:nodoc:
-        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
+        cells_rows[1..-1].map(&:to_hash)
       end
 
       def create_cell_matrix(ast_table) #:nodoc:
         ast_table.raw.map do |raw_row|
-          line = raw_row.line rescue -1
+          line = begin
+                   raw_row.line
+                 rescue StandardError
+                   -1
+                 end
           raw_row.map do |raw_cell|
             Cell.new(raw_cell, self, line)
           end
@@ -528,111 +499,42 @@ module Cucumber
         header_cells = cell_matrix[0]
 
         if @header_conversion_proc
-          header_values = header_cells.map { |cell| cell.value } - @header_mappings.keys
+          header_values = header_cells.map(&:value) - @header_mappings.keys
           @header_mappings = @header_mappings.merge(Hash[*header_values.zip(header_values.map(&@header_conversion_proc)).flatten])
         end
 
         @header_mappings.each_pair do |pre, post|
-          mapped_cells = header_cells.select { |cell| pre === cell.value }
+          mapped_cells = header_cells.reject { |cell| cell.value.match(pre).nil? }
           raise "No headers matched #{pre.inspect}" if mapped_cells.empty?
-          raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map { |c| c.value }.inspect}" if mapped_cells.length > 1
+          raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map(&:value).inspect}" if mapped_cells.length > 1
           mapped_cells[0].value = post
-          if @conversion_procs.has_key?(pre)
-            @conversion_procs[post] = @conversion_procs.delete(pre)
-          end
-        end
-      end
-
-      def require_diff_lcs #:nodoc:
-        begin
-          require 'diff/lcs'
-        rescue LoadError => e
-          e.message << "\n Please gem install diff-lcs\n"
-          raise e
+          @conversion_procs[post] = @conversion_procs.delete(pre) if @conversion_procs.key?(pre)
         end
       end
 
       def clear_cache! #:nodoc:
-        @hashes = @rows_hash = @col_names = @rows = @columns = nil
-      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) #:nodoc:
-        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
+        @hashes = @rows_hash = @column_names = @rows = @columns = nil
       end
 
       def ensure_table(table_or_array) #:nodoc:
-        return table_or_array if DataTable === table_or_array
+        return table_or_array if DataTable == table_or_array.class
         DataTable.from(table_or_array)
       end
 
-      def ensure_array_of_array(array)
-        Hash === array[0] ? hashes_to_array(array) : array
-      end
-
-      def hashes_to_array(hashes) #:nodoc:
-        header = hashes[0].keys.sort
-        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
-      end
-
-      def ensure_green! #:nodoc:
-        each_cell{|cell| cell.status = :passed}
-      end
-
-      def each_cell(&proc) #:nodoc:
-        cell_matrix.each{|row| row.each(&proc)}
-      end
-
-      def mark_as_missing(col) #:nodoc:
-        col.each do |cell|
-          cell.status = :undefined
-        end
+      def symbolize_key(key)
+        key.downcase.tr(' ', '_').to_sym
       end
 
       # Represents a row of cells or columns of cells
       class Cells #:nodoc:
         include Enumerable
-        include Gherkin::Formatter::Escaping
+        include Cucumber::Gherkin::Formatter::Escaping
 
         attr_reader :exception
 
         def initialize(table, cells)
-          @table, @cells = table, cells
+          @table = table
+          @cells = cells
         end
 
         def accept(visitor)
@@ -645,7 +547,7 @@ module Cucumber
 
         # For testing only
         def to_sexp #:nodoc:
-          [:row, line, *@cells.map{|cell| cell.to_sexp}]
+          [:row, line, *@cells.map(&:to_sexp)]
         end
 
         def to_hash #:nodoc:
@@ -679,7 +581,7 @@ module Cucumber
         end
 
         def width
-          map{|cell| cell.value ? escape_cell(cell.value.to_s).unpack('U*').length : 0}.max
+          map { |cell| cell.value ? escape_cell(cell.value.to_s).unpack('U*').length : 0 }.max
         end
       end
 
@@ -688,19 +590,21 @@ module Cucumber
         attr_accessor :status, :value
 
         def initialize(value, table, line)
-          @value, @table, @line = value, table, line
+          @value = value
+          @table = table
+          @line = line
         end
 
         def inspect!
           @value = "(i) #{value.inspect}"
         end
 
-        def ==(o)
-          SurplusCell === o || value == o.value
+        def ==(other)
+          SurplusCell == other.class || value == other.value
         end
 
-        def eql?(o)
-          self == o
+        def eql?(other)
+          self == other
         end
 
         def hash
@@ -718,7 +622,7 @@ module Cucumber
           :comment
         end
 
-        def ==(o)
+        def ==(_other)
           true
         end