httpx 1.6.3 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f49b29ea3703f6f40abe3cd82d455235b0a0b50a694bd8fa55839ac471d32bbb
-  data.tar.gz: ce933bb3c35d9434f810d4fc83acb244a1ad0db187123d5f01dcbbbd83622a47
+  metadata.gz: 2af63a63fe08211db58764570618b2e7c234d3473a28fc1ad6f5a31c3d0fb13d
+  data.tar.gz: 6b2671b85ac69e4817b8b764dfdabf638dacf94cfdcab6c44627ad64a57bcb50
 SHA512:
-  metadata.gz: 258cb32129840347a1a37633fb6273133187c98636b63ffcc0b8064f39e3b5642d693ee5da5d7776529625fbe4b68b5193b405c2e0658b2c9b1193b49e316bdc
-  data.tar.gz: 387397ab1954b6abf6a8a54d8764fb25e786fb1bd293401e8afd57f823464f67210527fee0b9e94b34cc3d2931143a5d94598fb6241f5728df77a8f1e045a5bf
+  metadata.gz: 50a2d2d3c0cb27f3bf84cc34553b06bd9fadf46ad789f9cfa08091cc458ac07751cb5593e01d242d88e444f10ac2b3014ea3e4e56f7c616ebc860517d08ef90d
+  data.tar.gz: 6b15f21262e85639c6d32b9851926d7e717b6f9bcbc226b9af3872d67461799fd24847a2d563dfbad1967d5349d371c18a1a6e1a28c721c5f33387f2fc1446a7

data/doc/release_notes/0_11_0.md

