httpx 0.15.3 → 0.17.0

data/lib/httpx/connection.rb

@@ -69,10 +69,10 @@ module HTTPX
       end
 
       @inflight = 0
-      @keep_alive_timeout = options.timeout[:keep_alive_timeout]
+      @keep_alive_timeout = @options.timeout[:keep_alive_timeout]
       @keep_alive_timer = nil
 
-      self.addresses = options.addresses if options.addresses
+      self.addresses = @options.addresses if @options.addresses
     end
 
     # this is a semi-private method, to be used by the resolver
@@ -313,7 +313,7 @@ module HTTPX
 
             # exit #consume altogether if all outstanding requests have been dealt with
             return if @pending.size.zero? && @inflight.zero?
-          end unless (interests.nil? || interests == :w || @state == :closing) && !epiped
+          end unless ((ints = interests).nil? || ints == :w || @state == :closing) && !epiped
 
           #
           # tight write loop.
@@ -360,19 +360,18 @@ module HTTPX
             break if interests == :r || @state == :closing || @state == :closed
 
             write_drained = false
-          end unless interests == :r
+          end unless (ints = interests) == :r
 
           send_pending if @state == :open
 
           # return if socket is drained
-          next unless (interests != :r || read_drained) &&
-                      (interests != :w || write_drained)
+          next unless (ints != :r || read_drained) && (ints != :w || write_drained)
 
           # gotta go back to the event loop. It happens when:
           #
           # * the socket is drained of bytes or it's not the interest of the conn to read;
           # * theres nothing more to write, or it's not in the interest of the conn to write;
-          log(level: 3) { "(#{interests}): WAITING FOR EVENTS..." }
+          log(level: 3) { "(#{ints}): WAITING FOR EVENTS..." }
           return
         end
       end

data/lib/httpx/errors.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 module HTTPX
-  Error = Class.new(StandardError)
+  class Error < StandardError; end
 
-  UnsupportedSchemeError = Class.new(Error)
+  class UnsupportedSchemeError < Error; end
 
-  TimeoutError = Class.new(Error) do
+  class TimeoutError < Error
     attr_reader :timeout
 
     def initialize(timeout, message)
@@ -20,17 +20,17 @@ module HTTPX
     end
   end
 
-  TotalTimeoutError = Class.new(TimeoutError)
+  class TotalTimeoutError < TimeoutError; end
 
-  ConnectTimeoutError = Class.new(TimeoutError)
+  class ConnectTimeoutError < TimeoutError; end
 
-  SettingsTimeoutError = Class.new(TimeoutError)
+  class SettingsTimeoutError < TimeoutError; end
 
-  ResolveTimeoutError = Class.new(TimeoutError)
+  class ResolveTimeoutError < TimeoutError; end
 
-  ResolveError = Class.new(Error)
+  class ResolveError < Error; end
 
-  NativeResolveError = Class.new(ResolveError) do
+  class NativeResolveError < ResolveError
     attr_reader :connection, :host
 
     def initialize(connection, host, message = "Can't resolve #{host}")
@@ -40,7 +40,7 @@ module HTTPX
     end
   end
 
-  HTTPError = Class.new(Error) do
+  class HTTPError < Error
     attr_reader :response
 
     def initialize(response)
@@ -53,5 +53,5 @@ module HTTPX
     end
   end
 
-  MisdirectedRequestError = Class.new(HTTPError)
+  class MisdirectedRequestError < HTTPError; end
 end

data/lib/httpx/headers.rb

@@ -57,7 +57,7 @@ module HTTPX
     def merge(other)
       headers = dup
       other.each do |field, value|
-        headers[field] = value
+        headers[downcased(field)] = value
       end
       headers
     end

data/lib/httpx/io/ssl.rb

@@ -7,9 +7,9 @@ module HTTPX
 
   class SSL < TCP
     TLS_OPTIONS = if OpenSSL::SSL::SSLContext.instance_methods.include?(:alpn_protocols)
-      { alpn_protocols: %w[h2 http/1.1] }
+      { alpn_protocols: %w[h2 http/1.1].freeze }.freeze
     else
-      {}
+      {}.freeze
     end
 
     def initialize(_, _, options)

data/lib/httpx/io/tls.rb

@@ -4,7 +4,7 @@ require "openssl"
 
 module HTTPX
   class TLS < TCP
-    Error = Class.new(StandardError)
+    class Error < StandardError; end
 
     def initialize(_, _, options)
       super

data/lib/httpx/options.rb

@@ -30,6 +30,7 @@ module HTTPX
       :request_body_class => Class.new(Request::Body),
       :response_body_class => Class.new(Response::Body),
       :connection_class => Class.new(Connection),
+      :options_class => Class.new(self),
       :transport => nil,
       :transport_options => nil,
       :addresses => nil,
