cucumber 3.2.0 → 5.2.0

data/lib/cucumber/formatter/http_io.rb

@@ -1,80 +1,82 @@
 require 'net/http'
 require 'tempfile'
+require 'shellwords'
 
 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 = CurlOptionParser.parse(url)
-          IOHTTPBuffer.new(uri, method, headers, https_verify_mode)
+          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
+        args = Shellwords.split(options)
 
-          if chunk == '-H'
-            last_flag = '-H'
-            next
-          end
-
-          if last_flag == '-X'
-            http_method = chunk
-            last_flag = nil
+        url = nil
+        http_method = 'PUT'
+        headers = {}
+
+        until args.empty?
+          arg = args.shift
+          case arg
+          when '-X', '--request'
+            http_method = remove_arg_for(args, arg)
+          when '-H'
+            header_arg = remove_arg_for(args, arg)
+            headers = headers.merge(parse_header(header_arg))
+          else
+            raise StandardError, "#{options} was not a valid curl command. Can't set url to #{arg} it is already set to #{url}" if url
+            url = arg
           end
-
-          headers += chunk if last_flag == '-H'
         end
+        raise StandardError, "#{options} was not a valid curl command" unless url
 
         [
           url,
           http_method,
-          make_headers(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] ? header[1].strip : header[1]
-        end
+      def self.remove_arg_for(args, arg)
+        return args.shift unless args.empty?
+        raise StandardError, "Missing argument for #{arg}"
+      end
 
-        hash_headers
+      def self.parse_header(header_arg)
+        parts = header_arg.split(':', 2)
+        raise StandardError, "#{header_arg} was not a valid header" unless parts.length == 2
+        { parts[0].strip => parts[1].strip }
       end
     end
 
     class IOHTTPBuffer
       attr_reader :uri, :method, :headers
 
-      def initialize(uri, method, headers = {}, https_verify_mode = nil)
+      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
-        post_content(@uri, @method, @headers)
+        response = send_content(@uri, @method, @headers)
+        @reporter.report(response.body)
         @write_io.close
+        return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPRedirection)
+        raise StandardError, "request to #{uri} failed with status #{response.code}"
       end
 
       def write(data)
@@ -91,8 +93,8 @@ module Cucumber
 
       private
 
-      def post_content(uri, method, headers, attempt = 10)
-        content = @write_io
+      def send_content(uri, method, headers, attempt = 10)
+        content = (method == 'GET' ? StringIO.new : @write_io)
         http = build_client(uri, @https_verify_mode)
 
         raise StandardError, "request to #{uri} failed (too many redirections)" if attempt <= 0
@@ -115,13 +117,12 @@ module Cucumber
         end
 
         case response
-        when Net::HTTPSuccess
-          response
+        when Net::HTTPAccepted
+          send_content(URI(response['Location']), 'PUT', {}, attempt - 1) if response['Location']
         when Net::HTTPRedirection
-          post_content(URI(response['Location']), method, headers, attempt - 1)
-        else
-          raise StandardError, "request to #{uri} failed with status #{response.code}"
+          send_content(URI(response['Location']), method, headers, attempt - 1)
         end
+        response
       end
 
       def build_request(uri, method, headers)

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -8,7 +8,7 @@ module Cucumber
       end
 
       def method_missing(message, *args)
-        @receiver.send(message, *args) if @receiver.respond_to?(message)
+        @receiver.respond_to?(message) ? @receiver.send(message, *args) : super
       end
 
       def respond_to_missing?(name, include_private = false)

data/lib/cucumber/formatter/interceptor.rb

@@ -5,34 +5,23 @@ module Cucumber
     module Interceptor
       class Pipe
         attr_reader :pipe
+
         def initialize(pipe)
           @pipe = pipe
           @buffer = StringIO.new
           @wrapped = true
+          @lock = Mutex.new
         end
 
         def write(str)
-          lock.synchronize do
+          @lock.synchronize do
             @buffer << str if @wrapped
             return @pipe.write(str)
           end
         end
 
