rigortype 0.2.7 → 0.2.9

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

@@ -8,27 +8,21 @@ require_relative "helper_table"
 module Rigor
   module Plugin
     class RailsRoutes < Rigor::Plugin::Base
-      # Statically interprets `config/routes.rb`'s DSL via
-      # Prism — never executes the file. The interpreter is
-      # deliberately narrow; it covers the subset documented
-      # in the plugin's README and degrades silently on
-      # constructs it doesn't recognise.
+      # Statically interprets `config/routes.rb`'s DSL via Prism — never executes the file. The interpreter
+      # is deliberately narrow; it covers the subset documented in the plugin's README and degrades
+      # silently on constructs it doesn't recognise.
       #
-      # Recognised DSL surface (per the Rails-plugins
-      # roadmap):
+      # Recognised DSL surface (per the Rails-plugins roadmap):
       #
-      # - `Rails.application.routes.draw do ... end` (entry
-      #   block; the body is interpreted)
+      # - `Rails.application.routes.draw do ... end` (entry block; the body is interpreted)
       # - `resources :name [, only: [...] | except: [...]]`
       # - `resource :name`
       # - `get/post/patch/put/delete "path", to:, as:`
       # - `root to: "..."` / `root "..."`
       # - `scope "path", as: :name do ... end` (with `as:` key)
       # - One level of `namespace :foo do ... end`
-      # - One level of nested `resources` (`resources :users
-      #   do; resources :posts; end`)
-      # - `member do ... end` / `collection do ... end`
-      #   inside `resources`
+      # - One level of nested `resources` (`resources :users do; resources :posts; end`)
+      # - `member do ... end` / `collection do ... end` inside `resources`
       #
       # Out of scope for v0.1.0 (silent skips):
       #
@@ -40,12 +34,10 @@ module Rigor
       module RoutesParser
         # Standard resource actions Rails generates by default.
         DEFAULT_RESOURCE_ACTIONS = %i[index show new create edit update destroy].freeze
-        # Default actions for `resource` (singular) — no index,
-        # no `:id` segment.
+        # Default actions for `resource` (singular) — no index, no `:id` segment.
         DEFAULT_SINGULAR_ACTIONS = %i[show new create edit update destroy].freeze
 
-        # Helper-name conventions per action. `:show` and
-        # `:update` / `:destroy` share the singular-form
+        # Helper-name conventions per action. `:show` and `:update` / `:destroy` share the singular-form
         # helper (Rails dedupes).
         ACTION_HTTP_METHODS = {
           index: :get,
@@ -64,17 +56,17 @@ module Rigor
         #   draw partial from `config/routes/name.rb`. Returns file contents
         #   or nil when the file is absent.
         # @return [HelperTable]
-        def parse(contents, file_reader: nil, custom_helpers: [])
+        def parse(contents, file_reader: nil, custom_helpers: [], grape_prefixes: [])
           parse_result = Prism.parse(contents)
-          return HelperTable.new([], custom_helpers: custom_helpers) unless parse_result.errors.empty?
+          unless parse_result.errors.empty?
+            return HelperTable.new([], custom_helpers: custom_helpers, grape_prefixes: grape_prefixes)
+          end
 
           context = Context.new(file_reader: file_reader)
           interpret(parse_result.value, context)
 
-          # Apply name-transform alias rules discovered during
-          # the walk (the `direct(name.sub(X, Y)) do |...| send(
-          # "#{name}_url", ...) end` GitLab pattern — see
-          # `collect_alias_rules` below).
+          # Apply name-transform alias rules discovered during the walk (the `direct(name.sub(X, Y)) do
+          # |...| send("#{name}_url", ...) end` GitLab pattern — see `collect_alias_rules` below).
           apply_alias_rules(context)
 
           # Each helper has both `_path` and `_url` forms.
@@ -90,24 +82,19 @@ module Rigor
               )
             ]
           end
-          HelperTable.new(paired, custom_helpers: custom_helpers, devise_resources: context.devise_resources)
+          HelperTable.new(paired, custom_helpers: custom_helpers, devise_resources: context.devise_resources,
+                                  grape_prefixes: grape_prefixes)
         end
 
-        # For every registered alias rule `(from_str, to_str,
-        # arity_delta)`, find every existing entry whose name
-        # contains `from_str` and register an aliased entry with
-        # `from_str → to_str` substitution. The pattern matches
-        # GitLab's shorthand-helper idiom: a loop over registered
-        # route names that invokes `direct(new_name) do |project,
-        # *args| send("#{name}_url", project&.namespace,
-        # project, *args) end` where `new_name = name.sub(FROM,
-        # TO)`. The direct block extracts the namespace from
-        # `project` and forwards the rest, so the alias's arity
-        # is one LESS than the original helper's
-        # (`namespace_project_blob_path(namespace_id, project_id,
-        # blob_id)` → `project_blob_path(project, blob_id)`).
-        # We register each alias under the original entry's
-        # arity AND `original - 1` to span both interpretations.
+        # For every registered alias rule `(from_str, to_str, arity_delta)`, find every existing entry whose
+        # name contains `from_str` and register an aliased entry with `from_str → to_str` substitution. The
+        # pattern matches GitLab's shorthand-helper idiom: a loop over registered route names that invokes
+        # `direct(new_name) do |project, *args| send("#{name}_url", project&.namespace, project, *args) end`
+        # where `new_name = name.sub(FROM, TO)`. The direct block extracts the namespace from `project` and
+        # forwards the rest, so the alias's arity is one LESS than the original helper's
+        # (`namespace_project_blob_path(namespace_id, project_id, blob_id)` →
+        # `project_blob_path(project, blob_id)`). We register each alias under the original entry's arity
+        # AND `original - 1` to span both interpretations.
         def apply_alias_rules(context)
           return if context.alias_rules.empty?
 
@@ -119,10 +106,8 @@ module Rigor
               new_name = entry.name.sub(from, to)
               next if new_name == entry.name
 
