httpx 0.13.0 → 0.14.2

data/lib/httpx/headers.rb

@@ -103,16 +103,20 @@ module HTTPX
     # returns the enumerable headers store in pairs of header field + the values in
     # the comma-separated string format
     #
-    def each
-      return enum_for(__method__) { @headers.size } unless block_given?
+    def each(extra_headers = nil)
+      return enum_for(__method__, extra_headers) { @headers.size } unless block_given?
 
       @headers.each do |field, value|
         yield(field, value.join(", ")) unless value.empty?
       end
+
+      extra_headers.each do |field, value|
+        yield(field, value) unless value.empty?
+      end if extra_headers
     end
 
     def ==(other)
-      to_hash == Headers.new(other).to_hash
+      other == to_hash
     end
 
     # the headers store in Hash format

data/lib/httpx/io/tcp.rb

@@ -63,7 +63,7 @@ module HTTPX
       @ip_index -= 1
       retry
     rescue Errno::ETIMEDOUT => e
-      raise ConnectTimeoutError.new(@options.timeout.connect_timeout, e.message) if @ip_index <= 0
+      raise ConnectTimeoutError.new(@options.timeout[:connect_timeout], e.message) if @ip_index <= 0
 
       @ip_index -= 1
       retry
@@ -120,6 +120,8 @@ module HTTPX
         end
         transition(:connected)
         @interests = :w
+      rescue Errno::EALREADY
+        @interests = :w
       end
       private :try_connect
 

data/lib/httpx/io/udp.rb

@@ -39,16 +39,20 @@ module HTTPX
       end
     end
 
-    def write(buffer)
-      siz = @io.send(buffer.to_s, 0, @host, @port)
-      log { "WRITE: #{siz} bytes..." }
-      buffer.shift!(siz)
-      siz
-    end
-
     # :nocov:
     if (RUBY_ENGINE == "truffleruby" && RUBY_ENGINE_VERSION < "21.1.0") ||
        RUBY_VERSION < "2.3"
+      def write(buffer)
+        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s))
+        log { "WRITE: #{siz} bytes..." }
+        buffer.shift!(siz)
+        siz
+      rescue ::IO::WaitWritable
+        0
+      rescue EOFError
+        nil
+      end
+
       def read(size, buffer)
         data, _ = @io.recvfrom_nonblock(size)
         buffer.replace(data)
@@ -59,6 +63,18 @@ module HTTPX
       rescue IOError
       end
     else
+
+      def write(buffer)
+        siz = @io.sendmsg_nonblock(buffer.to_s, 0, Socket.sockaddr_in(@port, @host.to_s), exception: false)
+        return 0 if siz == :wait_writable
+        return if siz.nil?
+
+        log { "WRITE: #{siz} bytes..." }
+
+        buffer.shift!(siz)
+        siz
+      end
+
       def read(size, buffer)
         ret = @io.recvfrom_nonblock(size, 0, buffer, exception: false)
         return 0 if ret == :wait_readable
@@ -68,6 +84,14 @@ module HTTPX
       rescue IOError
       end
     end
+
+    # In JRuby, sendmsg_nonblock is not implemented
+    def write(buffer)
+      siz = @io.send(buffer.to_s, 0, @host, @port)
+      log { "WRITE: #{siz} bytes..." }
+      buffer.shift!(siz)
+      siz
+    end if RUBY_ENGINE == "jruby"
     # :nocov:
   end
 end

data/lib/httpx/options.rb

@@ -4,6 +4,37 @@ module HTTPX
   class Options
     WINDOW_SIZE = 1 << 14 # 16K
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
+    CONNECT_TIMEOUT = 60
+    OPERATION_TIMEOUT = 60
+    KEEP_ALIVE_TIMEOUT = 20
+
+    DEFAULT_OPTIONS = {
+      :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
+      :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
+      :ssl => {},
+      :http2_settings => { settings_enable_push: 0 },
+      :fallback_protocol => "http/1.1",
+      :timeout => {
+        connect_timeout: CONNECT_TIMEOUT,
+        operation_timeout: OPERATION_TIMEOUT,
+        keep_alive_timeout: KEEP_ALIVE_TIMEOUT,
+      },
+      :headers => {},
+      :window_size => WINDOW_SIZE,
+      :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
+      :request_class => Class.new(Request),
+      :response_class => Class.new(Response),
+      :headers_class => Class.new(Headers),
+      :request_body_class => Class.new(Request::Body),
+      :response_body_class => Class.new(Response::Body),
+      :connection_class => Class.new(Connection),
+      :transport => nil,
+      :transport_options => nil,
+      :addresses => nil,
+      :persistent => false,
+      :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
+      :resolver_options => { cache: true },
+    }.freeze
 
     class << self
       def new(options = {})
