cucumber 3.1.2 → 8.0.0

data/lib/cucumber/formatter/http_io.rb

@@ -0,0 +1,152 @@
+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
+        # 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, reporter)
+        end
+      end
+    end
+
+    class CurlOptionParser
+      def self.parse(options)
+        args = Shellwords.split(options)
+
+        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
+        end
+        raise StandardError, "#{options} was not a valid curl command" unless url
+
+        [
+          url,
+          http_method,
+          headers
+        ]
+      end
+
+      def self.remove_arg_for(args, arg)
+        return args.shift unless args.empty?
+
+        raise StandardError, "Missing argument for #{arg}"
+      end
+
+      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, 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
+        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)
+        @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 = (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
+
+        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
+
+        case response
+        when Net::HTTPAccepted
+          send_content(URI(response['Location']), 'PUT', {}, attempt - 1) if response['Location']
+        when Net::HTTPRedirection
+          send_content(URI(response['Location']), method, headers, attempt - 1)
+        end
+        response
+      end
+
+      def build_request(uri, method, headers)
+        method_class_name = "#{method[0].upcase}#{method[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
+end

data/lib/cucumber/formatter/ignore_missing_messages.rb

@@ -8,11 +8,11 @@ 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)
-        @receiver.respond_to?(name, include_private)
+        @receiver.respond_to?(name, include_private) || super(name, include_private)
       end
     end
   end

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,33 +1,77 @@
 # 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_io)
-        return nil if path_or_io.nil?
-        return path_or_io if path_or_io.respond_to?(:write)
-        file = File.open(path_or_io, Cucumber.file_mode('w'))
-        at_exit do
-          unless file.closed?
-            file.flush
-            file.close
+      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 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
+        @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
-        file
+      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(/^https?:\/\//)
       end
 
       def ensure_file(path, name)
-        raise "You *must* specify --out FILE for the #{name} formatter" unless String === path
+        raise "You *must* specify --out FILE for the #{name} formatter" unless path.instance_of? String
         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)}" if !File.directory?(File.dirname(path))
-        ensure_io(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, nil)
       end
 
       def ensure_dir(path, name)
-        raise "You *must* specify --out DIR for the #{name} formatter" unless String === path
+        raise "You *must* specify --out DIR for the #{name} formatter" unless path.instance_of? String
         raise "I can't write #{name} reports to a file - it has to be a directory" if File.file?(path)
+
         FileUtils.mkdir_p(path) unless File.directory?(path)
         File.absolute_path path
       end