httpx 0.11.3 → 0.14.0

data/lib/httpx/resolver/https.rb

@@ -55,20 +55,12 @@ module HTTPX
       early_resolve(connection) || resolve(connection)
     end
 
-    def timeout
-      @connections.map(&:timeout).min
-    end
-
     def closed?
-      return true unless @resolver_connection
-
-      resolver_connection.closed?
+      true
     end
 
-    def interests
-      return if @queries.empty?
-
-      resolver_connection.__send__(__method__)
+    def empty?
+      true
     end
 
     private

data/lib/httpx/resolver/native.rb

@@ -101,7 +101,7 @@ module HTTPX
         transition(:open)
       end
 
-      !@write_buffer.empty? || @queries.empty? ? :w : :r
+      calculate_interests
     end
 
     def <<(connection)
@@ -127,10 +127,14 @@ module HTTPX
 
     private
 
+    def calculate_interests
+      !@write_buffer.empty? || @queries.empty? ? :w : :r
+    end
+
     def consume
-      dread
+      dread if calculate_interests == :r
       do_retry
-      dwrite
+      dwrite if calculate_interests == :w
     end
 
     def do_retry

data/lib/httpx/response.rb

@@ -27,8 +27,7 @@ module HTTPX
       @version = version
       @status = Integer(status)
       @headers = @options.headers_class.new(headers)
-      @body = @options.response_body_class.new(self, threshold_size: @options.body_threshold_size,
-                                                     window_size: @options.window_size)
+      @body = @options.response_body_class.new(self, @options)
     end
 
     def merge_headers(h)
@@ -83,17 +82,22 @@ module HTTPX
     end
 
     class Body
-      def initialize(response, threshold_size:, window_size: 1 << 14)
+      def initialize(response, options)
         @response = response
         @headers = response.headers
-        @threshold_size = threshold_size
-        @window_size = window_size
+        @options = options
+        @threshold_size = options.body_threshold_size
+        @window_size = options.window_size
         @encoding = response.content_type.charset || Encoding::BINARY
         @length = 0
         @buffer = nil
         @state = :idle
       end
 
+      def closed?
+        @state == :closed
+      end
+
       def write(chunk)
         return if @state == :closed
 
@@ -268,8 +272,15 @@ module HTTPX
       @error.message
     end
 
-    def to_s
-      @error.backtrace.join("\n")
+    if Exception.method_defined?(:full_message)
+      def to_s
+        @error.full_message
+      end
+    else
+      def to_s
+        "#{@error.message} (#{@error.class})\n" \
+        "#{@error.backtrace.join("\n") if @error.backtrace}"
+      end
     end
 
     def raise_for_status

data/lib/httpx/selector.rb

@@ -69,6 +69,11 @@ class HTTPX::Selector
 
         if @selectables.empty?
           @selectables = selectables
+
+          # do not run event loop if there's nothing to wait on.
+          # this might happen if connect failed and connection was unregistered.
+          return if (!r || r.empty?) && (!w || w.empty?)
+
           break
         else
           @selectables = [*selectables, @selectables]

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,18 +194,33 @@ 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
 
-          break if requests.empty? || pool.empty?
+          break if requests.empty?
+
+          next unless pool.empty?
+
+          # in some cases, the pool of connections might have been drained because there was some
+          # handshake error, and the error responses have already been emitted, but there was no
+          # 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, options)
+          end
+          break
         end
         responses
       ensure
@@ -269,7 +290,19 @@ module HTTPX
       end
       # :nocov:
     end
+  end
+
+  unless ENV.grep(/https?_proxy$/i).empty?
+    proxy_session = plugin(:proxy)
+    ::HTTPX.send(:remove_const, :Session)
+    ::HTTPX.send(:const_set, :Session, proxy_session.class)
+  end
 
-    plugin(:proxy) unless ENV.grep(/https?_proxy$/i).empty?
+  # :nocov:
+  if Session.default_options.debug_level > 2
+    proxy_session = plugin(:internal_telemetry)
+    ::HTTPX.send(:remove_const, :Session)
+    ::HTTPX.send(:const_set, :Session, proxy_session.class)
   end
+  # :nocov:
 end

data/lib/httpx/transcoder/body.rb

@@ -44,11 +44,9 @@ module HTTPX::Transcoder
       end
 
       def method_missing(meth, *args, &block)
-        if @raw.respond_to?(meth)
-          @raw.__send__(meth, *args, &block)
-        else
-          super
-        end
+        return super unless @raw.respond_to?(meth)
+
+        @raw.__send__(meth, *args, &block)
       end
     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.11.3"
+  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/chainable.rbs

@@ -18,7 +18,8 @@ module HTTPX
               | (:cookies) -> Plugins::sessionCookies
               | (:expect) -> Session
               | (:follow_redirects) -> Plugins::sessionFollowRedirects
-              | (:h2c) -> Plugins::sessionH2C
+              | (:upgrade) -> Session
+              | (:h2c) -> Session
               | (:multipart) -> Session
               | (:persistent) -> Plugins::sessionPersistent
               | (:proxy) -> Plugins::sessionProxy

data/sig/connection/http1.rbs

@@ -4,6 +4,7 @@ module HTTPX
     include Loggable
 
     attr_reader pending: Array[Request]
+    attr_reader requests: Array[Request]
 
     @options: Options
     @max_concurrent_requests: Integer
@@ -31,7 +32,7 @@ module HTTPX
 
     def on_headers: (Hash[String, Array[String]] headers) -> void
 
