rigortype 0.2.7 → 0.2.8

data/lib/rigor/type_node/identifier.rb

@@ -2,19 +2,15 @@
 
 module Rigor
   module TypeNode
-    # A bare named-type reference in an RBS::Extended payload. The
-    # `name` is the head as the parser saw it — kebab-case for
-    # built-in refinement names (`"non-empty-string"`),
-    # PascalCase for class-like names (`"String"`, `"Pick"`),
-    # `lower_snake` for type-function-shaped names without
+    # A bare named-type reference in an RBS::Extended payload. The `name` is the head as the parser
+    # saw it — kebab-case for built-in refinement names (`"non-empty-string"`), PascalCase for
+    # class-like names (`"String"`, `"Pick"`), `lower_snake` for type-function-shaped names without
     # arguments (rare).
     #
-    # The resolver dispatch path treats an `Identifier` as the
-    # no-arg form: if a plugin recognises `Pick` as a TS-utility
-    # name, it MAY still return `Dynamic[top]` for the bare
-    # `Identifier("Pick")` since TypeScript's `Pick` is only
-    # meaningful with two type arguments. The `Generic` carrier
-    # is what plugin resolvers normally key on.
+    # The resolver dispatch path treats an `Identifier` as the no-arg form: if a plugin recognises
+    # `Pick` as a TS-utility name, it MAY still return `Dynamic[top]` for the bare `Identifier("Pick")`
+    # since TypeScript's `Pick` is only meaningful with two type arguments. The `Generic` carrier is
+    # what plugin resolvers normally key on.
     class Identifier < Data.define(:name)
       def initialize(name:)
         unless name.is_a?(String) && !name.empty?
@@ -23,14 +19,11 @@ module Rigor
                 "got #{name.inspect}"
         end
 
-        # Freeze the String field so the resulting Data object
-        # is `Ractor.shareable?` regardless of whether the
-        # caller passed a `# frozen_string_literal: true`
-        # constant or a dynamically built String. The same
-        # discipline applies to every other TypeNode value
-        # object — they live in the parser's hot path and are
-        # the natural carriers to flow through future Ractor
-        # boundaries (see CURRENT_WORK Open Items #8).
+        # Freeze the String field so the resulting Data object is `Ractor.shareable?` regardless of
+        # whether the caller passed a `# frozen_string_literal: true` constant or a dynamically built
+        # String. The same discipline applies to every other TypeNode value object — they live in the
+        # parser's hot path and are the natural carriers to flow through future Ractor boundaries
+        # (see CURRENT_WORK Open Items #8).
         super(name: name.frozen? ? name : name.dup.freeze)
       end
     end

data/lib/rigor/type_node.rb

@@ -2,18 +2,9 @@
 
 module Rigor
   # Mini-AST passed to plugin-supplied `TypeNode` resolvers (see
-  # [ADR-13](../../docs/adr/13-typenode-resolver-plugin.md)). The
-  # two leaf carriers — {Identifier} and {Generic} — describe a
-  # node in an `%a{rigor:v1:...}` payload at the point the
-  # built-in registry / `ImportedRefinements::Parser` failed to
-  # resolve it and the analyzer hands the node off to plugins.
-  #
-  # Slice 1 of the ADR-13 envelope ships these two value objects
-  # only. The `NameScope` companion + plugin manifest hook arrive
-  # in slice 2; the parser integration arrives in slice 3. Until
-  # those land, the carriers are reachable only through direct
-  # instantiation in tests — they are the stable data shape every
-  # later slice consumes.
+  # [ADR-13](../../docs/adr/13-typenode-resolver-plugin.md)). The two leaf carriers — {Identifier} and
+  # {Generic} — describe a node in an `%a{rigor:v1:...}` payload at the point the built-in registry /
+  # `ImportedRefinements::Parser` failed to resolve it and the analyzer hands the node off to plugins.
   module TypeNode
   end
 end

data/lib/rigor/value_semantics.rb

