httpx 0.10.0 → 0.10.1

data/lib/httpx/resolver/native.rb

@@ -15,7 +15,6 @@ module HTTPX
       "AAAA" => Resolv::DNS::Resource::IN::AAAA,
     }.freeze
 
-    # :nocov:
     DEFAULTS = if RUBY_VERSION < "2.2"
       {
         **Resolv::DNS::Config.default_config_hash,
@@ -44,7 +43,6 @@ module HTTPX
         false
       end
     end if DEFAULTS[:nameserver]
-    # :nocov:
 
     DNS_PORT = 53
 
@@ -53,15 +51,15 @@ module HTTPX
     def initialize(options)
       @options = Options.new(options)
       @ns_index = 0
-      @resolver_options = Resolver::Options.new(DEFAULTS.merge(@options.resolver_options || {}))
-      @nameserver = @resolver_options.nameserver
-      @_timeouts = Array(@resolver_options.timeouts)
+      @resolver_options = DEFAULTS.merge(@options.resolver_options)
+      @nameserver = @resolver_options[:nameserver]
+      @_timeouts = Array(@resolver_options[:timeouts])
       @timeouts = Hash.new { |timeouts, host| timeouts[host] = @_timeouts.dup }
-      @_record_types = Hash.new { |types, host| types[host] = @resolver_options.record_types.dup }
+      @_record_types = Hash.new { |types, host| types[host] = @resolver_options[:record_types].dup }
       @connections = []
       @queries = {}
       @read_buffer = "".b
-      @write_buffer = Buffer.new(@resolver_options.packet_size)
+      @write_buffer = Buffer.new(@resolver_options[:packet_size])
       @state = :idle
     end
 
@@ -111,9 +109,9 @@ module HTTPX
       return if early_resolve(connection)
 
       if @nameserver.nil?
-        ex = ResolveError.new("Can't resolve #{connection.origin.host}: no nameserver")
+        ex = ResolveError.new("No available nameserver")
         ex.set_backtrace(caller)
-        emit(:error, connection, ex)
+        throw(:resolve_error, ex)
       else
         @connections << connection
         resolve
@@ -164,7 +162,7 @@ module HTTPX
       connections.each { |ch| resolve(ch) }
     end
 
-    def dread(wsize = @resolver_options.packet_size)
+    def dread(wsize = @resolver_options[:packet_size])
       loop do
         siz = @io.read(wsize, @read_buffer)
         return unless siz && siz.positive?
@@ -199,13 +197,14 @@ module HTTPX
         end
       end
 
-      if addresses.empty?
+      if addresses.nil? || addresses.empty?
         hostname, connection = @queries.first
         @_record_types[hostname].shift
         if @_record_types[hostname].empty?
           @queries.delete(hostname)
           @_record_types.delete(hostname)
           @connections.delete(connection)
+
           raise NativeResolveError.new(connection, hostname)
         end
       else
@@ -223,7 +222,7 @@ module HTTPX
           end
         else
           @connections.delete(connection)
-          Resolver.cached_lookup_set(connection.origin.host, addresses) if @resolver_options.cache
+          Resolver.cached_lookup_set(connection.origin.host, addresses) if @resolver_options[:cache]
           emit_addresses(connection, addresses.map { |addr| addr["data"] })
         end
       end
@@ -243,7 +242,7 @@ module HTTPX
         log { "resolver: resolve IDN #{connection.origin.non_ascii_hostname} as #{hostname}" } if connection.origin.non_ascii_hostname
       end
       @queries[hostname] = connection
-      type = @_record_types[hostname].first
+      type = @_record_types[hostname].first || "A"
       log { "resolver: query #{type} for #{hostname}" }
       begin
         @write_buffer << Resolver.encode_dns_query(hostname, type: RECORD_TYPES[type])

data/lib/httpx/resolver/resolver_mixin.rb

@@ -38,7 +38,7 @@ module HTTPX
       def early_resolve(connection, hostname: connection.origin.host)
         addresses = connection.addresses ||
                     ip_resolve(hostname) ||
-                    (@resolver_options.cache && Resolver.cached_lookup(hostname)) ||
+                    (@resolver_options[:cache] && Resolver.cached_lookup(hostname)) ||
                     system_resolve(hostname)
         return unless addresses
 
@@ -57,11 +57,13 @@ module HTTPX
         ips.map { |ip| IPAddr.new(ip) }
       end
 
-      def emit_resolve_error(connection, hostname, ex = nil)
+      def emit_resolve_error(connection, hostname = connection.origin.host, ex = nil)
         emit(:error, connection, resolve_error(hostname, ex))
       end
 
       def resolve_error(hostname, ex = nil)
+        return ex if ex.is_a?(ResolveError)
+
         message = ex ? ex.message : "Can't resolve #{hostname}"
         error = ResolveError.new(message)
         error.set_backtrace(ex ? ex.backtrace : caller)

data/lib/httpx/resolver/system.rb

@@ -14,9 +14,9 @@ module HTTPX
 
     def initialize(options)
       @options = Options.new(options)
-      @resolver_options = Resolver::Options.new(@options.resolver_options)
+      @resolver_options = @options.resolver_options
       @state = :idle
-      resolv_options = @resolver_options.to_h
+      resolv_options = @resolver_options.dup
       timeouts = resolv_options.delete(:timeouts)
       resolv_options.delete(:cache)
       @resolver = Resolv::DNS.new(resolv_options.empty? ? nil : resolv_options)

data/lib/httpx/selector.rb

@@ -4,19 +4,14 @@ require "io/wait"
 
 module IOExtensions
   refine IO do
-    def wait(timeout = nil, mode = :read)
-      case mode
-      when :read
-        wait_readable(timeout)
-      when :write
-        wait_writable(timeout)
-      when :read_write
-        r, w = IO.select([self], [self], nil, timeout)
-
-        return unless r || w
-
-        self
-      end
+    # provides a fallback for rubies where IO#wait isn't implemented,
+    # but IO#wait_readable and IO#wait_writable are.
+    def wait(timeout = nil, _mode = :read_write)
+      r, w = IO.select([self], [self], nil, timeout)
+
+      return unless r || w
+
+      self
     end
   end
 end

data/lib/httpx/session.rb

@@ -77,10 +77,16 @@ module HTTPX
     end
 
     def set_connection_callbacks(connection, connections, options)
-      connection.on(:uncoalesce) do |uncoalesced_uri|
-        other_connection = build_connection(uncoalesced_uri, options)
+      connection.on(:misdirected) do |misdirected_request|
+        other_connection = connection.create_idle(ssl: { alpn_protocols: %w[http/1.1] })
+        other_connection.merge(connection)
+        catch(:coalesced) do
+          pool.init_connection(other_connection, options)
+        end
+        set_connection_callbacks(other_connection, connections, options)
         connections << other_connection
-        connection.unmerge(other_connection)
+        misdirected_request.transition(:idle)
+        other_connection.send(misdirected_request)
       end
       connection.on(:altsvc) do |alt_origin, origin, alt_params|
         other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)

