cucumber 3.2.0 → 5.2.0

data/lib/cucumber/glue/step_definition.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'cucumber/step_match'
-require 'cucumber/step_argument'
 require 'cucumber/core_ext/string'
 require 'cucumber/glue/invoke_in_world'
 
@@ -25,9 +24,9 @@ module Cucumber
       end
 
       class << self
-        def new(registry, string_or_regexp, proc_or_sym, options)
+        def new(id, registry, string_or_regexp, proc_or_sym, options)
           raise MissingProc if proc_or_sym.nil?
-          super registry, registry.create_expression(string_or_regexp), create_proc(proc_or_sym, options)
+          super id, registry, registry.create_expression(string_or_regexp), create_proc(proc_or_sym, options)
         end
 
         private
@@ -44,33 +43,59 @@ module Cucumber
         end
 
         def patch_location_onto(block)
-          location = Core::Ast::Location.of_caller(5)
+          location = Core::Test::Location.of_caller(5)
           block.define_singleton_method(:source_location) { [location.file, location.line] }
           block
         end
 
         def parse_target_proc_from(options)
-          return lambda { self } unless options.key?(:on)
+          return -> { self } unless options.key?(:on)
           target = options[:on]
           case target
           when Proc
             target
           when Symbol
-            lambda { self.send(target) }
+            -> { send(target) }
           else
-            lambda { raise ArgumentError, 'Target must be a symbol or a proc' }
+            -> { raise ArgumentError, 'Target must be a symbol or a proc' }
           end
         end
       end
 
-      attr_reader :expression, :registry
+      attr_reader :id, :expression, :registry
 
-      def initialize(registry, expression, proc)
+      def initialize(id, registry, expression, proc)
         raise 'No regexp' if expression.is_a?(Regexp)
-        @registry, @expression, @proc = registry, expression, proc
+        @id = id
+        @registry = registry
+        @expression = expression
+        @proc = proc
         # @registry.available_step_definition(regexp_source, location)
       end
 
+      def to_envelope
+        Cucumber::Messages::Envelope.new(
+          step_definition: Cucumber::Messages::StepDefinition.new(
+            id: id,
+            pattern: Cucumber::Messages::StepDefinition::StepDefinitionPattern.new(
+              source: expression.source.to_s,
+              type: expression_type
+            ),
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: location.file,
+              location: Cucumber::Messages::Location.new(
+                line: location.lines.first
+              )
+            )
+          )
+        )
+      end
+
+      def expression_type
+        return Cucumber::Messages::StepDefinition::StepDefinitionPattern::StepDefinitionPatternType::CUCUMBER_EXPRESSION if expression.is_a?(CucumberExpressions::CucumberExpression)
+        Cucumber::Messages::StepDefinition::StepDefinitionPattern::StepDefinitionPatternType::REGULAR_EXPRESSION
+      end
+
       # @api private
       def to_hash
         type = expression.is_a?(CucumberExpressions::RegularExpression) ? 'regular expression' : 'cucumber expression'
@@ -92,8 +117,8 @@ module Cucumber
       end
 
       # @api private
-      def ==(step_definition)
-        expression.source == step_definition.expression.source
+      def ==(other)
+        expression.source == other.expression.source
       end
 
       # @api private
@@ -106,12 +131,10 @@ module Cucumber
       # @api private
       # TODO: inline this and step definition just be a value object
       def invoke(args)
-        begin
-          InvokeInWorld.cucumber_instance_exec_in(@registry.current_world, true, @expression.to_s, *args, &@proc)
-        rescue ArityMismatchError => e
-          e.backtrace.unshift(self.backtrace_line)
-          raise e
-        end
+        InvokeInWorld.cucumber_instance_exec_in(@registry.current_world, true, @expression.to_s, *args, &@proc)
+      rescue ArityMismatchError => e
+        e.backtrace.unshift(backtrace_line)
+        raise e
       end
 
       # @api private
@@ -131,7 +154,7 @@ module Cucumber
 
       # The source location where the step definition can be found
       def location
-        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
+        @location ||= Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
       end
 
       # @api private

data/lib/cucumber/glue/world_factory.rb

@@ -10,7 +10,7 @@ module Cucumber
       end
 
       def raise_nil_world
-        raise NilWorld.new
+        raise NilWorld
       rescue NilWorld => e
         e.backtrace.clear
         e.backtrace.push(Glue.backtrace_line(@proc, 'World'))

