cucumber 6.0.0 → 8.0.0.rc.1

data/lib/cucumber/multiline_argument/data_table.rb

@@ -27,7 +27,7 @@ module Cucumber
     # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
     #
     class DataTable
-      def self.default_arg_name #:nodoc:
+      def self.default_arg_name # :nodoc:
         'table'
       end
 
@@ -78,11 +78,12 @@ module Cucumber
       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!
+      # @param conversion_procs [Hash] see map_column
+      # @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::Test::DataTable' unless data.is_a? Core::Test::DataTable
+
         ast_table = data
         # Verify that it's square
         ast_table.transpose
@@ -107,13 +108,6 @@ module Cucumber
         @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::Test::DataTable.new(raw), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
-      end
-
       # Returns a new, transposed table. Example:
       #
       #   | a | 7 | 4 |
@@ -141,7 +135,7 @@ module Cucumber
       #
       #   [{'a' => '2', 'b' => '3', 'sum' => '5'}, {'a' => '7', 'b' => '9', 'sum' => '16'}]
       #
-      # Use #map_column! to specify how values in a column are converted.
+      # Use #map_column to specify how values in a column are converted.
       #
       def hashes
         @hashes ||= build_hashes
@@ -161,7 +155,7 @@ module Cucumber
       def symbolic_hashes
         @symbolic_hashes ||=
           hashes.map do |string_hash|
-            Hash[string_hash.map { |a, b| [symbolize_key(a), b] }]
+            string_hash.transform_keys { |a| symbolize_key(a) }
           end
       end
 
@@ -179,6 +173,7 @@ module Cucumber
       #
       def rows_hash
         return @rows_hash if @rows_hash
+
         verify_table_width(2)
         @rows_hash = transpose.hashes[0]
       end
@@ -199,7 +194,7 @@ module Cucumber
         end
       end
 
-      def column_names #:nodoc:
+      def column_names # :nodoc:
         @column_names ||= cell_matrix[0].map(&:value)
       end
 
@@ -209,7 +204,7 @@ module Cucumber
         end
       end
 
-      def each_cells_row(&proc) #:nodoc:
+      def each_cells_row(&proc) # :nodoc:
         cells_rows.each(&proc)
       end
 
@@ -228,7 +223,8 @@ module Cucumber
         pattern.match(header_to_match)
       end
 
-      # Redefines the table headers. This makes it possible to use
+      # Returns a new Table where the headers are redefined.
+      # 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
@@ -244,54 +240,41 @@ module Cucumber
       # A StepDefinition receiving this table can then map the columns
       # with both Regexp and String:
       #
-      #   table.map_headers!(/phone( number)?/i => :phone, 'Address' => :address)
+      #   table.map_headers(/phone( number)?/i => :phone, 'Address' => :address)
       #   table.hashes
       #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
       #
       # You may also pass in a block if you wish to convert all of the headers:
       #
-      #   table.map_headers! { |header| header.downcase }
+      #   table.map_headers { |header| header.downcase }
       #   table.hashes.keys
       #   # => ['phone number', 'address']
       #
       # When a block is passed in along with a hash then the mappings in the hash take precendence:
       #
-      #   table.map_headers!('Address' => 'ADDRESS') { |header| header.downcase }
+      #   table.map_headers('Address' => 'ADDRESS') { |header| header.downcase }
       #   table.hashes.keys
       #   # => ['phone number', 'ADDRESS']
       #
-      def map_headers!(mappings = {}, &block)
-        # TODO: Remove this method for 2.0
-        clear_cache!
-        @header_mappings = mappings
-        @header_conversion_proc = block
-      end
-
-      # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings = {}, &block)
         self.class.new(Core::Test::DataTable.new(raw), @conversion_procs.dup, mappings, block)
       end
 
+      # Returns a new Table with an additional column mapping.
+      #
       # 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. Example:
       #
       #   Given /^an expense report for (.*) with the following posts:$/ do |table|
-      #     posts_table.map_column!('amount') { |a| a.to_i }
+      #     posts_table = posts_table.map_column('amount') { |a| a.to_i }
       #     posts_table.hashes.each do |post|
       #       # post['amount'] is a Fixnum, rather than a String
       #     end
       #   end
       #
