httpx 0.18.6 → 0.19.2

data/sig/parser/http1.rbs

@@ -1,5 +1,8 @@
 module HTTPX
   module Parser
+    class Error < HTTPX::Error
+    end
+
     type parsed_headers = Hash[String, Array[String]]
 
     interface _HTTP1Events
@@ -14,16 +17,22 @@ module HTTPX
     class HTTP1
       VERSIONS: Array[String]
 
-      def <<: (String chunk) -> void
+      attr_reader status_code: Integer
+      attr_reader http_version: [Integer, Integer]
+      attr_reader headers: parsed_headers
 
-      def headers: () -> parsed_headers
+      @observer: _HTTP1Events
+      @state: Symbol
+      @buffer: String
+      @content_type: String?
+      @content_length: Integer
+      @_has_trailers: bool
+      @upgrade: bool
 
-      def http_version: () -> Array[1 | 0]
+      def <<: (String chunk) -> void
 
       def reset!: () -> void
 
-      def status_code: () -> Integer
-
       def upgrade?: () -> bool
 
       def upgrade_data: () -> String

data/sig/pool.rbs

@@ -1,14 +1,22 @@
 module HTTPX
   class Pool
+    type resolver_manager = Resolver::Multi | Resolver::System
+
+    @resolvers: Hash[Class, resolver_manager]
+    @timers: Timers
+    @selector: Selector
+    @connections: Array[Connection]
+    @connected_connections: Integer
+
     def empty?: () -> void
 
     def next_tick: () -> void
 
-    def close: (*Array[Connection]) -> void
+    def close: (?Array[Connection] connections) -> void
 
-    def init_connection: (Connection, Options) -> void
+    def init_connection: (Connection connection, Options options) -> void
 
-    def find_connection: (generic_uri, Options) -> Connection?
+    def find_connection: (URI::Generic uri, Options options) -> Connection?
 
     def deactivate: (*Array[Connection]) -> void
 
@@ -22,20 +30,20 @@ module HTTPX
 
     def on_resolver_error: (Connection, StandardError) -> void
 
-    def on_resolver_close: (resolver) -> void
+    def on_resolver_close: (Resolver::Resolver) -> void
 
     def register_connection: (Connection) -> void
 
     def unregister_connection: (Connection) -> void
 
-    def select_connection: (resolver | Connection connection) -> void
+    def select_connection: (Resolver::Resolver | Connection connection) -> void
 
-    def deselect_connection: (resolver | Connection connection) -> void
+    def deselect_connection: (Resolver::Resolver | Connection connection) -> void
 
-    def coalesce_connections: (Connection, Connection) -> void
+    def coalesce_connections: (Connection coalescable, Connection coalescing) -> void
 
-    def next_timeout: () -> Numeric?
+    def next_timeout: () -> (Integer | Float | nil)
 
-    def find_resolver_for: (Connection) -> resolver
+    def find_resolver_for: (Connection) { (Resolver::Resolver resolver) -> void } -> resolver_manager
   end
 end

data/sig/registry.rbs

@@ -1,4 +1,7 @@
 module HTTPX::Registry[T, V]
+  class Error < HTTPX::Error
+  end
+
   # type registrable = Symbol | String | Class
 
   def self.registry: (T tag) -> Class

data/sig/request.rbs

@@ -15,6 +15,11 @@ module HTTPX
     attr_reader response: response?
     attr_reader drain_error: StandardError?
 
+    @trailers: Headers?
+    @informational_status: Integer?
+    @query: String?
+    @drainer: Enumerator[String, void]?
+
     def initialize: (Symbol | String, generic_uri, ?options) -> untyped
 
     def interests: () -> (:r | :w)
@@ -46,6 +51,10 @@ module HTTPX
     def trailers?: () -> boolish
 
     class Body
+      @headers: Headers
+      @body: body_encoder?
+      @unbounded_body: bool
+
       def initialize: (Headers, Options) -> untyped
       def each: () { (String) -> void } -> void
               | () -> Enumerable[String]
@@ -61,6 +70,8 @@ module HTTPX
     end
 
     class ProcIO
