rigortype 0.4.6 → 0.4.7

data/lib/rigor/type/hash_shape.rb

@@ -28,14 +28,14 @@ module Rigor
       ALLOWED_KEY_CLASSES = [Symbol, String, Integer, Float, TrueClass, FalseClass, NilClass].freeze
       EXTRA_KEY_POLICIES = %i[open closed].freeze
       POLICY_KEYWORDS = %i[required_keys optional_keys read_only_keys extra_keys].freeze
-      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#erase_to_rbs};
-      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#erase_key_prefix}.
+      # A Symbol whose text matches renders as a bare RBS record key (`lang:`) in {#describe} and {#erase_to_rbs};
+      # anything else is a quoted Symbol with a fat arrow (`:"data-contrast" =>`). See {#key_prefix}.
       BARE_RECORD_KEY = /\A[A-Za-z_][A-Za-z0-9_]*[?!]?\z/
 
       attr_reader :pairs, :required_keys, :optional_keys, :read_only_keys, :extra_keys
 
       # @param pairs — ordered map of
-      #   keys to declared types. Keys MUST be Symbol or String;
+      #   keys to declared types. Keys MUST be one of ALLOWED_KEY_CLASSES;
       #   values MUST be Rigor::Type instances. The hash is duped and
       #   frozen at construction; callers MUST NOT mutate the input
       #   afterwards (mutation does not affect the carrier, but the
@@ -74,7 +74,7 @@ module Rigor
         return hash_erasure unless closed?
         return hash_erasure if pairs.each_key.any? { |k| !k.is_a?(Symbol) || !record_key_spellable?(k) }
 
-        rendered = pairs.map { |k, v| "#{erase_key_prefix(k)} #{v.erase_to_rbs}" }
+        rendered = pairs.map { |k, v| "#{key_prefix(k)} #{v.erase_to_rbs}" }
         "{ #{rendered.join(', ')} }"
       end
 
@@ -193,46 +193,27 @@ module Rigor
       def render_entry(key, value, verbosity)
         prefix = []
         prefix << "readonly" if read_only_key?(key)
-        rendered_key = optional_key?(key) ? "?#{render_key(key)}" : render_key(key)
-        prefix << "#{rendered_key}#{key_separator(key)}"
+        prefix << key_prefix(key)
         "#{prefix.join(' ')} #{value.describe(verbosity)}"
       end
 
-      # `describe` is a human-facing display contract (it feeds diagnostic messages, never a parser),
-      # so it keeps the compact `"a":` form for a quoted key. Non-(Symbol|String) scalar keys render in
-      # the natural hashrocket spelling (`1 => 2`, `1.0 => 4`, `nil => 0`) via {#key_separator}; their
-      # `inspect` is the canonical Ruby literal, so describe stays deterministic. The RBS-erasure path
-      # uses {#erase_key_prefix} instead, which must emit a parseable key.
-      def render_key(key)
-        case key
-        when Symbol then key.to_s
-        else key.inspect
-        end
-      end
-
-      # Symbol / String keys keep the compact colon form (`a: 1`, `"k": 2`); every other scalar key uses
-      # the hashrocket (`1 => 2`) — the form the user would have to write in source.
-      def key_separator(key)
-        case key
-        when Symbol, String then ":"
-        else " =>"
-        end
-      end
-
-      # An RBS record entry's key + separator, for the {#erase_to_rbs} path (which only ever sees
-      # Symbol keys — string-keyed shapes degrade to `Hash[...]` before reaching here). A Symbol whose
-      # text is a plain identifier is a bare key with a colon (`lang:`, Ruby keywords like `class`
-      # included). Any other Symbol is a quoted Symbol literal with a fat arrow (`:"data-contrast" =>`):
-      # RBS rejects a bare non-identifier (`data-contrast:`) and a quoted key with a colon
-      # (`"data-contrast":`), and reads `"data-contrast" =>` as the String key, so the written record
-      # declared a key the body never has (#2176). Optional keys carry a leading `?`.
-      def erase_key_prefix(key)
+      # A key and its separator as RBS spells them, with a leading `?` for an optional key. `describe`
+      # (the diagnostic display) and {#erase_to_rbs} (which only ever sees Symbol keys — string-keyed
+      # shapes degrade to `Hash[...]` before reaching here) share it, so a key reads the same in a
+      # message as in the signature it erases to. A Symbol whose text is a plain identifier is a bare
+      # key with a colon (`lang:`, Ruby keywords like `class` included). Any other Symbol is a quoted
+      # Symbol literal with a fat arrow (`:"data-contrast" =>`): RBS rejects a bare non-identifier
+      # (`data-contrast:`) and a quoted key with a colon (`"data-contrast":`), and reads
+      # `"data-contrast" =>` as the String key, so the written record declared a key the body never has
+      # (#2176). Every other key, a String included, is its `inspect` literal with a fat arrow
+      # (`"a-b" =>`, `1 =>`, `nil =>`): the compact `"a-b":` would read as a Symbol key in Ruby, so a
+      # String-vs-Symbol key mismatch in a diagnostic was unreadable (#2235).
+      def key_prefix(key)
         optional = optional_key?(key) ? "?" : ""