-      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 }
-        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::Test::DataTable.new(raw), conversion_procs, @header_mappings.dup, @header_conversion_proc)
@@ -312,8 +295,8 @@ module Cucumber
       # 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.
+      # objects in their cells, you may want to use #map_column before calling
+      # #diff!. You can use #map_column on either of the tables.
       #
       # A Different error is raised if there are missing rows or columns, or
       # surplus rows. An error is <em>not</em> raised for surplus columns. An
@@ -346,6 +329,7 @@ module Cucumber
 
       class Different < StandardError
         attr_reader :table
+
         def initialize(table)
           @table = table
           super("Tables were not identical:\n#{table}")
@@ -356,7 +340,7 @@ module Cucumber
         cells_rows.map { |cells| cells.map(&:value) }
       end
 
-      def cells_to_hash(cells) #:nodoc:
+      def cells_to_hash(cells) # :nodoc:
         hash = Hash.new do |hash_inner, key|
           hash_inner[key.to_s] if key.is_a?(Symbol)
         end
@@ -366,51 +350,51 @@ module Cucumber
         hash
       end
 
-      def index(cells) #:nodoc:
+      def index(cells) # :nodoc:
         cells_rows.index(cells)
       end
 
-      def verify_column(column_name) #:nodoc:
+      def verify_column(column_name) # :nodoc:
         raise %(The column named "#{column_name}" does not exist) unless raw[0].include?(column_name)
       end
 
