cucumber 3.1.2 → 7.1.0

data/lib/cucumber/glue/registry_and_more.rb

@@ -4,6 +4,7 @@ require 'cucumber/cucumber_expressions/parameter_type_registry'
 require 'cucumber/cucumber_expressions/cucumber_expression'
 require 'cucumber/cucumber_expressions/regular_expression'
 require 'cucumber/cucumber_expressions/cucumber_expression_generator'
+require 'cucumber/deprecate'
 require 'cucumber/glue/dsl'
 require 'cucumber/glue/snippet'
 require 'cucumber/glue/hook'
@@ -28,7 +29,7 @@ module Cucumber
     # Raised if there are 2 or more World blocks.
     class MultipleWorld < StandardError
       def initialize(first_proc, second_proc)
-        message = String.new
+        message = String.new # rubocop:disable Style/EmptyLiteral
         message << "You can only pass a proc to #World once, but it's happening\n"
         message << "in 2 places:\n\n"
         message << Glue.backtrace_line(first_proc, 'World') << "\n"
@@ -53,7 +54,8 @@ module Cucumber
       end
 
       def initialize(runtime, configuration)
-        @runtime, @configuration = runtime, configuration
+        @runtime = runtime
+        @configuration = configuration
         @step_definitions = []
         Glue::Dsl.rb_language = self
         @world_proc = @world_modules = nil
@@ -63,27 +65,36 @@ module Cucumber
       end
 
       def step_matches(name_to_match)
-        @step_definitions.reduce([]) do |result, step_definition|
+        @step_definitions.each_with_object([]) do |step_definition, result|
           if (arguments = step_definition.arguments_from(name_to_match))
             result << StepMatch.new(step_definition, name_to_match, arguments)
           end
-          result
         end
       end
 
       def register_rb_hook(phase, tag_expressions, proc)
-        add_hook(phase, Hook.new(self, tag_expressions, proc))
+        hook = add_hook(phase, Hook.new(@configuration.id_generator.new_id, self, tag_expressions, proc))
+        @configuration.notify :envelope, hook.to_envelope
+        hook
       end
 
       def define_parameter_type(parameter_type)
+        @configuration.notify :envelope, parameter_type_envelope(parameter_type)
+
         @parameter_type_registry.define_parameter_type(parameter_type)
       end
 
       def register_rb_step_definition(string_or_regexp, proc_or_sym, options)
-        step_definition = StepDefinition.new(self, string_or_regexp, proc_or_sym, options)
+        step_definition = StepDefinition.new(@configuration.id_generator.new_id, self, string_or_regexp, proc_or_sym, options)
         @step_definitions << step_definition
         @configuration.notify :step_definition_registered, step_definition
+        @configuration.notify :envelope, step_definition.to_envelope
         step_definition
+      rescue Cucumber::CucumberExpressions::UndefinedParameterTypeError => e
+        # TODO: add a way to extract the parameter type directly from the error.
+        type_name = e.message.match(/^Undefined parameter type ['|\{](.*)['|\}].?$/)[1]
+
+        @configuration.notify :undefined_parameter_type, type_name, string_or_regexp
       end
 
       def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
@@ -96,15 +107,20 @@ module Cucumber
 
         @namespaced_world_modules ||= Hash.new { |h, k| h[k] = [] }
         namespaced_world_modules.each do |namespace, world_module|
-          unless @namespaced_world_modules[namespace].include?(world_module)
-            @namespaced_world_modules[namespace] << world_module
-          end
+          @namespaced_world_modules[namespace] << world_module unless @namespaced_world_modules[namespace].include?(world_module)
         end
       end
 
       def load_code_file(code_file)
         return unless File.extname(code_file) == '.rb'
-        load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.define_parameter_type to be called from Glue::Dsl
+
+        # This will cause self.add_step_definition, self.add_hook, and self.define_parameter_type to be called from Glue::Dsl
+
+        if Cucumber.use_legacy_autoloader
+          load File.expand_path(code_file)
+        else
+          require File.expand_path(code_file)
+        end
       end
 
       def begin_scenario(test_case)
