httpx 0.10.0 → 0.11.2

data/lib/httpx/chainable.rb

@@ -42,12 +42,15 @@ module HTTPX
     end
 
     # deprecated
+    # :nocov:
     def plugins(*args, **opts)
+      warn ":#{__method__} is deprecated, use :plugin instead"
       klass = is_a?(Session) ? self.class : Session
       klass = Class.new(klass)
       klass.instance_variable_set(:@default_options, klass.default_options.merge(default_options))
       klass.plugins(*args, **opts).new
     end
+    # :nocov:
 
     def with(options, &blk)
       branch(default_options.merge(options), &blk)
@@ -56,7 +59,7 @@ module HTTPX
     private
 
     def default_options
-      @options || Options.new
+      @options || Session.default_options
     end
 
     def branch(options, &blk)
@@ -66,12 +69,10 @@ module HTTPX
     end
 
     def method_missing(meth, *args, **options)
-      if meth =~ /\Awith_(.+)/
-        option = Regexp.last_match(1).to_sym
-        with(option => (args.first || options))
-      else
-        super
-      end
+      return super unless meth =~ /\Awith_(.+)/
+
+      option = Regexp.last_match(1).to_sym
+      with(option => (args.first || options))
     end
 
     def respond_to_missing?(meth, *args)

data/lib/httpx/connection.rb

@@ -120,8 +120,8 @@ module HTTPX
       end
     end
 
-    def create_idle
-      self.class.new(@type, @origin, @options)
+    def create_idle(options = {})
+      self.class.new(@type, @origin, @options.merge(options))
     end
 
     def merge(connection)
@@ -131,17 +131,6 @@ module HTTPX
       end
     end
 
-    def unmerge(connection)
-      @origins -= connection.instance_variable_get(:@origins)
-      purge_pending do |request|
-        request.uri.origin == connection.origin && begin
-          request.transition(:idle)
-          connection.send(request)
-          true
-        end
-      end
-    end
-
     def purge_pending(&block)
       pendings = []
       if @parser
@@ -399,7 +388,7 @@ module HTTPX
       parser.on(:error) do |request, ex|
         case ex
         when MisdirectedRequestError
-          emit(:uncoalesce, request.uri)
+          emit(:misdirected, request)
         else
           response = ErrorResponse.new(request, ex, @options)
           request.emit(:response, response)
@@ -435,7 +424,7 @@ module HTTPX
           remove_instance_variable(:@total_timeout)
         end
 
-        @io.close
+        @io.close if @io
         @read_buffer.clear
         if @keep_alive_timer
           @keep_alive_timer.cancel

data/lib/httpx/connection/http1.rb

@@ -21,6 +21,7 @@ module HTTPX
       @version = [1, 1]
       @pending = []
       @requests = []
+      @handshake_completed = false
     end
 
     def interests
@@ -155,6 +156,7 @@ module HTTPX
       @parser.reset!
       @max_requests -= 1
       manage_connection(response)
+
       send(@pending.shift) unless @pending.empty?
     end
 
@@ -182,17 +184,28 @@ module HTTPX
       connection = response.headers["connection"]
       case connection
       when /keep-alive/i
+        if @handshake_completed
+          if @max_requests.zero?
+            @pending.concat(@requests)
+            @requests.clear
+            emit(:exhausted)
+          end
+          return
+        end
+
         keep_alive = response.headers["keep-alive"]
         return unless keep_alive
 
         parameters = Hash[keep_alive.split(/ *, */).map do |pair|
           pair.split(/ *= */)
         end]
-        @max_requests = parameters["max"].to_i if parameters.key?("max")
+        @max_requests = parameters["max"].to_i - 1 if parameters.key?("max")
+
         if parameters.key?("timeout")
           keep_alive_timeout = parameters["timeout"].to_i
           emit(:timeout, keep_alive_timeout)
         end
+        @handshake_completed = true
       when /close/i
         disable
       when nil