+      @block: ^(String) -> void
+
       def initialize: (^(String) -> void) -> untyped
 
       def write: (String data) -> Integer

data/sig/resolver/https.rbs

@@ -1,49 +1,37 @@
 module HTTPX
   module Resolver
-    class HTTPS
-      include ResolverMixin
-      include _ToIO
+    class HTTPS < Resolver
+      NAMESERVER: String
 
+      DEFAULTS: Hash[Symbol, untyped]
+      FAMILY_TYPES: Hash[singleton(Resolv::DNS::Resource), String]
+
+      @family: ip_family
       @options: Options
-      @resolver_options: Hash[Symbol, untyped]
-      @_record_types: Hash[String, Hash["A" | "AAAA", dns_resource]]
-      @queries: Hash[String, Connection]
       @requests: Hash[Request, Connection]
       @connections: Array[Connection]
-      @uri: URI::HTTPS
+      @uri: URI::Generic
       @uri_addresses: Array[String]?
+      @resolver: Resolv::DNS
+      @resolver_connection: Connection
 
-      def <<: (Connection) -> void
-
-      def timeout: () -> Numeric?
-
-      def closed?: () -> bool
-
-      def empty?: () -> bool
+      attr_writer pool: Pool
 
-      def close: () -> void
-
-      def call: () -> void
-
-      def interests: () -> io_interests?
+      def <<: (Connection) -> void
 
       private
 
-      def initialize: (options) -> untyped
-
-      def pool: () -> Pool
+      def initialize: (ip_family family, options options) -> void
 
       def resolver_connection: () -> Connection
 
-      def resolve: (Connection, String hostname) -> void
-                 | (Connection) -> void
-                 | () -> void
+      def resolve: (?Connection connection, ?String? hostname) -> void
 
       def on_response: (Request, response) -> void
 
-      def response: (Response) -> void
+      def parse: (Response response) -> void
 
-      def build_request: (String hostname, "A" | "AAAA") -> Request
+      def build_request: (String hostname) -> Request
 
       def decode_response_body: (Response) -> Array[dns_result]
     end

data/sig/resolver/multi.rbs

@@ -0,0 +1,7 @@
+module HTTPX
+  module Resolver
+    class Multi
+      def early_resolve: (Connection connection, ?hostname: String) -> void
+    end
+  end
+end

data/sig/resolver/native.rbs

@@ -1,33 +1,24 @@
 module HTTPX
   module Resolver
-    class Native
+    class Native < Resolver
       extend Forwardable
-      include ResolverMixin
       include _ToIO
 
       DEFAULTS: Hash[Symbol, untyped]
       DNS_PORT: Integer
 
+      @family: ip_family
       @options: Options
       @ns_index: Integer
-      @resolver_options: Hash[Symbol, untyped]
       @nameserver: String
       @_timeouts: Array[Numeric]
       @timeouts: Hash[String, Array[Numeric]]
-      @_record_types: Hash[String, Hash["A" | "AAAA", dns_resource]]
       @connections: Array[Connection]
-      @queries: Hash[String, Connection]
       @read_buffer: String
       @write_buffer: Buffer
 
       attr_reader state: Symbol
 
-      def closed?: () -> bool
-
-      def empty?: () -> bool
-
-      def close: () -> void
-
       def call: () -> void
 
       def interests: () -> io_interests
@@ -38,7 +29,7 @@ module HTTPX
 
       private
 
-      def initialize: (options) -> untyped
+      def initialize: (ip_family family, options options) -> void
 
       def calculate_interests: () -> (:r | :w)
 

data/sig/resolver/resolver.rbs