data/lib/cucumber/hooks.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'pathname'
-require 'cucumber/core/ast/location'
+require 'cucumber/core/test/location'
 require 'cucumber/core/test/around_hook'
 
 module Cucumber
@@ -9,29 +9,29 @@ module Cucumber
   # source for test steps
   module Hooks
     class << self
-      def before_hook(source, location, &block)
-        build_hook_step(source, location, block, BeforeHook, Core::Test::UnskippableAction)
+      def before_hook(id, location, &block)
+        build_hook_step(id, location, block, BeforeHook, Core::Test::UnskippableAction)
       end
 
-      def after_hook(source, location, &block)
-        build_hook_step(source, location, block, AfterHook, Core::Test::UnskippableAction)
+      def after_hook(id, location, &block)
+        build_hook_step(id, location, block, AfterHook, Core::Test::UnskippableAction)
       end
 
-      def after_step_hook(source, location, &block)
-        raise ArgumentError unless source.last.is_a?(Core::Ast::Step)
-        build_hook_step(source, location, block, AfterStepHook, Core::Test::Action)
+      def after_step_hook(id, test_step, location, &block)
+        raise ArgumentError if test_step.hook?
+        build_hook_step(id, location, block, AfterStepHook, Core::Test::Action)
       end
 
-      def around_hook(_source, &block)
+      def around_hook(&block)
         Core::Test::AroundHook.new(&block)
       end
 
       private
 
-      def build_hook_step(source, location, block, hook_type, action_type)
+      def build_hook_step(id, location, block, hook_type, action_type)
         action = action_type.new(location, &block)
         hook = hook_type.new(action.location)
-        Core::Test::Step.new(source + [hook], action)
+        Core::Test::HookStep.new(id, hook.text, location, action)
       end
     end
 

data/lib/cucumber/multiline_argument/data_table/diff_matrices.rb

@@ -95,7 +95,7 @@ module Cucumber
         def changes
           require 'diff/lcs'
           diffable_cell_matrix = cell_matrix.dup.extend(::Diff::LCS)
-          diffable_cell_matrix.diff(other_table_cell_matrix).flatten
+          diffable_cell_matrix.diff(other_table_cell_matrix).flatten(1)
         end
 
         def inspect_rows(missing_row, inserted_row)
@@ -135,7 +135,7 @@ module Cucumber
         def raise_error
           table = DataTable.from([[]])
           table.instance_variable_set :@cell_matrix, cell_matrix
-          raise Different.new(table) if should_raise?
+          raise Different, table if should_raise?
         end
 
         def should_raise?

data/lib/cucumber/multiline_argument/data_table.rb

@@ -3,7 +3,6 @@
 require 'forwardable'
 require 'cucumber/gherkin/data_table_parser'
 require 'cucumber/gherkin/formatter/escaping'
-require 'cucumber/core/ast/describes_itself'
 require 'cucumber/multiline_argument/data_table/diff_matrices'
 
 module Cucumber
@@ -28,19 +27,21 @@ module Cucumber
     # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
     #
     class DataTable
-      include Core::Ast::DescribesItself
-
       def self.default_arg_name #:nodoc:
         'table'
       end
 
+      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)
           case data
           when Array
-            from_array(data, location)
+            from_array(data)
           when String
-            parse(data, location)
+            parse(data)
           else
             raise ArgumentError, 'expected data to be a String or an Array.'
           end
@@ -48,15 +49,15 @@ module Cucumber
 
         private
 
-        def parse(text, location = Core::Ast::Location.of_caller)
+        def parse(text)
           builder = Builder.new
           parser = Cucumber::Gherkin::DataTableParser.new(builder)
           parser.parse(text)
-          from_array(builder.rows, location)
+          from_array(builder.rows)
         end
 
-        def from_array(data, location = Core::Ast::Location.of_caller)
-          new Core::Ast::DataTable.new(data, location)
+        def from_array(data)
+          new Core::Test::DataTable.new(data)
         end
       end
 
@@ -71,18 +72,17 @@ module Cucumber
           @rows << row
         end
 
-        def eof
-        end
+        def eof; end
       end
 
-      NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda { |cell_value| cell_value } }).freeze
+      NULL_CONVERSIONS = Hash.new(strict: false, proc: ->(cell_value) { cell_value }).freeze
 
-      # @param data [Core::Ast::DataTable] the data for the table
+      # @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.is_a? 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
@@ -111,7 +111,7 @@ module Cucumber
       # 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), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Returns a new, transposed table. Example:
@@ -126,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), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -160,7 +160,7 @@ module Cucumber
       #
       def symbolic_hashes
         @symbolic_hashes ||=
-          self.hashes.map do |string_hash|
+          hashes.map do |string_hash|
             Hash[string_hash.map { |a, b| [symbolize_key(a), b] }]
           end
       end
@@ -180,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
@@ -200,7 +200,7 @@ module Cucumber
       end
 
       def column_names #:nodoc:
-        @col_names ||= cell_matrix[0].map(&:value)
+        @column_names ||= cell_matrix[0].map(&:value)
       end
 
       def rows
@@ -269,7 +269,7 @@ module Cucumber
 
       # 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)
+        self.class.new(Core::Test::DataTable.new(raw), @conversion_procs.dup, mappings, block)
       end
 
       # Change how #hashes converts column values. The +column_name+ argument identifies the column
@@ -286,15 +286,15 @@ module Cucumber
       #
       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)
         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), conversion_procs, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Compares +other_table+ to self. If +other_table+ contains columns
@@ -352,9 +352,13 @@ module Cucumber
         end
       end
 
-      def to_hash(cells) #:nodoc:
-        hash = Hash.new do |hash, key|
-          hash[key.to_s] if key.is_a?(Symbol)
+      def to_hash
+        cells_rows.map { |cells| cells.map(&:value) }
+      end
+
+      def cells_to_hash(cells) #:nodoc:
+        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)
@@ -367,19 +371,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:
+      # 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
@@ -399,26 +405,48 @@ module Cucumber
       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]
-        runtime = Struct.new(:configuration).new(Configuration.new)
-        formatter = Formatter::Pretty.new(runtime, 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:
@@ -446,7 +474,11 @@ module Cucumber
 
       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
@@ -476,22 +508,20 @@ module Cucumber
         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(&:value).inspect}" if mapped_cells.length > 1
           mapped_cells[0].value = post
-          if @conversion_procs.key?(pre)
-            @conversion_procs[post] = @conversion_procs.delete(pre)
-          end
+          @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
+        @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
 
@@ -507,7 +537,8 @@ module Cucumber
         attr_reader :exception
 
         def initialize(table, cells)
-          @table, @cells = table, cells
+          @table = table
+          @cells = cells
         end
 
         def accept(visitor)
@@ -524,7 +555,7 @@ module Cucumber
         end
 
         def to_hash #:nodoc:
-          @to_hash ||= @table.to_hash(self)
+          @to_hash ||= @table.cells_to_hash(self)
         end
 
         def value(n) #:nodoc:
@@ -563,19 +594,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
@@ -593,7 +626,7 @@ module Cucumber
           :comment
         end
 
-        def ==(_o)
+        def ==(_other)
           true
         end
 

data/lib/cucumber/multiline_argument/doc_string.rb

@@ -4,7 +4,7 @@ module Cucumber
   module MultilineArgument
     class DocString < SimpleDelegator
       def append_to(array)
-        array << self.to_s
+        array << to_s
       end
     end
   end

data/lib/cucumber/multiline_argument.rb

@@ -12,10 +12,10 @@ module Cucumber
       end
 
       def from(argument, location = nil, content_type = nil)
-        location ||= Core::Ast::Location.of_caller
+        location ||= Core::Test::Location.of_caller
         case argument
         when String
-          builder.doc_string(Core::Ast::DocString.new(argument, content_type, location))
+          builder.doc_string(Core::Test::DocString.new(argument, content_type))
         when Array
           location = location.on_line(argument.first.line..argument.last.line)
           builder.data_table(argument.map(&:cells), location)
@@ -52,11 +52,9 @@ module Cucumber
     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

data/lib/cucumber/platform.rb

@@ -7,7 +7,7 @@ require 'cucumber/core/platform'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = File.read(File.expand_path('../version', __FILE__))
+    VERSION       = File.read(File.expand_path('version', __dir__)).strip
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     RAILS         = defined?(Rails)
@@ -18,8 +18,8 @@ module Cucumber
       attr_accessor :use_full_backtrace
 
       # @private
-      def file_mode(m, encoding = 'UTF-8')
-        "#{m}:#{encoding}"
+      def file_mode(mode, encoding = 'UTF-8')
+        "#{mode}:#{encoding}"
       end
     end
     self.use_full_backtrace = false