data/lib/httpx/transcoder.rb

@@ -3,6 +3,24 @@
 module HTTPX
   module Transcoder
     extend Registry
+
+    def self.normalize_keys(key, value, &block)
+      if value.respond_to?(:to_ary)
+        if value.empty?
+          block.call("#{key}[]")
+        else
+          value.to_ary.each do |element|
+            normalize_keys("#{key}[]", element, &block)
+          end
+        end
+      elsif value.respond_to?(:to_hash)
+        value.to_hash.each do |child_key, child_value|
+          normalize_keys("#{key}[#{child_key}]", child_value, &block)
+        end
+      else
+        block.call(key.to_s, value)
+      end
+    end
   end
 end
 

data/lib/httpx/transcoder/form.rb

@@ -12,10 +12,18 @@ module HTTPX::Transcoder
 
       def_delegator :@raw, :to_s
 
+      def_delegator :@raw, :to_str
+
       def_delegator :@raw, :bytesize
 
       def initialize(form)
-        @raw = URI.encode_www_form(form)
+        @raw = form.each_with_object("".b) do |(key, val), buf|
+          HTTPX::Transcoder.normalize_keys(key, val) do |k, v|
+            buf << "&" unless buf.empty?
+            buf << URI.encode_www_form_component(k)
+            buf << "=#{URI.encode_www_form_component(v.to_s)}" unless v.nil?
+          end
+        end
       end
 
       def content_type

data/lib/httpx/version.rb

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

data/sig/connection.rbs

