rigortype 0.2.7 → 0.2.9

data/plugins/rigor-minitest/lib/rigor/plugin/minitest.rb

@@ -6,61 +6,44 @@ require_relative "minitest/assertion_analyzer"
 
 module Rigor
   module Plugin
-    # rigor-minitest — narrows locals through Minitest /
-    # Test::Unit assertions.
+    # rigor-minitest — narrows locals through Minitest / Test::Unit assertions.
     #
-    # Recognises every supported `assert_*` / `refute_*` /
-    # `assert_not_*` shape (Minitest core + Test::Unit aliases),
-    # plus the Minitest/spec `_(x).must_*` / `.wont_*` matchers
-    # (`expect(x)` / `value(x)` wrappers covered too). For each
-    # recognised assertion the plugin emits a Rigor
-    # `post_return_fact` whose `:local`-kind target narrows the
-    # named local on the post-call edge so downstream calls in
-    # the same `it` / `test_` / `def test_*` body resolve
-    # against the narrowed type.
+    # Recognises every supported `assert_*` / `refute_*` / `assert_not_*` shape (Minitest core + Test::Unit
+    # aliases), plus the Minitest/spec `_(x).must_*` / `.wont_*` matchers (`expect(x)` / `value(x)` wrappers
+    # covered too). For each recognised assertion the plugin emits a Rigor `post_return_fact` whose
+    # `:local`-kind target narrows the named local on the post-call edge so downstream calls in the same
+    # `it` / `test_` / `def test_*` body resolve against the narrowed type.
     #
     # ## Why a single plugin covers two frameworks
     #
-    # Minitest and Test::Unit share the `assert_*` / `refute_*`
-    # surface (Test::Unit's `assert_not_*` aliases are
-    # recognised by the same rule table). The matchers_vaccine
-    # gem layers RSpec-style matcher composition on top of
-    # Minitest's `must` API and is covered by the spec-style
-    # recogniser without additional wiring.
+    # Minitest and Test::Unit share the `assert_*` / `refute_*` surface (Test::Unit's `assert_not_*` aliases
+    # are recognised by the same rule table). The matchers_vaccine gem layers RSpec-style matcher composition
+    # on top of Minitest's `must` API and is covered by the spec-style recogniser without additional wiring.
     #
     # ## Configuration
     #
-    # No configuration knobs. Activate via
-    # `plugins: ["rigor-minitest"]` in `.rigor.yml`.
+    # No configuration knobs. Activate via `plugins: ["rigor-minitest"]` in `.rigor.yml`.
     #
     # ## Limitations
     #
-    # - **No `assert_raises(T) { ... }`** — that's a block-shape
-    #   matcher and Rigor's narrowing model is for
+    # - **No `assert_raises(T) { ... }`** — that's a block-shape matcher and Rigor's narrowing model is for
     #   straight-line locals.
-    # - **No `assert_predicate(x, :foo?)`** — needs a
-    #   predicate-state carrier Rigor doesn't model today.
-    # - **No `assert_respond_to(x, :m)`** — same shape gap
-    #   (respond-to-set carrier).
-    # - **No legacy bare `x.must_be_kind_of(T)`** — the
-    #   receiver IS the value, so the analyzer has nothing to
+    # - **No `assert_predicate(x, :foo?)`** — needs a predicate-state carrier Rigor doesn't model today.
+    # - **No `assert_respond_to(x, :m)`** — same shape gap (respond-to-set carrier).
+    # - **No legacy bare `x.must_be_kind_of(T)`** — the receiver IS the value, so the analyzer has nothing to
     #   narrow against. Users should migrate to `_(x).must_*`.
