httpx 0.21.0 → 1.2.1

data/sig/connection/http2.rbs

@@ -38,7 +38,7 @@ module HTTPX
 
     alias reset init_connection
 
-    def timeout: () -> Numeric
+    def timeout: () -> Numeric?
 
     private
 

data/sig/connection.rbs

@@ -17,10 +17,9 @@ module HTTPX
     extend Forwardable
     include Loggable
     include Callbacks
-    include HTTPX::Registry[String, Class]
 
-    BUFFER_SIZE: Integer
 
+    attr_reader type: io_type
     attr_reader origin: URI::Generic
     attr_reader origins: Array[String]
     attr_reader state: Symbol
@@ -28,33 +27,40 @@ module HTTPX
     attr_reader options: Options
     attr_writer timers: Timers
 
-    @type: io_type
+    attr_accessor family: Integer?
+
     @window_size: Integer
     @read_buffer: Buffer
     @write_buffer: Buffer
     @inflight: Integer
     @keep_alive_timeout: Numeric?
-    @total_timeout: Numeric?
+    @timeout: Numeric?
+    @current_timeout: Numeric?
+    @io: TCP | SSL | UNIX
+    @parser: HTTP1 | HTTP2 | _Parser
+    @connected_at: Float
+    @response_received_at: Float
+    @intervals: Array[Timers::Interval]
 
     def addresses: () -> Array[ipaddr]?
 
-    def addresses=: (Array[ipaddr]) -> void
+    def addresses=: (Array[ipaddr] addresses) -> void
 
-    def match?: (URI::Generic uri, Options options) -> bool
+    def send: (Request request) -> void
 
-    def mergeable?: (Connection) -> bool
+    def match?: (URI::Generic uri, Options options) -> bool
 
-    def coalescable?: (Connection) -> bool
+    def expired?: () -> boolish
 
-    def create_idle: (?Hash[Symbol, untyped] options) -> Connection
+    def mergeable?: (Connection connection) -> bool
 
-    def merge: (Connection) -> void
+    def coalescable?: (Connection connection) -> bool
 
-    def purge_pending: () { (Request) -> void } -> void
+    def create_idle: (?Hash[Symbol, untyped] options) -> Connection
 
-    def match_altsvcs?: (URI::Generic uri) -> bool
+    def merge: (Connection connection) -> void
 
-    def match_altsvc_options?: (URI::Generic uri, Options options) -> bool
+    def purge_pending: () { (Request request) -> void } -> void
 
     def connecting?: () -> bool
 
@@ -66,20 +72,29 @@ module HTTPX
 
     def call: () -> void
 
+    def terminate: () -> void
+
     def close: () -> void
-    def reset: () -> void
 
-    def send: (Request) -> void
+    def reset: () -> void
 
     def timeout: () -> Numeric?
 
+    def idling: () -> void
+
+    def used?: () -> boolish
+
     def deactivate: () -> void
 
-    def raise_timeout_error: (Numeric interval) -> void
+    def open?: () -> bool
+
+    def handle_socket_timeout: (Numeric interval) -> void
 
     private
 
-    def initialize: (io_type, URI::Generic, options) -> untyped
+    def initialize: (URI::Generic uri, options) -> void
+
+    def initialize_type: (URI::Generic uri, options) -> io_type
 
     def connect: () -> void
 
@@ -89,20 +104,23 @@ module HTTPX
 
     def send_pending: () -> void
 
-    def parser: () -> _Parser
+    def parser: () -> (HTTP1 | HTTP2 | _Parser)
 
     def send_request_to_parser: (Request request) -> void
 
-    def build_parser: () -> _Parser
-                    | (String) -> _Parser
+    def build_parser: (?String protocol) -> (HTTP1 | HTTP2)
 
-    def set_parser_callbacks: (_Parser) -> void
+    def set_parser_callbacks: (HTTP1 | HTTP2 parser) -> void
 
-    def transition: (Symbol) -> void
+    def transition: (Symbol nextstate) -> void
 
-    def on_error: (HTTPX::TimeoutError | Error | StandardError) -> void
+    def handle_transition: (Symbol nextstate) -> void
 
