httpx 0.15.1 → 0.16.0

data/lib/httpx/session.rb

@@ -15,8 +15,6 @@ module HTTPX
     end
 
     def wrap
-      return unless block_given?
-
       begin
         prev_persistent = @persistent
         @persistent = true
@@ -31,6 +29,8 @@ module HTTPX
     end
 
     def request(*args, **options)
+      raise ArgumentError, "must perform at least one request" if args.empty?
+
       requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
       responses = send_requests(*requests, options)
       return responses.first if responses.size == 1
@@ -247,9 +247,8 @@ module HTTPX
         if !@plugins.include?(pl)
           @plugins << pl
           pl.load_dependencies(self, &block) if pl.respond_to?(:load_dependencies)
+
           @default_options = @default_options.dup
-          @default_options = pl.extra_options(@default_options, &block) if pl.respond_to?(:extra_options)
-          @default_options = @default_options.merge(options) if options
 
           include(pl::InstanceMethods) if defined?(pl::InstanceMethods)
           extend(pl::ClassMethods) if defined?(pl::ClassMethods)
@@ -266,14 +265,26 @@ module HTTPX
           opts.response_body_class.__send__(:include, pl::ResponseBodyMethods) if defined?(pl::ResponseBodyMethods)
           opts.response_body_class.extend(pl::ResponseBodyClassMethods) if defined?(pl::ResponseBodyClassMethods)
           opts.connection_class.__send__(:include, pl::ConnectionMethods) if defined?(pl::ConnectionMethods)
+          if defined?(pl::OptionsMethods)
+            opts.options_class.__send__(:include, pl::OptionsMethods)
+
+            (pl::OptionsMethods.instance_methods - Object.instance_methods).each do |meth|
+              opts.options_class.method_added(meth)
+            end
+            @default_options = opts.options_class.new(opts)
+          end
+
+          @default_options = pl.extra_options(@default_options) if pl.respond_to?(:extra_options)
+          @default_options = @default_options.merge(options) if options
+
           pl.configure(self, &block) if pl.respond_to?(:configure)
 
           @default_options.freeze
         elsif options
           # this can happen when two plugins are loaded, an one of them calls the other under the hood,
           # albeit changing some default.
-          @default_options = @default_options.dup
-          @default_options = @default_options.merge(options)
+          @default_options = pl.extra_options(@default_options) if pl.respond_to?(:extra_options)
+          @default_options = @default_options.merge(options) if options
 
           @default_options.freeze
         end
@@ -283,8 +294,8 @@ module HTTPX
       # :nocov:
       def plugins(pls)
         warn ":#{__method__} is deprecated, use :plugin instead"
-        pls.each do |pl, *args|
-          plugin(pl, *args)
+        pls.each do |pl|
+          plugin(pl)
         end
         self
       end

data/lib/httpx/session2.rb

@@ -0,0 +1,21 @@
+require_relative "session"
+module HTTPX
+  class Session
+    def initialize(options = EMPTY_HASH, &blk)
+      @options = self.class.default_options.merge(options)
+      @responses = {}
+      @persistent = @options.persistent
+      wrap(&blk) if block_given?
+    end
+
+    def wrap
+      begin
+        prev_persistent = @persistent
+        @persistent = true
+        yield self
+      ensure
+        @persistent = prev_persistent
+      end
+    end
+  end
+end

data/lib/httpx/transcoder/body.rb

@@ -4,7 +4,7 @@ require "forwardable"
 
 module HTTPX::Transcoder
   module Body
-    Error = Class.new(HTTPX::Error)
+    class Error < HTTPX::Error; end
 
     module_function
 

data/lib/httpx/transcoder/chunker.rb

@@ -4,7 +4,8 @@ require "forwardable"
 
 module HTTPX::Transcoder
   module Chunker
-    Error = Class.new(HTTPX::Error)
+    class Error < HTTPX::Error; end
+
     CRLF = "\r\n".b
 
     class Encoder

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.15.1"
+  VERSION = "0.16.0"
 end

data/sig/buffer.rbs

@@ -1,5 +1,7 @@
 module HTTPX
   class Buffer
+    extend Forwardable
+    
     include _ToS
     include _ToStr
 

data/sig/chainable.rbs

@@ -3,41 +3,37 @@ module HTTPX
     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
+            | (options) { (Session) -> void } -> void
 
