rigortype 0.2.7 → 0.2.9

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_index.rb

@@ -3,23 +3,17 @@
 module Rigor
   module Plugin
     class RailsI18n < Rigor::Plugin::Base
-      # Frozen catalogue of every dotted key discovered across
-      # all loaded locale files. Each entry tracks the locales
-      # the key appears in and, for each locale, the set of
-      # `%{var}` interpolation placeholders observed in the
-      # leaf string.
+      # Frozen catalogue of every dotted key discovered across all loaded locale files. Each entry tracks
+      # the locales the key appears in and, for each locale, the set of `%{var}` interpolation placeholders
+      # observed in the leaf string.
       #
-      # The catalogue is intentionally lossy: it only records
-      # the *presence* of each key per locale and the
-      # placeholder names. The actual translated values are
-      # not retained — the analyzer doesn't need them and
-      # keeping them would bloat the cache slice.
+      # The catalogue is intentionally lossy: it only records the *presence* of each key per locale and the
+      # placeholder names. The actual translated values are not retained — the analyzer doesn't need them
+      # and keeping them would bloat the cache slice.
       class LocaleIndex
-        # `placeholders` is a Hash: `locale_name => Set<String>`.
-        # `array_value` is true when at least one locale's leaf
-        # is an Array (used by `l(time, format:)` and similar).
-        # `value_kinds` is a Hash: `locale_name => Symbol`
-        # (`:string` / `:array` / `:hash`).
+        # `placeholders` is a Hash: `locale_name => Set<String>`. `array_value` is true when at least one
+        # locale's leaf is an Array (used by `l(time, format:)` and similar). `value_kinds` is a Hash:
+        # `locale_name => Symbol` (`:string` / `:array` / `:hash`).
         Entry = Data.define(:dotted_key, :placeholders, :value_kinds) do
           def locales
             placeholders.keys
@@ -33,8 +27,7 @@ module Rigor
             placeholders.fetch(locale.to_s) { Set.new }
           end
 
-          # Union of placeholder names across all known
-          # locales — used by the analyzer when no specific
+          # Union of placeholder names across all known locales — used by the analyzer when no specific
           # locale is in scope.
           def all_placeholders
             placeholders.values.reduce(Set.new) { |acc, set| acc | set }
@@ -44,8 +37,7 @@ module Rigor
         attr_reader :entries, :locales
 
         # @param entries [Array<Entry>]
-        # @param locales [Array<String>] all locale names
-        #   that contributed at least one key.
+        # @param locales [Array<String>] all locale names that contributed at least one key.
         def initialize(entries, locales:)
           @entries = entries.freeze
           @locales = locales.dup.freeze
@@ -62,19 +54,15 @@ module Rigor
           @by_key.key?(dotted_key.to_s)
         end
 
-        # CLDR plural form keys recognised by Ruby I18n. When a
-        # locale defines `accounts.posts.one`, `accounts.posts.other`,
-        # the call `t('accounts.posts', count: n)` resolves into
-        # the matching plural sub-key — the parent `accounts.posts`
-        # is a **pluralization namespace**, not a missing key.
-        # Mastodon hits this on `accounts.posts` /
-        # `accounts.following` / `accounts.followers` for the post,
-        # follow, and follower counts shown on the profile page.
+        # CLDR plural form keys recognised by Ruby I18n. When a locale defines `accounts.posts.one`,
+        # `accounts.posts.other`, the call `t('accounts.posts', count: n)` resolves into the matching
+        # plural sub-key — the parent `accounts.posts` is a **pluralization namespace**, not a missing key.
+        # Mastodon hits this on `accounts.posts` / `accounts.following` / `accounts.followers` for the
+        # post, follow, and follower counts shown on the profile page.
         PLURAL_SUBKEYS = %w[zero one two few many other].freeze
 
-        # Returns true when the dotted key itself isn't a leaf in
-        # any locale, but at least one of its CLDR plural form
-        # children exists.
+        # Returns true when the dotted key itself isn't a leaf in any locale, but at least one of its CLDR
+        # plural form children exists.
         def pluralization_namespace?(dotted_key)
           base = dotted_key.to_s
           PLURAL_SUBKEYS.any? { |sub| @by_key.key?("#{base}.#{sub}") }
