httpx 0.8.2 → 0.11.0

data/lib/httpx/resolver/resolver_mixin.rb

@@ -38,7 +38,7 @@ module HTTPX
       def early_resolve(connection, hostname: connection.origin.host)
         addresses = connection.addresses ||
                     ip_resolve(hostname) ||
-                    (@resolver_options.cache && Resolver.cached_lookup(hostname)) ||
+                    (@resolver_options[:cache] && Resolver.cached_lookup(hostname)) ||
                     system_resolve(hostname)
         return unless addresses
 
@@ -57,11 +57,13 @@ module HTTPX
         ips.map { |ip| IPAddr.new(ip) }
       end
 
-      def emit_resolve_error(connection, hostname, ex = nil)
+      def emit_resolve_error(connection, hostname = connection.origin.host, ex = nil)
         emit(:error, connection, resolve_error(hostname, ex))
       end
 
       def resolve_error(hostname, ex = nil)
+        return ex if ex.is_a?(ResolveError)
+
         message = ex ? ex.message : "Can't resolve #{hostname}"
         error = ResolveError.new(message)
         error.set_backtrace(ex ? ex.backtrace : caller)

data/lib/httpx/resolver/system.rb

@@ -14,13 +14,13 @@ module HTTPX
 
     def initialize(options)
       @options = Options.new(options)
-      @resolver_options = Resolver::Options.new(@options.resolver_options)
+      @resolver_options = @options.resolver_options
       @state = :idle
-      resolv_options = @resolver_options.to_h
+      resolv_options = @resolver_options.dup
       timeouts = resolv_options.delete(:timeouts)
       resolv_options.delete(:cache)
       @resolver = Resolv::DNS.new(resolv_options.empty? ? nil : resolv_options)
-      @resolver.timeouts = timeouts if timeouts
+      @resolver.timeouts = timeouts || Resolver::RESOLVE_TIMEOUT
     end
 
     def closed?

data/lib/httpx/response.rb

@@ -75,11 +75,11 @@ module HTTPX
         @status == 204 ||
         @status == 205 ||
         @status == 304 || begin
-        content_length = @headers["content-length"]
-        return false if content_length.nil?
+          content_length = @headers["content-length"]
+          return false if content_length.nil?
 
-        content_length == "0"
-      end
+          content_length == "0"
+        end
     end
 
     class Body
@@ -95,6 +95,8 @@ module HTTPX
       end
 
       def write(chunk)
+        return if @state == :closed
+
         @length += chunk.bytesize
         transition
         @buffer.write(chunk)
@@ -116,7 +118,7 @@ module HTTPX
         return enum_for(__method__) unless block_given?
 
         begin
-          unless @state == :idle
+          if @buffer
             rewind
             while (chunk = @buffer.read(@window_size))
               yield(chunk.force_encoding(@encoding))
@@ -155,20 +157,19 @@ module HTTPX
         if dest.respond_to?(:path) && @buffer.respond_to?(:path)
           FileUtils.mv(@buffer.path, dest.path)
         else
-          @buffer.rewind
           ::IO.copy_stream(@buffer, dest)
         end
       end
 
       # closes/cleans the buffer, resets everything
       def close
-        return if @state == :idle
-
-        @buffer.close
-        @buffer.unlink if @buffer.respond_to?(:unlink)
-        @buffer = nil
+        if @buffer
+          @buffer.close
+          @buffer.unlink if @buffer.respond_to?(:unlink)
+          @buffer = nil
+        end
         @length = 0
-        @state = :idle
+        @state = :closed
       end
 
       def ==(other)
@@ -186,7 +187,7 @@ module HTTPX
       private
 
       def rewind
-        return if @state == :idle
+        return unless @buffer
 
         @buffer.rewind
       end
@@ -239,13 +240,11 @@ module HTTPX
 
       private
 
-      # :nodoc:
       def mime_type(str)
         m = str.to_s[MIME_TYPE_RE, 1]
         m && m.strip.downcase
       end
 
-      # :nodoc:
       def charset(str)
         m = str.to_s[CHARSET_RE, 1]
         m && m.strip.delete('"')
@@ -269,15 +268,7 @@ module HTTPX
       @error.message
     end
 
-    def reason
-      @error.class.name
-    end
-
-    def headers
-      {}
-    end
-
-    def body
+    def to_s
       @error.backtrace.join("\n")
     end
 
@@ -287,7 +278,7 @@ module HTTPX
 
     # rubocop:disable Style/MissingRespondToMissing
     def method_missing(meth, *, &block)
-      raise NoMethodError, "undefined response method `#{meth}' for error response" if Response.public_method_defined?(meth)
+      raise NoMethodError, "undefined response method `#{meth}' for error response" if @options.response_class.public_method_defined?(meth)
 
       super
     end

data/lib/httpx/selector.rb

@@ -2,21 +2,16 @@
 
 require "io/wait"
 
-module IOExtensions # :nodoc:
+module IOExtensions
   refine IO do
-    def wait(timeout = nil, mode = :read)
-      case mode
-      when :read
-        wait_readable(timeout)
-      when :write
-        wait_writable(timeout)
-      when :read_write
-        r, w = IO.select([self], [self], nil, timeout)
-
-        return unless r || w
-
-        self
-      end
+    # provides a fallback for rubies where IO#wait isn't implemented,
+    # but IO#wait_readable and IO#wait_writable are.
+    def wait(timeout = nil, _mode = :read_write)
+      r, w = IO.select([self], [self], nil, timeout)
+
+      return unless r || w
+
+      self
     end
   end
 end
