rigortype 0.2.7 → 0.2.8

data/lib/rigor/plugin/blueprint.rb

@@ -2,25 +2,19 @@
 
 module Rigor
   module Plugin
-    # Frozen, `Ractor.shareable?` description of how to materialise
-    # a single plugin instance inside a worker.
-    # [ADR-15](../../../docs/adr/15-ractor-concurrency.md) Phase 3
-    # introduces the carrier so the eventual worker pool can pass
-    # `Array<Blueprint>` across a Ractor boundary verbatim; each
-    # worker calls {#materialize} once at startup, then owns its
-    # plugin instances (and their mutable per-run accumulators)
-    # for the lifetime of the worker.
+    # Frozen, `Ractor.shareable?` description of how to materialise a single plugin instance inside a worker.
+    # [ADR-15](../../../docs/adr/15-ractor-concurrency.md) Phase 3 introduces the carrier so the eventual worker
+    # pool can pass `Array<Blueprint>` across a Ractor boundary verbatim; each worker calls {#materialize} once
+    # at startup, then owns its plugin instances (and their mutable per-run accumulators) for the lifetime of
+    # the worker.
     #
-    # Holds the constant path (`String`) of the plugin class — NOT
-    # the class object itself. Plugin gems are required from the
-    # main Ractor BEFORE any worker spawns, so every Ractor
-    # resolves the same constant via `Object.const_get`.
+    # Holds the constant path (`String`) of the plugin class — NOT the class object itself. Plugin gems are
+    # required from the main Ractor BEFORE any worker spawns, so every Ractor resolves the same constant via
+    # `Object.const_get`.
     #
-    # The `config` Hash is deep-copied + made shareable at
-    # construction so the Blueprint stays decoupled from whatever
-    # Hash the project configuration emitted. The original config
-    # Hash held by the loader is therefore unaffected by Blueprint
-    # construction.
+    # The `config` Hash is deep-copied + made shareable at construction so the Blueprint stays decoupled from
+    # whatever Hash the project configuration emitted. The original config Hash held by the loader is therefore
+    # unaffected by Blueprint construction.
     class Blueprint
       attr_reader :klass_name, :config
 
@@ -30,12 +24,9 @@ module Rigor
         freeze
       end
 
-      # Resolves the plugin class via `Object.const_get`, builds a
-      # fresh instance bound to the supplied services container,
-      # and calls `#init(services)`. Mirrors
-      # {Rigor::Plugin::Loader#instantiate} bit-for-bit so the
-      # blueprint-driven path stays consistent with the
-      # configuration-driven load path.
+      # Resolves the plugin class via `Object.const_get`, builds a fresh instance bound to the supplied services
+      # container, and calls `#init(services)`. Mirrors {Rigor::Plugin::Loader#instantiate} bit-for-bit so the
+      # blueprint-driven path stays consistent with the configuration-driven load path.
       def materialize(services:)
         klass = Object.const_get(@klass_name)
         plugin = klass.new(services: services, config: @config)

data/lib/rigor/plugin/box.rb

@@ -2,45 +2,36 @@
 
 module Rigor
   module Plugin
-    # ADR-39 slice 5 — the isolation boundary for target-library
-    # invocation. When Rigor is launched with `RUBY_BOX=1` (opt-in; the
-    # launcher re-execs only when a project opts in), a target library is
-    # loaded and called inside a `Ruby::Box` so its **core-class
-    # monkey-patches and gem version cannot contaminate Rigor's main
-    # space**. `Ruby::Box` is not a security sandbox (the gem's code still
-    # runs in-process) — it is the *contamination* boundary the rule
-    # needs, which is sufficient because the rule only ever invokes a
+    # ADR-39 slice 5 — the isolation boundary for target-library invocation. When Rigor is launched with
+    # `RUBY_BOX=1` (opt-in; the launcher re-execs only when a project opts in), a target library is loaded and
+    # called inside a `Ruby::Box` so its **core-class monkey-patches and gem version cannot contaminate Rigor's
+    # main space**. `Ruby::Box` is not a security sandbox (the gem's code still runs in-process) — it is the
+    # *contamination* boundary the rule needs, which is sufficient because the rule only ever invokes a
     # declared, trusted, pure target library.
     #
