httpx 0.6.7 → 0.9.0

data/lib/httpx/headers.rb

@@ -2,7 +2,7 @@
 
 module HTTPX
   class Headers
-    EMPTY = [].freeze # :nodoc:
+    EMPTY = [].freeze
 
     class << self
       def new(headers = nil)
@@ -67,7 +67,7 @@ module HTTPX
     #
     def [](field)
       a = @headers[downcased(field)] || return
-      a.join(",")
+      a.join(", ")
     end
 
     # sets +value+ (if not nil) as single value for the +field+ header.

data/lib/httpx/io/ssl.rb

@@ -20,6 +20,10 @@ module HTTPX
       @state = :negotiated if @keep_open
     end
 
+    def interests
+      @interests || super
+    end
+
     def protocol
       @io.alpn_protocol || super
     rescue StandardError
@@ -62,15 +66,18 @@ module HTTPX
       @io.connect_nonblock
       @io.post_connection_check(@hostname) if @ctx.verify_mode != OpenSSL::SSL::VERIFY_NONE
       transition(:negotiated)
-    rescue ::IO::WaitReadable,
-           ::IO::WaitWritable
+    rescue ::IO::WaitReadable
+      @interests = :r
+    rescue ::IO::WaitWritable
+      @interests = :w
     end
 
     # :nocov:
     if RUBY_VERSION < "2.3"
-      def read(*)
+      def read(_, buffer)
         super
       rescue ::IO::WaitWritable
+        buffer.clear
         0
       end
 
@@ -86,6 +93,7 @@ module HTTPX
           buffer.bytesize
         rescue ::IO::WaitReadable,
                ::IO::WaitWritable
+          buffer.clear
           0
         rescue EOFError
           nil

data/lib/httpx/io/tcp.rb

@@ -11,6 +11,8 @@ module HTTPX
 
     attr_reader :addresses
 
+    attr_reader :state
+
     alias_method :host, :ip
 
     def initialize(origin, addresses, options)
@@ -41,6 +43,10 @@ module HTTPX
       @io ||= build_socket
     end
 
+    def interests
+      :w
+    end
+
     def to_io
       @io.to_io
     end
@@ -67,7 +73,7 @@ module HTTPX
       @ip_index -= 1
       retry
     rescue Errno::ETIMEDOUT => e
-      raise ConnectTimeout, e.message if @ip_index <= 0
+      raise ConnectTimeoutError, e.message if @ip_index <= 0
 
       @ip_index -= 1
       retry
@@ -82,6 +88,7 @@ module HTTPX
         @io.read_nonblock(size, buffer)
         buffer.bytesize
       rescue ::IO::WaitReadable
+        buffer.clear
         0
       rescue EOFError
         nil
@@ -100,7 +107,10 @@ module HTTPX
     else
       def read(size, buffer)
         ret = @io.read_nonblock(size, buffer, exception: false)
-        return 0 if ret == :wait_readable
+        if ret == :wait_readable
+          buffer.clear
+          return 0
+        end
         return if ret.nil?
 
         buffer.bytesize

data/lib/httpx/loggable.rb

@@ -13,35 +13,35 @@ module HTTPX
       white: 37,
     }.freeze
 
-    def log(level: @options.debug_level, label: "", color: nil, &msg)
+    def log(level: @options.debug_level, color: nil, &msg)
       return unless @options.debug
       return unless @options.debug_level >= level
 
       debug_stream = @options.debug
 
-      message = (+label << msg.call << "\n")
+      message = (+"" << msg.call << "\n")
       message = "\e[#{COLORS[color]}m#{message}\e[0m" if debug_stream.respond_to?(:isatty) && debug_stream.isatty
       debug_stream << message
     end
 
     if !Exception.instance_methods.include?(:full_message)
 
-      def log_exception(ex, level: @options.debug_level, label: "", color: nil)
+      def log_exception(ex, level: @options.debug_level, color: nil)
         return unless @options.debug
         return unless @options.debug_level >= level
 
         message = +"#{ex.message} (#{ex.class})"
         message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
-        log(level: level, label: label, color: color) { message }
+        log(level: level, color: color) { message }
       end
 
     else
 
-      def log_exception(ex, level: @options.debug_level, label: "", color: nil)
+      def log_exception(ex, level: @options.debug_level, color: nil)
         return unless @options.debug
         return unless @options.debug_level >= level
 
