rigortype 0.2.8 → 0.3.0

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -33,12 +35,25 @@ module Rigor
         # @param io_boundary [Rigor::Plugin::IoBoundary]
         # @param search_paths [Array<String>] absolute or project-relative paths.
         # @param base_classes [Array<String>] superclass names that identify a class as an AR model.
+        # Declaration macros whose column's runtime value is a rich object, not the SQL scalar. Their column
+        # must NOT be narrowed to the schema type (see {ModelIndex.build}'s type-override remap).
+        TYPE_OVERRIDE_METHODS = %i[serialize mount_uploader mount_uploaders].freeze
+
         def initialize(io_boundary:, search_paths:, base_classes:)
           @io_boundary = io_boundary
           @search_paths = search_paths
           @base_classes = base_classes.to_set
+          # Global set of column names whose declared runtime type overrides the schema scalar
+          # (`serialize` / `mount_uploader` / `attribute :x, CustomType`). Collected across every class AND
+          # concern module walked — a serialize inside a concern's `included do … end` is invisible to the
+          # per-model view (the discoverer doesn't follow `include`), so overrides are tracked globally by
+          # column name and applied wherever that column appears. Over-suppresses a same-named scalar
+          # column elsewhere (a precision cost, never a false positive).
+          @type_override_columns = Set.new
         end
 
+        attr_reader :type_override_columns
+
         # @return [Array<Hash>] rows of { class_name:, table_name_override:, sti_parent:, ... }
         def discover
           candidates = []
@@ -127,7 +142,7 @@ module Rigor
           when Prism::ModuleNode
             visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk_for_classes(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk_for_classes(child, lexical_path, &) }
           end
         end
 
@@ -141,6 +156,8 @@ module Rigor
           full_name = (lexical_path + [class_local_name]).join("::")
           superclass = constant_path_name(node.superclass) if node.superclass
 