-    # **Disabled by default.** {enabled?} is false unless the experimental
-    # `Ruby::Box` feature is active, so every consumer keeps a non-box
-    # path and the default behaviour (loading the trusted library into the
-    # main space, per slices 2/4) is unchanged. The box only ever holds
-    # the trusted, project-agnostic target libraries (inflection rules,
-    # the Rack status table); per-project / exact-version boxes are a
-    # later slice.
+    # **Disabled by default.** {enabled?} is false unless the experimental `Ruby::Box` feature is active, so
+    # every consumer keeps a non-box path and the default behaviour (loading the trusted library into the main
+    # space, per slices 2/4) is unchanged. The box only ever holds the trusted, project-agnostic target
+    # libraries (inflection rules, the Rack status table); per-project / exact-version boxes are a later slice.
     module Box
       module_function
 
-      # True only when the experimental `Ruby::Box` feature is present and
-      # active (the process was started with `RUBY_BOX=1`). Any error
-      # answers false so a consumer silently keeps its non-box path.
+      # True only when the experimental `Ruby::Box` feature is present and active (the process was started with
+      # `RUBY_BOX=1`). Any error answers false so a consumer silently keeps its non-box path.
       def enabled?
         defined?(::Ruby::Box) && ::Ruby::Box.respond_to?(:enabled?) && ::Ruby::Box.enabled?
       rescue StandardError
         false
       end
 
-      # The process-shared box for trusted, project-agnostic target
-      # libraries. Built lazily on first use.
+      # The process-shared box for trusted, project-agnostic target libraries. Built lazily on first use.
       def shared
         @shared ||= ::Ruby::Box.new
       end
 
-      # Requires `feature` into the shared box exactly once. Returns true
-      # when the feature is available in the box, false when it could not
-      # be loaded (the caller then declines — never falls back to loading
-      # into the main space, which would defeat the boundary).
+      # Requires `feature` into the shared box exactly once. Returns true when the feature is available in the
+      # box, false when it could not be loaded (the caller then declines — never falls back to loading into the
+      # main space, which would defeat the boundary).
       def require_feature(feature)
         @required ||= {}
         return @required[feature] if @required.key?(feature)
@@ -51,11 +42,9 @@ module Rigor
         @required[feature] = false
       end
 
-      # Evaluates `code` inside the shared box and returns the result
-      # across the box boundary. The caller MUST build `code` safely —
-      # interpolate value arguments through `String#inspect` (which
-      # round-trips as a safe Ruby literal) and only ever interpolate
-      # method names from a fixed allow-list, never free user input.
+      # Evaluates `code` inside the shared box and returns the result across the box boundary. The caller MUST
+      # build `code` safely — interpolate value arguments through `String#inspect` (which round-trips as a safe
+      # Ruby literal) and only ever interpolate method names from a fixed allow-list, never free user input.
       def eval(code)
         shared.eval(code)
       end

data/lib/rigor/plugin/fact_store.rb

@@ -4,23 +4,17 @@ module Rigor
   module Plugin
     # Per-run cross-plugin fact store. ADR-9 § "Plugin::FactStore".
     #
-    # A plugin publishes typed `(plugin_id, name) -> value` tuples
-    # in its `Plugin::Base#prepare(services)` hook (slice 3); other
-    # plugins read them in `#diagnostics_for_file` via
-    # `services.fact_store.read(plugin_id:, name:)`. The store is
-    # constructed fresh at the start of every `Analysis::Runner.run`
-    # and discarded at the end — caching the underlying expensive
-    # computation is the producer's job (`Plugin::Base.producer`);
-    # the FactStore just publishes a *reference* to that
+    # A plugin publishes typed `(plugin_id, name) -> value` tuples in its `Plugin::Base#prepare(services)` hook
+    # (slice 3); other plugins read them in `#diagnostics_for_file` via
+    # `services.fact_store.read(plugin_id:, name:)`. The store is constructed fresh at the start of every
+    # `Analysis::Runner.run` and discarded at the end — caching the underlying expensive computation is the
+    # producer's job (`Plugin::Base.producer`); the FactStore just publishes a *reference* to that
     # already-cached result.
     #
-    # `(plugin_id, name)` is a unique key. A second `publish` with
-    # the same value is a no-op (`==` comparison); a second
-    # `publish` with a different value raises {Conflict}. Since
-    # `plugin_id` namespaces the key, a real conflict only happens
-    # when a single plugin publishes twice with differing values —
-    # the conflict signals a plugin-author bug, never a load-time
-    # interaction between unrelated plugins.
+    # `(plugin_id, name)` is a unique key. A second `publish` with the same value is a no-op (`==` comparison);
+    # a second `publish` with a different value raises {Conflict}. Since `plugin_id` namespaces the key, a real
+    # conflict only happens when a single plugin publishes twice with differing values — the conflict signals a
+    # plugin-author bug, never a load-time interaction between unrelated plugins.
     class FactStore
       Fact = Data.define(:plugin_id, :name, :value)
 
