cucumber 3.2.0 → 4.1.0

data/lib/cucumber/cli/options.rb

@@ -10,25 +10,23 @@ module Cucumber
   module Cli
     class Options
       INDENT = ' ' * 53
-      # rubocop:disable Layout/MultilineOperationIndentation
       BUILTIN_FORMATS = {
-        'html'        => ['Cucumber::Formatter::Html',        'Generates a nice looking HTML report.'],
         'pretty'      => ['Cucumber::Formatter::Pretty',      'Prints the feature as is - in colours.'],
         'progress'    => ['Cucumber::Formatter::Progress',    'Prints one character per scenario.'],
         'rerun'       => ['Cucumber::Formatter::Rerun',       'Prints failing files with line numbers.'],
-        'usage'       => ['Cucumber::Formatter::Usage',       "Prints where step definitions are used.\n" +
-                                                              "#{INDENT}The slowest step definitions (with duration) are\n" +
-                                                              "#{INDENT}listed first. If --dry-run is used the duration\n" +
-                                                              "#{INDENT}is not shown, and step definitions are sorted by\n" +
+        'usage'       => ['Cucumber::Formatter::Usage',       "Prints where step definitions are used.\n" \
+                                                              "#{INDENT}The slowest step definitions (with duration) are\n" \
+                                                              "#{INDENT}listed first. If --dry-run is used the duration\n" \
+                                                              "#{INDENT}is not shown, and step definitions are sorted by\n" \
                                                               "#{INDENT}filename instead."],
-        'stepdefs'    => ['Cucumber::Formatter::Stepdefs',    "Prints All step definitions with their locations. Same as\n" +
+        'stepdefs'    => ['Cucumber::Formatter::Stepdefs',    "Prints All step definitions with their locations. Same as\n" \
                                                               "#{INDENT}the usage formatter, except that steps are not printed."],
         'junit'       => ['Cucumber::Formatter::Junit',       'Generates a report similar to Ant+JUnit.'],
-        'json'        => ['Cucumber::Formatter::Json',        'Prints the feature as JSON'],
-        'json_pretty' => ['Cucumber::Formatter::JsonPretty',  'Prints the feature as prettified JSON'],
+        'json'        => ['Cucumber::Formatter::Json',        '[DEPRECATED] Prints the feature as JSON'],
+        'message'     => ['Cucumber::Formatter::Message',     'Outputs protobuf messages'],
+        'html'        => ['Cucumber::Formatter::HTML',        'Outputs HTML report'],
         'summary'     => ['Cucumber::Formatter::Summary',     'Summary output of feature and scenarios']
-      }
-      # rubocop:enable Layout/MultilineOperationIndentation
+      }.freeze
       max = BUILTIN_FORMATS.keys.map(&:length).max
       FORMAT_HELP_MSG = [
         'Use --format rerun --out rerun.txt to write out failing',
@@ -41,24 +39,24 @@ module Cucumber
         'foo/bar_zap.rb. You can place the file with this relative',
         'path underneath your features/support directory or anywhere',
         "on Ruby's LOAD_PATH, for example in a Ruby gem."
-      ]
+      ].freeze
 
       FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
         "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
       end) + FORMAT_HELP_MSG
