httpx 0.15.3 → 0.17.0

data/lib/httpx/plugins/retries.rb

@@ -17,39 +17,43 @@ module HTTPX
                           Errno::ECONNRESET,
                           Errno::ECONNABORTED,
                           Errno::EPIPE,
-                          (TLSError if defined?(TLSError)),
+                          TLSError,
                           TimeoutError,
                           Parser::Error,
                           Errno::EINVAL,
                           Errno::ETIMEDOUT].freeze
 
       def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:retry_after, <<-OUT)
-            # return early if callable
-            unless value.respond_to?(:call)
-              value = Integer(value)
-              raise Error, ":retry_after must be positive" unless value.positive?
-            end
+        options.merge(max_retries: MAX_RETRIES)
+      end
+
+      module OptionsMethods
+        def option_retry_after(value)
+          # return early if callable
+          unless value.respond_to?(:call)
+            value = Integer(value)
+            raise TypeError, ":retry_after must be positive" unless value.positive?
+          end
 
-            value
-          OUT
+          value
+        end
 
-          def_option(:max_retries, <<-OUT)
-            num = Integer(value)
-            raise Error, ":max_retries must be positive" unless num.positive?
+        def option_max_retries(value)
+          num = Integer(value)
+          raise TypeError, ":max_retries must be positive" unless num.positive?
 
-            num
-          OUT
+          num
+        end
 
-          def_option(:retry_change_requests)
+        def option_retry_change_requests(v)
+          v
+        end
 
-          def_option(:retry_on, <<-OUT)
-            raise ":retry_on must be called with the response" unless value.respond_to?(:call)
+        def option_retry_on(value)
+          raise ":retry_on must be called with the response" unless value.respond_to?(:call)
 
-            value
-          OUT
-        end.new(options).merge(max_retries: MAX_RETRIES)
+          value
+        end
       end
 
       module InstanceMethods

data/lib/httpx/plugins/stream.rb

@@ -6,7 +6,6 @@ module HTTPX
       @request = request
       @session = session
       @connections = connections
-      @options = @request.options
     end
 
     def each(&block)
@@ -72,7 +71,7 @@ module HTTPX
     private
 
     def response
-      @session.__send__(:receive_requests, [@request], @connections, @options) until @request.response
+      @session.__send__(:receive_requests, [@request], @connections) until @request.response
 
       @request.response
     end
@@ -106,7 +105,7 @@ module HTTPX
 
           request = requests.first
 
-          connections = _send_requests(requests, request.options)
+          connections = _send_requests(requests)
 
           StreamResponse.new(request, self, connections)
         end

data/lib/httpx/plugins/upgrade.rb

@@ -18,14 +18,15 @@ module HTTPX
           upgrade_handlers = Module.new do
             extend Registry
           end
+          options.merge(upgrade_handlers: upgrade_handlers)
+        end
+      end
 
-          Class.new(options.class) do
-            def_option(:upgrade_handlers, <<-OUT)
-              raise Error, ":upgrade_handlers must be a registry" unless value.respond_to?(:registry)
+      module OptionsMethods
+        def option_upgrade_handlers(value)
+          raise TypeError, ":upgrade_handlers must be a registry" unless value.respond_to?(:registry)
 
-              value
-            OUT
-          end.new(options).merge(upgrade_handlers: upgrade_handlers)
+          value
         end
       end
 

data/lib/httpx/registry.rb

@@ -31,7 +31,7 @@ module HTTPX
   #
   module Registry
     # Base Registry Error
-    Error = Class.new(Error)
+    class Error < Error; end
 
     def self.extended(klass)
       super
@@ -59,7 +59,7 @@ module HTTPX
         @registry ||= {}
         return @registry if tag.nil?
 
-        handler = @registry.fetch(tag)
+        handler = @registry[tag]
         raise(Error, "#{tag} is not registered in #{self}") unless handler
 
         handler

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
@@ -155,9 +155,9 @@ module HTTPX
     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,6 +177,7 @@ module HTTPX
 
         @headers["content-type"] ||= @body.content_type
         @headers["content-length"] = @body.bytesize unless unbounded_body?
+        super(@body)
       end
 
       def each(&block)
@@ -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?
@@ -238,16 +239,6 @@ module HTTPX
         "#{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,8 +24,6 @@ module HTTPX
       record_types: RECORD_TYPES.keys,
     }.freeze
 
-    def_delegator :@connections, :empty?
-
     def_delegators :@resolver_connection, :connecting?, :to_io, :call, :close
 
     def initialize(options)

data/lib/httpx/resolver/native.rb

@@ -217,15 +217,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/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?
@@ -67,8 +70,31 @@ module HTTPX
       raise HTTPError, self
     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 +160,26 @@ module HTTPX
       end
 
       def to_s
-        rewind
-        if @buffer
-          content = @buffer.read
+        case @buffer
+        when StringIO
           begin
-            return content.force_encoding(@encoding)
+            @buffer.string.force_encoding(@encoding)
+          rescue ArgumentError
+            @buffer.string
+          end
+        when Tempfile, File
+          rewind
+          content = _with_same_buffer_pos { @buffer.read }
+          begin
+            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,7 +211,11 @@ module HTTPX
       end
 
       def ==(other)
-        to_s == other.to_s
+        if other.respond_to?(:read)
+          _with_same_buffer_pos { FileUtils.compare_stream(@buffer, other) }
+        else
+          to_s == other.to_s
+        end
       end
 
       # :nocov:
@@ -204,7 +242,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 +260,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 +279,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
 
@@ -286,14 +328,6 @@ module HTTPX
     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