+          collect_type_overrides(node.body)
+
           yield({
             class_name: full_name,
             superclass_name: superclass,
@@ -162,10 +179,56 @@ module Rigor
           module_local_name = constant_path_name(node.constant_path)
           return if module_local_name.nil?
 
+          # Concerns (`module DiffPositionableNote`) carry `serialize` / `mount_uploader` inside an
+          # `included do … end` block; collect their overrides even though the module itself is not a model.
+          collect_type_overrides(node.body)
+
           inner_path = lexical_path + [module_local_name]
           walk_for_classes(node.body, inner_path, &) if node.body
         end
 
+        # Records the column name of every `serialize :col` / `mount_uploader(s) :col` / `attribute :col,
+        # CustomType` in `body` (descending into `with_options` and concern `included do` blocks) into the
+        # global {#type_override_columns} set. `attribute :col, :symbol_type` (a built-in scalar type) is
+        # NOT an override — only a custom type CONSTANT is.
+        def collect_type_overrides(body)
+          type_override_declaration_calls(body).each do |node|
+            next if node.receiver
+
+            column = Rigor::Source::Literals.symbol_name(node.arguments&.arguments&.first)
+            next if column.nil?
+
+            if TYPE_OVERRIDE_METHODS.include?(node.name)
+              @type_override_columns << column
+            elsif node.name == :attribute && custom_type_attribute?(node)
+              @type_override_columns << column
+            end
+          end
+        end
+
+        # `declaration_calls` variant that also descends into a concern's `included do … end` block (the
+        # ActiveSupport::Concern idiom where models' shared `serialize` declarations live).
+        def type_override_declaration_calls(body)
+          return [] if body.nil?
+
+          body.compact_child_nodes.flat_map do |node|
+            next [] unless node.is_a?(Prism::CallNode)
+
+            if %i[with_options included].include?(node.name) && node.block.is_a?(Prism::BlockNode)
+              type_override_declaration_calls(node.block.body)
+            else
+              [node]
+            end
+          end
+        end
+
+        # True when an `attribute :col, <type>` call's type argument is a custom type CLASS (a constant),
+        # whose runtime value is a rich object — not a built-in `:symbol` type, which stays a scalar.
+        def custom_type_attribute?(node)
+          type_arg = node.arguments&.arguments&.[](1)
+          type_arg.is_a?(Prism::ConstantReadNode) || type_arg.is_a?(Prism::ConstantPathNode)
+        end
+
         # Renders a constant-path node (`Admin::User`, `::ApplicationRecord`) as a String. Returns nil for
         # shapes the discoverer chooses not to handle.
         def constant_path_name(node)
@@ -195,7 +258,7 @@ module Rigor
         def lookup_table_name_override(body)
           return nil if body.nil?
 
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode) && node.name == :table_name=
             next unless node.receiver.is_a?(Prism::SelfNode)
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_index.rb

@@ -88,15 +88,16 @@ module Rigor
         def class_names = entries.keys
         def empty? = entries.empty?
 
-        def self.build(model_rows:, schema_table:)
+        def self.build(model_rows:, schema_table:, type_override_columns: nil)
           rows_by_name = model_rows.to_h { |row| [row.fetch(:class_name), row] }
+          overrides = type_override_columns || []
 
           entries = model_rows.each_with_object({}) do |row, acc|
             class_name = row.fetch(:class_name)
             # The STI ancestry chain, root → self. For a plain (non-STI) model this is just `[row]`.
             chain = sti_chain(row, rows_by_name)
             table_name = sti_table_name(chain)
-            columns = schema_table.columns_for(table_name) || []
+            columns = apply_type_overrides(schema_table.columns_for(table_name) || [], overrides)
 
             # STI children inherit their ancestors' declared associations / enums / aliases / scopes /
             # validations / callbacks. Without the merge a `where(<parent-association>: ...)` on the
@@ -116,6 +117,23 @@ module Rigor
           new(entries.freeze)
         end
 
+        # Remaps every type-overridden column's `ruby_type` to `"Object"` so instance-side column narrowing
+        # declines to narrow it (the `"Object"` case in `ruby_type_to_type`). A `serialize` / `mount_uploader`
+        # / custom-`attribute` column reads as a rich object at runtime, not its SQL scalar, so narrowing it
+        # to e.g. `String` false-positives on the object's methods (`note.position.diff_refs`). The column
+        # stays in the set, so `where(col: ...)` existence validation is unaffected — only its value type.
+        def self.apply_type_overrides(columns, overrides)
+          return columns if overrides.empty?
+
+          columns.map do |column|
+            next column unless overrides.include?(column.name)
+
+            SchemaTable::Column.new(
+              name: column.name, type: column.type, ruby_type: "Object", array: column.array
+            )
+          end
+        end
+
         # The STI ancestry chain for a row, ordered root → self. Walks `sti_parent` pointers, guarding
         # against a cycle.
         def self.sti_chain(row, rows_by_name, seen = [])

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/schema_parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -66,7 +68,7 @@ module Rigor
 
           yield node if node.is_a?(Prism::CallNode) && node.name == :create_table && node.receiver.nil?
 
-          node.compact_child_nodes.each { |child| collect_create_table_calls(child, &) }
+          node.rigor_each_child { |child| collect_create_table_calls(child, &) }
         end
 
         def parse_create_table(call_node)
@@ -118,7 +120,7 @@ module Rigor
             return
           end
 
-          node.compact_child_nodes.each { |child| collect_column_calls(child, &) }
+          node.rigor_each_child { |child| collect_column_calls(child, &) }
         end
 
         def parse_column(call_node)

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/structure_sql_parser.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require_relative "schema_table"
+
+module Rigor
+  module Plugin
+    class Activerecord < Rigor::Plugin::Base
+      # Parses a PostgreSQL `db/structure.sql` (the `schema_format = :sql` schema dump) into the same
+      # {SchemaTable} the Ruby-DSL {SchemaParser} produces, so a project that commits `structure.sql`
+      # instead of `schema.rb` is no longer inert (GitLab-class apps use `structure.sql`; without this the
+      # plugin skips every AR call check and — worse — degrades ordinary relation chains to `Array`,
+      # cascading false diagnostics).
+      #
+      # The dump is regular enough to read line-by-line without a SQL parser. `pg_dump` emits, per table:
+      #
+      #   CREATE TABLE namespaces (
+      #       id bigint NOT NULL,
+      #       name character varying NOT NULL,
+      #       visibility_level integer DEFAULT 20 NOT NULL,
+      #       tag_ids bigint[],
+      #       created_at timestamp without time zone
+      #   );
+      #
+      # Load-bearing regularities this relies on: column names / types are lowercase, column modifiers
+      # (`NOT NULL`, `DEFAULT …`, `GENERATED …`, `COLLATE …`) are UPPERCASE, one column per line, the body
+      # closes on a line starting with `)`. So the type is the run of tokens before the first
+      # uppercase-initial token, and a table-level constraint line (`CONSTRAINT …`, `PRIMARY KEY …`) is
+      # recognised by its uppercase leading keyword and skipped. Anything it cannot map (custom enum,
+      # `tsvector`, `ltree`) degrades to `Object` via {SchemaTable.ruby_type_for} — never a dropped column,
+      # which would turn every query on it into a false `unknown-column`.
+      class StructureSqlParser
+        # Normalised PostgreSQL type (lowercased, length/precision + `[]` stripped) → the Rails column-type
+        # symbol {SchemaTable.ruby_type_for} already understands. Unmapped types fall through to their own
+        # symbol, which `ruby_type_for` maps to `Object` (the safe "do not narrow" default).
+        PG_TYPE_TO_RAILS = {
+          "bigint" => :bigint, "int8" => :bigint, "bigserial" => :bigint,
+          "integer" => :integer, "int" => :integer, "int4" => :integer, "serial" => :integer,
+          "smallint" => :integer, "int2" => :integer, "smallserial" => :integer,
+          "boolean" => :boolean, "bool" => :boolean,
+          "text" => :text,
+          "character varying" => :string, "varchar" => :string,
+          "character" => :string, "char" => :string, "name" => :string, "citext" => :citext,
+          "timestamp without time zone" => :datetime, "timestamp with time zone" => :datetime,
+          "timestamp" => :datetime, "timestamptz" => :datetime,
+          "date" => :date,
+          "time without time zone" => :time, "time with time zone" => :time, "time" => :time,
+          "numeric" => :decimal, "decimal" => :decimal, "money" => :decimal,
+          "double precision" => :float, "real" => :float, "float8" => :float, "float4" => :float,
+          "bytea" => :binary,
+          "json" => :json, "jsonb" => :jsonb,
+          "uuid" => :uuid, "inet" => :inet, "cidr" => :string, "macaddr" => :string
+        }.freeze
+
+        # Uppercase leading keywords that mark a table-level constraint line rather than a column.
+        CONSTRAINT_KEYWORDS = %w[CONSTRAINT PRIMARY UNIQUE CHECK FOREIGN EXCLUDE LIKE PARTITION].freeze
+
+        # @param source [String] contents of `db/structure.sql`
+        # @return [SchemaTable]
+        def self.parse(source)
+          new.parse(source)
+        end
+
+        def parse(source)
+          tables = {}
+          each_create_table(source.to_s) do |table_name, body_lines|
+            columns = parse_columns(body_lines)
+            tables[table_name] = columns unless columns.empty?
+          end
+          SchemaTable.new(tables.freeze)
+        end
+
+        private
+
+        # Yields `[table_name, body_lines]` for every `CREATE TABLE … (` … `)` block. Body lines are the raw
+        # lines between the opening `(` line and the closing `)` line.
+        def each_create_table(source)
+          lines = source.lines
+          index = 0
+          while index < lines.length
+            match = lines[index].match(/\ACREATE (?:UNLOGGED |TEMPORARY )?TABLE (?:IF NOT EXISTS )?(\S+)\s*\(/)
+            unless match
+              index += 1
+              next
+            end
+
+            table_name = normalize_table_name(match[1])
+            index += 1
+            body = []
+            while index < lines.length && lines[index] !~ /\A\s*\)/
+              body << lines[index]
+              index += 1
+            end
+            yield(table_name, body) if table_name
+            index += 1 # step past the closing `)` line
+          end
+        end
+
+        # Strips quotes and a leading schema qualifier. Only the default `public` schema (or an unqualified
+        # name) is accepted; other schemas (`gitlab_partitions_dynamic.*`, etc.) are partitions of a base
+        # table already emitted unqualified, so returning nil skips them without losing a real table.
+        def normalize_table_name(raw)
+          name = raw.delete('"')
+          if name.include?(".")
+            schema, table = name.split(".", 2)
+            return nil unless schema == "public"
+
+            name = table
+          end
+          name.empty? ? nil : name
+        end
+
+        def parse_columns(body_lines)
+          columns = {}
+          # A column's `DEFAULT` may carry a multi-line single-quoted string (a serialized YAML default,
+          # `DEFAULT '--- []\n'::character varying`). The column name + type sit before the `DEFAULT`, so
+          # the first physical line still parses correctly; the continuation lines must be skipped or they
+          # read as bogus columns (`'::character varying`). A line with an ODD count of single quotes opens
+          # (or closes) such a string — PG doubles a literal quote (`''`), so escapes stay even and only a
+          # genuinely unterminated string toggles the state.
+          in_string = false
+          body_lines.each do |raw|
+            if in_string
+              in_string = false if raw.count("'").odd?
+              next
+            end
+            in_string = true if raw.count("'").odd?
+
+            line = raw.strip.chomp(",")
+            next if line.empty?
+
+            name, rest = line.split(/\s+/, 2)
+            next if name.nil? || rest.nil?
+            next if CONSTRAINT_KEYWORDS.include?(name) # a table-level constraint, not a column
+
+            column = build_column(name.delete('"'), rest)
+            columns[column.name] = column if column
+          end
+          columns.freeze
+        end
+
+        def build_column(name, rest)
+          type_str, array = extract_type(rest)
+          return nil if type_str.empty?
+
+          rails_type = PG_TYPE_TO_RAILS.fetch(type_str, type_str.to_sym)
+          SchemaTable::Column.new(
+            name: name,
+            type: rails_type,
+            ruby_type: SchemaTable.ruby_type_for(rails_type),
+            array: array
+          )
+        end
+
+        # The type is every token before the first uppercase-initial token (a column modifier such as
+        # `NOT`, `NULL`, `DEFAULT`, `GENERATED`, `COLLATE`). A trailing `[]` marks a Postgres array column;
+        # a `(length[,scale])` specifier is dropped. Returns `[normalized_type, array?]`.
+        def extract_type(rest)
+          type_tokens = []
+          rest.split(/\s+/).each do |token|
+            break if token.match?(/\A[A-Z]/)
+
+            type_tokens << token
+          end
+          type_str = type_tokens.join(" ")
+          array = type_str.include?("[]")
+          type_str = type_str.gsub("[]", "").gsub(/\([0-9,\s]*\)/, "").strip.downcase
+          [type_str, array]
+        end
+      end
+    end
+  end
+end

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

@@ -4,6 +4,7 @@ require "rigor/plugin"
 
 require_relative "activerecord/schema_table"
 require_relative "activerecord/schema_parser"
+require_relative "activerecord/structure_sql_parser"
 require_relative "activerecord/model_index"
 require_relative "activerecord/model_discoverer"
 require_relative "activerecord/analyzer"
@@ -18,7 +19,8 @@ module Rigor
     # Two cached producers per plugin run:
     #
     # 1. `:schema_table` reads `db/schema.rb` via the `IoBoundary` and parses it through {SchemaParser} into
-    #    a {SchemaTable} mapping `table_name → { column_name → Column }`.
+    #    a {SchemaTable} mapping `table_name → { column_name → Column }`. When `db/schema.rb` is absent it
+    #    falls back to a PostgreSQL `db/structure.sql` (`schema_format = :sql` apps) via {StructureSqlParser}.
     # 2. `:model_index` walks every `.rb` file under the configured `model_search_paths`, finds class
     #    declarations whose direct superclass is in `model_base_classes`, and composes them with the schema
     #    table into a {ModelIndex}.
@@ -57,6 +59,9 @@ module Rigor
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
+          # `schema_format = :sql` projects (GitLab-class apps) commit a PostgreSQL `db/structure.sql`
+          # instead of `db/schema.rb`. Used as the fallback schema source when `schema_file` is absent.
+          "structure_sql_file" => { kind: :string, default: "db/structure.sql" },
           "model_search_paths" => { kind: :array, default: ["app/models"] },
           "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
@@ -76,26 +81,34 @@ module Rigor
       RELATION_CLASS_NAME = "ActiveRecord::Relation"
 
       # Cached: parsed schema table. The producer reads `@schema_file` via `io_boundary.read_file` so the
-      # descriptor picks up the digest, then parses through {SchemaParser}.
+      # descriptor picks up the digest, then parses through {SchemaParser}. When `db/schema.rb` is absent
+      # the producer falls back to a PostgreSQL `db/structure.sql` (`schema_format = :sql` apps) parsed
+      # through {StructureSqlParser} — both reads are captured into the record-and-validate descriptor.
       producer :schema_table do |_params|
-        contents = io_boundary.read_file(@schema_file)
-        SchemaParser.parse(contents)
+        SchemaParser.parse(io_boundary.read_file(@schema_file))
+      rescue Errno::ENOENT
+        StructureSqlParser.parse(io_boundary.read_file(@structure_sql_file))
       end
 
       # Cached: model index. Walks every model file, then composes the rows with the cached schema table.
       # `watch:` (ADR-60 WD3) covers model-file additions; the discoverer's in-block reads are captured
       # into the record-and-validate dependency descriptor after the block runs.
       producer :model_index, watch: -> { [[@model_search_paths, "**/*.rb"]] } do |_params|
-        rows = ModelDiscoverer.new(
+        discoverer = ModelDiscoverer.new(
           io_boundary: io_boundary,
           search_paths: @model_search_paths,
           base_classes: @model_base_classes
-        ).discover
-        ModelIndex.build(model_rows: rows, schema_table: schema_table_or_nil)
+        )
+        rows = discoverer.discover
+        ModelIndex.build(
+          model_rows: rows, schema_table: schema_table_or_nil,
+          type_override_columns: discoverer.type_override_columns
+        )
       end
 
       def init(_services)
         @schema_file = config.fetch("schema_file")
+        @structure_sql_file = config.fetch("structure_sql_file")
         @model_search_paths = Array(config.fetch("model_search_paths")).map(&:to_s)
         @model_base_classes = Array(config.fetch("model_base_classes")).map(&:to_s)
         @schema_table = nil
@@ -518,7 +531,8 @@ module Rigor
         @load_errors << "rigor-activerecord: #{e.message}"
         nil
       rescue Errno::ENOENT
-        @load_errors << "rigor-activerecord: schema file `#{@schema_file}` not found; AR call checks skipped"
+        @load_errors << "rigor-activerecord: schema file `#{@schema_file}` (or `#{@structure_sql_file}`) " \
+                        "not found; AR call checks skipped"
         nil
       rescue StandardError => e
         @load_errors << "rigor-activerecord: failed to parse `#{@schema_file}`: #{e.class}: #{e.message}"

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -32,7 +34,7 @@ module Rigor
           return if node.nil?
 
           yield node
-          node.compact_child_nodes.each { |child| walk(child, &) }
+          node.rigor_each_child { |child| walk(child, &) }
         end
 
         def visit_call(node)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -77,7 +79,7 @@ module Rigor
           when Prism::ModuleNode
             visit_module(node, lexical_path, &)
           else
-            node.compact_child_nodes.each { |child| walk(child, lexical_path, &) }
+            node.rigor_each_child { |child| walk(child, lexical_path, &) }
           end
         end
 
@@ -105,7 +107,7 @@ module Rigor
           return [] if body.nil?
 
           rows = []
-          body.compact_child_nodes.each do |node|
+          body.rigor_each_child do |node|
             next unless node.is_a?(Prism::CallNode)
 
             kind = ATTACHMENT_METHODS[node.name]

data/plugins/rigor-activesupport-core-ext/sig/active_support/core_ext.rbs

@@ -62,6 +62,9 @@ class Object
   # `acts_like?(:string)` / `acts_like?(:date)` / `acts_like?(:time)`
   # is ActiveSupport's "duck-typing helper" predicate.
   def acts_like?: (Symbol | String) -> bool
+
+  # `core_ext/object/inclusion` — `x.in?([a, b])` / `x.in?(1..10)`.
+  def in?: (untyped) -> bool
 end
 
 # `nil.blank?` / `nil.present?` / `nil.try` are the most frequent
@@ -99,6 +102,9 @@ class String
   def demodulize: () -> String
   def deconstantize: () -> String
   def titleize: () -> String
+  def titlecase: () -> String
+  def dasherize: () -> String
+  def upcase_first: () -> String
   def parameterize: (?separator: String, ?preserve_case: bool, ?locale: Symbol?) -> String
   def tableize: () -> String
   def foreign_key: (?bool separate_class_name_and_id_with_underscore) -> String
@@ -112,6 +118,9 @@ class String
   def truncate: (Integer truncate_at, ?omission: String, ?separator: String | Regexp | nil) -> String
   def truncate_bytes: (Integer truncate_at, ?omission: String) -> String
   def truncate_words: (Integer words_count, ?omission: String, ?separator: String | Regexp | nil) -> String
+  # `remove` / `remove!` delete every occurrence of the given patterns.
+  def remove: (*Regexp | String patterns) -> String
+  def remove!: (*Regexp | String patterns) -> String
 
   # `core_ext/string/output_safety` — `html_safe` returns an
   # `ActiveSupport::SafeBuffer` (a String subclass). The closest
@@ -274,6 +283,9 @@ class Time
   def noon: () -> Time
   def utc?: () -> bool
   def acts_like_time?: () -> true
+  # `advance(days: 1, months: -2)` and `all_day` (a `beginning_of_day..end_of_day` Range).
+  def advance: (untyped options) -> Time
+  def all_day: () -> Range[Time]
 end
 
 # ---------------------------------------------------------------
@@ -314,6 +326,11 @@ class Date
   def at_beginning_of_day: () -> Time
   def end_of_day: () -> Time
   def at_end_of_day: () -> Time
+  # `advance(days: 1)`, `all_day` (a Time Range), and `to_time(form)` — the
+  # `:local` / `:utc` form arg core RBS' `Date#to_time` (arity 0) omits.
+  def advance: (untyped options) -> Date
+  def all_day: () -> Range[Time]
+  def to_time: (?Symbol form) -> Time
 end
 
 # ---------------------------------------------------------------
@@ -476,3 +493,18 @@ end
 class String
   def exclude?: (String) -> bool
 end
+
+# ---------------------------------------------------------------
+# ERB::Util — ActionView extends it with `html_escape_once`
+# ---------------------------------------------------------------
+
+# `ERB` is a CLASS in Ruby / RBS (not a module), so reopen it as a class —
+# a `module ERB` wrapper collides with upstream `class ERB` once the `erb`
+# stdlib is in scope. `ERB::Util` itself is a module.
+class ERB
+  module Util
+    # `ERB::Util.html_escape_once(s)` escapes HTML without double-escaping
+    # an already-escaped entity. ActionView adds it on top of stdlib ERB.
+    def self.html_escape_once: (untyped) -> String
+  end
+end

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

@@ -63,12 +63,28 @@ module Rigor
         produces: [:dry_type_aliases]
       )
 