@@ -1,19 +1,16 @@
 # frozen_string_literal: true
 
 module Rigor
-  # Generates the value-object identity trio (`==` / `eql?` / `hash`)
-  # from a fixed field list. Every `Rigor::Type` carrier and the cache
-  # descriptor entries are immutable value objects that each hand-wrote
-  # the same three methods; forgetting a field in one of them (or letting
-  # `==` and `hash` disagree) silently corrupts `Set` / `Hash`-key
-  # behaviour — a carrier vanishes after its first insertion, or two
-  # distinct types compare equal.
+  # Generates the value-object identity trio (`==` / `eql?` / `hash`) from a fixed field
+  # list. Every `Rigor::Type` carrier and the cache descriptor entries are immutable value
+  # objects that each hand-wrote the same three methods; forgetting a field in one of them
+  # (or letting `==` and `hash` disagree) silently corrupts `Set` / `Hash`-key behaviour — a
+  # carrier vanishes after its first insertion, or two distinct types compare equal.
   #
-  # The methods are CODE-GENERATED at class-definition time, not driven
-  # by per-call reflection, so they are as fast as the hand-written
-  # versions they replace — `hash` and `==` run on the inference hot path
-  # (type dedup, fact-store keys, memo caches), where a `send`-per-field
-  # would be a real regression.
+  # The methods are CODE-GENERATED at class-definition time, not driven by per-call
+  # reflection, so they are as fast as the hand-written versions they replace — `hash` and
+  # `==` run on the inference hot path (type dedup, fact-store keys, memo caches), where a
+  # `send`-per-field would be a real regression.
   #
   # Usage:
   #
@@ -32,11 +29,10 @@ module Rigor
   #     [self.class, class_name, type_args].hash
   #   end
   #
-  # Value objects whose equality is NOT a plain field-wise comparison
-  # keep their hand-written `==` / `hash` and do not call `value_fields`
-  # — e.g. `Type::Constant` also distinguishes `value.class` (so
-  # `Constant[1] != Constant[1.0]`), and `Type::Top` / `Type::Bot` are
-  # field-free singletons.
+  # Value objects whose equality is NOT a plain field-wise comparison keep their
+  # hand-written `==` / `hash` and do not call `value_fields` — e.g. `Type::Constant` also
+  # distinguishes `value.class` (so `Constant[1] != Constant[1.0]`), and `Type::Top` /
+  # `Type::Bot` are field-free singletons.
   module ValueSemantics
     def self.included(base)
       base.extend(ClassMethods)
@@ -49,10 +45,9 @@ module Rigor
         guard = comparisons.empty? ? "" : " && #{comparisons.join(' && ')}"
         key = (["self.class"] + fields.map(&:to_s)).join(", ")
 
-        # Codegen (not per-call reflection) so the generated `==` / `hash`
-        # read fields directly and run at hand-written speed on the
-        # inference hot path. For `value_fields :class_name, :type_args`
-        # the emitted source is:
+        # Codegen (not per-call reflection) so the generated `==` / `hash` read fields
+        # directly and run at hand-written speed on the inference hot path. For
+        # `value_fields :class_name, :type_args` the emitted source is:
         #
         #   def ==(other)
         #     other.is_a?(self.class) && class_name == other.class_name && type_args == other.type_args

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.2.7"
+  VERSION = "0.2.8"
 end

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

@@ -6,43 +6,34 @@ require "prism"
 module Rigor
   module Plugin
     class Actioncable < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for ActionCable
-      # entry-point calls and validates each against the
-      # {ChannelIndex}.
+      # Walks a parsed file's AST looking for ActionCable entry-point calls and validates each against
+      # the {ChannelIndex}.
       #
       # Recognised shapes:
       #
