cucumber 4.1.0 → 9.2.0

data/lib/cucumber/formatter/usage.rb

@@ -2,10 +2,12 @@
 
 require 'cucumber/formatter/progress'
 require 'cucumber/step_definition_light'
+require 'cucumber/formatter/console'
 
 module Cucumber
   module Formatter
     class Usage < Progress
+      include Console
       class StepDefKey < StepDefinitionLight
         attr_accessor :mean_duration, :status
       end
@@ -76,7 +78,7 @@ module Cucumber
           if @stepdef_to_match[stepdef_key].any?
             print_steps(stepdef_key)
           else
-            @io.puts('  ' + format_string('NOT MATCHED BY ANY STEPS', :failed))
+            @io.puts("  #{format_string('NOT MATCHED BY ANY STEPS', :failed)}")
           end
         end
         @io.puts
@@ -84,11 +86,11 @@ module Cucumber
       end
 
       def print_step_definition(stepdef_key)
-        @io.print format_string(format('%<duration>.7f', duration: stepdef_key.mean_duration), :skipped) + ' ' unless config.dry_run?
+        @io.print "#{format_string(format('%<duration>.7f', duration: stepdef_key.mean_duration), :skipped)} " unless config.dry_run?
         @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
         if config.source?
-          indent = max_length - stepdef_key.regexp_source.unpack('U*').length
-          line_comment = "   # #{stepdef_key.location}".indent(indent)
+          indent_amount = max_length - stepdef_key.regexp_source.unpack('U*').length
+          line_comment = indent("   # #{stepdef_key.location}", indent_amount)
           @io.print(format_string(line_comment, :comment))
         end
         @io.puts
@@ -97,11 +99,11 @@ module Cucumber
       def print_steps(stepdef_key)
         @stepdef_to_match[stepdef_key].each do |step|
           @io.print '  '
-          @io.print format_string(format('%<duration>.7f', duration: step[:duration]), :skipped) + ' ' unless config.dry_run?
+          @io.print "#{format_string(format('%<duration>.7f', duration: step[:duration]), :skipped)} " unless config.dry_run?
           @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
           if config.source?
-            indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
-            line_comment = " # #{step[:location]}".indent(indent)
+            indent_amount = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
+            line_comment = indent(" # #{step[:location]}", indent_amount)
             @io.print(format_string(line_comment, :comment))
           end
           @io.puts

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -15,10 +15,11 @@ module Cucumber
         messages = ::Gherkin.from_source('dummy', feature_header + text, gherkin_options)
 
         messages.each do |message|
-          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+          gherkin_document = message.gherkin_document.to_h unless message.gherkin_document.nil?
         end
 
         return if gherkin_document.nil?
+
         gherkin_document[:feature][:children][0][:scenario][:steps][0][:data_table][:rows].each do |row|
           @builder.row(row[:cells].map { |cell| cell[:value] })
         end

data/lib/cucumber/gherkin/formatter/ansi_escapes.rb

@@ -5,8 +5,7 @@ module Cucumber
     module Formatter
       # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
       # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
-      # tweak the familiar POSIX command <tt>ls</tt> with
-      # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
+      # tweak the familiar POSIX command <tt>ls</tt> with $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
       #
       # The colours that you can change are:
       #
@@ -41,40 +40,39 @@ module Cucumber
       # Although not listed, you can also use <tt>grey</tt>
       module AnsiEscapes
         COLORS = {
-          'black'   => "\e[30m",
-          'red'     => "\e[31m",
-          'green'   => "\e[32m",
-          'yellow'  => "\e[33m",
-          'blue'    => "\e[34m",
+          'black' => "\e[30m",
+          'red' => "\e[31m",
+          'green' => "\e[32m",
+          'yellow' => "\e[33m",
+          'blue' => "\e[34m",
           'magenta' => "\e[35m",
-          'cyan'    => "\e[36m",
-          'white'   => "\e[37m",
-          'grey'    => "\e[90m",
-          'bold'    => "\e[1m"
+          'cyan' => "\e[36m",
+          'white' => "\e[37m",
+          'grey' => "\e[90m",
+          'bold' => "\e[1m"
         }.freeze
 
         ALIASES = Hash.new do |h, k|
