rigortype 0.1.19 → 0.2.0

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

@@ -132,8 +132,7 @@ module Rigor
         # ADR-60 WD3 record-and-validate: the producer's in-block
         # `AttachmentDiscoverer` reads are captured into the
         # dependency descriptor after the block runs, and the
-        # producer's `watch:` covers model-file additions — so no
-        # priming walk is needed (it used to run the discover twice).
+        # producer's `watch:` covers model-file additions.
         @attachment_index = cache_for(:attachment_index, params: {}).call
       rescue Plugin::AccessDeniedError => e
         @load_errors << "rigor-activestorage: #{e.message}"

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

@@ -44,19 +44,17 @@ module Rigor
     # `send_reset_password_instructions`, etc. resolve through the
     # synthetic-method tier without `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision tier
     #
-    # Slice 3 ships at the **floor**: synthesised method names
-    # emit and the dispatcher's `try_synthetic_method` tier
-    # returns `Type::Combinator.untyped` (Dynamic[T]) for every
-    # match. Per the slice-3 design judgment (1) the precision
-    # promotion — looking up the module's authored RBS return
-    # type at dispatch time — is **slice-6 ceiling work** and is
-    # NOT a delivery commitment of slice 3c. The `origin_module:`
-    # provenance field is recorded so the ceiling slice can
-    # promote without rescanning.
+    # The scanner records `origin_module:` in each synthetic
+    # method's provenance. The dispatcher's slice-6a TierB path
+    # (`promote_via_origin_module`) redispatches on
+    # `Nominal[origin_module]` via `RbsDispatch`, so Devise's
+    # authored RBS return types win: `valid_password?` returns
+    # `bool`, not `Dynamic[T]`. Unknown return types degrade
+    # gracefully to `Dynamic[T]`.
     #
-    # ## Scope (slice 3c minimum)
+    # ## Scope
     #
     # - Recognises model-side `devise :a, :b` on any AR::Base
     #   subclass; trait symbol set mirrors `lib/devise/modules.rb`.

data/plugins/rigor-dry-struct/lib/rigor/plugin/dry_struct.rb

@@ -35,16 +35,15 @@ module Rigor
     # other files then dispatch through the synthetic record rather
     # than falling through to `call.undefined-method`.
     #
-    # ## Floor / ceiling per ADR-16 WD13
+    # ## Precision model (ADR-16 WD13 + ADR-18)
     #
-    # Slice 2 ships at the **floor**: the synthetic reader's return
-    # type degrades to `Dynamic[T]`. The manifest's `returns: "Object"`
-    # is recorded but not resolved — precise return-type promotion
-    # (so `attribute :city, Types::String` makes `address.city`
-    # return `String`) is the **ceiling**, deferred to slice 6
-    # (ADR-13 `Plugin::TypeNodeResolver` chain). The plugin's manifest
-    # value of `returns:` would today be the upstream gem's reader
-    # return shape; slice 6 unlocks precision without re-authoring.
+    # The synthetic reader's return type is resolved via ADR-18's
+    # `returns_from_arg:` fact lookup: the call-site's second argument
+    # (`Types::String` etc.) is looked up through the `:dry_type_aliases`
+    # fact published by `rigor-dry-types`, yielding `Nominal[String]`
+    # for common cases. When the lookup misses (e.g. inline method-chain
+    # argument whose chain-head isn't currently extracted), the row
+    # falls back to `Dynamic[Top]` silently.
     #
     # ## Scope (slice 2c minimum)
     #

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -22,9 +22,8 @@ module Rigor
     # Other dry-rb adapter plugins consume this fact:
     #
     # - `rigor-dry-struct` reads it so `attribute :city, Types::String`
-    #   can promote `address.city` from `Dynamic[T]` to `Nominal[String]`
-    #   (gated on the slice-6 precision-promotion work + ADR-13
-    #   resolver chain).
+    #   promotes `address.city` from `Dynamic[Top]` to `Nominal[String]`
+    #   via ADR-18's `returns_from_arg:` fact lookup.
     # - `rigor-dry-validation` / `rigor-dry-schema` read it for
     #   per-key type recognition in `schema { … }` / `params { … }`
     #   blocks (separate plugin slice).