@@ -38,71 +39,100 @@ module HTTPX
       :resolver_options => { cache: true },
     }.freeze
 
+    begin
+      module HashExtensions
+        refine Hash do
+          def >=(other)
+            Hash[other] <= self
+          end
+
+          def <=(other)
+            other = Hash[other]
+            return false unless size <= other.size
+
+            each do |k, v|
+              v2 = other.fetch(k) { return false }
+              return false unless v2 == v
+            end
+            true
+          end
+        end
+      end
+      using HashExtensions
+    end unless Hash.method_defined?(:>=)
+
     class << self
       def new(options = {})
         # let enhanced options go through
-        return options if self == Options && options.class > self
+        return options if self == Options && options.class < self
         return options if options.is_a?(self)
 
         super
       end
 
-      def def_option(name, layout = nil, &interpreter)
-        attr_reader name
+      def method_added(meth)
+        super
 
-        if layout
-          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-            def #{name}=(value)
-              return if value.nil?
+        return unless meth =~ /^option_(.+)$/
 
-              value = begin
-                #{layout}
-              end
+        optname = Regexp.last_match(1).to_sym
 
-              @#{name} = value
-            end
+        attr_reader(optname)
+      end
+
+      def def_option(optname, *args, &block)
+        if args.size.zero? && !block_given?
+          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+            def option_#{optname}(v); v; end
           OUT
+          return
+        end
 
-        elsif interpreter
-          define_method(:"#{name}=") do |value|
-            return if value.nil?
+        deprecated_def_option(optname, *args, &block)
+      end
+
+      def deprecated_def_option(optname, layout = nil, &interpreter)
+        warn "DEPRECATION WARNING: using `def_option(#{optname})` for setting options is deprecated. " \
+          "Define module OptionsMethods and `def option_#{optname}(val)` instead."
 
-            instance_variable_set(:"@#{name}", instance_exec(value, &interpreter))
+        if layout
+          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+            def option_#{optname}(value)
+              #{layout}
+            end
+          OUT
+        elsif block_given?
+          define_method(:"option_#{optname}") do |value|
+            instance_exec(value, &interpreter)
           end
-        else
-          attr_writer name
         end
-
-        protected :"#{name}="
       end
     end
 
     def initialize(options = {})
       defaults = DEFAULT_OPTIONS.merge(options)
-      defaults.each do |(k, v)|
+      defaults.each do |k, v|
         next if v.nil?
 
         begin
-          __send__(:"#{k}=", v)
+          value = __send__(:"option_#{k}", v)
+          instance_variable_set(:"@#{k}", value)
         rescue NoMethodError
           raise Error, "unknown option: #{k}"
         end
       end
+      freeze
     end
 
-    def_option(:origin, <<-OUT)
+    def option_origin(value)
       URI(value)
-    OUT
+    end
 
-    def_option(:headers, <<-OUT)
-      if self.headers
-        self.headers.merge(value)
-      else
-        Headers.new(value)
-      end
-    OUT
+    def option_headers(value)
+      Headers.new(value)
+    end
 
-    def_option(:timeout, <<-OUT)
+    def option_timeout(value)
       timeouts = Hash[value]
 
       if timeouts.key?(:loop_timeout)
@@ -111,42 +141,43 @@ module HTTPX
       end
 
       timeouts
-    OUT
+    end
 
-    def_option(:max_concurrent_requests, <<-OUT)
-      raise Error, ":max_concurrent_requests must be positive" unless value.positive?
+    def option_max_concurrent_requests(value)
+      raise TypeError, ":max_concurrent_requests must be positive" unless value.positive?
 
       value
-    OUT
+    end
 
-    def_option(:max_requests, <<-OUT)
-      raise Error, ":max_requests must be positive" unless value.positive?
+    def option_max_requests(value)
+      raise TypeError, ":max_requests must be positive" unless value.positive?
 
       value
-    OUT
+    end
 
-    def_option(:window_size, <<-OUT)
+    def option_window_size(value)
       Integer(value)
-    OUT
+    end
 
-    def_option(:body_threshold_size, <<-OUT)
+    def option_body_threshold_size(value)
       Integer(value)
-    OUT
+    end
 
-    def_option(:transport, <<-OUT)
+    def option_transport(value)
       transport = value.to_s
-      raise Error, "\#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
+      raise TypeError, "\#{transport} is an unsupported transport type" unless IO.registry.key?(transport)
 
       transport
-    OUT
+    end
 
-    def_option(:addresses, <<-OUT)
+    def option_addresses(value)
       Array(value)
-    OUT
+    end
 
     %i[
       params form json body ssl http2_settings
-      request_class response_class headers_class request_body_class response_body_class connection_class
+      request_class response_class headers_class request_body_class
+      response_body_class connection_class options_class
       io fallback_protocol debug debug_level transport_options resolver_class resolver_options
       persistent
     ].each do |method_name|