@@ -0,0 +1,36 @@
+module HTTPX
+  module Resolver
+    class Resolver
+      include Callbacks
+      include Loggable
+
+      RECORD_TYPES: Hash[Integer, singleton(Resolv::DNS::Resource)]
+
+      attr_reader family: ip_family
+
+      @record_type: singleton(Resolv::DNS::Resource)
+      @options: Options
+      @resolver_options: Hash[Symbol, untyped]
+      @queries: Hash[String, Connection]
+      @system_resolver: Resolv::Hosts
+
+      def close: () -> void
+
+      def closed?: () -> bool
+
+      def empty?: () -> bool
+
+      def emit_addresses: (Connection connection, ip_family family, Array[IPAddr]) -> void
+
+      private
+
+      def initialize: (ip_family? family, options options) -> void
+
+      def early_resolve: (Connection connection, ?hostname: String) -> void
+
+      def emit_resolve_error: (Connection connection, ?String hostname, ?StandardError) -> void
+
+      def resolve_error: (String hostname, ?StandardError?) -> ResolveError
+    end
+  end
+end

data/sig/resolver/system.rbs

@@ -1,21 +1,15 @@
 module HTTPX
   module Resolver
-    class System
-      include ResolverMixin
-
+    class System < Resolver
       RESOLV_ERRORS: Array[singleton(StandardError)] # ResolvError
 
-      attr_reader state: Symbol
-
-      def closed?: () -> true
-
-      def empty?: () -> true
+      @resolver: Resolv::DNS
 
       def <<: (Connection) -> void
 
       private
 
-      def initialize: (options) -> untyped
+      def initialize: (options options) -> void
     end
   end
 end

data/sig/resolver.rbs

@@ -1,28 +1,30 @@
 module HTTPX
   type ipaddr = IPAddr | String
 
-  type resolver = Resolver::System | Resolver::Native | Resolver::HTTPS
-
   module Resolver
-    RESOLVE_TIMEOUT: Integer | Float
+    extend Registry[Symbol, Class]
 
-    def self.registry: (Symbol tag) -> Class
-    | () -> Hash[Symbol, Class]
+    RESOLVE_TIMEOUT: Integer | Float
 
-    def self.register: (Symbol tag,  Class handler) -> void
+    @lookup_mutex: Thread::Mutex
 
     type dns_resource = singleton(Resolv::DNS::Resource)
 
     type dns_result = { "name" => String, "TTL" => Numeric, "alias" => String }
                     | { "name" => String, "TTL" => Numeric, "data" => String }
 
-    def self?.cached_lookup: (String hostname) -> Array[String]?
 
-    def self?.cached_lookup_set: (String hostname, Array[dns_result] addresses) -> void
+    def nolookup_resolve: (String hostname) -> Array[IPAddr]
+
+    def ip_resolve: (String hostname) -> Array[IPAddr]?
+
+    def system_resolve: (String hostname) -> Array[IPAddr]?
+
+    def self?.cached_lookup: (String hostname) -> Array[IPAddr]?
 
-    def self?.uncache: (String hostname) -> void
+    def self?.cached_lookup_set: (String hostname, ip_family family, Array[dns_result] addresses) -> void
 
-    def self?.lookup: (String hostname, Numeric ttl) -> Array[String]?
+    def self?.lookup: (String hostname, Numeric ttl) -> Array[IPAddr]?
 
     def self?.generate_id: () -> Integer
 

data/sig/response.rbs

@@ -19,6 +19,7 @@ module HTTPX
 
     @options: Options
     @request: Request
+    @content_type: ContentType
 
     def copy_to: (_ToPath | _Writer destination) -> void
     def close: () -> void
@@ -45,9 +46,15 @@ module HTTPX
       include _ToS
       include _ToStr
 
+      @response: Response
+      @headers: Headers
+      @options: Options
       @state: :idle | :memory | :buffer | :closed
       @threshold_size: Integer
       @window_size: Integer
+      @encoding: String
+      @length: Integer
+      @buffer: StringIO | Tempfile | nil
 
       def write:(String chunk) -> Integer?
 
@@ -65,6 +72,7 @@ module HTTPX
       def initialize: (Response, Options) -> untyped
       def rewind: () -> void
       def transition: () -> void
+      def _with_same_buffer_pos: [A] () { () -> A } -> A
     end
   end
 
@@ -72,12 +80,13 @@ module HTTPX
     MIME_TYPE_RE: Regexp
     CHARSET_RE: Regexp
 
-    attr_reader mime_type: String?
-    attr_reader charset: String?
+    @header_value: String?
+    @mime_type: String?
+    @charset: String?
 