@@ -43,17 +42,19 @@ module Rigor
     #   "<UnderlyingClass>" }` so consumers can match on the
     #   qualified constant name they see in source.
     #
-    # The **ceiling** (slice 2+):
+    # Implemented beyond the floor:
     #
-    # - Recognises nested namespaces (`Types::Coercible::Integer`,
+    # - Nested-namespace aliases (`Types::Coercible::Integer`,
     #   `Types::Strict::Symbol`, `Types::Params::Bool`,
-    #   `Types::JSON::Date`) — each is a separate dry-types
-    #   "category" with its own coercion semantics.
-    # - Recognises user-authored compositions
-    #   (`Types::String.constrained(min_size: 1)`,
-    #   `Email = Types::String.constrained(format: …)`) so the
-    #   alias surface extends beyond the canonical names.
-    # - Emits `dry-types.unknown-alias` / `dry-types.alias-shadow`
+    #   `Types::JSON::Date`) — the four coercion categories each
+    #   map to the same underlying class as their canonical shortcut.
+    # - User-authored compositions (`Email = Types::String.constrained(...)`,
+    #   transitive resolution through composition chains) — the alias
+    #   surface extends beyond the 15 canonical names.
+    #
+    # Deferred:
+    #
+    # - `dry-types.unknown-alias` / `dry-types.alias-shadow`
     #   diagnostics when downstream code references a name that
     #   wasn't published.
     #

data/plugins/rigor-dry-validation/lib/rigor/plugin/dry_validation.rb

@@ -21,10 +21,9 @@ module Rigor
     #   cross-plugin fact.
     # - Ships an RBS overlay (`sig/dry_validation.rbs`) typing
     #   `Dry::Validation::Contract#call` (returns Result) and
-    #   `Dry::Validation::Result#{success?, failure?, to_h}`. Users
-    #   add the path to their `.rigor.yml`'s `signature_paths:` so
-    #   `contract.call(input).to_h` infers cleanly. See the README
-    #   for the wiring step.
+    #   `Dry::Validation::Result#{success?, failure?, to_h}`.
+    #   The manifest's `signature_paths: ["sig"]` auto-contributes
+    #   the overlay (ADR-25) — no project-side wiring needed.
     #
     # Slice 2 (deferred, per design note):
     #

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

@@ -86,14 +86,14 @@ module Rigor
         # a `Prism::SymbolNode` is treated as a literal
         # attribute reference.
         #
-        # Phase 1 (c) — when `model_index` (the cross-plugin
-        # `:model_index` fact published by rigor-activerecord)
-        # is present, the effective accepted key set is the
-        # UNION of the factory's declared attributes plus the
-        # corresponding model's columns. FactoryBot's runtime
-        # accepts any AR attribute regardless of whether the
-        # factory declared it, so the cross-check broadens the
-        # acceptance accordingly.
+        # When `model_index` (the cross-plugin `:model_index`
+        # fact published by rigor-activerecord) is present,
+        # the effective accepted key set is the UNION of the
+        # factory's declared attributes plus the corresponding
+        # model's columns. FactoryBot's runtime accepts any AR
+        # attribute regardless of whether the factory declared
+        # it, so the cross-check broadens the acceptance
+        # accordingly.
         def unknown_attribute_violations(call_node, entry, model_index)
           accepted_keys, suggestion_dictionary = effective_keys(entry, model_index)
           attr_spell_checker = DidYouMean::SpellChecker.new(dictionary: suggestion_dictionary)

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -23,8 +23,8 @@ module Rigor
       # - `factory :users, aliases: [:author] do ... end` — alias form
       #
       # Inside a factory block, attribute declarations come in
