rigortype 0.2.7 → 0.2.8

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

@@ -3,53 +3,35 @@
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Generates the catalogue of route helpers a `devise_for
-      # :resources` call adds to a Rails app's routing table.
-      # The set is fixed and well-documented (the
-      # [Devise wiki](https://github.com/heartcombo/devise/wiki/How-To:-Add-routes-helpers)
-      # enumerates every generated helper); the generator
-      # mirrors it.
+      # Generates the catalogue of route helpers a `devise_for :resources` call adds to a Rails app's
+      # routing table. The set is fixed and well-documented (the
+      # [Devise wiki](https://github.com/heartcombo/devise/wiki/How-To:-Add-routes-helpers) enumerates
+      # every generated helper); the generator mirrors it.
       #
-      # Used by `RoutesParser` when it sees a top-level
-      # `devise_for :name` (or `devise_for :name, skip:
-      # [...]`) call. Each generated helper is materialised as
-      # a `HelperTable::Entry` so the analyzer's
-      # `unknown-helper` rule recognises them and the arity
-      # check accepts the canonical signatures (Devise helpers
-      # take zero positional args plus an optional trailing
-      # options hash, which `HelperTable#accepts_arity?`
-      # already handles via the `arity + 1` rule).
+      # Used by `RoutesParser` when it sees a top-level `devise_for :name` (or `devise_for :name, skip:
+      # [...]`) call. Each generated helper is materialised as a `HelperTable::Entry` so the analyzer's
+      # `unknown-helper` rule recognises them and the arity check accepts the canonical signatures (Devise
+      # helpers take zero positional args plus an optional trailing options hash, which
+      # `HelperTable#accepts_arity?` already handles via the `arity + 1` rule).
       #
       # Scope:
       #
-      # - Recognises the standard six controllers
-      #   (`:sessions`, `:passwords`, `:confirmations`,
-      #   `:unlocks`, `:registrations`, `:omniauth_callbacks`).
-      # - Honours `skip: [...]` to suppress controllers the
-      #   project disables.
-      # - Honours `path: "..."` to remap the URL path (does
-      #   NOT remap the helper-name prefix — Devise uses the
-      #   resource name for the helper, not the path).
-      # - Does NOT yet honour `as: "..."` overrides, `class_name:`,
-      #   `controllers: { ... }` (these are rare; expand on
-      #   demand).
-      # - `omniauth_callbacks` helpers are dynamic — the
-      #   provider name is supplied at call time
-      #   (`user_facebook_omniauth_authorize_path`) and Devise
-      #   declares them from the configured providers, which
-      #   live in an initializer this static parser does not
-      #   read. The suffix patterns are registered in
-      #   `OMNIAUTH_SUFFIXES` and consulted by
-      #   `HelperTable#omniauth_match?`.
+      # - Recognises the standard six controllers (`:sessions`, `:passwords`, `:confirmations`, `:unlocks`,
+      #   `:registrations`, `:omniauth_callbacks`).
+      # - Honours `skip: [...]` to suppress controllers the project disables.
+      # - Honours `path: "..."` to remap the URL path (does NOT remap the helper-name prefix — Devise uses
+      #   the resource name for the helper, not the path).
+      # - Does NOT yet honour `as: "..."` overrides, `class_name:`, `controllers: { ... }` (these are rare;
+      #   expand on demand).
+      # - `omniauth_callbacks` helpers are dynamic — the provider name is supplied at call time
+      #   (`user_facebook_omniauth_authorize_path`) and Devise declares them from the configured providers,
+      #   which live in an initializer this static parser does not read. The suffix patterns are registered
+      #   in `OMNIAUTH_SUFFIXES` and consulted by `HelperTable#omniauth_match?`.
       module DeviseRoutes