-    def handle_error: (StandardError) -> void
+    def build_socket: (?Array[ipaddr]? addrs) -> (TCP | SSL | UNIX)
+
+    def on_error: (HTTPX::TimeoutError | Error | StandardError error) -> void
+
+    def handle_error: (StandardError error) -> void
 
     def purge_after_closed: () -> void
 
@@ -111,5 +129,9 @@ module HTTPX
     def write_timeout_callback: (Request request, Numeric write_timeout) -> void
 
     def read_timeout_callback: (Request request, Numeric read_timeout, ?singleton(RequestTimeoutError) error_type) -> void
+
+    def set_request_timeout: (Request request, Numeric timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
+
+    def self.parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
   end
 end

data/sig/errors.rbs

@@ -2,6 +2,12 @@ module HTTPX
   class Error < StandardError
   end
 
+  class UnsupportedSchemeError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
   class TimeoutError < Error
     attr_reader timeout: Numeric
 
@@ -11,9 +17,6 @@ module HTTPX
     def initialize: (Numeric timeout, String message) -> untyped
   end
 
-  class TotalTimeoutError < TimeoutError
-  end
-
   class ConnectTimeoutError < TimeoutError
   end
 
@@ -55,4 +58,7 @@ module HTTPX
 
     def initialize: (Connection connection, String hostname, ?String message) -> untyped
   end
+
+  class MisdirectedRequestError < HTTPError
+  end
 end

data/sig/httpx.rbs

@@ -5,12 +5,13 @@ module HTTPX
 
   VERSION: String
 
-  type uri = URI::HTTP | URI::HTTPS | string
+  type http_uri = URI::HTTP | URI::HTTPS
+  type uri = http_uri | string
   type generic_uri = String | URI::Generic
 
-  type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
-              :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
-              :acl | :report | :patch | :search
+  type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |
+              "PROPFIND" | "PROPPATCH" | "MKCOL" | "COPY" | "MOVE" | "LOCK" | "UNLOCK" | "ORDERPATCH" |
+              "ACL" | "REPORT" | "PATCH" | "SEARCH"
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 

data/sig/io/ssl.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+
+  class TLSError < OpenSSL::SSL::SSLError
+  end
+
+  class SSL < TCP
+    TLS_OPTIONS: Hash[Symbol, untyped]
+
+    @ctx: OpenSSL::SSL::SSLContext
+    @verify_hostname: bool
+
+    attr_writer ssl_session: OpenSSL::SSL::Session?
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    # def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (self) -> void } -> void
+
+    def can_verify_peer?: () -> bool
+
+    def verify_hostname: (String host) -> bool
+
+    def ssl_session_expired?: () -> boolish
+
+    # :nocov:
+    def try_ssl_connect: () -> void
+  end
+end

data/sig/io/tcp.rbs

@@ -0,0 +1,60 @@
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader ip: ipaddr?
+
+    attr_reader port: Integer
+
+    attr_reader addresses: Array[ipaddr]
+
+    attr_reader state: Symbol
+
+    attr_reader interests: io_interests
+
+    alias host ip
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (self) -> void } -> void
+
+    def add_addresses: (Array[ipaddr] addrs) -> void
+
+    def to_io: () -> ::IO
+
+    def protocol: () -> String
+
+    def connect: () -> void
+
+    private
+
+    # :nocov:
+    def try_connect: () -> void
+
+    public
+
+    def read: (Integer size, ?(Buffer | String) buffer) -> (0 | nil | untyped)
+
+    def write: (Buffer buffer) -> Integer?
+
+    def close: () -> void
+
+    def connected?: () -> bool
+
+    def expired?: () -> boolish
+
+    def closed?: () -> bool
+
+    # :nocov:
+    def inspect: () -> ::String
+
+    private
+
+    def build_socket: () -> Socket
+
+    def transition: (Symbol nextstate) -> void
+
+    def do_transition: (Symbol nextstate) -> void
+
+    def log_transition_state: (Symbol nextstate) -> void
+  end
+end

data/sig/io/udp.rbs