-      # - `<ChannelClass>.broadcast_to(record, data)` —
-      #   class-targeted broadcast. The class must exist in
-      #   the index.
-      # - `ActionCable.server.broadcast(stream_name, data)`
-      #   — string-targeted broadcast. When `stream_name`
-      #   is a literal string and the index has at least
-      #   one channel with no dynamic stream registrations,
-      #   we check that the name appears in
-      #   `index.all_stream_names`. Otherwise the
-      #   `unknown-stream` warning is suppressed (we can't
-      #   prove absence).
+      # - `<ChannelClass>.broadcast_to(record, data)` — class-targeted broadcast. The class must exist
+      #   in the index.
+      # - `ActionCable.server.broadcast(stream_name, data)` — string-targeted broadcast. When
+      #   `stream_name` is a literal string and the index has at least one channel with no dynamic
+      #   stream registrations, we check that the name appears in `index.all_stream_names`. Otherwise
+      #   the `unknown-stream` warning is suppressed (we can't prove absence).
       module Analyzer
-        # `ActionCable.server.broadcast(...)` — the receiver
-        # path we recognise as a server-targeted broadcast.
-        # Single-symbol form (just `broadcast`) is too
-        # ambiguous to validate.
+        # `ActionCable.server.broadcast(...)` — the receiver path we recognise as a server-targeted
+        # broadcast. Single-symbol form (just `broadcast`) is too ambiguous to validate.
         SERVER_BROADCAST_RECEIVER_NAMES = %w[
           ActionCable.server
           ::ActionCable.server
         ].freeze
 
-        # One broadcast observation. Carries no path/location — the
-        # caller (the `node_rule` block) positions it via
-        # `Plugin::Base#diagnostic`.
+        # One broadcast 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
 
-        # The broadcast violations for a single call node, or `[]` when
-        # the node is not a `broadcast_to` / `ActionCable.server.broadcast`
-        # call this plugin recognises. ADR-37: the engine owns the walk.
+        # The broadcast violations for a single call node, or `[]` when the node is not a
+        # `broadcast_to` / `ActionCable.server.broadcast` call this plugin recognises. ADR-37: the
+        # engine owns the walk.
         #
         # @param call_node [Prism::Node]
         # @param channel_index [ChannelIndex]
@@ -61,10 +52,8 @@ module Rigor
           class_name = constant_receiver_name(call_node.receiver)
           return [] if class_name.nil?
 
-          # broadcast_to with a class-name receiver that
-          # doesn't end in "Channel" is almost certainly
-          # not ActionCable — pass through silently to
-          # avoid flagging unrelated `broadcast_to` methods.
+          # broadcast_to with a class-name receiver that doesn't end in "Channel" is almost certainly
+          # not ActionCable — pass through silently to avoid flagging unrelated `broadcast_to` methods.
           return [] unless class_name.end_with?("Channel")
 
           entry = channel_index.find(class_name) || channel_index.find("::#{class_name}")
@@ -127,8 +116,7 @@ module Rigor
           )
         end
 
-        # Renders an `A.b.c` chain as a string (used to
-        # detect `ActionCable.server`). Returns nil for
+        # Renders an `A.b.c` chain as a string (used to detect `ActionCable.server`). Returns nil for
         # non-chained nodes.
         def call_chain_string(node)
           parts = []

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -7,36 +7,27 @@ require_relative "channel_index"
 module Rigor
   module Plugin
     class Actioncable < Rigor::Plugin::Base
-      # Walks the configured channel-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 channel-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 channel, the discoverer:
       #
-      # - Records every public instance-side `def` whose
-      #   name isn't an ActionCable framework hook
-      #   (`subscribed`, `unsubscribed`, `_`-prefixed).
-      #   These are the action methods clients can invoke
+      # - Records every public instance-side `def` whose name isn't an ActionCable framework hook
+      #   (`subscribed`, `unsubscribed`, `_`-prefixed). These are the action methods clients can invoke
       #   via `subscription.perform("action_name", data)`.
