httpx 0.9.0 → 0.10.0

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

data/sig/parser/http1.rbs

@@ -0,0 +1,50 @@
+module HTTPX
+  module Parser
+    type parsed_headers = Hash[String, Array[String]]
+
+    interface _HTTP1Events
+
+      def on_start: () -> void
+      def on_headers: (parsed_headers) -> void
+      def on_trailers: (parsed_headers) -> void
+      def on_data: (String) -> void
+      def on_complete: () -> void
+    end
+
+    class HTTP1
+      VERSIONS: Array[String]
+
+      def <<: (String chunk) -> void
+
+      def headers: () -> parsed_headers
+
+      def http_version: () -> Array[1 | 0]
+
+      def reset!: () -> void
+
+      def status_code: () -> Integer
+
+      def upgrade?: () -> bool
+
+      def upgrade_data: () -> String
+
+      private
+
+      def initialize: (_HTTP1Events observer) -> untyped
+
+      def nextstate: (Symbol state) -> void
+
+      def no_more_data?: () -> bool
+
+      def parse: () -> void
+
+      def parse_data: () -> void
+
+      def parse_headers: () -> void
+
+      def parse_headline: () -> void
+
+      def prepare_data: (parsed_headers headers) -> void
+    end
+  end
+end

data/sig/plugins/authentication.rbs

@@ -0,0 +1,11 @@
+module HTTPX
+  module Plugins
+    module Authentication
+      module InstanceMethods
+        def authentication: (string token) -> instance
+      end
+    end
+
+    type sessionAuthentication = Session & Plugins::Authentication::InstanceMethods
+  end
+end

data/sig/plugins/basic_authentication.rbs

@@ -0,0 +1,13 @@
+module HTTPX
+  module Plugins
+    module BasicAuthentication
+      # def self.load_dependencies: (singleton(Session)) -> void
+
+      module InstanceMethods
+        def basic_authentication: (string user, string password) -> instance
+      end
+    end
+
+    type sessionBasicAuthentication = Plugins::sessionAuthentication & Plugins::Authentication::InstanceMethods
+  end
+end

data/sig/plugins/compression.rbs

@@ -0,0 +1,55 @@
+module HTTPX
+  module Plugins
+    module Compression
+      extend Registry[Symbol, Class]
+
+      type deflatable = _Reader | _ToS
+
+      interface _Deflater
+        def deflate: (deflatable, _Writer, chunk_size: Integer) -> void
+                   | (deflatable, _Writer, chunk_size: Integer) { (String) -> void } -> void
+      end
+
+      interface _Inflater
+        def inflate: (string) -> String
+
+        def initialize: (Numeric bytesize) -> untyped
+      end
+       
+      # def self.load_dependencies: (singleton(Session)) -> void
+
+      interface _CompressionOptions
+        def compression_threshold_size: () -> _Integer?
+        def compression_threshold_size=: (int) -> int
+        def with_compression_threshold_size: (int) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _CompressionOptions)
+
+
+      module ResponseBodyMethods
+        @encodings: Array[String]
+        @_deflaters: Array[_Decoder]
+
+        private
+
+        def decompress: (string) -> String
+      end
+
+      class Encoder
+        include Transcoder::_Encoder
+        include _ToS
+        include _Each[String]
+
+        def close: () -> void
+
+      	private
+
+        def initialize: (deflatable body, _Deflater deflater) -> untyped
+        def deflate: () -> void
+                   | () { (String) -> void } -> void
+      end
+
+    end
+  end
+end

data/sig/plugins/compression/brotli.rbs

@@ -0,0 +1,21 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module Brotli
+        # def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.decoder: (Numeric bytesize) -> Inflater
+
+        module Deflater
+          extend _Deflater
+        end
+
+        class Inflater
+          include _Inflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/compression/deflate.rbs

@@ -0,0 +1,17 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module Deflate
+        # def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.inflater: (Numeric bytesize) -> GZIP::Inflater
+
+        module Deflater
+          extend _Deflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/compression/gzip.rbs

@@ -0,0 +1,29 @@
+module HTTPX
+  module Plugins
+    module Compression
+      module GZIP
+        # def self.load_dependencies: (singleton(Session)) -> void
+        def self.configure: (*untyped) -> void
+
+        def self?.deflater: () -> _Deflater
+        def self?.inflater: (Numeric bytesize) -> Inflater
+
+        class Deflater
+          include _Deflater
+
+          @compressed_chunk: String
+          
+          private
+          
+          def initialize: () -> untyped
+          def write: (string) -> void
+          def compressed_chunk: () -> String
+        end
+
+        class Inflater
+          include _Inflater
+        end
+      end
+    end
+  end
+end

data/sig/plugins/cookies.rbs

@@ -0,0 +1,26 @@
+module HTTPX
+  module Plugins
+    module Cookies
+      type jar = Jar | _Each[cookies]
+
+      interface _CookieOptions
+        def cookies: () -> Jar?
+        def cookies=: (jar) -> Jar
+        def with_cookies: (jar) -> instance
+      end
+ 
+      def self.extra_options: (Options) -> (Options & _CookieOptions)
+
+      module InstanceMethods
+        def cookies: () -> Jar
+      end
+
+      module HeadersMethods
+        def set_cookie: (Array[Cookie]) -> void
+      end
+    end
+
+    type sessionCookies = Session & Plugins::Cookies::InstanceMethods
+    type headersCookies = Headers & Plugins::Cookies::HeadersMethods
+  end
+end

data/sig/plugins/cookies/cookie.rbs

@@ -0,0 +1,50 @@
+module HTTPX
+  module Plugins::Cookies
+    type cookie_attributes = Hash[Symbol | String, top]
+
+    class Cookie
+      include Comparable
+
+      MAX_LENGTH: Integer
+
+      attr_reader domain: DomainName?
+
+      attr_reader path: String
+
+      attr_reader name: String
+
+      attr_reader value: String?
+
+      attr_reader created_at: Time
+
+      def path=: (string) -> void
+
+      def domain=: (string) -> void
+
+      def expires: () -> Time?
+
+      def expired?: () -> bool
+                  | (Time) -> bool
+
+      def cookie_value: () -> String
+      alias to_s cookie_value
+
+      def valid_for_uri?: (uri) -> bool
+
+      def self.new: (Cookie) -> untyped
+                    | (cookie_attributes) -> untyped
+                    | (String, String) -> untyped
+                    | (String, String, cookie_attributes) -> untyped
+
+      def self.path_match?: (String, String) -> bool
+
+      private
+
+      def initialize: (cookie_attributes) -> untyped
+                    | (String, String) -> untyped
+                    | (String, String, cookie_attributes?) -> untyped
+      
+      def acceptable_from_uri?: (uri) -> bool
+    end
+  end
+end

data/sig/plugins/cookies/jar.rbs

@@ -0,0 +1,27 @@
+module HTTPX
+  module Plugins::Cookies
+    class Jar
+      type cookie = Cookie | Array[String, String, cookie_attributes] | Array[String, String] | cookie_attributes
+
+      include Enumerable[Cookie]
+
+      @cookies: Array[Cookie]
+
+      def parse: (String) -> void
+
+      def add: (Cookie) -> void
+             | (Cookie, String) -> void
+
+      def []: (uri) -> Array[Cookie]
+
+      def each: (uri) { (Cookie) -> void } -> void
+              | (uri) -> Enumerable[Cookie]
+              | () { (Cookie) -> void } -> void
+              | () -> Enumerable[Cookie]
+      private
+
+      def initialize: () -> void
+                    | (_Each[cookie]) -> untyped
+    end
+  end
+end