rigortype 0.2.7 → 0.2.9

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

@@ -7,15 +7,11 @@ require_relative "controller_index"
 module Rigor
   module Plugin
     class Actionpack < Rigor::Plugin::Base
-      # Walks `controller_search_paths` building a
-      # {ControllerIndex} of `(class_name, methods,
-      # parent_class_name)` triples. Used by Phase 2 (filter
-      # chains) to validate that `before_action :name`
-      # references a method defined on the controller or its
-      # ancestor chain.
+      # Walks `controller_search_paths` building a {ControllerIndex} of `(class_name, methods,
+      # parent_class_name)` triples. Used by Phase 2 (filter chains) to validate that `before_action
+      # :name` references a method defined on the controller or its ancestor chain.
       #
-      # Two declaration shapes are recognised and qualified
-      # the same way:
+      # Two declaration shapes are recognised and qualified the same way:
       #
       #   class Admin::AccountsController < BaseController
       #     # → registered as "Admin::AccountsController"
@@ -26,25 +22,18 @@ module Rigor
       #     end
       #   end
       #
-      # Pre-fix the nested form ignored the enclosing `module
-      # Admin` and registered the inner class as bare
-      # `"AccountsController"`, overwriting the top-level
-      # `app/controllers/accounts_controller.rb` entry. Mastodon
-      # has both shapes for the same logical name (top-level
-      # `AccountsController` + `Admin::AccountsController` +
-      # `Api::V1::AccountsController`) and the overwrite caused
-      # the wrong inheritance / method set to flow downstream,
-      # producing dozens of false `unknown-filter-method`
+      # Pre-fix the nested form ignored the enclosing `module Admin` and registered the inner class as
+      # bare `"AccountsController"`, overwriting the top-level `app/controllers/accounts_controller.rb`
+      # entry. Mastodon has both shapes for the same logical name (top-level `AccountsController` +
+      # `Admin::AccountsController` + `Api::V1::AccountsController`) and the overwrite caused the wrong
+      # inheritance / method set to flow downstream, producing dozens of false `unknown-filter-method`
       # diagnostics.
       #
-      # Multi-level inheritance is also walked: `Admin::AccountsController
-      # < BaseController < ApplicationController` resolves
-      # methods from all three. Cycle-safe via a visited set.
-      # The parent-name lookup is **lexically scoped** — a bare
-      # `BaseController` reference inside `module Admin` first
-      # tries `Admin::BaseController`, then falls through to
-      # top-level `BaseController`, matching Ruby's constant-
-      # resolution semantics.
+      # Multi-level inheritance is also walked: `Admin::AccountsController < BaseController <
+      # ApplicationController` resolves methods from all three. Cycle-safe via a visited set. The
+      # parent-name lookup is **lexically scoped** — a bare `BaseController` reference inside `module
+      # Admin` first tries `Admin::BaseController`, then falls through to top-level `BaseController`,
+      # matching Ruby's constant-resolution semantics.
       class ControllerDiscoverer
         def initialize(io_boundary:, search_paths:)
           @io_boundary = io_boundary
@@ -84,15 +73,12 @@ module Rigor
           nil
         end
 
-        # Walks every `ClassNode` / `ModuleNode` in the AST,
-        # yielding `[declaration_node, enclosing_namespace_array]`
-        # for each. `enclosing` is the chain of module / class
-        # qualifiers OUTSIDE the yielded declaration (e.g. for
-        # `module Admin; class AccountsController; end; end`
-        # the inner class yields with enclosing
-        # `["Admin"]`). The yielded declaration's own segment
-        # is added to the chain for its body's recursion so
-        # constants nested two levels deep qualify correctly.
+        # Walks every `ClassNode` / `ModuleNode` in the AST, yielding `[declaration_node,
+        # enclosing_namespace_array]` for each. `enclosing` is the chain of module / class qualifiers
+        # OUTSIDE the yielded declaration (e.g. for `module Admin; class AccountsController; end; end`
+        # the inner class yields with enclosing `["Admin"]`). The yielded declaration's own segment is
+        # added to the chain for its body's recursion so constants nested two levels deep qualify
+        # correctly.
         def walk_declarations(node, namespace:, &)
           return unless node.is_a?(Prism::Node)
 
