httpx-patched 1.6.2.1

data/sig/callbacks.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  interface _Callable
+    def call: (*untyped) -> void
+  end
+
+  module Callbacks
+    def on: (Symbol) { (*untyped) -> void } -> ^(*untyped) -> void
+    def once: (Symbol) { (*untyped) -> void } -> ^(*untyped) -> void
+    def emit: (Symbol, *untyped) -> void
+
+    def callbacks_for?: (Symbol) -> boolish
+    def callbacks: () -> Hash[Symbol, Array[_Callable]]
+                  | (Symbol) -> Array[_Callable]
+  end
+end

data/sig/chainable.rbs

@@ -0,0 +1,55 @@
+module HTTPX
+  module Chainable
+    def request: (*Request, **untyped) -> Array[response]
+               | (Request, **untyped) -> response
+               | (verb, uri | [uri], **untyped) -> response
+               | (Array[[verb, uri] | [verb, uri, request_params]], **untyped) -> Array[response]
+               | (verb, _Each[uri | [uri, request_params]], **untyped) -> Array[response]
+
+    def accept: (String) -> Session
+    def wrap: () { (Session) -> void } -> void
+
+    def with: (options) -> Session
+            | (options) { (Session) -> void } -> void
+
+    def plugin: (:auth, ?options) -> Plugins::sessionAuthorization
+              | (:basic_auth, ?options) -> Plugins::sessionBasicAuth
+              | (:digest_auth, ?options) -> Plugins::sessionDigestAuth
+              | (:ntlm_auth, ?options) -> Plugins::sessionNTLMAuth
+              | (:aws_sdk_authentication, ?options) -> Plugins::sessionAwsSdkAuthentication
+              | (:brotli, ?options) -> Session
+              | (:cookies, ?options) -> Plugins::sessionCookies
+              | (:expect, ?options) -> Session
+              | (:follow_redirects, ?options) -> Plugins::sessionFollowRedirects
+              | (:upgrade, ?options) -> Plugins::sessionUpgrade
+              | (:h2c, ?options) -> Plugins::sessionUpgrade
+              | (:h2, ?options) -> Plugins::sessionUpgrade
+              | (:fiber_concurrency, ?options) -> Plugins::sessionFiberConcurrency
+              | (:persistent, ?options) -> Plugins::sessionPersistent
+              | (:proxy, ?options) -> (Plugins::sessionProxy & Plugins::httpProxy)
+              | (:push_promise, ?options) -> Plugins::sessionPushPromise
+              | (:retries, ?options) -> Plugins::sessionRetries
+              | (:rate_limiter, ?options) -> Session
+              | (:stream, ?options) -> Plugins::sessionStream
+              | (:stream_bidi, ?options) -> Plugins::sessionStreamBidi
+              | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
+              | (:grpc, ?options) -> Plugins::grpcSession
+              | (:response_cache, ?options) -> Plugins::sessionResponseCache
+              | (:circuit_breaker, ?options) -> Plugins::sessionCircuitBreaker
+              | (:oauth, ?options) -> Plugins::sessionOAuth
+              | (:callbacks, ?options) -> Plugins::sessionCallbacks
+              | (:content_digest, ?options) -> Plugins::sessionContentDigest
+              | (:ssrf_filter, ?options) -> Plugins::sessionSsrf
+              | (:webdav, ?options) -> Plugins::sessionWebDav
+              | (:xml, ?options) -> Plugins::sessionXML
+              | (:query, ?options) -> Plugins::sessionQuery
+              | (Symbol | Module, ?options) { (Class) -> void } -> Session
+              | (Symbol | Module, ?options) -> Session
+
+    private
+
+    def default_options: () -> Options
+    def branch: (options) -> Session
+              | (options) { (Session) -> void } -> Session
+  end
+end

data/sig/connection/http1.rbs

@@ -0,0 +1,85 @@
+module HTTPX
+  class Connection::HTTP1
+    include Callbacks
+    include Loggable
+
+    UPCASED: Hash[String, String]
+    MAX_REQUESTS: Integer
+    CRLF: String
+
+    attr_reader pending: Array[Request]
+    attr_reader requests: Array[Request]
+
+    attr_accessor max_concurrent_requests: Integer
+
+    @options: Options
+    @max_requests: Integer
+    @parser: Parser::HTTP1
+    @buffer: Buffer
+    @version: [Integer, Integer]
+    @handshake_completed: bool
+    @pipelining: bool
+
+    @request: Request?
+
+    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, ?Request? request) -> void
+
+    def on_start: () -> void
+
+    def on_headers: (Hash[String, Array[String]] headers) -> void
+
+    def on_trailers: (Hash[String, Array[String]] headers) -> void
+
+    def on_data: (String chunk) -> void
+
+    def on_complete: () -> void
+
+    def dispatch: () -> void
+
+    def ping: () -> void
+
+    def waiting_for_ping?: () -> bool
+
+    def timeout: () -> Numeric?
+
+    private
+
+    def initialize: (Buffer buffer, Options options) -> untyped
+
+    def manage_connection: (Request request, Response response) -> void
+
+    def disable: () -> void
+
+    def disable_pipelining: () -> void
+
+    def set_protocol_headers: (Request request) -> _Each[[String, String]]
+
+    def handle: (Request request) -> void
+
+    def join_headers: (Request request) -> void
+
+    def join_trailers: (Request request) -> void
+
+    def join_headers2: (_Each[[String, String]] headers) -> void
+
+    def join_body: (Request request) -> void
+
+    def capitalized: (String field) -> String
+  end
+end