-      # - Records every literal-string `stream_from "name"`
-      #   call as a registered stream name.
-      # - Sets `dynamic_streams: true` when the channel has
-      #   ANY non-literal `stream_from` argument (or a
-      #   `stream_for` call) so the analyzer knows it can't
-      #   be sure of every stream name.
+      # - Records every literal-string `stream_from "name"` call as a registered stream name.
+      # - Sets `dynamic_streams: true` when the channel has ANY non-literal `stream_from` argument (or a
+      #   `stream_for` call) so the analyzer knows it can't be sure of every stream name.
       #
       # Intentional limitations:
       #
       # - Direct-superclass match only.
-      # - Public-vs-private is not tracked; the framework
-      #   hooks (`subscribed`/`unsubscribed`) are excluded
-      #   by name. Methods marked `private` after a
-      #   `private` keyword would still appear in the
+      # - Public-vs-private is not tracked; the framework hooks (`subscribed`/`unsubscribed`) are
+      #   excluded by name. Methods marked `private` after a `private` keyword would still appear in the
       #   `action_methods` set.
-      # - `stream_for(record)` (model-scoped streams) is
-      #   recognised as setting `dynamic_streams: true` but
-      #   not introspected further.
+      # - `stream_for(record)` (model-scoped streams) is recognised as setting `dynamic_streams: true`
+      #   but not introspected further.
       class ChannelDiscoverer
         FRAMEWORK_HOOKS = %i[subscribed unsubscribed].to_set.freeze
 
@@ -126,12 +117,9 @@ module Rigor
           )
         end
 
-        # Walks the channel body recursively (so
-        # `stream_from` / `stream_for` calls inside
-        # `subscribed` / helper methods are picked up).
-        # Returns `[Array<String>, bool]` — the literal
-        # stream names + whether any dynamic registration
-        # was seen.
+        # Walks the channel body recursively (so `stream_from` / `stream_for` calls inside `subscribed`
+        # / helper methods are picked up). Returns `[Array<String>, bool]` — the literal stream names +
+        # whether any dynamic registration was seen.
         def collect_stream_registrations(node, names: [], dynamic: false)
           return [names, dynamic] if node.nil?
 
@@ -145,8 +133,7 @@ module Rigor
                 dynamic = true
               end
             when :stream_for
-              # Model-scoped stream — name is computed from
-              # the record at runtime; treat as dynamic.
+              # Model-scoped stream — name is computed from the record at runtime; treat as dynamic.
               dynamic = true
             end
           end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_index.rb

@@ -3,23 +3,16 @@
 module Rigor
   module Plugin
     class Actioncable < Rigor::Plugin::Base
-      # Frozen catalogue of discovered ActionCable channel
-      # classes keyed by qualified class name. Each entry
-      # holds:
+      # Frozen catalogue of discovered ActionCable channel classes keyed by qualified class name. Each
+      # entry holds:
       #
-      # - `action_methods` — the set of public instance
-      #   methods that aren't ActionCable framework hooks
-      #   (`subscribed` / `unsubscribed`). These are the
-      #   methods clients invoke via
+      # - `action_methods` — the set of public instance methods that aren't ActionCable framework hooks
+      #   (`subscribed` / `unsubscribed`). These are the methods clients invoke via
       #   `subscription.perform("action_name", data)`.
-      # - `stream_names` — the set of literal-string stream
-      #   names registered via `stream_from "name"` calls
-      #   inside the channel body. Dynamic registrations
-      #   (`stream_from interpolated_string`) are recorded
-      #   separately as `dynamic_streams: true` so the
-      #   analyzer can suppress unknown-stream warnings on
-      #   any channel that has at least one dynamic
-      #   registration.
+      # - `stream_names` — the set of literal-string stream names registered via `stream_from "name"`
+      #   calls inside the channel body. Dynamic registrations (`stream_from interpolated_string`) are
+      #   recorded separately as `dynamic_streams: true` so the analyzer can suppress unknown-stream
+      #   warnings on any channel that has at least one dynamic registration.
       class ChannelIndex
         Entry = Data.define(:class_name, :file_path, :action_methods, :stream_names, :dynamic_streams) do
           def includes_action?(name)