-      def verify_table_width(width) #:nodoc:
+      def verify_table_width(width) # :nodoc:
         raise %(The table must have exactly #{width} columns) unless raw[0].size == width
       end
 
       # TODO: remove the below function if it's not actually being used.
       # Nothing else in this repo calls it.
-      def text?(text) #:nodoc:
+      def text?(text) # :nodoc:
         raw.flatten.compact.detect { |cell_value| cell_value.index(text) }
       end
 
-      def cells_rows #:nodoc:
+      def cells_rows # :nodoc:
         @rows ||= cell_matrix.map do |cell_row| # rubocop:disable Naming/MemoizedInstanceVariableName
           Cells.new(self, cell_row)
         end
       end
 
-      def headers #:nodoc:
+      def headers # :nodoc:
         raw.first
       end
 
-      def header_cell(col) #:nodoc:
+      def header_cell(col) # :nodoc:
         cells_rows[0][col]
       end
 
       attr_reader :cell_matrix
 
-      def col_width(col) #:nodoc:
+      def col_width(col) # :nodoc:
         columns[col].__send__(:width)
       end
 
-      def to_s(options = {}) #:nodoc:
+      def to_s(options = {}) # :nodoc:
         indentation = options.key?(:indent) ? options[:indent] : 2
         prefixes = options.key?(:prefixes) ? options[:prefixes] : TO_S_PREFIXES
         DataTablePrinter.new(self, indentation, prefixes).to_s
       end
 
-      class DataTablePrinter #:nodoc:
+      class DataTablePrinter # :nodoc:
         include Cucumber::Gherkin::Formatter::Escaping
         attr_reader :data_table, :indentation, :prefixes
         private :data_table, :indentation, :prefixes
@@ -424,7 +408,7 @@ module Cucumber
         def to_s
           leading_row = "\n"
           end_indentation = indentation - 2
-          trailing_row = "\n" + (' ' * end_indentation)
+          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
@@ -432,7 +416,7 @@ module Cucumber
         private
 
         def format_row(row)
-          row_start = (' ' * indentation) + '| '
+          row_start = "#{' ' * indentation}| "
           row_end = '|'
           cells = row.map.with_index do |cell, i|
             format_cell(cell, data_table.col_width(i))
@@ -449,7 +433,7 @@ module Cucumber
         end
       end
 
-      def columns #:nodoc:
+      def columns # :nodoc:
         @columns ||= cell_matrix.transpose.map do |cell_row|
           Cells.new(self, cell_row)
         end
@@ -469,23 +453,23 @@ module Cucumber
       def build_hashes
         convert_headers!
         convert_columns!
-        cells_rows[1..-1].map(&:to_hash)
+        cells_rows[1..].map(&:to_hash)
       end
 
-      def create_cell_matrix(ast_table) #:nodoc:
+      def create_cell_matrix(ast_table) # :nodoc:
         ast_table.raw.map do |raw_row|
           line = begin
-                   raw_row.line
-                 rescue StandardError
-                   -1
-                 end
+            raw_row.line
+          rescue StandardError
+            -1
+          end
           raw_row.map do |raw_cell|
             Cell.new(raw_cell, self, line)
           end
         end
       end
 
-      def convert_columns! #:nodoc:
+      def convert_columns! # :nodoc:
         @conversion_procs.each do |column_name, conversion_proc|
           verify_column(column_name) if conversion_proc[:strict]
         end
@@ -493,13 +477,13 @@ module Cucumber
         cell_matrix.transpose.each do |col|
           column_name = col[0].value
           conversion_proc = @conversion_procs[column_name][:proc]
-          col[1..-1].each do |cell|
+          col[1..].each do |cell|
             cell.value = conversion_proc.call(cell.value)
           end
         end
       end
 
-      def convert_headers! #:nodoc:
+      def convert_headers! # :nodoc:
         header_cells = cell_matrix[0]
 
         if @header_conversion_proc
@@ -508,20 +492,22 @@ module Cucumber
         end
 
         @header_mappings.each_pair do |pre, post|
-          mapped_cells = header_cells.reject { |cell| cell.value.match(pre).nil? }
+          mapped_cells = header_cells.select { |cell| pre.is_a?(Regexp) ? cell.value.match?(pre) : cell.value == pre }
           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
           @conversion_procs[post] = @conversion_procs.delete(pre) if @conversion_procs.key?(pre)
         end
       end
 
-      def clear_cache! #:nodoc:
+      def clear_cache! # :nodoc:
         @hashes = @rows_hash = @column_names = @rows = @columns = nil
       end
 
-      def ensure_table(table_or_array) #:nodoc:
+      def ensure_table(table_or_array) # :nodoc:
         return table_or_array if DataTable == table_or_array.class
+
         DataTable.from(table_or_array)
       end
 
@@ -530,7 +516,7 @@ module Cucumber
       end
 
       # Represents a row of cells or columns of cells
-      class Cells #:nodoc:
+      class Cells # :nodoc:
         include Enumerable
         include Cucumber::Gherkin::Formatter::Escaping
 
@@ -543,6 +529,7 @@ module Cucumber
 
         def accept(visitor)
           return if Cucumber.wants_to_quit
+
           each do |cell|
             visitor.visit_table_cell(cell)
           end
@@ -550,15 +537,15 @@ module Cucumber
         end
 
         # For testing only
-        def to_sexp #:nodoc:
+        def to_sexp # :nodoc:
           [:row, line, *@cells.map(&:to_sexp)]
         end
 
-        def to_hash #:nodoc:
+        def to_hash # :nodoc:
           @to_hash ||= @table.cells_to_hash(self)
         end
 
-        def value(n) #:nodoc:
+        def value(n) # :nodoc:
           self[n].value
         end
 
@@ -589,7 +576,7 @@ module Cucumber
         end
       end
 
-      class Cell #:nodoc:
+      class Cell # :nodoc:
         attr_reader :line, :table
         attr_accessor :status, :value
 
@@ -616,12 +603,12 @@ module Cucumber
         end
 
         # For testing only
-        def to_sexp #:nodoc:
+        def to_sexp # :nodoc:
           [:cell, @value]
         end
       end
 
-      class SurplusCell < Cell #:nodoc:
+      class SurplusCell < Cell # :nodoc:
         def status
           :comment
         end

data/lib/cucumber/platform.rb

@@ -8,8 +8,8 @@ require 'cucumber/core/platform'
 module Cucumber
   unless defined?(Cucumber::VERSION)
     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')
+    BINARY        = File.expand_path("#{File.dirname(__FILE__)}/../../bin/cucumber")
+    LIBDIR        = File.expand_path("#{File.dirname(__FILE__)}/../../lib")
     RAILS         = defined?(Rails)
     RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
     RUBY          = defined? RUBY_VERSION

data/lib/cucumber/rake/task.rb

@@ -30,13 +30,14 @@ module Cucumber
       include Cucumber::Gherkin::Formatter::AnsiEscapes
       include ::Rake::DSL if defined?(::Rake::DSL)
 
-      class InProcessCucumberRunner #:nodoc:
+      class InProcessCucumberRunner # :nodoc:
         include ::Rake::DSL if defined?(::Rake::DSL)
 
         attr_reader :args
 
         def initialize(libs, cucumber_opts, feature_files)
           raise 'libs must be an Array when running in-process' unless Array == libs.class
+
           libs.reverse_each { |lib| $LOAD_PATH.unshift(lib) }
           @args = (
             cucumber_opts +
@@ -51,7 +52,7 @@ module Cucumber
         end
       end
 
-      class ForkedCucumberRunner #:nodoc:
+      class ForkedCucumberRunner # :nodoc:
         include ::Rake::DSL if defined?(::Rake::DSL)
 
         def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files)
@@ -110,7 +111,8 @@ module Cucumber
       # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
       # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
       attr_reader :cucumber_opts
-      def cucumber_opts=(opts) #:nodoc:
+
+      def cucumber_opts=(opts) # :nodoc:
         @cucumber_opts = String == opts.class ? opts.split(' ') : opts
       end
 
@@ -145,24 +147,25 @@ module Cucumber
         define_task
       end
 
-      def define_task #:nodoc:
+      def define_task # :nodoc:
         desc @desc
         task @task_name do
           runner.run
         end
       end
 
-      def runner(_task_args = nil) #:nodoc:
+      def runner(_task_args = nil) # :nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
         return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files) if fork