-              # Register at original arity AND at arity-1 so the
-              # common GitLab `|project, *args|` pattern (which
-              # collapses namespace_id + project_id into project)
-              # passes the arity check.
+              # Register at original arity AND at arity-1 so the common GitLab `|project, *args|` pattern
+              # (which collapses namespace_id + project_id into project) passes the arity check.
               [entry.arity, [entry.arity - 1, 0].max].uniq.each do |arity|
                 aliases << HelperTable::Entry.new(
                   name: new_name, arity: arity,
@@ -135,9 +120,8 @@ module Rigor
           context.entries.concat(aliases)
         end
 
-        # Per-parse mutable accumulator. Tracks the current
-        # nesting prefix (namespaces + parent resource) and the
-        # entries collected so far.
+        # Per-parse mutable accumulator. Tracks the current nesting prefix (namespaces + parent resource)
+        # and the entries collected so far.
         class Context
           attr_reader :entries, :file_reader, :devise_resources, :alias_rules
 
@@ -149,22 +133,15 @@ module Rigor
             # - `{ kind: :scope, parent: "user", arity_segments: [":user_id"] }`
             # - `{ kind: :as_scope, name: "event", path: "/:event_slug", arity: 1 }`
             @stack = []
-            # Devise resource segments (singularised) declared
-            # via `devise_for :resource`. Drives the
+            # Devise resource segments (singularised) declared via `devise_for :resource`. Drives the
             # OmniAuth-helper recognition in `HelperTable#omniauth_match?`.
             @devise_resources = []
-            # Registered `concern :name do ... end` blocks.
-            # Keyed by Symbol name; value is the block's body
-            # node. `resources :foo, concerns: :name do ... end`
-            # replays the body at the resource's site.
+            # Registered `concern :name do ... end` blocks. Keyed by Symbol name; value is the block's body
+            # node. `resources :foo, concerns: :name do ... end` replays the body at the resource's site.
             @concerns = {}
-            # `(from_str, to_str)` pairs collected from
-            # iterative `direct(name.sub(FROM, TO)) do ... end`
-            # patterns. Applied after parsing via
-            # `apply_alias_rules` to generate substituted-name
-            # aliases for every matching entry — closes
-            # GitLab's `namespace_project_*` → `project_*`
-            # shorthand idiom.
+            # `(from_str, to_str)` pairs collected from iterative `direct(name.sub(FROM, TO)) do ... end`
+            # patterns. Applied after parsing via `apply_alias_rules` to generate substituted-name aliases
+            # for every matching entry — closes GitLab's `namespace_project_*` → `project_*` shorthand idiom.
             @alias_rules = []
           end
 
@@ -200,17 +177,12 @@ module Rigor
             @stack.pop
           end
 
-          # `resource :foo do ... end` (SINGULAR resource) —
-          # adds the resource name to the helper prefix and
-          # path for nested declarations, but DOESN'T
-          # contribute a dynamic `:id` segment (singular
-          # resources have no `:id`). So `resource :instance
-          # do; resources :domain_blocks; end` generates
-          # `instance_domain_blocks_path` (arity 0), not
-          # `instance_domain_blocks_path(:id)`.
+          # `resource :foo do ... end` (SINGULAR resource) — adds the resource name to the helper prefix
+          # and path for nested declarations, but DOESN'T contribute a dynamic `:id` segment (singular
+          # resources have no `:id`). So `resource :instance do; resources :domain_blocks; end` generates
+          # `instance_domain_blocks_path` (arity 0), not `instance_domain_blocks_path(:id)`.
           #
-          # Helper-prefix segment uses the AS-GIVEN name (no
-          # singularising — `resource :foo` keeps `foo`).
+          # Helper-prefix segment uses the AS-GIVEN name (no singularising — `resource :foo` keeps `foo`).
           def push_singular_resource(parent_name)
             name = parent_name.to_s
             @stack.push(kind: :singular_scope, parent: name, path_segment: "/#{name}")
@@ -219,14 +191,10 @@ module Rigor
             @stack.pop
           end
 
-          # `member do ... end` / `collection do ... end` —
-          # records the mode so subsequent shorthand HTTP-verb
-          # calls (`post :memorialize`) inside the block can
-          # derive their helper name from the enclosing
-          # resource. The frame also carries the immediate
-          # parent's singular / plural names so member /
-          # collection actions can pick the correct form
-          # (`memorialize_account_path(id)` vs
+          # `member do ... end` / `collection do ... end` — records the mode so subsequent shorthand
+          # HTTP-verb calls (`post :memorialize`) inside the block can derive their helper name from the
+          # enclosing resource. The frame also carries the immediate parent's singular / plural names so
+          # member / collection actions can pick the correct form (`memorialize_account_path(id)` vs
           # `memorialize_accounts_path`).
           def push_action_block(mode, parent_singular, parent_plural)
             @stack.push(kind: :"#{mode}_block", parent_singular: parent_singular, parent_plural: parent_plural)
@@ -235,11 +203,9 @@ module Rigor
             @stack.pop
           end
 
-          # `with_options only: [:index], concerns: :batch do
-          # ... end` — every call inside the block inherits
-          # these default options (each call's own options
-          # override the defaults). `effective_options_for`
-          # below merges them in caller-precedence order.
+          # `with_options only: [:index], concerns: :batch do ... end` — every call inside the block
+          # inherits these default options (each call's own options override the defaults).
+          # `effective_options_for` below merges them in caller-precedence order.
           def push_with_options(defaults)
             @stack.push(kind: :with_options, defaults: defaults)
             yield
@@ -247,15 +213,10 @@ module Rigor
             @stack.pop
           end
 
-          # The merged default-options chain from every
-          # enclosing `with_options` frame on the stack
-          # (outer-most first; inner frames take precedence).
-          # `handle_resources` / `handle_resource` merge this
-          # with the node's own option hash so a bare
-          # `resources :links` inside `with_options only:
-          # [:index], concerns: :batch do ... end` is
-          # treated as if it had those options written
-          # inline.
+          # The merged default-options chain from every enclosing `with_options` frame on the stack
+          # (outer-most first; inner frames take precedence). `handle_resources` / `handle_resource` merge
+          # this with the node's own option hash so a bare `resources :links` inside `with_options only:
+          # [:index], concerns: :batch do ... end` is treated as if it had those options written inline.
           def with_options_defaults
             defaults = {}
             @stack.each do |frame|
@@ -266,10 +227,8 @@ module Rigor
             defaults
           end
 
-          # Returns the top-most `:scope` frame's singular /
-          # plural names, or `nil` when not inside a resources
-          # / resource block. Used by `handle_member_or_collection`
-          # to push the action-block frame.
+          # Returns the top-most `:scope` frame's singular / plural names, or `nil` when not inside a
+          # resources / resource block. Used by `handle_member_or_collection` to push the action-block frame.
           def innermost_resource
             scope_frame = @stack.rfind { |f| f[:kind] == :scope }
             return nil if scope_frame.nil?
@@ -277,17 +236,14 @@ module Rigor
             { singular: scope_frame[:parent], plural: scope_frame[:parent_plural] || scope_frame[:parent] }
           end
 
-          # Top-most `:member_block` / `:collection_block`
-          # frame, or nil when not in a shorthand action
-          # context. `handle_explicit_route` uses this to
-          # detect a `post :memorialize` symbol-only call shape.
+          # Top-most `:member_block` / `:collection_block` frame, or nil when not in a shorthand action
+          # context. `handle_explicit_route` uses this to detect a `post :memorialize` symbol-only call shape.
           def innermost_action_block
             @stack.rfind { |f| %i[member_block collection_block].include?(f[:kind]) }
           end
 
-          # `scope "/:slug", as: "foo" do ... end` — adds a
-          # helper-name prefix without the "parent resource" arity
-          # arithmetic that push_resource uses.
+          # `scope "/:slug", as: "foo" do ... end` — adds a helper-name prefix without the "parent
+          # resource" arity arithmetic that push_resource uses.
           def push_as_scope(name, path, arity_count)
             @stack.push(kind: :as_scope, name: name.to_s, path: path, arity: arity_count)
             yield
@@ -295,20 +251,16 @@ module Rigor
             @stack.pop
           end
 
-          # Helper-name prefix from namespaces (`admin_`,
-          # `admin_users_`, …).
+          # Helper-name prefix from namespaces (`admin_`, `admin_users_`, …).
           def helper_prefix
             segments = @stack.filter_map { |frame| frame_helper_segment(frame) }
             segments.map { |segment| "#{segment}_" }.join
           end
 
-          # The chain of resource-singular segments above the
-          # current scope, in order — used to form member-route
-          # helper names of the form `<as>_<singular_chain>_path`.
-          # Includes nested resources (`resources :projects do;
-          # resources :issues do; get 'foo', as: 'bar'; end; end`
-          # → `bar_project_issue_path`). Returns `""` outside any
-          # `:scope` / `:singular_scope` frame.
+          # The chain of resource-singular segments above the current scope, in order — used to form
+          # member-route helper names of the form `<as>_<singular_chain>_path`. Includes nested resources
+          # (`resources :projects do; resources :issues do; get 'foo', as: 'bar'; end; end` →
+          # `bar_project_issue_path`). Returns `""` outside any `:scope` / `:singular_scope` frame.
           def resource_singular_chain
             segments = @stack.filter_map do |frame|
               case frame[:kind]
@@ -319,12 +271,10 @@ module Rigor
             segments.empty? ? "" : "#{segments.join('_')}_"
           end
 
-          # Namespace-only prefix (drops the resource-singular
-          # segments that `helper_prefix` includes). Used so that
-          # an `:as => 'foo'` inside `namespace :admin do
-          # resources :projects do; ...; end; end` generates
-          # `admin_foo_project_path` — namespace first, then
-          # `:as` action prefix, then singular chain.
+          # Namespace-only prefix (drops the resource-singular segments that `helper_prefix` includes).
+          # Used so that an `:as => 'foo'` inside `namespace :admin do resources :projects do; ...; end;
+          # end` generates `admin_foo_project_path` — namespace first, then `:as` action prefix, then
+          # singular chain.
           def namespace_only_prefix
             segments = @stack.filter_map do |frame|
               case frame[:kind]
@@ -335,34 +285,28 @@ module Rigor
             segments.empty? ? "" : "#{segments.join('_')}_"
           end
 
-          # True when we're inside a `resources` or `resource`
-          # scope (the AST has pushed a `:scope` or
-          # `:singular_scope` frame). Drives member-route
-          # helper-name generation in `handle_explicit_route`.
+          # True when we're inside a `resources` or `resource` scope (the AST has pushed a `:scope` or
+          # `:singular_scope` frame). Drives member-route helper-name generation in `handle_explicit_route`.
           def inside_resource_scope?
             @stack.any? { |frame| %i[scope singular_scope].include?(frame[:kind]) }
           end
 
-          # The innermost `:scope` frame (plural resource),
-          # carrying `parent` (singular) and `parent_plural`.
-          # Used by the inline `:on => :collection` / `:on =>
-          # :member` form to derive the helper name.
+          # The innermost `:scope` frame (plural resource), carrying `parent` (singular) and
+          # `parent_plural`. Used by the inline `:on => :collection` / `:on => :member` form to derive the
+          # helper name.
           def innermost_scope_frame
             @stack.rfind { |f| f[:kind] == :scope }
           end
 
-          # Path prefix — including the parent's `:user_id`
-          # segments for nested resources and the namespace
-          # path prefix.
+          # Path prefix — including the parent's `:user_id` segments for nested resources and the
+          # namespace path prefix.
           def path_prefix
             parts = @stack.flat_map { |frame| frame_path_segments(frame) }
             parts.join
           end
 
-          # Number of dynamic segments (`:user_id`-style)
-          # captured by the parent scope chain. Used to
-          # compute helper arity for nested resources.
-          # Each nested-resource `:scope` frame contributes 1;
+          # Number of dynamic segments (`:user_id`-style) captured by the parent scope chain. Used to
+          # compute helper arity for nested resources. Each nested-resource `:scope` frame contributes 1;
           # each `:as_scope` frame contributes its own arity.
           def parent_segment_count
             @stack.sum do |frame|
@@ -381,10 +325,8 @@ module Rigor
             when :namespace then frame[:name]
             when :scope then frame[:parent]
             when :as_scope
-              # An `:as_scope` frame with an empty `:name` is a
-              # path-only frame pushed by `scope(path: 'X')`
-              # without `:as` — contributes path/arity but no
-              # helper-prefix segment.
+              # An `:as_scope` frame with an empty `:name` is a path-only frame pushed by `scope(path: 'X')`
+              # without `:as` — contributes path/arity but no helper-prefix segment.
               frame[:name].to_s.empty? ? nil : frame[:name]
             when :singular_scope then frame[:parent]
             end
@@ -394,12 +336,9 @@ module Rigor
             case frame[:kind]
             when :namespace then ["/#{frame[:name]}"]
             when :scope
-              # Use the as-given plural when available
-              # (`parent_plural` was captured at
-              # push_resource time) — the singularize /
-              # pluralize round-trip is lossy for irregular
-              # forms (`media → medium → medias`) but the
-              # original name is always correct.
+              # Use the as-given plural when available (`parent_plural` was captured at push_resource
+              # time) — the singularize / pluralize round-trip is lossy for irregular forms (`media →
+              # medium → medias`) but the original name is always correct.
               plural = frame[:parent_plural] || pluralize(frame[:parent])
               ["/#{plural}/:#{frame[:parent]}_id"]
             when :as_scope then frame[:path] ? [frame[:path]] : []
@@ -408,18 +347,14 @@ module Rigor
             end
           end
 
-          # ADR-39: inflection delegates to the shared
-          # `Rigor::Plugin::Inflector`, which calls the real
-          # `ActiveSupport::Inflector` (the authority Rails itself uses to
-          # generate helper names) when available, falling back to a
-          # built-in approximation otherwise. This replaces the hand-tuned
-          # AS-replica these methods used to carry — every special case
-          # they accreted (`news` uncountable, `media`→`medium`,
-          # `databases`→`database`, `custom_css` ss-preservation,
-          # `async_refresh`→`async_refreshes`) was reverse-engineered
-          # `ActiveSupport::Inflector` behaviour, so the real inflector
-          # produces the same result for those and the correct one for the
-          # words the replica never covered.
+          # ADR-39: inflection delegates to the shared `Rigor::Plugin::Inflector`, which calls the real
+          # `ActiveSupport::Inflector` (the authority Rails itself uses to generate helper names) when
+          # available, falling back to a built-in approximation otherwise. This replaces the hand-tuned
+          # AS-replica these methods used to carry — every special case they accreted (`news` uncountable,
+          # `media`→`medium`, `databases`→`database`, `custom_css` ss-preservation,
+          # `async_refresh`→`async_refreshes`) was reverse-engineered `ActiveSupport::Inflector` behaviour,
+          # so the real inflector produces the same result for those and the correct one for the words the
+          # replica never covered.
           def singularize(word)
             Rigor::Plugin::Inflector.singularize(word)
           end
@@ -447,21 +382,15 @@ module Rigor
               # `Rails.application.routes.draw do ... end`
               interpret_block_body(node, context)
             else
-              # `draw(:admin)` — routing partial at
-              # config/routes/{name}.rb.
+              # `draw(:admin)` — routing partial at config/routes/{name}.rb.
               load_drawn_routes(node, context)
             end
           when :draw_all
-            # `draw_all :user` — from the
-            # `action_dispatch-draw_all` gem (used by GitLab
-            # FOSS). Same single-file load semantics as `draw`
-            # — the gem just allows multiple route-dir search
-            # paths (we look in the one we know about).
-            # GitLab's `draw_all :user` loads
-            # `config/routes/user.rb` containing `devise_for
-            # :users, controllers: ...` plus the broader user
-            # route catalogue; without this every Devise
-            # session helper reads as `unknown-helper`.
+            # `draw_all :user` — from the `action_dispatch-draw_all` gem (used by GitLab FOSS). Same
+            # single-file load semantics as `draw` — the gem just allows multiple route-dir search paths
+            # (we look in the one we know about). GitLab's `draw_all :user` loads
+            # `config/routes/user.rb` containing `devise_for :users, controllers: ...` plus the broader
+            # user route catalogue; without this every Devise session helper reads as `unknown-helper`.
             load_drawn_routes(node, context)
           when :namespace
             handle_namespace(node, context)
@@ -474,21 +403,15 @@ module Rigor
           when :scope
             handle_scope(node, context)
           when :get, :post, :patch, :put, :delete, :match
-            # `match 'login', :to => 'a#b', :as => :signin, :via => [:get, :post]`
-            # generates the same helper-name shape as `get` /
-            # `post` (first arg = path string, `:as` overrides the
-            # derived helper name). The only difference is the
-            # HTTP-method set (driven by `:via`); the helper-name
-            # generation logic is identical, so reuse the same
-            # handler. Redmine relies heavily on `match` for
-            # multi-method endpoints (`account/lost_password`,
-            # `news/preview`, etc.).
+            # `match 'login', :to => 'a#b', :as => :signin, :via => [:get, :post]` generates the same
+            # helper-name shape as `get` / `post` (first arg = path string, `:as` overrides the derived
+            # helper name). The only difference is the HTTP-method set (driven by `:via`); the helper-name
+            # generation logic is identical, so reuse the same handler. Redmine relies heavily on `match`
+            # for multi-method endpoints (`account/lost_password`, `news/preview`, etc.).
             handle_explicit_route(node, context)
           when :member, :collection
-            # Inside a `resources` block, `member do ... end`
-            # / `collection do ... end` introduces extra
-            # routes. Interpreted only when we have a parent
-            # scope (otherwise the call is meaningless).
+            # Inside a `resources` block, `member do ... end` / `collection do ... end` introduces extra
+            # routes. Interpreted only when we have a parent scope (otherwise the call is meaningless).
             handle_member_or_collection(node, context)
           when :devise_for
             handle_devise_for(node, context)
@@ -501,19 +424,14 @@ module Rigor
           when :concern
             handle_concern_definition(node, context)
           when :direct
-            # `direct(:name) do |args...| ... end` — Rails DSL
-            # for a custom URL helper. We register `name_path`
-            # and (auto-paired) `name_url`. The arity comes
-            # from the block's required-parameter count. Only
-            # literal Symbol/String names are handled here;
-            # non-literal forms are caught by the
+            # `direct(:name) do |args...| ... end` — Rails DSL for a custom URL helper. We register
+            # `name_path` and (auto-paired) `name_url`. The arity comes from the block's required-parameter
+            # count. Only literal Symbol/String names are handled here; non-literal forms are caught by the
             # `detect_alias_rule_in_each` walker upstream.
             handle_direct(node, context)
           when :each
-            # `.each do |name| ... end` — scan the block for
-            # the GitLab `direct(name.sub(X, Y)) do ... end`
-            # alias-generation idiom. If found, record the
-            # (X, Y) pair so `apply_alias_rules` can expand
+            # `.each do |name| ... end` — scan the block for the GitLab `direct(name.sub(X, Y)) do ... end`
+            # alias-generation idiom. If found, record the (X, Y) pair so `apply_alias_rules` can expand
             # every matching registered entry.
             detect_alias_rule_in_each(node, context)
             interpret_block_body(node, context)
@@ -522,11 +440,9 @@ module Rigor
           end
         end
 
-        # `direct(:name) do |arg1, arg2, ...| ... end` — Rails
-        # adds a custom URL helper. We register `name_path`
-        # with the block's required-arg count as the arity (the
-        # auto-pairing in `parse` adds `name_url`). Only handled
-        # for literal Symbol or String first-arg.
+        # `direct(:name) do |arg1, arg2, ...| ... end` — Rails adds a custom URL helper. We register
+        # `name_path` with the block's required-arg count as the arity (the auto-pairing in `parse` adds
+        # `name_url`). Only handled for literal Symbol or String first-arg.
         def handle_direct(node, context)
           name = Rigor::Source::Literals.symbol_or_string_name(node.arguments&.arguments&.first)
           return if name.nil? || name.empty?
@@ -556,13 +472,10 @@ module Rigor
         # Walks a `.each do |loop_var| ... end` body looking for:
         #   - `<new_name_var> = <loop_var>.sub(FROM_STR, TO_STR)`
         #   - `direct(<new_name_var>) do |...| ... end`
-        # When both shapes appear with the same `<new_name_var>`,
-        # registers `(FROM_STR, TO_STR)` as an alias rule. The
-        # iterated collection (`Rails.application.routes.set`)
-        # is assumed to yield the names of already-registered
-        # helpers — GitLab's idiom. Other iterations that happen
-        # to match the shape are rare; the FP risk is bounded
-        # because alias generation only adds entries.
+        # When both shapes appear with the same `<new_name_var>`, registers `(FROM_STR, TO_STR)` as an
+        # alias rule. The iterated collection (`Rails.application.routes.set`) is assumed to yield the
+        # names of already-registered helpers — GitLab's idiom. Other iterations that happen to match the
+        # shape are rare; the FP risk is bounded because alias generation only adds entries.
         def detect_alias_rule_in_each(each_node, context)
           block = each_node.block
           return unless block.is_a?(Prism::BlockNode)
@@ -573,8 +486,7 @@ module Rigor
           body = block.body
           return if body.nil?
 
-          # First pass: gather every `<var> = <loop_var>.sub(FROM, TO)`
-          # assignment.
+          # First pass: gather every `<var> = <loop_var>.sub(FROM, TO)` assignment.
           sub_assignments = {}
           walk_for_alias_pattern(body) do |node|
             next unless node.is_a?(Prism::LocalVariableWriteNode)
@@ -596,9 +508,8 @@ module Rigor
 
           return if sub_assignments.empty?
 
-          # Second pass: find `direct(<var>) do ... end` calls
-          # whose first arg is one of the captured assignment
-          # variables.
+          # Second pass: find `direct(<var>) do ... end` calls whose first arg is one of the captured
+          # assignment variables.
           walk_for_alias_pattern(body) do |node|
             next unless node.is_a?(Prism::CallNode) && node.name == :direct
             next if node.arguments.nil?
@@ -644,14 +555,11 @@ module Rigor
           context.push_namespace(name) { interpret_block_body(node, context) }
         end
 
-        # `devise_for :users [, skip: [...], path: "..."]` —
-        # generates the standard Devise route-helper catalogue
-        # for the named resource. Symbol-literal first arg
-        # only; non-literal forms (e.g. dynamic resource names
-        # built from constants) are silently skipped because the
-        # helper SET depends on the literal name and we cannot
-        # statically resolve a variable here. `skip:` is read
-        # so the project's omitted controllers do not register.
+        # `devise_for :users [, skip: [...], path: "..."]` — generates the standard Devise route-helper
+        # catalogue for the named resource. Symbol-literal first arg only; non-literal forms (e.g. dynamic
+        # resource names built from constants) are silently skipped because the helper SET depends on the
+        # literal name and we cannot statically resolve a variable here. `skip:` is read so the project's
+        # omitted controllers do not register.
         def handle_devise_for(node, context)
           resource = symbol_argument(node, 0)
           return if resource.nil?
@@ -664,18 +572,13 @@ module Rigor
           end
         end
 
-        # `with_options X do ... end` — applies the `X`
-        # options hash as defaults for every call inside the
-        # block. Mastodon's `with_options only: [:index],
-        # concerns: :batch do resources :links; resources
-        # :tags; end` lets us register the inner resources
-        # with the implicit defaults — closing `batch_*_path`
-        # cluster generated via the `:batch` concern.
+        # `with_options X do ... end` — applies the `X` options hash as defaults for every call inside the
+        # block. Mastodon's `with_options only: [:index], concerns: :batch do resources :links; resources
+        # :tags; end` lets us register the inner resources with the implicit defaults — closing
+        # `batch_*_path` cluster generated via the `:batch` concern.
         #
-        # We push a `:with_options` frame carrying the
-        # defaults; `effective_options_for(node)` (in
-        # `handle_resources` / `handle_resource`) merges them
-        # in before reading specific option keys.
+        # We push a `:with_options` frame carrying the defaults; `effective_options_for(node)` (in
+        # `handle_resources` / `handle_resource`) merges them in before reading specific option keys.
         def handle_with_options(node, context)
           defaults = options_hash(node)
           context.push_with_options(defaults) do
@@ -683,18 +586,13 @@ module Rigor
           end
         end
 
-        # `mount Foo::Engine, at: '/path', as: :name` —
-        # mounted Rails engines. The mount adds a single
-        # helper for the mount point itself: `<as>_path` /
-        # `<as>_url` (arity 0). The engine's own internal
-        # helpers are out of scope (they'd need the engine's
-        # routes.rb available; almost no static parser
-        # follows that). Mastodon uses `mount Sidekiq::Web,
-        # at: 'sidekiq', as: :sidekiq` and similar.
+        # `mount Foo::Engine, at: '/path', as: :name` — mounted Rails engines. The mount adds a single
+        # helper for the mount point itself: `<as>_path` / `<as>_url` (arity 0). The engine's own internal
+        # helpers are out of scope (they'd need the engine's routes.rb available; almost no static parser
+        # follows that). Mastodon uses `mount Sidekiq::Web, at: 'sidekiq', as: :sidekiq` and similar.
         #
-        # When `as:` is omitted Rails derives a helper name
-        # from the engine class — that's harder to compute
-        # statically, so we silently skip.
+        # When `as:` is omitted Rails derives a helper name from the engine class — that's harder to
+        # compute statically, so we silently skip.
         def handle_mount(node, context)
           options = options_hash(node)
           as_name = options[:as]
@@ -710,15 +608,11 @@ module Rigor
           )
         end
 
