httpx 0.15.4 → 0.18.0

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
+          class_eval(<<-OUT, __FILE__, __LINE__ + 1)
+            def option_#{optname}(v); v; end # def option_smth(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)  # def option_origin(v)
+              #{layout}                   #   URI(v)
+            end                           # end
+          OUT
+        elsif interpreter
+          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?

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -8,6 +8,23 @@ module HTTPX
     # It requires the "aws-sdk-core" gem.
     #
     module AwsSdkAuthentication
+      # Mock configuration, to be used only when resolving credentials
+      class Configuration
+        attr_reader :profile
+
+        def initialize(profile)
+          @profile = profile
+        end
+
+        def respond_to_missing?(*)
+          true
+        end
+
+        def method_missing(*)
+          nil
+        end
+      end
+
       #
       # encapsulates access to an AWS SDK credentials store.
       #
@@ -30,23 +47,8 @@ module HTTPX
       end
 
       class << self
-        attr_reader :credentials, :region
-
         def load_dependencies(_klass)
           require "aws-sdk-core"
-
-          client = Class.new(Seahorse::Client::Base) do
-            @identifier = :httpx
-            set_api(Aws::S3::ClientApi::API)
-            add_plugin(Aws::Plugins::CredentialsConfiguration)
-            add_plugin(Aws::Plugins::RegionalEndpoint)
-            class << self
-              attr_reader :identifier
-            end
-          end.new
-
-          @credentials = Credentials.new(client.config[:credentials])
-          @region = client.config[:region]
         end
 
         def configure(klass)
@@ -56,6 +58,26 @@ module HTTPX
         def extra_options(options)
           options.merge(max_concurrent_requests: 1)
         end
+
+        def credentials(profile)
+          mock_configuration = Configuration.new(profile)
+          Credentials.new(Aws::CredentialProviderChain.new(mock_configuration).resolve)
+        end
+
+        def region(profile)
+          # https://github.com/aws/aws-sdk-ruby/blob/version-3/gems/aws-sdk-core/lib/aws-sdk-core/plugins/regional_endpoint.rb#L62
+          keys = %w[AWS_REGION AMAZON_REGION AWS_DEFAULT_REGION]
+          env_region = ENV.values_at(*keys).compact.first
+          env_region = nil if env_region == ""
+          cfg_region = Aws.shared_config.region(profile: profile)
+          env_region || cfg_region
+        end
+      end
+
+      module OptionsMethods
+        def option_aws_profile(value)
+          String(value)
+        end
       end
 
       module InstanceMethods
@@ -64,9 +86,11 @@ module HTTPX
         # aws_authentication(credentials: Aws::Credentials.new('akid', 'secret'))
         # aws_authentication()
         #