@@ -0,0 +1,20 @@
+module HTTPX
+  class UDP
+    include Loggable
+
+    def initialize: (String ip, Integer port, Options options) -> void
+
+    def to_io: () -> ::IO
+
+    def connect: () -> void
+
+    def connected?: () -> bool
+
+    # :nocov:
+    def close: () -> void
+
+    def read: (Integer size, ?(Buffer | String) buffer) -> Integer?
+
+    def write: (Buffer buffer) -> Integer?
+  end
+end

data/sig/io/unix.rbs

@@ -0,0 +1,10 @@
+module HTTPX
+  class UNIX < TCP
+
+    attr_reader path: String
+
+    alias host path
+
+    def initialize: (http_uri origin, Array[String]? addresses, options options) -> void
+  end
+end

data/sig/options.rbs

@@ -2,21 +2,22 @@ module HTTPX
   class Options
     # include _ToHash
 
+    BUFFER_SIZE: Integer
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
     CONNECT_TIMEOUT: Integer
     OPERATION_TIMEOUT: Integer
     KEEP_ALIVE_TIMEOUT: Integer
     SETTINGS_TIMEOUT: Integer
+    CLOSE_HANDSHAKE_TIMEOUT: Integer
     DEFAULT_OPTIONS: Hash[Symbol, untyped]
+    REQUEST_BODY_IVARS: Array[Symbol]
 
-    type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout | :read_timeout | :write_timeout | :request_timeout
-    type timeout = Hash[timeout_type, Numeric]
+    type timeout_type = :connect_timeout | :settings_timeout | :close_handshake_timeout | :operation_timeout | :keep_alive_timeout | :read_timeout | :write_timeout | :request_timeout
+    type timeout = Hash[timeout_type, Numeric?]
 
     def self.new: (?options) -> instance
 
-    def self.def_option: (Symbol, ?String) -> void
-                       | (Symbol) { (*nil) -> untyped } -> void
     # headers
     attr_reader uri: URI?
 
@@ -33,23 +34,32 @@ module HTTPX
     attr_reader max_concurrent_requests: Integer?
 
     # max_requests
-    attr_reader max_requests: Integer?
+    attr_reader max_requests: Numeric?
 
     # window_size
     attr_reader window_size: Integer
 
+    # buffer_size
+    attr_reader buffer_size: Integer
+
     # body_threshold_size
     attr_reader body_threshold_size: Integer
 
     # transport
-    attr_reader transport: String?
-
-    # transport_options
-    attr_reader transport_options: Hash[untyped, untyped]?
+    attr_reader transport: "unix" | nil
 
     # addresses
     attr_reader addresses: Array[ipaddr]?
 
+    # supported_compression_formats
+    attr_reader supported_compression_formats: Array[String]
+
+    # compress_request_body
+    attr_reader compress_request_body: bool
+
+    # decompress_response_body
+    attr_reader decompress_response_body: bool
+
     # params
     attr_reader params: Transcoder::urlencoded_input?
 
@@ -112,17 +122,23 @@ module HTTPX
     # ip_families
     attr_reader ip_families: Array[ip_family]
 
-    def ==: (untyped other) -> bool
+    def ==: (Options other) -> bool
+
+    def options_equals?: (Options other, ?Array[Symbol] ignore_ivars) -> bool
+
     def merge: (_ToHash[Symbol, untyped] other) -> instance
+
     def to_hash: () -> Hash[Symbol, untyped]
 
+    def extend_with_plugin_classes: (Module pl) -> void
+
     private
 
     REQUEST_IVARS: Array[Symbol]
 
-    def initialize: (?options options) -> untyped
+    def initialize: (?options options) -> void
 
-    def __initialize__: (?options options) -> untyped
+    def do_initialize: (?options options) -> void
   end
 
   type options = Options | Hash[Symbol, untyped]

data/sig/plugins/{authentication → auth}/basic.rbs

@@ -5,8 +5,6 @@ module HTTPX
         @user: String
         @password: String
 
-        def can_authenticate?: (String? authenticate) -> boolish
-
         def authenticate: (*untyped) -> String
 
         private

data/sig/plugins/{authentication → auth}/digest.rbs