data/lib/httpx/connection/http2.rb

@@ -51,12 +51,8 @@ module HTTPX
       :rw
     end
 
-    def reset
-      init_connection
-    end
-
-    def close(*args)
-      @connection.goaway(*args) unless @connection.state == :closed
+    def close
+      @connection.goaway unless @connection.state == :closed
       emit(:close)
     end
 
@@ -163,14 +159,17 @@ module HTTPX
       @connection.send_connection_preface
     end
 
+    alias_method :reset, :init_connection
+    public :reset
+
     def handle_stream(stream, request)
-      stream.on(:close, &method(:on_stream_close).curry[stream, request])
+      stream.on(:close, &method(:on_stream_close).curry(3)[stream, request])
       stream.on(:half_close) do
         log(level: 2) { "#{stream.id}: waiting for response..." }
       end
-      stream.on(:altsvc, &method(:on_altsvc).curry[request.origin])
-      stream.on(:headers, &method(:on_stream_headers).curry[stream, request])
-      stream.on(:data, &method(:on_stream_data).curry[stream, request])
+      stream.on(:altsvc, &method(:on_altsvc).curry(2)[request.origin])
+      stream.on(:headers, &method(:on_stream_headers).curry(3)[stream, request])
+      stream.on(:data, &method(:on_stream_data).curry(3)[stream, request])
     end
 
     def join_headers(stream, request)
@@ -270,16 +269,16 @@ module HTTPX
     end
 
     def on_close(_last_frame, error, _payload)
+      is_connection_closed = @connection.state == :closed
       if error && error != :no_error
+        @buffer.clear if is_connection_closed
         ex = Error.new(0, error)
         ex.set_backtrace(caller)
-        @streams.each_key do |request|
-          emit(:error, request, ex)
-        end
+        handle_error(ex)
       end
-      return unless @connection.state == :closed && @streams.size.zero?
+      return unless is_connection_closed && @streams.size.zero?
 
-      emit(:close)
+      emit(:close, is_connection_closed)
     end
 
     def on_frame_sent(frame)
@@ -317,7 +316,7 @@ module HTTPX
     end
 
     def on_pong(ping)
-      if !@pings.delete(ping)
+      if !@pings.delete(ping.to_s)
         close(:protocol_error, "ping payload did not match")
       else
         emit(:pong)

data/lib/httpx/domain_name.rb

@@ -139,10 +139,8 @@ module HTTPX
       elsif @hostname.end_with?(othername) && @hostname[-othername.size - 1, 1] == DOT
         # The other is higher
         -1
-      elsif othername.end_with?(@hostname) && othername[-@hostname.size - 1, 1] == DOT
-        # The other is lower
-        1
       else
+        # The other is lower
         1
       end
     end

data/lib/httpx/errors.rb

@@ -24,6 +24,8 @@ module HTTPX
 
   ConnectTimeoutError = Class.new(TimeoutError)
 
+  ResolveTimeoutError = Class.new(TimeoutError)
+
   ResolveError = Class.new(Error)
 
   NativeResolveError = Class.new(ResolveError) do
@@ -41,7 +43,7 @@ module HTTPX
 
     def initialize(response)
       @response = response
-      super("HTTP Error: #{@response.status}")
+      super("HTTP Error: #{@response.status} #{@response.headers}\n#{@response.body}")
     end
 
     def status

data/lib/httpx/headers.rb

@@ -119,6 +119,7 @@ module HTTPX
     def to_hash
       Hash[to_a]
     end
+    alias_method :to_h, :to_hash
 
     # the headers store in array of pairs format
     def to_a

data/lib/httpx/io/ssl.rb

@@ -7,16 +7,16 @@ module HTTPX
     TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
       { alpn_protocols: %w[h2 http/1.1] }
     else
-      # :nocov:
       {}
-      # :nocov:
     end
 
     def initialize(_, _, options)
       @ctx = OpenSSL::SSL::SSLContext.new
       ctx_options = TLS_OPTIONS.merge(options.ssl)
