httpx 0.15.4 → 0.18.0

data/lib/httpx/request.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "delegate"
 require "forwardable"
 
 module HTTPX
@@ -40,16 +41,15 @@ module HTTPX
 
     def_delegator :@body, :empty?
 
-    def_delegator :@body, :chunk!
-
     def initialize(verb, uri, options = {})
       @verb    = verb.to_s.downcase.to_sym
       @options = Options.new(options)
       @uri     = Utils.to_uri(uri)
       if @uri.relative?
-        raise(Error, "invalid URI: #{@uri}") unless @options.origin
+        origin = @options.origin
+        raise(Error, "invalid URI: #{@uri}") unless origin
 
-        @uri = @options.origin.merge(@uri)
+        @uri = origin.merge(@uri)
       end
 
       raise(Error, "unknown method: #{verb}") unless METHODS.include?(@verb)
@@ -97,7 +97,7 @@ module HTTPX
     def response=(response)
       return unless response
 
-      if response.status == 100
+      if response.is_a?(Response) && response.status == 100
         @informational_status = response.status
         return
       end
@@ -148,16 +148,16 @@ module HTTPX
     # :nocov:
     def inspect
       "#<HTTPX::Request:#{object_id} " \
-      "#{@verb.to_s.upcase} " \
-      "#{uri} " \
-      "@headers=#{@headers} " \
-      "@body=#{@body}>"
+        "#{@verb.to_s.upcase} " \
+        "#{uri} " \
+        "@headers=#{@headers} " \
+        "@body=#{@body}>"
     end
     # :nocov:
 
-    class Body
+    class Body < SimpleDelegator
       class << self
-        def new(*, options)
+        def new(_, options)
           return options.body if options.body.is_a?(self)
 
           super
@@ -177,10 +177,11 @@ module HTTPX
 
         @headers["content-type"] ||= @body.content_type
         @headers["content-length"] = @body.bytesize unless unbounded_body?
+        super(@body)
       end
 
       def each(&block)
-        return enum_for(__method__) unless block_given?
+        return enum_for(__method__) unless block
         return if @body.nil?
 
         body = stream(@body)
@@ -214,14 +215,14 @@ module HTTPX
 
       def stream(body)
         encoded = body
-        encoded = Transcoder.registry("chunker").encode(body) if chunked?
+        encoded = Transcoder.registry("chunker").encode(body.enum_for(:each)) if chunked?
         encoded
       end
 
       def unbounded_body?
         return @unbounded_body if defined?(@unbounded_body)
 
-        @unbounded_body = (chunked? || @body.bytesize == Float::INFINITY)
+        @unbounded_body = !@body.nil? && (chunked? || @body.bytesize == Float::INFINITY)
       end
 
       def chunked?
@@ -235,19 +236,9 @@ module HTTPX
       # :nocov:
       def inspect
         "#<HTTPX::Request::Body:#{object_id} " \
-        "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
+          "#{unbounded_body? ? "stream" : "@bytesize=#{bytesize}"}>"
       end
       # :nocov:
-
-      def respond_to_missing?(meth, *args)
-        @body.respond_to?(meth, *args) || super
-      end
-
-      def method_missing(meth, *args, &block)
-        return super unless @body.respond_to?(meth)
-
-        @body.__send__(meth, *args, &block)
-      end
     end
 
     def transition(nextstate)

data/lib/httpx/resolver/https.rb

@@ -24,9 +24,9 @@ module HTTPX
       record_types: RECORD_TYPES.keys,
     }.freeze
 
-    def_delegator :@connections, :empty?
+    def_delegators :@resolver_connection, :state, :connecting?, :to_io, :call, :close
 
-    def_delegators :@resolver_connection, :connecting?, :to_io, :call, :close
+    attr_writer :pool
 
     def initialize(options)
       @options = Options.new(options)
@@ -65,15 +65,11 @@ module HTTPX
 
     private
 
-    def pool
-      Thread.current[:httpx_connection_pool] ||= Pool.new
-    end
-
     def resolver_connection
