httpx 0.17.0 → 0.18.3

data/lib/httpx/extensions.rb

@@ -54,6 +54,51 @@ module HTTPX
     Numeric.__send__(:include, NegMethods)
   end
 
+  module HashExtensions
+    refine Hash do
+      def compact
+        h = {}
+        each do |key, value|
+          h[key] = value unless value == nil
+        end
+        h
+      end unless Hash.method_defined?(:compact)
+    end
+  end
+
+  module ArrayExtensions
+    refine Array do
+
+      def filter_map
+        return to_enum(:filter_map) unless block_given?
+
+        each_with_object([]) do |item, res|
+          processed = yield(item)
+          res << processed if processed
+        end
+      end unless Array.method_defined?(:filter_map)
+
+      def sum(accumulator = 0, &block)
+        values = block_given? ? map(&block) : self
+        values.inject(accumulator, :+)
+      end unless Array.method_defined?(:sum)
+    end
+  end
+
+  module IOExtensions
+    refine IO do
+      # provides a fallback for rubies where IO#wait isn't implemented,
+      # but IO#wait_readable and IO#wait_writable are.
+      def wait(timeout = nil, _mode = :read_write)
+        r, w = IO.select([self], [self], nil, timeout)
+
+        return unless r || w
+
+        self
+      end unless IO.method_defined?(:wait) && IO.instance_method(:wait).arity == 2
+    end
+  end
+
   module RegexpExtensions
     # If you wonder why this is there: the oauth feature uses a refinement to enhance the
     # Regexp class locally with #match? , but this is never tested, because ActiveSupport
@@ -77,13 +122,14 @@ module HTTPX
       end
 
       def authority
-        port_string = port == default_port ? nil : ":#{port}"
-        "#{host}#{port_string}"
-      end
+        return host if port == default_port
+
+        "#{host}:#{port}"
+      end unless URI::HTTP.method_defined?(:authority)
 
       def origin
         "#{scheme}://#{authority}"
-      end
+      end unless URI::HTTP.method_defined?(:origin)
 
       def altsvc_match?(uri)
         uri = URI.parse(uri)

data/lib/httpx/io/ssl.rb

@@ -27,6 +27,10 @@ module HTTPX
       super
     end
 
+    def can_verify_peer?
+      @ctx.verify_mode == OpenSSL::SSL::VERIFY_PEER
+    end
+
     def verify_hostname(host)
       return false if @ctx.verify_mode == OpenSSL::SSL::VERIFY_NONE
       return false if !@io.respond_to?(:peer_cert) || @io.peer_cert.nil?
@@ -134,7 +138,7 @@ module HTTPX
       server_cert = @io.peer_cert
 
       "#{super}\n\n" \
-      "SSL connection using #{@io.ssl_version} / #{Array(@io.cipher).first}\n" \
+        "SSL connection using #{@io.ssl_version} / #{Array(@io.cipher).first}\n" \
         "ALPN, server accepted to use #{protocol}\n" \
         "Server certificate:\n" \
         " subject: #{server_cert.subject}\n" \

data/lib/httpx/io/tls.rb

@@ -194,15 +194,15 @@ module HTTPX
       server_cert = @peer_cert
 
       "#{super}\n\n" \
-        "SSL connection using #{@ctx.ssl_version} / #{Array(@ctx.cipher).first}\n" \
-        "ALPN, server accepted to use #{protocol}\n" +
+      "SSL connection using #{@ctx.ssl_version} / #{Array(@ctx.cipher).first}\n" \
+      "ALPN, server accepted to use #{protocol}\n" +
         (if server_cert
            "Server certificate:\n" \
-                 " subject: #{server_cert.subject}\n" \
-                 " start date: #{server_cert.not_before}\n" \
-                 " expire date: #{server_cert.not_after}\n" \
-                 " issuer: #{server_cert.issuer}\n" \
-                 " SSL certificate verify ok."
+             " subject: #{server_cert.subject}\n" \
+             " start date: #{server_cert.not_before}\n" \
+             " expire date: #{server_cert.not_after}\n" \
+             " issuer: #{server_cert.issuer}\n" \
+             " SSL certificate verify ok."
          else
            "SSL certificate verify failed."
          end

data/lib/httpx/loggable.rb

@@ -24,15 +24,13 @@ module HTTPX
       debug_stream << message
     end
 
-    if !Exception.instance_methods.include?(:full_message)
+    if Exception.instance_methods.include?(:full_message)
 
       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, color: color) { message }
+        log(level: level, color: color) { ex.full_message }
       end
 
     else
@@ -41,7 +39,9 @@ module HTTPX
         return unless @options.debug
         return unless @options.debug_level >= level
 
