httpx 0.16.1 → 0.17.0

data/lib/httpx/response.rb

@@ -14,6 +14,8 @@ module HTTPX
 
     def_delegator :@body, :to_s
 
+    def_delegator :@body, :to_str
+
     def_delegator :@body, :read
 
     def_delegator :@body, :copy_to
@@ -45,7 +47,7 @@ module HTTPX
     end
 
     def content_type
-      ContentType.parse(@headers["content-type"])
+      @content_type ||= ContentType.new(@headers["content-type"])
     end
 
     def complete?
@@ -68,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 ||
@@ -93,16 +118,6 @@ module HTTPX
         @length = 0
         @buffer = nil
         @state = :idle
-        ObjectSpace.define_finalizer(self, self.class.finalize(@buffer))
-      end
-
-      def self.finalize(buffer)
-        proc {
-          return unless buffer
-
-          @buffer.close
-          @buffer.unlink if @buffer.respond_to?(:unlink)
-        }
       end
 
       def closed?
@@ -264,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
 

data/lib/httpx/selector.rb

@@ -86,7 +86,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
@@ -109,6 +109,8 @@ class HTTPX::Selector
   def select_one(interval)
     io = @selectables.first
 
+    return unless io
+
     interests = io.interests
 
     result = case interests
@@ -118,7 +120,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

data/lib/httpx/session.rb

@@ -32,7 +32,7 @@ module HTTPX
       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)
+      responses = send_requests(*requests)
       return responses.first if responses.size == 1
 
       responses
@@ -40,7 +40,8 @@ module HTTPX
 
     def build_request(verb, uri, options = EMPTY_HASH)
       rklass = @options.request_class
-      request = rklass.new(verb, uri, @options.merge(options).merge(persistent: @persistent))
+      options = @options.merge(options) unless options.is_a?(Options)
+      request = rklass.new(verb, uri, options.merge(persistent: @persistent))
       request.on(:response, &method(:on_response).curry(2)[request])
       request.on(:promise, &method(:on_promise))
       request
@@ -174,37 +175,38 @@ module HTTPX
       end
     end
 
-    def send_requests(*requests, options)
-      request_options = @options.merge(options)
-
-      connections = _send_requests(requests, request_options)
-      receive_requests(requests, connections, request_options)
+    def send_requests(*requests)
+      connections = _send_requests(requests)
+      receive_requests(requests, connections)
     end
 
-    def _send_requests(requests, options)
+    def _send_requests(requests)
       connections = []
 
       requests.each do |request|
         error = catch(:resolve_error) do
-          connection = find_connection(request, connections, options)
+          connection = find_connection(request, connections, request.options)
           connection.send(request)
         end
         next unless error.is_a?(ResolveError)
 
-        request.emit(:response, ErrorResponse.new(request, error, options))
+        request.emit(:response, ErrorResponse.new(request, error, request.options))
       end
 
       connections
     end
 
-    def receive_requests(requests, connections, options)
+    def receive_requests(requests, connections)
       responses = []
 
       begin
         # guarantee ordered responses
         loop do
           request = requests.first
-          pool.next_tick until (response = fetch_response(request, connections, options))
+
+          return responses unless request
+
+          pool.next_tick until (response = fetch_response(request, connections, request.options))
 
           responses << response
           requests.shift
@@ -218,7 +220,7 @@ module HTTPX
           # opportunity to traverse the requests, hence we're returning only a fraction of the errors
           # we were supposed to. This effectively fetches the existing responses and return them.
           while (request = requests.shift)
-            responses << fetch_response(request, connections, options)
+            responses << fetch_response(request, connections, request.options)
           end
           break
         end

data/lib/httpx/transcoder/form.rb

@@ -7,6 +7,8 @@ module HTTPX::Transcoder
   module Form
     module_function
 
+    PARAM_DEPTH_LIMIT = 32
+
     class Encoder
       extend Forwardable
 
@@ -31,9 +33,27 @@ module HTTPX::Transcoder
       end
     end
 
+    module Decoder
+      module_function
+
+      def call(response, _)
+        URI.decode_www_form(response.to_s).each_with_object({}) do |(field, value), params|
+          HTTPX::Transcoder.normalize_query(params, field, value, PARAM_DEPTH_LIMIT)
+        end
+      end
+    end
+
     def encode(form)
       Encoder.new(form)
     end
+
+    def decode(response)
+      content_type = response.content_type.mime_type
+
+      raise Error, "invalid form mime type (#{content_type})" unless content_type == "application/x-www-form-urlencoded"
+
+      Decoder
+    end
   end
   register "form", Form
 end

data/lib/httpx/transcoder/json.rb

@@ -5,6 +5,10 @@ require "json"
 
 module HTTPX::Transcoder
   module JSON
+    JSON_REGEX = %r{\bapplication/(?:vnd\.api\+)?json\b}i.freeze
+
+    using HTTPX::RegexpExtensions unless Regexp.method_defined?(:match?)
+
     module_function
 
     class Encoder
@@ -27,6 +31,14 @@ module HTTPX::Transcoder
     def encode(json)
       Encoder.new(json)
     end
+
+    def decode(response)
+      content_type = response.content_type.mime_type
+
+      raise Error, "invalid json mime type (#{content_type})" unless JSON_REGEX.match?(content_type)
+
+      ::JSON.method(:parse)
+    end
   end
   register "json", JSON
 end

data/lib/httpx/transcoder.rb

@@ -4,7 +4,11 @@ module HTTPX
   module Transcoder
     extend Registry
 