@@ -14,10 +45,23 @@ module HTTPX
         super
       end
 
-      def def_option(name, &interpreter)
+      def def_option(name, layout = nil, &interpreter)
         attr_reader name
 
-        if interpreter
+        if layout
+          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+            def #{name}=(value)
+              return if value.nil?
+
+              value = begin
+                #{layout}
+              end
+
+              @#{name} = value
+            end
+          OUT
+
+        elsif interpreter
           define_method(:"#{name}=") do |value|
             return if value.nil?
 
@@ -32,80 +76,71 @@ module HTTPX
     end
 
     def initialize(options = {})
-      defaults = {
-        :debug => ENV.key?("HTTPX_DEBUG") ? $stderr : nil,
-        :debug_level => (ENV["HTTPX_DEBUG"] || 1).to_i,
-        :ssl => {},
-        :http2_settings => { settings_enable_push: 0 },
-        :fallback_protocol => "http/1.1",
-        :timeout => Timeout.new,
-        :headers => {},
-        :window_size => WINDOW_SIZE,
-        :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
-        :request_class => Class.new(Request),
-        :response_class => Class.new(Response),
-        :headers_class => Class.new(Headers),
-        :request_body_class => Class.new(Request::Body),
-        :response_body_class => Class.new(Response::Body),
-        :connection_class => Class.new(Connection),
-        :transport => nil,
-        :transport_options => nil,
-        :addresses => nil,
-        :persistent => false,
-        :resolver_class => (ENV["HTTPX_RESOLVER"] || :native).to_sym,
-        :resolver_options => { cache: true },
-      }
-
-      defaults.merge!(options)
+      defaults = DEFAULT_OPTIONS.merge(options)
       defaults.each do |(k, v)|
         next if v.nil?
 
-        __send__(:"#{k}=", v)
+        begin
+          __send__(:"#{k}=", v)
+        rescue NoMethodError
+          raise Error, "unknown option: #{k}"
+        end
       end
     end
 
-    def_option(:headers) do |headers|
+    def_option(:origin, <<-OUT)
+      URI(value)
+    OUT
+
+    def_option(:headers, <<-OUT)
       if self.headers
-        self.headers.merge(headers)
+        self.headers.merge(value)
       else
-        Headers.new(headers)
+        Headers.new(value)
       end
-    end
+    OUT
 
-    def_option(:timeout) do |opts|
-      Timeout.new(opts)
-    end
+    def_option(:timeout, <<-OUT)
+      timeouts = Hash[value]
+
+      if timeouts.key?(:loop_timeout)
+        warn ":loop_timeout is deprecated, use :operation_timeout instead"
+        timeouts[:operation_timeout] = timeouts.delete(:loop_timeout)
+      end
 
-    def_option(:max_concurrent_requests) do |num|
-      raise Error, ":max_concurrent_requests must be positive" unless num.positive?
+      timeouts
+    OUT
 
-      num
-    end
+    def_option(:max_concurrent_requests, <<-OUT)
+      raise Error, ":max_concurrent_requests must be positive" unless value.positive?
 
-    def_option(:max_requests) do |num|
-      raise Error, ":max_requests must be positive" unless num.positive?
+      value
+    OUT
 
-      num
-    end
+    def_option(:max_requests, <<-OUT)
+      raise Error, ":max_requests must be positive" unless value.positive?
 
-    def_option(:window_size) do |num|
-      Integer(num)
-    end
+      value
+    OUT
 
-    def_option(:body_threshold_size) do |num|
-      Integer(num)
-    end
+    def_option(:window_size, <<-OUT)
+      Integer(value)
+    OUT
+
+    def_option(:body_threshold_size, <<-OUT)
+      Integer(value)
+    OUT
 
-    def_option(:transport) do |tr|
-      transport = tr.to_s
-      raise Error, "#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
+    def_option(:transport, <<-OUT)
+      transport = value.to_s
+      raise Error, "\#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
 
       transport
-    end
+    OUT
 