@@ -60,18 +53,14 @@ module Rigor
           @by_name.keys
         end
 
-        # All literal stream names registered across every
-        # discovered channel.
+        # All literal stream names registered across every discovered channel.
         def all_stream_names
           @entries.flat_map { |e| e.stream_names.to_a }.to_set
         end
 
-        # True when at least one discovered channel uses a
-        # dynamic stream registration. The analyzer treats
-        # this as "we can't be sure any literal name is
-        # missing" and skips the `unknown-stream` warning
-        # entirely — absence of a literal match doesn't prove
-        # the name is wrong.
+        # True when at least one discovered channel uses a dynamic stream registration. The analyzer
+        # treats this as "we can't be sure any literal name is missing" and skips the `unknown-stream`
+        # warning entirely — absence of a literal match doesn't prove the name is wrong.
         def any_dynamic_streams?
           @entries.any?(&:dynamic_streams)
         end

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

@@ -8,14 +8,11 @@ require_relative "actioncable/analyzer"
 
 module Rigor
   module Plugin
-    # rigor-actioncable — validates ActionCable
-    # `<Channel>.broadcast_to(...)` and
-    # `ActionCable.server.broadcast(stream_name, ...)`
-    # call sites against the discovered channel index.
+    # rigor-actioncable — validates ActionCable `<Channel>.broadcast_to(...)` and
+    # `ActionCable.server.broadcast(stream_name, ...)` call sites against the discovered channel index.
     #
     # Tier 3F of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
-    # Statically discovers channel classes by walking
-    # `channel_search_paths` and parsing each file with
+    # Statically discovers channel classes by walking `channel_search_paths` and parsing each file with
     # Prism — no `actioncable` runtime dependency.
     #
     # ## Configuration
@@ -28,33 +25,22 @@ module Rigor
     #
     # ## What it checks
     #
-    # 1. **Channel class existence** — `<X>.broadcast_to(...)`
-    #    where `X` ends in `Channel` must resolve to a
-    #    discovered channel.
-    # 2. **Stream-name registration** —
-    #    `ActionCable.server.broadcast("stream_name", ...)`
-    #    with a literal stream name is checked against
-    #    every discovered channel's `stream_from "..."`
-    #    registrations. The check is suppressed when ANY
-    #    discovered channel uses a dynamic registration
-    #    (`stream_from interpolated_string` or
-    #    `stream_for record`) — the absence of a literal
-    #    match doesn't prove absence.
+    # 1. **Channel class existence** — `<X>.broadcast_to(...)` where `X` ends in `Channel` must resolve
+    #    to a discovered channel.
+    # 2. **Stream-name registration** — `ActionCable.server.broadcast("stream_name", ...)` with a
+    #    literal stream name is checked against every discovered channel's `stream_from "..."`
+    #    registrations. The check is suppressed when ANY discovered channel uses a dynamic registration
+    #    (`stream_from interpolated_string` or `stream_for record`) — the absence of a literal match
+    #    doesn't prove absence.
     #
     # ## Limitations
     #
-    # - **Direct-superclass match only.** Indirect
-    #   inheritance (`AdminChannel < BaseChannel <
-    #   ApplicationCable::Channel`) needs `BaseChannel`
-    #   listed in `channel_base_classes`.
-    # - **Action method invocations are not validated.**
-    #   ActionCable actions are invoked from JS via
-    #   `subscription.perform("action_name", data)`; we
-    #   don't analyse JS so the action-method index is
-    #   informational only (deferred: cross-plugin handoff
-    #   to a JS-side analyzer).
-    # - **`broadcast_to` arity isn't checked.** The method
-    #   takes any record + any data hash; there's no
+    # - **Direct-superclass match only.** Indirect inheritance (`AdminChannel < BaseChannel <
+    #   ApplicationCable::Channel`) needs `BaseChannel` listed in `channel_base_classes`.
+    # - **Action method invocations are not validated.** ActionCable actions are invoked from JS via
+    #   `subscription.perform("action_name", data)`; we don't analyse JS so the action-method index is
+    #   informational only (deferred: cross-plugin handoff to a JS-side analyzer).
+    # - **`broadcast_to` arity isn't checked.** The method takes any record + any data hash; there's no
     #   useful arity envelope.
     class Actioncable < Rigor::Plugin::Base
       manifest(
@@ -70,11 +56,9 @@ module Rigor
         }
       )
 
