httpx 0.13.2 → 0.14.0

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

data/lib/httpx/transcoder/chunker.rb

@@ -20,7 +20,7 @@ module HTTPX::Transcoder
         @raw.each do |chunk|
           yield "#{chunk.bytesize.to_s(16)}#{CRLF}#{chunk}#{CRLF}"
         end
-        yield "0#{CRLF}#{CRLF}"
+        yield "0#{CRLF}"
       end
 
       def respond_to_missing?(meth, *args)

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.13.2"
+  VERSION = "0.14.0"
 end

data/sig/callbacks.rbs

@@ -6,8 +6,10 @@ module HTTPX
   module Callbacks
     def on: (Symbol) { (*untyped) -> void } -> void
     def once: (Symbol) { (*untyped) -> void } -> void
+    def only: (Symbol) { (*untyped) -> void } -> void
     def emit: (Symbol, *untyped) -> void
 
+    def callbacks_for?: (Symbol) -> bool
     def callbacks: () -> Hash[Symbol, Array[_Callable]]
                   | (Symbol) -> Array[_Callable]
   end

data/sig/connection/http1.rbs

@@ -60,6 +60,10 @@ module HTTPX
 
     def join_headers: (Request request) -> void
 
+    def join_trailers: (Request request) -> void
+
+    def join_headers2: (Headers headers) -> void
+
     def join_body: (Request request) -> void
 
     def capitalized: (String field) -> String

data/sig/connection/http2.rbs

@@ -53,13 +53,17 @@ module HTTPX
 
     def join_headers: (HTTP2Next::Stream stream, Request request) -> void
 
+    def join_trailers: (HTTP2Next::Stream stream, Request request) -> void
+
     def join_body: (HTTP2Next::Stream stream, Request request) -> void
 
     def on_stream_headers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
 
+    def on_stream_trailers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
+
     def on_stream_data: (HTTP2Next::Stream stream, Request request, string data) -> void
 
-    def on_stream_close: (HTTP2Next::Stream stream, Request request, Symbol? error) -> void
+    def on_stream_close: (HTTP2Next::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void