-        log(level: level, color: color) { ex.full_message }
+        message = +"#{ex.message} (#{ex.class})"
+        message << "\n" << ex.backtrace.join("\n") unless ex.backtrace.nil?
+        log(level: level, color: color) { message }
       end
 
     end

data/lib/httpx/options.rb

@@ -81,9 +81,9 @@ module HTTPX
       end
 
       def def_option(optname, *args, &block)
-        if args.size.zero? && !block_given?
+        if args.size.zero? && !block
           class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-            def option_#{optname}(v); v; end
+            def option_#{optname}(v); v; end # def option_smth(v); v; end
           OUT
           return
         end
@@ -93,15 +93,15 @@ module HTTPX
 
       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."
+             "Define module OptionsMethods and `def option_#{optname}(val)` instead."
 
         if layout
           class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-            def option_#{optname}(value)
-              #{layout}
-            end
+            def option_#{optname}(value)  # def option_origin(v)
+              #{layout}                   #   URI(v)
+            end                           # end
           OUT
-        elsif block_given?
+        elsif interpreter
           define_method(:"option_#{optname}") do |value|
             instance_exec(value, &interpreter)
           end

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
@@ -142,6 +139,7 @@ module HTTPX
 
       class << self
         def load_dependencies(*)
+          require "set"
           require "digest/sha2"
           require "openssl"
         end

data/lib/httpx/plugins/compression.rb

@@ -72,6 +72,8 @@ module HTTPX
       end
 
       module ResponseBodyMethods
+        using ArrayExtensions
+
         attr_reader :encodings
 
         def initialize(*)
@@ -90,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)
@@ -100,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?
@@ -134,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/jar.rb

@@ -55,7 +55,7 @@ module HTTPX
       end
 
       def each(uri = nil, &blk)
-        return enum_for(__method__, uri) unless block_given?
+        return enum_for(__method__, uri) unless blk
 
         return @cookies.each(&blk) unless uri
 

data/lib/httpx/plugins/expect.rb

@@ -69,9 +69,14 @@ module HTTPX
       end
 
       module ConnectionMethods
-        def send(request)
+        def send_request_to_parser(request)
+          super
+
+          return unless request.headers["expect"] == "100-continue"
+
           request.once(:expect) do
-            @timers.after(@options.expect_timeout) do
+            @timers.after(request.options.expect_timeout) do
+              # expect timeout expired
               if request.state == :expect && !request.expects?
                 Expect.no_expect_store << request.origin
                 request.headers.delete("expect")
@@ -79,7 +84,6 @@ module HTTPX
               end
             end
           end
-          super
         end
       end
 

data/lib/httpx/plugins/grpc/message.rb

@@ -17,7 +17,7 @@ module HTTPX
 
         # lazy decodes a grpc stream response
         def stream(response, &block)
-          return enum_for(__method__, response) unless block_given?
+          return enum_for(__method__, response) unless block
 
           response.each do |frame|
             decode(frame, encodings: response.headers.get("grpc-encoding"), encoders: response.encoders, &block)
@@ -57,7 +57,7 @@ module HTTPX
 
             yield data
 
-            message = message.byteslice(5 + size..-1)
+            message = message.byteslice((5 + size)..-1)
           end
         end
 

data/lib/httpx/plugins/grpc.rb

@@ -143,9 +143,9 @@ module HTTPX
 
           session_class = Class.new(self.class) do
             class_eval(<<-OUT, __FILE__, __LINE__ + 1)
-              def #{rpc_name}(input, **opts)
-                rpc_execute("#{rpc_name}", input, **opts)
-              end
+              def #{rpc_name}(input, **opts)              # def grpc_action(input, **opts)
+                rpc_execute("#{rpc_name}", input, **opts) #   rpc_execute("grpc_action", input, **opts)
+              end                                         # end
             OUT
           end
 

data/lib/httpx/plugins/internal_telemetry.rb

@@ -44,6 +44,11 @@ module HTTPX
           meter_elapsed_time("Session: initialized!!!")
         end
 
+        def close(*)
+          super
+          meter_elapsed_time("Session -> close")
+        end
+
         private
 
         def build_requests(*)
@@ -55,11 +60,6 @@ module HTTPX
           meter_elapsed_time("Session -> response") if response
           response
         end
-
-        def close(*)
-          super
-          meter_elapsed_time("Session -> close")
-        end
       end
 
       module RequestMethods
@@ -69,9 +69,9 @@ module HTTPX
         end
 
         def transition(nextstate)
-          state = @state
+          prev_state = @state
           super
-          meter_elapsed_time("Request##{object_id}[#{@verb} #{@uri}: #{state}] -> #{nextstate}") if nextstate == @state
+          meter_elapsed_time("Request##{object_id}[#{@verb} #{@uri}: #{prev_state}] -> #{@state}") if prev_state != @state
         end
       end
 