-      @resolver_connection ||= pool.find_connection(@uri, @options) || begin
+      @resolver_connection ||= @pool.find_connection(@uri, @options) || begin
         @building_connection = true
         connection = @options.connection_class.new("ssl", @uri, @options.merge(ssl: { alpn_protocols: %w[h2] }))
-        pool.init_connection(connection, @options)
+        @pool.init_connection(connection, @options)
         emit_addresses(connection, @uri_addresses)
         @building_connection = false
         connection

data/lib/httpx/resolver/native.rb

@@ -47,6 +47,8 @@ module HTTPX
 
     def_delegator :@connections, :empty?
 
+    attr_reader :state
+
     def initialize(options)
       @options = Options.new(options)
       @ns_index = 0
@@ -120,7 +122,7 @@ module HTTPX
     def timeout
       return if @connections.empty?
 
-      @start_timeout = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @start_timeout = Utils.now
       hosts = @queries.keys
       @timeouts.values_at(*hosts).reject(&:empty?).map(&:first).min
     end
@@ -140,7 +142,7 @@ module HTTPX
     def do_retry
       return if @queries.empty?
 
-      loop_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start_timeout
+      loop_time = Utils.elapsed_time(@start_timeout)
       connections = []
       queries = {}
       while (query = @queries.shift)
@@ -217,15 +219,27 @@ module HTTPX
         end
       else
         address = addresses.first
-        connection = @queries.delete(address["name"])
-        return unless connection # probably a retried query for which there's an answer
+        name = address["name"]
+
+        connection = @queries.delete(name)
+
+        unless connection
+          # absolute name
+          name_labels = Resolv::DNS::Name.create(name).to_a
+          name = @queries.keys.first { |hname| name_labels == Resolv::DNS::Name.create(hname).to_a }
+
+          # probably a retried query for which there's an answer
+          return unless name
+
+          address["name"] = name
+          connection = @queries.delete(name)
+        end
 
         if address.key?("alias") # CNAME
           if early_resolve(connection, hostname: address["alias"])
             @connections.delete(connection)
           else
             resolve(connection, address["alias"])
-            @queries.delete(address["name"])
             return
           end
         else

data/lib/httpx/resolver/resolver_mixin.rb

@@ -9,7 +9,7 @@ module HTTPX
       include Callbacks
       include Loggable
 
-      CHECK_IF_IP = proc do |name|
+      CHECK_IF_IP = lambda do |name|
         begin
           IPAddr.new(name)
           true
@@ -55,6 +55,7 @@ module HTTPX
         return if ips.empty?
 
         ips.map { |ip| IPAddr.new(ip) }
+      rescue IOError
       end
 
       def emit_resolve_error(connection, hostname = connection.origin.host, ex = nil)

data/lib/httpx/resolver/system.rb

@@ -12,6 +12,8 @@ module HTTPX
                      Resolv::DNS::EncodeError,
                      Resolv::DNS::DecodeError].freeze
 
+    attr_reader :state
+
     def initialize(options)
       @options = Options.new(options)
       @resolver_options = @options.resolver_options

data/lib/httpx/resolver.rb

@@ -26,14 +26,14 @@ module HTTPX
     module_function
 
     def cached_lookup(hostname)
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      now = Utils.now
       @lookup_mutex.synchronize do
         lookup(hostname, now)
       end
     end
 
     def cached_lookup_set(hostname, entries)
-      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      now = Utils.now
       entries.each do |entry|
         entry["TTL"] += now
       end

data/lib/httpx/response.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "objspace"
 require "stringio"
 require "tempfile"
 require "fileutils"
@@ -13,6 +14,8 @@ module HTTPX
 
     def_delegator :@body, :to_s
 
+    def_delegator :@body, :to_str
+
     def_delegator :@body, :read
 
     def_delegator :@body, :copy_to
@@ -44,7 +47,7 @@ module HTTPX
     end
 
     def content_type
-      ContentType.parse(@headers["content-type"])
+      @content_type ||= ContentType.new(@headers["content-type"])
     end
 
     def complete?
@@ -54,21 +57,50 @@ module HTTPX
     # :nocov:
     def inspect
       "#<Response:#{object_id} "\