@@ -4,6 +4,7 @@ module HTTPX
       class Digest
         @user: String
         @password: String
+        @hashed: bool
 
         def can_authenticate?: (String? authenticate) -> boolish
 
@@ -13,7 +14,7 @@ module HTTPX
 
         def generate_header: (String meth, String uri, String authenticate) -> String
 
-        def initialize: (string user, string password) -> void
+        def initialize: (string user, string password, ?hashed: bool, **untyped) -> void
 
         def make_cnonce: () -> String
 

data/sig/plugins/auth.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module Authorization
+      module InstanceMethods
+        def authorization: (string token) -> instance
+
+        def bearer_auth: (string token) -> instance
+      end
+    end
+
+    type sessionAuthorization = Session & Authorization::InstanceMethods
+  end
+end

data/sig/plugins/{basic_authentication.rbs → basic_auth.rbs}

@@ -6,10 +6,10 @@ module HTTPX
       def self.configure: (singleton(Session)) -> void
 
       module InstanceMethods
-        def basic_authentication: (string user, string password) -> instance
+        def basic_auth: (string user, string password) -> instance
       end
     end
 
-    type sessionBasicAuth = sessionAuthentication & Authentication::InstanceMethods & BasicAuth::InstanceMethods
+    type sessionBasicAuth = sessionAuthorization & BasicAuth::InstanceMethods
   end
 end

data/sig/plugins/brotli.rbs

@@ -0,0 +1,22 @@
+module HTTPX
+  module Plugins
+    module Brotli
+      def self?.load_dependencies: (singleton(Session)) -> void
+
+      def self?.encode: (body_encoder body) -> Deflater
+
+      def self?.decode: (HTTPX::Response response, ?bytesize: Integer) -> Transcoder::_Decoder
+
+      class Deflater < Transcoder::Deflater
+      end
+
+      module RequestBodyClassMethods
+        def initialize_deflater_body: (body_encoder body, Encoding | String encoding) -> body_encoder
+      end
+
+      module ResponseBodyClassMethods
+        def initialize_inflater_by_encoding: (Encoding | String encoding, Response response, ?bytesize: Integer) -> (Transcoder::_Decoder | Transcoder::GZIP::Inflater)
+      end
+    end
+  end
+end

data/sig/plugins/callbacks.rbs

@@ -0,0 +1,38 @@
+module HTTPX
+  module Plugins
+    module Callbacks
+      class CallbackError < Exception
+      end
+
+      module InstanceMethods
+        include HTTPX::Callbacks
+
+        type socket = TCPSocket | SSLSocket | UNIXSocket
+
+        def on_connection_opened: () { (http_uri origin, socket sock) -> void } -> self
+
+        def on_connection_closed: () { (http_uri origin) -> void } -> self
+
+        def on_request_error: () { (Request request, StandardError error) -> void } -> self
+
+        def on_request_started: () { (Request request) -> void } -> self
+
+        def on_request_body_chunk: () { (Request request, String chunk) -> void } -> self
+
+        def on_request_completed: () { (Request request) -> void } -> self
+
+        def on_response_started: () { (Request request, Response response) -> void } -> self
+
+        def on_response_body_chunk: () { (Request request, Response response, String chunk) -> void } -> self
+
+        def on_response_completed: () { (Request request, response response) -> void } -> self
+
+        private
+
+        def emit_or_callback_error: (*untyped) -> void
+      end
+    end
+
+    type sessionCallbacks = Session & Callbacks::InstanceMethods
+  end
+end

data/sig/plugins/circuit_breaker.rbs

@@ -5,13 +5,17 @@ module HTTPX
       class CircuitStore
         @circuits: Hash[String, Circuit]
 
-        def try_open: (generic_uri uri, response response) -> void
+        @circuits_mutex: Thread::Mutex
+
+        def try_open: (uri uri, response response) -> response?
 
         def try_respond: (Request request) -> response?
 
+        def try_close: (http_uri uri) -> void
+
         private
 
-        def get_circuit_for_uri: (generic_uri uri) -> Circuit
+        def get_circuit_for_uri: (uri uri) -> Circuit
 
         def initialize: (Options & _CircuitOptions options) -> void
       end