@@ -45,15 +39,13 @@ module Rigor
         @mutex = Mutex.new
       end
 
-      # Writes a `(plugin_id, name) -> value` triple. Idempotent if
-      # the same value is published twice (`==`); raises
-      # {Conflict} if the values differ.
+      # Writes a `(plugin_id, name) -> value` triple. Idempotent if the same value is published twice (`==`);
+      # raises {Conflict} if the values differ.
       #
       # @param plugin_id [String] producing plugin's manifest id.
-      # @param name [Symbol, String] fact name (canonicalised to
-      #   Symbol for lookup).
-      # @param value [Object] frozen-shape value object the
-      #   producer chose to publish. The value is stored as-is.
+      # @param name [Symbol, String] fact name (canonicalised to Symbol for lookup).
+      # @param value [Object] frozen-shape value object the producer chose to publish. The value is stored
+      #   as-is.
       def publish(plugin_id:, name:, value:)
         plugin_id = plugin_id.to_s
         name = name.to_sym
@@ -68,10 +60,8 @@ module Rigor
         nil
       end
 
-      # @return [Object, nil] the published value, or `nil` when no
-      #   fact is registered. Reads do NOT establish a dependency —
-      #   `manifest(consumes:)` (slice 4) is the dependency
-      #   declaration mechanism.
+      # @return [Object, nil] the published value, or `nil` when no fact is registered. Reads do NOT establish
+      #   a dependency — `manifest(consumes:)` (slice 4) is the dependency declaration mechanism.
       def read(plugin_id:, name:)
         fact = @mutex.synchronize { @facts[[plugin_id.to_s, name.to_sym]] }
         fact&.value

data/lib/rigor/plugin/inflector.rb

@@ -2,58 +2,46 @@
 
 module Rigor
   module Plugin
-    # ADR-39 — the shared inflection helper for the Rails-family plugins
-    # (`rigor-rails-routes`, `rigor-activerecord`, `rigor-actionpack`).
+    # ADR-39 — the shared inflection helper for the Rails-family plugins (`rigor-rails-routes`,
+    # `rigor-activerecord`, `rigor-actionpack`).
     #
-    # Inflection (`posts` ↔ `post`, `BlogPost` → `blog_posts`) drives
-    # route-helper and model-name resolution, so an inflection that
-    # diverges from Rails' *actual* rules produces a wrong helper / model
-    # name and therefore a **false positive on working code** (a bogus
-    # `unknown-helper` / `unknown-permit-key`). Rigor therefore inflects
-    # **only** with the real `ActiveSupport::Inflector` — the authority
-    # Rails itself uses — and carries **no built-in approximation**: an
-    # approximation would be exactly the source of wrong facts the
+    # Inflection (`posts` ↔ `post`, `BlogPost` → `blog_posts`) drives route-helper and model-name resolution, so
+    # an inflection that diverges from Rails' *actual* rules produces a wrong helper / model name and therefore
+    # a **false positive on working code** (a bogus `unknown-helper` / `unknown-permit-key`). Rigor therefore
+    # inflects **only** with the real `ActiveSupport::Inflector` — the authority Rails itself uses — and
+    # carries **no built-in approximation**: an approximation would be exactly the source of wrong facts the
     # false-positive discipline forbids.
     #
-    # Per ADR-39 this is a permitted *target-library* invocation: the
-    # methods called are a fixed, pure, allow-listed set
-    # ({ALLOWED_METHODS}) on a trusted gem the consuming plugins declare
-    # as a dependency. (`ActiveSupport::Inflector` is loaded, not the
-    # analyzed application's code; project-specific inflection rules are
-    # ingested by *statically parsing* `config/initializers/inflections.rb`
-    # in a later slice, never by executing it.)
+    # Per ADR-39 this is a permitted *target-library* invocation: the methods called are a fixed, pure,
+    # allow-listed set ({ALLOWED_METHODS}) on a trusted gem the consuming plugins declare as a dependency.
+    # (`ActiveSupport::Inflector` is loaded, not the analyzed application's code; project-specific inflection
+    # rules are ingested by *statically parsing* `config/initializers/inflections.rb` in a later slice, never
+    # by executing it.)
     #