-        # The standard Devise controllers and the helper
-        # actions each generates. Keys are the controller
-        # name; values are arrays of `[helper_prefix,
-        # http_method, action]` triples — `helper_prefix` is
-        # the part BEFORE the resource-name segment (Rails
-        # produces `<prefix>_<resource>_<suffix>_path`; for
-        # the bare `<resource>_session_path` shape the prefix
-        # is empty).
+        # The standard Devise controllers and the helper actions each generates. Keys are the controller
+        # name; values are arrays of `[helper_prefix, http_method, action]` triples — `helper_prefix` is
+        # the part BEFORE the resource-name segment (Rails produces `<prefix>_<resource>_<suffix>_path`;
+        # for the bare `<resource>_session_path` shape the prefix is empty).
         CONTROLLER_HELPERS = {
           sessions: [
             ["new", "session", :get, :new],
@@ -77,13 +59,10 @@ module Rigor
           ]
         }.freeze
 
-        # Dynamic-provider helper patterns. `_omniauth_authorize_path`
-        # and `_omniauth_callback_path` are generated per
-        # configured provider (Facebook, GitHub, …) by an
-        # initializer this parser does not read. We treat any
-        # `<resource>_<provider>_omniauth_(authorize|callback)_(path|url)`
-        # call as recognised when the resource is one the
-        # project declared via `devise_for`.
+        # Dynamic-provider helper patterns. `_omniauth_authorize_path` and `_omniauth_callback_path` are
+        # generated per configured provider (Facebook, GitHub, …) by an initializer this parser does not
+        # read. We treat any `<resource>_<provider>_omniauth_(authorize|callback)_(path|url)` call as
+        # recognised when the resource is one the project declared via `devise_for`.
         OMNIAUTH_SUFFIXES = %w[
           _omniauth_authorize_path _omniauth_authorize_url
           _omniauth_callback_path _omniauth_callback_url
@@ -91,16 +70,12 @@ module Rigor
 
         module_function
 
-        # @param resource [String, Symbol] the `devise_for`
-        #   argument — typically `:users`. Used as both the
-        #   helper-name segment (`new_user_session_path`) and
-        #   to derive the resource path.
-        # @param skip [Array<Symbol>] controllers the project
-        #   disables via `devise_for :users, skip: [:registrations]`.
-        # @return [Array<HelperTable::Entry>] one entry per
-        #   generated `_path` helper. The caller is expected to
-        #   pair `_url` variants the same way `RoutesParser` does
-        #   for other entries.
+        # @param resource [String, Symbol] the `devise_for` argument — typically `:users`. Used as both the
+        #   helper-name segment (`new_user_session_path`) and to derive the resource path.
+        # @param skip [Array<Symbol>] controllers the project disables via `devise_for :users, skip:
+        #   [:registrations]`.
+        # @return [Array<HelperTable::Entry>] one entry per generated `_path` helper. The caller is
+        #   expected to pair `_url` variants the same way `RoutesParser` does for other entries.
         def generate(resource:, skip: [])
           resource_segment = singularize(resource.to_s)
           skip_set = skip.to_set(&:to_sym)
@@ -126,21 +101,15 @@ module Rigor
             end
           end
 
-          # Devise also ships *scoped* helpers
-          # (`Devise::Controllers::UrlHelpers`) that DROP the
-          # resource segment and take the scope as a positional
-          # argument: `new_password_path(resource_name)` is the
+          # Devise also ships *scoped* helpers (`Devise::Controllers::UrlHelpers`) that DROP the resource
+          # segment and take the scope as a positional argument: `new_password_path(resource_name)` is the
           # bare form of `new_user_password_path`. Used inside
-          # `Auth::PasswordsController < Devise::PasswordsController`
-          # (Mastodon's idiom). Arity 1 (the scope), and a
-          # trailing options-hash bumps it via the existing
-          # `arity + 1` rule.
+          # `Auth::PasswordsController < Devise::PasswordsController` (Mastodon's idiom). Arity 1 (the
+          # scope), and a trailing options-hash bumps it via the existing `arity + 1` rule.
           entries.concat(scoped_helpers(skip_set))
 
-          # `omniauth_authorize_path(scope, provider)` and
-          # `omniauth_callback_path(scope, provider)` are
-          # `Devise::Controllers::UrlHelpers` scoped helpers
-          # that delegate to the OmniAuth gem. Arity 2.
+          # `omniauth_authorize_path(scope, provider)` and `omniauth_callback_path(scope, provider)` are
+          # `Devise::Controllers::UrlHelpers` scoped helpers that delegate to the OmniAuth gem. Arity 2.
           unless skip_set.include?(:omniauth_callbacks)
             %w[omniauth_authorize_path omniauth_callback_path].each do |name|
               entries << HelperTable::Entry.new(
@@ -156,11 +125,9 @@ module Rigor
           entries
         end
 
-        # Scoped helpers Devise exposes inside its controllers.
-        # The arity-1 family — caller supplies the resource
-        # scope (`:user` etc.) as the first positional arg.
-        # Names mirror the qualified `<scope>_<name>_path`
-        # entries above, minus the scope segment.
+        # Scoped helpers Devise exposes inside its controllers. The arity-1 family — caller supplies the
+        # resource scope (`:user` etc.) as the first positional arg. Names mirror the qualified
+        # `<scope>_<name>_path` entries above, minus the scope segment.
         SCOPED_HELPERS = {
           sessions: %w[new_session_path session_path destroy_session_path],
           passwords: %w[new_password_path edit_password_path password_path],
@@ -186,28 +153,22 @@ module Rigor
           end
         end
 
-        # Returns the set of OmniAuth pattern suffixes the
-        # analyzer accepts for a given resource. The analyzer
-        # consults this set (via `HelperTable#omniauth_match?`)
-        # when a `*_path` / `*_url` call's name does not match
-        # any registered entry and its prefix matches a Devise
-        # resource.
+        # Returns the set of OmniAuth pattern suffixes the analyzer accepts for a given resource. The
+        # analyzer consults this set (via `HelperTable#omniauth_match?`) when a `*_path` / `*_url` call's
+        # name does not match any registered entry and its prefix matches a Devise resource.
         def omniauth_suffixes
           OMNIAUTH_SUFFIXES
         end
 
-        # ADR-39 — delegates to the shared inflector (real
-        # `ActiveSupport::Inflector` when available), replacing the tiny
-        # AS-replica this module used to duplicate from `RoutesParser`.
+        # ADR-39 — delegates to the shared inflector (real `ActiveSupport::Inflector` when available),
+        # replacing the tiny AS-replica this module used to duplicate from `RoutesParser`.
         def singularize(word)
           Rigor::Plugin::Inflector.singularize(word)
         end
 
-        # Approximate path generation. We don't honour the
-        # `path:` Devise option here because the helper NAME
-        # is what the analyzer cares about; the `path` field is
-        # informational and surfaces only in the `:helper` info
-        # diagnostic.
+        # Approximate path generation. We don't honour the `path:` Devise option here because the helper
+        # NAME is what the analyzer cares about; the `path` field is informational and surfaces only in
+        # the `:helper` info diagnostic.
         def devise_path_for(resource_segment, controller, action)
           plural = "#{resource_segment}s"
           base = "/#{plural}"

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

@@ -3,39 +3,27 @@
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Generates the catalogue of OAuth route helpers a
-      # `use_doorkeeper do ... end` block adds to a Rails app's
-      # routing table. The set is the Doorkeeper gem's
-      # documented default — see Doorkeeper's
-      # [Routing](https://github.com/doorkeeper-gem/doorkeeper/wiki/Customizing-routes)
-      # documentation; this module mirrors the canonical
-      # helper names.
+      # Generates the catalogue of OAuth route helpers a `use_doorkeeper do ... end` block adds to a Rails
+      # app's routing table. The set is the Doorkeeper gem's documented default — see Doorkeeper's
+      # [Routing](https://github.com/doorkeeper-gem/doorkeeper/wiki/Customizing-routes) documentation; this
+      # module mirrors the canonical helper names.
       #
-      # Used by `RoutesParser` when it sees a `use_doorkeeper`
-      # call. Each generated helper is materialised as a
-      # `HelperTable::Entry` so the analyzer's
-      # `unknown-helper` rule recognises them. Arity for the
-      # `oauth_application_path(:id)` / `oauth_authorized_application_path(:id)`
-      # forms is 1 (the `:id`); all other Doorkeeper helpers
-      # are arity 0.
+      # Used by `RoutesParser` when it sees a `use_doorkeeper` call. Each generated helper is materialised
+      # as a `HelperTable::Entry` so the analyzer's `unknown-helper` rule recognises them. Arity for the
+      # `oauth_application_path(:id)` / `oauth_authorized_application_path(:id)` forms is 1 (the `:id`);
+      # all other Doorkeeper helpers are arity 0.
       #
       # Scope:
       #
-      # - Recognises the standard helper set: authorization,
-      #   token, revoke, introspect, token_info, userinfo,
-      #   applications (resources), authorized_applications.
-      # - Honours `skip_controllers <names>` inside the block
-      #   to omit the named controller's helpers.
-      # - Does NOT yet honour `controllers ...:` remappings —
-      #   those change WHICH class serves the route but not
-      #   the helper NAMES, so omitting them is sound.
-      # - Does NOT yet honour custom `as:` / `at:` on
-      #   `use_doorkeeper` itself.
+      # - Recognises the standard helper set: authorization, token, revoke, introspect, token_info,
+      #   userinfo, applications (resources), authorized_applications.
+      # - Honours `skip_controllers <names>` inside the block to omit the named controller's helpers.
+      # - Does NOT yet honour `controllers ...:` remappings — those change WHICH class serves the route but
+      #   not the helper NAMES, so omitting them is sound.
+      # - Does NOT yet honour custom `as:` / `at:` on `use_doorkeeper` itself.
       module DoorkeeperRoutes
-        # Per-controller helper catalogue. Keys are the
-        # `skip_controllers :<key>` names; values are the
-        # entries (name + arity + path + http_method).
-        # Both `_path` and `_url` variants are paired by
+        # Per-controller helper catalogue. Keys are the `skip_controllers :<key>` names; values are the
+        # entries (name + arity + path + http_method). Both `_path` and `_url` variants are paired by
         # `RoutesParser` after registration.
         CONTROLLER_HELPERS = {
           authorizations: [
@@ -78,8 +66,7 @@ module Rigor
 
         module_function
 
-        # @param skip [Array<Symbol>] controller names the
-        #   project omits via `skip_controllers :name, ...`.
+        # @param skip [Array<Symbol>] controller names the project omits via `skip_controllers :name, ...`.
         # @return [Array<HelperTable::Entry>] flattened entries.
         def generate(skip: [])
           skip_set = skip.to_set(&:to_sym)

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

@@ -5,76 +5,54 @@ require "prism"
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Walks `app/helpers/**/*.rb` (or any configured set of
-      # helper directories) and extracts every public
-      # module-level method name so the analyzer's
-      # `unknown-helper` rule does not false-fire on calls to
-      # project-defined `*_path` / `*_url` helpers (the
-      # canonical Rails pattern: a `UrlHelper` module exposing
-      # `full_asset_url`, `host_to_url`, `frontend_asset_url`,
-      # and so on).
+      # Walks `app/helpers/**/*.rb` (or any configured set of helper directories) and extracts every public
+      # module-level method name so the analyzer's `unknown-helper` rule does not false-fire on calls to
+      # project-defined `*_path` / `*_url` helpers (the canonical Rails pattern: a `UrlHelper` module
+      # exposing `full_asset_url`, `host_to_url`, `frontend_asset_url`, and so on).
       #
       # The discoverer is deliberately conservative:
       #
-      # - Walks `def name(...)` declarations at the module /
-      #   class top level. Nested `def` inside a method body or
-      #   a `define_method` macro is NOT extracted (the same
-      #   reason `rigor-actionpack` is not the canonical
-      #   custom-helper source — metaprogrammed helpers are out
-      #   of scope for a static scan).
-      # - **Visibility-agnostic.** A `private` / `protected`
-      #   `def some_url` IS registered. The `unknown-helper`
-      #   rule is a project-wide name-presence check, not a
-      #   visibility check — if the user wrote a `_path` /
-      #   `_url` method anywhere in `app/`, they very likely
-      #   intend to call it (often Mastodon's pattern: a
-      #   controller's `private def page_url(page)` invoked
-      #   by a `link_to` in its own view). The core engine's
-      #   `call.undefined-method` rule still catches the case
-      #   where the receiver genuinely cannot see the method.
-      # - Ignores `def self.x` (singleton-method definitions) —
-      #   Rails helpers are instance methods on the helper
-      #   module; class-side `self.x` shapes are usually
-      #   internal utilities, not view helpers.
-      # - Filters the resulting set to names ending in `_path`
-      #   or `_url` (the dispatch surface the analyzer's rule
-      #   actually cares about). A helper whose name does not
-      #   end with either suffix is irrelevant to the rule's
-      #   false-positive surface, so excluding it costs nothing
-      #   and keeps the registered set focused.
+      # - Walks `def name(...)` declarations at the module / class top level. Nested `def` inside a method
+      #   body or a `define_method` macro is NOT extracted (the same reason `rigor-actionpack` is not the
+      #   canonical custom-helper source — metaprogrammed helpers are out of scope for a static scan).
+      # - **Visibility-agnostic.** A `private` / `protected` `def some_url` IS registered. The
+      #   `unknown-helper` rule is a project-wide name-presence check, not a visibility check — if the user
+      #   wrote a `_path` / `_url` method anywhere in `app/`, they very likely intend to call it (often
+      #   Mastodon's pattern: a controller's `private def page_url(page)` invoked by a `link_to` in its own
+      #   view). The core engine's `call.undefined-method` rule still catches the case where the receiver
+      #   genuinely cannot see the method.
+      # - Ignores `def self.x` (singleton-method definitions) — Rails helpers are instance methods on the
+      #   helper module; class-side `self.x` shapes are usually internal utilities, not view helpers.
+      # - Filters the resulting set to names ending in `_path` or `_url` (the dispatch surface the
+      #   analyzer's rule actually cares about). A helper whose name does not end with either suffix is
+      #   irrelevant to the rule's false-positive surface, so excluding it costs nothing and keeps the
+      #   registered set focused.
       #
       # Out of scope (intentional):
       #
-      # - Helpers defined via `define_method` or via macros like
-      #   `inheritance_traversed_helpers`. These would need
-      #   ADR-16 macro substrate or per-plugin custom recognizers.
-      # - Helpers inherited from gems (`Devise::Controllers::Helpers`,
-      #   `ViteRails::TagHelpers`, etc.). Those need their own
-      #   handling — Devise auto-routes are covered by the
-      #   companion `DeviseRoutes` generator; other gem-injected
-      #   helpers fall to ADR-25 plugin-contributed RBS or the
-      #   ADR-10 `dependencies.source_inference:` path.
+      # - Helpers defined via `define_method` or via macros like `inheritance_traversed_helpers`. These
+      #   would need ADR-16 macro substrate or per-plugin custom recognizers.
+      # - Helpers inherited from gems (`Devise::Controllers::Helpers`, `ViteRails::TagHelpers`, etc.).
+      #   Those need their own handling — Devise auto-routes are covered by the companion `DeviseRoutes`
+      #   generator; other gem-injected helpers fall to ADR-25 plugin-contributed RBS or the ADR-10
+      #   `dependencies.source_inference:` path.
       module HelperDiscoverer
         HELPER_SUFFIXES = [/_path\z/, /_url\z/].freeze
 
         module_function
 
-        # @param contents_per_path [Hash{String => String}]
-        #   file path → source text. The caller is responsible
-        #   for reading files (typically through the trusted
-        #   `IoBoundary` so cache invalidation works).
-        # @return [Set<String>] method names suitable for
-        #   inclusion in the `HelperTable`'s custom-helper set.
+        # @param contents_per_path [Hash{String => String}] file path → source text. The caller is
+        #   responsible for reading files (typically through the trusted `IoBoundary` so cache invalidation
+        #   works).
+        # @return [Set<String>] method names suitable for inclusion in the `HelperTable`'s custom-helper set.
         def discover(contents_per_path)
           names = []
           contents_per_path.each_value do |contents|
             names.concat(extract_from_contents(contents))
           rescue StandardError
-            # Skip any file whose AST walk explodes — discovery
-            # is best-effort and a parse failure in one helper
-            # file MUST NOT abort discovery for the rest. Other
-            # rules will still surface the parse failure on the
-            # affected file through the core pipeline.
+            # Skip any file whose AST walk explodes — discovery is best-effort and a parse failure in one
+            # helper file MUST NOT abort discovery for the rest. Other rules will still surface the parse
+            # failure on the affected file through the core pipeline.
             next
           end
           names.to_set
@@ -89,17 +67,9 @@ module Rigor
           walker.helper_names
         end
 
-        # Per-file AST walker. Tracks the current visibility
-        # mode (`:public` by default; `private` / `protected`
-        # calls flip the bit) so a `def` declared after a bare
-        # `private` is excluded.
-        #
-        # The walker is recursive into module / class bodies so
-        # `module UrlHelpers; module Routing; def foo_url; end;
-        # end; end` registers `foo_url`. It does NOT recurse
-        # into method bodies (a `def inside def` would be
-        # `define_method`-shaped, which we skip per the
-        # docstring).
+        # Per-file AST walker. The walker is recursive into module / class bodies so `module UrlHelpers;
+        # module Routing; def foo_url; end; end; end` registers `foo_url`. It does NOT recurse into method
+        # bodies (a `def inside def` would be `define_method`-shaped, which we skip per the docstring).
         class ModuleBodyWalker
           attr_reader :helper_names
 
@@ -134,11 +104,9 @@ module Rigor
           def visit_statements(body)
             return if body.nil?
 
-            # Visibility tracking is intentionally absent — see
-            # the "visibility-agnostic" point in the module
-            # docstring. A `private def page_url(page)` inside
-            # a controller IS registered so a caller in the
-            # paired view does not false-fire `unknown-helper`.
+            # Visibility tracking is intentionally absent — see the "visibility-agnostic" point in the
+            # module docstring. A `private def page_url(page)` inside a controller IS registered so a
+            # caller in the paired view does not false-fire `unknown-helper`.
             statements_of(body).each do |stmt|
               case stmt
               when Prism::DefNode

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

@@ -6,71 +6,50 @@ require_relative "doorkeeper_routes"
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Frozen catalogue of route helpers parsed from
-      # `config/routes.rb`. Each entry maps a helper name
-      # (`users_path`, `edit_user_path`, …) to the metadata
-      # downstream consumers and the analyzer's per-call
+      # Frozen catalogue of route helpers parsed from `config/routes.rb`. Each entry maps a helper name
+      # (`users_path`, `edit_user_path`, …) to the metadata downstream consumers and the analyzer's per-call
       # validation need:
       #
-      # - `arity`: number of positional arguments the helper
-      #   takes. `users_path` → 0; `user_path(:id)` → 1;
+      # - `arity`: number of positional arguments the helper takes. `users_path` → 0; `user_path(:id)` → 1;
       #   `user_post_path(:user_id, :id)` → 2.
-      # - `path`: the path template Rails generates
-      #   (`/users/:user_id/posts/:id`).
-      # - `http_method`: `:get` / `:post` / `:patch` / `:put` /
-      #   `:delete` for the canonical action; `nil` for
-      #   helpers that span multiple methods (a `resources`
-      #   show helper isn't HTTP-method-specific in the
-      #   helper sense — it's path-sensitive only).
-      # - `action`: `:index` / `:show` / `:new` / `:edit` /
-      #   `:create` / `:update` / `:destroy` for resourceful
-      #   routes; `:custom` for explicit `get`/`post`/etc.;
-      #   `:root` for the root route.
+      # - `path`: the path template Rails generates (`/users/:user_id/posts/:id`).
+      # - `http_method`: `:get` / `:post` / `:patch` / `:put` / `:delete` for the canonical action; `nil`
+      #   for helpers that span multiple methods (a `resources` show helper isn't HTTP-method-specific in
+      #   the helper sense — it's path-sensitive only).
+      # - `action`: `:index` / `:show` / `:new` / `:edit` / `:create` / `:update` / `:destroy` for
+      #   resourceful routes; `:custom` for explicit `get`/`post`/etc.; `:root` for the root route.
       #
-      # Both `_path` and `_url` forms share the same metadata —
-      # the table records each helper twice (once with `_path`,
-      # once with `_url`) for `O(1)` lookup at the call site.
+      # Both `_path` and `_url` forms share the same metadata — the table records each helper twice (once
+      # with `_path`, once with `_url`) for `O(1)` lookup at the call site.
       class HelperTable
         Entry = Data.define(:name, :arity, :path, :http_method, :action)
 
         attr_reader :entries, :custom_helpers, :devise_resources
 
-        # @param entries [Array<Entry>] freshly built; the
-        #   factory below is the canonical construction path.
-        # @param custom_helpers [Enumerable<String>] names of
-        #   project-defined helper methods (typically pulled
-        #   from `app/helpers/**/*.rb` by
-        #   {HelperDiscoverer}) that the analyzer should treat
-        #   as known — they do NOT correspond to a route but
-        #   their presence MUST NOT fire `unknown-helper`. No
-        #   arity / path metadata is recorded; the analyzer
-        #   skips the route-side checks for these names.
-        # @param devise_resources [Enumerable<String>] resource
-        #   names declared via `devise_for :resource` (already
-        #   singularised, e.g. `"user"`). Used to recognise the
-        #   dynamic OmniAuth helper family
-        #   (`<resource>_<provider>_omniauth_(authorize|callback)_(path|url)`)
-        #   whose provider segment is supplied at runtime — no
-        #   per-name entry is registered for them but they MUST
-        #   NOT fire `unknown-helper` either.
+        # @param entries [Array<Entry>] freshly built; the factory below is the canonical construction path.
+        # @param custom_helpers [Enumerable<String>] names of project-defined helper methods (typically
+        #   pulled from `app/helpers/**/*.rb` by {HelperDiscoverer}) that the analyzer should treat as
+        #   known — they do NOT correspond to a route but their presence MUST NOT fire `unknown-helper`. No
+        #   arity / path metadata is recorded; the analyzer skips the route-side checks for these names.
+        # @param devise_resources [Enumerable<String>] resource names declared via `devise_for :resource`
+        #   (already singularised, e.g. `"user"`). Used to recognise the dynamic OmniAuth helper family
+        #   (`<resource>_<provider>_omniauth_(authorize|callback)_(path|url)`) whose provider segment is
+        #   supplied at runtime — no per-name entry is registered for them but they MUST NOT fire
+        #   `unknown-helper` either.
         def initialize(entries, custom_helpers: [], devise_resources: [])
           @entries = entries.freeze
-          # Multimap: a single helper name can map to multiple
-          # entries when an uncountable-noun resource registers
-          # both an arity-0 index helper and an arity-1 show
-          # helper under the same `news_path` name. `find`
-          # returns the first entry (preserving the previous
-          # API); `accepts_arity?` checks against every entry.
+          # Multimap: a single helper name can map to multiple entries when an uncountable-noun resource
+          # registers both an arity-0 index helper and an arity-1 show helper under the same `news_path`
+          # name. `find` returns the first entry (preserving the previous API); `accepts_arity?` checks
+          # against every entry.
           @by_name = entries.group_by(&:name).transform_values(&:freeze).freeze
           @custom_helpers = custom_helpers.to_set.freeze
           @devise_resources = devise_resources.to_set(&:to_s).freeze
           freeze
         end
 
-        # @return [Entry, nil] First matching entry; for the
-        #   uncountable-noun case this is the index helper
-        #   (the show helper is also registered but starts
-        #   second).
+        # @return [Entry, nil] First matching entry; for the uncountable-noun case this is the index helper
+        #   (the show helper is also registered but starts second).
         def find(helper_name)
           @by_name[helper_name.to_s]&.first
         end
@@ -80,14 +59,10 @@ module Rigor
           @by_name.key?(helper_name.to_s)
         end
 
-        # True when `helper_name` is either a registered route
-        # helper, a discovered project-defined custom helper,
-        # OR a dynamic OmniAuth-shaped helper for one of the
-        # declared `devise_for` resources. The
-        # `unknown-helper` rule consults this predicate to
-        # decide whether to fire — `known?` alone misses
-        # custom helpers and OmniAuth providers, which would
-        # then false-fire on canonical Rails-app patterns.
+        # True when `helper_name` is either a registered route helper, a discovered project-defined custom
+        # helper, OR a dynamic OmniAuth-shaped helper for one of the declared `devise_for` resources. The
+        # `unknown-helper` rule consults this predicate to decide whether to fire — `known?` alone misses
+        # custom helpers and OmniAuth providers, which would then false-fire on canonical Rails-app patterns.
         def recognised?(helper_name)
           name = helper_name.to_s
           return true if @by_name.key?(name)
@@ -96,11 +71,9 @@ module Rigor
           omniauth_match?(name)
         end
 
-        # `<resource>_<provider>_omniauth_(authorize|callback)_(path|url)` — when
-        # `<resource>` matches a declared `devise_for` resource
-        # the helper is dynamic-provider Devise OmniAuth. The
-        # provider segment is opaque to a static parser, so we
-        # accept any non-empty token between the resource and
+        # `<resource>_<provider>_omniauth_(authorize|callback)_(path|url)` — when `<resource>` matches a
+        # declared `devise_for` resource the helper is dynamic-provider Devise OmniAuth. The provider
+        # segment is opaque to a static parser, so we accept any non-empty token between the resource and
         # the omniauth suffix.
         def omniauth_match?(name)
           return false if @devise_resources.empty?
@@ -115,19 +88,16 @@ module Rigor
           end
         end
 
-        # @return [Boolean] true when any entry under this
-        #   helper name accepts the given positional arity.
+        # @return [Boolean] true when any entry under this helper name accepts the given positional arity.
         #
-        # Rails helpers have the signature `helper(*segments, options = {})`,
-        # so `expected + 1` is always valid — the extra argument is treated
-        # as a query-params/options hash (e.g. `users_path(page: 2)` or
-        # `user_path(@u, pagination_params(...))`).
+        # Rails helpers have the signature `helper(*segments, options = {})`, so `expected + 1` is always
+        # valid — the extra argument is treated as a query-params/options hash (e.g. `users_path(page: 2)`
+        # or `user_path(@u, pagination_params(...))`).
         def accepts_arity?(helper_name, arity)
           (@by_name[helper_name.to_s] || []).any? { |entry| entry.arity == arity || entry.arity + 1 == arity }
         end
 
-        # @return [Array<Integer>] all accepted positional
-        #   arities for a helper name. Empty when unknown.
+        # @return [Array<Integer>] all accepted positional arities for a helper name. Empty when unknown.
         def acceptable_arities(helper_name)
           (@by_name[helper_name.to_s] || []).map(&:arity).uniq
         end
@@ -146,11 +116,9 @@ module Rigor
         end
 
         def to_h
-          # Plain dump for fact-store publishing (ADR-9). Each
-          # name serialises as a small Hash for the FIRST entry
-          # under that name, with `acceptable_arities` carrying
-          # the full arity set so cross-plugin consumers can
-          # honour the uncountable-noun multi-arity case.
+          # Plain dump for fact-store publishing (ADR-9). Each name serialises as a small Hash for the
+          # FIRST entry under that name, with `acceptable_arities` carrying the full arity set so
+          # cross-plugin consumers can honour the uncountable-noun multi-arity case.
           @by_name.transform_values do |group|
             entry = group.first
             { name: entry.name, arity: entry.arity, path: entry.path,