-    # - **No `assert_in_delta` / `assert_operator`** — float-
-    #   range / generic operator narrowing is future work.
-    # - **No `assert_throws(:tag) { ... }` / `assert_raises`** —
-    #   block-form expectations need a separate slice.
+    # - **No `assert_in_delta` / `assert_operator`** — float-range / generic operator narrowing is future work.
+    # - **No `assert_throws(:tag) { ... }` / `assert_raises`** — block-form expectations need a separate slice.
     class Minitest < Rigor::Plugin::Base
       manifest(
         id: "minitest",
         version: "0.1.0",
         description: "Narrows locals through Minitest / Test::Unit `assert_*` / `refute_*` " \
                      "and Minitest/spec `_(x).must_*` / `.wont_*` matchers.",
-        # ADR-38 — `def setup` runs before every `def test_*`, so
-        # ivars it assigns are initialised by the time a test body
-        # reads them. Declaring it an additional initializer stops
-        # the read-before-write nil widening that would otherwise
-        # type `@conn` (set in `setup`, read in a test) as
-        # `T | nil` and surface a false nil-receiver diagnostic.
+        # ADR-38 — `def setup` runs before every `def test_*`, so ivars it assigns are initialised by the
+        # time a test body reads them. Declaring it an additional initializer stops the read-before-write
+        # nil widening that would otherwise type `@conn` (set in `setup`, read in a test) as `T | nil` and
+        # surface a false nil-receiver diagnostic.
         additional_initializers: [
           Rigor::Plugin::AdditionalInitializer.new(
             receiver_constraint: "Minitest::Test", methods: [:setup]
@@ -74,10 +57,8 @@ module Rigor
         ]
       )
 
-      # ADR-37 slice 2 — emits `post_return_facts` for every recognised
-      # assertion, method-gated by the engine. The engine routes
-      # `:local`-kind facts through
-      # `StatementEvaluator#apply_local_post_return_fact`.
+      # ADR-37 slice 2 — emits `post_return_facts` for every recognised assertion, method-gated by the
+      # engine. The engine routes `:local`-kind facts through `StatementEvaluator#apply_local_post_return_fact`.
       narrowing_facts methods: AssertionAnalyzer::SUPPORTED_METHODS do |call_node, scope|
         AssertionAnalyzer.contribution_for(call_node, environment: scope&.environment)&.post_return_facts
       end

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/analyzer.rb

@@ -6,41 +6,32 @@ require "prism"
 module Rigor
   module Plugin
     class Pundit < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for Pundit
-      # entry-point calls and validates each against the
+      # Walks a parsed file's AST looking for Pundit entry-point calls and validates each against the
       # {PolicyIndex}.
       #
       # Recognised shapes:
       #
-      # - `authorize(record, :action)` — record's inferred
-      #   type → `<Type>Policy#<action>?` lookup. Both the
+      # - `authorize(record, :action)` — record's inferred type → `<Type>Policy#<action>?` lookup. Both the
       #   policy class and the predicate must exist.
-      # - `authorize(record)` — without an action argument,
-      #   we only validate that `<Type>Policy` exists. The
-      #   action name is determined at runtime from the
-      #   controller's current action; static validation
+      # - `authorize(record)` — without an action argument, we only validate that `<Type>Policy` exists. The
+      #   action name is determined at runtime from the controller's current action; static validation
       #   isn't possible without controller context.
-      # - `policy(record)` / `policy_scope(scope)` — same
-      #   `<Type>Policy` existence check.
+      # - `policy(record)` / `policy_scope(scope)` — same `<Type>Policy` existence check.
       #
-      # When the first argument's inferred type is NOT a
-      # `Nominal[T]` (e.g. an untyped local variable), the
-      # call is silently passed through. The plugin only
-      # validates what it can prove from the static type
+      # When the first argument's inferred type is NOT a `Nominal[T]` (e.g. an untyped local variable), the
+      # call is silently passed through. The plugin only validates what it can prove from the static type
       # carrier.
       module Analyzer
         ENTRY_METHODS = %i[authorize policy policy_scope].freeze
 
-        # One policy violation: the kebab-case `rule`, `severity`, and
-        # human-readable `message`. Carries no path/location — the caller
-        # (the `node_rule` block) positions it via `Plugin::Base#diagnostic`.
+        # One policy violation: the kebab-case `rule`, `severity`, and human-readable `message`. 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
 
-        # The policy violations for a single call node (0..2 of them), or
-        # `[]` when the node is not a Pundit entry call or its record type
-        # is not statically determinable. ADR-37: the engine owns the
+        # The policy violations for a single call node (0..2 of them), or `[]` when the node is not a
+        # Pundit entry call or its record type is not statically determinable. ADR-37: the engine owns the
         # walk, so this is per-node logic.
         #
         # @param call_node [Prism::Node]
@@ -71,15 +62,11 @@ module Rigor
           ENTRY_METHODS.include?(node.name) && node.receiver.nil?
         end
 
-        # Resolves the first-argument expression to a policy
-        # class name. The candidates are:
+        # Resolves the first-argument expression to a policy class name. The candidates are:
         # - `Foo` (a constant) → `FooPolicy`
-        # - `Foo.method(...)` whose inferred type is
-        #   `Nominal[Bar]` → `BarPolicy`
-        # - any other expression whose inferred type is
-        #   `Nominal[Bar]` → `BarPolicy`
-        # Returns `nil` when the type isn't statically
-        # determinable.
+        # - `Foo.method(...)` whose inferred type is `Nominal[Bar]` → `BarPolicy`
+        # - any other expression whose inferred type is `Nominal[Bar]` → `BarPolicy`
+        # Returns `nil` when the type isn't statically determinable.
         def derive_policy_class_name(record_node, scope)
           if record_node.is_a?(Prism::ConstantReadNode) || record_node.is_a?(Prism::ConstantPathNode)
             constant_name = constant_receiver_name(record_node)
@@ -118,10 +105,8 @@ module Rigor
           )
         end
 
