httpx 1.2.5 → 1.3.0

data/lib/httpx/request/body.rb

@@ -4,30 +4,53 @@ module HTTPX
   # Implementation of the HTTP Request body as a delegator which iterates (responds to +each+) payload chunks.
   class Request::Body < SimpleDelegator
     class << self
-      def new(_, options)
-        return options.body if options.body.is_a?(self)
+      def new(_, options, body: nil, **params)
+        if body.is_a?(self)
+          # request derives its options from body
+          body.options = options.merge(params)
+          return body
+        end
 
         super
       end
     end
 
-    # inits the instance with the request +headers+ and +options+, which contain the payload definition.
-    def initialize(headers, options)
-      @headers = headers
+    attr_accessor :options
 
-      # forego compression in the Range request case
-      if @headers.key?("range")
-        @headers.delete("accept-encoding")
-      else
-        @headers["accept-encoding"] ||= options.supported_compression_formats
+    # inits the instance with the request +headers+, +options+ and +params+, which contain the payload definition.
+    # it wraps the given body with the appropriate encoder on initialization.
+    #
+    #   ..., json: { foo: "bar" }) #=> json encoder
+    #   ..., form: { foo: "bar" }) #=> form urlencoded encoder
+    #   ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
+    #   ..., form: { body: "bla") }) #=> raw data encoder
+    def initialize(headers, options, body: nil, form: nil, json: nil, xml: nil, **params)
+      @headers = headers
+      @options = options.merge(params)
+
+      @body = if body
+        Transcoder::Body.encode(body)
+      elsif form
+        Transcoder::Form.encode(form)
+      elsif json
+        Transcoder::JSON.encode(json)
+      elsif xml
+        Transcoder::Xml.encode(xml)
       end
 
-      initialize_body(options)
+      if @body
+        if @options.compress_request_body && @headers.key?("content-encoding")
 
-      return if @body.nil?
+          @headers.get("content-encoding").each do |encoding|
+            @body = self.class.initialize_deflater_body(@body, encoding)
+          end
+        end
+
+        @headers["content-type"] ||= @body.content_type
+        @headers["content-length"] = @body.bytesize unless unbounded_body?
+      end
 
-      @headers["content-type"] ||= @body.content_type
-      @headers["content-length"] = @body.bytesize unless unbounded_body?
       super(@body)
     end
 
@@ -99,33 +122,6 @@ module HTTPX
     end
     # :nocov:
 
-    private
-
-    # wraps the given body with the appropriate encoder.
-    #
-    #   ..., json: { foo: "bar" }) #=> json encoder
-    #   ..., form: { foo: "bar" }) #=> form urlencoded encoder
-    #   ..., form: { foo: Pathname.open("path/to/file") }) #=> multipart urlencoded encoder
-    #   ..., form: { foo: File.open("path/to/file") }) #=> multipart urlencoded encoder
-    #   ..., form: { body: "bla") }) #=> raw data encoder
-    def initialize_body(options)
-      @body = if options.body
-        Transcoder::Body.encode(options.body)
-      elsif options.form
-        Transcoder::Form.encode(options.form)
-      elsif options.json
-        Transcoder::JSON.encode(options.json)
-      elsif options.xml
-        Transcoder::Xml.encode(options.xml)
-      end
-
-      return unless @body && options.compress_request_body && @headers.key?("content-encoding")
-
-      @headers.get("content-encoding").each do |encoding|
-        @body = self.class.initialize_deflater_body(@body, encoding)
-      end
-    end
-
     class << self
       # returns the +body+ wrapped with the correct deflater accordinng to the given +encodisng+.
       def initialize_deflater_body(body, encoding)

data/lib/httpx/request.rb

@@ -46,12 +46,43 @@ module HTTPX
     # will be +true+ when request body has been completely flushed.
     def_delegator :@body, :empty?
 