-      # Walks every project file once during `prepare(services)` to build the alias table, then publishes
-      # via the ADR-9 fact store. The walk is bounded by the configured `paths:` surface; each file's
-      # parse error degrades to "no contribution" without polluting the user-visible diagnostic stream.
+      # Cached alias-table producer (ADR-60 WD3 record-and-validate). The scan Prism-parses every `.rb` file
+      # under the project's `paths:` tree to find `include Dry.Types()` declarations — an expensive pass that
+      # ran on EVERY invocation (cold and warm) because `#prepare` called {AliasScanner.scan} directly, with
+      # no cache. It now rides `cache_for`: a warm run re-globs + re-digests the watched tree (cheap SHA over
+      # file bytes, no AST build) and reuses the cached table instead of re-parsing. This is the dominant win
+      # even for a project that ships no dry-types module — the parse still has to run to prove that, and now
+      # the empty result is cached too.
+      #
+      # `watch:` covers exactly the files the scan reads: one glob per project `paths:` entry, co-extensive
+      # with {#scannable_paths}. A {Cache::Descriptor::GlobEntry} digests every file matching its glob, so a
+      # content edit, a file addition, and a file removal anywhere under those paths all move the digest and
+      # invalidate the entry. The scan reads no file individually through the `IoBoundary`, so the evaluated
+      # `watch:` globs are the entire dependency descriptor — and they fully cover the scan's input.
+      producer :dry_type_aliases, watch: -> { alias_watch_globs } do |_params|
+        AliasScanner.scan(paths: scannable_paths)
+      end
+
+      # Builds the (cached) alias table and publishes it via the ADR-9 fact store. `producer_value` runs the
+      # producer through `cache_for` and memoises the result — including a rescued nil — for the run.
       def prepare(services)