-      # several shapes. Phase 1 (a) recognises the literal-name
-      # forms only (Symbol arg / String arg):
+      # several shapes. Only literal-name forms are recognised
+      # (Symbol arg / String arg):
       #
       # - `name { "Alice" }` — implicit attribute via
       #   `method_missing` with a block (FactoryBot's modern
@@ -116,8 +116,8 @@ module Rigor
           Rigor::Source::Literals.symbol_or_string_name(call_node.arguments&.arguments&.first)
         end
 
-        # Pillar 2 Slice 3 — resolve the model class name for
-        # the factory. Three sources, in priority order:
+        # Resolves the model class name for the factory.
+        # Three sources, in priority order:
         #
         # 1. Explicit `class: <Const>` keyword arg —
         #    ConstantReadNode / ConstantPathNode value.
@@ -188,11 +188,10 @@ module Rigor
           attributes
         end
 
-        # Walks the block body collecting attribute names. The
-        # recogniser looks at top-level statements only —
-        # attributes inside `trait :admin do ... end` or other
-        # nested blocks are NOT collected in Phase 1 (a)
-        # (traits ship in a follow-up).
+        # Walks the block body collecting attribute names. Only
+        # top-level statements are examined — attributes inside
+        # `trait :admin do ... end` or other nested blocks are
+        # not collected (traits deferred to a follow-up).
         def collect_attributes_from(node, accumulator)
           return unless node.is_a?(Prism::Node)
 
@@ -206,8 +205,7 @@ module Rigor
         def record_attribute(node, accumulator)
           return unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           # Skip association / sequence / trait / framework
-          # methods — Phase 1 (a) only records plain attribute
-          # declarations.
+          # methods — only plain attribute declarations are recorded.
           return if SKIPPED_METHODS.include?(node.name)
 
           name = if node.name == :add_attribute

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_index.rb

@@ -4,15 +4,14 @@ module Rigor
   module Plugin
     class Factorybot < Rigor::Plugin::Base
       # Per-run frozen index of discovered FactoryBot factories
-      # and the attribute keys each declares. Phase 1 (a) keys
-      # only the **literal symbol/string** factory name + the
-      # **literal symbol** attribute names; sequences,
-      # parent/child relationships, traits, and dynamically-
-      # named factories ship behind later slices.
+      # and the attribute keys each declares. Indexes only
+      # **literal symbol/string** factory names + **literal
+      # symbol** attribute names; sequences, parent/child
+      # relationships, traits, and dynamically-named factories
+      # are deferred to follow-up slices.
       #
-      # v0.2.0 (Pillar 2 Slice 3) adds `model_class` to each
-      # entry — the inferred or explicit class the factory
-      # builds. Resolved from:
+      # Each entry carries a `model_class` — the inferred or
+      # explicit class the factory builds. Resolved from:
       #
       #   1. An explicit `factory :user, class: User do`
       #      keyword option (ConstantReadNode / ConstantPathNode

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

@@ -13,12 +13,10 @@ module Rigor
     # attributes_for / *_list family against a per-run index
     # built from `factory_search_paths`.
     #
-    # **Phase 1 (a)** of the FactoryBot plugin family — the
-    # self-contained slice. Recognises factory NAMES + literal
-    # ATTRIBUTE KEYS in the call's keyword hash. Phase 1 (c)
-    # ships the AR column cross-check via the
-    # `rigor-activerecord` `:model_index` ADR-9 fact, after
-    # `rigor-activerecord` adds the matching publish hook.
+    # Recognises factory NAMES + literal ATTRIBUTE KEYS in
+    # the call's keyword hash. The AR column cross-check uses
+    # the `rigor-activerecord` `:model_index` ADR-9 fact when
+    # that plugin is loaded (optional `consumes:`).
     # Traits, sequences, parent / child factories, and dynamic
     # factory names are deferred to follow-up slices.
     #
@@ -54,9 +52,9 @@ module Rigor
     # `.build_stubbed_list`. The legacy `FactoryGirl` constant
     # is recognised identically. Implicit-receiver calls
     # (`create(:name)` inside an `include FactoryBot::Syntax::Methods`