-    # initializes the instance with the given +verb+, an absolute or relative +uri+, and the
-    # request options.
-    def initialize(verb, uri, options = {})
+    # initializes the instance with the given +verb+ (an upppercase String, ex. 'GEt'),
+    # an absolute or relative +uri+ (either as String or URI::HTTP object), the
+    # request +options+ (instance of HTTPX::Options) and an optional Hash of +params+.
+    #
+    # Besides any of the options documented in HTTPX::Options (which would override or merge with what
+    # +options+ sets), it accepts also the following:
+    #
+    # :params :: hash or array of key-values which will be encoded and set in the query string of request uris.
+    # :body :: to be encoded in the request body payload. can be a String, an IO object (i.e. a File), or an Enumerable.
+    # :form :: hash of array of key-values which will be form-urlencoded- or multipart-encoded in requests body payload.
+    # :json :: hash of array of key-values which will be JSON-encoded in requests body payload.
+    # :xml :: Nokogiri XML nodes which will be encoded in requests body payload.
+    #
+    # :body, :form, :json and :xml are all mutually exclusive, i.e. only one of them gets picked up.
+    def initialize(verb, uri, options, params = EMPTY_HASH)
       @verb    = verb.to_s.upcase
-      @options = Options.new(options)
       @uri     = Utils.to_uri(uri)
+
+      @headers = options.headers.dup
+      merge_headers(params.delete(:headers)) if params.key?(:headers)
+
+      @headers["user-agent"] ||= USER_AGENT
+      @headers["accept"]     ||= "*/*"
+
+      # forego compression in the Range request case
+      if @headers.key?("range")
+        @headers.delete("accept-encoding")
+      else
+        @headers["accept-encoding"] ||= options.supported_compression_formats
+      end
+
+      @query_params = params.delete(:params) if params.key?(:params)
+
+      @body = options.request_body_class.new(@headers, options, **params)
+
+      @options = @body.options
+
       if @uri.relative?
         origin = @options.origin
         raise(Error, "invalid URI: #{@uri}") unless origin
@@ -61,11 +92,6 @@ module HTTPX
         @uri = origin.merge("#{base_path}#{@uri}")
       end
 
-      @headers = @options.headers.dup
-      @headers["user-agent"] ||= USER_AGENT
-      @headers["accept"]     ||= "*/*"
-
-      @body = @options.request_body_class.new(@headers, @options)
       @state = :idle
       @response = nil
       @peer_address = nil
@@ -172,7 +198,7 @@ module HTTPX
       return @query if defined?(@query)
 
       query = []
-      if (q = @options.params)
+      if (q = @query_params)
         query << Transcoder::Form.encode(q)
       end
       query << @uri.query if @uri.query

data/lib/httpx/resolver/https.rb

@@ -219,7 +219,7 @@ module HTTPX
         uri.query = URI.encode_www_form(params)
         request = rklass.new("GET", uri, @options)
       else
-        request = rklass.new("POST", uri, @options.merge(body: [payload]))
+        request = rklass.new("POST", uri, @options, body: [payload])
         request.headers["content-type"] = "application/dns-message"
       end
       request.headers["accept"] = "application/dns-message"

data/lib/httpx/resolver/native.rb

@@ -65,6 +65,7 @@ module HTTPX
       if nameserver && @ns_index < nameserver.size
         log { "resolver: failed resolving on nameserver #{@nameserver[@ns_index - 1]} (#{e.message})" }
         transition(:idle)
+        @timeouts.clear
       else
         handle_error(e)
       end
@@ -143,13 +144,16 @@ module HTTPX
 
       if !@timeouts[host].empty?
         log { "resolver: timeout after #{timeout}s, retry(#{@timeouts[host].first}) #{host}..." }
-        resolve(connection)
+        # must downgrade to tcp AND retry on same host as last
+        downgrade_socket
+        resolve(connection, h)
       elsif @ns_index + 1 < @nameserver.size
         # try on the next nameserver
         @ns_index += 1
         log { "resolver: failed resolving #{host} on nameserver #{@nameserver[@ns_index - 1]} (timeout error)" }
         transition(:idle)
-        resolve(connection)
+        @timeouts.clear
+        resolve(connection, h)
       else
 
         @timeouts.delete(host)
@@ -187,10 +191,9 @@ module HTTPX
             next unless @large_packet.full?
 
             parse(@large_packet.to_s)
-            @socket_type = @resolver_options.fetch(:socket_type, :udp)
             @large_packet = nil