@@ -51,7 +46,7 @@ class HTTPX::Selector
   READ_INTERESTS = %i[r rw].freeze
   WRITE_INTERESTS = %i[w rw].freeze
 
-  def select_many(interval)
+  def select_many(interval, &block)
     selectables, r, w = nil
 
     # first, we group IOs based on interest type. On call to #interests however,
@@ -102,9 +97,7 @@ class HTTPX::Selector
       writers.delete(io)
     end if readers
 
-    writers.each do |io|
-      yield io
-    end if writers
+    writers.each(&block) if writers
   end
 
   def select_one(interval)
@@ -124,6 +117,7 @@ class HTTPX::Selector
     yield io
   rescue IOError, SystemCallError
     @selectables.reject!(&:closed?)
+    raise unless @selectables.empty?
   end
 
   def select(interval, &block)

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(2)[request])
+      request.on(:promise, &method(:on_promise))
+      request
+    end
+
     private
 
     def pool
@@ -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
@@ -66,10 +77,16 @@ module HTTPX
     end
 
     def set_connection_callbacks(connection, connections, options)
-      connection.on(:uncoalesce) do |uncoalesced_uri|
-        other_connection = build_connection(uncoalesced_uri, options)
+      connection.on(:misdirected) do |misdirected_request|
+        other_connection = connection.create_idle(ssl: { alpn_protocols: %w[http/1.1] })
+        other_connection.merge(connection)
+        catch(:coalesced) do
+          pool.init_connection(other_connection, options)
+        end
+        set_connection_callbacks(other_connection, connections, options)
         connections << other_connection
-        connection.unmerge(other_connection)
+        misdirected_request.transition(:idle)
+        other_connection.send(misdirected_request)
       end
       connection.on(:altsvc) do |alt_origin, origin, alt_params|
         other_connection = build_altsvc_connection(connection, connections, alt_origin, origin, alt_params, options)
@@ -119,23 +136,20 @@ module HTTPX
     def build_requests(*args, options)
       request_options = @options.merge(options)
 
-      requests = case args.size
-                 when 1
-                   reqs = args.first
-                   reqs.map do |verb, uri|
-                     build_request(verb, uri, request_options)
-                   end
-                 when 2, 3
-                   verb, uris = args
-                   if uris.respond_to?(:each)
-                     uris.map do |uri, **opts|
-                       build_request(verb, uri, request_options.merge(opts))
-                     end
-                   else
-                     [build_request(verb, uris, request_options)]
-                   end
-                 else
-                   raise ArgumentError, "unsupported number of arguments"
+      requests = if args.size == 1
+        reqs = args.first
+        reqs.map do |verb, uri, opts = EMPTY_HASH|
+          build_request(verb, uri, request_options.merge(opts))
+        end
+      else
+        verb, uris = args
+        if uris.respond_to?(:each)
+          uris.enum_for(:each).map do |uri, opts = EMPTY_HASH|
+            build_request(verb, uri, request_options.merge(opts))
+          end
+        else
+          [build_request(verb, uris, request_options)]
+        end
       end
       raise ArgumentError, "wrong number of URIs (given 0, expect 1..+1)" if requests.empty?
 
@@ -179,15 +193,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 +207,6 @@ module HTTPX
       end
     end
 
-    def build_request(verb, uri, options)
-      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
-
     @default_options = Options.new
     @default_options.freeze
     @plugins = []
@@ -219,7 +223,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 +247,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/transcoder.rb

@@ -3,6 +3,26 @@
 module HTTPX
   module Transcoder
     extend Registry
+
+    def self.normalize_keys(key, value, cond = nil, &block)
+      if (cond && cond.call(value))
+        block.call(key.to_s, value)
+      elsif value.respond_to?(:to_ary)
+        if value.empty?
+          block.call("#{key}[]")
+        else
+          value.to_ary.each do |element|
+            normalize_keys("#{key}[]", element, cond, &block)
+          end
+        end
+      elsif value.respond_to?(:to_hash)
+        value.to_hash.each do |child_key, child_value|
+          normalize_keys("#{key}[#{child_key}]", child_value, cond, &block)
+        end
+      else
+        block.call(key.to_s, value)
+      end
+    end
   end
 end
 

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

@@ -12,21 +12,23 @@ module HTTPX::Transcoder
 
       def_delegator :@raw, :to_s
 
-      def_delegator :@raw, :bytesize
+      def_delegator :@raw, :to_str
 
-      def_delegator :@raw, :force_encoding
+      def_delegator :@raw, :bytesize
 
       def initialize(form)
-        @raw = URI.encode_www_form(form)
+        @raw = form.each_with_object("".b) do |(key, val), buf|
+          HTTPX::Transcoder.normalize_keys(key, val) do |k, v|
+            buf << "&" unless buf.empty?
+            buf << URI.encode_www_form_component(k)
+            buf << "=#{URI.encode_www_form_component(v.to_s)}" unless v.nil?
+          end
+        end
       end
 
       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