-
-
-
-    def plugin: (:authentication) -> Plugins::sessionAuthentication
-              | (:basic_authentication) -> Plugins::sessionBasicAuthentication
-              | (:digest_authentication) -> Plugins::sessionDigestAuthentication
-              | (:ntlm_authentication) -> Plugins::sessionNTLMAuthentication
-              | (:aws_sdk_authentication) -> Plugins::sessionAwsSdkAuthentication
-              | (:compression) -> Session
-              | (:cookies) -> Plugins::sessionCookies
-              | (:expect) -> Session
-              | (:follow_redirects) -> Plugins::sessionFollowRedirects
-              | (:upgrade) -> Session
-              | (:h2c) -> Session
-              | (:multipart) -> Session
-              | (:persistent) -> Plugins::sessionPersistent
-              | (:proxy) -> Plugins::sessionProxy
-              | (:push_promise) -> Plugins::sessionPushPromise
-              | (:retries) -> Plugins::sessionRetries
-              | (:rate_limiter) -> Session
-              | (:stream) -> Plugins::sessionStream
-              | (:aws_sigv4) -> Plugins::awsSigV4Session
-              | (:grpc) -> Plugins::grpcSession
-              | (Symbol | Module, ?options?) { (Class) -> void } -> Session
-              | (Symbol | Module, ?options?) -> Session
+    def plugin: (:authentication, ?options) -> Plugins::sessionAuthentication
+              | (:basic_authentication, ?options) -> Plugins::sessionBasicAuthentication
+              | (:digest_authentication, ?options) -> Plugins::sessionDigestAuthentication
+              | (:ntlm_authentication, ?options) -> Plugins::sessionNTLMAuthentication
+              | (:aws_sdk_authentication, ?options) -> Plugins::sessionAwsSdkAuthentication
+              | (:compression, ?options) -> Session
+              | (:cookies, ?options) -> Plugins::sessionCookies
+              | (:expect, ?options) -> Session
+              | (:follow_redirects, ?options) -> Plugins::sessionFollowRedirects
+              | (:upgrade, ?options) -> Session
+              | (:h2c, ?options) -> Session
+              | (:multipart, ?options) -> Session
+              | (:persistent, ?options) -> Plugins::sessionPersistent
+              | (:proxy, ?options) -> Plugins::sessionProxy
+              | (:push_promise, ?options) -> Plugins::sessionPushPromise
+              | (:retries, ?options) -> Plugins::sessionRetries
+              | (:rate_limiter, ?options) -> Session
+              | (:stream, ?options) -> Plugins::sessionStream
+              | (:aws_sigv4, ?options) -> Plugins::awsSigV4Session
+              | (:grpc, ?options) -> Plugins::grpcSession
+              | (Symbol | Module, ?options) { (Class) -> void } -> Session
+              | (Symbol | Module, ?options) -> Session
 
     private
 
     def default_options: () -> Options
     def branch: (options) -> Session
-              | (options) { (Session) -> Session } -> Session
+              | (options) { (Session) -> void } -> Session
   end
 end

data/sig/connection.rbs

@@ -1,28 +1,37 @@
 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
-    extend HTTPX::Registry[String, Class]
+    include HTTPX::Registry[String, Class]
+
+    BUFFER_SIZE: Integer
 
-    attr_reader origin: generic_uri 
+    attr_reader origin: URI::Generic
     attr_reader state: Symbol
     attr_reader pending: Array[Request]
-    attr_reader options: options
+    attr_reader options: Options
 
     def addresses: () -> Array[ipaddr]?
 
     def addresses=: (Array[ipaddr]) -> void
 
-    def match?: (generic_uri, options) -> bool
+    def match?: (URI::Generic, options) -> bool
 
     def mergeable?: (Connection) -> bool
 
@@ -35,7 +44,7 @@ module HTTPX
 
     def purge_pending: () { (Request) -> void } -> void
 
-    def match_altsvcs?: (generic_uri) -> bool
+    def match_altsvcs?: (URI::Generic uri) -> bool
 
     def connecting?: () -> bool
     def inflight?: () -> boolish
@@ -55,7 +64,7 @@ module HTTPX
 
     private
 
-    def initialize: (String, generic_uri, options) -> untyped
+    def initialize: (String, URI::Generic, options) -> untyped
 
     def connect: () -> void
 
@@ -76,10 +85,13 @@ module HTTPX
 
     def handle_response: () -> void
 
-    def on_error: (StandardError) -> void
+    def on_error: (HTTPX::TimeoutError | Error | StandardError) -> void
 
     def handle_error: (StandardError) -> void
 