-    def self.normalize_keys(key, value, cond = nil, &block)
+    using RegexpExtensions unless Regexp.method_defined?(:match?)
+
+    module_function
+
+    def normalize_keys(key, value, cond = nil, &block)
       if (cond && cond.call(value))
         block.call(key.to_s, value)
       elsif value.respond_to?(:to_ary)
@@ -23,6 +27,63 @@ module HTTPX
         block.call(key.to_s, value)
       end
     end
+
+    # based on https://github.com/rack/rack/blob/d15dd728440710cfc35ed155d66a98dc2c07ae42/lib/rack/query_parser.rb#L82
+    def normalize_query(params, name, v, depth)
+      raise Error, "params depth surpasses what's supported" if depth <= 0
+
+      name =~ /\A[\[\]]*([^\[\]]+)\]*/
+      k = Regexp.last_match(1) || ""
+      after = Regexp.last_match ? Regexp.last_match.post_match : ""
+
+      if k.empty?
+        return Array(v) if !v.empty? && name == "[]"
+
+        return
+      end
+
+      case after
+      when ""
+        params[k] = v
+      when "["
+        params[name] = v
+      when "[]"
+        params[k] ||= []
+        raise Error, "expected Array (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Array)
+
+        params[k] << v
+      when /^\[\]\[([^\[\]]+)\]$/, /^\[\](.+)$/
+        child_key = Regexp.last_match(1)
+        params[k] ||= []
+        raise Error, "expected Array (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Array)
+
+        if params[k].last.is_a?(Hash) && !params_hash_has_key?(params[k].last, child_key)
+          normalize_query(params[k].last, child_key, v, depth - 1)
+        else
+          params[k] << normalize_query({}, child_key, v, depth - 1)
+        end
+      else
+        params[k] ||= {}
+        raise Error, "expected Hash (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Hash)
+
+        params[k] = normalize_query(params[k], after, v, depth - 1)
+      end
+
+      params
+    end
+
+    def params_hash_has_key?(hash, key)
+      return false if /\[\]/.match?(key)
+
+      key.split(/[\[\]]+/).inject(hash) do |h, part|
+        next h if part == ""
+        return false unless h.is_a?(Hash) && h.key?(part)
+
+        h[part]
+      end
+
+      true
+    end
   end
 end
 

data/lib/httpx/utils.rb

@@ -28,9 +28,9 @@ module HTTPX
       URIParser = URI::RFC2396_Parser.new
 
       def to_uri(uri)
-        return Kernel.URI(uri) unless uri.is_a?(String) && !uri.ascii_only?
+        return URI(uri) unless uri.is_a?(String) && !uri.ascii_only?
 
-        uri = Kernel.URI(URIParser.escape(uri))
+        uri = URI(URIParser.escape(uri))
 
         non_ascii_hostname = URIParser.unescape(uri.host)
 

data/lib/httpx/version.rb

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

data/sig/buffer.rbs

@@ -1,7 +1,7 @@
 module HTTPX
   class Buffer
     extend Forwardable
-    
+
     include _ToS
     include _ToStr
 
@@ -13,7 +13,7 @@ module HTTPX
     def shift!: (Integer) -> void
 
     # delegated
-    def <<: (string data) -> void
+    def <<: (string data) -> String
     def empty?: () -> bool
     def bytesize: () -> Integer
     def clear: () -> void

data/sig/chainable.rbs

@@ -1,6 +1,11 @@
 module HTTPX
   module Chainable
-    def request: (*untyped, **untyped) -> (response | Array[response])
+    def request: (*Request, **untyped) -> Array[response]
+               | (Request, **untyped) -> response
+               | (verb | string, uri | [uri], **untyped) -> response
+               | (Array[[verb | string, uri] | [verb | string, uri, options]], **untyped) -> Array[response]
+               | (verb | string, _Each[uri | [uri, options]], **untyped) -> Array[response]
+
     def accept: (String) -> Session
     def wrap: () { (Session) -> void } -> void
 

data/sig/connection/http1.rbs

@@ -3,6 +3,10 @@ module HTTPX
     include Callbacks
     include Loggable
 
+    UPCASED: Hash[String, String]
+    MAX_REQUESTS: Integer
+    CRLF: String
+
     attr_reader pending: Array[Request]
     attr_reader requests: Array[Request]
 
@@ -30,11 +34,13 @@ module HTTPX
 
     def handle_error: (StandardError ex) -> void
 
+    def on_start: () -> void
+
     def on_headers: (Hash[String, Array[String]] headers) -> void
 
     def on_trailers: (Hash[String, Array[String]] headers) -> void
 
-    def on_data: (string chunk) -> void
+    def on_data: (String chunk) -> void
 
     def on_complete: () -> void
 
@@ -42,7 +48,7 @@ module HTTPX
 
     def ping: () -> void
 
-    def timeout: () -> Integer
+    def timeout: () -> Numeric
 
     private
 
@@ -54,7 +60,7 @@ module HTTPX
 
     def disable_pipelining: () -> void
 
-    def set_protocol_headers: (Request) -> _Each[[headers_key, String]]
+    def set_protocol_headers: (Request) -> _Each[[String, String]]
 
     def headline_uri: (Request) -> String
 
@@ -64,7 +70,7 @@ module HTTPX
 
     def join_trailers: (Request request) -> void
 
-    def join_headers2: (_Each[[headers_key, String]] headers) -> void
+    def join_headers2: (_Each[[String, String]] headers) -> void
 
     def join_body: (Request request) -> void