-        # `use_doorkeeper do ... end` — Doorkeeper gem's
-        # standard OAuth route helpers (`oauth_token_path`,
-        # `oauth_authorization_path`, `oauth_application_path`,
-        # etc.). We generate the full catalogue plus walk the
-        # block body for `skip_controllers <names>` calls so
-        # the project's omitted controllers don't register.
-        # `controllers <hash>` mappings inside the block change
-        # the serving controller class but not the helper
-        # names — they can stay unmodelled.
+        # `use_doorkeeper do ... end` — Doorkeeper gem's standard OAuth route helpers (`oauth_token_path`,
+        # `oauth_authorization_path`, `oauth_application_path`, etc.). We generate the full catalogue plus
+        # walk the block body for `skip_controllers <names>` calls so the project's omitted controllers
+        # don't register. `controllers <hash>` mappings inside the block change the serving controller
+        # class but not the helper names — they can stay unmodelled.
         def handle_use_doorkeeper(node, context)
           skip = collect_doorkeeper_skips(node)
           DoorkeeperRoutes.generate(skip: skip).each do |entry|
@@ -750,37 +644,27 @@ module Rigor
 
         # `scope "/:slug", as: "event" do ... end`
         #
-        # When `as:` is present the block body is interpreted under a
-        # new `:as_scope` stack frame that adds the given prefix to
-        # every helper registered inside.  Dynamic path segments
-        # (`:slug`) are counted so nested-resource arities stay
-        # correct.
+        # When `as:` is present the block body is interpreted under a new `:as_scope` stack frame that
+        # adds the given prefix to every helper registered inside. Dynamic path segments (`:slug`) are
+        # counted so nested-resource arities stay correct.
         #