@@ -154,6 +185,7 @@ module HTTPX
     end
 
     REQUEST_IVARS = %i[@params @form @json @body].freeze
+    private_constant :REQUEST_IVARS
 
     def ==(other)
       ivars = instance_variables | other.instance_variables
@@ -171,18 +203,17 @@ module HTTPX
     end
 
     def merge(other)
-      raise ArgumentError, "#{other.inspect} is not a valid set of options" unless other.respond_to?(:to_hash)
+      raise ArgumentError, "#{other} is not a valid set of options" unless other.respond_to?(:to_hash)
 
       h2 = other.to_hash
       return self if h2.empty?
 
       h1 = to_hash
 
-      return self if h1 == h2
+      return self if h1 >= h2
 
-      merged = h1.merge(h2) do |k, v1, v2|
-        case k
-        when :headers, :ssl, :http2_settings, :timeout
+      merged = h1.merge(h2) do |_k, v1, v2|
+        if v1.respond_to?(:merge) && v2.respond_to?(:merge)
           v1.merge(v2)
         else
           v2
@@ -193,34 +224,30 @@ module HTTPX
     end
 
     def to_hash
-      hash_pairs = instance_variables.map do |ivar|
-        [ivar[1..-1].to_sym, instance_variable_get(ivar)]
+      instance_variables.each_with_object({}) do |ivar, hs|
+        hs[ivar[1..-1].to_sym] = instance_variable_get(ivar)
+      end
+    end
+
+    if RUBY_VERSION > "2.4.0"
+      def initialize_dup(other)
+        instance_variables.each do |ivar|
+          instance_variable_set(ivar, other.instance_variable_get(ivar).dup)
+        end
+      end
+    else
+      def initialize_dup(other)
+        instance_variables.each do |ivar|
+          value = other.instance_variable_get(ivar)
+          value = case value
+                  when Symbol, Fixnum, TrueClass, FalseClass # rubocop:disable Lint/UnifiedInteger
+                    value
+                  else
+                    value.dup
+          end
+          instance_variable_set(ivar, value)
+        end
       end
-      Hash[hash_pairs]
-    end
-
-    def initialize_dup(other)
-      self.headers             = other.headers.dup
-      self.ssl                 = other.ssl.dup
-      self.request_class       = other.request_class.dup
-      self.response_class      = other.response_class.dup
-      self.headers_class       = other.headers_class.dup
-      self.request_body_class  = other.request_body_class.dup
-      self.response_body_class = other.response_body_class.dup
-      self.connection_class    = other.connection_class.dup
-    end
-
-    def freeze
-      super
-
-      headers.freeze
-      ssl.freeze
-      request_class.freeze
-      response_class.freeze
-      headers_class.freeze
-      request_body_class.freeze
-      response_body_class.freeze
-      connection_class.freeze
     end
   end
 end

data/lib/httpx/parser/http1.rb

@@ -2,7 +2,7 @@
 
 module HTTPX
   module Parser
-    Error = Class.new(Error)
+    class Error < Error; end
 
     class HTTP1
       VERSIONS = %w[1.0 1.1].freeze
@@ -60,7 +60,7 @@ module HTTPX
         (m = %r{\AHTTP(?:/(\d+\.\d+))?\s+(\d\d\d)(?:\s+(.*))?}in.match(@buffer)) ||
           raise(Error, "wrong head line format")
         version, code, _ = m.captures
-        raise(Error, "unsupported HTTP version (HTTP/#{version})") unless VERSIONS.include?(version)
+        raise(Error, "unsupported HTTP version (HTTP/#{version})") unless version && VERSIONS.include?(version)
 
         @http_version = version.split(".").map(&:to_i)
         @status_code = code.to_i
@@ -72,9 +72,14 @@ module HTTPX
 
       def parse_headers
         headers = @headers
-        while (idx = @buffer.index("\n"))
-          line = @buffer.byteslice(0..idx).sub(/\s+\z/, "")
-          @buffer = @buffer.byteslice((idx + 1)..-1)
+        buffer = @buffer
+
+        while (idx = buffer.index("\n"))
+          line = buffer.byteslice(0..idx)
+          raise Error, "wrong header format" if line.start_with?("\s", "\t")
+
+          line.lstrip!
+          buffer = @buffer = buffer.byteslice((idx + 1)..-1)
           if line.empty?
             case @state
             when :headers
@@ -97,9 +102,8 @@ module HTTPX
           raise Error, "wrong header format" unless separator_index
 
           key = line.byteslice(0..(separator_index - 1))
-          raise Error, "wrong header format" if key.start_with?("\s", "\t")
 
-          key.strip!
+          key.rstrip! # was lstripped previously!
           value = line.byteslice((separator_index + 1)..-1)
           value.strip!
           raise Error, "wrong header format" if value.nil?