-      "HTTP/#{version} " \
-      "@status=#{@status} " \
-      "@headers=#{@headers} " \
-      "@body=#{@body.bytesize}>"
+        "HTTP/#{version} " \
+        "@status=#{@status} " \
+        "@headers=#{@headers} " \
+        "@body=#{@body.bytesize}>"
     end
     # :nocov:
 
-    def raise_for_status
+    def error
       return if @status < 400
 
-      raise HTTPError, self
+      HTTPError.new(self)
+    end
+
+    def raise_for_status
+      return self unless (err = error)
+
+      raise err
+    end
+
+    def json(options = nil)
+      decode("json", options)
+    end
+
+    def form
+      decode("form")
     end
 
     private
 
+    def decode(format, options = nil)
+      # TODO: check if content-type is a valid format, i.e. "application/json" for json parsing
+      transcoder = Transcoder.registry(format)
+
+      raise Error, "no decoder available for \"#{format}\"" unless transcoder.respond_to?(:decode)
+
+      decoder = transcoder.decode(self)
+
+      raise Error, "no decoder available for \"#{format}\"" unless decoder
+
+      decoder.call(self, options)
+    rescue Registry::Error
+      raise Error, "no decoder available for \"#{format}\""
+    end
+
     def no_data?
       @status < 200 ||
         @status == 204 ||
@@ -134,18 +166,26 @@ module HTTPX
       end
 
       def to_s
-        rewind
-        if @buffer
-          content = @buffer.read
+        case @buffer
+        when StringIO
+          begin
+            @buffer.string.force_encoding(@encoding)
+          rescue ArgumentError
+            @buffer.string
+          end
+        when Tempfile, File
+          rewind
+          content = _with_same_buffer_pos { @buffer.read }
           begin
-            return content.force_encoding(@encoding)
+            content.force_encoding(@encoding)
           rescue ArgumentError # ex: unknown encoding name - utf
-            return content
+            content
           end
+        when nil
+          "".b
+        else
+          @buffer
         end
-        "".b
-      ensure
-        close
       end
       alias_method :to_str, :to_s
 
@@ -177,14 +217,20 @@ module HTTPX
       end
 
       def ==(other)
-        to_s == other.to_s
+        object_id == other.object_id || begin
+          if other.respond_to?(:read)
+            _with_same_buffer_pos { FileUtils.compare_stream(@buffer, other) }
+          else
+            to_s == other.to_s
+          end
+        end
       end
 
       # :nocov:
       def inspect
         "#<HTTPX::Response::Body:#{object_id} " \
-        "@state=#{@state} " \
-        "@length=#{@length}>"
+          "@state=#{@state} " \
+          "@length=#{@length}>"
       end
       # :nocov:
 
@@ -204,7 +250,7 @@ module HTTPX
             @buffer = Tempfile.new("httpx", encoding: Encoding::BINARY, mode: File::RDWR)
           else
             @state = :memory
-            @buffer = StringIO.new("".b, File::RDWR)
+            @buffer = StringIO.new("".b)
           end
         when :memory
           if @length > @threshold_size
@@ -222,6 +268,18 @@ module HTTPX
 
         return unless %i[memory buffer].include?(@state)
       end
+
+      def _with_same_buffer_pos
+        return yield unless @buffer && @buffer.respond_to?(:pos)
+
+        current_pos = @buffer.pos
+        @buffer.rewind
+        begin
+          yield
+        rescue StandardError
+          @buffer.pos = current_pos
+        end
+      end
     end
   end
 
@@ -229,30 +287,22 @@ module HTTPX
     MIME_TYPE_RE = %r{^([^/]+/[^;]+)(?:$|;)}.freeze
     CHARSET_RE   = /;\s*charset=([^;]+)/i.freeze
 
-    attr_reader :mime_type, :charset
-
-    def initialize(mime_type, charset)
-      @mime_type = mime_type
-      @charset = charset
+    def initialize(header_value)
+      @header_value = header_value
     end
 
-    class << self
-      # Parse string and return ContentType struct
-      def parse(str)
-        new(mime_type(str), charset(str))
-      end
+    def mime_type
+      return @mime_type if defined?(@mime_type)
 