-        # When `as:` is absent the block is interpreted without any
-        # prefix change — helper names are unaffected by the scope's
-        # path, which matches Rails' behaviour for path-only scopes.
+        # When `as:` is absent the block is interpreted without any prefix change — helper names are
+        # unaffected by the scope's path, which matches Rails' behaviour for path-only scopes.
         def handle_scope(node, context)
           as_name = keyword_symbol(node, :as)
-          # `scope :path_arg, as: :name` (path as a positional
-          # arg) vs `scope(path: ':project_id', as: :project)`
-          # (path as a `:path` keyword). GitLab's project routes
-          # rely on the latter for the `*namespace_id` /
-          # `:project_id` outer scopes. The leading `/` is added
-          # if missing so the path-prefix join produces clean
-          # segments.
+          # `scope :path_arg, as: :name` (path as a positional arg) vs `scope(path: ':project_id', as:
+          # :project)` (path as a `:path` keyword). GitLab's project routes rely on the latter for the
+          # `*namespace_id` / `:project_id` outer scopes. The leading `/` is added if missing so the
+          # path-prefix join produces clean segments.
           path = string_argument(node, 0) || keyword_value_string(node, :path)
           path = "/#{path}" if path && !path.start_with?("/")
           arity = path ? count_path_placeholders(path) : 0
 
           if as_name.nil?