-      PROFILE_SHORT_FLAG = '-p'
-      NO_PROFILE_SHORT_FLAG = '-P'
-      PROFILE_LONG_FLAG = '--profile'
-      NO_PROFILE_LONG_FLAG = '--no-profile'
-      FAIL_FAST_FLAG = '--fail-fast'
-      RETRY_FLAG = '--retry'
+      PROFILE_SHORT_FLAG = '-p'.freeze
+      NO_PROFILE_SHORT_FLAG = '-P'.freeze
+      PROFILE_LONG_FLAG = '--profile'.freeze
+      NO_PROFILE_LONG_FLAG = '--no-profile'.freeze
+      FAIL_FAST_FLAG = '--fail-fast'.freeze
+      RETRY_FLAG = '--retry'.freeze
       OPTIONS_WITH_ARGS = [
         '-r', '--require', '--i18n-keywords', '-f', '--format', '-o',
         '--out', '-t', '--tags', '-n', '--name', '-e', '--exclude',
         PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG, RETRY_FLAG, '-l',
         '--lines', '--port', '-I', '--snippet-type'
-      ]
-      ORDER_TYPES = %w{defined random}
+      ].freeze
+      ORDER_TYPES = %w[defined random].freeze
       TAG_LIMIT_MATCHER = /(?<tag_name>\@\w+):(?<limit>\d+)/x
 
       def self.parse(args, out_stream, error_stream, options = {})
@@ -87,19 +85,17 @@ module Cucumber
         @options[key] = value
       end
 