-    # context) are NOT recognised in Phase 1 (a) — too many
-    # false positives on plain `create` calls outside test
-    # files; this needs receiver-type inference (Phase 1 (b)).
+    # context) are NOT recognised — too many false positives on
+    # plain `create` calls outside test files; deferred until
+    # receiver-type inference can disambiguate.
     #
     # ## What's recognised inside `factory :name do ... end`
     #

data/plugins/rigor-graphql/lib/rigor/plugin/graphql/type_scanner.rb

@@ -50,12 +50,13 @@ module Rigor
 
         # @param paths [Array<String>] absolute paths to `.rb` files
         #   the project's `paths:` resolves to.
-        # @return [Hash{Symbol => Hash}] frozen 3-key result with
+        # @return [Hash{Symbol => Hash}] frozen 4-key result:
         #   `:types` (per-`Schema::Object` field table),
-        #   `:enums` (per-`Schema::Enum` value list), and
-        #   `:input_objects` (per-`Schema::InputObject` argument
-        #   table). Any subset may be empty when no recognisable
-        #   declaration of that kind is found.
+        #   `:enums` (per-`Schema::Enum` value list),
+        #   `:input_objects` (per-`Schema::InputObject` argument table),
+        #   `:mutations` (per-`Schema::Mutation` arguments+fields table).
+        #   Any subset may be empty when no recognisable declaration
+        #   of that kind is found.
         def scan(paths:)
           acc = empty_accumulator
           paths.each do |path|
@@ -97,10 +98,9 @@ module Rigor
         private_class_method :scan_file
 
         # Walks the AST collecting `class X < GraphQL::Schema::Object`,
-        # `class X < GraphQL::Schema::Enum`, and
-        # `class X < GraphQL::Schema::InputObject` decls at any
-        # nesting level. Returns a 3-key hash so the caller can
-        # publish multiple cross-plugin facts from one walk.
+        # `Schema::Enum`, `Schema::InputObject`, and `Schema::Mutation`
+        # decls at any nesting level. Returns a 4-key hash so the
+        # caller can publish multiple cross-plugin facts from one walk.
         def collect_definitions(node, qualified_prefix)
           return empty_accumulator if node.nil?
 
@@ -203,10 +203,9 @@ module Rigor
         # The first positional must be a String literal — the
         # graphql-ruby `value` API also accepts a Symbol form
         # (`value :ACTIVE`) but the documented idiom is String.
-        # Slice 2b only stores the GraphQL-side value name; the
-        # optional `value:` kwarg (Ruby-side override) and
-        # `description:` stay out of the published table for
-        # the floor.
+        # Only the GraphQL-side value name is stored; the optional
+        # `value:` kwarg (Ruby-side override) and `description:`
+        # are omitted from the published table.
         def collect_values(body)
           return [] if body.nil?
 

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

@@ -25,10 +25,10 @@ module Rigor
     # resolver methods themselves; rigor's value here is producing a
     # static type table downstream consumers can cross-reference.
     #
-    # ## What downstream consumers DO with `:graphql_type_table`
+    # ## What downstream consumers DO with the published facts
     #
-    # The fact is the substrate for two future capabilities (both
-    # demand-driven, NOT in slice 1):
+    # The tables are the substrate for two future capabilities
+    # (demand-driven, not yet implemented):
     #
     # - Resolver-method check: for each `field :name, Type` whose
     #   `name` is also defined as a Ruby method on the class, verify
@@ -37,33 +37,25 @@ module Rigor
     #   plugin could type `Schema.execute(query).to_h` against the
     #   queried fields.
     #
-    # ## Floor / ceiling (slice 1)
+    # ## What's recognised
     #