@@ -109,11 +95,9 @@ module Rigor
           end
         end
 
-        # The segments contributed by a declaration to the
-        # qualifier chain of its body. For `class A::B` this is
-        # `["A", "B"]`; for `module Outer` it is `["Outer"]`.
-        # Returns `[]` for an anonymous declaration the walker
-        # cannot qualify.
+        # The segments contributed by a declaration to the qualifier chain of its body. For `class A::B`
+        # this is `["A", "B"]`; for `module Outer` it is `["Outer"]`. Returns `[]` for an anonymous
+        # declaration the walker cannot qualify.
         def namespace_segments_for(declaration_node)
           path = qualified_name_for(declaration_node.constant_path)
           path ? path.split("::") : []
@@ -133,13 +117,10 @@ module Rigor
           )
         end
 
-        # Resolves the declared name against the enclosing
-        # namespace chain. A `ConstantPathNode` (e.g.
-        # `Admin::Foo` in `class Admin::Foo`) is already
-        # absolute and ignores the enclosing chain. A
-        # `ConstantReadNode` (bare `Foo` in `module Admin;
-        # class Foo`) is qualified against the chain so the
-        # name becomes `Admin::Foo`.
+        # Resolves the declared name against the enclosing namespace chain. A `ConstantPathNode` (e.g.
+        # `Admin::Foo` in `class Admin::Foo`) is already absolute and ignores the enclosing chain. A
+        # `ConstantReadNode` (bare `Foo` in `module Admin; class Foo`) is qualified against the chain so
+        # the name becomes `Admin::Foo`.
         def qualified_name_with_enclosing(node, enclosing)
           return nil unless node.is_a?(Prism::Node)
 
@@ -165,11 +146,9 @@ module Rigor
           accumulator
         end
 
-        # Collects the qualified-constant targets passed to
-        # `include` calls inside the body. Stops at nested
-        # `ClassNode` / `ModuleNode` boundaries so a class
-        # declared inside a concern doesn't pull the concern's
-        # includes into itself.
+        # Collects the qualified-constant targets passed to `include` calls inside the body. Stops at
+        # nested `ClassNode` / `ModuleNode` boundaries so a class declared inside a concern doesn't pull
+        # the concern's includes into itself.
         def collect_include_targets(node, accumulator = [])
           return accumulator unless node.is_a?(Prism::Node)
           return accumulator if node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)

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

@@ -3,13 +3,11 @@
 module Rigor
   module Plugin
     class Actionpack < Rigor::Plugin::Base
-      # 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.
+      # 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.
       #
       # Real-world example (Mastodon):
       #   AccountsController < ApplicationController
@@ -19,23 +17,17 @@ module Rigor
       #   SignatureVerification < module
       #     def require_account_signature!        # ← the filter target
       #
-      # The include chain spans three concern modules.
-      # `effective_methods_for("AccountsController")` walks all
-      # of them transitively to collect `require_account_signature!`.
+      # The include chain spans three concern modules. `effective_methods_for("AccountsController")`
+      # walks all of them transitively to collect `require_account_signature!`.
       class ControllerIndex
-        # `defined_methods` carries the discovered method names
-        # (Symbols). `included_module_names` carries the constant
-        # names passed to `include X` calls inside the
-        # class / module body (Strings). `parent_class_name` is
-        # the immediate superclass (nil for plain modules).
-        # `enclosing_namespace` is the qualifier chain of the
-        # declaration's *lexical* enclosing scope (e.g.
-        # `["Admin"]` for an `Admin::Foo` declared via
-        # `module Admin; class Foo; end; end`). Used by the
-        # index's parent / module lookup to try lexically-scoped
-        # constant resolution before falling through to the
-        # top-level form — Ruby's constant lookup walks the
-        # enclosing scope chain before `Object`.
+        # `defined_methods` carries the discovered method names (Symbols). `included_module_names`
+        # carries the constant names passed to `include X` calls inside the class / module body
+        # (Strings). `parent_class_name` is the immediate superclass (nil for plain modules).
+        # `enclosing_namespace` is the qualifier chain of the declaration's *lexical* enclosing scope
+        # (e.g. `["Admin"]` for an `Admin::Foo` declared via `module Admin; class Foo; end; end`). Used
+        # by the index's parent / module lookup to try lexically-scoped constant resolution before
+        # falling through to the top-level form — Ruby's constant lookup walks the enclosing scope chain
+        # before `Object`.
         Entry = Data.define(:class_name, :defined_methods, :parent_class_name, :included_module_names,
                             :enclosing_namespace)
 
