ruby-link-checker 0.4.0 → 0.5.1

data/README.md

@@ -19,9 +19,13 @@ A fast Ruby link checker with support for multiple HTTP libraries. Does not pars
     - [LinkChecker::Net::HTTP](#linkcheckernethttp)
   - [Options](#options)
     - [Retries](#retries)
+    - [Redirects](#redirects)
     - [Retry After](#retry-after)
+    - [Retry Policy](#retry-policy)
     - [Results](#results)
     - [Methods](#methods)
+    - [Deduplication](#deduplication)
+    - [Caching](#caching)
     - [Logger](#logger)
     - [User-Agent](#user-agent)
     - [Headers](#headers)
@@ -172,6 +176,20 @@ LinkChecker::Async::HTTP.configure do |config|
 end
 ```
 
+You can also force a specific HTTP protocol version, `:http1` or `:http2`, per instance or globally. By default, `async-http` negotiates the protocol version with the server.
+
+```ruby
+LinkChecker::Async::HTTP.configure do |config|
+  config.protocol = :http2
+end
+```
+
+Async::HTTP reuses connection-pooling clients per scheme/host/port. Its default concurrency is unlimited; set `max_concurrency` to bound active requests without counting delayed retries against that limit.
+
+```ruby
+checker = LinkChecker::Async::HTTP::Checker.new(max_concurrency: 25)
+```
+
 #### [LinkChecker::Net::HTTP](lib/ruby-link-checker/net/http/checker.rb)
 
 Slow, sequential checker.
@@ -210,18 +228,43 @@ end
 
 #### Retries
 
-By default link checkers do not retry. You can set a number of times to retry all errors and failures with `retries`.
+By default link checkers do not retry. Set `retries` to enable retries for transient connection errors/timeouts and HTTP statuses 408, 425, 429, 500, 502, 503, and 504. Permanent HTTP failures and invalid URLs are not retried. HEAD-to-GET fallback still applies independently of the retry policy. The retry budget is shared across methods: with `retries: 2`, repeated transient failures produce `HEAD`, `HEAD`, `HEAD`, then `GET`.
 
 ```ruby
-checker = LinkChecker::Net::HTTP::Checker.new(retry: 1)
+checker = LinkChecker::Net::HTTP::Checker.new(retries: 1)
+```
+
+#### Redirects
+
+Checkers follow up to 20 redirects per attempt and detect redirect loops. Relative redirects are resolved against the current response URL. Set `max_redirects` to change the limit, or use `0` to disable redirects.
+
+```ruby
+checker = LinkChecker::Typhoeus::Hydra::Checker.new(max_redirects: 10)
 ```
 
 #### Retry After
 
-If retry is enabled, link checkers can wait for a number of seconds before retrying.
+Set `retry_after` to a minimum delay in seconds (default `0`). Optional `retry_backoff` multiplies that delay on successive retries (default `1`), and `retry_jitter` adds a random fraction between `0` and the configured value (default `0`, maximum `1`). All delays are capped by `max_retry_delay` (default `60` seconds).
+
+```ruby
+checker = LinkChecker::Typhoeus::Hydra::Checker.new(
+  retries: 2,
+  retry_after: 1,
+  retry_backoff: 2,
+  retry_jitter: 0.1,
+  respect_retry_after: true,
+  max_retry_delay: 60
+)
+```
+
+With `respect_retry_after: true` (default `false`), HTTP `Retry-After` delta-seconds and dates provide a minimum delay, subject to the same cap. Invalid or past dates are ignored. Async delays yield without blocking other requests. Hydra queues delayed retries after the active batch drains, so actual delays can exceed the configured minimum without blocking completion callbacks. Delays apply to retries, not ordinary HEAD-to-GET fallback.
+
+#### Retry Policy
+
+Customize `retry_status_codes` to choose retryable HTTP statuses. Set it to `nil` to restore the previous behavior of retrying every failure and error, including malformed URLs and programming errors.
 
 ```ruby
-checker = LinkChecker::Net::HTTP::Checker.new(retry_after: 1) # wait for 1 second before retrying
+checker = LinkChecker::Net::HTTP::Checker.new(retries: 1, retry_status_codes: [429, 503])
 ```
 
 #### Results
@@ -256,6 +299,34 @@ The following examples disables `GET` and only makes `HEAD` requests.
 checker = LinkChecker::Net::HTTP::Checker.new(methods: %w[HEAD])
 ```
 
+#### Deduplication
+
+Set `deduplicate: true` to coalesce identical in-flight requests and reuse successful results for the lifetime of the checker. Failures and errors are rechecked after completion. Each submission still receives its own result events and metadata, including events emitted before it joined an in-flight check. Deduplication is disabled by default.
+
+```ruby
+checker = LinkChecker::Typhoeus::Hydra::Checker.new(deduplicate: true)
+checker.check('https://www.example.org', location: 'one.html')
+checker.check('https://www.example.org', location: 'two.html')
+checker.run # one check, two sets of result events
+```
+
+Identity includes the complete URL (including query values and fragment), transport, methods, headers, user-agent, and request-related settings. Changing those settings prevents reuse. URLs containing user-info credentials bypass deduplication and caching.
+
+#### Caching
+
+Persistent success caching is disabled by default. Enable it with an explicit file path and positive TTL in seconds. Recent successful checks can then be reused across checker instances; failures and errors are never stored. Cache writes are atomic and locked, and unreadable or malformed files fall back to normal checking.
+
+```ruby
+checker = LinkChecker::Typhoeus::Hydra::Checker.new(
+  deduplicate: true,
+  cache: { file: 'tmp/link-checker/cache.json', ttl: 3600 }
+)
+```
+
+Each cache hit emits `:result` and `:success` with the new submission's metadata and `cached? == true`. Persistent hits return `LinkChecker::CachedResult` with the HTTP method, status, original/final URIs, and metadata; native request/response objects and headers are not persisted. Redirect targets containing user-info credentials are not written. Add the cache directory to your ignore rules.
+
+Caching alone does not coalesce in-flight checks. With deduplication enabled, successful results remain reusable within that checker even after the persistent TTL expires. Cached successes do not replay historical redirect/retry events.
+
 #### Logger
 
 Pass your own logger.
@@ -334,6 +405,9 @@ Events are called with results, which contain the following properties.
 | :request_headers  | Request headers.                                                |
 | :redirect_to      | A redirect URL in case of redirects.                            |
 | :error            | A raised error in case of errors.                               |
+| :error_type       | `:timeout`, `:connection`, or `:other` for errors; otherwise `nil`. |
+| :response_headers | Response headers, accessible using `[]`.                        |
+| :cached?          | Whether this result was reused from a successful check.         |
 
 See [result.rb](lib/ruby-link-checker/result.rb) for more details.
 

data/RELEASING.md

@@ -2,59 +2,36 @@
 
 There are no hard rules about when to release ruby-link-checker. Release bug fixes frequently, features not so frequently and breaking API changes rarely.
 
-### Release
+Releases use [ruby-gem-release](https://github.com/dblock/ruby-gem-release/tree/v0.3.1) and the manual [Release workflow](.github/workflows/release.yml). Merges do not publish. Every workflow dispatch performs a real release.
 
-Run tests, check that all tests succeed locally.
+## One-Time Setup
 
-```
-bundle install
-rake
-```
-
-Check that the last build succeeded.
-
-Add a date to this release in [CHANGELOG.md](CHANGELOG.md).
-
-```
-### 0.2.2 (2015/7/10)
-```
+Create a GitHub environment named `release` in this repository. Restrict deployment to `main` and require approval when available.
 
-Remove the line with "Your contribution here.", since there will be no more contributions to this release.
+On [RubyGems.org](https://rubygems.org/gems/ruby-link-checker/trusted_publishers), configure a trusted publisher with repository owner `dblock`, repository name `ruby-link-checker`, workflow filename `release.yml`, and environment `release`. Set the separate workflow repository owner to `dblock` and name to `ruby-gem-release` because publication uses its reusable workflow. No stored RubyGems API key is needed.
 
-Commit your changes.
+The workflow requests `contents: write` and `id-token: write`. Branch rules must allow the release identity to push fast-forward release and next-version commits to `main` and create tags, without allowing force pushes or deletion. Adding the workflow does not configure these permissions or the trusted publisher.
 
-```
-git add README.md CHANGELOG.md lib/ruby-link-checker/version.rb
-git commit -m "Preparing for release, 0.2.2."
-```
+## Prepare and Publish
 
-Release.
+Prepare the intended version in `lib/ruby-link-checker/version.rb` and its matching `### VERSION (Next)` section in `CHANGELOG.md` through a PR. Keep exactly one `* Your contribution here.` placeholder in that section. The workflow releases the current version, dates the changelog, and removes the placeholder; it does not select a new release version.
 
-```
-$ rake release
+Run tests and RuboCop locally and review the release changes before merging:
 
-ruby-link-checker 0.2.2 built to pkg/ruby-link-checker-0.2.2.gem.
-Tagged v0.2.2.
-Pushed git commits and tags.
-Pushed ruby-link-checker 0.2.2 to rubygems.org.
+```sh
+bundle exec rake
 ```
 
-### Prepare for the Next Version
-
-Add the next release to [CHANGELOG.md](CHANGELOG.md).
+After merging, explicit release approval, and successful Trusted Publishing setup, dispatch from `main`:
 
+```sh
+gh workflow run release.yml --ref main
 ```
-### 0.2.3 (Next)
 
-* Your contribution here.
-```
+The workflow runs `bundle exec rake`, publishes the verified gem to RubyGems, pushes the release commit and tag atomically, and creates a GitHub Release with the gem attached. It then increments the patch version and pushes a new development commit with a fresh changelog section. Actions-token pushes do not trigger ordinary push workflows, so the release workflow runs tests and RuboCop before publication.
 
-Increment the third version number in [lib/ruby-link-checker/version.rb](lib/ruby-link-checker/version.rb).
+## Verify and Recover
 
-Commit your changes.
+Verify the published RubyGems version, matching tag and GitHub Release, attached gem, and next development version on `main`.
 
-```
-git add CHANGELOG.md lib/ruby-link-checker/version.rb
-git commit -m "Preparing for next development iteration, 0.2.3."
-git push origin main
-```
+Never automatically rerun a failed or timed-out publication: RubyGems may have accepted the upload. Check registry and GitHub state first. Do not republish an existing version or move its tag. Available `release.gem`, `release.json`, and `release.bundle` recovery artifacts are retained for 30 days; follow the [upstream recovery instructions](https://github.com/dblock/ruby-gem-release/blob/v0.3.1/RELEASING.md#verify-and-recover) to complete only the missing steps.

data/Rakefile

@@ -15,4 +15,12 @@ end
 require 'rubocop/rake_task'
 RuboCop::RakeTask.new(:rubocop)
 
+require 'ruby-gem-release/workflow/ruby_gem'
+require 'ruby-gem-release/changelog'
+
+RubyGemRelease::Workflow::RubyGem.new(
+  version: RubyGemRelease::Version::RubyConstant.new(path: 'lib/ruby-link-checker/version.rb', constant: 'VERSION'),
+  changelog: RubyGemRelease::Changelog::Intridea.new(placeholder: '* Your contribution here.')
+).install_tasks
+
 task default: %i[rubocop spec]

data/lib/ruby-link-checker/async/http/checker.rb

@@ -3,7 +3,7 @@ module LinkChecker
     module HTTP
       class Task < ::LinkChecker::Task
         def run!
-          checker._queue { _run! }
+          checker._queue(delay: delay) { _run! }
         end
 
         private
@@ -42,25 +42,36 @@ module LinkChecker
           end
           @queue = []
           @clients = {}
+          if max_concurrency && (!max_concurrency.is_a?(Integer) || max_concurrency < 1)
+            raise ArgumentError, "Invalid concurrency limit: #{max_concurrency}"
+          end
+
           super
         end
 
         # Runs all queued checks concurrently and blocks until they complete.
         def run
+          require 'async/semaphore'
+
           Barrier do |barrier|
             @barrier = barrier
+            @semaphore = ::Async::Semaphore.new(max_concurrency) if max_concurrency
             _flush!
           end
         ensure
           @barrier = nil
+          @semaphore = nil
           _close_clients!
         end
 
-        def _queue(&block)
+        def _queue(delay: 0, &block)
           if @barrier
-            @barrier.async(&block)
+            @barrier.async do
+              sleep(delay) if delay.positive?
+              @semaphore ? @semaphore.acquire(&block) : block.call
+            end
           else
-            @queue << block
+            @queue << [delay, block]
           end
         end
 
@@ -69,17 +80,32 @@ module LinkChecker
         def _client_for(uri)
           key = [uri.scheme, uri.host, uri.port]
           @clients[key] ||= begin
-            endpoint = ::Async::HTTP::Endpoint.parse(uri.to_s, timeout: open_timeout)
+            endpoint = ::Async::HTTP::Endpoint.parse(uri.to_s, timeout: open_timeout, **_endpoint_options)
             ::Async::HTTP::Client.new(endpoint)
           end
         end
 
         private
 
+        # Maps the configured protocol (:http1 or :http2) to the
+        # corresponding async-http protocol implementation.
+        def _endpoint_options
+          case protocol
+          when :http1
+            { protocol: ::Async::HTTP::Protocol::HTTP1 }
+          when :http2
+            { protocol: ::Async::HTTP::Protocol::HTTP2 }
+          when nil
+            {}
+          else
+            raise ArgumentError, "Unsupported protocol: #{protocol.inspect}, expected :http1 or :http2"
+          end
+        end
+
         def _flush!
           queue = @queue
           @queue = []
-          queue.each { |block| @barrier.async(&block) }
+          queue.each { |delay, block| _queue(delay: delay, &block) }
         end
 
         def _close_clients!

data/lib/ruby-link-checker/async/http/config.rb

@@ -9,6 +9,8 @@ module LinkChecker
         ATTRIBUTES = %i[
           read_timeout
           open_timeout
+          protocol
+          max_concurrency
         ].freeze
 
         attr_accessor(*Config::ATTRIBUTES)
@@ -16,6 +18,8 @@ module LinkChecker
         def reset
           self.read_timeout = nil
           self.open_timeout = nil
+          self.protocol = nil
+          self.max_concurrency = nil
         end
       end
 

data/lib/ruby-link-checker/async/http/result.rb

@@ -58,6 +58,10 @@ module LinkChecker
           Headers.new(request.headers)
         end
 
+        def response_headers
+          response&.headers || {}
+        end
+
         def redirect_to
           return nil unless response
 

data/lib/ruby-link-checker/cache.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'tempfile'
+require 'uri'
+
+module LinkChecker
+  class CachedResult < Result
+    attr_reader :code
+
+    def initialize(data, uri)
+      @code = data.fetch('code')
+      super(URI(data.fetch('result_uri')), data.fetch('method'), URI(uri.to_s))
+      @cached = true
+    end
+
+    def success?
+      true
+    end
+  end
+
+  class Cache
+    VERSION = 1
+
+    def initialize(options, logger:)
+      unless options.is_a?(Hash) && options[:file].is_a?(String) && !options[:file].strip.empty?
+        raise ArgumentError, 'Cache requires a file path'
+      end
+
+      @ttl = options[:ttl]
+      unless @ttl.is_a?(Numeric) && @ttl.real? && @ttl.finite? && @ttl.positive?
+        raise ArgumentError, 'Cache requires a positive, finite TTL in seconds'
+      end
+
+      @file = File.expand_path(options[:file])
+      @logger = logger
+    end
+
+    def fetch(key, uri)
+      data = read_entries[key]
+      return unless fresh?(data) && data['code'].is_a?(Integer) && data['code'].between?(200, 299)
+      return unless data['method'].is_a?(String) && data['result_uri'].is_a?(String)
+
+      parsed = URI(data['result_uri'])
+      return unless %w[http https].include?(parsed.scheme) && parsed.host && !parsed.userinfo
+
+      CachedResult.new(data, uri)
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def store(key, result)
+      return unless result.success?
+      return if URI(result.result_uri.to_s).userinfo
+
+      directory = File.dirname(@file)
+      FileUtils.mkdir_p(directory)
+      File.open("#{@file}.lock", File::RDWR | File::CREAT, 0o600) do |lock|
+        lock.flock(File::LOCK_EX)
+        entries = read_entries.select { |_entry_key, data| fresh?(data) }
+        entries[key] = {
+          'checked_at' => Time.now.to_f,
+          'method' => result.method,
+          'code' => result.code,
+          'result_uri' => result.result_uri.to_s
+        }
+        Tempfile.create(['link-checker-', '.json'], directory) do |file|
+          file.write(JSON.generate('version' => VERSION, 'entries' => entries))
+          file.flush
+          File.rename(file.path, @file)
+        end
+      end
+    rescue IOError, SystemCallError, JSON::GeneratorError
+      @logger.warn("Unable to write link cache #{@file}; result was not cached")
+    end
+
+    private
+
+    def fresh?(data)
+      return false unless data.is_a?(Hash)
+
+      timestamp = data['checked_at']
+      now = Time.now.to_f
+      timestamp.is_a?(Numeric) && timestamp.finite? && timestamp <= now && now - timestamp < @ttl
+    end
+
+    def read_entries
+      data = JSON.parse(File.read(@file))
+      return {} unless data.is_a?(Hash) && data['version'] == VERSION && data['entries'].is_a?(Hash)
+
+      data['entries']
+    rescue Errno::ENOENT
+      {}
+    rescue IOError, SystemCallError, JSON::ParserError
+      @logger.warn("Unable to read link cache #{@file}; checking links normally")
+      {}
+    end
+  end
+end

data/lib/ruby-link-checker/checker.rb

@@ -6,15 +6,17 @@ module LinkChecker
     include LinkChecker::Callbacks
 
     attr_reader :results
-    attr_accessor(*Config::ATTRIBUTES)
 
     def initialize(options = {})
       LinkChecker::Config::ATTRIBUTES.each do |key|
-        send("#{key}=", options[key] || LinkChecker.config.send(key))
+        send("#{key}=", options.fetch(key) { LinkChecker.config.send(key) })
       end
       raise ArgumentError, "Missing methods." if methods&.none?
       @logger ||= options[:logger] || LinkChecker::Config.logger || LinkChecker::Logger.default
       @results = { error: [], failure: [], success: [] } unless options.key?(:results) && !options[:results]
+      @pending = {}
+      @successful = {}
+      @cache_store = Cache.new(cache, logger: @logger) if cache
     end
 
     def task_klass
@@ -25,6 +27,37 @@ module LinkChecker
     end
 
     def check(uri, options = {})
+      return execute_check(uri, options) unless deduplicate || @cache_store
+
+      key = request_key(uri)
+      return execute_check(uri, options) unless key
+
+      subscriber = [uri.to_s.dup, options]
+      if deduplicate && (entry = @pending[key])
+        entry[:subscribers] << subscriber
+        entry[:events].each { |event, result| publish(event, copy_result(result, subscriber)) }
+        return
+      end
+
+      cached_result = @successful[key] if deduplicate
+      cached_result ||= @cache_store&.fetch(key, uri)
+      if cached_result
+        @successful[key] ||= cached_result if deduplicate
+        result = copy_result(cached_result, subscriber)
+        result.cached = true
+        publish(:result, result)
+        publish(:success, result)
+        return
+      end
+
+      entry = { subscribers: [subscriber], events: [] }
+      @pending[key] = entry if deduplicate
+      execute_check(uri, options) { |event, result| handle_shared_result(key, entry, uri, event, result) }
+    end
+
+    private
+
+    def execute_check(uri, options, &handler)
       tasks = Tasks.new(
         self,
         task_klass,
@@ -33,10 +66,49 @@ module LinkChecker
         options
       )
       tasks.on do |event, *args|
-        results[event] << args.first if @results && %i[error failure success].include?(event)
-        callback event, *args
+        handler ? handler.call(event, *args) : publish(event, args.first)
       end
       tasks.execute!
     end
+
+    def publish(event, result)
+      result.checker = self
+      results[event] << result if @results && %i[error failure success].include?(event)
+      callback(event, result)
+    end
+
+    def handle_shared_result(key, entry, uri, event, result)
+      entry[:events] << [event, result]
+      subscribers = entry[:subscribers].dup
+      if %i[error failure success].include?(event)
+        @pending.delete(key) if @pending[key].equal?(entry)
+        if event == :success && request_key(uri) == key
+          @successful[key] = result if deduplicate
+          @cache_store&.store(key, result)
+        end
+      end
+      subscribers.each { |subscriber| publish(event, copy_result(result, subscriber)) }
+    end
+
+    def copy_result(result, subscriber)
+      result.dup.tap do |copy|
+        copy.uri = URI(subscriber.first)
+        copy.result_uri = result.result_uri.dup
+        copy.options = subscriber.last
+      end
+    end
+
+    def request_key(uri)
+      parsed = URI(uri.to_s)
+      return unless %w[http https].include?(parsed.scheme) && parsed.host && !parsed.userinfo
+
+      attributes = Config::ATTRIBUTES - %i[logger cache deduplicate]
+      attributes += %i[timeout connecttimeout read_timeout open_timeout protocol].select { |key| respond_to?(key) }
+      settings = attributes.to_h { |key| [key, send(key)] }
+      settings[:headers] = headers.sort_by { |key, _value| key.to_s }
+      Digest::SHA256.hexdigest(JSON.generate([task_klass.name, parsed.to_s, settings]))
+    rescue URI::InvalidURIError, JSON::GeneratorError, TypeError
+      nil
+    end
   end
 end

data/lib/ruby-link-checker/config.rb

@@ -10,6 +10,15 @@ module LinkChecker
       headers
       logger
       retries
+      max_redirects
+      retry_status_codes
+      retry_after
+      retry_backoff
+      retry_jitter
+      max_retry_delay
+      respect_retry_after
+      deduplicate
+      cache
     ].freeze
 
     attr_accessor(*Config::ATTRIBUTES)
@@ -20,6 +29,15 @@ module LinkChecker
       self.headers = {}
       self.logger = nil
       self.retries = 0
+      self.max_redirects = 20
+      self.retry_status_codes = [408, 425, 429, 500, 502, 503, 504]
+      self.retry_after = 0
+      self.retry_backoff = 1
+      self.retry_jitter = 0
+      self.max_retry_delay = 60
+      self.respect_retry_after = false
+      self.deduplicate = false
+      self.cache = nil
     end
 
     def retries=(value)
@@ -27,6 +45,50 @@ module LinkChecker
 
       @retries = value
     end
+
+    def max_redirects=(value)
+      raise ArgumentError, "Invalid redirect limit: #{value}" unless value.is_a?(Integer) && value >= 0
+
+      @max_redirects = value
+    end
+
+    def retry_status_codes=(value)
+      unless value.nil? || (value.is_a?(Array) && value.all? { |code| code.is_a?(Integer) && code.between?(100, 599) })
+        raise ArgumentError, "Invalid retry status codes: #{value}"
+      end
+
+      @retry_status_codes = value&.dup
+    end
+
+    def retry_after=(value)
+      validate_number!(:retry_after, value, 0)
+      @retry_after = value
+    end
+
+    def retry_backoff=(value)
+      validate_number!(:retry_backoff, value, 1)
+      @retry_backoff = value
+    end
+
+    def retry_jitter=(value)
+      validate_number!(:retry_jitter, value, 0)
+      raise ArgumentError, "Invalid retry_jitter: #{value}" if value > 1
+
+      @retry_jitter = value
+    end
+
+    def max_retry_delay=(value)
+      validate_number!(:max_retry_delay, value, 0)
+      @max_retry_delay = value
+    end
+
+    private
+
+    def validate_number!(name, value, minimum)
+      return if value.is_a?(Numeric) && value.real? && value.finite? && value >= minimum
+
+      raise ArgumentError, "Invalid #{name}: #{value}"
+    end
   end
 
   class << self

data/lib/ruby-link-checker/errors/connection_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LinkChecker
+  module Errors
+    class ConnectionError < BaseError
+      TRANSIENT_CODES = %i[
+        couldnt_resolve_proxy couldnt_resolve_host couldnt_connect
+        partial_file got_nothing send_error recv_error http2 http2_stream
+      ].freeze
+
+      attr_reader :return_code
+
+      def initialize(return_code, message)
+        @return_code = return_code
+        super(message)
+      end
+
+      def error_type
+        TRANSIENT_CODES.include?(return_code) ? :connection : :other
+      end
+    end
+  end
+end

data/lib/ruby-link-checker/errors/redirect_limit_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LinkChecker
+  module Errors
+    class RedirectLimitError < BaseError
+      attr_reader :limit, :urls
+
+      def initialize(limit, urls)
+        @limit = limit
+        @urls = urls
+        super("Redirect limit of #{limit} exceeded: #{urls.join(' -> ')}.")
+      end
+    end
+  end
+end