+      @tls_hostname = ctx_options.delete(:hostname)
       @ctx.set_params(ctx_options) unless ctx_options.empty?
       super
+      @tls_hostname ||= @hostname
       @state = :negotiated if @keep_open
     end
 
@@ -59,11 +59,11 @@ module HTTPX
 
       unless @io.is_a?(OpenSSL::SSL::SSLSocket)
         @io = OpenSSL::SSL::SSLSocket.new(@io, @ctx)
-        @io.hostname = @hostname
+        @io.hostname = @tls_hostname
         @io.sync_close = true
       end
       @io.connect_nonblock
-      @io.post_connection_check(@hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
+      @io.post_connection_check(@tls_hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
       transition(:negotiated)
     rescue ::IO::WaitReadable
       @interests = :r
@@ -71,7 +71,6 @@ module HTTPX
       @interests = :w
     end
 
-    # :nocov:
     if RUBY_VERSION < "2.3"
       def read(_, buffer)
         super
@@ -99,14 +98,11 @@ module HTTPX
         end
       end
     end
-    # :nocov:
 
-    # :nocov:
     def inspect
       id = @io.closed? ? "closed" : @io.to_io.fileno
       "#<SSL(fd: #{id}): #{@ip}:#{@port} state: #{@state}>"
     end
-    # :nocov:
 
     private
 

data/lib/httpx/io/udp.rb

@@ -25,7 +25,7 @@ module HTTPX
       true
     end
 
-    if RUBY_VERSION < "2.2"
+    if RUBY_VERSION < "2.3"
       # :nocov:
       def close
         @io.close
@@ -40,14 +40,15 @@ module HTTPX
     end
 
     def write(buffer)
-      siz = @io.send(buffer, 0, @host, @port)
+      siz = @io.send(buffer.to_s, 0, @host, @port)
       log { "WRITE: #{siz} bytes..." }
       buffer.shift!(siz)
       siz
     end
 
     # :nocov:
-    if RUBY_VERSION < "2.3"
+    if (RUBY_ENGINE == "truffleruby" && RUBY_ENGINE_VERSION < "21.1.0") ||
+       RUBY_VERSION < "2.3"
       def read(size, buffer)
         data, _ = @io.recvfrom_nonblock(size)
         buffer.replace(data)

data/lib/httpx/plugins/compression.rb

@@ -94,7 +94,7 @@ module HTTPX
         end
 
         def write(chunk)
-          return super unless defined?(@_inflaters)
+          return super unless defined?(@_inflaters) && !chunk.empty?
 
           chunk = decompress(chunk)
           super(chunk)

data/lib/httpx/plugins/cookies/set_cookie_parser.rb

@@ -107,7 +107,7 @@ module HTTPX
               case aname
               when "expires"
                 # RFC 6265 5.2.1
-                (avalue &&= Time.httpdate(avalue)) || next
+                (avalue &&= Time.parse(avalue)) || next
               when "max-age"
                 # RFC 6265 5.2.2
                 next unless /\A-?\d+\z/.match?(avalue)

data/lib/httpx/plugins/expect.rb

@@ -10,6 +10,10 @@ module HTTPX
     module Expect
       EXPECT_TIMEOUT = 2
 
+      def self.no_expect_store
+        @no_expect_store ||= []
+      end
+
       def self.extra_options(options)
         Class.new(options.class) do
           def_option(:expect_timeout) do |seconds|
@@ -28,25 +32,46 @@ module HTTPX
         end.new(options).merge(expect_timeout: EXPECT_TIMEOUT)
       end
 
-      module RequestBodyMethods
-        def initialize(*, options)
+      module RequestMethods
+        def initialize(*)
           super
-          return if @body.nil?
+          return if @body.empty?
 
-          threshold = options.expect_threshold_size
-          return if threshold && !unbounded_body? && @body.bytesize < threshold
+          threshold = @options.expect_threshold_size
+          return if threshold && !@body.unbounded_body? && @body.bytesize < threshold
+
+          return if Expect.no_expect_store.include?(origin)
 
           @headers["expect"] = "100-continue"
         end
+
+        def response=(response)
+          if response && response.status == 100 &&
+             !@headers.key?("expect") &&
+             (@state == :body || @state == :done)
+
+            # if we're past this point, this means that we just received a 100-Continue response,
+            # but the request doesn't have the expect flag, and is already flushing (or flushed) the body.
+            #
+            # this means that expect was deactivated for this request too soon, i.e. response took longer.
+            #
+            # so we have to reactivate it again.
+            @headers["expect"] = "100-continue"
+            @informational_status = 100
+            Expect.no_expect_store.delete(origin)
+          end
+          super
+        end
       end
 
       module ConnectionMethods
         def send(request)
-          request.once(:expects) do
+          request.once(:expect) do
             @timers.after(@options.expect_timeout) do
-              if request.state == :expects && !request.expects?
+              if request.state == :expect && !request.expects?
+                Expect.no_expect_store << request.origin
                 request.headers.delete("expect")
-                handle(request)
+                consume
               end
             end
           end

data/lib/httpx/plugins/multipart.rb

@@ -10,38 +10,57 @@ module HTTPX
     # https://gitlab.com/honeyryderchuck/httpx/wikis/Multipart-Uploads
     #
     module Multipart
-      module FormTranscoder
-        module_function
-
-        class Encoder
-          extend Forwardable
-
-          def_delegator :@raw, :content_type
-
-          def_delegator :@raw, :to_s
-
-          def_delegator :@raw, :read
+      MULTIPART_VALUE_COND = lambda do |value|
+        value.respond_to?(:read) ||
+          (value.respond_to?(:to_hash) &&
+            value.key?(:body) &&
+            (value.key?(:filename) || value.key?(:content_type)))
+      end
 
-          def initialize(form)
-            @raw = HTTP::FormData.create(form)
-          end
+      class << self
+        def normalize_keys(key, value, &block)
+          Transcoder.normalize_keys(key, value, MULTIPART_VALUE_COND, &block)
+        end
 
-          def bytesize
-            @raw.content_length
+        def load_dependencies(*)
+          begin
+            unless defined?(HTTP::FormData)
+              # in order not to break legacy code, we'll keep loading http/form_data for them.
+              require "http/form_data"
+              warn "httpx: http/form_data is no longer a requirement to use HTTPX :multipart plugin. See migration instructions under" \
+                "https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads.html#notes. \n\n" \
+                "If you'd like to stop seeing this message, require 'http/form_data' yourself."
+            end
+          rescue LoadError
           end
+          require "httpx/plugins/multipart/encoder"
+          require "httpx/plugins/multipart/part"
+          require "httpx/plugins/multipart/mime_type_detector"
         end
 
-        def encode(form)
-          Encoder.new(form)
+        def configure(*)
+          Transcoder.register("form", FormTranscoder)
         end
       end
 
-      def self.load_dependencies(*)
-        require "http/form_data"
-      end
+      module FormTranscoder
+        module_function
 
-      def self.configure(*)
-        Transcoder.register("form", FormTranscoder)
+        def encode(form)
+          if multipart?(form)
+            Encoder.new(form)
+          else
+            Transcoder::Form::Encoder.new(form)
+          end
+        end
+
+        def multipart?(data)
+          data.any? do |_, v|
+            MULTIPART_VALUE_COND.call(v) ||
+              (v.respond_to?(:to_ary) && v.to_ary.any?(&MULTIPART_VALUE_COND)) ||
+              (v.respond_to?(:to_hash) && v.to_hash.any? { |_, e| MULTIPART_VALUE_COND.call(e) })
+          end
+        end
       end
     end
     register_plugin :multipart, Multipart