-        # Validates the `authorize(record, :action)` form.
-        # Returns nil when the call has no second argument
-        # (the runtime infers it from the controller — out
-        # of scope here) or when the second argument isn't
+        # Validates the `authorize(record, :action)` form. Returns nil when the call has no second argument
+        # (the runtime infers it from the controller — out of scope here) or when the second argument isn't
         # a literal symbol / string.
         def action_violation(call_node, policy_entry)
           args = call_node.arguments&.arguments || []

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb

@@ -7,22 +7,17 @@ require_relative "policy_index"
 module Rigor
   module Plugin
     class Pundit < Rigor::Plugin::Base
-      # Walks the configured policy-search paths via the
-      # plugin's `IoBoundary`, parses each `.rb` file with
-      # Prism, and collects classes whose immediate
-      # superclass is one of the configured base classes.
+      # Walks the configured policy-search paths via the plugin's `IoBoundary`, parses each `.rb` file with
+      # Prism, and collects classes whose immediate superclass is one of the configured base classes.
       #
-      # For each discovered policy class, the discoverer
-      # collects every instance-side `def name?` predicate
-      # method. Non-predicate methods (`initialize`,
-      # `resolve`, helper methods) are ignored — Pundit's
+      # For each discovered policy class, the discoverer collects every instance-side `def name?` predicate
+      # method. Non-predicate methods (`initialize`, `resolve`, helper methods) are ignored — Pundit's
       # `authorize` only ever calls predicate methods.
       #
       # Limitations (intentional for v0.1.0):
       #
       # - Direct-superclass match only.
-      # - Predicate methods are read from the syntactic
-      #   `def` list. Methods built via `define_method` /
+      # - Predicate methods are read from the syntactic `def` list. Methods built via `define_method` /
       #   inherited from a sibling concern are out of scope.
       class PolicyDiscoverer
         def initialize(io_boundary:, search_paths:, base_classes:)
@@ -120,8 +115,7 @@ module Rigor
           end
         end
 
-        # Returns symbolic predicate names (`:update?`,
-        # `:show?`, …) defined on the policy. Only
+        # Returns symbolic predicate names (`:update?`, `:show?`, …) defined on the policy. Only
         # instance-side names that end in `?` are recorded.
         def collect_predicate_methods(body)
           return [] if body.nil?

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_index.rb

@@ -3,14 +3,11 @@
 module Rigor
   module Plugin
     class Pundit < Rigor::Plugin::Base