@@ -23,6 +27,8 @@ module HTTPX
         @break_in: Float
         @circuit_breaker_half_open_drip_rate: Float
         @attempts: Integer
+        @real_attempts: Integer
+        @drip_factor: Integer
 
         @response: response?
         @opened_at: Float?
@@ -30,7 +36,7 @@ module HTTPX
 
         def respond: () -> response?
 
-        def try_open: (response) -> void
+        def try_open: (response) -> response?
 
         def try_close: () -> void
 
@@ -52,6 +58,10 @@ module HTTPX
 
       module InstanceMethods
         @circuit_store: CircuitStore
+
+        private
+
+        def try_circuit_open: (Request request, response response) -> response?
       end
 
     end

data/sig/plugins/compression.rbs

@@ -1,7 +1,6 @@
 module HTTPX
   module Plugins
     module Compression
-      type encodings_registry = Registry[Symbol, Class]
 
       type deflatable = _Reader | _ToS
 
@@ -16,12 +15,15 @@ module HTTPX
         def initialize: (Integer | Float bytesize) -> untyped
       end
 
+      interface _Compressor
+        def deflater: () -> _Deflater
+        def inflater: (Integer | Float bytesize) -> _Inflater
+      end
+
       def self.configure: (singleton(Session)) -> void
 
       interface _CompressionOptions
-        def compression_threshold_size: () -> Integer?
-
-        def encodings: () -> encodings_registry?
+        def encodings: () -> Hash[String, _Compressor]
       end
 
       def self.extra_options: (Options) -> (Options & _CompressionOptions)

data/sig/plugins/cookies/jar.rbs

@@ -13,8 +13,8 @@ module HTTPX
 
       def []: (uri) -> Array[Cookie]
 
-      def each: (?uri) { (Cookie) -> void } -> void
-              | (?uri) -> Enumerable[Cookie]
+      def each: (?uri?) { (Cookie) -> void } -> void
+              | (?uri?) -> Enumerable[Cookie]
 
       def merge: (_Each[cookie] cookies) -> instance
 

data/sig/plugins/cookies.rbs

@@ -5,6 +5,8 @@ module HTTPX
 
       interface _CookieOptions
         def cookies: () -> Jar?
+
+        def merge_cookie_in_jar: (Array[String] cookies, Jar jar) -> void
       end
 
       def self.extra_options: (Options) -> (Options & _CookieOptions)

data/sig/plugins/{digest_authentication.rbs → digest_auth.rbs}

@@ -12,10 +12,10 @@ module HTTPX
       def self.load_dependencies: (*untyped) -> void
 
       module InstanceMethods
-        def digest_authentication: (string user, string password) -> instance
+        def digest_auth: (string user, string password, ?hashed: bool) -> instance
       end
     end
 
-    type sessionDigestAuth = sessionAuthentication & DigestAuth::InstanceMethods
+    type sessionDigestAuth = sessionAuthorization & DigestAuth::InstanceMethods
   end
 end

data/sig/plugins/follow_redirects.rbs

@@ -10,6 +10,10 @@ module HTTPX
         def max_redirects: () -> Integer?
 
         def follow_insecure_redirects: () -> bool?
+
+        def allow_auth_to_other_origins: () -> bool?
+
+        def redirect_on: (http_uri) -> bool?
       end
 
       def self.extra_options: (Options) -> (Options & _FollowRedirectsOptions)
@@ -17,13 +21,18 @@ module HTTPX
       module InstanceMethods
         def max_redirects: (_ToI) -> instance
 
-        def build_redirect_request: (Request, Response, Options) -> Request
+        def redirect_request_headers: (http_uri original_uri, http_uri redirect_uri, Headers headers, Options & _FollowRedirectsOptions options) -> Headers
+
         def __get_location_from_response: (Response) -> (URI::HTTP | URI::HTTPS)
       end
 
       module RequestMethods
-        def redirect_request: () -> Request
+        attr_accessor root_request: instance?
+
+        def redirect_request: () -> instance
+
         def redirect_request=: (Request) -> void
+
         def max_redirects: () -> Integer
       end
     end