+
         InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
       end
 
-      def cucumber_opts_with_profile #:nodoc:
+      def cucumber_opts_with_profile # :nodoc:
         Array(cucumber_opts).concat(Array(@profile).flat_map { |p| ['--profile', p] })
       end
 
-      def feature_files #:nodoc:
+      def feature_files # :nodoc:
         make_command_line_safe(FileList[ENV['FEATURE'] || []])
       end
 

data/lib/cucumber/rspec/disable_option_parser.rb

@@ -2,12 +2,12 @@
 
 require 'optparse'
 
-module Spec #:nodoc:
-  module Runner #:nodoc:
+module Spec # :nodoc:
+  module Runner # :nodoc:
     # Neuters RSpec's option parser.
     # (RSpec's option parser tries to parse ARGV, which
     # will fail when running cucumber)
-    class OptionParser < ::OptionParser #:nodoc:
+    class OptionParser < ::OptionParser # :nodoc:
       NEUTERED_RSPEC = Object.new
       def NEUTERED_RSPEC.method_missing(_method, *_args) # rubocop:disable Style/MissingRespondToMissing
         self || super
@@ -15,11 +15,14 @@ module Spec #:nodoc:
 
       def self.method_added(method)
         return if @__neutering_rspec
+
         @__neutering_rspec = true
         define_method(method) do |*_a|
           NEUTERED_RSPEC
         end
         @__neutering_rspec = false
+
+        super
       end
     end
   end

data/lib/cucumber/running_test_case.rb

@@ -33,6 +33,7 @@ module Cucumber
 
       def exception
         return unless @result.failed?
+
         @result.exception
       end
 

data/lib/cucumber/runtime/meta_message_builder.rb

