httpx 0.8.0 → 0.10.1

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)

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
@@ -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)
@@ -122,13 +139,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 +196,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 +210,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 +226,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 +250,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,24 @@
 module HTTPX
   module Transcoder
     extend Registry
+
+    def self.normalize_keys(key, value, &block)
+      if value.respond_to?(:to_ary)
+        if value.empty?
+          block.call("#{key}[]")
+        else
+          value.to_ary.each do |element|
+            normalize_keys("#{key}[]", element, &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, &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

data/lib/httpx/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTPX
-  VERSION = "0.8.0"
+  VERSION = "0.10.1"
 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