-    def self.parse: (_ToS) -> ContentType
-    def self.mime_type: (_ToS) -> String?
-    def self.charset: (_ToS) -> String?
+    def mime_type: () -> String?
+
+    def charset: () -> String?
 
     private
 
@@ -89,6 +98,7 @@ module HTTPX
     include Loggable
 
     @options: Options
+    @error: Exception
 
     attr_reader request: Request
 

data/sig/selector.rbs

@@ -1,13 +1,13 @@
 module HTTPX
   class Selector
-    type selectable = Connection | Resolver::Native | Resolver::HTTPS
+    type selectable = Connection | Resolver::Native | Resolver::System
 
     READABLE: Array[Symbol]
     WRITABLE: Array[Symbol]
     @selectables: Array[selectable]
 
-    def register: (selectable) -> void
-    def deregister: (selectable) -> void
+    def register: (selectable io) -> void
+    def deregister: (selectable io) -> void
 
     def select: (Numeric? interval) { (selectable) -> void } -> void
 

data/sig/timers.rbs

@@ -1,12 +1,13 @@
 module HTTPX
   class Timers
-    @interval: Array[Interval]
+    @intervals: Array[Interval]
+    @next_interval_at: Numeric
 
     def after: (Numeric interval_in_secs) { () -> void } -> void
 
     def wait_interval: () -> Numeric?
 
-    def fire: (?StandardError error) -> void
+    def fire: (?TimeoutError error) -> void
 
     def cancel: () -> void
 
@@ -19,6 +20,8 @@ module HTTPX
 
       attr_reader interval: Numeric
 
+      @callbacks: Array[^() -> void]
+
       def to_f: () -> Float
 
       def <<: (^() -> void) -> void

data/sig/transcoder/chunker.rbs

@@ -10,27 +10,38 @@ module HTTPX::Transcoder
     class Encoder
       @raw: _Each[String]
 
-      include _Each[String]
+      def each: () { (String) -> void } -> void
+              | () -> Enumerator[String, void]
 
       private
 
-      def initialize: (_Each[String] chunks) -> untyped
+      def initialize: (_Each[String] chunks) -> void
     end
 
     class Decoder
       extend Forwardable
       include _ToS
-      include _Each[String]
+
+      @buffer: String
+      @chunk_length: Integer
+      @chunk_buffer: String
+      @finished: bool
+      @state: Symbol
+      @trailers: bool
+
+      def each: () { (String) -> void } -> void
 
       def finished?: () -> bool
+
       def empty?: () -> bool
+
       def <<: (string) -> void
+
       def clear: () -> void
 
       private
 
-      def initialize: (String, bool) -> untyped
-                    | (String) -> untyped
+      def initialize: (String, ?bool) -> void
 
       def nextstate: (Symbol) -> void
     end

data/sig/transcoder/json.rbs

@@ -1,5 +1,7 @@
 module HTTPX::Transcoder
   module JSON
+    JSON_REGEX: Regexp
+
     def self?.encode: (_ToJson json) -> Encoder
     def self?.decode: (HTTPX::Response response) -> _Decoder
 
@@ -8,6 +10,9 @@ module HTTPX::Transcoder
       include _Encoder
       include _ToS
 
+      @raw: String
+      @charset: String
+
       def content_type: () -> String
 
       private

data/sig/transcoder.rbs

@@ -1,6 +1,8 @@
 module HTTPX
   type bodyIO = _Reader | _Each[[String, untyped]] | _ToS
 
+  type body_encoder = Transcoder::_Encoder | _Each[String]
+
   module Transcoder
     def self?.registry: (String tag) -> _Encode
                    | () -> Hash[String, _Encode]
@@ -12,7 +14,7 @@ module HTTPX
     def self?.normalize_query: (Hash[String, untyped] params, String name, String v, Integer depth) -> void
 
     interface _Encode
-      def encode: (untyped payload) -> (_Encoder | _Each[String])
+      def encode: (untyped payload) -> body_encoder
     end
 
     interface _Encoder

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: httpx
 version: !ruby/object:Gem::Version