@@ -88,14 +76,12 @@ module Rigor
           @entries.size
         end
 
-        # All known dotted keys, sorted for stable did-you-mean
-        # output.
+        # All known dotted keys, sorted for stable did-you-mean output.
         def keys
           @by_key.keys.sort
         end
 
-        # Returns the locales (set of strings) in which a key
-        # is *missing*, given the configured locale list.
+        # Returns the locales (set of strings) in which a key is *missing*, given the configured locale list.
         def missing_locales_for(dotted_key, configured_locales:)
           entry = find(dotted_key)
           return configured_locales.to_set if entry.nil?

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -7,27 +7,21 @@ require_relative "locale_index"
 module Rigor
   module Plugin
     class RailsI18n < Rigor::Plugin::Base
-      # Walks `locale_search_paths` for `.yml` / `.yaml`
-      # files, reads each through the trusted IoBoundary,
-      # parses with `YAML.safe_load`, and folds the resulting
-      # nested hash into a flat `dotted_key => Entry` table.
+      # Walks `locale_search_paths` for `.yml` / `.yaml` files, reads each through the trusted IoBoundary,
+      # parses with `YAML.safe_load`, and folds the resulting nested hash into a flat `dotted_key => Entry`
+      # table.
       #
-      # The top-level YAML key is the locale (`en:`, `ja:`,
-      # …). Anything underneath is recursively flattened into
-      # dotted keys (`users.welcome`, `errors.messages.blank`,
-      # …). For each leaf string, `%{var}` placeholders are
-      # extracted via a simple regex.
+      # The top-level YAML key is the locale (`en:`, `ja:`, …). Anything underneath is recursively
+      # flattened into dotted keys (`users.welcome`, `errors.messages.blank`, …). For each leaf string,
+      # `%{var}` placeholders are extracted via a simple regex.
       #
-      # Files that fail to parse are skipped with a load-error
-      # diagnostic surfaced through the plugin's error
-      # channel. Non-Hash YAML roots (e.g. a top-level
-      # sequence) are also skipped — the format is locale-keyed
-      # by convention.
+      # Files that fail to parse are skipped with a load-error diagnostic surfaced through the plugin's
+      # error channel. Non-Hash YAML roots (e.g. a top-level sequence) are also skipped — the format is
+      # locale-keyed by convention.
       class LocaleLoader
         PLACEHOLDER_RE = /%\{(?<name>[^}]+)\}/
 
-        # Errno classes that indicate "this file is not
-        # readable as a YAML locale" — swallowed so a single
+        # Errno classes that indicate "this file is not readable as a YAML locale" — swallowed so a single
         # bad path doesn't take down the rest of the index.
         IO_ERRORS = [Errno::ENOENT, Errno::EACCES, Errno::EISDIR].freeze
 
@@ -100,19 +94,15 @@ module Rigor
           end.sort
         end
 
-        # Recursively walks the per-locale subtree, yielding
-        # `[dotted_key, leaf_value]` for each leaf. Hash leaves are
-        # *not* recorded as entries themselves — only their
-        # descendants — but every leaf scalar / array IS recorded.
+        # Recursively walks the per-locale subtree, yielding `[dotted_key, leaf_value]` for each leaf. Hash
+        # leaves are *not* recorded as entries themselves — only their descendants — but every leaf scalar
+        # / array IS recorded.
         #
-        # `breadcrumbs` is a single mutable stack reused across the
-        # whole walk (push before recursing, pop after): for the
-        # 530-file / 14 MB Mastodon locale corpus the old
-        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape
-        # allocated a fresh breadcrumb Array at every node plus an
-        # intermediate result Array at every level — millions of
-        # short-lived objects and the run's top allocation site. The
-        # dotted key is still materialised once per leaf (it has to
+        # `breadcrumbs` is a single mutable stack reused across the whole walk (push before recursing, pop
+        # after): for the 530-file / 14 MB Mastodon locale corpus the old
+        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape allocated a fresh breadcrumb Array at
+        # every node plus an intermediate result Array at every level — millions of short-lived objects and
+        # the run's top allocation site. The dotted key is still materialised once per leaf (it has to
         # be); everything else is now allocation-free traversal.
         def each_flattened(node, breadcrumbs, &)
           if node.is_a?(Hash)