-          h[Regexp.last_match(1)] + ',bold' if k.to_s =~ /(.*)_arg/
+          "#{h[Regexp.last_match(1)]},bold" if k.to_s =~ /(.*)_arg/
         end.merge(
           'undefined' => 'yellow',
-          'pending'   => 'yellow',
+          'pending' => 'yellow',
           'executing' => 'grey',
-          'failed'    => 'red',
-          'passed'    => 'green',
-          'outline'   => 'cyan',
-          'skipped'   => 'cyan',
-          'comments'  => 'grey',
-          'tag'       => 'cyan'
+          'failed' => 'red',
+          'passed' => 'green',
+          'outline' => 'cyan',
+          'skipped' => 'cyan',
+          'comments' => 'grey',
+          'tag' => 'cyan'
         )
 
-        if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
-          ENV['GHERKIN_COLORS'].split(':').each do |pair|
-            a = pair.split('=')
-            ALIASES[a[0]] = a[1]
-          end
+        # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV.fetch('GHERKIN_COLORS', '').split(':').each do |pair|
+          rule, colour = pair.split('=')
+          ALIASES[colour] = rule
         end
 
-        ALIASES.keys.each do |key|
+        ALIASES.each_key do |key|
           define_method(key) do
             ALIASES[key].split(',').map { |color| COLORS[color] }.join('')
           end
@@ -88,8 +86,8 @@ module Cucumber
           "\e[0m"
         end
 
-        def up(n)
-          "\e[#{n}A"
+        def up(amount)
+          "\e[#{amount}A"
         end
       end
     end

data/lib/cucumber/gherkin/steps_parser.rb

@@ -17,7 +17,7 @@ module Cucumber
         messages = ::Gherkin.from_source('dummy', feature_header(dialect) + text, gherkin_options)
 
         messages.each do |message|
-          gherkin_document = message.gherkin_document.to_hash unless message.gherkin_document.nil?
+          gherkin_document = message.gherkin_document.to_h unless message.gherkin_document.nil?
         end
 
         @builder.steps(gherkin_document[:feature][:children][0][:scenario][:steps])

data/lib/cucumber/glue/dsl.rb

@@ -19,8 +19,8 @@ module Cucumber
           @rb_language.build_rb_world_factory(world_modules, namespaced_world_modules, proc)
         end
 
-        def register_rb_hook(phase, tag_names, proc)
-          @rb_language.register_rb_hook(phase, tag_names, proc)
+        def register_rb_hook(phase, tag_names, proc, name: nil)
+          @rb_language.register_rb_hook(phase, tag_names, proc, name: name)
         end
 
         def define_parameter_type(parameter_type)
@@ -62,14 +62,14 @@ module Cucumber
 
       # Registers a proc that will run before each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def Before(*tag_expressions, &proc)
-        Dsl.register_rb_hook('before', tag_expressions, proc)
+      def Before(*tag_expressions, name: nil, &proc)
+        Dsl.register_rb_hook('before', tag_expressions, proc, name: name)
       end
 
       # Registers a proc that will run after each Scenario. You can register as many
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def After(*tag_expressions, &proc)
-        Dsl.register_rb_hook('after', tag_expressions, proc)
+      def After(*tag_expressions, name: nil, &proc)
+        Dsl.register_rb_hook('after', tag_expressions, proc, name: name)
       end
 
       # Registers a proc that will be wrapped around each scenario. The proc
@@ -77,14 +77,14 @@ module Cucumber
       # argument (but passed as a regular argument, since blocks cannot accept
       # blocks in 1.8), on which it should call the .call method. You can register
       # as many  as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def Around(*tag_expressions, &proc)
-        Dsl.register_rb_hook('around', tag_expressions, proc)
+      def Around(*tag_expressions, name: nil, &proc)
+        Dsl.register_rb_hook('around', tag_expressions, proc, name: name)
       end
 
       # Registers a proc that will run after each Step. You can register as
       # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def AfterStep(*tag_expressions, &proc)
-        Dsl.register_rb_hook('after_step', tag_expressions, proc)
+      def AfterStep(*tag_expressions, name: nil, &proc)
+        Dsl.register_rb_hook('after_step', tag_expressions, proc, name: name)
       end
 
       def ParameterType(options)
@@ -107,10 +107,21 @@ module Cucumber
         value.nil? ? default : value
       end
 