-        # @deprecated use #buffer_string
-        def buffer
-          require 'cucumber/deprecate.rb'
-          Cucumber.deprecate(
-            'Use Cucumber::Formatter::Interceptor::Pipe#buffer_string instead',
-            'Cucumber::Formatter::Interceptor::Pipe#buffer',
-            '3.99'
-          )
-          lock.synchronize do
-            return @buffer.string.lines
-          end
-        end
-
         def buffer_string
-          lock.synchronize do
+          @lock.synchronize do
             return @buffer.string.dup
           end
         end
@@ -43,17 +32,15 @@ module Cucumber
         end
 
         def method_missing(method, *args, &blk)
-          @pipe.send(method, *args, &blk)
+          @pipe.respond_to?(method) ? @pipe.send(method, *args, &blk) : super
         end
 
-        def respond_to?(method, include_private = false)
+        def respond_to_missing?(method, include_private = false)
           super || @pipe.respond_to?(method, include_private)
         end
 
         def self.validate_pipe(pipe)
-          unless [:stdout, :stderr].include? pipe
-            raise ArgumentError, '#wrap only accepts :stderr or :stdout'
-          end
+          raise ArgumentError, '#wrap only accepts :stderr or :stdout' unless %i[stdout stderr].include? pipe
         end
 
         def self.unwrap!(pipe)
@@ -75,19 +62,13 @@ module Cucumber
 
           case pipe
           when :stderr
-            $stderr = self.new($stderr)
-            return $stderr
+            $stderr = new($stderr)
+            $stderr
           when :stdout
-            $stdout = self.new($stdout)
-            return $stdout
+            $stdout = new($stdout)
+            $stdout
           end
         end
-
-        private
-
-        def lock
-          @lock ||= Mutex.new
-        end
       end
     end
   end

data/lib/cucumber/formatter/io.rb

@@ -1,34 +1,70 @@
 # frozen_string_literal: true
 
 require 'cucumber/formatter/http_io'
+require 'cucumber/formatter/url_reporter'
+require 'cucumber/cli/options'
 
 module Cucumber
   module Formatter
     module Io
       module_function
 
-      def ensure_io(path_or_url_or_io)
+      def ensure_io(path_or_url_or_io, error_stream)
         return nil if path_or_url_or_io.nil?
-        return path_or_url_or_io if path_or_url_or_io.respond_to?(:write)
-        io = if path_or_url_or_io =~ %r{^https?://}
-               HTTPIO.open(path_or_url_or_io)
+        return path_or_url_or_io if io?(path_or_url_or_io)
+
+        io = if url?(path_or_url_or_io)
+               url = path_or_url_or_io
+               reporter = url.start_with?(Cucumber::Cli::Options::CUCUMBER_PUBLISH_URL) ? URLReporter.new(error_stream) : NoReporter.new
+               HTTPIO.open(url, nil, reporter)
              else
                File.open(path_or_url_or_io, Cucumber.file_mode('w'))
              end
-        at_exit do
-          unless io.closed?
-            io.flush
-            io.close
+        @io_objects_to_close ||= []
+        @io_objects_to_close.push(io)
+        io
+      end
+
+      module ClassMethods
+        def new(*args, &block)
+          instance = super
+
+          config = args[0]
+          if config.respond_to? :on_event
+            config.on_event :test_run_finished do
+              ios = instance.instance_variable_get(:@io_objects_to_close) || []
+              ios.each do |io|
+                at_exit do
+                  unless io.closed?
+                    io.flush
+                    io.close
+                  end
+                end
+              end
+            end
           end
+
+          instance
         end
-        io
+      end
+
+      def self.included(formatter_class)
+        formatter_class.extend(ClassMethods)
+      end
+
+      def io?(path_or_url_or_io)
+        path_or_url_or_io.respond_to?(:write)
+      end
+
+      def url?(path_or_url_or_io)
+        path_or_url_or_io.match(%r{^https?://})
       end
 
       def ensure_file(path, name)
         raise "You *must* specify --out FILE for the #{name} formatter" unless String == path.class
         raise "I can't write #{name} to a directory - it has to be a file" if File.directory?(path)
         raise "I can't write #{name} to a file in the non-existing directory #{File.dirname(path)}" unless File.directory?(File.dirname(path))
-        ensure_io(path)
+        ensure_io(path, nil)
       end
 
       def ensure_dir(path, name)