@@ -129,9 +119,8 @@ module Rigor
         def extract_placeholders(value)
           case value
           when String
-            # Most locale leaves carry no `%{var}`; skip the scan +
-            # flatten + to_set allocation trio for them. A string with
-            # no `%{` yields an empty placeholder set either way.
+            # Most locale leaves carry no `%{var}`; skip the scan + flatten + to_set allocation trio for
+            # them. A string with no `%{` yields an empty placeholder set either way.
             return Set.new unless value.include?("%{")
 
             value.scan(PLACEHOLDER_RE).flatten.to_set

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -8,16 +8,12 @@ require_relative "rails_i18n/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-rails-i18n — validates `t('key.path')` /
-    # `I18n.t(...)` calls against `config/locales/*.yml`.
+    # rigor-rails-i18n — validates `t('key.path')` / `I18n.t(...)` calls against `config/locales/*.yml`.
     #
     # Tier 1B of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Statically reads every YAML file under
-    # `locale_search_paths` (default `config/locales/`),
-    # builds a flat `dotted_key => Entry` index keyed by the
-    # leaf key path, and validates every `t(literal_key, ...)`
-    # call site against the catalogue. No Rails runtime
-    # dependency.
+    # Statically reads every YAML file under `locale_search_paths` (default `config/locales/`), builds a
+    # flat `dotted_key => Entry` index keyed by the leaf key path, and validates every `t(literal_key, ...)`
+    # call site against the catalogue. No Rails runtime dependency.
     #
     # ## Configuration
     #
@@ -30,55 +26,37 @@ module Rigor
     #
     # ## What it checks
     #
-    # 1. **Key existence** — `t('users.welcome')` is flagged
-    #    when `users.welcome` does not appear in any locale.
-    # 2. **Per-locale coverage** — when the key resolves in
-    #    some locales but not all configured locales, the
-    #    plugin emits a `missing-locale` warning. Suppressed
-    #    when the call site passes `default:`.
-    # 3. **Interpolation variables** — the leaf string's
-    #    `%{var}` placeholders must match the call's keyword
-    #    arguments. Missing placeholders are errors; extra
-    #    arguments are warnings.
-    # 4. **View template lazy keys** — `t('.title')` inside
-    #    `app/views/setting/index.html.erb` expands to
-    #    `setting.index.title` and is validated against the
-    #    locale index. ERB, Haml, and Slim templates are
+    # 1. **Key existence** — `t('users.welcome')` is flagged when `users.welcome` does not appear in any
+    #    locale.
+    # 2. **Per-locale coverage** — when the key resolves in some locales but not all configured locales,
+    #    the plugin emits a `missing-locale` warning. Suppressed when the call site passes `default:`.
+    # 3. **Interpolation variables** — the leaf string's `%{var}` placeholders must match the call's
+    #    keyword arguments. Missing placeholders are errors; extra arguments are warnings.
+    # 4. **View template lazy keys** — `t('.title')` inside `app/views/setting/index.html.erb` expands to
+    #    `setting.index.title` and is validated against the locale index. ERB, Haml, and Slim templates are
     #    scanned under `view_search_paths`.
     #
     # ## Limitations
     #