-    def total_timeout: () -> Timers::Timer?
+    def total_timeout: () -> untyped?
+    # def total_timeout: () -> Timers::Timer?
+    #
+    def purge_after_closed: () -> void
   end
 end

data/sig/connection/http1.rbs

@@ -9,7 +9,7 @@ module HTTPX
     @options: Options
     @max_concurrent_requests: Integer
     @max_requests: Integer
-    @parser: HTTP1
+    @parser: Parser::HTTP1
     @buffer: Buffer
 
     def interests: () -> io_interests?
@@ -54,7 +54,7 @@ module HTTPX
 
     def disable_pipelining: () -> void
 
-    def set_protocol_headers: (Request) -> _Each[headers_key, String]
+    def set_protocol_headers: (Request) -> _Each[[headers_key, String]]
 
     def headline_uri: (Request) -> String
 
@@ -64,7 +64,7 @@ module HTTPX
 
     def join_trailers: (Request request) -> void
 
-    def join_headers2: (_Each[headers_key, String] headers) -> void
+    def join_headers2: (_Each[[headers_key, String]] headers) -> void
 
     def join_body: (Request request) -> void
 

data/sig/connection/http2.rbs

@@ -45,7 +45,7 @@ module HTTPX
 
     def headline_uri: (Request) -> String
 
-    def set_protocol_headers: (Request) -> _Each[headers_key, String]
+    def set_protocol_headers: (Request) -> _Each[[headers_key, String]]
 
     def handle: (Request request, HTTP2Next::Stream stream) -> void
 

data/sig/errors.rbs

@@ -1,3 +1,37 @@
 module HTTPX
-  Error: singleton(StandardError)
+  class Error < StandardError
+  end
+
+  class TimeoutError < Error
+    attr_reader timeout: Numeric
+
+    def to_connection_error: () -> ConnectTimeoutError
+    private
+
+    def initialize: (Numeric timeout, String message) -> untyped
+  end
+
+  class TotalTimeoutError < TimeoutError
+  end
+
+  class ConnectTimeoutError < TimeoutError
+  end
+
+  class SettingsTimeoutError < TimeoutError
+  end
+
+  class ResolveTimeoutError < TimeoutError
+  end
+
+  class ResolveError < Error
+  end
+
+  class NativeResolveError < ResolveError
+    attr_reader connection: Connection
+    attr_reader host: String
+
+    private
+
+    def initialize: (Connection connection, String hostname, ?String message) -> untyped
+  end
 end

data/sig/headers.rbs

@@ -12,15 +12,15 @@ module HTTPX
     def []=: (headers_key field, headers_value value) -> void
 
     def add: (headers_key field, string value) -> void
-    def delete: (headers_key field) -> void
+    def delete: (headers_key field) -> Array[String]?
 
-    def each: (?_Each[headers_key, String]? extra_headers) { (headers_key, String) -> void } -> void
-            | (?_Each[headers_key, String]? extra_headers) -> Enumerable[[headers_key, String], void]
+    def each: (?_Each[[headers_key, String]]? extra_headers) { (headers_key, String) -> void } -> void
+            | (?_Each[[headers_key, String]]? extra_headers) -> Enumerable[[headers_key, String]]
 
     def get: (headers_key field) -> Array[String]
     def key?: (headers_key downcased_key) -> bool
 
-    def merge: (_Each[headers_key, headers_value] other) -> Headers
+    def merge: (_Each[[headers_key, headers_value]] other) -> Headers
 
     def same_headers?: (untyped headers) -> bool
 
@@ -28,7 +28,7 @@ module HTTPX
     def to_hash: () -> Hash[headers_key, String]
     alias to_h to_hash
 
-    def inspect: () -> String 
+    def inspect: () -> String
 
     private
 

data/sig/httpx.rbs

@@ -4,12 +4,15 @@ module HTTPX
   VERSION: String
 
   type uri = URI::HTTP | URI::HTTPS | string
-  type generic_uri = uri | URI::Generic
+  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
 
   module Plugins
+    def self?.load_plugin: (Symbol) -> Module
+
+    def self?.register_plugin: (Symbol, Module) -> void
   end
 end

data/sig/loggable.rbs

@@ -4,8 +4,10 @@ module HTTPX
   end
 
   module Loggable
+    COLORS: Hash[Symbol, Integer]
+
     def log: (?level: Integer?, ?color: Symbol?) { () -> String } -> void
 