-      def parse!(args) # rubocop:disable Metrics/AbcSize
+      def parse!(args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         @args = args
         @expanded_args = @args.dup
 
         @args.extend(::OptionParser::Arguable)
 
-        @args.options do |opts|
+        @args.options do |opts| # rubocop:disable Metrics/BlockLength
           opts.banner = banner
           opts.on('-r LIBRARY|DIR', '--require LIBRARY|DIR', *require_files_msg) { |lib| require_files(lib) }
 
-          if Cucumber::JRUBY
-            opts.on('-j DIR', '--jars DIR', 'Load all the jars under DIR') { |jars| load_jars(jars) }
-          end
+          opts.on('-j DIR', '--jars DIR', 'Load all the jars under DIR') { |jars| load_jars(jars) } if Cucumber::JRUBY
 
           opts.on("#{RETRY_FLAG} ATTEMPTS", *retry_msg) { |v| set_option :retry, v.to_i }
           opts.on('--i18n-languages', *i18n_languages_msg) { list_languages_and_exit }
@@ -108,13 +104,13 @@ module Cucumber
           opts.on('-f FORMAT', '--format FORMAT', *format_msg, *FORMAT_HELP) do |v|
             add_option :formats, [*parse_formats(v), @out_stream]
           end
-          opts.on('--init', *init_msg) { |v| initialize_project }
+          opts.on('--init', *init_msg) { |_v| initialize_project }
           opts.on('-o', '--out [FILE|DIR|URL]', *out_msg) { |v| out_stream v }
           opts.on('-t TAG_EXPRESSION', '--tags TAG_EXPRESSION', *tags_msg) { |v| add_tag v }
           opts.on('-n NAME', '--name NAME', *name_msg) { |v| add_option :name_regexps, /#{v}/ }
           opts.on('-e', '--exclude PATTERN', *exclude_msg) { |v| add_option :excludes, Regexp.new(v) }
           opts.on(PROFILE_SHORT_FLAG, "#{PROFILE_LONG_FLAG} PROFILE", *profile_short_flag_msg) { |v| add_profile v }
-          opts.on(NO_PROFILE_SHORT_FLAG, NO_PROFILE_LONG_FLAG, *no_profile_short_flag_msg) { |v| disable_profile_loading }
+          opts.on(NO_PROFILE_SHORT_FLAG, NO_PROFILE_LONG_FLAG, *no_profile_short_flag_msg) { |_v| disable_profile_loading }
           opts.on('-c', '--[no-]color', *color_msg) { |v| color v }
           opts.on('-d', '--dry-run', *dry_run_msg) { set_dry_run_and_duration }
           opts.on('-m', '--no-multiline', "Don't print multiline strings and tables under steps.") { set_option :no_multiline }
@@ -140,11 +136,9 @@ module Cucumber
   [random]      Shuffle scenarios before running.
 Specify SEED to reproduce the shuffling from a previous run.
   e.g. --order random:5738
-TEXT
+                  TEXT
             @options[:order], @options[:seed] = *order.split(':')
-            unless ORDER_TYPES.include?(@options[:order])
-              fail "'#{@options[:order]}' is not a recognised order type. Please use one of #{ORDER_TYPES.join(", ")}."
-            end
+            raise "'#{@options[:order]}' is not a recognised order type. Please use one of #{ORDER_TYPES.join(', ')}." unless ORDER_TYPES.include?(@options[:order])
           end
 
           opts.on_tail('--version', 'Show version.') { exit_ok(Cucumber::VERSION) }
@@ -156,7 +150,7 @@ TEXT
         extract_environment_variables
         @options[:paths] = @args.dup # whatver is left over
 
-        check_formatter_stream_conflicts()
+        check_formatter_stream_conflicts
 
         merge_profiles
 
@@ -171,7 +165,7 @@ TEXT
         @options[:filters] ||= []
       end
 
-      def check_formatter_stream_conflicts()
+      def check_formatter_stream_conflicts
         streams = @options[:formats].uniq.map { |(_, _, stream)| stream }
         return if streams == streams.uniq
         raise 'All but one formatter must use --out, only one can print to each stream (or STDOUT)'
@@ -196,10 +190,7 @@ TEXT
       end
 
       def dry_run_msg
-        [
-          'Invokes formatters without executing the steps.',
-          'This also omits the loading of your support/env.rb file if it exists.'
-        ]
+        ['Invokes formatters without executing the steps.']
       end
 
       def exclude_msg
@@ -219,7 +210,7 @@ TEXT
       def i18n_keywords_msg
         [
           'List keywords for in a particular language',
-          %{Run with "--i18n help" to see all languages}
+          %(Run with "--i18n help" to see all languages)
         ]
       end
 
@@ -320,11 +311,13 @@ TEXT
         [
           'Require files before executing the features. If this',
           'option is not specified, all *.rb files that are',
-          'siblings or below the features will be loaded auto-',
+          'siblings of or below the features will be loaded auto-',
           'matically. Automatic loading is disabled when this',
-          'option is specified, and all loading becomes explicit.',
-          'Files under directories named "support" are always',
-          'loaded first.',
+          'option is specified; all loading becomes explicit.',
+          'Files in directories named "support" are still always',
+          'loaded first when their parent directories are',
+          'required or if the "support" directoires themselves are',
+          'explicitly required.',
           'This option can be specified multiple times.'
         ]
       end
@@ -361,7 +354,7 @@ TEXT
       def language(lang)
         require 'gherkin/dialect'
 
-        return indicate_invalid_language_and_exit(lang) unless ::Gherkin::DIALECTS.keys.include? lang
+        return indicate_invalid_language_and_exit(lang) unless ::Gherkin::DIALECTS.key?(lang)
         list_keywords_and_exit(lang)
       end
 
@@ -370,7 +363,7 @@ TEXT
       end
 
       def non_stdout_formats
-        @options[:formats].select { |_, _, output| output != @out_stream }
+        @options[:formats].reject { |_, _, output| output == @out_stream }
       end
 
       def add_option(option, value)
@@ -378,8 +371,8 @@ TEXT
       end
 
       def add_tag(value)
-        warn("Deprecated: Found tags option '#{value}'. Support for '~@tag' will be removed from the next release of Cucumber. Please use 'not @tag' instead.") if value.include?('~')
-        warn("Deprecated: Found tags option '#{value}'. Support for '@tag1,@tag2' will be removed from the next release of Cucumber. Please use '@tag or @tag2' instead.") if value.include?(',')
+        raise("Found tags option '#{value}'. '~@tag' is no longer supported, use 'not @tag' instead.") if value.include?('~')
+        raise("Found tags option '#{value}'. '@tag1,@tag2' is no longer supported, use '@tag or @tag2' instead.") if value.include?(',')
         @options[:tag_expressions] << value.gsub(/(@\w+)(:\d+)?/, '\1')
         add_tag_limits(value)
       end
@@ -391,9 +384,7 @@ TEXT
       end
 
       def add_tag_limit(tag_limits, tag_name, limit)
-        if tag_limits[tag_name] && tag_limits[tag_name] != limit
-          raise "Inconsistent tag limits for #{tag_name}: #{tag_limits[tag_name]} and #{limit}"
-        end
+        raise "Inconsistent tag limits for #{tag_name}: #{tag_limits[tag_name]} and #{limit}" if tag_limits[tag_name] && tag_limits[tag_name] != limit
         tag_limits[tag_name] = limit
       end
 
@@ -440,7 +431,7 @@ TEXT
       def extract_environment_variables
         @args.delete_if do |arg|
           if arg =~ /^(\w+)=(.*)$/
-            @options[:env_vars][$1] = $2
+            @options[:env_vars][Regexp.last_match(1)] = Regexp.last_match(2)
             true
           end
         end
@@ -469,8 +460,8 @@ TEXT
         profile_args = profile_loader.args_from(profile)
         profile_options = Options.parse(
           profile_args, @out_stream, @error_stream,
-          :skip_profile_information => true,
-          :profile_loader => profile_loader
+          skip_profile_information: true,
+          profile_loader: profile_loader
         )
         reverse_merge(profile_options)
       end
@@ -478,14 +469,14 @@ TEXT
       def default_profile_should_be_used?
         @profiles.empty? &&
           profile_loader.cucumber_yml_defined? &&
-          profile_loader.has_profile?(@default_profile)
+          profile_loader.profile?(@default_profile)
       end
 
       def profile_loader
         @profile_loader ||= ProfileLoader.new
       end
 
-      def reverse_merge(other_options)
+      def reverse_merge(other_options) # rubocop:disable Metrics/AbcSize
         @options = other_options.options.merge(@options)
         @options[:require] += other_options[:require]
         @options[:excludes] += other_options[:excludes]
@@ -514,7 +505,7 @@ TEXT
           @options[:formats] = stdout_formats[0..0] + non_stdout_formats
         end
 
-        @options[:retry] = other_options[:retry] if @options[:retry] == 0
+        @options[:retry] = other_options[:retry] if @options[:retry].zero?
 
         self
       end
@@ -550,7 +541,7 @@ TEXT
             ['but (code)', to_code_keywords_string(language.but_keywords)]
           ]
         )