-        if BARE_RECORD_KEY.match?(key.to_s)
-          "#{optional}#{key}:"
-        else
-          "#{optional}:#{key.to_s.inspect} =>"
-        end
+        return "#{optional}#{key.inspect} =>" unless key.is_a?(Symbol)
+        return "#{optional}#{key}:" if BARE_RECORD_KEY.match?(key.to_s)
+
+        "#{optional}:#{key.to_s.inspect} =>"
       end
 
       # `String#inspect` escapes `#{`, `#$` and `#@` as `\#`, which RBS's parser does not read back as

data/lib/rigor/type/union.rb

@@ -49,7 +49,7 @@ module Rigor
         end
       end
 
-      # ADR-1 § "RBS round-trip is lossless" + the value-lattice rule `untyped | T = untyped` (every `T`
+      # ADR-1 § "Erasure Must Be Conservative" + the value-lattice rule `untyped | T = untyped` (every `T`
       # is gradually consistent with `untyped`). When any union member erases to `"untyped"`, the whole
       # union erases to `"untyped"` — the RBS surface has no carrier for "Dynamic-origin alongside a
       # static facet", and the gradual-consistency contract guarantees the substitution is sound at every

data/lib/rigor/type_node/identifier.rb

@@ -22,8 +22,7 @@ module Rigor
         # 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).
+        # parser's hot path and are the natural carriers to flow through future Ractor boundaries.
         super(name: name.frozen? ? name : name.dup.freeze)
       end
     end

data/lib/rigor/type_node/resolver_chain.rb

@@ -16,7 +16,7 @@ module Rigor
     # resolver in the chain plus the built-in registry through the
     # same entry point.
     #
-    # Constructed once per `Analysis::Runner.run` from
+    # Built by `Environment#build_name_scope` from
     # `Plugin::Registry#type_node_resolvers`. The chain is
     # immutable and re-entrant; the parser may consult it many
     # times for the same node.

data/lib/rigor/type_node/string_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, "name"]`, `pick_of[Shape, "a" | "b"]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `"name"` inside a type-arg position. The resolver translates
     # this node to a `Type::Constant` carrying the string value.
     # Slice 1 supports double-quoted strings without escape

data/lib/rigor/type_node/symbol_literal.rb

@@ -7,8 +7,7 @@ module Rigor
     # `Pick[T, :name]`, `pick_of[Shape, :a | :b]`, and downstream
     # plugin resolvers that accept literal key selectors.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): the RBS::Extended grammar previously could not tokenise
+    # ADR-13 follow-up: the RBS::Extended grammar previously could not tokenise
     # `:name` inside a type-arg position; this addition closes the
     # gap so `ImportedRefinements.parse` produces a uniform AST.
     # The resolver translates this node to a `Type::Constant`