-        def aws_sdk_authentication(**options)
-          credentials = AwsSdkAuthentication.credentials
-          region = AwsSdkAuthentication.region
+        def aws_sdk_authentication(
+          credentials: AwsSdkAuthentication.credentials(@options.aws_profile),
+          region: AwsSdkAuthentication.region(@options.aws_profile),
+          **options
+        )
 
           aws_sigv4_authentication(
             credentials: credentials,

data/lib/httpx/plugins/aws_sigv4.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-require "aws-sdk-s3"
-
 module HTTPX
   module Plugins
     #
@@ -75,16 +72,16 @@ module HTTPX
 
           # canonical request
           creq = "#{request.verb.to_s.upcase}" \
-            "\n#{request.canonical_path}" \
-            "\n#{request.canonical_query}" \
-            "\n#{canonical_headers}" \
-            "\n#{signed_headers}" \
-            "\n#{content_hashed}"
+                 "\n#{request.canonical_path}" \
+                 "\n#{request.canonical_query}" \
+                 "\n#{canonical_headers}" \
+                 "\n#{signed_headers}" \
+                 "\n#{content_hashed}"
 
           credential_scope = "#{date}" \
-            "/#{@region}" \
-            "/#{@service}" \
-            "/#{lower_provider_prefix}_request"
+                             "/#{@region}" \
+                             "/#{@service}" \
+                             "/#{lower_provider_prefix}_request"
 
           algo_line = "#{upper_provider_prefix}-HMAC-#{@algorithm}"
           # string to sign
@@ -141,22 +138,24 @@ module HTTPX
       end
 
       class << self
-        def extra_options(options)
-          Class.new(options.class) do
-            def_option(:sigv4_signer, <<-OUT)
-              value.is_a?(#{Signer}) ? value : #{Signer}.new(value)
-            OUT
-          end.new(options)
-        end
-
-        def load_dependencies(klass)
+        def load_dependencies(*)
+          require "set"
           require "digest/sha2"
           require "openssl"
+        end
+
+        def configure(klass)
           klass.plugin(:expect)
           klass.plugin(:compression)
         end
       end
 
+      module OptionsMethods
+        def option_sigv4_signer(value)
+          value.is_a?(Signer) ? value : Signer.new(value)
+        end
+      end
+
       module InstanceMethods
         def aws_sigv4_authentication(**options)
           with(sigv4_signer: Signer.new(**options))

data/lib/httpx/plugins/compression.rb

@@ -23,21 +23,22 @@ module HTTPX
           encodings = Module.new do
             extend Registry
           end
+          options.merge(encodings: encodings)
+        end
+      end
 
-          Class.new(options.class) do
-            def_option(:compression_threshold_size, <<-OUT)
-              bytes = Integer(value)
-              raise Error, ":expect_threshold_size must be positive" unless bytes.positive?
+      module OptionsMethods
+        def option_compression_threshold_size(value)
+          bytes = Integer(value)
+          raise TypeError, ":expect_threshold_size must be positive" unless bytes.positive?
 
-              bytes
-            OUT
+          bytes
+        end
 
-            def_option(:encodings, <<-OUT)
-              raise Error, ":encodings must be a registry" unless value.respond_to?(:registry)
+        def option_encodings(value)
+          raise TypeError, ":encodings must be a registry" unless value.respond_to?(:registry)
 
-              value
-            OUT
-          end.new(options).merge(encodings: encodings)
+          value
         end
       end
 
@@ -71,6 +72,8 @@ module HTTPX
       end
 
       module ResponseBodyMethods
+        using ArrayExtensions
+
         attr_reader :encodings
 
         def initialize(*)
@@ -89,7 +92,7 @@ module HTTPX
             Float::INFINITY
           end
 
-          @_inflaters = @headers.get("content-encoding").map do |encoding|
+          @_inflaters = @headers.get("content-encoding").filter_map do |encoding|
             next if encoding == "identity"
 
             inflater = @options.encodings.registry(encoding).inflater(compressed_length)
@@ -99,7 +102,7 @@ module HTTPX
 
             @encodings << encoding
             inflater
-          end.compact
+          end
 
           # this can happen if the only declared encoding is "identity"
           remove_instance_variable(:@_inflaters) if @_inflaters.empty?
@@ -133,7 +136,7 @@ module HTTPX
         end
 
         def each(&blk)
-          return enum_for(__method__) unless block_given?
+          return enum_for(__method__) unless blk
 
           return deflate(&blk) if @buffer.size.zero?
 

data/lib/httpx/plugins/cookies/cookie.rb

@@ -43,7 +43,7 @@ module HTTPX
         # Precedence: 1. longer path  2. older creation
         (@name <=> other.name).nonzero? ||
           (other.path.length <=> @path.length).nonzero? ||
-          (@created_at <=> other.created_at).nonzero?
+          (@created_at <=> other.created_at).nonzero? || 0
       end
 
       class << self
@@ -107,6 +107,8 @@ module HTTPX
 
         @path ||= "/"
         raise ArgumentError, "name must be specified" if @name.nil?
+
+        @name = @name.to_s
       end
 
       def expires
@@ -122,7 +124,7 @@ module HTTPX
       # Returns a string for use in the Cookie header, i.e. `name=value`
       # or `name="value"`.
       def cookie_value
-        "#{@name}=#{Scanner.quote(@value)}"
+        "#{@name}=#{Scanner.quote(@value.to_s)}"
       end
       alias_method :to_s, :cookie_value
 

data/lib/httpx/plugins/cookies/jar.rb

@@ -55,9 +55,9 @@ module HTTPX
       end
 
       def each(uri = nil, &blk)
-        return enum_for(__method__, uri) unless block_given?
+        return enum_for(__method__, uri) unless blk
 
-        return @store.each(&blk) unless uri
+        return @cookies.each(&blk) unless uri
 
         uri = URI(uri)
 
@@ -73,6 +73,25 @@ module HTTPX
           end
         end
       end
+
+      def merge(other)
+        cookies_dup = dup
+
+        other.each do |elem|
+          cookie = case elem
+                   when Cookie
+                     elem
+                   when Array
+                     Cookie.new(*elem)
+                   else
+                     Cookie.new(elem)
+          end
+
+          cookies_dup.add(cookie)
+        end
+
+        cookies_dup
+      end
     end
   end
 end

data/lib/httpx/plugins/cookies.rb

@@ -18,12 +18,10 @@ module HTTPX
         require "httpx/plugins/cookies/set_cookie_parser"
       end
 
-      def self.extra_options(options)
-        Class.new(options.class) do
-          def_option(:cookies, <<-OUT)
-            value.is_a?(#{Jar}) ? value : #{Jar}.new(value)
-          OUT
-        end.new(options)
+      module OptionsMethods
+        def option_cookies(value)
+          value.is_a?(Jar) ? value : Jar.new(value)
+        end
       end
 
       module InstanceMethods
@@ -63,7 +61,7 @@ module HTTPX
 
         def build_request(*, _)
           request = super
-          request.headers.set_cookie(@options.cookies[request.uri])
+          request.headers.set_cookie(request.options.cookies[request.uri])
           request
         end
       end
@@ -77,6 +75,21 @@ module HTTPX
           add("cookie", header_value)
         end
       end
+
+      module OptionsMethods
+        def initialize(*)
+          super
+
+          return unless @headers.key?("cookie")
+
+          @headers.delete("cookie").each do |ck|
+            ck.split(/ *; */).each do |cookie|
+              name, value = cookie.split("=", 2)
+              @cookies.add(Cookie.new(name, value))
+            end
+          end
+        end
+      end
     end
     register_plugin :cookies, Cookies
   end