data/sig/connection/http2.rbs

@@ -0,0 +1,116 @@
+module HTTPX
+  class Connection::HTTP2
+    include Callbacks
+    include Loggable
+
+    MAX_CONCURRENT_REQUESTS: Integer
+
+    attr_reader streams: Hash[Request, ::HTTP2::Stream]
+    attr_reader pending: Array[Request]
+
+    @connection: HTTP2::Client
+    @options: Options
+    @settings: Hash[Symbol, Integer | bool]
+    @max_concurrent_requests: Integer
+    @max_requests: Integer
+    @drains: Hash[Request, String]
+    @pings: Array[String]
+    @buffer: Buffer
+    @handshake_completed: bool
+    @wait_for_handshake: bool
+
+    def interests: () -> io_interests?
+
+    def close: () -> void
+
+    def empty?: () -> bool
+
+    def exhausted?: () -> bool
+
+    def <<: (string) -> void
+
+    def send: (Request request, ?bool head) -> bool
+
+    def consume: () -> void
+
+    def handle_error: (StandardError ex, ?Request? request) -> void
+
+    def ping: () -> void
+
+    def waiting_for_ping?: () -> bool
+
+    alias reset init_connection
+
+    def timeout: () -> Numeric?
+
+    private
+
+    def initialize: (Buffer buffer, Options options) -> untyped
+
+    def can_buffer_more_requests?: () -> bool
+
+    def send_pending: () -> void
+
+    def set_protocol_headers: (Request) -> _Each[[String, String]]
+
+    def handle: (Request request, ::HTTP2::Stream stream) -> void
+
+    def init_connection: () -> void
+
+    def handle_stream: (::HTTP2::Stream stream, Request request) -> void
+
+    def join_headline: (Request request) -> String
+
+    def join_headers: (::HTTP2::Stream stream, Request request) -> void
+
+    def join_trailers: (::HTTP2::Stream stream, Request request) -> void
+
+    def join_body: (::HTTP2::Stream stream, Request request) -> void
+
+    def send_chunk: (Request request, ::HTTP2::Stream stream, String chunk, String? next_chunk) -> void
+
+    def end_stream?: (Request request, String? next_chunk) -> void
+
+    def on_stream_headers: (::HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
+
+    def on_stream_trailers: (::HTTP2::Stream stream, Response response, Array[[String, String]] headers) -> void
+
+    def on_stream_data: (::HTTP2::Stream stream, Request request, String data) -> void
+
+    def on_stream_refuse: (::HTTP2::Stream stream, Request request, StandardError error) -> void
+
+    def on_stream_close: (::HTTP2::Stream stream, Request request, (Symbol | StandardError)? 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: (::HTTP2::frame) -> void
+
+    def on_frame_received: (::HTTP2::frame) -> void
+
+    def on_altsvc: (String origin, ::HTTP2::frame) -> void
+
+    def on_promise: (::HTTP2::Stream) -> void
+
+    def on_origin: (String) -> void
+
+    def on_pong: (string ping) -> void
+
+    def teardown: (?Request? request) -> void
+
+    class Error < ::HTTPX::Error
+      def initialize: (Integer id, Symbol | StandardError error) -> void
+    end
+
+    class GoawayError < Error
+      def initialize: (?Symbol code) -> void
+    end
+
+    class PingError < Error
+      def initialize: () -> void
+    end
+  end
+end

data/sig/connection.rbs

@@ -0,0 +1,169 @@
+module HTTPX
+  class Connection
+    interface _Parser
+
+      def on: (Symbol) { (*untyped) -> void } -> void
+      def empty?: () -> bool
+      # def exhausted?: () -> bool
+      def close: () -> void
+      def consume: () -> void
+      def <<: (string) -> void
+      # def send: (Request) -> void
+      # def ping: () -> void
+      # def timeout: () -> (Integer | Float)
+
+    end
+
+    extend Forwardable
+    include Loggable
+    include Callbacks
+
+
+    attr_reader type: io_type
+    attr_reader io: TCP | SSL | UNIX | nil
+    attr_reader origin: http_uri
+    attr_reader origins: Array[String]
+    attr_reader state: Symbol
+    attr_reader pending: Array[Request]
+    attr_reader options: Options
+    attr_reader ssl_session: OpenSSL::SSL::Session?
+    attr_reader sibling: instance?
+    attr_writer current_selector: Selector?
+    attr_accessor current_session: Session?
+    attr_accessor family: Integer?
+
+
+    @window_size: Integer
+    @read_buffer: Buffer
+    @write_buffer: Buffer
+    @inflight: Integer
+    @keep_alive_timeout: Numeric?
+    @timeout: Numeric?
+    @current_timeout: Numeric?
+    @parser: Object & _Parser
+    @connected_at: Float
+    @response_received_at: Float
+    @exhausted: bool
+    @cloned: bool
+    @coalesced_connection: instance?
+    @sibling: instance?
+    @main_sibling: bool
+
+
+    def addresses: () -> Array[Resolver::Entry]?
+
+    def peer: () -> URI::Generic
+
+    def addresses=: (Array[Resolver::Entry] addresses) -> void
+
+    def send: (Request request) -> void
+
+    def addresses?: () -> boolish
+
+    def match?: (URI::Generic uri, Options options) -> bool
+
+    def mergeable?: (Connection connection) -> bool
+
+    def coalesce!: (instance connection) -> void
+
+    def coalescable?: (Connection connection) -> bool
+
+    def create_idle: (?Hash[Symbol, untyped] options) -> instance
+
+    def merge: (Connection connection) -> void
+
+    def purge_pending: () { (Request request) -> void } -> void
+
+    def connecting?: () -> bool
+
+    def io_connected?: () -> bool
+
+    def inflight?: () -> boolish
+
+    def interests: () -> io_interests?
+
+    def to_io: () -> IO
+
+    def call: () -> void
+
+    def terminate: () -> void
+
+    def close: () -> void
+
+    def force_reset: (?bool cloned) -> void
+
+    def reset: () -> void
+
+    def timeout: () -> Numeric?
+
+    def idling: () -> void
+
+    def used?: () -> boolish
+
+    def deactivate: () -> void
+
+    def open?: () -> bool
+
+    def handle_socket_timeout: (Numeric interval) -> void
+
+    def sibling=: (instance? connection) -> void
+
+    def handle_connect_error: (StandardError error) -> void
+
+    def disconnect: () -> void
+
+    private
+
+    def initialize: (http_uri uri, Options options) -> void
+
+    def initialize_type: (http_uri uri, Options options) -> io_type
+
+    def connect: () -> void
+
+    def exhausted?: () -> boolish
+
+    def consume: () -> void
+
+    def send_pending: () -> void
+
+    def parser: () -> (Object & _Parser)
+
+    def send_request_to_parser: (Request request) -> void
+
+    def build_parser: (?String protocol) -> (Object & _Parser)
+
+    def set_parser_callbacks: (HTTP1 | HTTP2 parser) -> void
+
+    def transition: (Symbol nextstate) -> void
+
+    def handle_transition: (Symbol nextstate) -> void
+
+    def build_altsvc_connection: (URI::Generic alt_origin, String origin, Hash[String, String] alt_params) -> void
+
+    def build_socket: (?Array[Resolver::Entry]? addrs) -> (TCP | SSL | UNIX)
+
+    def on_error: (HTTPX::TimeoutError | Error | StandardError error, ?Request? request) -> void
+
+    def handle_error: (StandardError error, ?Request? request) -> void
+
+    def close_sibling: () -> void
+
+    def purge_after_closed: () -> void
+
+    def set_request_timeouts: (Request request) -> void
+
+    def set_request_read_timeout: (Request request) -> void
+
+    def set_request_write_timeout: (Request request) -> void
+
+    def set_request_request_timeout: (Request request) -> void
+
+    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: (Symbol label, Request request, Numeric timeout, Symbol start_event, Symbol | Array[Symbol] finish_events) { () -> void } -> void
+
+    def parser_type: (String protocol) -> (singleton(HTTP1) | singleton(HTTP2))
+  end
+end

data/sig/domain_name.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  class DomainName
+    type domain = string | DomainName
+
+    include Comparable
+
+    def normalize: (String) -> String
+
+    def cookie_domain?: (domain, ?bool?) -> bool
+
+    def self.new: (domain) -> untyped
+
+    private
+
+    def initialize: (string) -> untyped
+  end
+end

data/sig/errors.rbs

@@ -0,0 +1,69 @@
+module HTTPX
+  class Error < StandardError
+  end
+
+  class UnsupportedSchemeError < Error
+  end
+
+  class ConnectionError < Error
+  end
+
+  class TimeoutError < Error
+    attr_reader timeout: Numeric
+
+    def to_connection_error: () -> ConnectTimeoutError
+    private
+
+    def initialize: (Numeric timeout, String message) -> untyped
+  end
+
+  class PoolTimeoutError < TimeoutError
+  end
+
+  class ConnectTimeoutError < TimeoutError
+  end
+
+  class SettingsTimeoutError < TimeoutError
+  end
+
+  class ResolveTimeoutError < TimeoutError
+  end
+
+  class RequestTimeoutError < TimeoutError
+    attr_reader request: Request
+    attr_reader response: response?
+
+    def initialize: (Request request, response? response, Numeric timeout) -> void
+  end
+
+  class ReadTimeoutError < RequestTimeoutError
+  end
+
+  class WriteTimeoutError < RequestTimeoutError
+  end
+
+  class OperationTimeoutError < TimeoutError
+  end
+
+  class ResolveError < Error
+  end
+
+  class HTTPError < Error
+    attr_reader response: Response
+
+    def status: () -> Integer
+
+    private
+
+    def initialize: (Response response) -> void
+  end
+
+  class NativeResolveError < ResolveError
+    attr_accessor connection: Connection?
+    attr_reader host: String
+
+    private
+
+    def initialize: (Connection connection, String hostname, ?String message) -> untyped
+  end
+end

data/sig/headers.rbs

@@ -0,0 +1,49 @@
+module HTTPX
+  class Headers
+    include _ToS
+
+    @headers: Hash[String, Array[_ToS]]
+
+    def self.new: (?untyped headers) -> instance
+
+    def ==: (untyped other) -> bool
+
+    def []: (String field) -> String?
+    def []=: (String field, headers_value value) -> void
+
+    def add: (String field, String value) -> void
+    def delete: (String field) -> Array[_ToS]?
+
+    def each: (?_Each[[String, String]]? extra_headers) { (String k, String v) -> void } -> void
+            | (?_Each[[String, String]]? extra_headers) -> Enumerable[[String, String]]
+
+    def get: (String field) -> Array[_ToS]
+    def key?: (String downcased_key) -> bool
+
+    def merge: (_Each[[String, headers_value]] other) -> Headers
+
+    def empty?: () -> bool
+
+    def to_a: () -> Array[[String, String]]
+
+    def to_hash: () -> Hash[String, String]
+
+    alias to_h to_hash
+
+    def inspect: () -> String
+
+    private
+
+    def initialize: (?(headers_input | instance)?) -> void
+
+    def array_value: (headers_value value) -> Array[_ToS]
+
+    def downcased: (header_field field) -> String
+  end
+
+  type header_field = string | _ToS
+  type headers_value = _ToS | Array[_ToS]
+  type headers_hash = Hash[header_field, headers_value]
+  type headers_input = headers_hash | Array[[header_field, headers_value]]
+  type headers = Headers | headers_input
+end

data/sig/httpx.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+  extend Chainable
+
+  EMPTY: Array[untyped]
+  EMPTY_HASH: Hash[untyped, untyped]
+
+  VERSION: String
+
+  type http_uri = URI::HTTP | URI::HTTPS
+  type uri = http_uri | string
+  type generic_uri = String | URI::Generic
+
+  type verb = String
+
+  type request_params = Hash[Symbol, untyped]
+
+  type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
+
+  module Plugins
+    self.@plugins: Hash[Symbol, Module]
+    self.@plugins_mutex: Thread::Mutex
+
+    def self?.load_plugin: (Symbol name) -> Module
+
+    def self?.register_plugin: (Symbol, Module) -> void
+  end
+end

data/sig/io/ssl.rbs

@@ -0,0 +1,27 @@
+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[Resolver::Entry]? addresses, options options) ?{ (self) -> void } -> void
+
+    def session_new_cb: { (OpenSSL::SSL::Session sess) -> 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,72 @@
+module HTTPX
+  class TCP
+    include Loggable
+
+    attr_reader ip: Resolver::Entry?
+
+    attr_reader port: Integer
+
+    attr_reader addresses: Array[Resolver::Entry]
+
+    attr_reader state: Symbol
+
+    attr_reader interests: io_interests
+
+    alias host ip
+
+    @io: Socket
+
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @ip_index: Integer
+
+    # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
+    def initialize: (URI::Generic origin, Array[Resolver::Entry]? addresses, Options options) ?{ (instance) -> void } -> void
+
+    def add_addresses: (Array[Resolver::Entry] addrs) -> void
+
+    def addresses?: () -> bool
+
+    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 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