RubyGems - http - Versions diffs - 6.0.0-java - Mend

http 6.0.0-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (142) hide show

checksums.yaml +7 -0
data/CHANGELOG.md +267 -0
data/CONTRIBUTING.md +26 -0
data/LICENSE.txt +20 -0
data/README.md +263 -0
data/SECURITY.md +17 -0
data/UPGRADING.md +491 -0
data/http.gemspec +48 -0
data/lib/http/base64.rb +22 -0
data/lib/http/chainable/helpers.rb +62 -0
data/lib/http/chainable/verbs.rb +136 -0
data/lib/http/chainable.rb +377 -0
data/lib/http/client.rb +230 -0
data/lib/http/connection/internals.rb +141 -0
data/lib/http/connection.rb +265 -0
data/lib/http/content_type.rb +89 -0
data/lib/http/errors.rb +67 -0
data/lib/http/feature.rb +86 -0
data/lib/http/features/auto_deflate.rb +230 -0
data/lib/http/features/auto_inflate.rb +64 -0
data/lib/http/features/caching/entry.rb +178 -0
data/lib/http/features/caching/in_memory_store.rb +63 -0
data/lib/http/features/caching.rb +216 -0
data/lib/http/features/digest_auth.rb +234 -0
data/lib/http/features/instrumentation.rb +149 -0
data/lib/http/features/logging.rb +231 -0
data/lib/http/features/normalize_uri.rb +34 -0
data/lib/http/features/raise_error.rb +37 -0
data/lib/http/form_data/composite_io.rb +106 -0
data/lib/http/form_data/file.rb +95 -0
data/lib/http/form_data/multipart/param.rb +62 -0
data/lib/http/form_data/multipart.rb +106 -0
data/lib/http/form_data/part.rb +52 -0
data/lib/http/form_data/readable.rb +58 -0
data/lib/http/form_data/urlencoded.rb +175 -0
data/lib/http/form_data/version.rb +8 -0
data/lib/http/form_data.rb +102 -0
data/lib/http/headers/known.rb +90 -0
data/lib/http/headers/normalizer.rb +50 -0
data/lib/http/headers.rb +343 -0
data/lib/http/mime_type/adapter.rb +43 -0
data/lib/http/mime_type/json.rb +41 -0
data/lib/http/mime_type.rb +96 -0
data/lib/http/options/definitions.rb +189 -0
data/lib/http/options.rb +241 -0
data/lib/http/redirector.rb +157 -0
data/lib/http/request/body.rb +181 -0
data/lib/http/request/builder.rb +184 -0
data/lib/http/request/proxy.rb +83 -0
data/lib/http/request/writer.rb +186 -0
data/lib/http/request.rb +375 -0
data/lib/http/response/body.rb +172 -0
data/lib/http/response/inflater.rb +60 -0
data/lib/http/response/parser.rb +223 -0
data/lib/http/response/status/reasons.rb +79 -0
data/lib/http/response/status.rb +263 -0
data/lib/http/response.rb +350 -0
data/lib/http/retriable/delay_calculator.rb +91 -0
data/lib/http/retriable/errors.rb +35 -0
data/lib/http/retriable/performer.rb +197 -0
data/lib/http/session.rb +280 -0
data/lib/http/timeout/global.rb +229 -0
data/lib/http/timeout/null.rb +225 -0
data/lib/http/timeout/per_operation.rb +197 -0
data/lib/http/uri/normalizer.rb +82 -0
data/lib/http/uri/parsing.rb +182 -0
data/lib/http/uri.rb +376 -0
data/lib/http/version.rb +6 -0
data/lib/http.rb +36 -0
data/sig/deps.rbs +122 -0
data/sig/http.rbs +1619 -0
data/test/http/base64_test.rb +28 -0
data/test/http/client_test.rb +739 -0
data/test/http/connection_test.rb +1533 -0
data/test/http/content_type_test.rb +190 -0
data/test/http/errors_test.rb +28 -0
data/test/http/feature_test.rb +49 -0
data/test/http/features/auto_deflate_test.rb +317 -0
data/test/http/features/auto_inflate_test.rb +213 -0
data/test/http/features/caching_test.rb +942 -0
data/test/http/features/digest_auth_test.rb +996 -0
data/test/http/features/instrumentation_test.rb +246 -0
data/test/http/features/logging_test.rb +654 -0
data/test/http/features/normalize_uri_test.rb +41 -0
data/test/http/features/raise_error_test.rb +77 -0
data/test/http/form_data/composite_io_test.rb +215 -0
data/test/http/form_data/file_test.rb +255 -0
data/test/http/form_data/fixtures/the-http-gem.info +1 -0
data/test/http/form_data/multipart_test.rb +303 -0
data/test/http/form_data/part_test.rb +90 -0
data/test/http/form_data/urlencoded_test.rb +164 -0
data/test/http/form_data_test.rb +232 -0
data/test/http/headers/normalizer_test.rb +93 -0
data/test/http/headers_test.rb +888 -0
data/test/http/mime_type/json_test.rb +39 -0
data/test/http/mime_type_test.rb +150 -0
data/test/http/options/base_uri_test.rb +148 -0
data/test/http/options/body_test.rb +21 -0
data/test/http/options/features_test.rb +38 -0
data/test/http/options/form_test.rb +21 -0
data/test/http/options/headers_test.rb +32 -0
data/test/http/options/json_test.rb +21 -0
data/test/http/options/merge_test.rb +78 -0
data/test/http/options/new_test.rb +37 -0
data/test/http/options/proxy_test.rb +32 -0
data/test/http/options_test.rb +575 -0
data/test/http/redirector_test.rb +639 -0
data/test/http/request/body_test.rb +318 -0
data/test/http/request/builder_test.rb +623 -0
data/test/http/request/writer_test.rb +391 -0
data/test/http/request_test.rb +1733 -0
data/test/http/response/body_test.rb +292 -0
data/test/http/response/parser_test.rb +105 -0
data/test/http/response/status_test.rb +322 -0
data/test/http/response_test.rb +502 -0
data/test/http/retriable/delay_calculator_test.rb +194 -0
data/test/http/retriable/errors_test.rb +71 -0
data/test/http/retriable/performer_test.rb +551 -0
data/test/http/session_test.rb +424 -0
data/test/http/timeout/global_test.rb +239 -0
data/test/http/timeout/null_test.rb +218 -0
data/test/http/timeout/per_operation_test.rb +220 -0
data/test/http/uri/normalizer_test.rb +89 -0
data/test/http/uri_test.rb +1140 -0
data/test/http/version_test.rb +15 -0
data/test/http_test.rb +818 -0
data/test/regression_tests.rb +27 -0
data/test/support/capture_warning.rb +10 -0
data/test/support/dummy_server/encoding_routes.rb +47 -0
data/test/support/dummy_server/routes.rb +201 -0
data/test/support/dummy_server/servlet.rb +81 -0
data/test/support/dummy_server.rb +200 -0
data/test/support/fakeio.rb +21 -0
data/test/support/http_handling_shared/connection_reuse_tests.rb +97 -0
data/test/support/http_handling_shared/timeout_tests.rb +134 -0
data/test/support/http_handling_shared.rb +11 -0
data/test/support/proxy_server.rb +207 -0
data/test/support/servers/runner.rb +67 -0
data/test/support/simplecov.rb +28 -0
data/test/support/ssl_helper.rb +108 -0
data/test/test_helper.rb +38 -0
metadata +218 -0