-    # - Only literal-string keys are validated. `t(key)` with
-    #   a variable receiver is silently passed through.
-    # - Lazy lookup (`t('.key')`) is supported for controller
-    #   files (`app/controllers/**/*_controller.rb`): the key
-    #   is expanded to `<controller_scope>.<action>.<key>`
-    #   using the file path and the innermost enclosing `def`.
-    #   Lazy keys in non-controller `.rb` files (models, helpers,
-    #   mailers, …) are silently skipped — the controller/action
-    #   scope cannot be statically determined there.
-    # - View template lazy keys (`t('.key')` inside ERB / Haml /
-    #   Slim) are validated for key existence and per-locale
-    #   coverage. Interpolation variable validation is skipped
-    #   for view templates (the hash may come from controller
-    #   instance variables not visible in the template).
-    #   The view scan is a project-wide pass surfaced through the
-    #   per-file diagnostic hook, so under `--workers` each
-    #   fork-pool worker re-emits the full set (the same
-    #   once-per-run limitation the `load-error` path carries);
+    # - Only literal-string keys are validated. `t(key)` with a variable receiver is silently passed through.
+    # - Lazy lookup (`t('.key')`) is supported for controller files (`app/controllers/**/*_controller.rb`):
+    #   the key is expanded to `<controller_scope>.<action>.<key>` using the file path and the innermost
+    #   enclosing `def`. Lazy keys in non-controller `.rb` files (models, helpers, mailers, …) are silently
+    #   skipped — the controller/action scope cannot be statically determined there.
+    # - View template lazy keys (`t('.key')` inside ERB / Haml / Slim) are validated for key existence and
+    #   per-locale coverage. Interpolation variable validation is skipped for view templates (the hash may
+    #   come from controller instance variables not visible in the template). The view scan is a
+    #   project-wide pass surfaced through the per-file diagnostic hook, so under `--workers` each fork-pool
+    #   worker re-emits the full set (the same once-per-run limitation the `load-error` path carries);
     #   sequential `rigor check` is unaffected.
-    # - Pluralization (`t('errors.messages.too_short',
-    #   count: n)`) is recognised at the call site but the
-    #   `count` key is not used to validate the locale's
-    #   pluralization branches.
-    # - YAML aliases / merges are accepted (Psych's standard
-    #   `aliases: true`) but custom Ruby classes inside the
-    #   YAML are NOT permitted (`safe_load`).
+    # - Pluralization (`t('errors.messages.too_short', count: n)`) is recognised at the call site but the
+    #   `count` key is not used to validate the locale's pluralization branches.
+    # - YAML aliases / merges are accepted (Psych's standard `aliases: true`) but custom Ruby classes
+    #   inside the YAML are NOT permitted (`safe_load`).
     class RailsI18n < Rigor::Plugin::Base
       manifest(
         id: "rails-i18n",
-        # Bumped 2026-06-23 — view template lazy-key scanning
-        # (`t('.key')` inside ERB / Haml / Slim under
+        # Bumped 2026-06-23 — view template lazy-key scanning (`t('.key')` inside ERB / Haml / Slim under
         # `view_search_paths`).
         version: "0.3.0",
         description: "Validates I18n `t(key)` calls against `config/locales/*.yml`.",
@@ -89,12 +67,10 @@ module Rigor
         }
       )
 
