httpx 0.7.0 → 0.10.0

data/lib/httpx/session.rb

@@ -5,7 +5,9 @@ module HTTPX
     include Loggable
     include Chainable
 
-    def initialize(options = {}, &blk)
+    EMPTY_HASH = {}.freeze
+
+    def initialize(options = EMPTY_HASH, &blk)
       @options = self.class.default_options.merge(options)
       @responses = {}
       @persistent = @options.persistent
@@ -29,13 +31,21 @@ module HTTPX
     end
 
     def request(*args, **options)
-      requests = build_requests(*args, options)
+      requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
       responses = send_requests(*requests, options)
       return responses.first if responses.size == 1
 
       responses
     end
 
+    def build_request(verb, uri, options = EMPTY_HASH)
+      rklass = @options.request_class
+      request = rklass.new(verb, uri, @options.merge(options).merge(persistent: @persistent))
+      request.on(:response, &method(:on_response).curry[request])
+      request.on(:promise, &method(:on_promise))
+      request
+    end
+
     private
 
     def pool
@@ -47,7 +57,7 @@ module HTTPX
     end
 
     def on_promise(_, stream)
-      log(level: 2, label: "#{stream.id}: ") { "refusing stream!" }
+      log(level: 2) { "#{stream.id}: refusing stream!" }
       stream.refuse
     end
 
@@ -56,7 +66,8 @@ module HTTPX
     end
 
     def find_connection(request, connections, options)
-      uri = URI(request.uri)
+      uri = request.uri
+
       connection = pool.find_connection(uri, options) || build_connection(uri, options)
       unless connections.nil? || connections.include?(connection)
         connections << connection
@@ -122,13 +133,13 @@ module HTTPX
       requests = case args.size
                  when 1
                    reqs = args.first
-                   reqs.map do |verb, uri|
-                     build_request(verb, uri, request_options)
+                   reqs.map do |verb, uri, opts = EMPTY_HASH|
+                     build_request(verb, uri, request_options.merge(opts))
                    end
-                 when 2, 3
+                 when 2
                    verb, uris = args
                    if uris.respond_to?(:each)
-                     uris.map do |uri, **opts|
+                     uris.enum_for(:each).map do |uri, opts = EMPTY_HASH|
                        build_request(verb, uri, request_options.merge(opts))
                      end
                    else
@@ -179,15 +190,13 @@ module HTTPX
       begin
         # guarantee ordered responses
         loop do
-          begin
-            request = requests.first
-            pool.next_tick until (response = fetch_response(request, connections, request_options))
+          request = requests.first
+          pool.next_tick until (response = fetch_response(request, connections, request_options))
 
-            responses << response
-            requests.shift
+          responses << response
+          requests.shift
 
-            break if requests.empty? || pool.empty?
-          end
+          break if requests.empty? || pool.empty?
         end
         responses
       ensure
@@ -195,14 +204,6 @@ module HTTPX
       end
     end
 
-    def build_request(verb, uri, options)
-      rklass = @options.request_class
-      request = rklass.new(verb, uri, @options.merge(options))
-      request.on(:response, &method(:on_response).curry[request])
-      request.on(:promise, &method(:on_promise))
-      request
-    end
-
     @default_options = Options.new
     @default_options.freeze
     @plugins = []
@@ -219,7 +220,7 @@ module HTTPX
       def plugin(pl, options = nil, &block)
         # raise Error, "Cannot add a plugin to a frozen config" if frozen?
         pl = Plugins.load_plugin(pl) if pl.is_a?(Symbol)
-        unless @plugins.include?(pl)
+        if !@plugins.include?(pl)
           @plugins << pl
           pl.load_dependencies(self, &block) if pl.respond_to?(:load_dependencies)
           @default_options = @default_options.dup
@@ -243,6 +244,13 @@ module HTTPX
           opts.connection_class.__send__(:include, pl::ConnectionMethods) if defined?(pl::ConnectionMethods)
           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.freeze
         end
         self

data/lib/httpx/timeout.rb

@@ -6,6 +6,7 @@ module HTTPX
   class Timeout
     CONNECT_TIMEOUT = 60
     OPERATION_TIMEOUT = 60
+    KEEP_ALIVE_TIMEOUT = 20
 
     def self.new(opts = {})
       return opts if opts.is_a?(Timeout)
@@ -13,14 +14,16 @@ module HTTPX
       super(**opts)
     end
 
-    attr_reader :connect_timeout, :operation_timeout, :total_timeout
+    attr_reader :connect_timeout, :operation_timeout, :keep_alive_timeout, :total_timeout
 
     def initialize(connect_timeout: CONNECT_TIMEOUT,
                    operation_timeout: OPERATION_TIMEOUT,
+                   keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
                    total_timeout: nil,
                    loop_timeout: nil)
       @connect_timeout = connect_timeout
       @operation_timeout = operation_timeout