-  version: 0.18.6
+  version: 0.19.2
 platform: ruby
 authors:
 - Tiago Cardoso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-12 00:00:00.000000000 Z
+date: 2022-02-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: http-2-next
@@ -69,6 +69,10 @@ extra_rdoc_files:
 - doc/release_notes/0_18_4.md
 - doc/release_notes/0_18_5.md
 - doc/release_notes/0_18_6.md
+- doc/release_notes/0_18_7.md
+- doc/release_notes/0_19_0.md
+- doc/release_notes/0_19_1.md
+- doc/release_notes/0_19_2.md
 - doc/release_notes/0_1_0.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
@@ -131,6 +135,10 @@ files:
 - doc/release_notes/0_18_4.md
 - doc/release_notes/0_18_5.md
 - doc/release_notes/0_18_6.md
+- doc/release_notes/0_18_7.md
+- doc/release_notes/0_19_0.md
+- doc/release_notes/0_19_1.md
+- doc/release_notes/0_19_2.md
 - doc/release_notes/0_1_0.md
 - doc/release_notes/0_2_0.md
 - doc/release_notes/0_2_1.md
@@ -227,13 +235,15 @@ files:
 - lib/httpx/request.rb
 - lib/httpx/resolver.rb
 - lib/httpx/resolver/https.rb
+- lib/httpx/resolver/multi.rb
 - lib/httpx/resolver/native.rb
-- lib/httpx/resolver/resolver_mixin.rb
+- lib/httpx/resolver/resolver.rb
 - lib/httpx/resolver/system.rb
 - lib/httpx/response.rb
 - lib/httpx/selector.rb
 - lib/httpx/session.rb
 - lib/httpx/session2.rb
+- lib/httpx/session_extensions.rb
 - lib/httpx/timers.rb
 - lib/httpx/transcoder.rb
 - lib/httpx/transcoder/body.rb
@@ -290,8 +300,9 @@ files:
 - sig/request.rbs
 - sig/resolver.rbs
 - sig/resolver/https.rbs
+- sig/resolver/multi.rbs
 - sig/resolver/native.rbs
-- sig/resolver/resolver_mixin.rbs
+- sig/resolver/resolver.rbs
 - sig/resolver/system.rbs
 - sig/response.rbs
 - sig/selector.rbs

data/lib/httpx/resolver/resolver_mixin.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require "resolv"
-require "ipaddr"
-
-module HTTPX
-  module Resolver
-    module ResolverMixin
-      include Callbacks
-      include Loggable
-
-      CHECK_IF_IP = lambda do |name|
-        begin
-          IPAddr.new(name)
-          true
-        rescue ArgumentError
-          false
-        end
-      end
-
-      def uncache(connection)
-        hostname = hostname || @queries.key(connection) || connection.origin.host
-        Resolver.uncache(hostname)
-        @_record_types[hostname].shift
-      end
-
-      private
-
-      def emit_addresses(connection, addresses)
-        addresses.map! do |address|
-          address.is_a?(IPAddr) ? address : IPAddr.new(address.to_s)
-        end
-        log { "resolver: answer #{connection.origin.host}: #{addresses.inspect}" }
-        connection.addresses = addresses
-        catch(:coalesced) { emit(:resolve, connection) }
-      end
-
-      def early_resolve(connection, hostname: connection.origin.host)
-        addresses = connection.addresses ||
-                    ip_resolve(hostname) ||
-                    (@resolver_options[:cache] && Resolver.cached_lookup(hostname)) ||
-                    system_resolve(hostname)
-        return unless addresses
-
-        emit_addresses(connection, addresses)
-      end
-
-      def ip_resolve(hostname)
-        [hostname] if CHECK_IF_IP[hostname]
-      end
-
-      def system_resolve(hostname)
-        @system_resolver ||= Resolv::Hosts.new
-        ips = @system_resolver.getaddresses(hostname)
-        return if ips.empty?
-
-        ips.map { |ip| IPAddr.new(ip) }
-      rescue IOError
-      end
-
-      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)
-        error
-      end
-    end
-  end
-end