@@ -51,20 +43,15 @@ module Rigor
           @entries[class_name]
         end
 
-        # Resolves the **effective** method set for a controller,
-        # including methods contributed by every module the
-        # controller / any ancestor transitively `include`s AND
-        # methods inherited from the ancestor chain (unbounded
-        # depth, cycle-safe via a visited set).
+        # Resolves the **effective** method set for a controller, including methods contributed by
+        # every module the controller / any ancestor transitively `include`s AND methods inherited from
+        # the ancestor chain (unbounded depth, cycle-safe via a visited set).
         #
-        # Parent / module lookups are **lexically scoped** — a
-        # bare `BaseController` reference inside `module Admin`
-        # first tries `Admin::BaseController`, then falls
-        # through to the top-level `BaseController`. Matches
-        # Ruby's constant-resolution semantics. Without this an
-        # `Admin::Foo < BaseController` declaration would
-        # incorrectly walk the top-level `BaseController` even
-        # when an `Admin::BaseController` exists.
+        # Parent / module lookups are **lexically scoped** — a bare `BaseController` reference inside
+        # `module Admin` first tries `Admin::BaseController`, then falls through to the top-level
+        # `BaseController`. Matches Ruby's constant-resolution semantics. Without this an `Admin::Foo <
+        # BaseController` declaration would incorrectly walk the top-level `BaseController` even when an
+        # `Admin::BaseController` exists.
         def effective_methods_for(class_name)
           seen_classes = {}
           seen_modules = {}
@@ -81,11 +68,9 @@ module Rigor
               collect_methods(resolved_include, seen_modules, methods)
             end
             next_parent = entry.parent_class_name
-            # Same self-reference guard as `unresolved_include?`:
-            # `class ActivityPub::ApplicationController <
-            # ::ApplicationController` lexically resolves
-            # `ApplicationController` to itself; fall back to
-            # the unprefixed top-level name in that case.
+            # Same self-reference guard as `unresolved_include?`: `class ActivityPub::ApplicationController
+            # < ::ApplicationController` lexically resolves `ApplicationController` to itself; fall back
+            # to the unprefixed top-level name in that case.
             current = if next_parent
                         resolved = resolve_constant_lexically(next_parent, entry.enclosing_namespace)
                         resolved == current ? next_parent.sub(/\A::/, "") : resolved
@@ -94,30 +79,23 @@ module Rigor
           methods.uniq.freeze
         end
 
-        # @return [Boolean] true when the class has at least one
-        #   include OR parent class we couldn't resolve in the
-        #   index (typically a gem-shipped concern such as Devise's
-        #   `Devise::Controllers::Helpers`, or a gem-shipped
-        #   parent controller such as `Devise::ConfirmationsController`
-        #   or `Doorkeeper::AuthorizedApplicationsController`).
-        #   Phase 2 uses this to downgrade `unknown-filter-method`
-        #   to silence — the unresolved module / parent may
-        #   legitimately contribute the filter (either directly,
-        #   or via its own ancestor chain which the static
-        #   analyzer cannot follow), and there's no way to verify.
+        # @return [Boolean] true when the class has at least one include OR parent class we couldn't
+        #   resolve in the index (typically a gem-shipped concern such as Devise's
+        #   `Devise::Controllers::Helpers`, or a gem-shipped parent controller such as
+        #   `Devise::ConfirmationsController` or `Doorkeeper::AuthorizedApplicationsController`). Phase
+        #   2 uses this to downgrade `unknown-filter-method` to silence — the unresolved module / parent
+        #   may legitimately contribute the filter (either directly, or via its own ancestor chain which
+        #   the static analyzer cannot follow), and there's no way to verify.
         def unresolved_include?(class_name)
           entry = @entries[class_name]
           return false if entry.nil?
 