-            transition(:idle)
-            transition(:open)
+            # downgrade to udp again
+            downgrade_socket
             return
           else
             size = @read_buffer[0, 2].unpack1("n")
@@ -304,13 +307,21 @@ module HTTPX
         end
 
         if address.key?("alias") # CNAME
+          hostname_alias = address["alias"]
           # clean up intermediate queries
           @timeouts.delete(name) unless connection.origin.host == name
 
-          if catch(:coalesced) { early_resolve(connection, hostname: address["alias"]) }
+          if catch(:coalesced) { early_resolve(connection, hostname: hostname_alias) }
             @connections.delete(connection)
           else
-            resolve(connection, address["alias"])
+            if @socket_type == :tcp
+              # must downgrade to udp if tcp
+              @socket_type = @resolver_options.fetch(:socket_type, :udp)
+              transition(:idle)
+              transition(:open)
+            end
+            log { "resolver: ALIAS #{hostname_alias} for #{name}" }
+            resolve(connection, hostname_alias)
             return
           end
         else
@@ -386,6 +397,14 @@ module HTTPX
       end
     end
 
+    def downgrade_socket
+      return unless @socket_type == :tcp
+
+      @socket_type = @resolver_options.fetch(:socket_type, :udp)
+      transition(:idle)
+      transition(:open)
+    end
+
     def transition(nextstate)
       case nextstate
       when :idle
@@ -393,7 +412,6 @@ module HTTPX
           @io.close
           @io = nil
         end
-        @timeouts.clear
       when :open
         return unless @state == :idle
 

data/lib/httpx/resolver/resolver.rb

@@ -33,7 +33,7 @@ module HTTPX
     def initialize(family, options)
       @family = family
       @record_type = RECORD_TYPES[family]
-      @options = Options.new(options)
+      @options = options
     end
 
     def close; end

data/lib/httpx/response.rb

@@ -247,11 +247,11 @@ module HTTPX
     # the IP address of the peer server.
     def_delegator :@request, :peer_address
 
-    def initialize(request, error, options)
+    def initialize(request, error)
       @request = request
       @response = request.response if request.response.is_a?(Response)
       @error = error
-      @options = Options.new(options)
+      @options = request.options
       log_exception(@error)
     end
 

data/lib/httpx/session.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module HTTPX
+  EMPTY_HASH = {}.freeze
+
   # Class implementing the APIs being used publicly.
   #
   #   HTTPX.get(..) #=> delegating to an internal HTTPX::Session object.
@@ -9,8 +11,6 @@ module HTTPX
     include Loggable
     include Chainable
 
-    EMPTY_HASH = {}.freeze
-
     # initializes the session with a set of +options+, which will be shared by all
     # requests sent from it.
     #
@@ -65,10 +65,10 @@ module HTTPX
     #  resp1, resp2 = session.request(["POST", "https://server.org/a", form: { "foo" => "bar" }], ["GET", "https://server.org/b"])
     #  resp1, resp2 = session.request("GET", ["https://server.org/a", "https://server.org/b"], headers: { "x-api-token" => "TOKEN" })
     #
-    def request(*args, **options)
+    def request(*args, **params)
       raise ArgumentError, "must perform at least one request" if args.empty?
 
-      requests = args.first.is_a?(Request) ? args : build_requests(*args, options)
+      requests = args.first.is_a?(Request) ? args : build_requests(*args, params)
       responses = send_requests(*requests)
       return responses.first if responses.size == 1
 
@@ -81,10 +81,9 @@ module HTTPX
     #
     #   req = session.build_request("GET", "https://server.com")
     #   resp = session.request(req)
-    def build_request(verb, uri, options = EMPTY_HASH)
-      rklass = @options.request_class
-      options = @options.merge(options) unless options.is_a?(Options)
-      request = rklass.new(verb, uri, options)
+    def build_request(verb, uri, params = EMPTY_HASH, options = @options)
+      rklass = options.request_class
+      request = rklass.new(verb, uri, options, params)
       request.persistent = @persistent
       set_request_callbacks(request)
       request
@@ -133,7 +132,7 @@ module HTTPX
       end
       return unless error.is_a?(Error)
 