-        aliases = AliasScanner.scan(paths: scannable_paths(services))
-        return if aliases.empty?
+        aliases = producer_value(:dry_type_aliases)
+        return if aliases.nil? || aliases.empty?
 
         services.fact_store.publish(
           plugin_id: manifest.id,
@@ -86,7 +102,7 @@ module Rigor
       # Resolves the project's `paths:` to a flat list of `.rb` files the scanner walks. Mirrors
       # `Analysis::Runner`'s `expand_paths` floor; we don't need the runner's full exclude/sort surface
       # because the alias table is a union — any duplicate scan is a no-op.
-      def scannable_paths(services)
+      def scannable_paths
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if File.directory?(entry)
             Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
@@ -97,6 +113,22 @@ module Rigor
           end
         end.uniq.freeze
       end
+
+      # The `watch:` glob tuples covering the scan's entire input — one `[root, pattern]` per project `paths:`
+      # entry. A directory entry watches its whole `**/*.rb` subtree; a single-file `.rb` entry watches
+      # exactly that file (`[dir, basename]`). Roots are expanded to absolute paths by
+      # `Plugin::Base#watch_glob_entries`, so a relative CLI path (`app/models`) re-validates against the same
+      # tree from the project root on the next run. Co-extensive with {#scannable_paths}: every `.rb` the scan
+      # would read is watched, so any edit / addition / removal under those paths invalidates the cache.
+      def alias_watch_globs
+        services.configuration.paths.filter_map do |entry|
+          if File.directory?(entry)
+            [entry, "**/*.rb"]
+          elsif File.file?(entry) && entry.end_with?(".rb")
+            [File.dirname(entry), File.basename(entry)]
+          end
+        end
+      end
     end
 
     Rigor::Plugin.register(DryTypes)

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 require "rigor/source/literals"
 
@@ -86,7 +88,7 @@ module Rigor
             visit_factory(node, &)
             return
           end
-          node.compact_child_nodes.each { |child| walk_for_factories(child, &) }
+          node.rigor_each_child { |child| walk_for_factories(child, &) }
         end
 
         def factory_call?(node)

data/plugins/rigor-hanami/lib/rigor/plugin/hanami/action_checker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "rigor/source/node_children"
+
 require "prism"
 
 module Rigor
@@ -65,7 +67,7 @@ module Rigor
           case node
           when Prism::DefNode then defs << node
           when Prism::ClassNode, Prism::ModuleNode then nil # nested scopes own their own defs
-          else node.compact_child_nodes.each { |child| collect_direct_defs(child, defs) }
+          else node.rigor_each_child { |child| collect_direct_defs(child, defs) }
           end
         end