-    def log_exception: (StandardError, **untyped) -> void
+    def log_exception: (Exception error, ?level: Integer, ?color: Symbol) -> void
   end
 end

data/sig/options.rbs

@@ -4,108 +4,111 @@ module HTTPX
 
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
+    CONNECT_TIMEOUT: Integer
+    OPERATION_TIMEOUT: Integer
+    KEEP_ALIVE_TIMEOUT: Integer
+    SETTINGS_TIMEOUT: Integer
+    DEFAULT_OPTIONS: Hash[Symbol, untyped]
 
     type timeout_type = :connect_timeout | :settings_timeout | :operation_timeout | :keep_alive_timeout | :total_timeout
     type timeout = Hash[timeout_type, Numeric?]
 
-    def self.new: (options) -> instance
-                | () -> instance
+    def self.new: (?options) -> instance
 
+    def self.def_option: (Symbol, ?String) -> void
+                       | (Symbol) { (*nil) -> untyped } -> void
     # headers
     attr_reader uri: URI?
-    def uri=: (uri) -> void
 
     # headers
     attr_reader headers: Headers?
-    def headers=: (headers) -> void
 
     # timeout
     attr_reader timeout: timeout
-    def timeout=: (timeout) -> void
 
     # max_concurrent_requests
     attr_reader max_concurrent_requests: Integer?
-    def max_concurrent_requests=: (Integer) -> void
 
     # max_requests
     attr_reader max_requests: Integer?
-    def max_requests=: (Integer) -> void
 
     # window_size
-    attr_reader window_size: int?
-    def window_size=: (int) -> void
+    attr_reader window_size: Integer
 
     # body_threshold_size
-    attr_reader body_threshold_size: int?
-    def body_threshold_size=: (int) -> void
+    attr_reader body_threshold_size: Integer
 
     # transport
-    attr_reader transport: _ToS?
-    def transport=: (_ToS) -> void
+    attr_reader transport: String?
 
     # transport_options
     attr_reader transport_options: Hash[untyped, untyped]?
-    def transport_options=: (Hash[untyped, untyped]) -> void
 
     # addresses
-    attr_reader addresses: _ToAry[untyped]?
-    def addresses=: (_ToAry[untyped]) -> void
+    attr_reader addresses: _ToAry[ipaddr]?
 
     # params
     attr_reader params: Transcoder::urlencoded_input?
-    def params=: (Transcoder::urlencoded_input) -> void
 
     # form
     attr_reader form: Transcoder::urlencoded_input?
-    def form=: (Transcoder::urlencoded_input) -> void
 
     # json
     attr_reader json: _ToJson?
-    def json=: (_ToJson) -> void
 
     # body
     attr_reader body: bodyIO?
-    def body=: (bodyIO) -> void
 
     # ssl
 
     # http2_settings
 
+
+    # classes
+    attr_reader connection_class: singleton(Connection)
+
+    attr_reader request_class: singleton(Request)
+
+    attr_reader response_class: singleton(Response)
+
+    attr_reader headers_class: singleton(Headers)
+
+    attr_reader request_body_class: singleton(Request::Body)
+
+    attr_reader response_body_class: singleton(Response::Body)
+
+    attr_reader ssl: Hash[Symbol, untyped]
+
     # 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
-
     # io
     type io_option = _ToIO | Hash[String, _ToIO]
     attr_reader io: io_option?
-    def io=: (io_option) -> void
 
     # fallback_protocol
     attr_reader fallback_protocol: String?
-    def fallback_protocol=: (String) -> void
 
     # debug
     attr_reader debug: _IOLogger?
-    def debug=: (_IOLogger) -> void
 
     # debug_level
-    attr_reader debug_level: Integer?
-    def debug_level=: (Integer) -> void
+    attr_reader debug_level: Integer
 
     # persistent
     attr_reader persistent: bool?
-    def persistent=: (bool) -> void
+
+    # resolver_options
+    attr_reader resolver_options: Hash[Symbol, untyped]?
 
     def ==: (untyped other) -> bool
-    def merge: (_ToHash other) -> instance
+    def merge: (_ToHash[Symbol | String, untyped] other) -> instance
+    def to_hash: () -> Hash[Symbol, untyped]
 
     private
 
-    def initialize: (options) -> untyped
+    def initialize: (?options) -> untyped
   end
 
   type options = Options | Hash[Symbol | String, untyped]