-      # `watch:` covers every `.yml` / `.yaml` file under the locale
-      # search paths so the cache invalidates when locale files are
-      # added, removed, or edited (ADR-60 WD3). `@load_errors` is a
-      # producer-side capture: it is populated only when the block
-      # runs (a cache miss / a watched file changed), which is exactly
-      # when a malformed YAML must re-surface.
+      # `watch:` covers every `.yml` / `.yaml` file under the locale search paths so the cache invalidates
+      # when locale files are added, removed, or edited (ADR-60 WD3). `@load_errors` is a producer-side
+      # capture: it is populated only when the block runs (a cache miss / a watched file changed), which is
+      # exactly when a malformed YAML must re-surface.
       producer :locale_index, watch: -> { [[@locale_search_paths, "**/*.yml", "**/*.yaml"]] } do |_params|
         loader = LocaleLoader.new(
           io_boundary: io_boundary,
@@ -105,14 +81,12 @@ module Rigor
         index
       end
 
-      # Scans view templates under `view_search_paths` for lazy
-      # `t('.key')` / `I18n.translate('.key')` calls and validates
-      # each expanded key against the locale index. Interpolation
-      # validation is skipped — the hash may come from controller
-      # instance variables not visible in the template source.
+      # Scans view templates under `view_search_paths` for lazy `t('.key')` / `I18n.translate('.key')`
+      # calls and validates each expanded key against the locale index. Interpolation validation is
+      # skipped — the hash may come from controller instance variables not visible in the template source.
       #
-      # Watches `**/*.{erb,haml,slim}` under each search root so
-      # the cache invalidates when templates are edited.
+      # Watches `**/*.{erb,haml,slim}` under each search root so the cache invalidates when templates are
+      # edited.
       producer :view_diagnostics, watch: -> { [[@view_search_paths, "**/*.erb", "**/*.haml", "**/*.slim"]] } do |_params|
         index = producer_value(:locale_index)
         next [] if index.nil? || index.empty?
@@ -129,11 +103,10 @@ module Rigor
         @view_diagnostics_emitted = false
       end
 
-      # File-level only: the once-per-run YAML load errors + the
-      # runtime (cache-load) error + the view-template scan. Per-call
-      # `t('key')` validation runs over the engine-owned walk via the
-      # node_rule below (ADR-37). The locale index and view diagnostics
-      # are lazily loaded + memoised by `producer_value`.
+      # File-level only: the once-per-run YAML load errors + the runtime (cache-load) error + the
+      # view-template scan. Per-call `t('key')` validation runs over the engine-owned walk via the
+      # node_rule below (ADR-37). The locale index and view diagnostics are lazily loaded + memoised by
+      # `producer_value`.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:locale_index)
         diagnostics = []
@@ -151,9 +124,8 @@ module Rigor
         diagnostics
       end
 
-      # The lazy-key (`t('.key')`) expansion needs the enclosing method
-      # (the controller action), supplied by the node-rule NodeContext;
-      # the controller scope comes from the file path.
+      # The lazy-key (`t('.key')`) expansion needs the enclosing method (the controller action), supplied
+      # by the node-rule NodeContext; the controller scope comes from the file path.
       node_rule Prism::CallNode do |node, _scope, path, _fc, context|
         index = producer_value(:locale_index)
         next [] if index.nil? || index.empty?
@@ -205,12 +177,10 @@ module Rigor
         end.sort
       end
 
-      # Diagnostics anchor on a path relative to the working
-      # directory — the same base `File.expand_path` globbed the
-      # view files against — so view diagnostics render and match
-      # baselines like every other diagnostic (which carry
-      # project-relative paths). Falls back to the absolute path
-      # for a view outside the working tree.
+      # Diagnostics anchor on a path relative to the working directory — the same base `File.expand_path`
+      # globbed the view files against — so view diagnostics render and match baselines like every other
+      # diagnostic (which carry project-relative paths). Falls back to the absolute path for a view outside
+      # the working tree.
       def relative_view_path(absolute_path)
         Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
       rescue ArgumentError
@@ -232,12 +202,9 @@ module Rigor
         )
       end
 
-      # The runner only invokes `diagnostics_for_file` for
-      # Ruby files (`paths:` is filtered to `.rb`). YAML
-      # parse errors therefore can't be anchored on the
-      # offending locale file directly; instead, we emit
-      # them once per run on the first analyzed Ruby file,
-      # naming the offending YAML path in the message.
+      # The runner only invokes `diagnostics_for_file` for Ruby files (`paths:` is filtered to `.rb`). YAML
+      # parse errors therefore can't be anchored on the offending locale file directly; instead, we emit
+      # them once per run on the first analyzed Ruby file, naming the offending YAML path in the message.
       def consume_load_error_diagnostics(path)
         return [] if @load_errors_emitted
 

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes/analyzer.rb

@@ -6,18 +6,13 @@ require "rigor/source/literals"
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for `*_path` /
-      # `*_url` calls and validates each against the
-      # plugin's {HelperTable}. Emits info diagnostics for
-      # recognised helpers and error diagnostics for typos /
-      # arity mismatches.
+      # Walks a parsed file's AST looking for `*_path` / `*_url` calls and validates each against the
+      # plugin's {HelperTable}. Emits info diagnostics for recognised helpers and error diagnostics for
+      # typos / arity mismatches.
       module Analyzer