@@ -21,7 +21,7 @@ stub_http_request(:get, "https://www.google.com").and_return(status: 200, body:
 
 ```
 
-Read more about it in the [webmock integration documentation](https://os85.gitlab.io/httpx/wiki/Webmock-Adapter).
+Read more about it in the [webmock integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Webmock-Adapter).
 
 ### Datadog Adapter
 
@@ -40,7 +40,7 @@ A trace will be emitted for every request, so this should be an interesting visu
 
 Customization options and traces are similar to what [the net-http adapter provides](https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#nethttp).
 
-Read more about it in the [datadog integration documentation](https://os85.gitlab.io/httpx/wiki/Datadog-Adapter).
+Read more about it in the [datadog integration documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Datadog-Adapter).
 
 ## Improvements
 
@@ -52,7 +52,7 @@ Read more about it in the [datadog integration documentation](https://os85.gitla
 HTTPX.plugin(:multipart).post(uri, form: {file: File.new("path/to/file")})
 ```
 
-Read more about it in the [multipart plugin documentation](https://os85.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
+Read more about it in the [multipart plugin documentation](https://honeyryderchuck.gitlab.io/httpx/wiki/Multipart-Uploads), including also about why this was made.
 
 ### Expect Plugin
 

data/doc/release_notes/1_6_3.md

@@ -7,8 +7,8 @@
 ## Improvements
 
 * `system` resolver now works in a non-blocking manner, initiating the dns query in a separate thread and waiting on the pipe after that (it was blocking the main thread during resolution before).
-* reduce allocation to a sinfle shared option object when headers are passed as a session-level option, like `HTTPX.with(headers: geaders).get(...)`
-* privilege using `String#replace` in buffer operations (instead of "clean-then-append").
+* reduce allocation to a single shared option object when headers are passed as a session-level option, like `HTTPX.with(headers: headers).get(...)`
+* favour using `String#replace` in buffer operations (instead of "clean-then-append").
 * using `Array#unshift` instead of `Array#concat` in order to ensure that request ordering is respected in the face of an in-between error which requires reconnect-and-resend.
 * replaced more internal callback indirection with plain method calls.
 

data/doc/release_notes/1_7_0.md

@@ -0,0 +1,149 @@
+# 1.7.0
+
+## Features
+
+### All AUTH plugin improvements!!
+
+#### `:auth`
+
+The `:auth` plugin can now be used with a dynamic callable object (methods, procs...) to generate the token.
+
+```ruby
+# static token, pre 1.7.0
+HTTPX.plugin(:auth).authorization("API-TOKEN")
+# dynamically generate token!
+HTTPX.plugin(:auth).authorization { generate_new_ephemeral_token }
+```
+
+The `.authorization` method is now syntactic sugar for a new option, `:auth_header_value`, which can be used directly, alongside a `:auth_header_type`:
+
+```ruby
+HTTPX.plugin(:auth).authorization("API-TOKEN")
+HTTPX.plugin(:auth).authorization { generate_new_ephemeral_token }
+HTTPX.plugin(:auth).authorization("Bearer API-TOKEN")
+# same as
+HTTPX.plugin(:auth, auth_header_value: "API-TOKEN")
+HTTPX.plugin(:auth, auth_header_value: -> { generate_new_ephemeral_token })
+HTTPX.plugin(:auth, auth_header_type: "Bearer", auth_header_value: "API-TOKEN")
+```
+
+A new option `:generate_auth_value_on_retry` (which can be passed a callable receiving a response object) is now available; when used alongside the `:retries` plugin, it'll use the callable passed to the `.authorization` method to generate a new token before retrying the request:
+
+```ruby
+authed = HTTPX.plugin(:retries).plugin(:auth, generate_auth_value_on_retry: ->(res) {
+  res.status == 401
+}).authorization { generate_new_ephemeral_token }
+authed.get("https://example.com")
+```
+
+Read more about it in the [auth plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Auth).
+
+#### `:oauth`
+
+The `:oauth` plugin implementation was revamped to make use of the `:auth` plugin new functionality, in order to make managing an oauth session more seamless.
+
+Take the following example:
+
+```ruby
+session = HTTPX.plugin(:oauth).with_oauth_options(
+  issuer: server.origin,
+  client_id: "CLIENT_ID",
+  client_secret: "SECRET",
+)
+session.get("https://example.com") #=> will load server metadata, request an access token, and perform the request with the access token.
+# 2 hours later...
+session.get("https://example.com")
+# it'll reuse the same acces token, and if the request fails with 401, it'll request a new
+# access token using the refresh token grant (when supported by the token issuer), and
+# reperform the original request with the new access token.
+```
+
+A new option, `:oauth_options`, is now available. The same parameters previously supported by the `:oauth_session` options are supported.
+
+The following components are therefore deprecated and scheduled for removal in a future major version:
+
+* `:oauth_session` option
+* `.oauth_auth` session method
+* `.with_access_token` session method
+
+#### `:bearer_auth`, `:digest_auth`; `:ntlm_auth`
+
+The `:auth` plugin is now the foundation of each of these plugins, which haven't suffered major API changes.
+
+Read more about it in the [auth plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/OAuth).
+
+### `:retries` plugin: `:retry_after` backoff algorithms
+
+The `:retries` plugins supports two new possible values for the `:retry_after` option: `:exponential_backoff` and `:polynomial_backoff`. They'll implement the respective calculation per each retry of a given request.
+
+```ruby
+# will wait 1, 2, 4, 8, 16 seconds... depending of how many retries it can wait for
+session = HTTPX.plugin(:retries, retry_after: :exponential_backoff)
+```
+
+Read more about it in the [retries plugin wiki](https://honeyryderchuck.gitlab.io/httpx/wiki/Retries).
+
+### Ractor compatibility
+
+`httpx` can be used within a ractor:
+
+```ruby
+# ruby 4.0 syntax
+response = Ractor.new(uri) do |uri|
+  HTTPX.get(uri)
+end.value
+```
+
+Bear in mind that, if you're connection via HTTPS, you'll need make sure you're using version 4.0 or higher of the `openssl` gem.
+
+The test suite isn't exhaustive for ractors yet, but most plugins should also be ractor-compatible. If they don't work, that's a bug, and you're recommended to report it.
+
+## Improvements
+
+* When encoding the `:json` param to send it as `application/json` payload, (example: `HTTPX.post("https://example.com", json: { foo: "bar })`), and the method uses the `json` standard library, it'll use `JSON.generate` (instead of `JSON.dump`) to encode the JSON payload. The reason is that, unlike `JSON.dump`, it doesn't rely on access to a global mutable hash, and is therefore ractor-safe.
+* `:stream` plugin: the stream response class (the object that is returned in request calls is a stream response) can be extended now. You can add a `StreamResponseMethods` method to your plugin. Read more about it in the documentation.
+* The resolver name cache (used by the native and https resolvers) was remade into a LRU cache, and will therefore not keep on growing when `httpx` is used to connect to a huge number of hostnames in a process.
+* the native and https DNS resolvers will ignore answers with SERVFAIL code while there are retries left (some resolvers use such error code for rate limiting).
+* `:timeout` option values are now validated, and an error is raised when passing an unrecognized timeout option (which is a good layer of protection for typos).
+* pool: try passing the scheduler to a thread waiting on a connection, to avoid the current case where a connection may be checked-in-then-immediately-out-after when doing multiple requests in a loop, never giving a chance to others and potentially making the pool time out.
+* headers deep-freeze and dup.
+
+## Bugfixes
+
+* recover and close connection when an `IOError` is raised while waiting for IO readiness (could cause busy loops during HTTP/2 termination handshake).
+* `:stream_bidi` plugin: improve thread-safety of buffer operations when the session is used from multiple threads.
+* `:stream_bidi` plugin: added missing methods to signal in order to comply with the Selectable API (it was reported as raising `NoMethodError` under certain conditions).
+* `:stream_bidi` plugin: can support non-bidirectional stream requests using the same session.
+* `:stream` plugin: is now compatible with fiber scheduler engines (via the `:fiber_concurrency` plugin).
+* `:stream` plugin: make sure that stream long-running requests do not share the same connection as regular threads.
+* `:digest_auth` plugin: can now support qop values wrapped inside parentheses in the `www-authenticate` header (i.e. `qop="('auth',)"`).
+* https resolver: handle 3XX redirect responses in HTTP DNS queries.
+* https resolver: do not close HTTP connections whhich are shared across AAAA and A resolution paths when its in use by one of them.
+* fix access to private method from `http-2` which was made public in more recent versions, but not in older still-supported versions.
+* fixed resolver log message using a "connection" label.
+* `HTTPX::Response.copy_to` will explicitly close the response at the end; given that the body file can be moved as a result, there is no guarantee that the response is still usable, so might as well just close it altogether.
+* selector: avoid skipping persistent connections in the selector to deactivate due to iterate-and-modify.
+
+## Breaking Changes
+
+### `:digest_auth` error
+
+The main error class for the `:digest_auth` plugin has been moved to a different location. If you were rescuing the `HTTPX::Plugins::DigestAuth::DigestError` error, you should now point to the `HTTPX::Authentication::Digest::Error`.
+
+### `:stream` plugin: `build_request` should receive `stream: true` for stream requests
+
+In case you're building request objects before passing them to the session, you're now forced to create them with the `:stream` option on:
+
+```ruby
+session = HTTPX.plugin(:stream)
+
+# before
+req = session.build_request("GET", "https://example.com/stream")
+session.request(req, stream: true)
+
+# after
+req = session.build_request("GET", "https://example.com/stream", stream: true)
+session.request(req)
+```
+
+Previous code may still work in a few cases, but it is not guaranteed to work on all cases.

data/lib/httpx/adapters/datadog.rb

@@ -80,7 +80,7 @@ module Datadog::Tracing
             else
               span.set_tag(TAG_STATUS_CODE, response.status.to_s)
 
-              span.set_error(::HTTPX::HTTPError.new(response)) if response.status >= 400 && response.status <= 599
+              span.set_error(::HTTPX::HTTPError.new(response)) if response.status.between?(400, 599)
 
               span.set_tags(
                 Datadog.configuration.tracing.header_tags.response_tags(response.headers.to_h)

data/lib/httpx/adapters/faraday.rb

@@ -9,7 +9,7 @@ module Faraday
     class HTTPX < Faraday::Adapter
       def initialize(app = nil, opts = {}, &block)
         @connection = @bind = nil
-        super(app, opts, &block)
+        super
       end
 
       module RequestMixin

data/lib/httpx/altsvc.rb

@@ -8,6 +8,8 @@ module HTTPX
     module ConnectionMixin
       using URIExtensions
 
+      H2_ALTSVC_SCHEMES = %w[https h2].freeze
+
       def send(request)
         request.headers["alt-used"] = @origin.authority if @parser && !@write_buffer.full? && match_altsvcs?(request.uri)
 
@@ -46,7 +48,7 @@ module HTTPX
         uri.origin == other_uri.origin || begin
           case uri.scheme
           when "h2"
-            (other_uri.scheme == "https" || other_uri.scheme == "h2") &&
+            H2_ALTSVC_SCHEMES.include?(other_uri.scheme) &&
               uri.host == other_uri.host &&
               uri.port == other_uri.port
           else

data/lib/httpx/connection/http1.rb

@@ -10,6 +10,11 @@ module HTTPX
     MAX_REQUESTS = 200
     CRLF = "\r\n"
 
+    UPCASED = {
+      "www-authenticate" => "WWW-Authenticate",
+      "http2-settings" => "HTTP2-Settings",
+      "content-md5" => "Content-MD5",
+    }.freeze
     attr_reader :pending, :requests
 
     attr_accessor :max_concurrent_requests
@@ -386,12 +391,6 @@ module HTTPX
       end
     end
 
-    UPCASED = {
-      "www-authenticate" => "WWW-Authenticate",
-      "http2-settings" => "HTTP2-Settings",
-      "content-md5" => "Content-MD5",
-    }.freeze
-
     def capitalized(field)
       UPCASED[field] || field.split("-").map(&:capitalize).join("-")
     end

data/lib/httpx/connection/http2.rb

@@ -3,6 +3,8 @@
 require "securerandom"
 require "http/2"
 
+HTTP2::Connection.__send__(:public, :send_buffer) if HTTP2::VERSION < "1.1.1"
+
 module HTTPX
   class Connection::HTTP2
     include Callbacks

data/lib/httpx/connection.rb

@@ -100,14 +100,13 @@ module HTTPX
     def match?(uri, options)
       return false if !used? && (@state == :closing || @state == :closed)
 
-      (
-        @origins.include?(uri.origin) &&
+      @origins.include?(uri.origin) &&
         # if there is more than one origin to match, it means that this connection
         # was the result of coalescing. To prevent blind trust in the case where the
         # origin came from an ORIGIN frame, we're going to verify the hostname with the
         # SSL certificate
-        (@origins.size == 1 || @origin == uri.origin || (@io.is_a?(SSL) && @io.verify_hostname(uri.host)))
-      ) && @options == options
+        (@origins.size == 1 || @origin == uri.origin || (@io.is_a?(SSL) && @io.verify_hostname(uri.host))) &&
+        @options == options
     end
 
     def mergeable?(connection)
@@ -146,10 +145,6 @@ module HTTPX
       end
     end
 
-    def create_idle(options = {})
-      self.class.new(@origin, @options.merge(options))
-    end
-
     def merge(connection)
       @origins |= connection.instance_variable_get(:@origins)
       if @ssl_session.nil? && connection.ssl_session

data/lib/httpx/domain_name.rb

@@ -55,7 +55,7 @@ module HTTPX
       def new(domain)
         return domain if domain.is_a?(self)
 
-        super(domain)
+        super
       end
 
       # Normalizes a _domain_ using the Punycode algorithm as necessary.

data/lib/httpx/headers.rb

@@ -42,12 +42,12 @@ module HTTPX
     # dupped initialization
     def initialize_dup(orig)
       super
-      @headers = orig.instance_variable_get(:@headers).dup
+      @headers = orig.instance_variable_get(:@headers).transform_values(&:dup)
     end
 
     # freezes the headers hash
     def freeze
-      @headers.freeze
+      @headers.each_value(&:freeze).freeze
       super
     end
 

data/lib/httpx/loggable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "fiber" if RUBY_VERSION < "3.0.0"
+
 module HTTPX
   module Loggable
     COLORS = {

data/lib/httpx/options.rb

@@ -188,33 +188,40 @@ module HTTPX
     end
 
     def merge(other)
-      ivar_map = nil
-      other_ivars = case other
-                    when Options
-                      other.instance_variables
-                    else
-                      other = Hash[other] unless other.is_a?(Hash)
-                      ivar_map = other.keys.to_h { |k| [:"@#{k}", k] }
-                      ivar_map.keys
-      end
+      if (is_options = other.is_a?(Options))
+
+        return self if eql?(other)
+
+        opts_names = other.class.options_names
+
+        return self if opts_names.all? { |opt| public_send(opt) == other.public_send(opt) }
 
-      return self if other_ivars.empty?
+        other_opts = opts_names
+      else
+        other_opts = other # : Hash[Symbol, untyped]
+        other_opts = Hash[other] unless other.is_a?(Hash)
+
+        return self if other_opts.empty?
 
-      return self if other_ivars.all? { |ivar| instance_variable_get(ivar) == access_option(other, ivar, ivar_map) }
+        return self if other_opts.all? { |opt, v| !respond_to?(opt) || public_send(opt) == v }
+      end
 
       opts = dup
 
-      other_ivars.each do |ivar|
-        v = access_option(other, ivar, ivar_map)
+      other_opts.each do |opt, v|
+        next unless respond_to?(opt)
+
+        v = other.public_send(opt) if is_options
+        ivar = :"@#{opt}"
 
         unless v
           opts.instance_variable_set(ivar, v)
           next
         end
 
-        v = opts.__send__(:"option_#{ivar[1..-1]}", v)
+        v = opts.__send__(:"option_#{opt}", v)
 
-        orig_v = instance_variable_get(ivar)
+        orig_v = public_send(opt)
 
         v = orig_v.merge(v) if orig_v.respond_to?(:merge) && v.respond_to?(:merge)
 
@@ -379,7 +386,20 @@ module HTTPX
     end
 
     def option_timeout(value)
-      Hash[value]
+      timeout_hash = Hash[value]
+
+      default_timeouts = DEFAULT_OPTIONS[:timeout]
+
+      # Validate keys and values
+      timeout_hash.each do |key, val|
+        raise TypeError, "invalid timeout: :#{key}" unless default_timeouts.key?(key)
+
+        next if val.nil?
+
+        raise TypeError, ":#{key} must be numeric" unless val.is_a?(Numeric)
+      end
+
+      timeout_hash
     end
 
     def option_supported_compression_formats(value)
@@ -424,6 +444,8 @@ module HTTPX
       end
     end
 
+    # rubocop:disable Lint/UselessConstantScoping
+    # these really need to be defined at the end of the class
     SET_TEMPORARY_NAME = ->(klass, pl = nil) do
       if klass.respond_to?(:set_temporary_name) # ruby 3.4 only
         name = klass.name || "#{klass.superclass.name}(plugin)"
@@ -478,6 +500,7 @@ module HTTPX
       :pool_options => EMPTY_HASH,
       :ip_families => nil,
       :close_on_fork => false,
-    }.freeze
+    }.each_value(&:freeze).freeze
+    # rubocop:enable Lint/UselessConstantScoping
   end
 end

data/lib/httpx/plugins/auth/digest.rb

@@ -8,6 +8,8 @@ module HTTPX
   module Plugins
     module Authentication
       class Digest
+        Error = Class.new(Error)
+
         def initialize(user, password, hashed: false, **)
           @user = user
           @password = password
@@ -29,19 +31,53 @@ module HTTPX
           # discard first token, it's Digest
           auth_info = authenticate[/^(\w+) (.*)/, 2]
 
-          params = auth_info.split(/ *, */)
-                            .to_h { |val| val.split("=", 2) }
-                            .transform_values { |v| v.delete("\"") }
+          raise_format_error unless auth_info
+
+          s = StringScanner.new(auth_info)
+
+          params = {}
+          until s.eos?
+            k = s.scan_until(/=/)
+            raise_format_error unless k&.end_with?("=")
+
+            if s.peek(1) == "\""
+              s.skip("\"")
+              v = s.scan_until(/"/)
+              raise_format_error unless v&.end_with?("\"")
+
+              v = v[0..-2]
+              s.skip_until(/,/)
+            else
+              v = s.scan_until(/,|$/)
+
+              if v&.end_with?(",")
+                v = v[0..-2]
+              else
+                raise_format_error unless s.eos?
+              end
+
+              v = v[0..-2] if v&.end_with?(",")
+            end
+            params[k[0..-2]] = v
+            s.skip(/\s/)
+          end
+
           nonce = params["nonce"]
           nc = next_nonce
 
           # verify qop
           qop = params["qop"]
 
+          if qop
+            # some servers send multiple values wrapped in parentheses (i.e. "(qauth,)")
+            qop = qop[/\(?([^)]+)\)?/, 1]
+            qop = qop.split(",").map { |s| s.delete_prefix("'").delete_suffix("'") }.delete_if(&:empty?).map.first
+          end
+
           if params["algorithm"] =~ /(.*?)(-sess)?$/
             alg = Regexp.last_match(1)
             algorithm = ::Digest.const_get(alg)
-            raise DigestError, "unknown algorithm \"#{alg}\"" unless algorithm
+            raise Error, "unknown algorithm \"#{alg}\"" unless algorithm
 
             sess = Regexp.last_match(2)
           else
@@ -96,6 +132,10 @@ module HTTPX
         def next_nonce
           @nonce += 1
         end
+
+        def raise_format_error
+          raise Error, "unsupported digest header format"
+        end
       end
     end
   end

data/lib/httpx/plugins/auth.rb

@@ -10,13 +10,96 @@ module HTTPX
     # https://gitlab.com/os85/httpx/wikis/Auth#auth
     #
     module Auth
+      def self.subplugins
+        {
+          retries: AuthRetries,
+        }
+      end
+
+      module OptionsMethods
+        def option_auth_header_value(value)
+          value
+        end
+
+        def option_auth_header_type(value)
+          value
+        end
+
+        def option_generate_auth_value_on_retry(value)
+          raise TypeError, "`:generate_auth_value_on_retry` must be a callable" unless value.respond_to?(:call)
+
+          value
+        end
+      end
+
       module InstanceMethods
-        def authorization(token)
-          with(headers: { "authorization" => token })
+        def initialize(*)
+          super
+
+          @auth_header_value = nil
+          @skip_auth_header_value = false
+        end
+
+        def authorization(token = nil, auth_header_type: nil, &blk)
+          with(auth_header_type: auth_header_type, auth_header_value: token || blk)
+        end
+
+        def bearer_auth(token = nil, &blk)
+          authorization(token, auth_header_type: "Bearer", &blk)
+        end
+
+        def skip_auth_header
+          @skip_auth_header_value = true
+          yield
+        ensure
+          @skip_auth_header_value = false
+        end
+
+        def reset_auth_header_value!
+          @auth_header_value = nil
+        end
+
+        private
+
+        def send_request(request, *)
+          return super if @skip_auth_header_value
+
+          @auth_header_value ||= generate_auth_token
+
+          request.authorize(@auth_header_value) if @auth_header_value
+
+          super
+        end
+
+        def generate_auth_token
+          return unless (auth_value = @options.auth_header_value)
+
+          auth_value = auth_value.call(self) if auth_value.respond_to?(:call)
+
+          auth_value
         end
+      end
+
+      module RequestMethods
+        def authorize(auth_value)
+          if (auth_type = @options.auth_header_type)
+            auth_value = "#{auth_type} #{auth_value}"
+          end
+
+          @headers.add("authorization", auth_value)
+        end
+      end
+
+      module AuthRetries
+        module InstanceMethods
+          def prepare_to_retry(request, response)
+            super
+
+            return unless @options.generate_auth_value_on_retry && @options.generate_auth_value_on_retry.call(response)
 
-        def bearer_auth(token)
-          authorization("Bearer #{token}")
+            request.headers.get("authorization").pop
+            @auth_header_value = generate_auth_token
+          end
         end
       end
     end

data/lib/httpx/plugins/aws_sdk_authentication.rb

@@ -94,7 +94,6 @@ module HTTPX
           region: AwsSdkAuthentication.region(@options.aws_profile),
           **options
         )
-
           aws_sigv4_authentication(
             credentials: credentials,
             region: region,

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

@@ -7,6 +7,7 @@ module HTTPX
     # Contains the single cookie info: name, value and attributes.
     class Cookie
       include Comparable
+
       # Maximum number of bytes per cookie (RFC 6265 6.1 requires 4096 at
       # least)
       MAX_LENGTH = 4096

data/lib/httpx/plugins/digest_auth.rb

@@ -8,15 +8,14 @@ module HTTPX
     # https://gitlab.com/os85/httpx/wikis/Auth#digest-auth
     #
     module DigestAuth
-      DigestError = Class.new(Error)
-
       class << self
         def extra_options(options)
           options.merge(max_concurrent_requests: 1)
         end
 
-        def load_dependencies(*)
+        def load_dependencies(klass)
           require_relative "auth/digest"
+          klass.plugin(:auth)
         end
       end
 
@@ -48,11 +47,11 @@ module HTTPX
 
             probe_response = wrap { super(request).first }
 
-            return ([probe_response] * requests.size) unless probe_response.is_a?(Response)
+            return [probe_response] * requests.size unless probe_response.is_a?(Response)
 
             if probe_response.status == 401 && digest.can_authenticate?(probe_response.headers["www-authenticate"])
               request.transition(:idle)
-              request.headers["authorization"] = digest.authenticate(request, probe_response.headers["www-authenticate"])
+              request.authorize(digest.authenticate(request, probe_response.headers["www-authenticate"]))
               super(request)
             else
               probe_response