-      # `watch:` covers every `.rb` file under the channel search paths
-      # so the cache invalidates when channels are added, removed, or
-      # edited (ADR-60 WD3). The dependency descriptor is recorded after
-      # the discoverer runs, so the `io_boundary` reads inside it are
-      # captured too.
+      # `watch:` covers every `.rb` file under the channel search paths so the cache invalidates when
+      # channels are added, removed, or edited (ADR-60 WD3). The dependency descriptor is recorded after
+      # the discoverer runs, so the `io_boundary` reads inside it are captured too.
       producer :channel_index, watch: -> { [[@channel_search_paths, "**/*.rb"]] } do |_params|
         ChannelDiscoverer.new(
           io_boundary: io_boundary,
@@ -88,10 +72,9 @@ module Rigor
         @channel_base_classes = Array(config.fetch("channel_base_classes")).map(&:to_s)
       end
 
-      # File-level only: the load-error emission. Per-call broadcast
-      # validation runs over the engine-owned walk via the node_rule
-      # below (ADR-37). The channel index is lazily loaded + memoised by
-      # `producer_value`, shared by both surfaces.
+      # File-level only: the load-error emission. Per-call broadcast validation runs over the
+      # engine-owned walk via the node_rule below (ADR-37). The channel index is lazily loaded +
+      # memoised by `producer_value`, shared by both surfaces.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:channel_index)
         return [load_error_diagnostic(path)] if index.nil? && producer_error(:channel_index)

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

@@ -5,36 +5,25 @@ require "prism"
 module Rigor
   module Plugin
     class Actionmailer < Rigor::Plugin::Base
-      # Walks a parsed file's AST looking for
-      # `<MailerClass>.<action>(...)` calls and validates
-      # each against the {MailerIndex}. Recognises both:
+      # Walks a parsed file's AST looking for `<MailerClass>.<action>(...)` calls and validates each
+      # against the {MailerIndex}. Recognises both:
       #
-      # - `UserMailer.welcome(user)` — direct action call
-      #   (the call returns a `Mail::Message` ready for
+      # - `UserMailer.welcome(user)` — direct action call (the call returns a `Mail::Message` ready for
       #   `.deliver_now` / `.deliver_later`).
-      # - `UserMailer.with(user: u).welcome` — parametrized
-      #   action call. The `.with(...)` call is treated as a
-      #   pass-through; the action's argument shape is
-      #   validated on the trailing `.welcome` invocation
-      #   even though the receiver is a method-call chain
-      #   rather than a constant.
+      # - `UserMailer.with(user: u).welcome` — parametrized action call. The `.with(...)` call is
+      #   treated as a pass-through; the action's argument shape is validated on the trailing `.welcome`
+      #   invocation even though the receiver is a method-call chain rather than a constant.
       #
-      # The analyzer is purely syntactic: it does not look
-      # at runtime mailer state. Constants that don't appear
-      # in the index are silently ignored — the rule has no
-      # opinion on non-mailer call shapes.
+      # The analyzer is purely syntactic: it does not look at runtime mailer state. Constants that don't
+      # appear in the index are silently ignored — the rule has no opinion on non-mailer call shapes.
       module Analyzer
-        # `.with(...)` is recognised as a forwarding step:
-        # the receiver of `.with(...)` is the mailer class,
-        # so the trailing action-method call's class context
-        # is the same.
+        # `.with(...)` is recognised as a forwarding step: the receiver of `.with(...)` is the mailer
+        # class, so the trailing action-method call's class context is the same.
         WITH_METHODS = %i[with].freeze
 
-        # Ruby method names that ActionMailer reserves on the
-        # class itself. We don't validate against these as
-        # actions even if a mailer happens to override them
-        # — the user almost certainly meant the framework
-        # method, not their own action.
+        # Ruby method names that ActionMailer reserves on the class itself. We don't validate against
+        # these as actions even if a mailer happens to override them — the user almost certainly meant
+        # the framework method, not their own action.
         RESERVED_CLASS_METHODS = %i[
           new allocate name superclass class
           deliver_later deliver_now deliver_later! deliver_now!
@@ -45,16 +34,14 @@ module Rigor
           method instance_method methods
         ].freeze
 
-        # One mailer-call observation. Carries no path/location — the
-        # caller (the `node_rule` block) positions it via
-        # `Plugin::Base#diagnostic`.
+        # One mailer-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
 
-        # The mailer-call violations for a single call node (0..2), or
-        # `[]` when it is not a `<Mailer>.action(...)` call on a known
-        # mailer. ADR-37: the engine owns the walk.
+        # The mailer-call violations for a single call node (0..2), or `[]` when it is not a
+        # `<Mailer>.action(...)` call on a known mailer. ADR-37: the engine owns the walk.
         #
         # @param call_node [Prism::Node]
         # @param mailer_index [MailerIndex]
@@ -71,9 +58,8 @@ module Rigor
 
           action_entry = class_entry.find_action(call_node.name)
           if action_entry.nil?
-            # Skip `unknown-action` when the mailer's include set has any
-            # unresolved module — it may legitimately define the action
-            # (gem-shipped concern, dynamically loaded extension).
+            # Skip `unknown-action` when the mailer's include set has any unresolved module — it may
+            # legitimately define the action (gem-shipped concern, dynamically loaded extension).
             return [] if class_entry.unresolved_includes?
 
             return [unknown_action_violation(call_node, class_entry)]
@@ -86,19 +72,16 @@ module Rigor
         end
 
         def action_call_candidate?(node)
-          # Skip anything that doesn't look like a mailer
-          # action call: no receiver, or a non-constant /
+          # Skip anything that doesn't look like a mailer action call: no receiver, or a non-constant /
           # non-`.with(...)` receiver.
           return false if node.receiver.nil?
 
           mailer_class_for_call(node) ? true : false
         end
 
-        # Extracts the mailer class name when the call's
-        # receiver is either:
+        # Extracts the mailer class name when the call's receiver is either:
         # - A constant (`UserMailer.welcome(...)`), or
-        # - A `.with(...)` call whose receiver is a constant
-        #   (`UserMailer.with(user: u).welcome`).
+        # - A `.with(...)` call whose receiver is a constant (`UserMailer.with(user: u).welcome`).
         def mailer_class_for_call(node)
           receiver = node.receiver
           case receiver
@@ -125,13 +108,10 @@ module Rigor
           actual = args.size
           return nil if action_entry.accepts?(actual)
 
-          # Trailing keyword-hash relaxation. `Notify.foo(uid,
-          # gid, success_count: 5)` is 3 positional args from
-          # Prism's perspective (2 + a KeywordHashNode); the
-          # action's `def foo(uid, gid, success_count:)` has
-          # arity 2. When the call's trailing arg is a kwargs
-          # hash, allow `(actual - 1) ≤ max_arity` so kwargs-
-          # carrying calls don't surface as wrong-arity.
+          # Trailing keyword-hash relaxation. `Notify.foo(uid, gid, success_count: 5)` is 3 positional
+          # args from Prism's perspective (2 + a KeywordHashNode); the action's `def foo(uid, gid,
+          # success_count:)` has arity 2. When the call's trailing arg is a kwargs hash, allow `(actual
+          # - 1) ≤ max_arity` so kwargs-carrying calls don't surface as wrong-arity.
           return nil if args.last.is_a?(Prism::KeywordHashNode) && action_entry.accepts?(actual - 1)
 
           Violation.new(