cucumber 4.1.0 → 9.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1f051aade812ee4bb28ab3670734b189ade8bc0cd0150a686e21874594ae62f
-  data.tar.gz: 80c272791953dc442492c0571acffc628cb7b1f37a28a00adeef413bc7f76e1b
+  metadata.gz: 1c84d3e0ab90cabd1d67121371c8a95c0e5f91bfa5f3ec42a1024c1a85130bde
+  data.tar.gz: 1386d49afc93d04c9b616f38ab4466c8aa3092aa60a293c82557465ad8b4538a
 SHA512:
-  metadata.gz: 5026e105060af702f3b0adf50f3925ce04fdee7de79c2482093831cab838e2a605d69c056733d7820b6592c7229ee93e1ce64b80ae373ac7acd29f11d113d3a8
-  data.tar.gz: c66fe1effa60270eb430bc2c381252e5c3da5dec524e49c58a7e508febaeb0b1398791f75eba5542395672b2431dafcfb820da2870410a52474ebc157bfbe333
+  metadata.gz: afd28a66515dbb07168f7c906d1de7feb5c780437a22b0492f218db943555bc996e7dfc77750257033c9ae8c843e350ca12c389963b78e6ddf1c58dc3f1df371
+  data.tar.gz: bd21e8e340afc215e887be2e353fd9060a4a4ccf1975298403ed6487e263b4103ef01a73e069f16758cc286ba6d507ae0e2f4b9d72916fb976cbbe440af9d154

data/README.md