-      request.emit(:response, ErrorResponse.new(request, error, options))
+      request.emit(:response, ErrorResponse.new(request, error))
     end
 
     # sets the callbacks on the +connection+ required to process certain specific
@@ -192,22 +191,26 @@ module HTTPX
     end
 
     # returns a set of HTTPX::Request objects built from the given +args+ and +options+.
-    def build_requests(*args, options)
-      request_options = @options.merge(options)
-
+    def build_requests(*args, params)
       requests = if args.size == 1
         reqs = args.first
-        reqs.map do |verb, uri, opts = EMPTY_HASH|
-          build_request(verb, uri, request_options.merge(opts))
+        # TODO: find a way to make requests share same options object
+        reqs.map do |verb, uri, ps = EMPTY_HASH|
+          request_params = params
+          request_params = request_params.merge(ps) unless ps.empty?
+          build_request(verb, uri, request_params)
         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))
+          # TODO: find a way to make requests share same options object
+          uris.enum_for(:each).map do |uri, ps = EMPTY_HASH|
+            request_params = params
+            request_params = request_params.merge(ps) unless ps.empty?
+            build_request(verb, uri, request_params)
           end
         else
-          [build_request(verb, uris, request_options)]
+          [build_request(verb, uris, params)]
         end
       end
       raise ArgumentError, "wrong number of URIs (given 0, expect 1..+1)" if requests.empty?

data/lib/httpx/timers.rb

@@ -43,7 +43,7 @@ module HTTPX
 
       elapsed_time = Utils.elapsed_time(@next_interval_at)
 
-      @intervals.delete_if { |interval| interval.elapse(elapsed_time) <= 0 }
+      @intervals = @intervals.drop_while { |interval| interval.elapse(elapsed_time) <= 0 }
 
       @next_interval_at = nil if @intervals.empty?
     end

data/lib/httpx/transcoder/multipart/encoder.rb

@@ -19,7 +19,7 @@ module HTTPX
       end
 
       def read(length = nil, outbuf = nil)
-        data   = outbuf.clear.force_encoding(Encoding::BINARY) if outbuf
+        data   = String(outbuf).clear.force_encoding(Encoding::BINARY) if outbuf
         data ||= "".b
 
         read_chunks(data, length)

data/lib/httpx/version.rb

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

data/sig/chainable.rbs

@@ -3,8 +3,8 @@ module HTTPX
     def request: (*Request, **untyped) -> Array[response]
                | (Request, **untyped) -> response
                | (verb, uri | [uri], **untyped) -> response
-               | (Array[[verb, uri] | [verb, uri, options]], **untyped) -> Array[response]
-               | (verb, _Each[uri | [uri, options]], **untyped) -> Array[response]
+               | (Array[[verb, uri] | [verb, uri, request_params]], **untyped) -> Array[response]
+               | (verb, _Each[uri | [uri, request_params]], **untyped) -> Array[response]
 
     def accept: (String) -> Session
     def wrap: () { (Session) -> void } -> void

data/sig/connection/http1.rbs

@@ -32,7 +32,7 @@ module HTTPX
 
     def exhausted?: () -> bool
 
-    def <<: (String) -> void
+    def <<: (string) -> void
 
     def send: (Request) -> void
 
@@ -58,7 +58,7 @@ module HTTPX
 
     private
 
-    def initialize: (Buffer, options) -> untyped
+    def initialize: (Buffer buffer, Options options) -> untyped
 
     def manage_connection: (Request request, Response response) -> void
 

data/sig/connection/http2.rbs

@@ -5,7 +5,7 @@ module HTTPX
 
     MAX_CONCURRENT_REQUESTS: Integer
 
-    attr_reader streams: Hash[Request, HTTP2Next::Stream]
+    attr_reader streams: Hash[Request, ::HTTP2::Stream]
     attr_reader pending: Array[Request]
 
     @options: Options
@@ -24,7 +24,7 @@ module HTTPX
 
     def exhausted?: () -> bool
 
-    def <<: (String) -> void
+    def <<: (string) -> void
 
     def can_buffer_more_requests?: () -> bool
 