-          # Walk the full ancestor chain. `Admin::Foo <
-          # BaseController < ApplicationController` should report
-          # an unresolved include if ANY of the three references
-          # a gem-shipped concern OR a gem-shipped parent class
-          # we cannot index. The first iteration's `current_entry`
-          # is always resolved (caller verified `known?`); a nil
-          # `current_entry` on a subsequent iteration means the
-          # AST-side `< Parent` reached a gem-shipped class
-          # whose ancestor methods are invisible to us.
+          # Walk the full ancestor chain. `Admin::Foo < BaseController < ApplicationController` should
+          # report an unresolved include if ANY of the three references a gem-shipped concern OR a
+          # gem-shipped parent class we cannot index. The first iteration's `current_entry` is always
+          # resolved (caller verified `known?`); a nil `current_entry` on a subsequent iteration means
+          # the AST-side `< Parent` reached a gem-shipped class whose ancestor methods are invisible to
+          # us.
           seen_classes = {}
           current = class_name
           first = true
@@ -136,15 +114,11 @@ module Rigor
               return true if resolved.nil? || !@entries.key?(resolved)
             end
             next_parent = current_entry.parent_class_name
-            # Avoid lexically resolving to ourselves. `class
-            # ActivityPub::ApplicationController < ::ApplicationController`
-            # would otherwise resolve `ApplicationController` (in
-            # the lexical scope `["ActivityPub"]`) to
-            # `ActivityPub::ApplicationController` and short-
-            # circuit the walk before reaching the top-level
-            # parent. When the lexical match is the current
-            # class itself, fall back to the unprefixed
-            # top-level name.
+            # Avoid lexically resolving to ourselves. `class ActivityPub::ApplicationController <
+            # ::ApplicationController` would otherwise resolve `ApplicationController` (in the lexical
+            # scope `["ActivityPub"]`) to `ActivityPub::ApplicationController` and short-circuit the walk
+            # before reaching the top-level parent. When the lexical match is the current class itself,
+            # fall back to the unprefixed top-level name.
             current = if next_parent
                         resolved = resolve_constant_lexically(next_parent, current_entry.enclosing_namespace)
                         resolved == current ? next_parent.sub(/\A::/, "") : resolved
@@ -181,37 +155,28 @@ module Rigor
           end
         end
 
-        # Ruby's constant-lookup walk: a bare constant name
-        # inside `module Admin` first tries `Admin::Const`,
-        # then walks outward, and finally falls through to
-        # top-level `Const`. We approximate that by trying
-        # the candidate `enclosing + name` chains from
-        # deepest to shallowest, 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).
+        # Ruby's constant-lookup walk: a bare constant name inside `module Admin` first tries
+        # `Admin::Const`, then walks outward, and finally falls through to top-level `Const`. We
+        # approximate that by trying the candidate `enclosing + name` chains from deepest to shallowest,
+        # 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.
+        # `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?
 
-          # A leading `::` denotes the top-level constant
-          # explicitly (`< ::ApplicationController`). Strip it
-          # for index lookup — the discoverer registers entries
-          # under their unprefixed name. Without this strip a
-          # `class ActivityPub::ApplicationController <
-          # ::ApplicationController` parent never resolved.
+          # A leading `::` denotes the top-level constant explicitly (`< ::ApplicationController`).
+          # Strip it for index lookup — the discoverer registers entries under their unprefixed name.
+          # Without this strip a `class ActivityPub::ApplicationController < ::ApplicationController`
+          # parent never resolved.
           name = name.sub(/\A::/, "")
 
           # Constant already absolute or no enclosing scope.
           return name if enclosing.nil? || enclosing.empty?
 
-          # Try the deepest enclosing scope first, walking
-          # outward. `enclosing = ["A", "B"]` produces
+          # Try the deepest enclosing scope first, walking outward. `enclosing = ["A", "B"]` produces
           # candidates `["A::B::name", "A::name", "name"]`.
           enclosing.length.downto(0).each do |depth|
             prefix = enclosing[0, depth]