-      # Registers a proc that will run after Cucumber is configured. You can register as
-      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
-      def AfterConfiguration(&proc)
-        Dsl.register_rb_hook('after_configuration', [], proc)
+      # Registers a proc that will run after Cucumber is configured in order to install an external plugin.
+      def InstallPlugin(name: nil, &proc)
+        Dsl.register_rb_hook('install_plugin', [], proc, name: name)
+      end
+
+      # Registers a proc that will run before the execution of the scenarios.
+      # Use it for your final set-ups
+      def BeforeAll(name: nil, &proc)
+        Dsl.register_rb_hook('before_all', [], proc, name: name)
+      end
+
+      # Registers a proc that will run after the execution of the scenarios.
+      # Use it for your final clean-ups
+      def AfterAll(name: nil, &proc)
+        Dsl.register_rb_hook('after_all', [], proc, name: name)
       end
 
       # Registers a new Ruby StepDefinition. This method is aliased
@@ -136,5 +147,8 @@ module Cucumber
   end
 end
 
-# TODO: can we avoid adding methods to the global namespace (Kernel)
-extend(Cucumber::Glue::Dsl) # rubocop:disable Style/MixinUsage
+# rubocop:disable Style/MixinUsage
+# This "should" always be present, because it allows users to write `Before` and `After`
+# See. https://github.com/cucumber/cucumber-ruby/pull/1566#discussion_r683235396
+extend(Cucumber::Glue::Dsl)
+# rubocop:enable Style/MixinUsage

data/lib/cucumber/glue/hook.rb

@@ -6,11 +6,12 @@ module Cucumber
   module Glue
     # TODO: Kill pointless wrapper for Before, After and AfterStep hooks with fire
     class Hook
-      attr_reader :id, :tag_expressions, :location
+      attr_reader :id, :tag_expressions, :location, :name
 
-      def initialize(id, registry, tag_expressions, proc)
+      def initialize(id, registry, tag_expressions, proc, name: nil)
         @id = id
         @registry = registry
+        @name = name
         @tag_expressions = sanitize_tag_expressions(tag_expressions)
         @proc = proc
         @location = Cucumber::Core::Test::Location.from_source_location(*@proc.source_location)