data/lib/rigor/type_node/union.rb

@@ -5,8 +5,7 @@ module Rigor
     # Union AST node. Carries the nodes of a `T1 | T2 | …` union
     # expression authored at type-arg position.
     #
-    # ADR-13 follow-up (`docs/CURRENT_WORK.md` engineering item
-    # #2): together with {SymbolLiteral} / {StringLiteral} this
+    # ADR-13 follow-up: together with {SymbolLiteral} / {StringLiteral} this
     # closes the parser-side gap that prevented `Pick[T, :a | :b]`
     # / `Pick[T, "a" | "b"]` from tokenising. The resolver pass
     # recurses through each node and folds them via
@@ -16,10 +15,8 @@ module Rigor
     # shadowing `Data#members`, which is the introspection method
     # every `Data.define` mix-in inherits.
     #
-    # Nodes are themselves any of the {TypeNode} carriers — the
-    # parser builds a flat list (left-associative); nested
-    # `Union` nodes are permitted but the parser does not
-    # synthesise them by itself.
+    # The parser builds a flat list (left-associative); the constructor
+    # rejects a nested `Union` node.
     class Union < Data.define(:nodes)
       def initialize(nodes:)
         unless nodes.is_a?(Array) && nodes.size >= 2 && nodes.all? { |m| valid_member?(m) }

data/lib/rigor/value_semantics.rb

@@ -46,16 +46,7 @@ module Rigor
         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:
-        #
-        #   def ==(other)
-        #     other.is_a?(self.class) && class_name == other.class_name && type_args == other.type_args
-        #   end
-        #   alias_method :eql?, :==
-        #   def hash
-        #     [self.class, class_name, type_args].hash
-        #   end
+        # directly and run at hand-written speed on the inference hot path.
         class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
           def ==(other)
             other.is_a?(self.class)#{guard}

data/lib/rigor/version.rb

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

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

@@ -167,8 +167,8 @@ 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.
+        # / helper methods are picked up). Returns the literal stream names and whether any dynamic
+        # registration was seen, as a pair.
         def collect_stream_registrations(node, names: [], dynamic: false)
           return [names, dynamic] if node.nil?
 

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

@@ -11,8 +11,8 @@ module Rigor
       #   `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.
+      #   recorded separately as `dynamic_streams: true`; when any channel has one, the analyzer suppresses
+      #   unknown-stream warnings for the whole run.
       class ChannelIndex
         Entry = Data.define(:class_name, :file_path, :action_methods, :stream_names, :dynamic_streams) do
           def includes_action?(name)
@@ -59,7 +59,6 @@ module Rigor
           @by_name.keys
         end
 
-        # 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

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

@@ -12,7 +12,7 @@ module Rigor
     # 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).
+    # 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
     # Prism — no `actioncable` runtime dependency.
     #

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

@@ -19,9 +19,9 @@ module Rigor
       # - Reads the instance-side `def` nodes and records each one as an action method, capturing the
       #   arity envelope.
       # - For each (class, action) pair, attempts to read every candidate view template under
-      #   `app/views/<mailer_underscore>/<action>.{html,text}.erb`. Existing templates feed the
+      #   `app/views/<mailer_underscore>/<action>.{html,text}.{erb,haml,slim}`. Existing templates feed the
       #   IoBoundary's cache descriptor (so the cache invalidates when the template changes); missing
-      #   templates are recorded so the plugin can surface a diagnostic on the mailer class definition.
+      #   templates are recorded so the plugin can surface a diagnostic on the action's `def`.
       #
       # Limitations (intentional for v0.1.0):
       #
@@ -30,9 +30,6 @@ module Rigor
       # - Action methods are read from the syntactic instance-side `def` list. Methods built via
       #   `define_method`, `private`, or non-action helpers (e.g. methods starting with `_`) are out of
       #   scope. The discoverer filters obvious non-actions (`initialize`, names prefixed with `_`).