-            # Even without `:as`, a `scope(path: 'groups/*id')`
-            # still contributes its path / arity segments to
-            # helpers declared inside (GitLab's
-            # `scope(path: 'groups/*id', controller: :groups)
-            # do; get :edit, as: :edit_group end` → arity 1).
-            # Skip the frame when there's also no path
-            # contribution (a pure `scope(module: :foo)` with
-            # no helper-name / path effect).
+            # Even without `:as`, a `scope(path: 'groups/*id')` still contributes its path / arity segments
+            # to helpers declared inside (GitLab's `scope(path: 'groups/*id', controller: :groups) do; get
+            # :edit, as: :edit_group end` → arity 1). Skip the frame when there's also no path contribution
+            # (a pure `scope(module: :foo)` with no helper-name / path effect).
             return interpret_block_body(node, context) if path.nil? || arity.zero?
 
             context.push_as_scope("", path, arity) do
@@ -801,13 +685,10 @@ module Rigor
           options = effective_options_for(node, context)
           actions = restrict_actions_from(options, DEFAULT_RESOURCE_ACTIONS)
           base_arity = context.parent_segment_count
-          # `resources :collections, as: :actor_collections`
-          # remaps the helper name family —
-          # `actor_collections_path` for index,
-          # `actor_collection_path(id)` for show. Path / arity
-          # are unaffected. Mastodon uses this inside a
-          # concern (`resources :collections, only: [:show],
-          # as: :actor_collections`).
+          # `resources :collections, as: :actor_collections` remaps the helper name family —
+          # `actor_collections_path` for index, `actor_collection_path(id)` for show. Path / arity are
+          # unaffected. Mastodon uses this inside a concern (`resources :collections, only: [:show], as:
+          # :actor_collections`).
           helper_name = options[:as] || name
 
           register_resourceful_helpers(helper_name, actions, base_arity, context, plural: true)
@@ -827,30 +708,23 @@ module Rigor
           base_arity = context.parent_segment_count
           helper_name = options[:as] || name
 
-          # Singular resource — no `:id` segment, no `:index`
-          # / pluralised helper. The "show" helper is
+          # Singular resource — no `:id` segment, no `:index` / pluralised helper. The "show" helper is
           # `<name>_path` (singular).
           register_resourceful_helpers(helper_name, actions, base_arity, context, plural: false)
 
-          # Push a `:singular_scope` frame so nested
-          # declarations pick up the singular resource's
-          # name in their helper prefix (Mastodon's
-          # `resource :instance do; scope module: :instances
-          # do; resources :domain_blocks; end; end` →
-          # `instance_domain_blocks_path`). The singular
-          # frame adds NO `:id` segment to arity — singular
-          # resources don't carry one.
+          # Push a `:singular_scope` frame so nested declarations pick up the singular resource's name in
+          # their helper prefix (Mastodon's `resource :instance do; scope module: :instances do; resources
+          # :domain_blocks; end; end` → `instance_domain_blocks_path`). The singular frame adds NO `:id`
+          # segment to arity — singular resources don't carry one.
           context.push_singular_resource(name) do
             replay_concerns(node, context)
             interpret_block_body(node, context)
           end
         end
 
-        # `concern :account_resources do ... end` registers the
-        # body for later replay; we DO NOT interpret it at the
-        # definition site (the body has no parent-resource
-        # context yet). Concerns at the top level land in the
-        # Context's `concerns` map by Symbol name.
+        # `concern :account_resources do ... end` registers the body for later replay; we DO NOT interpret
+        # it at the definition site (the body has no parent-resource context yet). Concerns at the top
+        # level land in the Context's `concerns` map by Symbol name.
         def handle_concern_definition(node, context)
           name = symbol_argument(node, 0)
           body = node.block&.body
@@ -859,12 +733,9 @@ module Rigor
           context.register_concern(name, body)
         end
 
-        # `resources :accounts, concerns: :account_resources do ... end`
-        # — replays the registered concern body inside the
-        # current Context (which already has the accounts
-        # resource frame pushed). Supports both single-symbol
-        # (`concerns: :name`) and array-of-symbols
-        # (`concerns: [:a, :b]`) forms.
+        # `resources :accounts, concerns: :account_resources do ... end` — replays the registered concern
+        # body inside the current Context (which already has the accounts resource frame pushed). Supports
+        # both single-symbol (`concerns: :name`) and array-of-symbols (`concerns: [:a, :b]`) forms.
         def replay_concerns(resource_node, context)
           replay_concerns_from_options(effective_options_for(resource_node, context), context)
         end
@@ -881,33 +752,25 @@ module Rigor
           end
         end
 
-        # Returns the merged option hash for a node — the
-        # caller's own options override `with_options`
-        # defaults from the surrounding Context stack. Used by
-        # `handle_resources` / `handle_resource` so a bare
-        # `resources :foo` inside `with_options only: [:index],
-        # concerns: :batch do ... end` is treated as if it
-        # had those options written inline.
+        # Returns the merged option hash for a node — the caller's own options override `with_options`
+        # defaults from the surrounding Context stack. Used by `handle_resources` / `handle_resource` so a
+        # bare `resources :foo` inside `with_options only: [:index], concerns: :batch do ... end` is
+        # treated as if it had those options written inline.
         def effective_options_for(node, context)
           context.with_options_defaults.merge(options_hash(node))
         end
 
-        # Reads the value of an options-hash key. Distinct from
-        # `keyword_symbol` / `keyword_array` because `concerns:`
-        # accepts EITHER a single Symbol or an Array of Symbols
-        # — same Rails idiom Rails accepts.
+        # Reads the value of an options-hash key. Distinct from `keyword_symbol` / `keyword_array` because
+        # `concerns:` accepts EITHER a single Symbol or an Array of Symbols — same Rails idiom Rails accepts.
         def keyword_value(node, key)
           options_hash(node)[key]
         end
 
         def handle_root(node, context)