-        log(level: level, label: label, color: color) { ex.full_message }
+        log(level: level, color: color) { ex.full_message }
       end
 
     end

data/lib/httpx/options.rb

@@ -2,7 +2,6 @@
 
 module HTTPX
   class Options
-    MAX_CONCURRENT_REQUESTS = 100
     WINDOW_SIZE = 1 << 14 # 16K
     MAX_BODY_THRESHOLD_SIZE = (1 << 10) * 112 # 112K
 
@@ -26,16 +25,28 @@ module HTTPX
 
       def def_option(name, &interpreter)
         defined_options << name.to_sym
-        interpreter ||= ->(v) { v }
 
-        attr_accessor name
-        protected :"#{name}="
+        attr_reader name
+
+        if interpreter
+          define_method(:"#{name}=") do |value|
+            return if value.nil?
+
+            instance_variable_set(:"@#{name}", instance_exec(value, &interpreter))
+          end
+
+          define_method(:"with_#{name}") do |value|
+            merge(name => instance_exec(value, &interpreter))
+          end
+        else
+          attr_writer name
 
-        define_method(:"with_#{name}") do |value|
-          other = dup
-          other.send(:"#{name}=", other.instance_exec(value, &interpreter))
-          other
+          define_method(:"with_#{name}") do |value|
+            merge(name => value)
+          end
         end
+
+        protected :"#{name}="
       end
     end
 
@@ -48,7 +59,6 @@ module HTTPX
         :fallback_protocol => "http/1.1",
         :timeout => Timeout.new,
         :headers => {},
-        :max_concurrent_requests => MAX_CONCURRENT_REQUESTS,
         :window_size => WINDOW_SIZE,
         :body_threshold_size => MAX_BODY_THRESHOLD_SIZE,
         :request_class => Class.new(Request),
@@ -65,43 +75,52 @@ module HTTPX
       }
 
       defaults.merge!(options)
-      defaults[:headers] = Headers.new(defaults[:headers])
-      defaults.each { |(k, v)| self[k] = v }
+      defaults.each do |(k, v)|
+        __send__(:"#{k}=", v)
+      end
     end
 
     def_option(:headers) do |headers|
-      self.headers.merge(headers)
+      if self.headers
+        self.headers.merge(headers)
+      else
+        Headers.new(headers)
+      end
     end
 
     def_option(:timeout) do |opts|
-      self.timeout = Timeout.new(opts)
+      Timeout.new(opts)
     end
 
     def_option(:max_concurrent_requests) do |num|
-      max = Integer(num)
-      raise Error, ":max_concurrent_requests must be positive" unless max.positive?
+      raise Error, ":max_concurrent_requests must be positive" unless num.positive?
 
-      self.max_concurrent_requests = max
+      num
+    end
+
+    def_option(:max_requests) do |num|
+      raise Error, ":max_requests must be positive" unless num.positive?
+
+      num
     end
 
     def_option(:window_size) do |num|
-      self.window_size = Integer(num)
+      Integer(num)
     end
 
     def_option(:body_threshold_size) do |num|
-      self.body_threshold_size = Integer(num)
+      Integer(num)
     end
 
     def_option(:transport) do |tr|
       transport = tr.to_s
       raise Error, "#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
 