-      # Frozen catalogue of discovered Pundit policy classes
-      # keyed by policy class name (e.g. `"PostPolicy"`).
-      # Each entry tracks the set of predicate methods
-      # defined on the policy (instance-side `def name?`)
+      # Frozen catalogue of discovered Pundit policy classes keyed by policy class name (e.g. `"PostPolicy"`).
+      # Each entry tracks the set of predicate methods defined on the policy (instance-side `def name?`)
       # plus the source file path.
       #
-      # The analyzer maps a record's inferred type
-      # (`Nominal[Post]`) to the policy class name
+      # The analyzer maps a record's inferred type (`Nominal[Post]`) to the policy class name
       # (`"PostPolicy"`) and looks up the predicate.
       class PolicyIndex
         Entry = Data.define(:policy_class_name, :file_path, :predicate_methods) do
@@ -22,8 +19,7 @@ module Rigor
             predicate_methods.to_a.sort
           end
 
-          # Normalises an action symbol / string by ensuring
-          # a trailing `?`. `:update` and `:update?` both
+          # Normalises an action symbol / string by ensuring a trailing `?`. `:update` and `:update?` both
           # resolve to `update?`.
           def normalize(name)
             string = name.to_s

data/plugins/rigor-pundit/lib/rigor/plugin/pundit.rb

@@ -8,13 +8,11 @@ require_relative "pundit/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-pundit — validates Pundit `authorize` /
-    # `policy` / `policy_scope` calls against the project's
+    # rigor-pundit — validates Pundit `authorize` / `policy` / `policy_scope` calls against the project's
     # `app/policies/` tree.
     #
     # Tier 3B of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Statically discovers policy classes by walking
-    # `policy_search_paths` and parsing each file with
+    # Statically discovers policy classes by walking `policy_search_paths` and parsing each file with
     # Prism — no `pundit` runtime dependency.
     #
     # ## Configuration
@@ -27,34 +25,22 @@ module Rigor
     #
     # ## What it checks
     #
-    # 1. **Policy class existence** — `authorize(record, ...)`
-    #    looks up `<inferred-type>Policy` in the index.
-    #    Missing policies emit `unknown-policy-class` with
-    #    a did-you-mean suggestion.
-    # 2. **Predicate method existence** — for the
-    #    `authorize(record, :action)` form, validates that
-    #    `<Policy>#<action>?` is defined. Missing methods
-    #    emit `unknown-policy-method` listing the known
+    # 1. **Policy class existence** — `authorize(record, ...)` looks up `<inferred-type>Policy` in the index.
+    #    Missing policies emit `unknown-policy-class` with a did-you-mean suggestion.
+    # 2. **Predicate method existence** — for the `authorize(record, :action)` form, validates that
+    #    `<Policy>#<action>?` is defined. Missing methods emit `unknown-policy-method` listing the known
     #    predicates.
     #
     # ## Limitations (v0.1.0)
     #