-    def on_trailers: (Array[String, String] headers) -> void
+    def on_trailers: (Hash[String, Array[String]] headers) -> void
 
     def on_data: (string chunk) -> void
 
@@ -51,7 +52,7 @@ module HTTPX
 
     def disable_pipelining: () -> void
 
-    def set_request_headers: (Request) -> void
+    def set_protocol_headers: (Request) -> void
 
     def headline_uri: (Request) -> String
 
@@ -59,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

@@ -3,7 +3,7 @@ module HTTPX
     include Callbacks
     include Loggable
 
-    attr_reader streams: Hash[HTTP2Next::Stream, Response]
+    attr_reader streams: Hash[Request, HTTP2Next::Stream]
     attr_reader pending: Array[Request]
 
     @options: Options
@@ -13,7 +13,7 @@ module HTTPX
     @pings: Array[String]
     @buffer: Buffer
 
-    def interests: () -> io_interests
+    def interests: () -> io_interests?
 
     def close: () -> void
 
@@ -23,6 +23,8 @@ module HTTPX
 
     def <<: (String) -> void
 
+    def can_buffer_more_requests: () -> bool
+
     def send: (Request) -> void
 
     def consume: () -> void
@@ -41,7 +43,7 @@ module HTTPX
 
     def headline_uri: (Request) -> String
 
-    def set_request_headers: (Request) -> void
+    def set_protocol_headers: (Request) -> void
 
     def handle: (Request request, HTTP2Next::Stream stream) -> void
 
@@ -51,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
 

data/sig/options.rbs

@@ -5,68 +5,67 @@ module HTTPX
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
 
+    type timeout_type = :connect_timeout  | :operation_timeout | :keep_alive_timeout | :total_timeout
+    type timeout = Hash[timeout_type, Numeric?]
+
     def self.new: (options) -> instance
                 | () -> instance
 
+    # headers
+    attr_reader uri: URI?
+    def uri=: (uri) -> void
+
     # headers
     attr_reader headers: Headers?
     def headers=: (headers) -> void
-    def with_headers: (headers) -> instance 
 
     # timeout
-    attr_reader timeout: Timeout?
-    def timeout=: (Hash[Symbol, untyped] | Timeout) -> void
-    def with_timeout: (Hash[Symbol, untyped] | Timeout) -> instance
+    attr_reader timeout: timeout
+    def timeout=: (timeout) -> void
 
     # max_concurrent_requests
     attr_reader max_concurrent_requests: Integer?
     def max_concurrent_requests=: (Integer) -> void
-    def with_max_concurrent_requests: (Integer) -> instance
 
     # max_requests
     attr_reader max_requests: Integer?
     def max_requests=: (Integer) -> void
-    def with_max_requests: (Integer) -> instance
 
     # window_size
     attr_reader window_size: int?
     def window_size=: (int) -> void
-    def with_window_size: (int) -> instance
 
     # body_threshold_size
     attr_reader body_threshold_size: int?
     def body_threshold_size=: (int) -> void
-    def with_body_threshold_size: (int) -> instance
 
     # transport
     attr_reader transport: _ToS?
     def transport=: (_ToS) -> void
-    def with_transport: (_ToS) -> instance
 
     # transport_options
     attr_reader transport_options: Hash[untyped, untyped]?
     def transport_options=: (Hash[untyped, untyped]) -> void
-    def with_transport_options: (Hash[untyped, untyped]) -> instance
+
+    # addresses
+    attr_reader addresses: _ToAry[untyped]?
+    def addresses=: (_ToAry[untyped]) -> void
 
     # params
     attr_reader params: Transcoder::urlencoded_input?
     def params=: (Transcoder::urlencoded_input) -> void
-    def with_params: (Transcoder::urlencoded_input) -> instance
 
     # form
     attr_reader form: Transcoder::urlencoded_input?
     def form=: (Transcoder::urlencoded_input) -> void
-    def with_form: (Transcoder::urlencoded_input) -> instance
 
     # json
     attr_reader json: _ToJson?
     def json=: (_ToJson) -> void
-    def with_json: (_ToJson) -> instance
 
     # body
     attr_reader body: bodyIO?
     def body=: (bodyIO) -> void
-    def with_body: (bodyIO) -> instance
 
     # ssl
 
@@ -79,32 +78,27 @@ module HTTPX
     # request_class
     attr_reader request_class: singleton(Request)
     def request_class=: (singleton(Request)) -> void
-    def with_request_class: (singleton(Request)) -> instance
 
     # io
-    attr_reader io: _ToIO?
-    def io=: (_ToIO) -> void
-    def with_io: (_ToIO) -> instance
+    type io_option = _ToIO | Hash[String, _ToIO]
+    attr_reader io: io_option?
+    def io=: (io_option) -> void
 
     # fallback_protocol
     attr_reader fallback_protocol: String?
     def fallback_protocol=: (String) -> void
-    def with_fallback_protocol: (String) -> instance
 
     # debug
     attr_reader debug: _IOLogger?
     def debug=: (_IOLogger) -> void
-    def with_debug: (_IOLogger) -> instance
 
     # debug_level
     attr_reader debug_level: Integer?
     def debug_level=: (Integer) -> void
-    def with_debug_level: (Integer) -> instance
 
     # persistent
     attr_reader persistent: bool?
     def persistent=: (bool) -> void
-    def with_persistent: (bool) -> instance
 
     def ==: (untyped other) -> bool
     def merge: (_ToHash other) -> instance