@@ -32,7 +33,8 @@ module Cucumber
         Cucumber::Messages::Envelope.new(
           hook: Cucumber::Messages::Hook.new(
             id: id,
-            tag_expression: tag_expressions.join(' '),
+            name: name,
+            tag_expression: tag_expressions.empty? ? nil : tag_expressions.join(' '),
             source_reference: Cucumber::Messages::SourceReference.new(
               uri: location.file,
               location: Cucumber::Messages::Location.new(
@@ -58,6 +60,7 @@ module Cucumber
           end
 
           next unless tag_expression.include?(',')
+
           warn("Found tagged hook with '#{tag_expression}'." \
             "'@tag1,@tag2' is no longer supported, use '@tag or @tag2' instead.")
         end

data/lib/cucumber/glue/invoke_in_world.rb

@@ -12,6 +12,7 @@ module Cucumber
 
         instance_exec_pos = backtrace.index(instance_exec_invocation_line)
         return unless instance_exec_pos
+
         replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
         backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
 
@@ -27,7 +28,7 @@ module Cucumber
           if check_arity && !cucumber_compatible_arity?(args, block)
             world.instance_exec do
               ari = block.arity
-              ari = ari < 0 ? (ari.abs - 1).to_s + '+' : ari
+              ari = ari.negative? ? "#{ari.abs - 1}+" : ari
               s1 = ari == 1 ? '' : 's'
               s2 = args.length == 1 ? '' : 's'
               raise ArityMismatchError, "Your block takes #{ari} argument#{s1}, but the Regexp matched #{args.length} argument#{s2}."
@@ -40,15 +41,14 @@ module Cucumber
 
       def self.cucumber_compatible_arity?(args, block)
         return true if block.arity == args.length
-        if block.arity < 0
-          return true if args.length >= (block.arity.abs - 1)
-        end
+        return true if block.arity.negative? && args.length >= (block.arity.abs - 1)
+
         false
       end
 
       def self.cucumber_run_with_backtrace_filtering(pseudo_method)
         yield
-      rescue Exception => e # rubocop:disable Lint/RescueException
+      rescue Exception => e
         instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
         replace_instance_exec_invocation_line!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
         raise e

data/lib/cucumber/glue/proto_world.rb

@@ -3,10 +3,11 @@
 require 'cucumber/gherkin/formatter/ansi_escapes'
 require 'cucumber/core/test/data_table'
 require 'cucumber/deprecate'
+require 'mini_mime'
 
 module Cucumber
   module Glue
-    # Defines the basic API methods availlable in all Cucumber step definitions.
+    # Defines the basic API methods available in all Cucumber step definitions.
     #
     # You can, and probably should, extend this API with your own methods that
     # make sense in your domain. For more on that, see {Cucumber::Glue::Dsl#World}
@@ -25,7 +26,7 @@ module Cucumber
       # @example Passing a multiline string
       #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
       # @param [String] name The name of the step
-      # @param [String,Cucumber::Test::DocString,Cucumber::Ast::Table] multiline_argument
+      # @param [String, Cucumber::Test::DocString, Cucumber::Ast::Table] raw_multiline_arg
       def step(name, raw_multiline_arg = nil)
         super
       end
@@ -72,46 +73,31 @@ module Cucumber
         MultilineArgument::DataTable.from(text_or_table)
       end
 
-      # Print a message to the output.
-      #
-      # @note Cucumber might surprise you with the behaviour of this method. Instead
-      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
-      #   the message until the current step has finished, and then display it.
-      #
-      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
-      def puts(*messages)
-        Cucumber.deprecate(
-          'Messages emitted with "puts" will no longer be caught by Cucumber ' \
-          'and sent to the formatter. If you want message to be in the formatted output, ' \
-          "please use log(message) instead.\n" \
-          'If you simply want it in the console, '\
-          'keep using "puts" (or Kernel.puts to avoid this message)',
-          'puts(message)',
-          '5.0.0'
-        )
-        messages.each { |message| log(message.to_s) }
-      end
-
       # Pause the tests and ask the operator for input
       def ask(question, timeout_seconds = 60)
         super
       end
 
-      # Embed an image in the output
-      def embed(file, mime_type, _label = 'Screenshot')
-        Cucumber.deprecate(
-          'Please use attach(file, media_type) instead',
-          'embed(file, mime_type, label)',
-          '5.0.0'
-        )
-        attach(file, mime_type)
-      end
-
       def log(*messages)
         messages.each { |message| attach(message.to_s.dup, 'text/x.cucumber.log+plain') }
       end
 
-      def attach(file, media_type)
+      # Attach a file to the output
+      # @param file [string|io] the file to attach.
+      #   It can be a string containing the file content itself, the file path, or an IO ready to be read.
+      # @param media_type [string] the media type.
+      #   If file is a valid path, media_type can be omitted, it will then be inferred from the file name.
+      # @param filename [string] the name of the file you wish to specify.
+      #   This is only needed in situations where you want to rename a PDF download e.t.c. - In most situations
+      #   you should not need to pass a filename
+      def attach(file, media_type = nil, filename = nil)
+        return super unless File.file?(file)
+
+        content = File.read(file, mode: 'rb')
+        media_type = MiniMime.lookup_by_filename(file)&.content_type if media_type.nil?
+
+        super(content, media_type.to_s, filename)
+      rescue StandardError
         super
       end
 
@@ -119,12 +105,9 @@ module Cucumber
       def pending(message = 'TODO')
         raise Pending, message unless block_given?
 
-        begin
-          yield
-        rescue Exception # rubocop:disable Lint/RescueException
-          raise Pending, message
-        end
-        raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
+        yield
+      rescue Exception
+        raise Pending, message
       end
 
       # Skips this step and the remaining steps in the scenario
@@ -142,9 +125,9 @@ module Cucumber
         inspect
       end
 
-      # Dynamially generate the API module, closuring the dependencies
-      def self.for(runtime, language) # rubocop:disable Metrics/MethodLength
-        Module.new do # rubocop:disable Metrics/BlockLength
+      # Dynamically generate the API module, closuring the dependencies
+      def self.for(runtime, language)
+        Module.new do
           def self.extended(object)
             # wrap the dynamically generated module so that we can document the methods
             # for yardoc, which doesn't like define_method.
@@ -154,8 +137,8 @@ module Cucumber
           # TODO: pass these in when building the module, instead of mutating them later
           # Extend the World with user-defined modules
           def add_modules!(world_modules, namespaced_world_modules)
-            add_world_modules!(world_modules)
-            add_namespaced_modules!(namespaced_world_modules)
+            add_world_modules!(world_modules) if world_modules.any?
+            add_namespaced_modules!(namespaced_world_modules) if namespaced_world_modules.any?
           end
 
           define_method(:step) do |name, raw_multiline_arg = nil|
@@ -172,8 +155,8 @@ module Cucumber
             runtime.ask(question, timeout_seconds)
           end
 
-          define_method(:attach) do |file, media_type|
-            runtime.attach(file, media_type)
+          define_method(:attach) do |file, media_type, filename|
+            runtime.attach(file, media_type, filename)
           end
 
           # Prints the list of modules that are included in the World
@@ -188,27 +171,24 @@ module Cucumber
 
           private
 
-          # @private
           def add_world_modules!(modules)
             modules.each do |world_module|
               extend(world_module)
             end
           end
 
-          # @private
           def add_namespaced_modules!(modules)
             @__namespaced_modules = modules
             modules.each do |namespace, world_modules|
               world_modules.each do |world_module|
                 variable_name = "@__#{namespace}_world"
+                inner_world = instance_variable_get(variable_name) || Object.new
+
+                instance_variable_set(
+                  variable_name,
+                  inner_world.extend(world_module)
+                )
 
-                inner_world = if self.class.respond_to?(namespace)
-                                instance_variable_get(variable_name)
-                              else
-                                Object.new
-                              end
-                instance_variable_set(variable_name,
-                                      inner_world.extend(world_module))
                 self.class.send(:define_method, namespace) do
                   instance_variable_get(variable_name)
                 end
@@ -216,14 +196,14 @@ module Cucumber
             end
           end
 
-          # @private
           def stringify_namespaced_modules
+            return '' if @__namespaced_modules.nil?
+
             @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
           end
         end
       end
 
-      # @private
       AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
     end
   end

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,8 @@ module Cucumber
     # Raised if there are 2 or more World blocks.
     class MultipleWorld < StandardError
       def initialize(first_proc, second_proc)
-        message = String.new # rubocop:disable Style/EmptyLiteral
+        # TODO: [LH] - Just use a heredoc here to fix this up
+        message = String.new
         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"
@@ -71,8 +73,8 @@ module Cucumber
         end
       end
 
-      def register_rb_hook(phase, tag_expressions, proc)
-        hook = add_hook(phase, Hook.new(@configuration.id_generator.new_id, self, tag_expressions, proc))
+      def register_rb_hook(phase, tag_expressions, proc, name: nil)
+        hook = add_hook(phase, Hook.new(@configuration.id_generator.new_id, self, tag_expressions, proc, name: name))
         @configuration.notify :envelope, hook.to_envelope
         hook
       end
@@ -91,7 +93,7 @@ module Cucumber
         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]
+        type_name = e.message.match(/^Undefined parameter type ['|{](.*)['|}].?$/)[1]
 
         @configuration.notify :undefined_parameter_type, type_name, string_or_regexp
       end
@@ -99,6 +101,7 @@ module Cucumber
       def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
         if proc
           raise MultipleWorld.new(@world_proc, proc) if @world_proc
+
           @world_proc = proc
         end
         @world_modules ||= []
@@ -134,9 +137,21 @@ module Cucumber
         @current_world = nil
       end
 
-      def after_configuration(configuration)
-        hooks[:after_configuration].each do |hook|
-          hook.invoke('AfterConfiguration', configuration)
+      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
 
@@ -149,7 +164,7 @@ module Cucumber
         @hooks = nil
       end
 
-      def hooks_for(phase, scenario) #:nodoc:
+      def hooks_for(phase, scenario) # :nodoc:
         hooks[phase.to_sym].select { |hook| scenario.accept_hook?(hook) }
       end
 
@@ -168,6 +183,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, 'Expression must be a String or Regexp'
       end
 
@@ -182,16 +198,19 @@ module Cucumber
       private
 
       def parameter_type_envelope(parameter_type)
-        # TODO: should me moved to Cucumber::Expression::ParameterType#to_envelope ?
+        # TODO: should this be 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?
+            prefer_for_regular_expression_match: parameter_type.prefer_for_regexp_match,
+            use_for_snippets: parameter_type.use_for_snippets,
+            source_reference: Cucumber::Messages::SourceReference.new(
+              uri: parameter_type.transformer.source_location[0],
+              location: Cucumber::Messages::Location.new(line: parameter_type.transformer.source_location[1])
+            )
           )
         )
       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

@@ -61,7 +61,8 @@ module Cucumber
         end
 
         def do_block
-          do_block = String.new # rubocop:disable Style/EmptyLiteral
+          # TODO: [LH] - Just use a heredoc here to fix this up
+          do_block = String.new
           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"
@@ -95,7 +96,8 @@ module Cucumber
             "#{prefix}#{code_keyword}('#{expr.source}') do#{parameters(expr)}"
           end.join("\n")
 
-          body = String.new # rubocop:disable Style/EmptyLiteral
+          # TODO: [LH] - Just use a heredoc here to fix this up
+          body = String.new
           multiline_argument.append_comment_to(body)
           body << "  pending # Write code here that turns the phrase above into concrete actions\n"
           body << 'end'