@@ -42,35 +42,35 @@ module HTTPX
 
     private
 
-    def initialize: (Buffer, options) -> untyped
+    def initialize: (Buffer buffer, Options options) -> untyped
 
     def send_pending: () -> void
 
     def set_protocol_headers: (Request) -> _Each[[String, String]]
 
-    def handle: (Request request, HTTP2Next::Stream stream) -> void
+    def handle: (Request request, ::HTTP2::Stream stream) -> void
 
     def init_connection: () -> void
 
-    def handle_stream: (HTTP2Next::Stream stream, Request request) -> void
+    def handle_stream: (::HTTP2::Stream stream, Request request) -> void
 
     def join_headline: (Request request) -> String
 
-    def join_headers: (HTTP2Next::Stream stream, Request request) -> void
+    def join_headers: (::HTTP2::Stream stream, Request request) -> void
 
-    def join_trailers: (HTTP2Next::Stream stream, Request request) -> void
+    def join_trailers: (::HTTP2::Stream stream, Request request) -> void
 
-    def join_body: (HTTP2Next::Stream stream, Request request) -> void
+    def join_body: (::HTTP2::Stream stream, Request request) -> void
 
-    def on_stream_headers: (HTTP2Next::Stream stream, Request request, Array[[String, String]] headers) -> void
+    def on_stream_headers: (::HTTP2::Stream stream, Request request, Array[[String, String]] headers) -> void
 
-    def on_stream_trailers: (HTTP2Next::Stream stream, Response response, Array[[String, String]] headers) -> void
+    def on_stream_trailers: (::HTTP2::Stream stream, Response response, Array[[String, String]] headers) -> void
 
-    def on_stream_data: (HTTP2Next::Stream stream, Request request, String data) -> void
+    def on_stream_data: (::HTTP2::Stream stream, Request request, String data) -> void
 
-    def on_stream_refuse: (HTTP2Next::Stream stream, Request request, StandardError error) -> void
+    def on_stream_refuse: (::HTTP2::Stream stream, Request request, StandardError error) -> void
 
-    def on_stream_close: (HTTP2Next::Stream stream, Request request, (Symbol | StandardError)? error) -> void
+    def on_stream_close: (::HTTP2::Stream stream, Request request, (Symbol | StandardError)? error) -> void
 
     def on_frame: (string bytes) -> void
 
@@ -78,13 +78,13 @@ module HTTPX
 
     def on_close: (Integer last_frame, Symbol? error, String? payload) -> void
 
-    def on_frame_sent: (HTTP2Next::frame) -> void
+    def on_frame_sent: (::HTTP2::frame) -> void
 
-    def on_frame_received: (HTTP2Next::frame) -> void
+    def on_frame_received: (::HTTP2::frame) -> void
 
-    def on_altsvc: (String origin, HTTP2Next::frame) -> void
+    def on_altsvc: (String origin, ::HTTP2::frame) -> void
 
-    def on_promise: (HTTP2Next::Stream) -> void
+    def on_promise: (::HTTP2::Stream) -> void
 
     def on_origin: (String) -> void
 

data/sig/connection.rbs

@@ -20,11 +20,12 @@ module HTTPX
 
 
     attr_reader type: io_type
-    attr_reader origin: URI::Generic
+    attr_reader origin: http_uri
     attr_reader origins: Array[String]
     attr_reader state: Symbol
     attr_reader pending: Array[Request]
     attr_reader options: Options
+    attr_reader ssl_session: OpenSSL::SSL::Session?
     attr_writer timers: Timers
 
     attr_accessor family: Integer?
@@ -37,7 +38,7 @@ module HTTPX
     @timeout: Numeric?
     @current_timeout: Numeric?
     @io: TCP | SSL | UNIX
-    @parser: HTTP1 | HTTP2 | _Parser
+    @parser: Object & _Parser
     @connected_at: Float
     @response_received_at: Float
     @intervals: Array[Timers::Interval]
@@ -92,9 +93,9 @@ module HTTPX
 
     private
 
-    def initialize: (URI::Generic uri, options) -> void
+    def initialize: (http_uri uri, Options options) -> void
 
