cucumber 4.0.0.rc.5 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 388c05be14607a5aaa4acaef66d2bb5f6dab1258bc3e785e71a077fae3d366a7
-  data.tar.gz: 2546749fa602b12b756e0dee45ff756fc89507329504b94f633b39cd5692464e
+  metadata.gz: b3c9c9e718ba5a344adfb97aaebfb58f5c99bb6f8142bb74c115c9b7fe94d0f3
+  data.tar.gz: 3a70805fa19b0b83393e61853a6803eecc3b5cfd578a3f1e2201c258fa11b107
 SHA512:
-  metadata.gz: ed762cc475552e7698cf9ebae51b00366f88f000fcbbbd9697bfa1056a2ec7a7a9d49bb946e0f785d8c1d435da443bd2cca834a2309a11403836dc11f93de169
-  data.tar.gz: 112fb462eb9a3bdb1056c3ad32670ad1160ad0f40a6b804bc09b5e948443073df55a8b6c2818c0cb8f7794623b8e71f04d913a1559bb0b69536cc7bf7634873c
+  metadata.gz: 81ed3402348bf4882f9e8a3b43e3b926396813d844cb93c00e1bfecac15f3fb7672750e0162c01182bada9aed90aff96d1751d66fe3bcd7ff9a0bb0b10052c29
+  data.tar.gz: 8f13726940d23325f2f8278dd6c6ddabbbe4cec7fa3b61d7066c2c068b3c326af011bb6eca6b4a18c0cc9ffa00043bb535d2932185259f60baf51ebefbd19087

data/CHANGELOG.md