data/lib/http/response.rb ADDED Viewed

@@ -0,0 +1,350 @@
+# frozen_string_literal: true
+require "forwardable"
+require "http/errors"
+require "http/headers"
+require "http/content_type"
+require "http/mime_type"
+require "http/response/status"
+require "http/response/inflater"
+require "http/cookie"
+require "time"
+module HTTP
+  # Represents an HTTP response with status, headers, and body
+  class Response
+    extend Forwardable
+    # The response status
+    #
+    # @example
+    #   response.status # => #<HTTP::Response::Status 200>
+    #
+    # @return [Status] the response status
+    # @api public
+    attr_reader :status
+    # The HTTP version
+    #
+    # @example
+    #   response.version # => "1.1"
+    #
+    # @return [String] the HTTP version
+    # @api public
+    attr_reader :version
+    # The response body
+    #
+    # @example
+    #   response.body
+    #
+    # @return [Body] the response body
+    # @api public
+    attr_reader :body
+    # The original request
+    #
+    # @example
+    #   response.request
+    #
+    # @return [Request] the original request
+    # @api public
+    attr_reader :request
+    # The HTTP headers collection
+    #
+    # @example
+    #   response.headers
+    #
+    # @return [HTTP::Headers] the response headers
+    # @api public
+    attr_reader :headers
+    # The proxy headers
+    #
+    # @example
+    #   response.proxy_headers
+    #
+    # @return [Hash] the proxy headers
+    # @api public
+    attr_reader :proxy_headers
+    # Create a new Response instance
+    #
+    # @example
+    #   Response.new(status: 200, version: "1.1", request: req)
+    #
+    # @param [Integer] status Status code
+    # @param [String] version HTTP version
+    # @param [Hash] headers
+    # @param [Hash] proxy_headers
+    # @param [HTTP::Connection, nil] connection
+    # @param [String, nil] encoding Encoding to use when reading body
+    # @param [String, nil] body
+    # @param [HTTP::Request, nil] request The request this is in response to
+    # @param [String, nil] uri (DEPRECATED) used to populate a missing request
+    # @return [Response]
+    # @api public
+    def initialize(status:, version:, headers: {}, proxy_headers: {}, connection: nil,
+                   encoding: nil, body: nil, request: nil, uri: nil)
+      @version       = version
+      @request       = init_request(request, uri)
+      @status        = HTTP::Response::Status.new(status)
+      @headers       = HTTP::Headers.coerce(headers)
+      @proxy_headers = HTTP::Headers.coerce(proxy_headers)
+      @body          = init_body(body, connection, encoding)
+    end
+    # @!method reason
+    #   Return the reason phrase for the response status
+    #   @example
+    #     response.reason # => "OK"
+    #   @return [String, nil]
+    #   @api public
+    def_delegator :@status, :reason
+    # @!method code
+    #   Return the numeric status code
+    #   @example
+    #     response.code # => 200
+    #   @return [Integer]
+    #   @api public
+    def_delegator :@status, :code
+    # @!method to_s
+    #   Consume the response body as a string
+    #   @example
+    #     response.to_s # => "<html>...</html>"
+    #   @return [String]
+    #   @api public
+    def_delegator :@body, :to_s
+    alias to_str to_s
+    # @!method readpartial
+    #   Read a chunk of the response body
+    #   @example
+    #     response.readpartial # => "chunk"
+    #   @return [String]
+    #   @raise [EOFError] when no more data left
+    #   @api public
+    def_delegator :@body, :readpartial
+    # @!method connection
+    #   Return the underlying connection object
+    #   @example
+    #     response.connection
+    #   @return [HTTP::Connection]
+    #   @api public
+    def_delegator :@body, :connection
+    # @!method uri
+    #   Return the URI of the original request
+    #   @example
+    #     response.uri # => #<HTTP::URI ...>
+    #   @return (see HTTP::Request#uri)
+    #   @api public
+    def_delegator :@request, :uri
+    # Returns an Array ala Rack: `[status, headers, body]`
+    #
+    # @example
+    #   response.to_a # => [200, {"Content-Type" => "text/html"}, "body"]
+    #
+    # @return [Array(Fixnum, Hash, String)]
+    # @api public
+    def to_a
+      [status.to_i, headers.to_h, body.to_s]
+    end
+    # @!method deconstruct
+    #   Array pattern matching interface
+    #
+    #   @example
+    #     response.deconstruct
+    #
+    #   @see #to_a
+    #   @return [Array(Integer, Hash, String)]
+    #   @api public
+    alias deconstruct to_a
+    # Pattern matching interface for matching against response attributes
+    #
+    # @example
+    #   case response
+    #   in { status: 200..299, body: /success/ }
+    #     "ok"
+    #   in { status: 400.. }
+    #     "error"
+    #   end
+    #
+    # @param keys [Array<Symbol>, nil] keys to extract, or nil for all
+    # @return [Hash{Symbol => Object}]
+    # @api public
+    def deconstruct_keys(keys)
+      hash = {
+        status:        @status,
+        version:       @version,
+        headers:       @headers,
+        body:          @body,
+        request:       @request,
+        proxy_headers: @proxy_headers
+      }
+      keys ? hash.slice(*keys) : hash
+    end
+    # Flushes body and returns self-reference
+    #
+    # @example
+    #   response.flush # => #<HTTP::Response ...>
+    #
+    # @return [Response]
+    # @api public
+    def flush
+      body.to_s
+      self
+    end
+    # Value of the Content-Length header
+    #
+    # @example
+    #   response.content_length # => 438
+    #
+    # @return [nil] if Content-Length was not given, or it's value was invalid
+    #   (not an integer, e.g. empty string or string with non-digits).
+    # @return [Integer] otherwise
+    # @api public
+    def content_length
+      # http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3
+      # Clause 3: "If a message is received with both a Transfer-Encoding
+      # and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.
+      return nil if @headers.include?(Headers::TRANSFER_ENCODING)
+      # RFC 7230 Section 3.3.2: If multiple Content-Length values are present,
+      # they must all be identical; otherwise treat as invalid.
+      values = @headers.get(Headers::CONTENT_LENGTH).uniq
+      return nil unless values.one?
+      Integer(values.first, exception: false)
+    end
+    # Parsed Content-Type header
+    #
+    # @example
+    #   response.content_type # => #<HTTP::ContentType ...>
+    #
+    # @return [HTTP::ContentType]
+    # @api public
+    def content_type
+      @content_type ||= ContentType.parse headers[Headers::CONTENT_TYPE]
+    end
+    # @!method mime_type
+    #   MIME type of response (if any)
+    #   @example
+    #     response.mime_type # => "text/html"
+    #   @return [String, nil]
+    #   @api public
+    def_delegator :content_type, :mime_type
+    # @!method charset
+    #   Charset of response (if any)
+    #   @example
+    #     response.charset # => "utf-8"
+    #   @return [String, nil]
+    #   @api public
+    def_delegator :content_type, :charset
+    # Cookies from Set-Cookie headers
+    #
+    # @example
+    #   response.cookies # => [#<HTTP::Cookie ...>, ...]
+    #
+    # @return [Array<HTTP::Cookie>]
+    # @api public
+    def cookies
+      @cookies ||= headers.get(Headers::SET_COOKIE).flat_map { |v| HTTP::Cookie.parse(v, uri) }
+    end
+    # Check if the response uses chunked transfer encoding
+    #
+    # @example
+    #   response.chunked? # => true
+    #
+    # @return [Boolean]
+    # @api public
+    def chunked?
+      return false unless @headers.include?(Headers::TRANSFER_ENCODING)
+      encoding = @headers.get(Headers::TRANSFER_ENCODING)
+      encoding.last == Headers::CHUNKED
+    end
+    # Parse response body with corresponding MIME type adapter
+    #
+    # @example
+    #   response.parse("application/json") # => {"key" => "value"}
+    #
+    # @param type [#to_s] Parse as given MIME type.
+    # @raise (see MimeType.[])
+    # @return [Object]
+    # @api public
+    def parse(type = nil)
+      MimeType[type || mime_type].decode to_s
+    rescue => e
+      raise ParseError, e.message
+    end
+    # Inspect a response
+    #
+    # @example
+    #   response.inspect # => "#<HTTP::Response/1.1 200 OK text/html>"
+    #
+    # @return [String]
+    # @api public
+    def inspect
+      "#<#{self.class}/#{@version} #{code} #{reason} #{mime_type}>"
+    end
+    private
+    # Determine the default encoding for the body
+    # @return [Encoding]
+    # @api private
+    def default_encoding
+      return Encoding::UTF_8 if mime_type == "application/json"
+      Encoding::BINARY
+    end
+    # Initialize the response body
+    #
+    # @return [Body]
+    # @api private
+    def init_body(body, connection, encoding)
+      if body
+        body
+      else
+        encoding ||= charset || default_encoding
+        Response::Body.new(connection, encoding: encoding)
+      end
+    end
+    # Initialize an HTTP::Request
+    #
+    # @return [HTTP::Request]
+    # @api private
+    def init_request(request, uri)
+      raise ArgumentError, ":uri is for backwards compatibilty and conflicts with :request" if request && uri
+      # For backwards compatibilty
+      if uri
+        HTTP::Request.new(uri: uri, verb: :get)
+      else
+        request
+      end
+    end
+  end
+end