-      # - Adding a brand-new view file under `app/views/<mailer>/` will NOT invalidate the cached index
-      #   until something the mailer file touches changes. This is the standard read-tracking trade-off
-      #   — only files we successfully read get digested into the descriptor.
       class MailerDiscoverer
         DEFAULT_VIEWS_ROOT = "app/views"
         VIEW_FORMATS = %w[html text].freeze
@@ -56,22 +53,22 @@ module Rigor
           # Two-pass: first collect every module's defs (for the include-following step), then build
           # per-class entries that pull in actions from include'd modules. GitLab's `Notify` mailer
           # derives every action from `Emails::*` concerns under `app/mailers/emails/`.
-          module_actions = {} # module_fqn => Hash<Symbol, ActionEntry>
-          class_visits = []   # collected (class_name, path, def_nodes, includes)
+          module_actions = {} # fully-qualified module name => its action entries, keyed by method name
+          class_visits = []   # collected (class_name, path, def_nodes, includes, view_exempt)
 
           ruby_files_under(@search_paths).each do |path|
             contents = read_safely(path)
             next if contents.nil?
 
             tree = Prism.parse(contents).value
-            walk_for_mailers(tree, []) do |class_name, def_nodes, includes|
-              class_visits << [class_name, path, def_nodes, includes]
+            walk_for_mailers(tree, []) do |class_name, def_nodes, includes, view_exempt|
+              class_visits << [class_name, path, def_nodes, includes, view_exempt]
             end
             collect_module_actions(tree, [], module_actions)
           end
 
-          entries = class_visits.map do |class_name, path, def_nodes, includes|
-            build_class_entry(class_name, path, def_nodes, includes, module_actions)
+          entries = class_visits.map do |class_name, path, def_nodes, includes, view_exempt|
+            build_class_entry(class_name, path, def_nodes, includes, module_actions, view_exempt)
           end
           MailerIndex.new(entries)
         end
@@ -112,9 +109,9 @@ module Rigor
           full_name = declared_constant_name(class_local_name, lexical_path)
           superclass = strip_root(constant_path_name(node.superclass)) if node.superclass
           if superclass && @base_classes.include?(superclass)
-            def_nodes = collect_action_defs(node.body)
+            def_nodes, view_exempt = collect_action_defs(node.body)
             includes = collect_includes(node.body)
-            yield full_name, def_nodes, includes
+            yield full_name, def_nodes, includes, view_exempt
           end
 
           walk_for_mailers(node.body, [full_name], &) if node.body
@@ -139,8 +136,7 @@ module Rigor
         end
 
         # Walks the AST collecting every module's instance-side def nodes by fully-qualified module
-        # name. The same `collect_action_defs` filter applies (private / `_`-prefixed / callback-target
-        # methods skipped).
+        # name. The same `collect_action_defs` filter applies (private / `_`-prefixed skipped).
         def collect_module_actions(node, lexical_path, accumulator)
           return if node.nil?
 
@@ -151,8 +147,7 @@ module Rigor
 
             full_name = declared_constant_name(local_name, lexical_path)
             if node.body
-              def_nodes = collect_action_defs(node.body)
-              entries = def_nodes.to_h { |def_node| [def_node.name, build_action_entry(def_node)] }
+              entries = collect_action_defs(node.body).first.to_h { |def_node| [def_node.name, build_action_entry(def_node)] }
               # UNIONed, never assigned: a concern module reopened in a second file adds actions rather
               # than replacing the ones the first declaration spelled (same rule as {MailerIndex}'s
               # per-class merge).
@@ -220,40 +215,44 @@ module Rigor
         #   `private` / `protected` (until a `public` switches back), named by `private :foo` /
         #   `protected :foo`, or defined inline (`private def foo`) — Rails builds `action_methods` from the
         #   public instance methods. `public :foo` after a `protected` section makes `foo` an action again.