@@ -0,0 +1,106 @@
+require 'cucumber/messages'
+require 'cucumber/ci_environment'
+
+module Cucumber
+  class Runtime
+    # Builder to instanciate a Cucumber::Messages::Meta message filled-in with
+    # the runtime meta-data:
+    # - protocol version: the version of the Cucumber::Messages protocol
+    # - implementation: the name and version of the implementation (e.g. cucumber-ruby 8.0.0)
+    # - runtime: the name and version of the runtime (e.g. ruby 3.0.1)
+    # - os: the name and version of the operating system (e.g. linux 3.13.0-45-generic)
+    # - cpu: the name of the CPU (e.g. x86_64)
+    # - ci: informtion about the CI environment if any, including:
+    #   - name: the name of the CI environment (e.g. Jenkins)
+    #   - url: the URL of the CI environment (e.g. https://ci.example.com)
+    #   - build_number: the build number of the CI environment (e.g. 123)
+    #   - git: the git information of the CI environment if any
+    #     - remote: the remote of the git repository (e.g. git@github.com:cucumber/cucumber-ruby.git)
+    #     - revision: the revision of the git repository (e.g. abcdef)
+    #     - branch: the name of the git branch (e.g. main)
+    #     - tag: the name of the git tag (e.g. v1.0.0)
+    class MetaMessageBuilder
+      class << self
+        # Builds a Cucumber::Messages::Meta filled-in with the runtime meta-data
+        #
+        # @param [env] environment data from which the CI information will be
+        #  retrieved (default ENV). Can be used to mock the environment for
+        #  testing purpose.
+        #
+        # @return [Cucumber::Messages::Meta] the meta message
+        #
+        # @see Cucumber::Runtime::MetaMessageBuilder
+        #
+        # @example
+        # Cucumber::Runtime::MetaMessageBuilder.build_meta_message
+        #
+        def build_meta_message(env = ENV)
+          Cucumber::Messages::Meta.new(
+            protocol_version: protocol_version,
+            implementation: implementation,
+            runtime: runtime,
+            os: os,
+            cpu: cpu,
+            ci: ci(env)
+          )
+        end
+
+        private
+
+        def protocol_version
+          Cucumber::Messages::VERSION
+        end
+
+        def implementation
+          Cucumber::Messages::Product.new(
+            name: 'cucumber-ruby',
+            version: Cucumber::VERSION
+          )
+        end
+
+        def runtime
+          Cucumber::Messages::Product.new(
+            name: RUBY_ENGINE,
+            version: RUBY_VERSION
+          )
+        end
+
+        def os
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_os'],
+            version: Sys::Uname.uname.version
+          )
+        end
+
+        def cpu
+          Cucumber::Messages::Product.new(
+            name: RbConfig::CONFIG['target_cpu']
+          )
+        end
+
+        def ci(env)
+          ci_data = Cucumber::CiEnvironment.detect_ci_environment(env)
+          return nil unless ci_data
+
+          Cucumber::Messages::Ci.new(
+            name: ci_data[:name],
+            url: ci_data[:url],
+            build_number: ci_data[:buildNumber],
+            git: git_info(ci_data)
+          )
+        end
+
+        def git_info(ci_data)
+          return nil unless ci_data[:git]
+
+          Cucumber::Messages::Git.new(
+            remote: ci_data[:git][:remote],
+            revision: ci_data[:git][:revision],
+            branch: ci_data[:git][:branch],
+            tag: ci_data[:git][:tag]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -72,6 +72,7 @@ module Cucumber
       def invoke_dynamic_step(step_name, multiline_argument, _location = nil)
         matches = step_matches(step_name)
         raise UndefinedDynamicStep, step_name if matches.empty?
+
         matches.first.invoke(multiline_argument)
       end
 
@@ -109,6 +110,7 @@ module Cucumber
 
       def apply_before_hooks(test_case)
         return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:before, scenario)
         BeforeHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)
@@ -116,6 +118,7 @@ module Cucumber
 
       def apply_after_hooks(test_case)
         return test_case if test_case.test_steps.empty?
+
         scenario = RunningTestCase.new(test_case)
         hooks = registry.hooks_for(:after, scenario)
         AfterHooks.new(@configuration.id_generator, hooks, scenario, @configuration.event_bus).apply_to(test_case)

data/lib/cucumber/runtime/user_interface.rb

@@ -21,8 +21,8 @@ module Cucumber
       # that makes a sound before invoking #ask.
       #
       def ask(question, timeout_seconds)
-        STDOUT.puts(question)
-        STDOUT.flush
+        $stdout.puts(question)
+        $stdout.flush
         puts(question)
 
         answer = if Cucumber::JRUBY
@@ -32,6 +32,7 @@ module Cucumber
                  end
 
         raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+
         puts(answer)
         answer
       end
@@ -48,7 +49,7 @@ module Cucumber
 
       def mri_gets(timeout_seconds)
         Timeout.timeout(timeout_seconds) do
-          STDIN.gets
+          $stdin.gets
         end
       rescue Timeout::Error
         nil
@@ -57,7 +58,7 @@ module Cucumber
       def jruby_gets(timeout_seconds)
         answer = nil
         t = java.lang.Thread.new do
-          answer = STDIN.gets
+          answer = $stdin.gets
         end
         t.start
         t.join(timeout_seconds * 1000)