-        # Built-in Rails helpers we don't want to flag as
-        # unknown. The plugin's HelperTable describes
-        # user-declared routes; Rails (and a small set of
-        # widely-used asset gems) ship built-in helpers
-        # (`url_for`, `polymorphic_path`, vite_ruby's
-        # `vite_asset_path`, …) the plugin deliberately ignores.
+        # Built-in Rails helpers we don't want to flag as unknown. The plugin's HelperTable describes
+        # user-declared routes; Rails (and a small set of widely-used asset gems) ship built-in helpers
+        # (`url_for`, `polymorphic_path`, vite_ruby's `vite_asset_path`, …) the plugin deliberately ignores.
         BUILTIN_PASSTHROUGH = %w[
           url_for_path url_for_url
           polymorphic_path polymorphic_url
@@ -32,35 +27,27 @@ module Rigor
           audio_path audio_url
         ].freeze
 
-        # One route-helper observation. Carries no path/location — the
-        # caller (the `node_rule` block) positions it via
-        # `Plugin::Base#diagnostic`.
+        # One route-helper observation. Carries no path/location — the caller (the `node_rule` block)
+        # positions it via `Plugin::Base#diagnostic`.
         Violation = Struct.new(:rule, :severity, :message, keyword_init: true)
 
         module_function
 
-        # RSpec / Minitest DSL methods that DECLARE a memoized
-        # local — `let(:foo) { ... }`, `subject(:foo) { ... }`,
-        # plus the bang and let_it_be variants. The first
-        # positional Symbol argument is the local name. A bare
-        # `subject { ... }` (no arg) defines `:subject` itself.
+        # RSpec / Minitest DSL methods that DECLARE a memoized local — `let(:foo) { ... }`, `subject(:foo)
+        # { ... }`, plus the bang and let_it_be variants. The first positional Symbol argument is the local
+        # name. A bare `subject { ... }` (no arg) defines `:subject` itself.
         SHADOWING_DSL = %i[
           let let! let_it_be let_it_be!
           subject subject!
         ].freeze
 