-        # - methods named as a callback target (`before_action :name`, `after_action`, `around_action`)
+        # Methods named by a callback or `helper_method` macro (see {#collect_callback_names}) stay actions:
+        # Rails dispatches any public instance method, so `Mailer.target` still runs. They are returned as the
+        # view-exempt names, which exempt them from the missing-view check only.
         #
         # Pre-fix, Mastodon's `AdminMailer#process_params` / `set_instance` / `set_locale` /
         # `set_important_headers!` all surfaced as missing-view because the bare `private` keyword
         # wasn't honoured. ~19 false positives across Mastodon's mailers.
-        CALLBACK_DECLARATIONS = %i[before_action after_action around_action].freeze
-        private_constant :CALLBACK_DECLARATIONS
-
-        VISIBILITY_KEYWORDS = %i[public private protected].freeze
+        VISIBILITY_KEYWORDS = %i[public private protected module_function].freeze
         private_constant :VISIBILITY_KEYWORDS
 
+        # Returns `[action_def_nodes, view_exempt_names]`. The view-exempt names are the callback and
+        # `helper_method` targets of the body: they remain actions, and only the missing-view check skips them.
         def collect_action_defs(body)
-          return [] if body.nil?
+          return [[], Set[]] if body.nil?
 
           callback_names = collect_callback_names(body)
           def_nodes, final_visibility = scan_visibility(body)
 
-          def_nodes.select do |node|
+          actions = def_nodes.select do |node|
             next false if node.receiver.is_a?(Prism::SelfNode)
             next false if node.name == :initialize
             next false if node.name.to_s.start_with?("_")
-            next false if callback_names.include?(node.name)
 
             # Rails builds `action_methods` from the PUBLIC instance methods, so only a method whose final
             # visibility is public is an action.
             final_visibility[node.name] == :public
           end
+          [actions, callback_names]
         end
 
-        # Symbol arguments to callback declarations (`before_action :setup`, etc.).
+        # Symbol arguments to the macros the manifest's `per_invocation_non_action_macros` lists (`before_action
+        # :setup`, `after_deliver :record`, `helper_method :fmt`). The `skip_*` forms are left out, since
+        # `skip_before_action :x` names a callback a parent defined and does not exempt `x` from anything (#2319).
         def collect_callback_names(body)
+          macros = Actionmailer.manifest.per_invocation_non_action_macros.reject { |macro| macro.start_with?("skip_") }
           names = []
           body.rigor_each_child do |node|
-            next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && CALLBACK_DECLARATIONS.include?(node.name)
+            next unless node.is_a?(Prism::CallNode) && node.receiver.nil? && macros.include?(node.name)
 
             (node.arguments&.arguments || []).each do |arg|
               symbol = Rigor::Source::Literals.symbol(arg)
@@ -265,8 +264,8 @@ module Rigor
 
         # Walks the class body in source order and returns `[def_nodes, final_visibility]`: every `def` the body
         # spells (a direct statement or the inline argument of a visibility call, `private def x`), and the
-        # visibility each method name ends with. A bare `public` / `private` / `protected` sets the default for
-        # the defs after it; `private :x` / `public :x` / `protected def x` set that one method, whichever side of
+        # visibility each method name ends with. A bare `public` / `private` / `protected` / `module_function` sets
+        # the default for the defs after it; `private :x` / `public :x` / `protected def x` set that one method, whichever side of
         # its `def` they fall on in the source, and the last statement to name a method wins.
         def scan_visibility(body)
           def_nodes = []
@@ -286,7 +285,8 @@ module Rigor
           [def_nodes, final_visibility]
         end
 
-        # Applies one receiverless `public` / `private` / `protected` call and returns the (possibly new) default.
+        # Applies one receiverless `public` / `private` / `protected` / `module_function` call and returns the
+        # (possibly new) default.
         def apply_visibility_call(node, default, def_nodes, final_visibility)
           return default unless node.receiver.nil? && VISIBILITY_KEYWORDS.include?(node.name)
 
@@ -304,9 +304,9 @@ module Rigor
           default
         end
 