-    # **Absence is silence, never a guess.** When `ActiveSupport::Inflector`
-    # cannot be loaded (a misconfiguration — the consuming plugins declare
-    # it as a dependency, so it is present in practice), the inflection
-    # methods raise {Unavailable} rather than approximate. That raise
-    # propagates to the caller's per-plugin rescue boundary, so the
-    # inflection-dependent check degrades to **no diagnostics** — reduced
-    # coverage, never a wrong fact. A consumer that wants to fail cleanly
-    # up front can gate on {available?} and emit a single load-error.
+    # **Absence is silence, never a guess.** When `ActiveSupport::Inflector` cannot be loaded (a
+    # misconfiguration — the consuming plugins declare it as a dependency, so it is present in practice), the
+    # inflection methods raise {Unavailable} rather than approximate. That raise propagates to the caller's
+    # per-plugin rescue boundary, so the inflection-dependent check degrades to **no diagnostics** — reduced
+    # coverage, never a wrong fact. A consumer that wants to fail cleanly up front can gate on {available?}
+    # and emit a single load-error.
     module Inflector
-      # The pure, side-effect-free `ActiveSupport::Inflector` methods this
-      # helper is permitted to call (ADR-39 § "safety harness"). The set
-      # is fixed and greppable — never a dynamic `public_send`.
+      # The pure, side-effect-free `ActiveSupport::Inflector` methods this helper is permitted to call (ADR-39
+      # § "safety harness"). The set is fixed and greppable — never a dynamic `public_send`.
       #
-      # `tableize` is deliberately NOT delegated: `ActiveSupport::Inflector.
-      # tableize("Admin::User")` returns `"admin/users"`, but ActiveRecord's
-      # *actual* table name flattens the namespace to `"admin_users"` (the
-      # table-name computation does more than the pure `tableize` string
-      # method). So {.tableize} composes the AS-backed `underscore` /
-      # `pluralize` with the `::`→`_` flattening AR really uses.
+      # `tableize` is deliberately NOT delegated: `ActiveSupport::Inflector.tableize("Admin::User")` returns
+      # `"admin/users"`, but ActiveRecord's *actual* table name flattens the namespace to `"admin_users"` (the
+      # table-name computation does more than the pure `tableize` string method). So {.tableize} composes the
+      # AS-backed `underscore` / `pluralize` with the `::`→`_` flattening AR really uses.
       ALLOWED_METHODS = %i[underscore camelize singularize pluralize classify].freeze
 
-      # The target library + the constant the allow-listed methods are
-      # called on. Passed to {Isolation} so the call runs under the
-      # configured isolation strategy (none / ruby_box / process).
+      # The target library + the constant the allow-listed methods are called on. Passed to {Isolation} so the
+      # call runs under the configured isolation strategy (none / ruby_box / process).
       FEATURE = "active_support/inflector"
       RECEIVER = "ActiveSupport::Inflector"
 
-      # Raised when `ActiveSupport::Inflector` is required for an
-      # inflection but cannot be loaded. Caught by the per-plugin isolation
-      # boundary, so it surfaces as "this plugin produced no diagnostics"
-      # rather than a wrong inflection.
+      # Raised when `ActiveSupport::Inflector` is required for an inflection but cannot be loaded. Caught by
+      # the per-plugin isolation boundary, so it surfaces as "this plugin produced no diagnostics" rather than
+      # a wrong inflection.
       class Unavailable < StandardError
       end
 
@@ -84,17 +72,15 @@ module Rigor
         invoke(:classify, table_name)
       end
 
-      # `BlogPost` → `blog_posts`; `Admin::User` → `admin_users`.
-      # Composed (not delegated) so the namespace flattens with `_` the
-      # way ActiveRecord's table naming does — see {ALLOWED_METHODS}.
+      # `BlogPost` → `blog_posts`; `Admin::User` → `admin_users`. Composed (not delegated) so the namespace
+      # flattens with `_` the way ActiveRecord's table naming does — see {ALLOWED_METHODS}.
       def tableize(class_name)
         underscored = underscore(class_name.to_s.gsub("::", "/")).tr("/", "_")
         pluralize(underscored)
       end
 