data/lib/http/retriable/delay_calculator.rb ADDED Viewed

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+module HTTP
+  module Retriable
+    # Calculates retry delays with support for Retry-After headers
+    # @api private
+    class DelayCalculator
+      # Initializes the delay calculator
+      #
+      # @param [#call, Numeric, nil] delay delay value or proc
+      # @param [#to_f] max_delay maximum delay cap
+      # @api private
+      # @return [HTTP::Retriable::DelayCalculator]
+      def initialize(delay: nil, max_delay: Float::MAX)
+        @max_delay = Float(max_delay)
+        if delay.respond_to?(:call)
+          @delay_proc = delay
+        else
+          @delay = delay
+        end
+      end
+      # Calculates delay for the given iteration
+      #
+      # @param [Integer] iteration
+      # @param [HTTP::Response, nil] response
+      # @api private
+      # @return [Numeric]
+      def call(iteration, response)
+        delay = if response && (retry_header = response.headers["Retry-After"])
+                  delay_from_retry_header(retry_header)
+                else
+                  calculate_delay_from_iteration(iteration)
+                end
+        ensure_delay_in_bounds(delay)
+      end
+      # Pattern matching RFC 2822 formatted dates in Retry-After headers
+      RFC2822_DATE_REGEX = /^
+        (?:Sun|Mon|Tue|Wed|Thu|Fri|Sat),\s+
+        (?:0[1-9]|[1-2]?[0-9]|3[01])\s+
+        (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+
+        (?:19[0-9]{2}|[2-9][0-9]{3})\s+
+        (?:2[0-3]|[0-1][0-9]):(?:[0-5][0-9]):(?:60|[0-5][0-9])\s+
+        GMT
+      $/x
+      # Parses delay from Retry-After header value
+      #
+      # @param [String] value
+      # @api private
+      # @return [Numeric]
+      def delay_from_retry_header(value)
+        value = String(value).strip
+        case value
+        when RFC2822_DATE_REGEX then DateTime.rfc2822(value).to_time - Time.now.utc
+        when /\A\d+$/           then value.to_i
+        else 0
+        end
+      end
+      # Calculates delay based on iteration number
+      #
+      # @param [Integer] iteration
+      # @api private
+      # @return [Numeric]
+      def calculate_delay_from_iteration(iteration)
+        if @delay_proc
+          @delay_proc.call(iteration)
+        elsif @delay
+          @delay
+        else
+          delay = (2**(iteration - 1)) - 1
+          delay_noise = rand
+          delay + delay_noise
+        end
+      end
+      # Clamps delay to configured bounds
+      #
+      # @param [Numeric] delay
+      # @api private
+      # @return [Numeric]
+      def ensure_delay_in_bounds(delay)
+        Float(delay.clamp(0, @max_delay))
+      end
+    end
+  end
+end

data/lib/http/retriable/errors.rb ADDED Viewed

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module HTTP
+  # Retriable performance ran out of attempts
+  class OutOfRetriesError < Error
+    # The last response received before failure
+    #
+    # @example
+    #   error.response
+    #
+    # @return [HTTP::Response, nil] the last response received
+    # @api public
+    attr_accessor :response
+    # Set the underlying exception
+    #
+    # @example
+    #   error.cause = original_error
+    #
+    # @return [Exception, nil]
+    # @api public
+    attr_writer :cause
+    # Returns the cause of the error
+    #
+    # @example
+    #   error.cause
+    #
+    # @api public
+    # @return [Exception, nil]
+    def cause
+      @cause || super
+    end
+  end
+end

data/lib/http/retriable/performer.rb ADDED Viewed

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+require "date"
+require "http/retriable/errors"
+require "http/retriable/delay_calculator"
+require "openssl"
+module HTTP
+  # Retry logic for failed HTTP requests
+  module Retriable
+    # Request performing watchdog.
+    # @api private
+    class Performer
+      # Exceptions we should retry
+      RETRIABLE_ERRORS = [
+        HTTP::TimeoutError,
+        HTTP::ConnectionError,
+        IO::EAGAINWaitReadable,
+        Errno::ECONNRESET,
+        Errno::ECONNREFUSED,
+        Errno::EHOSTUNREACH,
+        OpenSSL::SSL::SSLError,
+        EOFError,
+        IOError
+      ].freeze
+      # Create a new retry performer
+      #
+      # @param [#to_i] tries maximum number of attempts
+      # @param [#call, #to_i, nil] delay delay between retries
+      # @param [Array<Exception>] exceptions exception classes to retry
+      # @param [Array<#to_i>, nil] retry_statuses status codes to retry
+      # @param [#call] on_retry callback invoked on each retry
+      # @param [#to_f] max_delay maximum delay between retries
+      # @param [#call, nil] should_retry custom retry predicate
+      # @api private
+      # @return [HTTP::Retriable::Performer]
+      def initialize(tries: 5, delay: nil, exceptions: RETRIABLE_ERRORS, retry_statuses: nil,
+                     on_retry: ->(*_args) {}, max_delay: Float::MAX, should_retry: nil)
+        @exception_classes = exceptions
+        @retry_statuses = retry_statuses
+        @tries = tries.to_i
+        @on_retry = on_retry
+        @should_retry_proc = should_retry
+        @delay_calculator = DelayCalculator.new(delay: delay, max_delay: max_delay)
+      end
+      # Execute request with retry logic
+      #
+      # @see #initialize
+      # @return [HTTP::Response]
+      # @api private
+      def perform(client, req, &block)
+        1.upto(Float::INFINITY) do |attempt| # infinite loop with index
+          err, res = try_request(&block)
+          if retry_request?(req, err, res, attempt)
+            retry_attempt(client, req, err, res, attempt)
+          elsif err
+            finish_attempt(client, err)
+          elsif res
+            return res
+          end
+        end
+      end
+      # Calculates delay between retries
+      #
+      # @param [Integer] iteration
+      # @param [HTTP::Response, nil] response
+      # @api private
+      # @return [Numeric]
+      def calculate_delay(iteration, response)
+        @delay_calculator.call(iteration, response)
+      end
+      private
+      # Executes a single retry attempt
+      #
+      # @api private
+      # @return [void]
+      def retry_attempt(client, req, err, res, attempt)
+        # Some servers support Keep-Alive on any response. Thus we should
+        # flush response before retry, to avoid state error (when socket
+        # has pending response data and we try to write new request).
+        # Alternatively, as we don't need response body here at all, we
+        # are going to close client, effectively closing underlying socket
+        # and resetting client's state.
+        wait_for_retry_or_raise(req, err, res, attempt)
+      ensure
+        client.close
+      end
+      # Closes client and raises the error
+      #
+      # @api private
+      # @return [void]
+      def finish_attempt(client, err)
+        client.close
+        raise err
+      end
+      # Attempts to execute the request block
+      #
+      # @api private
+      # @return [Array]
+      # rubocop:disable Lint/RescueException
+      def try_request
+        err, res = nil
+        begin
+          res = yield
+        rescue Exception => e
+          err = e
+        end
+        [err, res]
+      end
+      # rubocop:enable Lint/RescueException
+      # Checks whether the request should be retried
+      #
+      # @api private
+      # @return [Boolean]
+      def retry_request?(req, err, res, attempt)
+        if @should_retry_proc
+          @should_retry_proc.call(req, err, res, attempt)
+        elsif err
+          retry_exception?(err)
+        else
+          retry_response?(res)
+        end
+      end
+      # Checks whether the exception is retriable
+      #
+      # @api private
+      # @return [Boolean]
+      def retry_exception?(err)
+        @exception_classes.any? { |e| err.is_a?(e) }
+      end
+      # Checks whether the response status warrants retry
+      #
+      # @api private
+      # @return [Boolean]
+      def retry_response?(res)
+        return false unless @retry_statuses
+        response_status = Integer(res.status)
+        retry_matchers = [@retry_statuses].flatten
+        retry_matchers.any? do |matcher|
+          case matcher
+          when Range then matcher.cover?(response_status)
+          when Numeric then matcher == response_status
+          else matcher.call(response_status)
+          end
+        end
+      end
+      # Waits for retry delay or raises if out of attempts
+      #
+      # @api private
+      # @return [void]
+      def wait_for_retry_or_raise(req, err, res, attempt)
+        if attempt < @tries
+          @on_retry.call(req, err, res)
+          sleep(calculate_delay(attempt, res))
+        else
+          res&.flush
+          raise out_of_retries_error(req, res, err)
+        end
+      end
+      # Builds OutOfRetriesError
+      #
+      # @param request [HTTP::Request]
+      # @param response [HTTP::Response, nil]
+      # @param exception [Exception, nil]
+      # @api private
+      # @return [HTTP::OutOfRetriesError]
+      def out_of_retries_error(request, response, exception)
+        message = format("%s <%s> failed", String(request.verb).upcase, request.uri)
+        message += " with #{response.status}" if response
+        message += ":#{exception}" if exception
+        OutOfRetriesError.new(message).tap do |ex|
+          ex.cause = exception
+          ex.response = response
+        end
+      end
+    end
+  end
+end