-        # Paths under which `unknown-helper` is suppressed. Route
-        # helpers are not customarily resolved through these
-        # directories, so a bare `shared_inbox_url` call inside
-        # `app/models/account.rb` (the call-site is the
-        # `accounts.shared_inbox_url` AR column accessor — same
-        # name as a hypothetical route helper) or a `default_url`
-        # inside `lib/paperclip/url_generator_extensions.rb` (the
-        # call-site is `Paperclip::UrlGenerator#default_url`, a
-        # gem-side instance method) would be a false positive.
-        # The core engine's `call.undefined-method` still catches
-        # a genuinely unreachable receiver. Cheap path-prefix
-        # check; no AR-column / gem-include analysis required.
+        # Paths under which `unknown-helper` is suppressed. Route helpers are not customarily resolved
+        # through these directories, so a bare `shared_inbox_url` call inside `app/models/account.rb` (the
+        # call-site is the `accounts.shared_inbox_url` AR column accessor — same name as a hypothetical
+        # route helper) or a `default_url` inside `lib/paperclip/url_generator_extensions.rb` (the
+        # call-site is `Paperclip::UrlGenerator#default_url`, a gem-side instance method) would be a false
+        # positive. The core engine's `call.undefined-method` still catches a genuinely unreachable
+        # receiver. Cheap path-prefix check; no AR-column / gem-include analysis required.
         SKIP_UNKNOWN_HELPER_PATHS = [
           %r{(?:\A|/)app/models/},
           %r{(?:\A|/)app/services/},
@@ -78,12 +65,10 @@ module Rigor
         # @param root [Prism::Node]
         # @param helper_table [HelperTable]
         # @return [Array<Diagnostic>]
-        # The route-helper violations for a single call node (0..2),
-        # or `[]` when the node is not an implicit `*_path` / `*_url`
-        # helper call, is shadowed by a same-file binding, or is in a
-        # suppressed directory. ADR-37: the engine owns the walk; the
-        # same-file `shadowing` set is built once as the node-rule file
-        # context.
+        # The route-helper violations for a single call node (0..2), or `[]` when the node is not an
+        # implicit `*_path` / `*_url` helper call, is shadowed by a same-file binding, or is in a
+        # suppressed directory. ADR-37: the engine owns the walk; the same-file `shadowing` set is built
+        # once as the node-rule file context.
         #
         # @param call_node [Prism::Node]
         # @param helper_table [HelperTable]
@@ -97,9 +82,8 @@ module Rigor
           return [] if BUILTIN_PASSTHROUGH.include?(name)
           return [] if shadowing.include?(name)
 
-          # The SKIP set silences both `unknown-helper` and `wrong-arity`:
-          # a `group_path` inside `app/services/...` is more likely the
-          # file's own method (an `attr_accessor`) than a route helper.
+          # The SKIP set silences both `unknown-helper` and `wrong-arity`: a `group_path` inside
+          # `app/services/...` is more likely the file's own method (an `attr_accessor`) than a route helper.
           suppress_unknown = SKIP_UNKNOWN_HELPER_PATHS.any? { |re| path.match?(re) }
 
           entry = helper_table.find(name)
@@ -111,26 +95,21 @@ module Rigor
             violations << arity if arity
             violations
           elsif helper_table.recognised?(name) || suppress_unknown
-            # Recognised custom / dynamic helper (no arity to check), or
-            # a directory where helpers aren't customarily resolved.
+            # Recognised custom / dynamic helper (no arity to check), or a directory where helpers aren't
+            # customarily resolved.
             []
           else
             [unknown_helper_violation(name, helper_table)]
           end
         end
 
-        # Walks the AST once and returns the Set of names that
-        # shadow a route helper for this file. Includes:
+        # Walks the AST once and returns the Set of names that shadow a route helper for this file. Includes:
         #
-        # - `def name` declarations (any level — the
-        #   per-method-scope visibility model Ruby uses means a
-        #   local `def` shadows the helper at every call site
-        #   reachable from where it is defined; we approximate
-        #   "reachable" with "anywhere in the same file").
-        # - RSpec `let` / `let!` / `let_it_be` / `let_it_be!` /
-        #   `subject` / `subject!` declarations.
-        # - Local assignments at any scope
-        #   (`foo_url = "..."`).
+        # - `def name` declarations (any level — the per-method-scope visibility model Ruby uses means a
+        #   local `def` shadows the helper at every call site reachable from where it is defined; we
+        #   approximate "reachable" with "anywhere in the same file").
+        # - RSpec `let` / `let!` / `let_it_be` / `let_it_be!` / `subject` / `subject!` declarations.
+        # - Local assignments at any scope (`foo_url = "..."`).
         def collect_shadowing_names(root)
           names = Set.new
           Source::NodeWalker.each(root) do |node|
@@ -160,22 +139,17 @@ module Rigor
           end
         end
 
-        # `*_path` / `*_url` calls without an explicit
-        # receiver. Calls like `obj.users_path` or
-        # `Foo::users_path` are NOT route-helper invocations
-        # in Rails — controllers / views call helpers
+        # `*_path` / `*_url` calls without an explicit receiver. Calls like `obj.users_path` or
+        # `Foo::users_path` are NOT route-helper invocations in Rails — controllers / views call helpers
         # implicitly.
         def implicit_helper_call?(node)
           node.receiver.nil? && (node.name.to_s.end_with?("_path") || node.name.to_s.end_with?("_url"))
         end
 
-        # Paths where the implicit-params-fill pattern is
-        # idiomatic — controllers / mailers / views routinely
-        # call `*_path` / `*_url` helpers with fewer args than
-        # the route's static placeholder count because Rails
-        # fills `:foo_id` segments from `request.params` at
-        # runtime (controllers / views) or from the call's
-        # polymorphic-friendly receiver (mailers).
+        # Paths where the implicit-params-fill pattern is idiomatic — controllers / mailers / views
+        # routinely call `*_path` / `*_url` helpers with fewer args than the route's static placeholder
+        # count because Rails fills `:foo_id` segments from `request.params` at runtime (controllers /
+        # views) or from the call's polymorphic-friendly receiver (mailers).
         IMPLICIT_FILL_PATHS = [
           %r{(?:\A|/)app/controllers/},
           %r{(?:\A|/)app/mailers/},
@@ -200,40 +174,29 @@ module Rigor
         def arity_violation(call_node, entry, helper_table, path)
           args = call_node.arguments&.arguments || []
           actual = args.size
-          # Uncountable nouns (`news` / `series` / `media`) cause
-          # Rails to register two entries under the same helper
-          # name — `news_path` accepts both arity 0 (index) and
-          # arity 1 (show). The HelperTable multimap stores both;
-          # accepts_arity? checks the full set.
+          # Uncountable nouns (`news` / `series` / `media`) cause Rails to register two entries under the
+          # same helper name — `news_path` accepts both arity 0 (index) and arity 1 (show). The HelperTable
+          # multimap stores both; accepts_arity? checks the full set.
           return nil if helper_table.accepts_arity?(entry.name, actual)
 
-          # Rails accepts a kwargs-only call shape that supplies
-          # route segments by name:
+          # Rails accepts a kwargs-only call shape that supplies route segments by name:
           #   short_account_status_url(account_username: u, id: i)
-          # for the route `/@:account_username/:id` (arity 2).
-          # Our positional-arg count is 1 (the KeywordHashNode),
-          # so the strict check rejects — but Rails would
-          # resolve every segment from the hash. When the call
-          # has a trailing KeywordHashNode AND the positional
-          # count (excluding it) is `<= expected_arity`, accept
-          # — the kwargs may carry the missing segments.
+          # for the route `/@:account_username/:id` (arity 2). Our positional-arg count is 1 (the
+          # KeywordHashNode), so the strict check rejects — but Rails would resolve every segment from the
+          # hash. When the call has a trailing KeywordHashNode AND the positional count (excluding it) is
+          # `<= expected_arity`, accept — the kwargs may carry the missing segments.
           if args.last.is_a?(Prism::KeywordHashNode)
             positional = actual - 1
             return nil if helper_table.acceptable_arities(entry.name).any? { |exp| positional <= exp }
           end
 
-          # Underflow tolerance for controllers / mailers /
-          # views. A `redirect_to namespace_project_milestones_path`
-          # inside `Projects::MilestonesController` legitimately
-          # passes 0 args — Rails fills the missing `:namespace_id`
-          # / `:project_id` segments from `request.params` at
-          # runtime. Mailers reach helpers polymorphically too
-          # (`project_commit_url(commit)` resolves project from
-          # commit.project). Silence when `actual < min_arity`
-          # AND the call site is in a controller / mailer / view
-          # directory (where the implicit-params-fill pattern is
-          # idiomatic). Overflow (`actual > max_arity`) still
-          # fires — that's almost always a typo.
+          # Underflow tolerance for controllers / mailers / views. A `redirect_to
+          # namespace_project_milestones_path` inside `Projects::MilestonesController` legitimately passes
+          # 0 args — Rails fills the missing `:namespace_id` / `:project_id` segments from `request.params`
+          # at runtime. Mailers reach helpers polymorphically too (`project_commit_url(commit)` resolves
+          # project from commit.project). Silence when `actual < min_arity` AND the call site is in a
+          # controller / mailer / view directory (where the implicit-params-fill pattern is idiomatic).
+          # Overflow (`actual > max_arity`) still fires — that's almost always a typo.
           arities_set = helper_table.acceptable_arities(entry.name)
           min_arity = arities_set.min
           return nil if actual < min_arity && implicit_fill_path?(path)
@@ -248,8 +211,8 @@ module Rigor
         end
 
         def unknown_helper_violation(name, helper_table)
-          # ADR-39 / boilerplate 0c — the shared DidYouMean-backed suggester
-          # replaces the hand-rolled Levenshtein this module used to carry.
+          # ADR-39 / boilerplate 0c — the shared DidYouMean-backed suggester replaces the hand-rolled
+          # Levenshtein this module used to carry.
           suggestion = Rigor::Plugin::Base.suggest(name, helper_table.names)
           message = "no route helper `#{name}`"
           message += " (did you mean `#{suggestion}`?)" if suggestion