-    # Slice 1 ships the **floor**:
+    # - `class T < GraphQL::Schema::Object` subclasses (including
+    #   nested namespaces); `field :name, Type, null: ...`
+    #   declarations with constant-reference or list-array types
+    #   and GraphQL→Ruby scalar mapping.
+    # - `class T < GraphQL::Schema::Enum`; `value "ACTIVE"` calls.
+    # - `class T < GraphQL::Schema::InputObject` /
+    #   `GraphQL::Schema::Mutation`; `argument :name, Type,
+    #   required: ...` declarations.
+    # - No user-facing diagnostics yet.
     #
-    # - Recognises `class T < GraphQL::Schema::Object` subclasses
-    #   (including nested namespaces: `class Types::User < ...`,
-    #   `module Types; class User < ...; end; end`).
-    # - Recognises the `field :name, Type, **opts` declaration with:
-    #   - `Type` as a `ConstantReadNode` / `ConstantPathNode` (`String`
-    #     / `Integer` / `Boolean` / `Float` / `ID`, or a user-defined
-    #     `Types::OtherObject`).
-    #   - `null: true` / `null: false` keyword extracts nullability.
-    # - Maps the canonical GraphQL scalar names to underlying Ruby
-    #   classes (`String` → `String`, `Integer` → `Integer`,
-    #   `Boolean` → `TrueClass`, `Float` → `Float`, `ID` → `String`).
-    # - Publishes the table; no user-facing diagnostics yet.
+    # ## Deferred (demand-driven)
     #
-    # The **ceiling** (future slices, demand-driven):
-    #
-    # - **`GraphQL::Schema::Enum`** with `value "ACTIVE"` calls.
-    # - **`GraphQL::Schema::Mutation`** + **`GraphQL::Schema::InputObject`**.
-    # - **List / Non-Null wrappers** (`[String]`, `String.array`).
     # - **`resolver:` / `mutation:` reroute** recognition.
     # - **String type expressions** (`field :foo, "User"`) — defeats
     #   static resolution by design (graphql-ruby's `BuildType.parse_type`
     #   constantizes at runtime); a future slice could surface these