-          # `root to: "..."` / `root "..."` — single helper
-          # `root_path`, arity 0, GET. Real-world Rails apps also
-          # use `root :to => 'welcome#index', :as => 'home'` (the
-          # canonical Redmine idiom across 230+ call sites), which
-          # registers an additional `home_path` / `home_url` alias
-          # for the same path. Mastodon and Solidus also use the
-          # `as:` form occasionally for analytics-friendly URL
+          # `root to: "..."` / `root "..."` — single helper `root_path`, arity 0, GET. Real-world Rails
+          # apps also use `root :to => 'welcome#index', :as => 'home'` (the canonical Redmine idiom across
+          # 230+ call sites), which registers an additional `home_path` / `home_url` alias for the same
+          # path. Mastodon and Solidus also use the `as:` form occasionally for analytics-friendly URL
           # naming.
           path = context.path_prefix.empty? ? "/" : context.path_prefix
           context.entries << HelperTable::Entry.new(
@@ -925,23 +788,17 @@ module Rigor
         end
 
         def handle_explicit_route(node, context)
-          # Member / collection block shorthand: `post :memorialize`
-          # inside `member do ... end` (no path arg, just a
-          # SymbolNode). Rails generates a helper based on the
-          # action name + the enclosing resource: a member
-          # action becomes `<action>_<singular_chain>_path(id)`,
-          # a collection action becomes
-          # `<action>_<plural_chain>_path`.
+          # Member / collection block shorthand: `post :memorialize` inside `member do ... end` (no path
+          # arg, just a SymbolNode). Rails generates a helper based on the action name + the enclosing
+          # resource: a member action becomes `<action>_<singular_chain>_path(id)`, a collection action
+          # becomes `<action>_<plural_chain>_path`.
           return register_member_collection_action(node, context) if member_collection_shorthand?(node, context)
 
-          # `:on => :collection` / `:on => :member` inline form
-          # — Rails accepts this as a shorthand for `collection
-          # do ... end` / `member do ... end` wrappers around a
-          # single action. `get 'report', :on => :collection`
-          # inside `resources :time_entries` generates
-          # `report_time_entries_path` (collection-style: action
-          # prefix on the plural resource name). Treat the action
-          # name as the path's basename string (Redmine's idiom).
+          # `:on => :collection` / `:on => :member` inline form — Rails accepts this as a shorthand for
+          # `collection do ... end` / `member do ... end` wrappers around a single action. `get 'report',
+          # :on => :collection` inside `resources :time_entries` generates `report_time_entries_path`
+          # (collection-style: action prefix on the plural resource name). Treat the action name as the
+          # path's basename string (Redmine's idiom).
           on_target = keyword_symbol(node, :on)
           if on_target && context.inside_resource_scope?
             path_arg = string_argument(node, 0) || symbol_argument(node, 0)&.to_s
@@ -949,36 +806,33 @@ module Rigor
             return register_on_target_action(node, context, as_name, on_target) if as_name
           end
 
-          # `get "/about", to: "static#about", as: :about` —
-          # path as the first positional arg. Also handle the
-          # hashrocket-key form `get 'help/*path' => 'help#show',
-          # as: :help_page` where the path is the String key in
-          # the trailing keyword/options hash (its value is the
-          # `controller#action`). Without this, the arity check
-          # underestimates because the placeholder count comes
-          # from a nil path.
+          # `get "/about", to: "static#about", as: :about` — path as the first positional arg. Also handle
+          # the hashrocket-key form `get 'help/*path' => 'help#show', as: :help_page` where the path is the
+          # String key in the trailing keyword/options hash (its value is the `controller#action`). Without
+          # this, the arity check underestimates because the placeholder count comes from a nil path.
           path = string_argument(node, 0) || hashrocket_path_key(node)
+          # `get :activity` inside a `scope(as: :user)` — NOT a resources / member / collection block (that
+          # shape returned early above), so the symbol is both the path segment (`/activity`) and the action
+          # name. Rails composes `<scope_as>_activity_path`. Fall the symbol back into the path so the
+          # name-and-arity derivation below picks it up; without it the route registered nothing and every
+          # `user_activity_path` call read as `unknown-helper`.
+          path ||= symbol_action_path(node)
           as_name = keyword_symbol(node, :as)
           return if as_name.nil? && path.nil?
 
-          # When `as:` is omitted, Rails derives a helper name
-          # from the path for static paths (no :segment). We
-          # do the same when the path has no placeholders. The
-          # special case `get '/'` inside a `:as_scope` (e.g.
-          # `scope path: '/blob/*id', as: :blob do; get '/' end`)
-          # has empty path content after stripping the leading
-          # slash — Rails reuses the enclosing as_scope's name.
-          # We surface that by registering the helper with an
-          # empty `as_name`, which `explicit_route_helper_name`
-          # then composes from `helper_prefix.chomp("_")`.
+          # When `as:` is omitted, Rails derives a helper name from the path for static paths (no
+          # :segment). We do the same when the path has no placeholders. The special case `get '/'` inside
+          # a `:as_scope` (e.g. `scope path: '/blob/*id', as: :blob do; get '/' end`) has empty path
+          # content after stripping the leading slash — Rails reuses the enclosing as_scope's name. We
+          # surface that by registering the helper with an empty `as_name`, which
+          # `explicit_route_helper_name` then composes from `helper_prefix.chomp("_")`.
           if as_name.nil?
             return if path.nil? || path.include?(":")
 
             as_name = path.delete_prefix("/").tr("/", "_")
             if as_name.empty? && context.helper_prefix.empty?
-              # `get '/'` style — only meaningful when the
-              # helper_prefix is non-empty (otherwise Rails would
-              # generate a root helper, handled elsewhere).
+              # `get '/'` style — only meaningful when the helper_prefix is non-empty (otherwise Rails
+              # would generate a root helper, handled elsewhere).
               return
             end
           end
@@ -987,11 +841,9 @@ module Rigor
           total_placeholders = count_path_placeholders(path)
           optional = count_optional_path_placeholders(path)
           base_arity = context.parent_segment_count + total_placeholders
-          # Register the maximum-arity entry; if the path
-          # carries `(...)` optional segments (e.g.
-          # `'settings(/:tab)'`), register additional entries
-          # for each smaller arity so the call-site arity check
-          # accepts `settings_project_path(:id)` (no `:tab`).
+          # Register the maximum-arity entry; if the path carries `(...)` optional segments (e.g.
+          # `'settings(/:tab)'`), register additional entries for each smaller arity so the call-site
+          # arity check accepts `settings_project_path(:id)` (no `:tab`).
           (0..optional).each do |drop|
             context.entries << HelperTable::Entry.new(
               name: name, arity: base_arity - drop,
@@ -1001,28 +853,29 @@ module Rigor
           end
         end
 
-        # Builds the helper name for an explicit `get` / `post`
-        # / `match` route. Rails uses two distinct shapes:
+        # `/activity` for a bare `get :activity` first-arg symbol (used as both path and action name), else
+        # nil. Only reached outside a resources / member / collection block — the symbol-shorthand there is
+        # already handled as a member/collection action upstream.
+        def symbol_action_path(node)
+          symbol = symbol_argument(node, 0)
+          symbol && "/#{symbol}"
+        end
+
+        # Builds the helper name for an explicit `get` / `post` / `match` route. Rails uses two distinct
+        # shapes:
         #
-        # - **Outside a `resources` scope** (top-level or inside
-        #   `namespace` / `scope`): `<namespace_prefix><as>_path`
-        #   — e.g. `match 'login', as: :signin` →
-        #   `signin_path`; inside `namespace :admin` →
-        #   `admin_signin_path`.
-        # - **Inside a `resources` scope**: the `:as` acts as
-        #   the ACTION prefix on the resource's singular chain.
-        #   `resources :projects do; get 'settings', as:
-        #   :settings; end` → `settings_project_path(:id)` (NOT
-        #   `project_settings_path`). The namespace prefix still
-        #   leads: `namespace :admin do; resources :projects do;
-        #   get 'foo', as: :bar; end; end` →
+        # - **Outside a `resources` scope** (top-level or inside `namespace` / `scope`):
+        #   `<namespace_prefix><as>_path` — e.g. `match 'login', as: :signin` → `signin_path`; inside
+        #   `namespace :admin` → `admin_signin_path`.
+        # - **Inside a `resources` scope**: the `:as` acts as the ACTION prefix on the resource's singular
+        #   chain. `resources :projects do; get 'settings', as: :settings; end` →
+        #   `settings_project_path(:id)` (NOT `project_settings_path`). The namespace prefix still leads:
+        #   `namespace :admin do; resources :projects do; get 'foo', as: :bar; end; end` →
         #   `admin_bar_project_path(:id)`.
         def explicit_route_helper_name(context, as_name)
-          # Empty `as_name` is the `get '/'`-inside-an-as_scope
-          # case (e.g. `scope path: '/blob/*id', as: :blob do;
-          # get '/' end` → `blob_path(:id)`). Use the
-          # helper_prefix as-is (drop the trailing underscore)
-          # — Rails reuses the enclosing scope's name verbatim.
+          # Empty `as_name` is the `get '/'`-inside-an-as_scope case (e.g. `scope path: '/blob/*id', as:
+          # :blob do; get '/' end` → `blob_path(:id)`). Use the helper_prefix as-is (drop the trailing
+          # underscore) — Rails reuses the enclosing scope's name verbatim.
           return "#{context.helper_prefix.chomp('_')}_path" if as_name.to_s.empty?
 
           if context.inside_resource_scope?
@@ -1032,46 +885,51 @@ module Rigor
           end
         end
 
-        # True when the call is `<verb> :symbol [, options...]`
-        # or `<verb> 'string'` inside one of:
-        # - a `member do ... end` / `collection do ... end`
-        #   block (canonical shorthand context), or
-        # - a `resources :name do ... end` / `resource :name
-        #   do ... end` block at the *direct* nesting level.
-        #   Rails defaults a bare symbol- or string-named verb
-        #   inside resources to a member action (GitLab's
-        #   `resource :application_settings do; match :general,
-        #   via: [...] end` → `general_application_settings_path`).
+        # True when the call is `<verb> :symbol [, options...]` or `<verb> 'string'` inside one of:
+        # - a `member do ... end` / `collection do ... end` block (canonical shorthand context), or
+        # - a `resources :name do ... end` / `resource :name do ... end` block at the *direct* nesting
+        #   level. Rails defaults a bare symbol- or string-named verb inside resources to a member action
+        #   (GitLab's `resource :application_settings do; match :general, via: [...] end` →
+        #   `general_application_settings_path`).
         def member_collection_shorthand?(node, context)
           return false unless context.innermost_action_block || context.inside_resource_scope?
 
           first_arg = node.arguments&.arguments&.first
           return true if first_arg.is_a?(Prism::SymbolNode)
-
-          # A plain action-name string with no `/` or `:` —
-          # treat it as if it were a symbol (`get 'report'` ==
-          # `get :report` inside member/collection block).
-          first_arg.is_a?(Prism::StringNode) &&
-            !first_arg.unescaped.include?("/") &&
-            !first_arg.unescaped.include?(":")
+          return false unless first_arg.is_a?(Prism::StringNode)
+
+          path = first_arg.unescaped
+          # A dynamic segment (`get 'foo/:id'`) is a real path, not a plain action name — leave it to the
+          # generic explicit-route handler.
+          return false if path.include?(":")
+
+          # A bare `get '/'` (or `''`) inside a `collection do` block is the collection root, not an action
+          # shorthand — Rails names it after the enclosing resource, not `<empty>_<plural>_path`. An empty
+          # normalized action name means "not a shorthand"; fall through to the generic handler.
+          return false if path.delete_prefix("/").tr("/", "_").empty?
+
+          # A single-segment string is an action name in any resource context (`get 'report'` == `get
+          # :report`). A MULTI-segment static path (`get 'granular/new'`) is an action too, but only inside
+          # an explicit `member do` / `collection do` block, where Rails' `Mapper.normalize_name` maps the
+          # slashes to underscores (`granular_new_<scope>_<plural>_path`). Outside such a block (a bare
+          # `resources` scope) a multi-segment path is a nested custom route, so keep the generic handler.
+          !path.include?("/") || !context.innermost_action_block.nil?
         end
 
         # Generates the member / collection action helper.
         # Member: `<action>_<helper_prefix>path(id)`, arity =
-        #   parent_segment_count (which already includes the
-        #   enclosing resource's `:id`).
+        #   parent_segment_count (which already includes the enclosing resource's `:id`).
         # Collection: `<action>_<plural_helper_prefix>path`,
-        #   arity = parent_segment_count - 1 (no `:id` segment;
-        #   the collection URL is /<resource>/<action>).
+        #   arity = parent_segment_count - 1 (no `:id` segment; the collection URL is /<resource>/<action>).
         def register_member_collection_action(node, context)
+          # A multi-segment string action (`get 'granular/new'` in a `collection do` block) is named by
+          # Rails via `normalize_name` — leading slash stripped, remaining slashes → underscores.
           action_name = symbol_argument(node, 0)&.to_s ||
-                        string_argument(node, 0).to_s
+                        string_argument(node, 0).to_s.delete_prefix("/").tr("/", "_")
           frame = context.innermost_action_block
-          # No `member do` / `collection do` wrapper but we're
-          # inside a resources block — Rails defaults a bare
-          # `<verb> :symbol` inside resources to a MEMBER
-          # action (e.g. `get :preview` → `preview_<singular>_path
-          # (:id)`).
+          # No `member do` / `collection do` wrapper but we're inside a resources block — Rails defaults a
+          # bare `<verb> :symbol` inside resources to a MEMBER action (e.g. `get :preview` →
+          # `preview_<singular>_path(:id)`).
           if frame.nil?
             register_member_action(node, context, action_name)
           elsif frame[:kind] == :member_block
@@ -1081,12 +939,9 @@ module Rigor
           end
         end
 
-        # `get 'report', :on => :collection` (or `:member`)
-        # inline form inside `resources`. The helper name shape
-        # matches member_action / collection_action: the action
-        # name prefixes the resource's singular (member) or
-        # plural (collection). Closes Redmine's
-        # `report_time_entries_path` cluster.
+        # `get 'report', :on => :collection` (or `:member`) inline form inside `resources`. The helper name
+        # shape matches member_action / collection_action: the action name prefixes the resource's
+        # singular (member) or plural (collection). Closes Redmine's `report_time_entries_path` cluster.
         def register_on_target_action(node, context, action_name, on_target)
           scope_frame = context.innermost_scope_frame
           return if scope_frame.nil?
@@ -1114,12 +969,9 @@ module Rigor
         end
 
         def register_member_action(node, context, action_name)
-          # `helper_prefix` already ends with "_" (each segment
-          # appends one); the formula below yields e.g.
-          # `memorialize_admin_account_path`. Arity equals the
-          # parent segment count — Rails member URLs carry the
-          # enclosing resource's `:id`, which the :scope frame
-          # already counts.
+          # `helper_prefix` already ends with "_" (each segment appends one); the formula below yields e.g.
+          # `memorialize_admin_account_path`. Arity equals the parent segment count — Rails member URLs
+          # carry the enclosing resource's `:id`, which the :scope frame already counts.
           name = "#{action_name}_#{context.helper_prefix}path"
           context.entries << HelperTable::Entry.new(
             name: name, arity: context.parent_segment_count,
@@ -1129,10 +981,8 @@ module Rigor
         end
 
         def register_collection_action(node, context, action_name, frame)
-          # Collection URL drops the immediate parent's `:id`
-          # segment. The plural helper prefix swaps the
-          # singular form (in `helper_prefix`) for the plural
-          # — the immediate-resource frame stored both.
+          # Collection URL drops the immediate parent's `:id` segment. The plural helper prefix swaps the
+          # singular form (in `helper_prefix`) for the plural — the immediate-resource frame stored both.
           plural_prefix = context.helper_prefix.sub(/#{frame[:parent_singular]}_\z/, "#{frame[:parent_plural]}_")
           name = "#{action_name}_#{plural_prefix}path"
           arity = [context.parent_segment_count - 1, 0].max
@@ -1159,8 +1009,7 @@ module Rigor
         end
 
         def handle_member_or_collection(node, context)
-          # Only meaningful when we're inside a `resources` /
-          # `resource` block. The Context's stack tells us.
+          # Only meaningful when we're inside a `resources` / `resource` block. The Context's stack tells us.
           resource = context.innermost_resource
           return interpret_block_body(node, context) if resource.nil?
 
@@ -1171,25 +1020,20 @@ module Rigor
         end
 
         def in_singular_resource?(*)
-          # Stub: always returns true so member / collection
-          # blocks descend. The singular-resource frame
-          # (`push_singular_resource`) is modelled in Context;
-          # a future caller could use it to tighten this check.
+          # Stub: always returns true so member / collection blocks descend. The singular-resource frame
+          # (`push_singular_resource`) is modelled in Context; a future caller could use it to tighten this
+          # check.
           true
         end
 
-        # Generate the standard helpers for a resource(s).
-        # `plural: true` for `resources :users`, `false` for
-        # `resource :profile`.
+        # Generate the standard helpers for a resource(s). `plural: true` for `resources :users`, `false`
+        # for `resource :profile`.
         def register_resourceful_helpers(name, actions, base_arity, context, plural:)
-          # Plural resources (`resources :users`) singularise
-          # for show / new / edit helpers → `user_path(id)`.
-          # Singular resources (`resource :foo`) use the name
-          # AS-IS — singularising would mangle deliberately-
-          # plural names like Mastodon's `resource
-          # :relationships` → `relationships_path`, not
-          # `relationship_path`. The URL path uses `name`
-          # in both shapes (Rails never singularises the URL).
+          # Plural resources (`resources :users`) singularise for show / new / edit helpers →
+          # `user_path(id)`. Singular resources (`resource :foo`) use the name AS-IS — singularising would
+          # mangle deliberately-plural names like Mastodon's `resource :relationships` →
+          # `relationships_path`, not `relationship_path`. The URL path uses `name` in both shapes (Rails
+          # never singularises the URL).
           singular = plural ? singularize_word(name.to_s) : name.to_s
           path_base = "#{context.path_prefix}/#{name}"
 
@@ -1203,20 +1047,13 @@ module Rigor
           end
         end
 
-        # Maps an action keyword to the route-helper entry it
-        # produces. The five "named-helper" actions
-        # (`:index` / `:show` / `:new` / `:edit` plus
-        # singular-resource `:show`) generate a distinct
-        # helper; the three "verb-only" actions (`:create` /
-        # `:update` / `:destroy`) Rails serves under the same
-        # path-helper Rails reuses for show / index forms — so
-        # we emit them too, otherwise an `only: [:create]`
-        # resource (e.g. Mastodon's `resource :inbox, only:
-        # [:create]`) registers NO helpers and downstream
-        # callers see a false `unknown-helper inbox_path`.
-        # The HelperTable already dedupes by name, so a
-        # resource that lists both `:show` and `:update` does
-        # not double-register.
+        # Maps an action keyword to the route-helper entry it produces. The five "named-helper" actions
+        # (`:index` / `:show` / `:new` / `:edit` plus singular-resource `:show`) generate a distinct
+        # helper; the three "verb-only" actions (`:create` / `:update` / `:destroy`) Rails serves under the
+        # same path-helper Rails reuses for show / index forms — so we emit them too, otherwise an `only:
+        # [:create]` resource (e.g. Mastodon's `resource :inbox, only: [:create]`) registers NO helpers and
+        # downstream callers see a false `unknown-helper inbox_path`. The HelperTable already dedupes by
+        # name, so a resource that lists both `:show` and `:update` does not double-register.
         def entry_for_action(action, name:, singular:, base_arity:, path_base:, helper_prefix:, plural:)
           case action
           when :index then index_entry(plural, helper_prefix, name, base_arity, path_base, singular)
@@ -1229,18 +1066,14 @@ module Rigor
             )
           when :edit then edit_entry(plural, helper_prefix, singular, base_arity, path_base)
           when :create
-            # Plural `resources` collection POST shares the
-            # index helper (`<name>_path` → collection URL).
-            # Singular `resource` POST shares the show helper
-            # (`<name>_path` → resource URL). Both shapes
-            # produce a `<prefix><name>_path` entry; only the
-            # arity / path differ.
+            # Plural `resources` collection POST shares the index helper (`<name>_path` → collection URL).
+            # Singular `resource` POST shares the show helper (`<name>_path` → resource URL). Both shapes
+            # produce a `<prefix><name>_path` entry; only the arity / path differ.
             create_entry(plural, helper_prefix, name, singular, base_arity, path_base)
           when :update, :destroy
-            # Member PATCH / PUT / DELETE on plural resources
-            # share the show helper (`<prefix><singular>_path(id)`).
-            # Singular-resource PATCH / DELETE shares
-            # `<prefix><name>_path` (no `:id`).
+            # Member PATCH / PUT / DELETE on plural resources share the show helper
+            # (`<prefix><singular>_path(id)`). Singular-resource PATCH / DELETE shares `<prefix><name>_path`
+            # (no `:id`).
             show_entry(plural, helper_prefix, singular, base_arity, path_base)
           end
         end
@@ -1264,27 +1097,18 @@ module Rigor
         def index_entry(plural, helper_prefix, name, base_arity, path_base, singular)
           return nil unless plural
 
-          # Rails appends `_index_path` to the index helper
-          # name when the singular form of the resource matches
-          # the plural form AND the noun isn't in the canonical
-          # UNCOUNTABLE list. The collision would otherwise put
-          # both the index (`:id`-less) and show (`:id`-bearing)
-          # helpers under the same name, and Rails disambiguates
-          # by suffixing the index form. Mastodon's
-          # `resources :reblogged_by, controller:
-          # :reblogged_by_accounts, only: :index` and similar
-          # rely on this — calls like
-          # `api_v1_status_reblogged_by_index_url(status.id)`
-          # would otherwise read as `unknown-helper`.
+          # Rails appends `_index_path` to the index helper name when the singular form of the resource
+          # matches the plural form AND the noun isn't in the canonical UNCOUNTABLE list. The collision
+          # would otherwise put both the index (`:id`-less) and show (`:id`-bearing) helpers under the same
+          # name, and Rails disambiguates by suffixing the index form. Mastodon's `resources
+          # :reblogged_by, controller: :reblogged_by_accounts, only: :index` and similar rely on this —
+          # calls like `api_v1_status_reblogged_by_index_url(status.id)` would otherwise read as
+          # `unknown-helper`.
           #
-          # Rails adds `_index_` whenever `singular == plural`
-          # — including for UNCOUNTABLE nouns (Redmine's
-          # `resources :news` registers `news_index_path` for
-          # the index). The earlier "skip UNCOUNTABLE" carve-out
-          # was empirically wrong; only the
-          # IRREGULAR-singular path (e.g. `media → medium`)
-          # actually has `singular != plural` and skips
-          # `_index_`.
+          # Rails adds `_index_` whenever `singular == plural` — including for UNCOUNTABLE nouns (Redmine's
+          # `resources :news` registers `news_index_path` for the index). The earlier "skip UNCOUNTABLE"
+          # carve-out was empirically wrong; only the IRREGULAR-singular path (e.g. `media → medium`)
+          # actually has `singular != plural` and skips `_index_`.
           index_name = if name.to_s == singular
                          "#{helper_prefix}#{name}_index_path"
                        else
@@ -1322,9 +1146,8 @@ module Rigor
         end
 
         def restrict_actions_from(options, default)
-          # `resources :foo, only: :show` is the same as
-          # `only: [:show]` in Rails; `options_hash` preserves the
-          # Symbol shape from the source, so coerce here.
+          # `resources :foo, only: :show` is the same as `only: [:show]` in Rails; `options_hash` preserves
+          # the Symbol shape from the source, so coerce here.
           if (only = options[:only])
             Array(only) & default
           elsif (except = options[:except])
@@ -1362,21 +1185,17 @@ module Rigor
           options_hash(node)[key]
         end
 
-        # Reads a keyword option whose value is a literal String
-        # (returned as-is). Returns nil when the key is missing
-        # or the value is non-literal. Used for `scope(path:
-        # ':project_id', ...)` shape parsing where `:path` is
-        # passed as a keyword rather than a positional arg.
+        # Reads a keyword option whose value is a literal String (returned as-is). Returns nil when the key
+        # is missing or the value is non-literal. Used for `scope(path: ':project_id', ...)` shape parsing
+        # where `:path` is passed as a keyword rather than a positional arg.
         def keyword_value_string(node, key)
           value = options_hash(node)[key]
           value.is_a?(String) ? value : nil
         end
 
-        # `get 'help/*path' => 'help#show', as: :help_page` —
-        # the path lives in a String-keyed AssocNode of the
-        # trailing keyword/options hash (its value is the
-        # `controller#action` String). Returns the path String,
-        # or nil when no such hashrocket-key entry exists.
+        # `get 'help/*path' => 'help#show', as: :help_page` — the path lives in a String-keyed AssocNode of
+        # the trailing keyword/options hash (its value is the `controller#action` String). Returns the
+        # path String, or nil when no such hashrocket-key entry exists.
         def hashrocket_path_key(node)
           args = node.arguments&.arguments || []
           last = args.last
@@ -1409,29 +1228,24 @@ module Rigor
         def count_path_placeholders(path)
           return 0 if path.nil?
 
-          # Both `:name` (regular segment) and `*name` (wildcard
-          # / "globbing" segment) are Rails path parameters and
-          # contribute to helper arity. GitLab's
-          # `path: '*namespace_id'` outer scope adds 1 to the
-          # arity of every helper underneath.
+          # Both `:name` (regular segment) and `*name` (wildcard / "globbing" segment) are Rails path
+          # parameters and contribute to helper arity. GitLab's `path: '*namespace_id'` outer scope adds 1
+          # to the arity of every helper underneath.
           path.scan(/[:*][a-z_][a-z0-9_]*/).size
         end
 
-        # Number of placeholders inside `(...)` groups — Rails'
-        # optional-segment syntax (`'settings(/:tab)'`). Required
-        # arity is `count_path_placeholders - count_optional`;
-        # callers accepting a `(required..required+optional)`
-        # arity range register an entry per achievable arity.
+        # Number of placeholders inside `(...)` groups — Rails' optional-segment syntax
+        # (`'settings(/:tab)'`). Required arity is `count_path_placeholders - count_optional`; callers
+        # accepting a `(required..required+optional)` arity range register an entry per achievable arity.
         def count_optional_path_placeholders(path)
           return 0 if path.nil?
 
           path.scan(/\([^)]*\)/).sum { |group| group.scan(/[:*][a-z_][a-z0-9_]*/).size }
         end
 
-        # ADR-39 — delegates to the shared inflector (real
-        # `ActiveSupport::Inflector` when available). Previously a
-        # hand-tuned AS-replica kept in sync with `Context#singularize`;
-        # both now share the one authoritative implementation.
+        # ADR-39 — delegates to the shared inflector (real `ActiveSupport::Inflector` when available).
+        # Previously a hand-tuned AS-replica kept in sync with `Context#singularize`; both now share the
+        # one authoritative implementation.
         def singularize_word(word)
           Rigor::Plugin::Inflector.singularize(word)
         end