@@ -9,6 +9,113 @@ This document is formatted according to the principles of [Keep A CHANGELOG](htt
 Please visit [cucumber/CONTRIBUTING.md](https://github.com/cucumber/cucumber/blob/master/CONTRIBUTING.md) for more info on how to contribute to Cucumber.
 
 ----
+
+## [In GIT](https://github.com/cucumber/cucumber-ruby/compare/v5.0.0...master)
+
+### Added
+
+### Changed
+
+### Removed
+
+### Deprecated
+
+### Fixed
+
+## [5.0.0](https://github.com/cucumber/cucumber-ruby/compare/v4.1.0...5.0.0)
+
+### Added
+
+* `--publish` automatically publishes reports to [reports.cucumber.io](https://reports.cucumber.io)
+* `--publish-quiet` does not print information banner about [reports.cucumber.io](https://reports.cucumber.io)
+
+### Changed
+
+* `-q, --quiet` will also imply `--publish-quiet` in addition to `--no-snippets --no-source --no-duration`
+
+### Removed
+
+* Dropped support for Ruby [2.3](https://www.ruby-lang.org/en/news/2019/03/31/support-of-ruby-2-3-has-ended/)
+  and [2.4](https://www.ruby-lang.org/en/news/2020/04/05/support-of-ruby-2-4-has-ended/)
+
+### Fixed
+
+* Update code to be compatible with `diff-lcs` versions 1.3 and 1.4
+* Defer registration of `at_exit` hook that flushes and closes formatter streams
+  ([#1458](https://github.com/cucumber/cucumber-ruby/pull/1458))
+* Updated gems (see git diff for details)
+  * `cucumber-expressions`
+  * `cucumber-gherkin`
+  * `cucumber-create-meta`
+  * `cucumber-messages`
+    * Fix issue with timestamp nanos [#1438](https://github.com/cucumber/cucumber-ruby/issues/1438)
+  * `cucumber-html-formatter`
+    * Add filtering capabilities [#1444](https://github.com/cucumber/cucumber-ruby/issues/1444)
+* Fix Interceptor that was raising exception when calling `puts` on the wrapped stream ([#1445](https://github.com/cucumber/cucumber-ruby/issues/1445))
+
+## [4.1.0](https://github.com/cucumber/cucumber-ruby/compare/v4.0.1...v4.1.0)
+
+### Changed
+
+* Use [`cucumber-create-meta`](https://rubygems.org/gems/cucumber-create-meta) to produce the `Meta` message before the run.
+
+* Updated gems:
+  * `cucumber-wire` ~> 3.1.0
+  * `cucumber-core` ~> 7.1.0
+  * `cucumber-gherkin` ~> 14.0.1
+    * Fix issue with empty feature files [#1427](https://github.com/cucumber/cucumber-ruby/issues/1427)
+  * `cucumber-messages` ~> 12.2.0
+  * `cucumber-html-formatter` ~> 7.0.0
+    * Fix issue with Hook attachments [#1420](https://github.com/cucumber/cucumber-ruby/issues/1420)
+
+### Fixed
+
+* `AfterStep` hook do not cause issue when running `message` formatter. [#1433](https://github.com/cucumber/cucumber-ruby/issues/1433) - [#1434](https://github.com/cucumber/cucumber-ruby/pull/1434)
+
+
+## [4.0.1](https://github.com/cucumber/cucumber-ruby/compare/v4.0.0...v4.0.1)
+
+### Fixed
+
+* force reference to `diff-lcs` to 1.3 as 1.4 introduced breaking changes.
+
+## [4.0.0](https://github.com/cucumber/cucumber-ruby/compare/v4.0.0.rc.5...v4.0.0)
+
+### Changed
+
+* `log` method can now be called with non-string objects and will run `.to_s` on them. [#1410](https://github.com/cucumber/cucumber-ruby/issues/1410)
+
+### Improved
+
+* Display snippet when using undefined parameter type [#1411](https://github.com/cucumber/cucumber-ruby/issues/1411)
+
+## [4.0.0.rc.6](https://github.com/cucumber/cucumber-ruby/compare/v4.0.0.rc.5...4.0.0.rc.6)
+
+### Changed
+
+* Code snippet for an undefined step with a Doc String will ouput `doc_string` instead of `string` in block params
+  ([#1401](https://github.com/cucumber/cucumber-ruby/issues/1401)
+   [#1402](https://github.com/cucumber/cucumber-ruby/pull/1402)
+   [karamosky](https://github.com/karamosky))
+
+* Updated monorepo libraries:
+  - cucumber-gherkin ~> 13
+  - cucumber-html-formatter ~> 6
+  - cucumber-cucumber-expressions ~> 10
+
+* Use `cucumber-ruby-core` 7.0.0
+
+* Use `cucumber-ruby-wire` 3.0.0
+
+* Use `body` field of attachments
+
+### Improved
+
+* `--out url` updates:
+  * supports redirects
+  * use `PUT` method by default
+  * use a cURL like options (for example: `cucumber --out 'http://example.com -X POST -H Content-Type: json`)
+
 ## [4.0.0.rc.5](https://github.com/cucumber/cucumber-ruby/compare/v4.0.0.rc.4...4.0.0.rc.5)
 
 ### Added
@@ -53,7 +160,7 @@ Please visit [cucumber/CONTRIBUTING.md](https://github.com/cucumber/cucumber/blo
    * If you wish to alter this, then you can set a top level config option: `Cucumber.use_legacy_autoloader`
    * Like most config options, setting this inside a `spec_helper.rb` or `env.rb` file is advised
    * For more information on this change, including why it was made. Please read this
-   [Blog Post](www.google.com)
+   [Blog Post](https://cucumber.io/blog/open-source/tweaking-cucumber-rubys-auto-loader/)
    ([#1349](https://github.com/cucumber/cucumber-ruby/pull/1349),
     [#1043](https://github.com/cucumber/cucumber-ruby/issues/1043)
     [luke-hill](https://github.com/luke-hill))

data/CONTRIBUTING.md

@@ -59,13 +59,13 @@ help us to correct style violations reported here:
 
 ## Release Process
 
-* Bump the version number in `lib/cucumber/version`.
-* Make sure `CHANGELOG.md` is updated with the upcoming version number, and has entries for all fixes.
-
-Now release it
-
-    bundle update
-    bundle exec rake
-    git commit -m "Release X.Y.Z"
-    # Make sure you run gem signin as the cukebot@cucumber.io user before running the following step. Credentials can be found in 1Password
-    rake release
+* Upgrade gems with `scripts/update-gemspec`
+* Bump the version number in `lib/cucumber/version`
+* Update `CHANGELOG.md` with the upcoming version number and create a new `In Git` section
+* Remove empty sections from `CHANGELOG.md`
+* Now release it:
+
+```
+git commit -am "Release X.Y.Z"
+make release
+```

data/lib/autotest/cucumber_mixin.rb

@@ -24,23 +24,21 @@ module Autotest::CucumberMixin
     add_sigint_handler
 
     loop do # ^c handler
-      begin
-        get_to_green
-        if tainted
-          rerun_all_tests
-          rerun_all_features if all_good
-        else
-          hook :all_good
-        end
-        wait_for_changes
-        # Once tests and features are green, reset features every
-        # time a file is changed to see if anything breaks.
-        reset_features
-      rescue Interrupt
-        break if wants_to_quit
-        reset
-        reset_features
+      get_to_green
+      if tainted
+        rerun_all_tests
+        rerun_all_features if all_good
+      else
+        hook :all_good
       end
+      wait_for_changes
+      # Once tests and features are green, reset features every
+      # time a file is changed to see if anything breaks.
+      reset_features
+    rescue Interrupt
+      break if wants_to_quit
+      reset
+      reset_features
     end
     hook :quit
   end

data/lib/cucumber/cli/options.rb

@@ -9,6 +9,7 @@ require 'cucumber/core/test/result'
 module Cucumber
   module Cli
     class Options
+      CUCUMBER_PUBLISH_URL = ENV['CUCUMBER_PUBLISH_URL'] || 'https://messages.cucumber.io/api/reports'
       INDENT = ' ' * 53
       BUILTIN_FORMATS = {
         'pretty'      => ['Cucumber::Formatter::Pretty',      'Prints the feature as is - in colours.'],
@@ -93,6 +94,10 @@ module Cucumber
 
         @args.options do |opts| # rubocop:disable Metrics/BlockLength
           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
@@ -117,7 +122,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) }
@@ -145,6 +150,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
@@ -182,6 +189,18 @@ 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',
@@ -302,9 +321,8 @@ Specify SEED to reproduce the shuffling from a previous run.
           "formatter's docs to see whether to pass a file, dir or URL.",
           "\n",
           'When using a URL, the output of the formatter will be sent as the HTTP request body.',
-          'HTTP headers and request method can be set with http- prefixed query parameters,',
-          'for example ?http-content-type=application/json&http-method=PUT.',
-          'All http- prefixed query parameters will be removed from the sent query parameters.'
+          'HTTP headers and request method can be set with cURL like options.',
+          'Example: --out "http://example.com -X POST -H Content-Type:text/json"'
         ]
       end
 
@@ -352,6 +370,12 @@ Specify SEED to reproduce the shuffling from a previous run.
         Dir["#{jars}/**/*.jar"].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'
 
@@ -416,6 +440,7 @@ Specify SEED to reproduce the shuffling from a previous run.
       end
 
       def shut_up
+        @options[:publish_quiet] = true
         @options[:snippets] = false
         @options[:source] = false
         @options[:duration] = false

data/lib/cucumber/configuration.rb

@@ -62,6 +62,14 @@ module Cucumber
       @options[:dry_run]
     end
 
+    def publish_enabled?
+      @options[:publish_enabled]
+    end
+
+    def publish_quiet?
+      @options[:publish_quiet]
+    end
+
     def fail_fast?
       @options[:fail_fast]
     end
@@ -197,14 +205,12 @@ module Cucumber
 
     def formatter_factories
       formats.map do |format, formatter_options, path_or_io|
-        begin
-          factory = formatter_class(format)
-          yield factory,
-                formatter_options,
-                path_or_io
-        rescue Exception => e # rubocop:disable Lint/RescueException
-          raise e, "#{e.message}\nError creating formatter: #{format}", e.backtrace
-        end
+        factory = formatter_class(format)
+        yield factory,
+              formatter_options,
+              path_or_io
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise e, "#{e.message}\nError creating formatter: #{format}", e.backtrace
       end
     end
 
@@ -256,6 +262,7 @@ module Cucumber
         strict: Cucumber::Core::Test::Result::StrictConfiguration.new,
         require: [],
         dry_run: false,
+        publish_quiet: false,
         fail_fast: false,
         formats: [],
         excludes: [],

data/lib/cucumber/errors.rb

@@ -49,7 +49,4 @@ module Cucumber
       super(messages.join("\n"))
     end
   end
-
-  class LogTypeInvalid < StandardError
-  end
 end

data/lib/cucumber/events.rb

@@ -38,7 +38,8 @@ module Cucumber
         TestStepCreated,
         TestStepFinished,
         TestStepStarted,
-        Envelope
+        Envelope,
+        UndefinedParameterType
       )
     end
   end

data/lib/cucumber/events/undefined_parameter_type.rb

@@ -0,0 +1,10 @@
+require 'cucumber/core/events'
+
+module Cucumber
+  module Events
+    class UndefinedParameterType < Core::Event.new(:type_name, :expression)
+      attr_reader :type_name
+      attr_reader :expression
+    end
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Metrics/ModuleLength
+
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
 require 'cucumber/gherkin/i18n'
@@ -116,14 +118,21 @@ module Cucumber
         @snippets_input << Console::SnippetData.new(keyword, test_step)
       end
 
+      def collect_undefined_parameter_type_names(undefined_parameter_type)
+        @undefined_parameter_types << undefined_parameter_type.type_name
+      end
+
       def print_snippets(options)
         return unless options[:snippets]
-        return if @snippets_input.empty?
 
         snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
           snippet_text(step_keyword, step_name, multiline_arg)
         end
-        do_print_snippets(snippet_text_proc)
+        do_print_snippets(snippet_text_proc) unless @snippets_input.empty?
+
+        @undefined_parameter_types.map do |type_name|
+          do_print_undefined_parameter_type_snippet(type_name)
+        end
       end
 
       def do_print_snippets(snippet_text_proc)
@@ -181,6 +190,24 @@ module Cucumber
         @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
       end
 
+      def do_print_undefined_parameter_type_snippet(type_name)
+        camelized = type_name.split(/_|-/).collect(&:capitalize).join
+
+        @io.puts [
+          "The parameter #{type_name} is not defined. You can define a new one with:",
+          '',
+          'ParameterType(',
+          "  name:        '#{type_name}',",
+          '  regexp:      /some regexp here/,',
+          "  type:        #{camelized},",
+          '  # The transformer takes as many arguments as there are capture groups in the regexp,',
+          '  # or just one if there are none.',
+          "  transformer: ->(s) { #{camelized}.new(s) }",
+          ')',
+          ''
+        ].join("\n")
+      end
+
       private
 
       FORMATS = Hash.new { |hash, format| hash[format] = method(format).to_proc }
@@ -219,3 +246,4 @@ module Cucumber
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/cucumber/formatter/http_io.rb

@@ -1,92 +1,150 @@
 require 'net/http'
+require 'tempfile'
 
 module Cucumber
   module Formatter
     class HTTPIO
       class << self
         # Returns an IO that will write to a HTTP request's body
-        def open(url, https_verify_mode = nil)
+        # https_verify_mode can be set to OpenSSL::SSL::VERIFY_NONE
+        # to ignore unsigned certificate - setting to nil will verify the certificate
+        def open(url, https_verify_mode = nil, reporter = nil)
           @https_verify_mode = https_verify_mode
-          uri, method, headers = build_uri_method_headers(url)
-
-          @req = build_request(uri, method, headers)
-          @http = build_client(uri, https_verify_mode)
-
-          read_io, write_io = IO.pipe
-          @req.body_stream = read_io
-
-          class << write_io
-            attr_writer :request_thread
-
-            def start_request(http, req)
-              @req_thread = Thread.new do
-                begin
-                  res = http.request(req)
-                  raise StandardError, "request to #{req.uri} failed with status #{res.code}" if res.code.to_i >= 400
-                rescue StandardError => e
-                  @http_error = e
-                end
-              end
-            end
-
-            def close
-              super
-              begin
-                @req_thread.join
-              rescue StandardError
-                nil
-              end
-              raise @http_error unless @http_error.nil?
-            end
+          uri, method, headers = CurlOptionParser.parse(url)
+          IOHTTPBuffer.new(uri, method, headers, https_verify_mode, reporter)
+        end
+      end
+    end
+
+    class CurlOptionParser
+      def self.parse(options)
+        chunks = options.split(/\s/).compact
+        http_method = 'PUT'
+        url = chunks[0]
+        headers = ''
+
+        last_flag = nil
+        chunks.each do |chunk|
+          if ['-X', '--request'].include?(chunk)
+            last_flag = '-X'
+            next
           end
-          write_io.start_request(@http, @req)
 
-          write_io
+          if chunk == '-H'
+            last_flag = '-H'
+            next
+          end
+
+          if last_flag == '-X'
+            http_method = chunk
+            last_flag = nil
+          end
+
+          headers += chunk if last_flag == '-H'
         end
 
-        def build_uri_method_headers(url)
-          uri = URI(url)
-          query_pairs = uri.query ? URI.decode_www_form(uri.query) : []
-
-          # Build headers from query parameters prefixed with http- and extract HTTP method
-          http_query_pairs = query_pairs.select { |pair| pair[0] =~ /^http-/ }
-          http_query_hash_without_prefix = Hash[http_query_pairs.map do |pair|
-                                                  [
-                                                    pair[0][5..-1].downcase, # remove http- prefix
-                                                    pair[1]
-                                                  ]
-                                                end]
-          method = http_query_hash_without_prefix.delete('method') || 'POST'
-          headers = {
-            'transfer-encoding' => 'chunked'
-          }.merge(http_query_hash_without_prefix)
-
-          # Update the query with the http-* parameters removed
-          remaining_query_pairs = query_pairs - http_query_pairs
-          new_query_hash = Hash[remaining_query_pairs]
-          uri.query = URI.encode_www_form(new_query_hash) unless new_query_hash.empty?
-          [uri, method, headers]
+        [
+          url,
+          http_method,
+          make_headers(headers)
+        ]
+      end
+
+      def self.make_headers(headers)
+        hash_headers = {}
+        str_scanner = /("(?<key>[^":]+)\s*:\s*(?<value>[^":]+)")|('(?<key1>[^':]+)\s*:\s*(?<value1>[^':]+)')/
+
+        headers.scan(str_scanner) do |header|
+          header = header.compact!
+          hash_headers[header[0]] = header[1]&.strip
         end
 
-        private
+        hash_headers
+      end
+    end
 
-        def build_request(uri, method, headers)
-          method_class_name = "#{method[0].upcase}#{method[1..-1].downcase}"
-          req = Net::HTTP.const_get(method_class_name).new(uri)
-          headers.each do |header, value|
-            req[header] = value
-          end
-          req
+    class IOHTTPBuffer
+      attr_reader :uri, :method, :headers
+
+      def initialize(uri, method, headers = {}, https_verify_mode = nil, reporter = nil)
+        @uri = URI(uri)
+        @method = method
+        @headers = headers
+        @write_io = Tempfile.new('cucumber', encoding: 'UTF-8')
+        @https_verify_mode = https_verify_mode
+        @reporter = reporter || NoReporter.new
+      end
+
+      def close
+        resource_uri = send_content(@uri, @method, @headers)
+
+        @reporter.report(resource_uri)
+        @write_io.close
+      end
+
+      def write(data)
+        @write_io.write(data)
+      end
+
+      def flush
+        @write_io.flush
+      end
+
+      def closed?
+        @write_io.closed?
+      end
+
+      private
+
+      def send_content(uri, method, headers, attempt = 10)
+        content = @write_io
+        http = build_client(uri, @https_verify_mode)
+
+        raise StandardError, "request to #{uri} failed (too many redirections)" if attempt <= 0
+        req = build_request(
+          uri,
+          method,
+          headers.merge(
+            'Content-Length' => content.size.to_s
+          )
+        )
+
+        content.rewind
+        req.body_stream = content
+
+        begin
+          response = http.request(req)
+        rescue SystemCallError
+          # We may get the redirect response before pushing the file.
+          response = http.request(build_request(uri, method, headers))
         end
 
-        def build_client(uri, https_verify_mode)
-          http = Net::HTTP.new(uri.hostname, uri.port)
-          if uri.scheme == 'https'
-            http.use_ssl = true
-            http.verify_mode = https_verify_mode if https_verify_mode
-          end
-          http
+        case response
+        when Net::HTTPSuccess
+          uri
+        when Net::HTTPRedirection
+          send_content(URI(response['Location']), method, headers, attempt - 1)
+        else
+          raise StandardError, "request to #{uri} failed with status #{response.code}"
+        end
+      end
+
+      def build_request(uri, method, headers)
+        method_class_name = "#{method[0].upcase}#{method[1..-1].downcase}"
+        req = Net::HTTP.const_get(method_class_name).new(uri)
+        headers.each do |header, value|
+          req[header] = value
+        end
+        req
+      end
+
+      def build_client(uri, https_verify_mode)
+        http = Net::HTTP.new(uri.hostname, uri.port)
+        if uri.scheme == 'https'
+          http.use_ssl = true
+          http.verify_mode = https_verify_mode if https_verify_mode
         end
+        http
       end
     end
   end