-    def initialize_type: (URI::Generic uri, options) -> io_type
+    def initialize_type: (http_uri uri, Options options) -> io_type
 
     def connect: () -> void
 
@@ -104,11 +105,11 @@ module HTTPX
 
     def send_pending: () -> void
 
-    def parser: () -> (HTTP1 | HTTP2 | _Parser)
+    def parser: () -> (Object & _Parser)
 
     def send_request_to_parser: (Request request) -> void
 
-    def build_parser: (?String protocol) -> (HTTP1 | HTTP2)
+    def build_parser: (?String protocol) -> (Object & _Parser)
 
     def set_parser_callbacks: (HTTP1 | HTTP2 parser) -> void
 

data/sig/httpx.rbs

@@ -9,9 +9,9 @@ module HTTPX
   type uri = http_uri | string
   type generic_uri = String | URI::Generic
 
-  type verb = "OPTIONS" | "GET" | "HEAD" | "POST" | "PUT" | "DELETE" | "TRACE" | "CONNECT" |
-              "PROPFIND" | "PROPPATCH" | "MKCOL" | "COPY" | "MOVE" | "LOCK" | "UNLOCK" | "ORDERPATCH" |
-              "ACL" | "REPORT" | "PATCH" | "SEARCH"
+  type verb = String
+
+  type request_params = Hash[Symbol, untyped]
 
   type ip_family = Integer #Socket::AF_INET6 | Socket::AF_INET
 

data/sig/io/ssl.rbs

@@ -14,6 +14,7 @@ module HTTPX
     # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
     # def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (self) -> void } -> void
 
+    def session_new_cb: { (OpenSSL::SSL::Session sess) -> void } -> void
     def can_verify_peer?: () -> bool
 
     def verify_hostname: (String host) -> bool

data/sig/io/tcp.rbs

@@ -15,7 +15,7 @@ module HTTPX
     alias host ip
 
     # TODO: lift when https://github.com/ruby/rbs/issues/1497 fixed
-    def initialize: (URI::Generic origin, Array[ipaddr]? addresses, options options) ?{ (self) -> void } -> void
+    def initialize: (URI::Generic origin, Array[ipaddr]? addresses, Options options) ?{ (instance) -> void } -> void
 
     def add_addresses: (Array[ipaddr] addrs) -> void
 

data/sig/io/unix.rbs

@@ -5,6 +5,23 @@ module HTTPX
 
     alias host path
 
-    def initialize: (http_uri origin, Array[String]? addresses, options options) -> void
+    @hostname: String
+
+    @options: Options
+
+    @fallback_protocol: String
+
+    @keep_open: bool
+
+    @io: Socket
+
+    def initialize: (http_uri origin, String? path, Options options) -> void
+
+    def connect: () -> void
+
+    def expired?: () -> bool
+    private
+
+    def build_socket: () -> Socket
   end
 end

data/sig/options.rbs

@@ -6,6 +6,9 @@ module HTTPX
     WINDOW_SIZE: Integer
     MAX_BODY_THRESHOLD_SIZE: Integer
     CONNECT_TIMEOUT: Integer
+    READ_TIMEOUT: Integer
+    WRITE_TIMEOUT: Integer
+    REQUEST_TIMEOUT: Integer
     OPERATION_TIMEOUT: Integer
     KEEP_ALIVE_TIMEOUT: Integer
     SETTINGS_TIMEOUT: Integer
@@ -46,7 +49,7 @@ module HTTPX
     attr_reader body_threshold_size: Integer
 
     # transport
-    attr_reader transport: "unix" | nil
+    attr_reader transport: io_type | nil
 
     # addresses
     attr_reader addresses: Array[ipaddr]?
@@ -60,19 +63,7 @@ module HTTPX
     # decompress_response_body
     attr_reader decompress_response_body: bool
 
-    # params
-    attr_reader params: Transcoder::urlencoded_input?
-
-    # form
-    attr_reader form: Transcoder::urlencoded_input?
-
-    # json
-    attr_reader json: _ToJson?
-
-    # body
-    attr_reader body: bodyIO?
-
-    # body
+    # origin
     attr_reader origin: URI::Generic?
 
     # base_path