@@ -84,7 +84,7 @@ module HTTPX
         def transition(nextstate)
           state = @state
           super
-          meter_elapsed_time("Connection[#{@origin}]: #{state} -> #{nextstate}") if nextstate == @state
+          meter_elapsed_time("Connection##{object_id}[#{@origin}]: #{state} -> #{nextstate}") if nextstate == @state
         end
       end
     end

data/lib/httpx/plugins/multipart.rb

@@ -29,8 +29,8 @@ module HTTPX
               # in order not to break legacy code, we'll keep loading http/form_data for them.
               require "http/form_data"
               warn "httpx: http/form_data is no longer a requirement to use HTTPX :multipart plugin. See migration instructions under" \
-                "https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads.html#notes. \n\n" \
-                "If you'd like to stop seeing this message, require 'http/form_data' yourself."
+                   "https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads.html#notes. \n\n" \
+                   "If you'd like to stop seeing this message, require 'http/form_data' yourself."
             end
           rescue LoadError
           end

data/lib/httpx/plugins/response_cache/store.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module HTTPX::Plugins
+  module ResponseCache
+    class Store
+      extend Forwardable
+
+      def_delegator :@store, :clear
+
+      def initialize
+        @store = {}
+      end
+
+      def lookup(uri)
+        @store[uri]
+      end
+
+      def cached?(uri)
+        @store.key?(uri)
+      end
+
+      def cache(uri, response)
+        @store[uri] = response
+      end
+
+      def prepare(request)
+        cached_response = @store[request.uri]
+
+        return unless cached_response
+
+        original_request = cached_response.instance_variable_get(:@request)
+
+        if (vary = cached_response.headers["vary"])
+          if vary == "*"
+            return unless request.headers.same_headers?(original_request.headers)
+          else
+            return unless vary.split(/ *, */).all? do |cache_field|
+              !original_request.headers.key?(cache_field) || request.headers[cache_field] == original_request.headers[cache_field]
+            end
+          end
+        end
+
+        if !request.headers.key?("if-modified-since") && (last_modified = cached_response.headers["last-modified"])
+          request.headers.add("if-modified-since", last_modified)
+        end
+
+        if !request.headers.key?("if-none-match") && (etag = cached_response.headers["etag"]) # rubocop:disable Style/GuardClause
+          request.headers.add("if-none-match", etag)
+        end
+      end
+    end
+  end
+end

data/lib/httpx/plugins/response_cache.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module HTTPX
+  module Plugins
+    #
+    # This plugin adds support for retrying requests when certain errors happen.
+    #
+    # https://gitlab.com/honeyryderchuck/httpx/wikis/Response-Cache
+    #
+    module ResponseCache
+      CACHEABLE_VERBS = %i[get head].freeze
+      private_constant :CACHEABLE_VERBS
+
+      class << self
+        def load_dependencies(*)
+          require_relative "response_cache/store"
+        end
+
+        def cacheable_request?(request)
+          CACHEABLE_VERBS.include?(request.verb)
+        end
+
+        def cacheable_response?(response)
+          response.is_a?(Response) &&
+            # partial responses shall not be cached, only full ones.
+            response.status != 206 && (
+            response.headers.key?("etag") || response.headers.key?("last-modified-at")
+          )
+        end
+
+        def cached_response?(response)
+          response.is_a?(Response) && response.status == 304
+        end
+
+        def extra_options(options)
+          options.merge(response_cache_store: Store.new)
+        end
+      end
+
+      module OptionsMethods
+        def option_response_cache_store(value)
+          raise TypeError, "must be an instance of #{Store}" unless value.is_a?(Store)
+
+          value
+        end
+      end
+
+      module InstanceMethods
+        def clear_response_cache
+          @options.response_cache_store.clear
+        end
+
+        def build_request(*)
+          request = super
+          return request unless ResponseCache.cacheable_request?(request) && @options.response_cache_store.cached?(request.uri)
+
+          @options.response_cache_store.prepare(request)
+
+          request
+        end
+
+        def fetch_response(request, *)
+          response = super
+
+          if response && ResponseCache.cached_response?(response)
+            log { "returning cached response for #{request.uri}" }
+            cached_response = @options.response_cache_store.lookup(request.uri)
+
+            response.copy_from_cached(cached_response)
+          end
+
+          @options.response_cache_store.cache(request.uri, response) if response && ResponseCache.cacheable_response?(response)
+
+          response
+        end
+      end
+
+      module ResponseMethods
+        def copy_from_cached(other)
+          @body = other.body
+
+          @body.__send__(:rewind)
+        end
+      end
+    end
+    register_plugin :response_cache, ResponseCache
+  end
+end