httpx 0.13.2 → 0.14.4

data/lib/httpx/plugins/proxy.rb

@@ -67,13 +67,9 @@ module HTTPX
 
         def extra_options(options)
           Class.new(options.class) do
-            def_option(:proxy) do |pr|
-              if pr.is_a?(Parameters)
-                pr
-              else
-                Hash[pr]
-              end
-            end
+            def_option(:proxy, <<-OUT)
+              value.is_a?(#{Parameters}) ? value : Hash[value]
+            OUT
           end.new(options)
         end
       end

data/lib/httpx/plugins/proxy/http.rb

@@ -82,11 +82,12 @@ module HTTPX
           end
 
           def set_protocol_headers(request)
-            super
+            extra_headers = super
+
             proxy_params = @options.proxy
-            request.headers["proxy-authorization"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
-            request.headers["proxy-connection"] = request.headers["connection"]
-            request.headers.delete("connection")
+            extra_headers["proxy-authorization"] = "Basic #{proxy_params.token_authentication}" if proxy_params.authenticated?
+            extra_headers["proxy-connection"] = extra_headers.delete("connection") if extra_headers.key?("connection")
+            extra_headers
           end
         end
 

data/lib/httpx/plugins/proxy/ssh.rb

@@ -12,9 +12,9 @@ module HTTPX
 
         def self.extra_options(options)
           Class.new(options.class) do
-            def_option(:proxy) do |pr|
-              Hash[pr]
-            end
+            def_option(:proxy, <<-OUT)
+              Hash[value]
+            OUT
           end.new(options)
         end
 

data/lib/httpx/plugins/rate_limiter.rb

@@ -15,7 +15,7 @@ module HTTPX
       class << self
         RATE_LIMIT_CODES = [429, 503].freeze
 
-        def load_dependencies(klass)
+        def configure(klass)
           klass.plugin(:retries,
                        retry_change_requests: true,
                        retry_on: method(:retry_on_rate_limited_response),

data/lib/httpx/plugins/retries.rb

@@ -25,31 +25,30 @@ module HTTPX
 
       def self.extra_options(options)
         Class.new(options.class) do
-          # number of seconds after which one can retry the request
-          def_option(:retry_after) do |num|
+          def_option(:retry_after, <<-OUT)
             # return early if callable
-            unless num.respond_to?(:call)
-              num = Integer(num)
-              raise Error, ":retry_after must be positive" unless num.positive?
+            unless value.respond_to?(:call)
+              value = Integer(value)
+              raise Error, ":retry_after must be positive" unless value.positive?
             end
 
-            num
-          end
+            value
+          OUT
 
-          def_option(:max_retries) do |num|
-            num = Integer(num)
+          def_option(:max_retries, <<-OUT)
+            num = Integer(value)
             raise Error, ":max_retries must be positive" unless num.positive?
 
             num
-          end
+          OUT
 
           def_option(:retry_change_requests)
 
-          def_option(:retry_on) do |callback|
-            raise ":retry_on must be called with the response" unless callback.respond_to?(:call)
+          def_option(:retry_on, <<-OUT)
+            raise ":retry_on must be called with the response" unless value.respond_to?(:call)
 
-            callback
-          end
+            value
+          OUT
         end.new(options).merge(max_retries: MAX_RETRIES)
       end
 

data/lib/httpx/plugins/stream.rb

@@ -1,6 +1,93 @@
 # frozen_string_literal: true
 
 module HTTPX
+  class StreamResponse
+    def initialize(request, session, connections)
+      @request = request
+      @session = session
+      @connections = connections
+      @options = @request.options
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+
+      raise Error, "response already streamed" if @response
+
+      @request.stream = self
+
+      begin
+        @on_chunk = block
+
+        if @request.response
+          # if we've already started collecting the payload, yield it first
+          # before proceeding
+          body = @request.response.body
+
+          body.each do |chunk|
+            on_chunk(chunk)
+          end
+        end
+
+        response.raise_for_status
+        response.close
+      ensure
+        @on_chunk = nil
+      end
+    end
+
+    def each_line
+      return enum_for(__method__) unless block_given?
+
+      line = +""
+
+      each do |chunk|
+        line << chunk
+
+        while (idx = line.index("\n"))
+          yield line.byteslice(0..idx - 1)
+
+          line = line.byteslice(idx + 1..-1)
+        end
+      end
+    end
+
+    # This is a ghost method. It's to be used ONLY internally, when processing streams
+    def on_chunk(chunk)
+      raise NoMethodError unless @on_chunk
+
+      @on_chunk.call(chunk)
+    end
+
+    # :nocov:
+    def inspect
+      "#<StreamResponse:#{object_id}>"
+    end
+    # :nocov:
+
+    def to_s
+      response.to_s
+    end
+
+    private
+
+    def response
+      @session.__send__(:receive_requests, [@request], @connections, @options) until @request.response
+
+      @request.response
+    end
+
+    def respond_to_missing?(meth, *args)
+      response.respond_to?(meth, *args) || super
+    end
+
+    def method_missing(meth, *args, &block)
+      return super unless response.respond_to?(meth)
+
+      response.__send__(meth, *args, &block)
+    end
+  end
+
   module Plugins
     #
     # This plugin adds support for stream response (text/event-stream).
@@ -15,10 +102,13 @@ module HTTPX
           return super(*args, **options) unless stream
 
           requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
-
           raise Error, "only 1 response at a time is supported for streaming requests" unless requests.size == 1
 
-          StreamResponse.new(requests.first, self)
+          request = requests.first
+
+          connections = _send_requests(requests, request.options)
+
+          StreamResponse.new(request, self, connections)
         end
       end
 
@@ -53,78 +143,10 @@ module HTTPX
         end
       end
 
-      class StreamResponse
-        def initialize(request, session)
-          @request = request
-          @session = session
-          @options = @request.options
-        end
-
-        def each(&block)
-          return enum_for(__method__) unless block_given?
-
-          raise Error, "response already streamed" if @response
-
-          @request.stream = self
-
-          begin
-            @on_chunk = block
-
-            response.raise_for_status
-            response.close
-          ensure
-            @on_chunk = nil
-          end
-        end
-
-        def each_line
-          return enum_for(__method__) unless block_given?
-
-          line = +""
-
-          each do |chunk|
-            line << chunk
-
-            while (idx = line.index("\n"))
-              yield line.byteslice(0..idx - 1)
-
-              line = line.byteslice(idx + 1..-1)
-            end
-          end
-        end
-
-        # This is a ghost method. It's to be used ONLY internally, when processing streams
-        def on_chunk(chunk)
-          raise NoMethodError unless @on_chunk
-
-          @on_chunk.call(chunk)
-        end
-
-        # :nocov:
-        def inspect
-          "#<StreamResponse:#{object_id}>"
-        end
-        # :nocov:
-
-        def to_s
-          response.to_s
-        end
-
-        private
-
-        def response
-          @response ||= @session.__send__(:send_requests, @request, @options).first
-        end
-
-        def respond_to_missing?(*args)
-          @options.response_class.respond_to?(*args) || super
-        end
-
-        def method_missing(meth, *args, &block)
-          return super unless @options.response_class.public_method_defined?(meth)
-
-          response.__send__(meth, *args, &block)
-        end
+      def self.const_missing(const_name)
+        super unless const_name == :StreamResponse
+        warn "DEPRECATION WARNING: the class #{self}::StreamResponse is deprecated. Use HTTPX::StreamResponse instead."
+        HTTPX::StreamResponse
       end
     end
     register_plugin :stream, Stream

data/lib/httpx/plugins/upgrade.rb

@@ -20,11 +20,11 @@ module HTTPX
           end
 
           Class.new(options.class) do
-            def_option(:upgrade_handlers) do |encs|
-              raise Error, ":upgrade_handlers must be a registry" unless encs.respond_to?(:registry)
+            def_option(:upgrade_handlers, <<-OUT)
+              raise Error, ":upgrade_handlers must be a registry" unless value.respond_to?(:registry)
 
-              encs
-            end
+              value
+            OUT
           end.new(options).merge(upgrade_handlers: upgrade_handlers)
         end
       end

data/lib/httpx/request.rb

@@ -35,14 +35,22 @@ module HTTPX
 
     attr_reader :verb, :uri, :headers, :body, :state, :options, :response
 
+    # Exception raised during enumerable body writes
+    attr_reader :drain_error
+
     def_delegator :@body, :empty?
 
     def_delegator :@body, :chunk!
 
     def initialize(verb, uri, options = {})
       @verb    = verb.to_s.downcase.to_sym
-      @uri     = Utils.uri(uri)
       @options = Options.new(options)
+      @uri     = Utils.uri(uri)
+      if @uri.relative?
+        raise(Error, "invalid URI: #{@uri}") unless @options.origin
+
+        @uri = @options.origin.merge(@uri)
+      end
 
       raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
 
@@ -54,6 +62,14 @@ module HTTPX
       @state = :idle
     end
 
+    def trailers?
+      defined?(@trailers)
+    end
+
+    def trailers
+      @trailers ||= @options.headers_class.new
+    end
+
     def interests
       return :r if @state == :done || @state == :expect
 
@@ -124,6 +140,9 @@ module HTTPX
       chunk.dup
     rescue StopIteration
       nil
+    rescue StandardError => e
+      @drain_error = e
+      nil
     end
 
     # :nocov:
@@ -200,7 +219,9 @@ module HTTPX
       end
 
       def unbounded_body?
-        chunked? || @body.bytesize == Float::INFINITY
+        return @unbounded_body if defined?(@unbounded_body)
+
+        @unbounded_body = (chunked? || @body.bytesize == Float::INFINITY)
       end
 
       def chunked?
@@ -253,6 +274,8 @@ module HTTPX
             nextstate = :expect
           end
         end
+      when :trailers
+        return unless @state == :body
       when :done
         return if @state == :expect
       end

data/lib/httpx/response.rb

@@ -94,6 +94,10 @@ module HTTPX
         @state = :idle
       end
 
+      def closed?
+        @state == :closed
+      end
+
       def write(chunk)
         return if @state == :closed
 

data/lib/httpx/session.rb

@@ -77,7 +77,7 @@ module HTTPX
     end
 
     def set_connection_callbacks(connection, connections, options)
-      connection.on(:misdirected) do |misdirected_request|
+      connection.only(:misdirected) do |misdirected_request|
         other_connection = connection.create_idle(ssl: { alpn_protocols: %w[http/1.1] })
         other_connection.merge(connection)
         catch(:coalesced) do
@@ -88,11 +88,11 @@ module HTTPX
         misdirected_request.transition(:idle)
         other_connection.send(misdirected_request)
       end
-      connection.on(:altsvc) do |alt_origin, origin, alt_params|
+      connection.only(:altsvc) do |alt_origin, origin, alt_params|
         other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)
         connections << other_connection if other_connection
       end
-      connection.on(:exhausted) do
+      connection.only(:exhausted) do
         other_connection = connection.create_idle
         other_connection.merge(connection)
         catch(:coalesced) do
@@ -175,12 +175,18 @@ module HTTPX
     end
 
     def send_requests(*requests, options)
-      connections = []
       request_options = @options.merge(options)
 
+      connections = _send_requests(requests, request_options)
+      receive_requests(requests, connections, request_options)
+    end
+
+    def _send_requests(requests, options)
+      connections = []
+
       requests.each do |request|
         error = catch(:resolve_error) do
-          connection = find_connection(request, connections, request_options)
+          connection = find_connection(request, connections, options)
           connection.send(request)
         end
         next unless error.is_a?(ResolveError)
@@ -188,13 +194,17 @@ module HTTPX
         request.emit(:response, ErrorResponse.new(request, error, options))
       end
 
+      connections
+    end
+
+    def receive_requests(requests, connections, options)
       responses = []
 
       begin
         # guarantee ordered responses
         loop do
           request = requests.first
-          pool.next_tick until (response = fetch_response(request, connections, request_options))
+          pool.next_tick until (response = fetch_response(request, connections, options))
 
           responses << response
           requests.shift
@@ -208,7 +218,7 @@ module HTTPX
           # opportunity to traverse the requests, hence we're returning only a fraction of the errors
           # we were supposed to. This effectively fetches the existing responses and return them.
           while (request = requests.shift)
-            responses << fetch_response(request, connections, request_options)
+            responses << fetch_response(request, connections, options)
           end
           break
         end