-        @out_stream.write(data.to_s({ color: false, prefixes: Hash.new('') }))
+        @out_stream.write(data.to_s(color: false, prefixes: Hash.new('')))
         Kernel.exit(0)
       end
 
@@ -561,7 +552,7 @@ TEXT
             [key, ::Gherkin::DIALECTS[key].fetch('name'), ::Gherkin::DIALECTS[key].fetch('native')]
           end
         )
-        @out_stream.write(data.to_s({ color: false, prefixes: Hash.new('') }))
+        @out_stream.write(data.to_s(color: false, prefixes: Hash.new('')))
         Kernel.exit(0)
       end
 
@@ -575,20 +566,20 @@ TEXT
 
       def default_options
         {
-          :strict       => Cucumber::Core::Test::Result::StrictConfiguration.new,
-          :require      => [],
-          :dry_run      => false,
-          :formats      => [],
-          :excludes     => [],
-          :tag_expressions => [],
-          :tag_limits   => {},
-          :name_regexps => [],
-          :env_vars     => {},
-          :diff_enabled => true,
-          :snippets     => true,
-          :source       => true,
-          :duration     => true,
-          :retry        => 0
+          strict: Cucumber::Core::Test::Result::StrictConfiguration.new,
+          require: [],
+          dry_run: false,
+          formats: [],
+          excludes: [],
+          tag_expressions: [],
+          tag_limits: {},
+          name_regexps: [],
+          env_vars: {},
+          diff_enabled: true,
+          snippets: true,
+          source: true,
+          duration: true,
+          retry: 0
         }
       end
     end

data/lib/cucumber/cli/profile_loader.rb