@@ -120,11 +136,31 @@ module Cucumber
       end
 
       def after_configuration(configuration)
+        deprecate_after_configuration_hook if hooks[:after_configuration].any?
+
         hooks[:after_configuration].each do |hook|
           hook.invoke('AfterConfiguration', configuration)
         end
       end
 
+      def install_plugin(configuration, registry)
+        hooks[:install_plugin].each do |hook|
+          hook.invoke('InstallPlugin', [configuration, registry])
+        end
+      end
+
+      def before_all
+        hooks[:before_all].each do |hook|
+          hook.invoke('BeforeAll', [])
+        end
+      end
+
+      def after_all
+        hooks[:after_all].each do |hook|
+          hook.invoke('AfterAll', [])
+        end
+      end
+
       def add_hook(phase, hook)
         hooks[phase.to_sym] << hook
         hook
@@ -153,7 +189,7 @@ module Cucumber
       def create_expression(string_or_regexp)
         return CucumberExpressions::CucumberExpression.new(string_or_regexp, @parameter_type_registry) if string_or_regexp.is_a?(String)
         return CucumberExpressions::RegularExpression.new(string_or_regexp, @parameter_type_registry) if string_or_regexp.is_a?(Regexp)
-        raise ArgumentError.new('Expression must be a String or Regexp')
+        raise ArgumentError, 'Expression must be a String or Regexp'
       end
 
       def self.cli_snippet_type_options
@@ -166,6 +202,21 @@ module Cucumber
 
       private
 
+      def parameter_type_envelope(parameter_type)
+        # TODO: should me moved to Cucumber::Expression::ParameterType#to_envelope ?
+        # Note: that would mean that cucumber-expression would depend on cucumber-messages
+
+        Cucumber::Messages::Envelope.new(
+          parameter_type: Cucumber::Messages::ParameterType.new(
+            id: @configuration.id_generator.new_id,
+            name: parameter_type.name,
+            regular_expressions: parameter_type.regexps.map(&:to_s),
+            prefer_for_regular_expression_match: parameter_type.prefer_for_regexp_match?,
+            use_for_snippets: parameter_type.use_for_snippets?
+          )
+        )
+      end
+
       def available_step_definition_hash
         @available_step_definition_hash ||= {}
       end
@@ -177,10 +228,18 @@ module Cucumber
       def hooks
         @hooks ||= Hash.new { |h, k| h[k] = [] }
       end
+
+      def deprecate_after_configuration_hook
+        Cucumber.deprecate(
+          'See https://github.com/cucumber/cucumber-ruby/blob/main/UPGRADING.md#upgrading-to-710 for more info',
+          ' AfterConfiguration hook',
+          '8.0.0'
+        )
+      end
     end
 
     def self.backtrace_line(proc, name)
-      location = Cucumber::Core::Ast::Location.from_source_location(*proc.source_location)
+      location = Cucumber::Core::Test::Location.from_source_location(*proc.source_location)
       "#{location}:in `#{name}'"
     end
   end

data/lib/cucumber/glue/registry_wrapper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cucumber
+  module Glue
+    ##
+    # This class wraps some internals methods to expose them to external plugins.
+    class RegistryWrapper
+      def initialize(registry)
+        @registry = registry
+      end
+
+      ##
+      # Creates a new CucumberExpression from the given +string_or_regexp+.
+      #
+      # If +string_or_regexp+ is a string, it will return a new CucumberExpression::CucumberExpression
+      #
+      # If +string_or_regexp+ is a regexp, it will return a new CucumberExpressions::RegularExpression
+      #
+      # An ArgumentError is raised if +string_or_regexp+ is not a string or a regexp
+      def create_expression(string_or_regexp)
+        @registry.create_expression(string_or_regexp)
+      end
+
+      ##
+      # Return the current execution environment - AKA an isntance of World
+      def current_world
+        @registry.current_world
+      end
+    end
+  end
+end

data/lib/cucumber/glue/snippet.rb

@@ -3,7 +3,7 @@
 module Cucumber
   module Glue
     module Snippet
-      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)'].freeze
 
       class Generator
         def self.register_on(configuration)