-      self.transport = transport
+      transport
     end
 
     %w[
-      params form json body
-      follow ssl http2_settings
+      params form json body ssl http2_settings
       request_class response_class headers_class request_body_class response_body_class connection_class
       io fallback_protocol debug debug_level transport_options resolver_class resolver_options
       persistent
@@ -127,8 +146,10 @@ module HTTPX
     end
 
     def merge(other)
-      h1 = to_hash
       h2 = other.to_hash
+      return self if h2.empty?
+
+      h1 = to_hash
 
       merged = h1.merge(h2) do |k, v1, v2|
         case k
@@ -172,11 +193,5 @@ module HTTPX
       response_body_class.freeze
       connection_class.freeze
     end
-
-    protected
-
-    def []=(option, val)
-      send(:"#{option}=", val)
-    end
   end
 end

data/lib/httpx/plugins/authentication.rb

@@ -11,7 +11,7 @@ module HTTPX
     module Authentication
       module InstanceMethods
         def authentication(token)
-          headers("authorization" => token)
+          with(headers: { "authorization" => token })
         end
       end
     end

data/lib/httpx/plugins/compression.rb

@@ -14,13 +14,23 @@ module HTTPX
     #
     module Compression
       extend Registry
-      def self.load_dependencies(klass)
-        klass.plugin(:"compression/gzip")
-        klass.plugin(:"compression/deflate")
-      end
 
-      def self.extra_options(options)
-        options.merge(headers: { "accept-encoding" => Compression.registry.keys })
+      class << self
+        def load_dependencies(klass)
+          klass.plugin(:"compression/gzip")
+          klass.plugin(:"compression/deflate")
+        end
+
+        def extra_options(options)
+          Class.new(options.class) do
+            def_option(:compression_threshold_size) do |bytes|
+              bytes = Integer(bytes)
+              raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
+
+              bytes
+            end
+          end.new(options).merge(headers: { "accept-encoding" => Compression.registry.keys })
+        end
       end
 
       module RequestMethods
@@ -32,11 +42,19 @@ module HTTPX
       end
 
       module RequestBodyMethods
-        def initialize(*)
+        def initialize(*, options)
           super
           return if @body.nil?
 
+          if (threshold = options.compression_threshold_size)
+            unless unbounded_body?
+              return if @body.bytesize < threshold
+            end
+          end
+
           @headers.get("content-encoding").each do |encoding|
+            next if encoding == "identity"
+
             @body = Encoder.new(@body, Compression.registry(encoding).encoder)
           end
           @headers["content-length"] = @body.bytesize unless chunked?
@@ -54,6 +72,8 @@ module HTTPX
           return unless @headers.key?("content-encoding")
 
           @_decoders = @headers.get("content-encoding").map do |encoding|
+            next if encoding == "identity"
+
             decoder = Compression.registry(encoding).decoder
             # do not uncompress if there is no decoder available. In fact, we can't reliably
             # continue decompressing beyond that, so ignore.
@@ -61,7 +81,7 @@ module HTTPX
 
             @encodings << encoding
             decoder
-          end
+          end.compact
 
           # remove encodings that we are able to decode
           @headers["content-encoding"] = @headers.get("content-encoding") - @encodings

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

@@ -15,31 +15,41 @@ module HTTPX
         end
 
         class Encoder
+          def initialize
+            @compressed_chunk = "".b
+          end
+
           def deflate(raw, buffer, chunk_size:)
             gzip = Zlib::GzipWriter.new(self)
 
-            while (chunk = raw.read(chunk_size))
-              gzip.write(chunk)
-              gzip.flush
-              compressed = compressed_chunk
-              buffer << compressed
-              yield compressed if block_given?
+            begin
+              while (chunk = raw.read(chunk_size))
+                gzip.write(chunk)
+                gzip.flush
+                compressed = compressed_chunk
+                buffer << compressed
+                yield compressed if block_given?
+              end
+            ensure
+              gzip.close
             end
-          ensure
-            gzip.close
+
+            return unless (compressed = compressed_chunk)
+
+            buffer << compressed
+            yield compressed if block_given?
           end
 
           private
 
           def write(chunk)
-            @compressed_chunk = chunk
+            @compressed_chunk << chunk
           end
 
           def compressed_chunk
-            compressed = @compressed_chunk
-            compressed
+            @compressed_chunk.dup
           ensure
-            @compressed_chunk = nil
+            @compressed_chunk.clear
           end
         end
 

data/lib/httpx/plugins/cookies.rb

@@ -17,14 +17,22 @@ module HTTPX
       def self.extra_options(options)
         Class.new(options.class) do
           def_option(:cookies) do |cookies|
-            return cookies if cookies.is_a?(Store)
-
-            Store.new(cookies)
+            if cookies.is_a?(Store)
+              cookies
+            else
+              Store.new(cookies)
+            end
           end
         end.new(options)
       end
 
       class Store
+        def self.new(cookies = nil)
+          return cookies if cookies.is_a?(self)
+
+          super
+        end
+
         def initialize(cookies = nil)
           @store = Hash.new { |hash, origin| hash[origin] = HTTP::CookieJar.new }
           return unless cookies
@@ -74,10 +82,6 @@ module HTTPX
           super({ cookies: Store.new }.merge(options), &blk)
         end
 
-        def with_cookies(cookies)
-          branch(default_options.with_cookies(cookies))
-        end
-
         def wrap
           return super unless block_given?
 
@@ -86,7 +90,7 @@ module HTTPX
             begin
               yield session
             ensure
-              @options = @options.with_cookies(old_cookies_store)
+              @options = @options.with(cookies: old_cookies_store)
             end
           end
         end