-        def build_class_entry(class_name, file_path, def_nodes, includes = [], module_actions = {})
+        def build_class_entry(class_name, file_path, def_nodes, includes = [], module_actions = {}, view_exempt = Set[])
           actions = def_nodes.to_h do |def_node|
-            entry = build_action_entry(def_node)
+            entry = build_action_entry(def_node, view_exempt: view_exempt.include?(def_node.name))
             [entry.method_name, entry]
           end
 
@@ -326,7 +326,7 @@ module Rigor
             end
           end
 
-          missing_views = actions.keys.reject { |action| view_exists?(class_name, action) }
+          missing_views = actions.reject { |_, entry| entry.view_exempt }.keys.reject { |action| view_exists?(class_name, action) }
 
           MailerIndex::ClassEntry.new(
             class_name: class_name,
@@ -337,7 +337,7 @@ module Rigor
           )
         end
 
-        def build_action_entry(def_node)
+        def build_action_entry(def_node, view_exempt: false)
           parameters = def_node.parameters
           location = def_node.name_loc
 
@@ -346,7 +346,8 @@ module Rigor
               method_name: def_node.name,
               min_arity: 0, max_arity: 0,
               def_line: location.start_line,
-              def_column: location.start_column + 1
+              def_column: location.start_column + 1,
+              view_exempt: view_exempt
             )
           end
 
@@ -359,7 +360,8 @@ module Rigor
             min_arity: required_count,
             max_arity: rest_present ? Float::INFINITY : required_count + optional_count,
             def_line: location.start_line,
-            def_column: location.start_column + 1
+            def_column: location.start_column + 1,
+            view_exempt: view_exempt
           )
         end
 

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

@@ -11,7 +11,9 @@ module Rigor
       #   the mailer file)
       # - the list of `(action, location)` pairs whose view templates are missing from `app/views/`
       class MailerIndex
-        ActionEntry = Data.define(:method_name, :min_arity, :max_arity, :def_line, :def_column) do
+        # `view_exempt` marks a callback or `helper_method` target: still an action (Rails dispatches it), but
+        # left out of the missing-view check.
+        ActionEntry = Data.define(:method_name, :min_arity, :max_arity, :def_line, :def_column, :view_exempt) do
           def arity_label
             return "#{min_arity}+" if max_arity == Float::INFINITY
             return min_arity.to_s if min_arity == max_arity
@@ -67,7 +69,7 @@ module Rigor
         end
 
         # @param file_path — absolute path of a mailer file (canonicalised — see plugin entry's
-        #   `harvest`)
+        #   `canonical_path`)
         def find_by_file(file_path)
           @entries.find { |entry| entry.file_path == file_path }
         end

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

@@ -11,7 +11,7 @@ module Rigor
   module Plugin
     # rigor-actionmailer — validates `Mailer.action(args)` call sites and detects missing view templates.
     #
-    # Tier 1C of the [Rails plugins roadmap](../../../../docs/design/20260508-rails-plugins-roadmap.md).
+    # Tier 1C of the [Rails plugins roadmap](../../../../../docs/design/20260508-rails-plugins-roadmap.md).
     # Statically discovers mailer classes by walking `mailer_search_paths` and parsing each file with
     # Prism — no `action_mailer` runtime dependency.
     #
@@ -38,8 +38,6 @@ module Rigor
     # - Direct-superclass match only.
     # - Action methods are read from the syntactic instance-side `def` list. `define_method` actions are
     #   out of scope.