-      # Whether inflection is available under the configured isolation
-      # strategy. A consumer can gate inflection-dependent work on this to
-      # emit a single clean load-error instead of letting the first
+      # Whether inflection is available under the configured isolation strategy. A consumer can gate
+      # inflection-dependent work on this to emit a single clean load-error instead of letting the first
       # inflection raise. Probes with a trivial pluralization.
       def available?
         invoke(:pluralize, "rigor_inflector_probe")
@@ -103,12 +89,10 @@ module Rigor
         false
       end
 
-      # Delegates an allow-listed method to the real
-      # `ActiveSupport::Inflector` through the configured isolation
-      # strategy ({Isolation}: none / ruby_box / process). Raises
-      # {Unavailable} (never approximates) when the library cannot be
-      # reached in that strategy — the caller's per-plugin rescue turns
-      # that into silence, never a wrong inflection.
+      # Delegates an allow-listed method to the real `ActiveSupport::Inflector` through the configured
+      # isolation strategy ({Isolation}: none / ruby_box / process). Raises {Unavailable} (never approximates)
+      # when the library cannot be reached in that strategy — the caller's per-plugin rescue turns that into
+      # silence, never a wrong inflection.
       def invoke(name, arg)
         raise ArgumentError, "method not allow-listed: #{name}" unless ALLOWED_METHODS.include?(name)
 

data/lib/rigor/plugin/io_boundary.rb

@@ -6,46 +6,30 @@ require_relative "access_denied_error"
 
 module Rigor
   module Plugin
-    # Analyzer-side helper plugins go through to read files and
-    # (eventually) reach the network. The boundary enforces the
-    # active {TrustPolicy} and accumulates a {Cache::Descriptor}
-    # of every read so plugin contributions stay invalidatable
-    # alongside their inputs.
+    # Analyzer-side helper plugins go through to read files and (eventually) reach the network. The boundary
+    # enforces the active {TrustPolicy} and accumulates a {Cache::Descriptor} of every read so plugin
+    # contributions stay invalidatable alongside their inputs.
     #
-    # ADR-2 § "Plugin Trust and I/O Policy" is the binding
-    # contract. The boundary is **not** a sandbox: a plugin that
-    # uses `File.read` directly bypasses everything here, and the
-    # ADR explicitly accepts that trade-off. The discipline is:
-    # when plugin code goes through this surface, reads stay
-    # within the trust scope and feed the cache descriptor;
-    # contributions built on top of out-of-scope reads will not
+    # ADR-2 § "Plugin Trust and I/O Policy" is the binding contract. The boundary is **not** a sandbox: a
+    # plugin that uses `File.read` directly bypasses everything here, and the ADR explicitly accepts that
+    # trade-off. The discipline is: when plugin code goes through this surface, reads stay within the trust
+    # scope and feed the cache descriptor; contributions built on top of out-of-scope reads will not
     # invalidate correctly.
     #
     # Slice 2 ships a minimal surface:
     #
-    # - `#read_file(path)` — validates against the policy, returns
-    #   the file's contents, and adds a digest-keyed
-    #   {Cache::Descriptor::FileEntry} to the boundary's
-    #   accumulated descriptor.
-    # - `#open_url(url)` — fetches the URL when the policy
-    #   permits it (`network_policy: :allowlist` plus an
-    #   `allowed_url_hosts` match) and raises
-    #   {AccessDeniedError} otherwise. v0.1.2 ships the
-    #   allowlist surface; the default project policy still
-    #   has `network_policy: :disabled` so plugins that want
-    #   network access opt in explicitly through
-    #   `.rigor.yml`'s `plugins_io.network: allowlist` plus
-    #   `plugins_io.allowed_url_hosts: [...]`. The HTTP fetch
-    #   is GET-only over HTTPS, capped at {URL_TIMEOUT_SECONDS}
-    #   wall time and {URL_MAX_BYTES} body size; non-2xx
-    #   responses raise {AccessDeniedError} so plugin code
-    #   doesn't have to rescue mid-build.
-    # - `#cache_descriptor` — flushes the accumulated entries into
-    #   a fresh {Cache::Descriptor} for the contribution that
-    #   built it. URL fetches contribute `ConfigEntry` rows
-    #   keyed `"url:#{url}"` with the response body's SHA-256
-    #   so contributions invalidate when the remote document
-    #   changes.
+    # - `#read_file(path)` — validates against the policy, returns the file's contents, and adds a
+    #   digest-keyed {Cache::Descriptor::FileEntry} to the boundary's accumulated descriptor.
+    # - `#open_url(url)` — fetches the URL when the policy permits it (`network_policy: :allowlist` plus an
+    #   `allowed_url_hosts` match) and raises {AccessDeniedError} otherwise. v0.1.2 ships the allowlist
+    #   surface; the default project policy still has `network_policy: :disabled` so plugins that want network
+    #   access opt in explicitly through `.rigor.yml`'s `plugins_io.network: allowlist` plus
+    #   `plugins_io.allowed_url_hosts: [...]`. The HTTP fetch is GET-only over HTTPS, capped at
+    #   {URL_TIMEOUT_SECONDS} wall time and {URL_MAX_BYTES} body size; non-2xx responses raise
+    #   {AccessDeniedError} so plugin code doesn't have to rescue mid-build.
+    # - `#cache_descriptor` — flushes the accumulated entries into a fresh {Cache::Descriptor} for the
+    #   contribution that built it. URL fetches contribute `ConfigEntry` rows keyed `"url:#{url}"` with the
+    #   response body's SHA-256 so contributions invalidate when the remote document changes.
     class IoBoundary
       URL_TIMEOUT_SECONDS = 10
       URL_MAX_BYTES = 10 * 1024 * 1024