-    # - Records whose inferred type is NOT a `Nominal[T]`
-    #   (untyped local variables, untyped instance
-    #   variables) are silently passed through. The plugin
-    #   only validates what it can prove from the static
-    #   carrier.
-    # - The two-argument form
-    #   `authorize(record, :action_symbol)` is the only
-    #   one validated. The implicit form
-    #   `authorize(record)` (which Pundit resolves at
-    #   runtime against the controller's current action) is
-    #   passed through with the policy-class check only.
-    # - Direct-superclass match for `policy_base_classes`.
-    #   Indirect inheritance (`AdminPolicy <
-    #   ApplicationPolicy`) needs `AdminPolicy` listed in
-    #   `policy_base_classes` if subclasses inherit from
-    #   it.
+    # - Records whose inferred type is NOT a `Nominal[T]` (untyped local variables, untyped instance
+    #   variables) are silently passed through. The plugin only validates what it can prove from the
+    #   static carrier.
+    # - The two-argument form `authorize(record, :action_symbol)` is the only one validated. The implicit
+    #   form `authorize(record)` (which Pundit resolves at runtime against the controller's current action)
+    #   is passed through with the policy-class check only.
+    # - Direct-superclass match for `policy_base_classes`. Indirect inheritance (`AdminPolicy <
+    #   ApplicationPolicy`) needs `AdminPolicy` listed in `policy_base_classes` if subclasses inherit from it.
     class Pundit < Rigor::Plugin::Base
       manifest(
         id: "pundit",
@@ -79,10 +65,9 @@ module Rigor
         @policy_base_classes = Array(config.fetch("policy_base_classes")).map(&:to_s)
       end
 
-      # File-level only: the load-error emission. The per-call policy
-      # validation runs over the engine-owned walk via the node_rule
-      # below (ADR-37). The index is lazily loaded + memoised by
-      # `producer_value`, so both surfaces share one load.
+      # File-level only: the load-error emission. The per-call policy validation runs over the engine-owned
+      # walk via the node_rule below (ADR-37). The index is lazily loaded + memoised by `producer_value`,
+      # so both surfaces share one load.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:policy_index)
         return [load_error_diagnostic(path)] if index.nil? && producer_error(:policy_index)

data/plugins/rigor-rails/lib/rigor-rails.rb

@@ -1,26 +1,19 @@
 # frozen_string_literal: true
 
-# Convenience entry point. `require "rigor-rails"` requires
-# every Tier 1+2 Rails ecosystem plugin in one go, so projects
-# that prefer a single require statement (some `spec_helper`
-# patterns, ad-hoc scripts) do not have to list seven require
-# lines.
+# Convenience entry point. `require "rigor-rails"` requires every Tier 1+2 Rails ecosystem plugin in one go,
+# so projects that prefer a single require statement (some `spec_helper` patterns, ad-hoc scripts) do not
+# have to list seven require lines.
 #
-# Note: requiring this entry point does NOT mark every plugin as
-# active. The Rigor plugin loader walks `.rigor.yml`'s `plugins:`
-# list and instantiates only the plugins enumerated there. This
-# is per ADR-12 WD1's "Gemfile-convenience meta-gem" pattern —
-# users still control which plugins participate in analysis via
-# `.rigor.yml`.
+# Note: requiring this entry point does NOT mark every plugin as active. The Rigor plugin loader walks
+# `.rigor.yml`'s `plugins:` list and instantiates only the plugins enumerated there. This is per ADR-12
+# WD1's "Gemfile-convenience meta-gem" pattern — users still control which plugins participate in analysis
+# via `.rigor.yml`.
 #
-# Sub-plugins ARE registered with `Rigor::Plugin` when this file
-# loads (each gem's entry point side-effects a `Plugin.register`
-# call); the loader's lookup phase finds them by id when listed.
+# Sub-plugins ARE registered with `Rigor::Plugin` when this file loads (each gem's entry point side-effects
+# a `Plugin.register` call); the loader's lookup phase finds them by id when listed.
 #
-# Adding the gem to a project's Gemfile without listing any
-# plugin in `.rigor.yml` is harmless: the requires happen on
-# `Bundler.require`, but no plugin's `init` / `prepare` / hooks
-# run.
+# Adding the gem to a project's Gemfile without listing any plugin in `.rigor.yml` is harmless: the requires
+# happen on `Bundler.require`, but no plugin's `init` / `prepare` / hooks run.
 
 require "rigor-rails-routes"
 require "rigor-rails-i18n"

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

@@ -6,85 +6,64 @@ require "prism"
 module Rigor
   module Plugin
     class RailsI18n < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for `t(...)` /
-      # `I18n.t(...)` / `I18n.translate(...)` calls with a
-      # literal-string first argument. Calls with a non-literal
-      # key (variable, expression) are silently passed through —
-      # the plugin only validates what it can prove statically.
+      # Walks a parsed file's AST looking for `t(...)` / `I18n.t(...)` / `I18n.translate(...)` calls with a
+      # literal-string first argument. Calls with a non-literal key (variable, expression) are silently
+      # passed through — the plugin only validates what it can prove statically.
       #
       # ## What gets emitted per recognised call
       #
-      # - `plugin.rails-i18n.translation-call` (info) names the
-      #   key and the locales it resolves in.
-      # - `plugin.rails-i18n.unknown-key` (error) when the key
-      #   is missing from every loaded locale; the message
-      #   includes a did-you-mean suggestion drawn from the
-      #   index.
-      # - `plugin.rails-i18n.missing-locale` (warning) when the
-      #   key resolves in some configured locales but is absent
-      #   from at least one. Suppressed when the call passes
-      #   `default:` (the user has signalled they're aware of
-      #   the partial coverage).
-      # - `plugin.rails-i18n.wrong-interpolation` (error) when
-      #   the call's interpolation hash uses keys that don't
-      #   match the value's `%{var}` placeholders, or omits a
-      #   required placeholder.
+      # - `plugin.rails-i18n.translation-call` (info) names the key and the locales it resolves in.
+      # - `plugin.rails-i18n.unknown-key` (error) when the key is missing from every loaded locale; the
+      #   message includes a did-you-mean suggestion drawn from the index.
+      # - `plugin.rails-i18n.missing-locale` (warning) when the key resolves in some configured locales but
+      #   is absent from at least one. Suppressed when the call passes `default:` (the user has signalled
+      #   they're aware of the partial coverage).
+      # - `plugin.rails-i18n.wrong-interpolation` (error) when the call's interpolation hash uses keys that
+      #   don't match the value's `%{var}` placeholders, or omits a required placeholder.
       module Analyzer
         TRANSLATE_METHODS = %i[t translate].freeze
 
-        # Methods that are always I18n receivers (`I18n.t`,
-        # `::I18n.t`).
+        # Methods that are always I18n receivers (`I18n.t`, `::I18n.t`).
         I18N_RECEIVER_NAMES = %w[I18n ::I18n].freeze
 
-        # Matches controller file paths so lazy keys (`.key`)
-        # can be expanded to `<controller_scope>.<action>.<key>`.
-        # Captures the path segment between `controllers/` and
+        # Matches controller file paths so lazy keys (`.key`) can be expanded to
+        # `<controller_scope>.<action>.<key>`. Captures the path segment between `controllers/` and
         # `_controller.rb` (e.g. `users`, `admin/users`).
         CONTROLLER_PATH_RE = %r{(?:^|/)controllers/(.+)_controller\.rb$}
 
-        # Matches Rails view-template file paths to derive the
-        # I18n "virtual path" — the scope that Rails uses for
-        # lazy `t('.key')` lookups inside a template.
+        # Matches Rails view-template file paths to derive the I18n "virtual path" — the scope that Rails
+        # uses for lazy `t('.key')` lookups inside a template.
         #
-        # Captures the path segment between `views/` and the
-        # format+variant+handler suffix, then strips a leading
-        # underscore from each segment — Rails templates resolve
-        # `_form.html.erb` as "form", not "_form".
+        # Captures the path segment between `views/` and the format+variant+handler suffix, then strips a
+        # leading underscore from each segment — Rails templates resolve `_form.html.erb` as "form", not
+        # "_form".
         #
         #   app/views/setting/index.html.erb      → setting.index
         #   app/views/admin/users/new.html.erb    → admin.users.new
         #   app/views/home/index.html+mobile.erb  → home.index
         #   app/views/users/_form.html.erb        → users.form
         #
-        # The view-scope lazy expansion replaces the action
-        # part with the view's virtual path:
+        # The view-scope lazy expansion replaces the action part with the view's virtual path:
         #   `<%= t('.title') %>` → `setting.index.title`
         VIEW_SCOPE_RE = %r{views/(.+?)\.(?:\w+)(?:\+\w+)?\.\w+\z}
 
-        # Regex to extract lazy-key arguments from ERB / HTML
-        # template content. Matches `t('.key')`, `t(".key")`,
-        # `I18n.t('.key')`, and `I18n.translate('.key')` with a
-        # leading dot on the key string. Captures only the key
-        # part after the dot.
+        # Regex to extract lazy-key arguments from ERB / HTML template content. Matches `t('.key')`,
+        # `t(".key")`, `I18n.t('.key')`, and `I18n.translate('.key')` with a leading dot on the key string.
+        # Captures only the key part after the dot.
         LAZY_T_KEY_RE = /\b(?:I18n\.)?(?:t|translate)\s*\(\s*(?:"\.([^"\\]*)"|'\.([^'\\]*)')/
 
-        # Reserved option keys — these are recognised by I18n
-        # itself and not treated as interpolation variables.
+        # Reserved option keys — these are recognised by I18n itself and not treated as interpolation
+        # variables.
         RESERVED_OPTION_KEYS = %i[
           default scope locale count raise throw fallback
           fallback_in_progress separator deep_interpolation
         ].to_set.freeze
 
-        # Key prefixes Rails / `rails-i18n` ship in every
-        # locale by default. Projects whose own locale files
-        # don't redeclare them still get them at runtime (via
-        # the `rails-i18n` gem's bundled locale catalogues).
-        # `t('date.order')` is the canonical Mastodon case —
-        # used by `Settings::Date::Order` and date-of-birth
-        # selects, never authored project-side. Skip
-        # `unknown-key` for these; downstream interpolation
-        # checks have nothing to validate without a leaf entry
-        # so they decline silently too.
+        # Key prefixes Rails / `rails-i18n` ship in every locale by default. Projects whose own locale
+        # files don't redeclare them still get them at runtime (via the `rails-i18n` gem's bundled locale
+        # catalogues). `t('date.order')` is the canonical Mastodon case — used by `Settings::Date::Order`
+        # and date-of-birth selects, never authored project-side. Skip `unknown-key` for these; downstream
+        # interpolation checks have nothing to validate without a leaf entry so they decline silently too.
         RAILS_SHIPPED_KEY_PREFIXES = %w[
           date.
           time.
@@ -101,9 +80,8 @@ module Rigor
           activerecord.errors.models.
         ].freeze
 
-        # One translation-call observation. Carries no path/location —
-        # the caller (the `node_rule` block) positions it via
-        # `Plugin::Base#diagnostic`.
+        # One translation-call 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
@@ -118,12 +96,10 @@ module Rigor
         # @param locale_index [LocaleIndex]
         # @param configured_locales [Array<String>]
         # @return [Array<Diagnostic>]
-        # The translation violations for a single call node, or `[]`
-        # when it is not a recognised `t` / `translate` call with a
-        # literal key. ADR-37: the engine owns the walk; `action` (the
-        # enclosing method, for lazy `t('.key')` expansion) comes from
-        # the node-rule `NodeContext`, and `controller_scope` from the
-        # file path.
+        # The translation violations for a single call node, or `[]` when it is not a recognised `t` /
+        # `translate` call with a literal key. ADR-37: the engine owns the walk; `action` (the enclosing
+        # method, for lazy `t('.key')` expansion) comes from the node-rule `NodeContext`, and
+        # `controller_scope` from the file path.
         #
         # @param call_node [Prism::Node]
         # @param locale_index [LocaleIndex]
@@ -143,11 +119,11 @@ module Rigor
           options = options_hash(call_node)
           entry = locale_index.find(literal_key)
           if entry.nil?
-            # CLDR pluralization namespace: `t('accounts.posts', count: n)`
-            # resolves through a `.one` / `.other` child — not missing.
+            # CLDR pluralization namespace: `t('accounts.posts', count: n)` resolves through a `.one` /
+            # `.other` child — not missing.
             return [] if locale_index.pluralization_namespace?(literal_key)
-            # Rails / rails-i18n ship `date.order`, `time.am`, etc. in
-            # every locale at runtime even when project files omit them.
+            # Rails / rails-i18n ship `date.order`, `time.am`, etc. in every locale at runtime even when
+            # project files omit them.
             return [] if rails_shipped_key?(literal_key)
 
             return [unknown_key_violation(literal_key, locale_index)]
@@ -162,9 +138,8 @@ module Rigor
           violations
         end
 
-        # Derives the Rails controller scope from the file path,
-        # e.g. `app/controllers/admin/users_controller.rb` → `admin.users`.
-        # Returns nil for non-controller paths.
+        # Derives the Rails controller scope from the file path, e.g.
+        # `app/controllers/admin/users_controller.rb` → `admin.users`. Returns nil for non-controller paths.
         def controller_scope_from_path(path)
           m = CONTROLLER_PATH_RE.match(path.to_s)
           return nil unless m
@@ -198,12 +173,10 @@ module Rigor
           violations
         end
 
-        # Expands a lazy key (starting with `.`) to its full
-        # dotted path using the controller scope and action name.
-        # Returns the raw key unchanged for absolute keys.
-        # Returns nil for lazy keys outside a controller context
-        # or without an enclosing action — these are silently
-        # skipped to avoid false positives.
+        # Expands a lazy key (starting with `.`) to its full dotted path using the controller scope and
+        # action name. Returns the raw key unchanged for absolute keys. Returns nil for lazy keys outside a
+        # controller context or without an enclosing action — these are silently skipped to avoid false
+        # positives.
         def expand_key(raw_key, controller_scope:, action:)
           return raw_key unless raw_key.start_with?(".")
           return nil unless controller_scope && action
@@ -219,9 +192,8 @@ module Rigor
           I18N_RECEIVER_NAMES.include?(receiver_name)
         end
 
-        # Extracts the literal-string first argument when
-        # present. Returns nil for variable / expression keys —
-        # only literal keys are statically validated.
+        # Extracts the literal-string first argument when present. Returns nil for variable / expression
+        # keys — only literal keys are statically validated.
         def literal_key_for(call_node)
           args = call_node.arguments&.arguments || []
           return nil if args.empty?
@@ -232,11 +204,9 @@ module Rigor
           first.unescaped
         end
 
-        # Pulls the interpolation hash from the call's
-        # arguments. The trailing `Hash` argument (or
-        # `Prism::KeywordHashNode`) carries both reserved I18n
-        # options (`default:`, `scope:`, …) and interpolation
-        # variables. Returns:
+        # Pulls the interpolation hash from the call's arguments. The trailing `Hash` argument (or
+        # `Prism::KeywordHashNode`) carries both reserved I18n options (`default:`, `scope:`, …) and
+        # interpolation variables. Returns:
         #   {
         #     :has_default     => bool,
         #     :all_keys        => Set<Symbol>     (every assoc key in the hash),
@@ -244,15 +214,11 @@ module Rigor
         #     :hash_node       => Prism::Node (or nil)
         #   }
         #
-        # Note: a reserved option key (e.g. `count:`) can
-        # also serve as an interpolation value when the
-        # locale's leaf string has `%{count}`. The analyzer
-        # therefore checks the missing-placeholder set
-        # against `all_keys` (so `count:` satisfies a
-        # `%{count}` placeholder) and the
-        # extra-placeholder set against `non_reserved` (so
-        # `default:` / `scope:` are never reported as
-        # extra interpolation arguments).
+        # Note: a reserved option key (e.g. `count:`) can also serve as an interpolation value when the
+        # locale's leaf string has `%{count}`. The analyzer therefore checks the missing-placeholder set
+        # against `all_keys` (so `count:` satisfies a `%{count}` placeholder) and the extra-placeholder set
+        # against `non_reserved` (so `default:` / `scope:` are never reported as extra interpolation
+        # arguments).
         def options_hash(call_node)
           args = call_node.arguments&.arguments || []
           last = args.last
@@ -275,8 +241,8 @@ module Rigor
         end
 
         def collect_assoc_keys(hash_node)
-          # Both `Prism::HashNode` and `Prism::KeywordHashNode`
-          # expose `#elements`, so a single path handles both.
+          # Both `Prism::HashNode` and `Prism::KeywordHashNode` expose `#elements`, so a single path
+          # handles both.
           hash_node.elements.filter_map do |element|
             next nil unless element.is_a?(Prism::AssocNode)