@@ -16,26 +16,19 @@ Could not find profile: '#{profile}'
 
 Defined profiles in cucumber.yml:
   * #{cucumber_yml.keys.sort.join("\n  * ")}
-        END_OF_ERROR
+          END_OF_ERROR
         end
 
         args_from_yml = cucumber_yml[profile] || ''
 
-        require 'shellwords'
-
         case args_from_yml
         when String
-          raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml =~ /^\s*$/
-          if Cucumber::WINDOWS
-            # Shellwords treats backslash as an escape character so we have to mask it out temporarily
-
-            placeholder = 'pseudo_unique_backslash_placeholder'
-            sanitized_line = args_from_yml.gsub('\\', placeholder)
-
-            args_from_yml = Shellwords.shellwords(sanitized_line).collect { |argument| argument.gsub(placeholder, '\\') }
-          else
-            args_from_yml = Shellwords.shellwords(args_from_yml)
+          if args_from_yml =~ /^\s*$/
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank." \
+            "  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n"
           end
+
+          args_from_yml = processed_shellwords(args_from_yml)
         when Array
           raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was empty.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml.empty?
         else
@@ -45,7 +38,7 @@ Defined profiles in cucumber.yml:
         args_from_yml
       end
 
-      def has_profile?(profile)
+      def profile?(profile)
         cucumber_yml.key?(profile)
       end
 
@@ -58,29 +51,47 @@ Defined profiles in cucumber.yml:
       # Loads the profile, processing it through ERB and YAML, and returns it as a hash.
       def cucumber_yml
         return @cucumber_yml if @cucumber_yml