@@ -61,10 +45,9 @@ module Rigor
         @mutex = Mutex.new
       end
 
-      # Reads the file at `path` after validating it against the
-      # policy. Raises {AccessDeniedError} when the path is outside
-      # every allowed read root. Records a `:digest` {FileEntry}
-      # so the resulting cache slice invalidates on content change.
+      # Reads the file at `path` after validating it against the policy. Raises {AccessDeniedError} when the
+      # path is outside every allowed read root. Records a `:digest` {FileEntry} so the resulting cache slice
+      # invalidates on content change.
       def read_file(path)
         absolute = File.expand_path(path.to_s)
         unless @policy.allow_read?(absolute)
@@ -81,15 +64,11 @@ module Rigor
         contents
       end
 
-      # Fetches the URL when the policy permits it. Returns the
-      # response body. Raises {AccessDeniedError} when the policy
-      # is `:disabled`, the URL scheme is not `https`, the host is
-      # not on the allowlist, the response is non-2xx, the body
-      # exceeds {URL_MAX_BYTES}, or the request times out
-      # ({URL_TIMEOUT_SECONDS}). On success, records a
-      # `ConfigEntry` keyed `"url:#{url}"` with the body's
-      # SHA-256 so the cache descriptor invalidates if the remote
-      # document changes.
+      # Fetches the URL when the policy permits it. Returns the response body. Raises {AccessDeniedError} when
+      # the policy is `:disabled`, the URL scheme is not `https`, the host is not on the allowlist, the
+      # response is non-2xx, the body exceeds {URL_MAX_BYTES}, or the request times out
+      # ({URL_TIMEOUT_SECONDS}). On success, records a `ConfigEntry` keyed `"url:#{url}"` with the body's
+      # SHA-256 so the cache descriptor invalidates if the remote document changes.
       def open_url(url)
         url_string = url.to_s
         unless @policy.allow_url?(url_string)
@@ -107,10 +86,9 @@ module Rigor
         body
       end
 
-      # @return [Rigor::Cache::Descriptor] frozen snapshot of every
-      #   file / URL the boundary has read so far. Calling this
-      #   multiple times yields equal descriptors; subsequent
-      #   reads expand the underlying record tables.
+      # @return [Rigor::Cache::Descriptor] frozen snapshot of every file / URL the boundary has read so far.
+      #   Calling this multiple times yields equal descriptors; subsequent reads expand the underlying record
+      #   tables.
       def cache_descriptor
         files, configs = @mutex.synchronize { [@file_entries.values.dup, @config_entries.values.dup] }
         Cache::Descriptor.new(files: files, configs: configs)
@@ -132,10 +110,9 @@ module Rigor
       end
     end
 
-    # Default HTTP client wrapping `Net::HTTP`. Wraps a single
-    # `GET` over HTTPS. Specs inject a fake client that conforms
-    # to the same `#get(url, timeout:, max_bytes:)` shape so the
-    # tests don't require network access.
+    # Default HTTP client wrapping `Net::HTTP`. Wraps a single `GET` over HTTPS. Specs inject a fake client
+    # that conforms to the same `#get(url, timeout:, max_bytes:)` shape so the tests don't require network
+    # access.
     class DefaultHttpClient
       def get(url, timeout:, max_bytes:)
         require "net/http"