@@ -1,38 +1,151 @@
-[![OpenCollective](https://opencollective.com/cucumber/backers/badge.svg)](https://opencollective.com/cucumber)
-[![OpenCollective](https://opencollective.com/cucumber/sponsors/badge.svg)](https://opencollective.com/cucumber)
+<img src="docs/img/cucumber-open-logo.png" alt="Cucumber Open - Supported by Smartbear" width="428" />
 
-[![CircleCI](https://circleci.com/gh/cucumber/cucumber-ruby.svg?style=svg)](https://circleci.com/gh/cucumber/cucumber-ruby)
+# Cucumber
 
+[![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/badges/StandWithUkraine.svg)](https://vshymanskyy.github.io/StandWithUkraine)
+[![OpenCollective](https://opencollective.com/cucumber/backers/badge.svg)](https://opencollective.com/cucumber)
+[![OpenCollective](https://opencollective.com/cucumber/sponsors/badge.svg)](https://opencollective.com/cucumber)
+[![Test cucumber](https://github.com/cucumber/cucumber-ruby/actions/workflows/test.yaml/badge.svg)](https://github.com/cucumber/cucumber-ruby/actions/workflows/test.yaml)
 [![Code Climate](https://codeclimate.com/github/cucumber/cucumber-ruby.svg)](https://codeclimate.com/github/cucumber/cucumber-ruby)
-[![Coverage Status](https://coveralls.io/repos/cucumber/cucumber-ruby/badge.svg?branch=master)](https://coveralls.io/r/cucumber/cucumber-ruby?branch=master)
-
-# Cucumber
+[![Coverage Status](https://coveralls.io/repos/cucumber/cucumber-ruby/badge.svg?branch=main)](https://coveralls.io/r/cucumber/cucumber-ruby?branch=main)
 
 Cucumber is a tool for running automated tests written in plain language. Because they're
 written in plain language, they can be read by anyone on your team. Because they can be
 read by anyone, you can use them to help improve communication, collaboration and trust on
 your team.
 
-Where to get more info:
+<img src="docs/img/gherkin-example.png" alt="Cucumber Gherkin Example" width="728" />
+
+This is the Ruby implementation of Cucumber. Cucumber is also available for [JavaScript](https://github.com/cucumber/cucumber-js),
+[Java](https://github.com/cucumber/cucumber-jvm), and a lot of other languages. You can find a list of implementations here: https://cucumber.io/docs/installation/.
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for info on contributing to Cucumber (issues, PRs, etc.).
+
+Everyone interacting in this codebase and issue tracker is expected to follow the
+Cucumber [code of conduct](https://cucumber.io/conduct).
+
+## Installation
+
+Cucumber for Ruby is a Ruby gem. Install it as you would install any gem: add
+`cucumber` to your Gemfile:
+
+    gem 'cucumber'
+
+then install it:
+
+    $ bundle
+
+or install the gem directly:
+
+    $ gem install cucumber
+
+Later in this document, bundler is considered being used so all commands are using
+`bundle exec`. If this is not the case for you, execute `cucumber` directly, without
+`bundle exec`.
+
+### Supported platforms
+
+- Ruby 3.2
+- Ruby 3.1
+- Ruby 3.0
+- Ruby 2.7
+- TruffleRuby 22.0.0+
+- JRuby 9.4+ (with [some limitations](https://github.com/cucumber/cucumber-ruby/blob/main/docs/jruby-limitations.md))
+
+### Ruby on Rails
+
+Using Ruby on Rails? You can use [cucumber-rails](https://github.com/cucumber/cucumber-rails) to bring Cucumber into your Rails project.
+
+## Usage
+
+### Initialization
+
+If you need to, initialize your `features` directory with
+
+    $ bundle exec cucumber --init
+
+This will create the following directories and files if they do not exist already:
+
+    features
+    ├── step_definitions
+    └── support
+        └── env.rb
+
+### Create your specification
+
+Create a file named `rule.feature` in the `features` directory with:
+
+```gherkin
+# features/rule.feature
+
+Feature: Rule Sample
+
+  Rule: This is a rule
+
+    Example: A passing example
+      Given this will pass
+      When I do an action
+      Then some results should be there
+
+    Example: A failing example
+      Given this will fail
+      When I do an action
+      Then some results should be there
+
+```
+
+### Automate your specification
+
+And a file named `steps.rb` in `features/step_definitions` with:
+
+```ruby
+# features/step_definitions/steps.rb
+
+Given('this will pass') do
+  @this_will_pass = true
+end
+
+Given('this will fail') do
+  @this_will_pass = false
+end
+
+When('I do an action') do
+  :no_op
+end
+
+Then("some results should be there") do
+  expect(@this_will_pass).to be true
+end
+```
+
+### Run Cucumber
+
+    $ bundle exec cucumber
+
+To execute a single feature file:
+
+    $ bundle exec cucumber features/rule.feature
+
+To execute a single example, indicates the line of the name of the example:
+
+    $ bundle exec cucumber features/rule.feature:5
+
+To summarize the results on the standard output, and generate a HTML report on disk:
+
+    $ bundle exec cucumber --format summary --format html --out report.html
 
- * The main website: https://cucumber.io/
- * Documentation: https://cucumber.io/docs
- * Ruby API Documentation: http://www.rubydoc.info/github/cucumber/cucumber-ruby/
- * Support forum: https://groups.google.com/group/cukes
- * Chat: ([Slack](https://cucumber.io/support#slack) and [Gitter](https://cucumber.io/support#gitter))
+For more command line options
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for info on contributing to Cucumber.
+    $ bundle exec cucumber --help
 
-## Supported platforms
-* Ruby 2.6
-* Ruby 2.5
-* Ruby 2.4
-* Ruby 2.3
-* JRuby 9.2 (with [some limitations](https://github.com/cucumber/cucumber-ruby/blob/master/docs/jruby-limitations.md))
+You can also find documentation on the command line possibilities in [features/docs/cli](features/docs/cli).
 
-## Code of Conduct
+## Documentation and support
 
-Everyone interacting in this codebase and issue tracker is expected to follow the Cucumber [code of conduct](https://github.com/cucumber/cucumber/blob/master/CODE_OF_CONDUCT.md).
+- Getting started, writing features, step definitions, and more: https://cucumber.io/docs
+- Ruby API Documentation: http://www.rubydoc.info/github/cucumber/cucumber-ruby/
+- Community support forum: https://community.smartbear.com/t5/Cucumber-Open/bd-p/CucumberOS
+- Slack: [register for an account](https://cucumberbdd-slack-invite.herokuapp.com/) then head over to [#intro](https://cucumberbdd.slack.com/messages/C5WD8SA21/)
 
 ## Copyright
 

data/VERSION

@@ -0,0 +1 @@
+9.2.0

data/lib/cucumber/cli/configuration.rb

@@ -9,7 +9,9 @@ require 'cucumber'
 module Cucumber
   module Cli
     class YmlLoadError < StandardError; end
+
     class ProfilesNotDefinedError < YmlLoadError; end
+
     class ProfileNotFound < StandardError; end
 
     class Configuration
@@ -17,7 +19,7 @@ module Cucumber
 
       attr_reader :out_stream
 
-      def initialize(out_stream = STDOUT, error_stream = STDERR)
+      def initialize(out_stream = $stdout, error_stream = $stderr)
         @out_stream   = out_stream
         @error_stream = error_stream
         @options = Options.new(@out_stream, @error_stream, default_profile: 'default')
@@ -28,6 +30,7 @@ module Cucumber
         @options.parse!(args)
         arrange_formats
         raise("You can't use both --strict and --wip") if strict.strict? && wip?
+
         set_environment_variables
       end
 
@@ -126,13 +129,35 @@ module Cucumber
       end
 
       def arrange_formats
-        @options[:formats] << ['pretty', {}, @out_stream] if @options[:formats].empty?
+        add_default_formatter if needs_default_formatter?
+
         @options[:formats] = @options[:formats].sort_by do |f|
           f[2] == @out_stream ? -1 : 1
         end
         @options[:formats].uniq!
         @options.check_formatter_stream_conflicts
       end
+
+      def add_default_formatter
+        @options[:formats] << ['pretty', {}, @out_stream]
+      end
+
+      def needs_default_formatter?
+        formatter_missing? || publish_only?
+      end
+
+      def formatter_missing?
+        @options[:formats].empty?
+      end
+
+      def publish_only?
+        @options[:formats]
+          .uniq
+          .map { |formatter, _, stream| [formatter, stream] }
+          .uniq
+          .reject { |formatter, stream| formatter == 'message' && stream != @out_stream }
+          .empty?
+      end
     end
   end
 end

data/lib/cucumber/cli/main.rb

@@ -14,7 +14,7 @@ module Cucumber
         end
       end
 
-      def initialize(args, _ = nil, out = STDOUT, err = STDERR, kernel = Kernel)
+      def initialize(args, out = $stdout, err = $stderr, kernel = Kernel)
         @args   = args
         @out    = out
         @err    = err
@@ -41,7 +41,7 @@ module Cucumber
         @err.puts("Couldn't open #{e.path}")
         exit_unable_to_finish
       rescue FeatureFolderNotFoundException => e
-        @err.puts(e.message + '. You can use `cucumber --init` to get started.')
+        @err.puts("#{e.message}. You can use `cucumber --init` to get started.")
         exit_unable_to_finish
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
         @err.puts(e.message)
@@ -49,7 +49,7 @@ module Cucumber
       rescue Errno::EACCES, Errno::ENOENT => e
         @err.puts("#{e.message} (#{e.class})")
         exit_unable_to_finish
-      rescue Exception => e # rubocop:disable Lint/RescueException
+      rescue Exception => e
         @err.puts("#{e.message} (#{e.class})")
         @err.puts(e.backtrace.join("\n"))
         exit_unable_to_finish
@@ -85,13 +85,14 @@ module Cucumber
         trap('INT') do
           exit_unable_to_finish! if Cucumber.wants_to_quit
           Cucumber.wants_to_quit = true
-          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+          $stderr.puts "\nExiting... Interrupt again to exit immediately."
           exit_unable_to_finish
         end
       end
 
       def runtime(existing_runtime)
         return Runtime.new(configuration) unless existing_runtime
+
         existing_runtime.configure(configuration)
         existing_runtime
       end

data/lib/cucumber/cli/options.rb

@@ -9,23 +9,29 @@ require 'cucumber/core/test/result'
 module Cucumber
   module Cli
     class Options
+      CUCUMBER_PUBLISH_URL = ENV['CUCUMBER_PUBLISH_URL'] || 'https://messages.cucumber.io/api/reports -X GET'
       INDENT = ' ' * 53
       BUILTIN_FORMATS = {
-        '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" \
-                                                              "#{INDENT}filename instead."],
-        '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',        '[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']
+        '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" \
+          "#{INDENT}filename instead."],
+        '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. Use\n" \
+          "#{INDENT}junit,fileattribute=true to include a file attribute."],
+        'json' => ['Cucumber::Formatter::Json', "Prints the feature as JSON.\n" \
+          "#{INDENT}The JSON format is in maintenance mode.\n" \
+          "#{INDENT}Please consider using the message formatter\n"\
+          "#{INDENT}with the standalone json-formatter\n" \
+          "#{INDENT}(https://github.com/cucumber/cucumber/tree/master/json-formatter)."],
+        'message' => ['Cucumber::Formatter::Message', 'Prints each message in NDJSON form, which can then be consumed by other tools.'],
+        'html' => ['Cucumber::Formatter::HTML', 'Outputs HTML report'],
+        'summary' => ['Cucumber::Formatter::Summary', 'Summary output of feature and scenarios']
       }.freeze
       max = BUILTIN_FORMATS.keys.map(&:length).max
       FORMAT_HELP_MSG = [
@@ -44,26 +50,27 @@ module Cucumber
       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'.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
+      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'
+      RETRY_TOTAL_FLAG = '--retry-total'
       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'
+        PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG, RETRY_FLAG, RETRY_TOTAL_FLAG,
+        '-l', '--lines', '--port', '-I', '--snippet-type'
       ].freeze
       ORDER_TYPES = %w[defined random].freeze
-      TAG_LIMIT_MATCHER = /(?<tag_name>\@\w+):(?<limit>\d+)/x
+      TAG_LIMIT_MATCHER = /(?<tag_name>@\w+):(?<limit>\d+)/x.freeze
 
       def self.parse(args, out_stream, error_stream, options = {})
         new(out_stream, error_stream, options).parse!(args)
       end
 
-      def initialize(out_stream = STDOUT, error_stream = STDERR, options = {})
+      def initialize(out_stream = $stdout, error_stream = $stderr, options = {})
         @out_stream   = out_stream
         @error_stream = error_stream
 
@@ -85,29 +92,34 @@ module Cucumber
         @options[key] = value
       end
 
-      def parse!(args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def parse!(args)
         @args = args
         @expanded_args = @args.dup
 
         @args.extend(::OptionParser::Arguable)
 
-        @args.options do |opts| # rubocop:disable Metrics/BlockLength
+        @args.options do |opts|
           opts.banner = banner
+          opts.on('--publish', 'Publish a report to https://reports.cucumber.io') do
+            set_option :publish_enabled, true
+          end
+          opts.on('--publish-quiet', 'Don\'t print information banner about publishing reports') { set_option :publish_quiet }
           opts.on('-r LIBRARY|DIR', '--require LIBRARY|DIR', *require_files_msg) { |lib| require_files(lib) }
 
           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("#{RETRY_TOTAL_FLAG} TESTS", *retry_total_msg) { |v| set_option :retry_total, v.to_i }
           opts.on('--i18n-languages', *i18n_languages_msg) { list_languages_and_exit }
           opts.on('--i18n-keywords LANG', *i18n_keywords_msg) { |lang| language lang }
           opts.on(FAIL_FAST_FLAG, 'Exit immediately following the first failing scenario') { set_option :fail_fast }
           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) { 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('-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 }
@@ -117,7 +129,7 @@ module Cucumber
           opts.on('-s', '--no-source', "Don't print the file and line of the step definition with the steps.") { set_option :source, false }
           opts.on('-i', '--no-snippets', "Don't print snippets for pending steps.") { set_option :snippets, false }
           opts.on('-I', '--snippet-type TYPE', *snippet_type_msg) { |v| set_option :snippet_type, v.to_sym }
-          opts.on('-q', '--quiet', 'Alias for --no-snippets --no-source.') { shut_up }
+          opts.on('-q', '--quiet', 'Alias for --no-snippets --no-source --no-duration --publish-quiet.') { shut_up }
           opts.on('--no-duration', "Don't print the duration at the end of the summary") { set_option :duration, false }
           opts.on('-b', '--backtrace', 'Show full backtrace for all errors.') { Cucumber.use_full_backtrace = true }
           opts.on('-S', '--[no-]strict', *strict_msg) { |setting| set_strict(setting) }
@@ -131,11 +143,11 @@ module Cucumber
           opts.on('-x', '--expand', 'Expand Scenario Outline Tables in output.') { set_option :expand }
 
           opts.on('--order TYPE[:SEED]', 'Run examples in the specified order. Available types:',
-                  *<<-TEXT.split("\n")) do |order|
-  [defined]     Run scenarios in the order they were defined (default).
-  [random]      Shuffle scenarios before running.
-Specify SEED to reproduce the shuffling from a previous run.
-  e.g. --order random:5738
+                  *<<~TEXT.split("\n")) do |order|
+                      [defined]     Run scenarios in the order they were defined (default).
+                      [random]      Shuffle scenarios before running.
+                    Specify SEED to reproduce the shuffling from a previous run.
+                      e.g. --order random:5738
                   TEXT
             @options[:order], @options[:seed] = *order.split(':')
             raise "'#{@options[:order]}' is not a recognised order type. Please use one of #{ORDER_TYPES.join(', ')}." unless ORDER_TYPES.include?(@options[:order])
@@ -145,6 +157,8 @@ Specify SEED to reproduce the shuffling from a previous run.
           opts.on_tail('-h', '--help', "You're looking at it.") { exit_ok(opts.help) }
         end.parse!
 
+        process_publish_options
+
         @args.map! { |a| "#{a}:#{@options[:lines]}" } if @options[:lines]
 
         extract_environment_variables
@@ -168,6 +182,7 @@ Specify SEED to reproduce the shuffling from a previous run.
       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)'
       end
 
@@ -182,6 +197,19 @@ Specify SEED to reproduce the shuffling from a previous run.
 
       private
 
+      def process_publish_options
+        @options[:publish_enabled] = true if truthy_string?(ENV['CUCUMBER_PUBLISH_ENABLED']) || ENV['CUCUMBER_PUBLISH_TOKEN']
+        @options[:formats] << publisher if @options[:publish_enabled]
+
+        @options[:publish_quiet] = true if truthy_string?(ENV['CUCUMBER_PUBLISH_QUIET'])
+      end
+
+      def truthy_string?(str)
+        return false if str.nil?
+
+        str !~ /^(false|no|0)$/i
+      end
+
       def color_msg
         [
           'Whether or not to use ANSI color in the output. Cucumber decides',
@@ -245,6 +273,13 @@ Specify SEED to reproduce the shuffling from a previous run.
         ['Specify the number of times to retry failing tests (default: 0)']
       end
 
+      def retry_total_msg
+        [
+          'The total number of failing test after which retrying of tests is suspended.',
+          'Example: --retry-total 10 -> Will stop retrying tests after 10 failing tests.'
+        ]
+      end
+
       def name_msg
         [
           'Only execute the feature elements which match part of the given name.',
@@ -260,15 +295,15 @@ Specify SEED to reproduce the shuffling from a previous run.
         ]
       end
 
-      def parse_formats(v)
-        formatter, *formatter_options = v.split(',')
-        options_hash = Hash[formatter_options.map { |s| s.split('=') }]
+      def parse_formats(value)
+        formatter, *formatter_options = value.split(',')
+        options_hash = Hash[formatter_options.map { |string| string.split('=') }]
         [formatter, options_hash]
       end
 
-      def out_stream(v)
+      def out_stream(value)
         @options[:formats] << ['pretty', {}, nil] if @options[:formats].empty?
-        @options[:formats][-1][2] = v
+        @options[:formats][-1][2] = value
       end
 
       def tags_msg
@@ -316,7 +351,7 @@ Specify SEED to reproduce the shuffling from a previous run.
           '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',
+          'required or if the "support" directories themselves are',
           'explicitly required.',
           'This option can be specified multiple times.'
         ]
@@ -340,21 +375,29 @@ Specify SEED to reproduce the shuffling from a previous run.
         ].join("\n")
       end
 
-      def require_files(v)
-        @options[:require] << v
-        return unless Cucumber::JRUBY && File.directory?(v)
+      def require_files(filenames)
+        @options[:require] << filenames
+        return unless Cucumber::JRUBY && File.directory?(filenames)
+
         require 'java'
-        $CLASSPATH << v
+        $CLASSPATH << filenames
       end
 
       def require_jars(jars)
-        Dir["#{jars}/**/*.jar"].each { |jar| require jar }
+        Dir["#{jars}/**/*.jar"].sort.each { |jar| require jar }
+      end
+
+      def publisher
+        url = CUCUMBER_PUBLISH_URL
+        url += %( -H "Authorization: Bearer #{ENV['CUCUMBER_PUBLISH_TOKEN']}") if ENV['CUCUMBER_PUBLISH_TOKEN']
+        ['message', {}, url]
       end
 
       def language(lang)
         require 'gherkin/dialect'
 
         return indicate_invalid_language_and_exit(lang) unless ::Gherkin::DIALECTS.key?(lang)
+
         list_keywords_and_exit(lang)
       end
 
@@ -373,6 +416,7 @@ Specify SEED to reproduce the shuffling from a previous run.
       def add_tag(value)
         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
@@ -385,6 +429,7 @@ Specify SEED to reproduce the shuffling from a previous run.
 
       def add_tag_limit(tag_limits, tag_name, limit)
         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
 
@@ -396,8 +441,8 @@ Specify SEED to reproduce the shuffling from a previous run.
         ProjectInitializer.new.run && Kernel.exit(0)
       end
 
-      def add_profile(p)
-        @profiles << p
+      def add_profile(profile)
+        @profiles << profile
       end
 
       def set_option(option, value = nil)
@@ -410,11 +455,12 @@ Specify SEED to reproduce the shuffling from a previous run.
       end
 
       def exit_ok(text)
-        @out_stream.puts text
+        @out_stream.puts(text)
         Kernel.exit(0)
       end
 
       def shut_up
+        @options[:publish_quiet] = true
         @options[:snippets] = false
         @options[:source] = false
         @options[:duration] = false
@@ -437,22 +483,11 @@ Specify SEED to reproduce the shuffling from a previous run.
         end
       end
 
-      def disable_profile_loading?
-        @disable_profile_loading
-      end
-
       def merge_profiles
-        if @disable_profile_loading
-          @out_stream.puts 'Disabling profiles...'
-          return
-        end
+        return @out_stream.puts 'Disabling profiles...' if @disable_profile_loading
 
         @profiles << @default_profile if default_profile_should_be_used?
-
-        @profiles.each do |profile|
-          merge_with_profile(profile)
-        end
-
+        @profiles.each { |profile| merge_with_profile(profile) }
         @options[:profiles] = @profiles
       end
 
@@ -476,7 +511,7 @@ Specify SEED to reproduce the shuffling from a previous run.
         @profile_loader ||= ProfileLoader.new
       end
 
-      def reverse_merge(other_options) # rubocop:disable Metrics/AbcSize
+      def reverse_merge(other_options)
         @options = other_options.options.merge(@options)
         @options[:require] += other_options[:require]
         @options[:excludes] += other_options[:excludes]
@@ -506,6 +541,7 @@ Specify SEED to reproduce the shuffling from a previous run.
         end
 
         @options[:retry] = other_options[:retry] if @options[:retry].zero?
+        @options[:retry_total] = other_options[:retry_total] if @options[:retry_total].infinite?
 
         self
       end
@@ -579,7 +615,8 @@ Specify SEED to reproduce the shuffling from a previous run.
           snippets: true,
           source: true,
           duration: true,
-          retry: 0
+          retry: 0,
+          retry_total: Float::INFINITY
         }
       end
     end