-        unless cucumber_yml_defined?
-          raise(ProfilesNotDefinedError, "cucumber.yml was not found.  Current directory is #{Dir.pwd}.  Please refer to cucumber's documentation on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+
+        ensure_configuration_file_exists
+        process_configuration_file_with_erb
+        load_configuration
+
+        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
+          raise(YmlLoadError, 'cucumber.yml was found, but was blank or malformed. ' \
+          "Please refer to cucumber's documentation on correct profile usage.\n")
         end
 
+        @cucumber_yml
+      end
+
+      def ensure_configuration_file_exists
+        return if cucumber_yml_defined?
+
+        raise(ProfilesNotDefinedError, "cucumber.yml was not found.  Current directory is #{Dir.pwd}." \
+                                       "Please refer to cucumber's documentation on defining profiles in cucumber.yml.  You must define" \
+                                       "a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+      end
+
+      def process_configuration_file_with_erb
         require 'erb'
-        require 'yaml'
         begin
-          @cucumber_erb = ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
+          @cucumber_erb = if RUBY_VERSION >= '2.6'
+                            ERB.new(IO.read(cucumber_file), trim_mode: '%').result(binding)
+                          else
+                            ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
+                          end
         rescue StandardError
-          raise(YmlLoadError, "cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$!.inspect}")
+          raise(YmlLoadError, "cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$ERROR_INFO.inspect}")
         end
+      end
 
+      def load_configuration
+        require 'yaml'
         begin
-          @cucumber_yml = YAML.load(@cucumber_erb)
+          @cucumber_yml = YAML.load(@cucumber_erb) # rubocop:disable Security/YAMLLoad
         rescue StandardError
           raise(YmlLoadError, "cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage.\n")
         end
-
-        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
-          raise(YmlLoadError, "cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage.\n")
-        end
-
-        return @cucumber_yml
       end
 
       # Locates cucumber.yml file. The file can end in .yml or .yaml,
@@ -89,6 +100,18 @@ Defined profiles in cucumber.yml:
       def cucumber_file
         @cucumber_file ||= Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
       end
+
+      def processed_shellwords(args_from_yml)
+        require 'shellwords'
+
+        return Shellwords.shellwords(args_from_yml) unless Cucumber::WINDOWS
+
+        # Shellwords treats backslash as an escape character so we have to mask it out temporarily
+        placeholder = 'pseudo_unique_backslash_placeholder'
+        sanitized_line = args_from_yml.gsub('\\', placeholder)
+
+        Shellwords.shellwords(sanitized_line).collect { |argument| argument.gsub(placeholder, '\\') }
+      end
     end
   end
 end

data/lib/cucumber/configuration.rb

@@ -3,6 +3,7 @@
 require 'cucumber/constantize'
 require 'cucumber/cli/rerun_file'
 require 'cucumber/events'
+require 'cucumber/messages'
 require 'cucumber/core/event_bus'
 require 'cucumber/core/test/result'
 require 'forwardable'
@@ -54,7 +55,7 @@ module Cucumber
     end
 
     def seed
-      Integer(@options[:seed] || rand(0xFFFF))
+      @options[:seed]
     end
 
     def dry_run?
@@ -168,19 +169,23 @@ module Cucumber
 
     def support_to_load
       support_files = all_files_to_load.select { |f| f =~ %r{/support/} }
+
+      # env_files are separated from other_files so we can ensure env files
+      # load first.
+      #
       env_files = support_files.select { |f| f =~ %r{/support/env\..*} }
       other_files = support_files - env_files
-      @options[:dry_run] ? other_files : env_files + other_files
+      env_files.reverse + other_files.reverse
     end
 
     def all_files_to_load
       files = require_dirs.map do |path|
         path = path.tr('\\', '/') # In case we're on windows. Globs don't work with backslashes.
-        path = path.gsub(/\/$/, '') # Strip trailing slash.
+        path = path.gsub(/\/$/, '') # Strip trailing slash. # rubocop:disable Style/RegexpLiteral
         File.directory?(path) ? Dir["#{path}/**/*"] : path
       end.flatten.uniq
       remove_excluded_files_from(files)
-      files.reject! { |f| !File.file?(f) }
+      files.select! { |f| File.file?(f) }
       files.reject! { |f| File.extname(f) == '.feature' }
       files.reject! { |f| f =~ /^http/ }
       files.sort
@@ -196,9 +201,8 @@ module Cucumber
           factory = formatter_class(format)
           yield factory,
                 formatter_options,
-                path_or_io,
-                Cli::Options.new(STDOUT, STDERR, @options)
-        rescue Exception => e
+                path_or_io
+        rescue Exception => e # rubocop:disable Lint/RescueException
           raise e, "#{e.message}\nError creating formatter: #{format}", e.backtrace
         end
       end
@@ -239,26 +243,30 @@ module Cucumber
       @options[:event_bus]
     end
 
+    def id_generator
+      @id_generator ||= Cucumber::Messages::IdGenerator::UUID.new
+    end
+
     private
 
     def default_options
       {
-        :autoload_code_paths => ['features/support', 'features/step_definitions'],
-        :filters             => [],
-        :strict              => Cucumber::Core::Test::Result::StrictConfiguration.new,
-        :require             => [],
-        :dry_run             => false,
-        :fail_fast           => false,
-        :formats             => [],
-        :excludes            => [],
-        :tag_expressions     => [],
-        :name_regexps        => [],
-        :env_vars            => {},
-        :diff_enabled        => true,
-        :snippets            => true,
-        :source              => true,
-        :duration            => true,
-        :event_bus           => Cucumber::Events.make_event_bus
+        autoload_code_paths: ['features/support', 'features/step_definitions'],
+        filters: [],
+        strict: Cucumber::Core::Test::Result::StrictConfiguration.new,
+        require: [],
+        dry_run: false,
+        fail_fast: false,
+        formats: [],
+        excludes: [],
+        tag_expressions: [],
+        name_regexps: [],
+        env_vars: {},
+        diff_enabled: true,
+        snippets: true,
+        source: true,
+        duration: true,
+        event_bus: Cucumber::Events.make_event_bus
       }
     end
 

data/lib/cucumber/constantize.rb

@@ -17,11 +17,8 @@ module Cucumber
         constant
       rescue NameError => e
         require underscore(camel_cased_word)
-        if try < 2
-          retry
-        else
-          raise e
-        end
+        retry if try < 2
+        raise e
       end
     end
 

data/lib/cucumber/deprecate.rb

@@ -5,23 +5,47 @@ require 'cucumber/gherkin/formatter/ansi_escapes'
 
 module Cucumber
   module Deprecate
-    module ForUsers
-      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
+    class AnsiString
+      include Cucumber::Gherkin::Formatter::AnsiEscapes
+
+      def self.failure_message(message)
+        AnsiString.new.failure_message(message)
+      end
+
+      def failure_message(message)
+        failed + message + reset
+      end
+    end
 
+    class CliOption
+      def self.deprecate(stream, option, message, remove_after_version)
+        return if stream.nil?
+        stream.puts(
+          AnsiString.failure_message(
+            "\nWARNING: #{option} is deprecated" \
+            " and will be removed after version #{remove_after_version}.\n#{message}.\n"
+          )
+        )
+      end
+    end
+
+    module ForUsers
       def self.call(message, method, remove_after_version)
-        STDERR.puts AnsiEscapes.failed + "\nWARNING: ##{method} is deprecated and will be removed after version #{remove_after_version}. #{message}.\n(Called from #{caller[2]})" + AnsiEscapes.reset
+        STDERR.puts AnsiString.failure_message(
+          "\nWARNING: ##{method} is deprecated" \
+          " and will be removed after version #{remove_after_version}. #{message}.\n" \
+          "(Called from #{caller(3..3).first})"
+        )
       end
     end
 
     module ForDevelopers
       def self.call(_message, _method, remove_after_version)
-        if Cucumber::VERSION > remove_after_version
-          raise "This method is due for removal after version #{remove_after_version}"
-        end
+        raise "This method is due for removal after version #{remove_after_version}" if Cucumber::VERSION > remove_after_version
       end
     end
 
-    STRATEGY = $0.match(/rspec$/) ? ForDevelopers : ForUsers
+    STRATEGY = $PROGRAM_NAME =~ /rspec$/ ? ForDevelopers : ForUsers
   end
 
   def self.deprecate(*args)

data/lib/cucumber/errors.rb

@@ -6,14 +6,12 @@ module Cucumber
   # Raised when there is no matching StepDefinition for a step.
   class Undefined < Core::Test::Result::Undefined
     def self.from(result, step_name)
-      if result.is_a?(self)
-        return result.with_message(with_prefix(result.message))
-      end
+      return result.with_message(with_prefix(result.message)) if result.is_a?(self)
 
       begin
-        raise self.new(with_prefix(step_name))
-      rescue => exception
-        return exception
+        raise new(with_prefix(step_name)) # rubocop:disable Style/RaiseArgs
+      rescue StandardError => e
+        return e
       end
     end
 
@@ -37,7 +35,7 @@ module Cucumber
   # Raised when a step matches 2 or more StepDefinitions
   class Ambiguous < StandardError
     def initialize(step_name, step_definitions, used_guess)
-      message = String.new
+      message = String.new # rubocop:disable Style/EmptyLiteral
       message << "Ambiguous match of \"#{step_name}\":\n\n"
       message << step_definitions.map(&:backtrace_line).join("\n")
       message << "\n\n"

data/lib/cucumber/events/envelope.rb

@@ -0,0 +1,9 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    class Envelope < Core::Event.new(:envelope)
+      attr_reader :envelope
+    end
+  end
+end

data/lib/cucumber/events/gherkin_source_parsed.rb

@@ -0,0 +1,11 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    # Fired after we've parsed the contents of a feature file
+    class GherkinSourceParsed < Core::Event.new(:gherkin_document)
+      # The Gherkin Ast
+      attr_reader :gherkin_document
+    end
+  end
+end