httpx 0.8.0 → 0.10.1

data/sig/callbacks.rbs

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

data/sig/chainable.rbs

@@ -0,0 +1,37 @@
+module HTTPX
+  module Chainable
+    def request: (*untyped, **untyped) -> (response | Array[response])
+    def accept: (String) -> Session
+    def wrap: () { (Session) -> void } -> void
+            | () -> void
+
+    def with: (options) -> Session
+            | (options) { (Session) -> Session} -> Session
+
+
+
+
+    def plugin: (:authentication) -> Plugins::sessionAuthentication
+              | (:basic_authentication) -> Plugins::sessionBasicAuthentication
+              | (:digest_authentication) -> Plugins::sessionDigestAuthentication
+              | (:compression) -> Session
+              | (:cookies) -> Plugins::sessionCookies
+              | (:expect) -> Session
+              | (:follow_redirects) -> Plugins::sessionFollowRedirects
+              | (:h2c) -> Plugins::sessionH2C
+              | (:multipart) -> Session
+              | (:persistent) -> Plugins::sessionPersistent
+              | (:proxy) -> Plugins::sessionProxy
+              | (:push_promise) -> Plugins::sessionPushPromise
+              | (:retries) -> Plugins::sessionRetries
+              | (:stream) -> Plugins::sessionStream
+              | (Symbol | Module, ?options?) { (Class) -> void } -> Session
+              | (Symbol | Module, ?options?) -> Session
+
+    private
+
+    def default_options: () -> Options
+    def branch: (options) -> Session
+              | (options) { (Session) -> Session } -> Session
+  end
+end

data/sig/connection.rbs

@@ -0,0 +1,85 @@
+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

@@ -0,0 +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

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,3 @@
+module HTTPX
+  Error: singleton(StandardError)
+end

data/sig/headers.rbs

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

data/sig/httpx.rbs

@@ -0,0 +1,15 @@
+module HTTPX
+  extend Chainable
+
+  VERSION: String
+
+  type uri = URI::HTTP | URI::HTTPS | string
+  type generic_uri = uri | URI::Generic
+
+  type verb = :options | :get | :head | :post | :put | :delete | :trace | :connect |
+              :propfind | :proppatch | :mkcol | :copy | :move | :lock | :unlock | :orderpatch |
+              :acl | :report | :patch | :search
+
+  module Plugins
+  end
+end

data/sig/loggable.rbs

@@ -0,0 +1,11 @@
+module HTTPX
+  interface _IOLogger
+    def <<: (string?) -> void
+  end
+
+  module Loggable
+    def log: (?level: Integer?, ?color: Symbol?) { () -> String } -> void
+
+    def log_exception: (StandardError, **untyped) -> void
+  end
+end

data/sig/missing.rbs

@@ -0,0 +1,12 @@
+# defining these here, as I don't think there's hope of http-cookie to ever become type-friendly
+module HTTP
+  class Cookie
+  end
+  class CookieJar
+  end
+end
+
+module HTTP2Next
+  class Stream
+  end
+end

data/sig/options.rbs

@@ -0,0 +1,118 @@
+module HTTPX
+  class Options
+    # include _ToHash
+
+    WINDOW_SIZE: Integer
+    MAX_BODY_THRESHOLD_SIZE: Integer
+
+    def self.new: (options) -> instance
+                | () -> instance
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # http2_settings
+
+    # request_class response_class headers_class request_body_class
+    # response_body_class connection_class
+    # resolver_class resolver_options
+
+    # 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
+
+    # 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
+
+    private
+
+    def initialize: (options) -> untyped
+  end
+
+  type options = Options | Hash[Symbol | String, untyped]
+end