-    def_option(:addresses) do |addrs|
-      Array(addrs)
-    end
+    def_option(:addresses, <<-OUT)
+      Array(value)
+    OUT
 
     %w[
       params form json body ssl http2_settings

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -32,9 +32,8 @@ module HTTPX
       class << self
         attr_reader :credentials, :region
 
-        def load_dependencies(klass)
+        def load_dependencies(_klass)
           require "aws-sdk-core"
-          klass.plugin(:aws_sigv4)
 
           client = Class.new(Seahorse::Client::Base) do
             @identifier = :httpx
@@ -50,6 +49,10 @@ module HTTPX
           @region = client.config[:region]
         end
 
+        def configure(klass)
+          klass.plugin(:aws_sigv4)
+        end
+
         def extra_options(options)
           options.merge(max_concurrent_requests: 1)
         end

data/lib/httpx/plugins/aws_sigv4.rb

@@ -143,13 +143,14 @@ module HTTPX
       class << self
         def extra_options(options)
           Class.new(options.class) do
-            def_option(:sigv4_signer) do |signer|
-              signer.is_a?(Signer) ? signer : Signer.new(signer)
-            end
-          end.new.merge(options)
+            def_option(:sigv4_signer, <<-OUT)
+              value.is_a?(#{Signer}) ? value : #{Signer}.new(value)
+            OUT
+          end.new(options)
         end
 
         def load_dependencies(klass)
+          require "digest/sha2"
           require "openssl"
           klass.plugin(:expect)
           klass.plugin(:compression)

data/lib/httpx/plugins/basic_authentication.rb

@@ -8,9 +8,14 @@ module HTTPX
     # https://gitlab.com/honeyryderchuck/httpx/wikis/Authentication#basic-authentication
     #
     module BasicAuthentication
-      def self.load_dependencies(klass)
-        require "base64"
-        klass.plugin(:authentication)
+      class << self
+        def load_dependencies(_klass)
+          require "base64"
+        end
+
+        def configure(klass)
+          klass.plugin(:authentication)
+        end
       end
 
       module InstanceMethods

data/lib/httpx/plugins/compression.rb

@@ -25,18 +25,18 @@ module HTTPX
           end
 
           Class.new(options.class) do
-            def_option(:compression_threshold_size) do |bytes|
-              bytes = Integer(bytes)
+            def_option(:compression_threshold_size, <<-OUT)
+              bytes = Integer(value)
               raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
 
               bytes
-            end
+            OUT
 
-            def_option(:encodings) do |encs|
-              raise Error, ":encodings must be a registry" unless encs.respond_to?(:registry)
+            def_option(:encodings, <<-OUT)
+              raise Error, ":encodings must be a registry" unless value.respond_to?(:registry)
 
-              encs
-            end
+              value
+            OUT
           end.new(options).merge(encodings: encodings)
         end
       end
@@ -66,7 +66,7 @@ module HTTPX
 
             @body = Encoder.new(@body, options.encodings.registry(encoding).deflater)
           end
-          @headers["content-length"] = @body.bytesize unless chunked?
+          @headers["content-length"] = @body.bytesize unless unbounded_body?
         end
       end
 

data/lib/httpx/plugins/compression/brotli.rb

@@ -5,12 +5,12 @@ module HTTPX
     module Compression
       module Brotli
         class << self
-          def load_dependencies(klass)
-            klass.plugin(:compression)
+          def load_dependencies(_klass)
             require "brotli"
           end
 
           def configure(klass)
+            klass.plugin(:compression)
             klass.default_options.encodings.register "br", self
           end
         end
@@ -18,12 +18,13 @@ module HTTPX
         module Deflater
           module_function
 
-          def deflate(raw, buffer, chunk_size:)
+          def deflate(raw, buffer = "".b, chunk_size: 16_384)
             while (chunk = raw.read(chunk_size))
               compressed = ::Brotli.deflate(chunk)
               buffer << compressed
               yield compressed if block_given?
             end
+            buffer
           end
         end
 

data/lib/httpx/plugins/compression/deflate.rb

@@ -4,20 +4,20 @@ module HTTPX
   module Plugins
     module Compression
       module Deflate
-        def self.load_dependencies(klass)
+        def self.load_dependencies(_klass)
           require "stringio"
           require "zlib"
-          klass.plugin(:"compression/gzip")
         end
 
         def self.configure(klass)
+          klass.plugin(:"compression/gzip")
           klass.default_options.encodings.register "deflate", self
         end
 
         module Deflater
           module_function
 
-          def deflate(raw, buffer, chunk_size:)
+          def deflate(raw, buffer = "".b, chunk_size: 16_384)
             deflater = Zlib::Deflate.new
             while (chunk = raw.read(chunk_size))
               compressed = deflater.deflate(chunk)
@@ -27,6 +27,7 @@ module HTTPX
             last = deflater.finish
             buffer << last
             yield last if block_given?
+            buffer
           ensure
             deflater.close if deflater
           end