-      private
+      m = @header_value.to_s[MIME_TYPE_RE, 1]
+      m && @mime_type = m.strip.downcase
+    end
 
-      def mime_type(str)
-        m = str.to_s[MIME_TYPE_RE, 1]
-        m && m.strip.downcase
-      end
+    def charset
+      return @charset if defined?(@charset)
 
-      def charset(str)
-        m = str.to_s[CHARSET_RE, 1]
-        m && m.strip.delete('"')
-      end
+      m = @header_value.to_s[CHARSET_RE, 1]
+      m && @charset = m.strip.delete('"')
     end
   end
 
@@ -269,31 +319,24 @@ module HTTPX
     end
 
     def status
+      warn ":#{__method__} is deprecated, use :error.message instead"
       @error.message
     end
 
     if Exception.method_defined?(:full_message)
       def to_s
-        @error.full_message
+        @error.full_message(highlight: false)
       end
     else
       def to_s
         "#{@error.message} (#{@error.class})\n" \
-        "#{@error.backtrace.join("\n") if @error.backtrace}"
+          "#{@error.backtrace.join("\n") if @error.backtrace}"
       end
     end
 
     def raise_for_status
       raise @error
     end
-
-    # rubocop:disable Style/MissingRespondToMissing
-    def method_missing(meth, *, &block)
-      raise NoMethodError, "undefined response method `#{meth}' for error response" if @options.response_class.public_method_defined?(meth)
-
-      super
-    end
-    # rubocop:enable Style/MissingRespondToMissing
   end
 end
 

data/lib/httpx/selector.rb

@@ -2,20 +2,6 @@
 
 require "io/wait"
 
-module IOExtensions
-  refine IO do
-    # 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
-
 class HTTPX::Selector
   READABLE = %i[rw r].freeze
   WRITABLE = %i[rw w].freeze
@@ -23,7 +9,7 @@ class HTTPX::Selector
   private_constant :READABLE
   private_constant :WRITABLE
 
-  using IOExtensions unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2
+  using HTTPX::IOExtensions
 
   def initialize
     @selectables = []
@@ -43,9 +29,6 @@ class HTTPX::Selector
 
   private
 
-  READ_INTERESTS = %i[r rw].freeze
-  WRITE_INTERESTS = %i[w rw].freeze
-
   def select_many(interval, &block)
     selectables, r, w = nil
 
@@ -61,11 +44,13 @@ class HTTPX::Selector
           selectables = @selectables
           @selectables = []
 
-          selectables.each do |io|
+          selectables.delete_if do |io|
             interests = io.interests
 
-            (r ||= []) << io if READ_INTERESTS.include?(interests)
-            (w ||= []) << io if WRITE_INTERESTS.include?(interests)
+            (r ||= []) << io if READABLE.include?(interests)
+            (w ||= []) << io if WRITABLE.include?(interests)
+
+            io.state == :closed
           end
 
           if @selectables.empty?
@@ -73,7 +58,7 @@ class HTTPX::Selector
 
             # do not run event loop if there's nothing to wait on.
             # this might happen if connect failed and connection was unregistered.
-            return if (!r || r.empty?) && (!w || w.empty?)
+            return if (!r || r.empty?) && (!w || w.empty?) && !selectables.empty?
 
             break
           else
@@ -89,7 +74,7 @@ class HTTPX::Selector
 
       readers, writers = IO.select(r, w, nil, interval)
 
-      raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") if readers.nil? && writers.nil?
+      raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") if readers.nil? && writers.nil? && interval
     rescue IOError, SystemCallError
       @selectables.reject!(&:closed?)
       retry
@@ -112,6 +97,8 @@ class HTTPX::Selector
   def select_one(interval)
     io = @selectables.first
 
+    return unless io
+
     interests = io.interests
 
     result = case interests
@@ -121,7 +108,7 @@ class HTTPX::Selector
              when nil then return
     end
 
-    raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") unless result
+    raise HTTPX::TimeoutError.new(interval, "timed out while waiting on select") unless result || interval.nil?
 
     yield io
   rescue IOError, SystemCallError