+      @keep_alive_timeout = keep_alive_timeout
       @total_timeout = total_timeout
 
       return unless loop_timeout
@@ -35,6 +38,7 @@ module HTTPX
       if other.is_a?(Timeout)
         @connect_timeout == other.instance_variable_get(:@connect_timeout) &&
           @operation_timeout == other.instance_variable_get(:@operation_timeout) &&
+          @keep_alive_timeout == other.instance_variable_get(:@keep_alive_timeout) &&
           @total_timeout == other.instance_variable_get(:@total_timeout)
       else
         super
@@ -49,9 +53,11 @@ module HTTPX
       when Timeout
         connect_timeout = other.instance_variable_get(:@connect_timeout) || @connect_timeout
         operation_timeout = other.instance_variable_get(:@operation_timeout) || @operation_timeout
+        keep_alive_timeout = other.instance_variable_get(:@keep_alive_timeout) || @keep_alive_timeout
         total_timeout = other.instance_variable_get(:@total_timeout) || @total_timeout
         Timeout.new(connect_timeout: connect_timeout,
                     operation_timeout: operation_timeout,
+                    keep_alive_timeout: keep_alive_timeout,
                     total_timeout: total_timeout)
       else
         raise ArgumentError, "can't merge with #{other.class}"

data/lib/httpx/transcoder/chunker.rb

@@ -10,8 +10,6 @@ module HTTPX::Transcoder
     class Encoder
       extend Forwardable
 
-      def_delegator :@raw, :readpartial
-
       def initialize(body)
         @raw = body
       end

data/lib/httpx/transcoder/form.rb

@@ -14,8 +14,6 @@ module HTTPX::Transcoder
 
       def_delegator :@raw, :bytesize
 
-      def_delegator :@raw, :force_encoding
-
       def initialize(form)
         @raw = URI.encode_www_form(form)
       end
@@ -23,10 +21,6 @@ module HTTPX::Transcoder
       def content_type
         "application/x-www-form-urlencoded"
       end
-
-      def to_str
-        @raw.to_s
-      end
     end
 
     def encode(form)

data/lib/httpx/transcoder/json.rb

@@ -10,14 +10,10 @@ module HTTPX::Transcoder
     class Encoder
       extend Forwardable
 
-      def_delegator :@raw, :to_str
-
       def_delegator :@raw, :to_s
 
       def_delegator :@raw, :bytesize
 
-      def_delegator :@raw, :force_encoding
-
       def initialize(json)
         @raw = ::JSON.dump(json)
         @charset = @raw.encoding.name.downcase

data/lib/httpx/utils.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Utils
+    using URIExtensions
+
+    module_function
+
+    # The value of this field can be either an HTTP-date or a number of
+    # seconds to delay after the response is received.
+    def parse_retry_after(retry_after)
+      # first: bet on it being an integer
+      Integer(retry_after)
+    rescue ArgumentError
+      # Then it's a datetime
+      time = Time.httpdate(retry_after)
+      time - Time.now
+    end
+
+    if RUBY_VERSION < "2.3"
+      def uri(*args)
+        URI(*args)
+      end
+    else
+
+      URIParser = URI::RFC2396_Parser.new
+
+      def uri(uri)
+        return Kernel.URI(uri) unless uri.is_a?(String) && !uri.ascii_only?
+
+        uri = Kernel.URI(URIParser.escape(uri))
+
+        non_ascii_hostname = URIParser.unescape(uri.host)
+
+        non_ascii_hostname.force_encoding(Encoding::UTF_8)
+
+        idna_hostname = DomainName.new(non_ascii_hostname).hostname
+
+        uri.host = idna_hostname
+        uri.non_ascii_hostname = non_ascii_hostname
+        uri
+      end
+    end
+  end
+end

data/lib/httpx/version.rb

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

data/sig/buffer.rbs

@@ -0,0 +1,24 @@
+module HTTPX
+  class Buffer
+    include _ToS
+    include _ToStr
+
+    @buffer: String
+
+    attr_reader limit: Integer
+
+    def full?: () -> bool
+    def shift!: (Integer) -> void
+
+    # delegated
+    def <<: (string data) -> void
+    def empty?: () -> bool
+    def bytesize: () -> Integer
+    def clear: () -> void
+    def replace: (string) -> void
+
+    private
+
+    def initialize: (Integer limit) -> untyped
+  end
+end

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,2 @@
+class HTTPX::Connection
+end

data/sig/connection/http2.rbs

@@ -0,0 +1,4 @@
+module HTTPX
+  class Connection::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,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,14 @@
+module HTTPX
+  extend Chainable
+
+  VERSION: String
+
+  type uri = URI::HTTP | URI::HTTPS | string
+
+  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