-    #   as `graphql.string-type` `:info` diagnostics that point the
+    #   as `graphql.string-type` `:info` diagnostics pointing the
     #   user at the constant-reference form for static typing.
     class Graphql < Rigor::Plugin::Base
       manifest(

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

@@ -71,9 +71,9 @@ module Rigor
     # - `is_a?(Result::Ok)` / `Some` / `None` exhaustive
     #   narrowing — core control-flow analysis over a sealed
     #   hierarchy, not a plugin surface.
-    # - The `variants do variant Const, Type end` Enum DSL — needs
-    #   an ADR-16 nested-class emission tier (ADR-36). Today's
-    #   contract has no `const_set`-emitting macro substrate.
+    # - The `variants do variant Const, Type end` Enum DSL is handled
+    #   via ADR-36 `nested_class_templates:` in this plugin's manifest
+    #   (Slice A — see `nested_class_templates:` block below).
     class Mangrove < Rigor::Plugin::Base
       manifest(
         id: "mangrove",

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

@@ -30,10 +30,10 @@ module Rigor
     #
     # ## Configuration
     #
-    # No knobs in v0.1.0. Activate via `plugins: ["rigor-minitest"]`
-    # in `.rigor.yml`.
+    # No configuration knobs. Activate via
+    # `plugins: ["rigor-minitest"]` in `.rigor.yml`.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - **No `assert_raises(T) { ... }`** — that's a block-shape
     #   matcher and Rigor's narrowing model is for

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

@@ -169,7 +169,7 @@ module Rigor
 
         # Extracts the literal-string first argument when
         # present. Returns nil for variable / expression keys —
-        # those are out of scope for v0.1.0.
+        # only literal keys are statically validated.
         def literal_key_for(call_node)
           args = call_node.arguments&.arguments || []
           return nil if args.empty?
@@ -224,9 +224,7 @@ module Rigor
 
         def collect_assoc_keys(hash_node)
           # Both `Prism::HashNode` and `Prism::KeywordHashNode`
-          # expose `#elements`; the conditional was an
-          # accidental no-op carried over from an earlier
-          # draft.
+          # expose `#elements`, so a single path handles both.
           hash_node.elements.filter_map do |element|
             next nil unless element.is_a?(Prism::AssocNode)
 

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

@@ -57,7 +57,7 @@ module Rigor
             parsed.each do |locale, tree|
               locale = locale.to_s
               locales << locale
-              flatten_tree(tree, []).each do |dotted_key, value|
+              each_flattened(tree, []) do |dotted_key, value|
                 placeholders = (per_key[dotted_key] ||= {})
                 placeholders[locale] = extract_placeholders(value)
                 kinds = (per_key_kinds[dotted_key] ||= {})
@@ -101,24 +101,40 @@ module Rigor
         end
 
         # Recursively walks the per-locale subtree, yielding
-        # `[dotted_key, leaf_value]` pairs. Hash leaves are
+        # `[dotted_key, leaf_value]` for each leaf. Hash leaves are
         # *not* recorded as entries themselves — only their
-        # descendants — but every leaf scalar / array IS
-        # recorded.
-        def flatten_tree(node, breadcrumbs)
-          case node
-          when Hash
-            node.flat_map do |k, v|
-              flatten_tree(v, breadcrumbs + [k.to_s])
+        # descendants — but every leaf scalar / array IS recorded.
+        #
+        # `breadcrumbs` is a single mutable stack reused across the
+        # whole walk (push before recursing, pop after): for the
+        # 530-file / 14 MB Mastodon locale corpus the old
+        # `flat_map { flatten_tree(v, breadcrumbs + [k]) }` shape
+        # allocated a fresh breadcrumb Array at every node plus an
+        # intermediate result Array at every level — millions of
+        # short-lived objects and the run's top allocation site. The
+        # dotted key is still materialised once per leaf (it has to
+        # be); everything else is now allocation-free traversal.
+        def each_flattened(node, breadcrumbs, &)
+          if node.is_a?(Hash)
+            node.each do |k, v|
+              breadcrumbs.push(k.to_s)
+              each_flattened(v, breadcrumbs, &)
+              breadcrumbs.pop
             end
           else
-            [[breadcrumbs.join("."), node]]
+            yield breadcrumbs.join("."), node
           end
         end
 
         def extract_placeholders(value)
           case value
-          when String then value.scan(PLACEHOLDER_RE).flatten.to_set
+          when String
+            # Most locale leaves carry no `%{var}`; skip the scan +
+            # flatten + to_set allocation trio for them. A string with
+            # no `%{` yields an empty placeholder set either way.
+            return Set.new unless value.include?("%{")
+
+            value.scan(PLACEHOLDER_RE).flatten.to_set
           when Array then value.map { |v| extract_placeholders(v) }.reduce(Set.new) { |a, s| a | s }
           else Set.new
           end

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

@@ -40,7 +40,7 @@ module Rigor
     #    arguments. Missing placeholders are errors; extra
     #    arguments are warnings.
     #
-    # ## Limitations (v0.1.0)
+    # ## Limitations
     #
     # - Only literal-string keys are validated. `t(key)` with
     #   a variable receiver is silently passed through.

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

@@ -38,11 +38,9 @@ module Rigor
       #   (`user_facebook_omniauth_authorize_path`) and Devise
       #   declares them from the configured providers, which
       #   live in an initializer this static parser does not
-      #   read. We register the SHAPE-FAMILY suffix matchers
-      #   `_omniauth_authorize_path` / `_omniauth_callback_path`
-      #   via a separate hook (see `OMNIAUTH_HELPER_PATTERNS`);
-      #   these are NOT in the table but consulted by the
-      #   `Analyzer.allowed_dynamic_pattern?` check.
+      #   read. The suffix patterns are registered in
+      #   `OMNIAUTH_SUFFIXES` and consulted by
+      #   `HelperTable#omniauth_match?`.
       module DeviseRoutes
         # The standard Devise controllers and the helper
         # actions each generates. Keys are the controller
@@ -190,7 +188,7 @@ module Rigor
 
         # Returns the set of OmniAuth pattern suffixes the
         # analyzer accepts for a given resource. The analyzer
-        # consults this set (via `HelperTable#allows_omniauth?`)
+        # consults this set (via `HelperTable#omniauth_match?`)
         # when a `*_path` / `*_url` call's name does not match
         # any registered entry and its prefix matches a Devise
         # resource.

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

@@ -1171,9 +1171,10 @@ module Rigor
         end
 
         def in_singular_resource?(*)
-          # Slice 1 doesn't model the singular-resource frame
-          # separately; placeholder so member / collection
-          # blocks at least descend.
+          # 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
 
@@ -1181,21 +1182,14 @@ module Rigor
         # `plural: true` for `resources :users`, `false` for
         # `resource :profile`.
         def register_resourceful_helpers(name, actions, base_arity, context, plural:)
-          # Singular resources (`resource :foo`) use the
-          # given name AS-IS for both path and helper —
-          # singularising would mangle a deliberately-plural
-          # singular-DSL name like Mastodon's
-          # `resource :relationships, only: [:show, :update]`
-          # (Rails generates `relationships_path`, not
-          # `relationship_path`). Plural resources still
-          # singularise for the show / new / edit helpers.
-          # Plural resources singularise for show / new / edit
-          # helpers (`resources :users` → `user_path(id)`);
-          # singular resources use the name AS-IS even when it
-          # looks plural (Mastodon's `resource :relationships,
-          # only: [:show, :update]` → `relationships_path`).
-          # The path segment 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}"
 

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

@@ -26,9 +26,9 @@ module Rigor
     # - One level of nested `resources`
     #
     # The plugin publishes its parsed `:helper_table` through
-    # the ADR-9 cross-plugin fact store so future
-    # `rigor-actionpack` Phase 4 can consume it for
-    # route-helper validation in controller code.
+    # the ADR-9 cross-plugin fact store; `rigor-actionpack`
+    # Phase 4 consumes it for route-helper validation in
+    # controller code.
     #
     # ## Configuration
     #
@@ -147,8 +147,8 @@ module Rigor
       end
 
       # Publishes the parsed table to the cross-plugin fact
-      # store so future Tier 2 plugins (rigor-actionpack
-      # Phase 4) can read it via `services.fact_store.read`.
+      # store; `rigor-actionpack` Phase 4 reads it via
+      # `services.fact_store.read`.
       def prepare(services)
         table = helper_table_or_nil
         return if table.nil?

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb

@@ -21,10 +21,9 @@ module Rigor
       #   { ... }` and `subject(:name) { ... }` declarations.
       #   `:subject` is the key for the implicit `subject { ... }`.
       #
-      # Pillar 2 Slice 2 — used by the plugin's let-binding
-      # `dynamic_return` rule to bind `let`-named
-      # method-shape calls inside `it` bodies to the let
-      # block's inferred type.
+      # Used by the plugin's let-binding `dynamic_return`
+      # rule to bind `let`-named method-shape calls inside
+      # `it` bodies to the let block's inferred type.
       class LetScopeIndex
         Record = Struct.new(:outer_range, :describe_const, :lets, keyword_init: true) do
           def contains?(line) = outer_range.cover?(line)

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_type_resolver.rb

@@ -6,7 +6,7 @@ require "rigor/type"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 2 — resolves the runtime type of a
+      # Resolves the runtime type of a
       # `let(:name) { body }` or `subject(:name) { body }`
       # block by pattern-matching its body's tail expression.
       #

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/matcher_analyzer.rb

@@ -8,7 +8,7 @@ require "rigor/flow_contribution/fact"
 module Rigor
   module Plugin
     class Rspec < Rigor::Plugin::Base
-      # Pillar 2 Slice 1 — recognises `expect(x).to MATCHER`
+      # Recognises `expect(x).to MATCHER`
       # patterns at per-call recognition time and emits
       # `post_return_facts` that narrow the named local on the
       # post-call edge.