-    # - Adding a brand-new view file does not invalidate the cache until something the mailer file
-    #   touches changes.
     class Actionmailer < Rigor::Plugin::Base
       manifest(
         id: "actionmailer",
@@ -55,7 +53,11 @@ module Rigor
         #
         # Bumped 2026-10-23 (#2308) — a method after a bare `protected` is no longer an action, so a cached 0.5.0
         # index can list protected helpers as actions (and as missing-view candidates).
-        version: "0.5.1",
+        #
+        # Bumped 2026-10-26 (#2319) — a method named by a callback or `helper_method` macro (`prepend_before_action`,
+        # `after_deliver`, `helper_method`, ...) no longer draws a missing-view row, and a method defined after a bare
+        # `module_function` is no longer an action, so a cached 0.5.1 index can carry those rows and actions.
+        version: "0.5.2",
         description: "Validates ActionMailer call shape and view template existence.",
         config_schema: {
           "mailer_search_paths" => { kind: :array, default: ["app/mailers"] },

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

@@ -102,7 +102,7 @@ module Rigor
 
         # Phase 2 — filter-chain validation for ONE filter-DSL call (`before_action :name`, …). The
         # enclosing controller is read from the node-rule `NodeContext` ancestors, looked up in the
-        # controller index to get the effective method set (including one level of inheritance), and
+        # controller index to get the effective method set (including inherited methods), and
         # each filter name reference is validated against it. Calls outside a known controller
         # contribute nothing.
         #

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_index.rb

@@ -6,8 +6,7 @@ module Rigor
       # Per-run frozen index of discovered controllers AND concerns (modules) in
       # `controller_search_paths`. Phase 2 (filter-chain validation) consults the index at every call
       # site to check that `before_action :name` references a method that actually exists on the
-      # controller, its parent (one level of inheritance), or any module the controller or its ancestor
-      # chain transitively `include`s.
+      # controller, any ancestor, or any module the controller or an ancestor transitively `include`s.
       #
       # Real-world example (Mastodon):
       #   AccountsController < ApplicationController
@@ -169,9 +168,6 @@ module Rigor
         # and returning the first candidate that has an entry in the index. When nothing resolves,
         # return the original name unchanged — the caller treats unresolved entries as "gem-shipped
         # concerns we cannot see" (the `unresolved_include?` predicate).
-        #
-        # `name` may already be qualified (`Foo::Bar`); we only try lexical prefixing when the
-        # unqualified first segment doesn't match a top-level entry.
         def resolve_constant_lexically(name, enclosing)
           return nil if name.nil?
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_scan.rb

@@ -83,7 +83,6 @@ module Rigor
           end.to_h
         end
 
-        # Every implicit-self `render` call node under `node`, at any depth.
         def each_render(node, &)
           return unless node.is_a?(Prism::Node)
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/erb_compiler.rb

@@ -229,7 +229,8 @@ module Rigor
         # been measured. Resolved ONCE per process: a failed resolution is as memoised as a successful
         # one, so a project without Erubi does not pay a `$LOAD_PATH` walk per template.
         #
-        # `Isolation.require_with_target_bundle` is [ADR-90](../../../../../../docs/adr/90-target-library-resolution-from-project-bundle.md)'s
+        # `Isolation.require_with_target_bundle` is
+        # [ADR-90](../../../../../../docs/adr/90-target-library-resolution-from-project-bundle.md)'s
         # path — Rigor's own gem env first, then the analysed project's bundle, `$LOAD_PATH` appended and
         # only on a failed require. Erubi is not a Rigor dependency and is never added to one. Any load
         # failure is equally "no Erubi here"; stdlib `ERB` answers the same question, so nothing is

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/view_assigns.rb

@@ -18,7 +18,7 @@ module Rigor
       # ## The inference is deliberately narrow
       #
       # Only `@user = Model.find(...)`-shaped assignments contribute, and only for a closed set of
-      # constructors and finders that **cannot return nil** — `find`, `find_by!`, `sole`, `first!`,
+      # constructors and finders that **cannot return nil** — `find`, `find_by!`, `find_sole_by`, `sole`, `first!`,
       # `last!`, `new`, `create`, `create!`. A seeded type is a claim the engine acts on, and a wrong one
       # is worse than none: seeding `@user` from `find_by` (which returns nil at runtime) would hand the
       # flow rules a non-nil nominal and license folds that draw diagnostics on correct templates — the