@@ -1,2 +1,85 @@
-class HTTPX::Connection
+module HTTPX
+  class Connection
+    interface _Parser
+
+      def on: (Symbol) { (*untyped) -> void } -> void
+      def empty?: () -> bool
+      def close: () -> void
+      def consume: () -> void
+      def <<: (string) -> void
+    end
+
+    include Loggable
+    include Callbacks
+    extend HTTPX::Registry[String, Class]
+
+    attr_reader origin: generic_uri 
+    attr_reader state: Symbol
+    attr_reader pending: Array[Request]
+    attr_reader options: options
+
+    def addresses: () -> Array[ipaddr]?
+
+    def addresses=: (Array[ipaddr]) -> void
+
+    def match?: (generic_uri, options) -> bool
+
+    def mergeable?: (Connection) -> bool
+
+    def coalescable?: (Connection) -> bool
+
+    def create_idle: (options) -> Connection
+                   | () -> Connection
+
+    def merge: (Connection) -> void
+
+    def purge_pending: () { (Request) -> void } -> void
+
+    def match_altsvcs?: (generic_uri) -> bool
+
+    def connecting?: () -> bool
+    def inflight?: () -> boolish
+
+    def interests: () -> io_interests?
+
+    def to_io: () -> _ToIO
+
+    def call: () -> void
+
+    def close: () -> void
+    def reset: () -> void
+
+    def send: (Request) -> void
+
+    def timeout: () -> Numeric?
+
+    private
+
+    def initialize: (String, generic_uri, options) -> untyped
+
+    def connect: () -> void
+
+    def exhausted?: () -> boolish
+
+    def consume: () -> void
+
+    def send_pending: () -> void
+
+    def parser: () -> _Parser
+
+    def build_parser: () -> _Parser
+                    | (String) -> _Parser
+
+    def set_parser_callbacks: (_Parser) -> void
+
+    def transition: (Symbol) -> void
+
+    def handle_response: () -> void
+
+    def on_error: (StandardError) -> void
+
+    def handle_error: (StandardError) -> void
+
+    def total_timeout: () -> Timers::Timer?
+  end
 end

data/sig/connection/http1.rbs

@@ -0,0 +1,66 @@
+module HTTPX
+  class Connection::HTTP1
+    include Callbacks
+    include Loggable
+
+    attr_reader pending: Array[Request]
+
+    @options: Options
+    @max_concurrent_requests: Integer
+    @max_requests: Integer
+    @parser: HTTP1
+    @buffer: Buffer
+
+    def interests: () -> io_interests?
+
+    def reset: () -> void
+
+    def close: () -> void
+
+    def empty?: () -> bool
+
+    def exhausted?: () -> bool
+
+    def <<: (String) -> void
+
+    def send: (Request) -> void
+
+    def consume: () -> void
+
+    def handle_error: (StandardError ex) -> void
+
+    def on_headers: (Hash[String, Array[String]] headers) -> void
+
+    def on_trailers: (Array[String, String] headers) -> void
+
+    def on_data: (string chunk) -> void
+
+    def on_complete: () -> void
+
+    def dispatch: () -> void
+
+    def ping: () -> void
+
+    private
+
+    def initialize: (Buffer, options) -> untyped
+
+    def manage_connection: (Response) -> void
+
+    def disable: () -> void
+
+    def disable_pipelining: () -> void
+
+    def set_request_headers: (Request) -> void
+
+    def headline_uri: (Request) -> String
+
+    def handle: (Request request) -> void
+
+    def join_headers: (Request request) -> void
+
+    def join_body: (Request request) -> void
+
+    def capitalized: (String field) -> String
+  end
+end

data/sig/connection/http2.rbs

@@ -1,4 +1,78 @@
 module HTTPX
   class Connection::HTTP2
+    include Callbacks
+    include Loggable
+
+    attr_reader streams: Hash[HTTP2Next::Stream, Response]
+    attr_reader pending: Array[Request]
+
+    @options: Options
+    @max_concurrent_requests: Integer
+    @max_requests: Integer
+    @drains: Hash[Request, String]
+    @pings: Array[String]
+    @buffer: Buffer
+
+    def interests: () -> io_interests
+
+    def close: () -> void
+
+    def empty?: () -> bool
+
+    def exhausted?: () -> bool
+
+    def <<: (String) -> void
+
+    def send: (Request) -> void
+
+    def consume: () -> void
+
+    def handle_error: (StandardError ex) -> void
+
+    def ping: () -> void
+
+    alias reset init_connection
+
+    private
+
+    def initialize: (Buffer, options) -> untyped
+
+    def send_pending: () -> void
+
+    def headline_uri: (Request) -> String
+
+    def set_request_headers: (Request) -> void
+
+    def handle: (Request request, HTTP2Next::Stream stream) -> void
+
+    def init_connection: () -> void
+
+    def handle_stream: (HTTP2Next::Stream stream, Request request) -> void
+
+    def join_headers: (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_data: (HTTP2Next::Stream stream, Request request, string data) -> void
+
+    # def on_stream_close: (HTTP2Next::Stream stream, Request request, Symbol? error) -> void
+
+    def on_frame: (string bytes) -> void
+
+    def on_settings: (*untyped) -> void
+
+    def on_close: (Integer last_frame, Symbol? error, String? payload) -> void
+
+    def on_frame_sent: (HTTP2Next::frame) -> void
+    def on_frame_received: (HTTP2Next::frame) -> void
+
+    def on_promise: (HTTP2Next::Stream) -> void
+
+    def on_origin: (String) -> void
+
+    def on_pong: (string ping) -> void
   end
 end