@@ -42,7 +42,7 @@ module Cucumber
         end
 
         def self.cli_option_string(type, cucumber_expression_generator)
-          format('%-7s: %-28s e.g. %s', type, description, example(cucumber_expression_generator))
+          format('%<type>-7s: %<description>-28s e.g. %<example>s', type: type, description: description, example: example(cucumber_expression_generator))
         end
 
         private
@@ -61,7 +61,7 @@ module Cucumber
         end
 
         def do_block
-          do_block = String.new
+          do_block = String.new # rubocop:disable Style/EmptyLiteral
           do_block << "do#{parameters}\n"
           multiline_argument.append_comment_to(do_block)
           do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
@@ -72,11 +72,15 @@ module Cucumber
         def parameters
           block_args = (0...number_of_arguments).map { |n| "arg#{n + 1}" }
           multiline_argument.append_block_parameter_to(block_args)
-          block_args.empty? ? '' : " |#{block_args.join(", ")}|"
+          block_args.empty? ? '' : " |#{block_args.join(', ')}|"
         end
 
-        def self.example(cucumber_expression_generator)
-          new(cucumber_expression_generator, 'Given', 'I have 2 cukes', MultilineArgument::None.new).step
+        class << self
+          private
+
+          def example(cucumber_expression_generator)
+            new(cucumber_expression_generator, 'Given', 'I have 2 cukes', MultilineArgument::None.new).step
+          end
         end
       end
 
@@ -87,11 +91,11 @@ module Cucumber
 
         def to_s
           header = generated_expressions.each_with_index.map do |expr, i|
-            prefix = i == 0 ? '' : '# '
-            "#{prefix}#{code_keyword}(\"#{expr.source}\") do#{parameters(expr)}"
+            prefix = i.zero? ? '' : '# '
+            "#{prefix}#{code_keyword}('#{expr.source}') do#{parameters(expr)}"
           end.join("\n")
 
-          body = String.new
+          body = String.new # rubocop:disable Style/EmptyLiteral
           multiline_argument.append_comment_to(body)
           body << "  pending # Write code here that turns the phrase above into concrete actions\n"
           body << 'end'
@@ -102,7 +106,7 @@ module Cucumber
         def parameters(expr)
           parameter_names = expr.parameter_names
           multiline_argument.append_block_parameter_to(parameter_names)
-          parameter_names.empty? ? '' : " |#{parameter_names.join(", ")}|"
+          parameter_names.empty? ? '' : " |#{parameter_names.join(', ')}|"
         end
 
         def self.description
@@ -141,11 +145,11 @@ module Cucumber
       end
 
       SNIPPET_TYPES = {
-        :cucumber_expression => CucumberExpression,
-        :regexp => Regexp,
-        :classic => Classic,
-        :percent => Percent
-      }
+        cucumber_expression: CucumberExpression,
+        regexp: Regexp,
+        classic: Classic,
+        percent: Percent
+      }.freeze
 
       module MultilineArgumentSnippet
         def self.new(multiline_argument)
@@ -170,11 +174,10 @@ module Cucumber
 
         class DocString
           def append_block_parameter_to(array)
-            array << 'string'
+            array << 'doc_string'
           end
 
-          def append_comment_to(string)
-          end
+          def append_comment_to(string); end
         end
 
         class DataTable
@@ -192,11 +195,9 @@ module Cucumber
         end
 
         class None
-          def append_block_parameter_to(array)
-          end
+          def append_block_parameter_to(array); end
 
-          def append_comment_to(string)
-          end
+          def append_comment_to(string); end
         end
       end
     end

data/lib/cucumber/glue/step_definition.rb

@@ -1,8 +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'
 
 module Cucumber
@@ -25,9 +23,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 +42,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::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::StepDefinitionPatternType::CUCUMBER_EXPRESSION if expression.is_a?(CucumberExpressions::CucumberExpression)
+        Cucumber::Messages::StepDefinitionPatternType::REGULAR_EXPRESSION
+      end
+
       # @api private
       def to_hash
         type = expression.is_a?(CucumberExpressions::RegularExpression) ? 'regular expression' : 'cucumber expression'
@@ -92,8 +116,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 +130,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 +153,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?