rigortype 0.4.0 → 0.4.2

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

@@ -940,7 +940,7 @@ module Rigor
                     node.name == :define_singleton_method
                 arg0 = node.arguments&.arguments&.first
                 name = Rigor::Source::Literals.symbol_name(arg0) || (arg0.is_a?(Prism::StringNode) ? arg0.unescaped : nil)
-                key = TABLE_NAME_DECORATOR_METHODS[name.to_sym] if name
+                key = TABLE_NAME_DECORATOR_METHODS[Rigor::Source::SymbolName.of(name)] if name
                 if key
                   readers << key
                   decorators[key] = node.block.is_a?(Prism::BlockNode) ? literal_def_value(node.block.body) : { computed: true }
@@ -1263,9 +1263,10 @@ module Rigor
         # association / enum / validation declared inside is invisible to the discoverer, turning
         # `where(<assoc>: ...)` into a false `unknown-column`. Nested `with_options` blocks recurse.
         #
-        # The options the `with_options` call itself carries (e.g. `with_options class_name: 'Account'`)
-        # are NOT merged into the nested calls — discovering the declaration name is what clears the
-        # false positive; the merged-option target precision is a separate refinement.
+        # This method returns only the nodes and does NOT merge the group's own options (e.g.
+        # `with_options class_name: 'Account'`); {#association_calls} is the variant that does, and it is
+        # what the association rows use. The other lookups (enums, scopes, validations, callbacks) ignore
+        # group options.
         def declaration_calls(body)
           return [] if body.nil?
 
@@ -1291,20 +1292,42 @@ module Rigor
           return [] if body.nil?
 
           rows = []
-          declaration_calls(body).each do |node|
+          association_calls(body, [], false).each do |node, inherited, opaque|
             kind = ASSOCIATION_METHODS[node.name]
             next if kind.nil?
             next if node.receiver # skip `self.has_many` and similar
 
-            row = build_association_row(node, kind)
+            row = build_association_row(node, kind, inherited, opaque)
             rows << row unless row.nil?
           end
           rows
         end
 
-        def build_association_row(node, kind)
-          args = node.arguments&.arguments
-          return nil if args.nil? || args.empty?
+        # {#declaration_calls} that also carries the options of the enclosing `with_options(...)` groups, as
+        # `[node, option_args, opaque]`. `option_args` are the keyword-hash arguments of those groups, which
+        # ActiveRecord merges under the call's own options; `opaque` is true when a group passes anything
+        # else (`with_options opts do`), so its options are unknown.
+        def association_calls(body, inherited, opaque)
+          return [] if body.nil?
+
+          body.compact_child_nodes.flat_map do |node|
+            next [] unless node.is_a?(Prism::CallNode)
+
+            if node.name == :with_options && node.block.is_a?(Prism::BlockNode)
+              args = node.arguments&.arguments || []
+              hashes = args.grep(Prism::KeywordHashNode)
+              association_calls(node.block.body, hashes + inherited, opaque || hashes.size != args.size)
+            else
+              [[node, inherited, opaque]]
+            end
+          end
+        end
+
+        def build_association_row(node, kind, inherited, opaque)
+          own = node.arguments&.arguments
+          return nil if own.nil? || own.empty?
+
+          args = own + inherited
 
           name = Rigor::Source::Literals.symbol_name(args.first)
           return nil if name.nil?
@@ -1322,7 +1345,65 @@ module Rigor
           end
 
           { name: name, kind: kind, target: target, polymorphic: polymorphic,
-            nullable: association_nullable?(node.name, args) }
+            nullable: association_nullable?(node.name, args),
+            macro: node.name, class_name_option: class_name_option(args),
+            through: association_key?(args, "through"),
+            source_type_option: literal_option(args, "source_type"),
+            roots_declined: opaque || association_key?(args, "anonymous_class") || own_options_unknown?(own) }
+        end
+
+        # The `class_name:` option as ActiveRecord's `compute_type` will read it: the literal String (a
+        # Symbol is `to_s`'d by Rails too), `nil` when the option is absent, and `:dynamic` when it is
+        # present but not a literal — the `:reachability_roots` consumer must decline then, where the
+        # `target` above falls back to the inferred name.
+        # A `**opts` splat may carry a `class_name:` too, so it reads as present-but-unknown.
+        def class_name_option(args)
+          literal_option(args, "class_name") ||
+            (args.any? { |a| a.is_a?(Prism::KeywordHashNode) && a.elements.any?(Prism::AssocSplatNode) } ? :dynamic : nil)
+        end
+
+        def literal_option(args, key)
+          args.each do |arg|
+            next unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.each do |pair|
+              next unless pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, key)
+
+              value = pair.value
+              return value.unescaped if value.is_a?(Prism::StringNode) || value.is_a?(Prism::SymbolNode)
+
+              return :dynamic
+            end
+          end
+          nil
+        end
+
+        ROOT_OPTION_KEYS = %w[class_name polymorphic through source_type anonymous_class].freeze
+        LITERAL_OPTION_VALUES = [Prism::StringNode, Prism::SymbolNode, Prism::TrueNode, Prism::FalseNode].freeze
+        private_constant :ROOT_OPTION_KEYS, :LITERAL_OPTION_VALUES
+
+        # Whether the association call's OWN arguments hide an option that decides its target class: a
+        # positional options hash or variable, a `**splat`, or a non-literal value for one of the keys. A
+        # `with_options` group's literal value must not stand in for it.
+        def own_options_unknown?(own)
+          own.drop(1).any? do |arg|
+            next false if arg.is_a?(Prism::LambdaNode) # the scope argument carries no class option
+            next true unless arg.is_a?(Prism::KeywordHashNode)
+
+            arg.elements.any? do |pair|
+              next true unless pair.is_a?(Prism::AssocNode)
+
+              ROOT_OPTION_KEYS.any? { |key| Source::Literals.symbol_named?(pair.key, key) } &&
+                LITERAL_OPTION_VALUES.none? { |klass| pair.value.is_a?(klass) }
+            end
+          end
+        end
+
+        def association_key?(args, key)
+          args.any? do |arg|
+            arg.is_a?(Prism::KeywordHashNode) &&
+              arg.elements.any? { |pair| pair.is_a?(Prism::AssocNode) && Source::Literals.symbol_named?(pair.key, key) }
+          end
         end
 
         # Whether a `:singular` association's accessor can return `nil`. `has_one` genuinely can (no
@@ -1356,6 +1437,9 @@ module Rigor
 
               return true if pair.value.is_a?(Prism::TrueNode)
               return false if pair.value.is_a?(Prism::FalseNode)
+
+              # The call's own non-literal value shadows a `with_options` group's literal one.
+              return nil
             end
           end
           nil

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

@@ -7,6 +7,7 @@ require_relative "activerecord/schema_parser"
 require_relative "activerecord/structure_sql_parser"
 require_relative "activerecord/model_index"
 require_relative "activerecord/model_discoverer"
+require_relative "activerecord/association_roots"
 require_relative "activerecord/analyzer"
 require_relative "activerecord/effects"
 
@@ -64,6 +65,11 @@ module Rigor
       manifest(
         id: "activerecord",
         target_gems: ["activerecord"],
+        # 0.14.0, 2026-10-10 (#1721) — the plugin publishes `:reachability_roots`: the models ActiveRecord loads
+        # by name from an association. The association rows gain `macro`, `class_name_option`, `through` and
+        # `source_type_option`, so a cached 0.13.0 payload lacks the fields the roots are derived from and
+        # would publish none; the bump (part of the producer cache KEY) is what stops a warm run serving it.
+        #
         # 0.13.0, 2026-09-24 (#1321) — the class-side `Model.find` with two or more arguments returns
         # `Array[Model]` instead of the model, and its `model-call` note says so. A model that defines its own
         # `self.find` keeps its own answer; the note reads syntax alone and does not see that override. No
@@ -118,7 +124,7 @@ module Rigor
         # a scope lambda body / class-method body now contributes `Relation[Model]` via `scope.self_type`
         # instead of falling through to `Kernel#select` (the IO multiplexer, `Array[String]` return). Plus
         # `:select` added to the relation-entry-point list.
-        version: "0.13.0",
+        version: "0.14.0",
         description: "Types ActiveRecord finders against the project's db/schema.rb and AR models.",
         config_schema: {
           "schema_file" => { kind: :string, default: "db/schema.rb" },
@@ -128,7 +134,7 @@ module Rigor
           "model_search_paths" => { kind: :array, default: ["app/models"] },
           "model_base_classes" => { kind: :array, default: %w[ApplicationRecord ActiveRecord::Base] }
         },
-        produces: [:model_index],
+        produces: %i[model_index reachability_roots],
         # ADR-25 — the bundled `ActiveRecord::Relation` RBS that relation-typed call sites (`has_many`
         # accessors, `Model.where`, scopes) dispatch against.
         signature_paths: ["sig"],
@@ -241,6 +247,9 @@ module Rigor
         # this, so the disclosure is in the coordinator's table before a single worker is forked.
         disclose_load_errors
         return if index.nil? || index.empty?
+
+        # Roots do not read columns, so reduced mode (Redmine) publishes them too.
+        publish_association_roots(services, index)
         # Reduced mode stays UNPUBLISHED. Every consumer reads `columns:` as authoritative and fires on a
         # key missing from it — rigor-actionpack's `permit(:title)` check and rigor-shoulda-matchers'
         # `have_db_column(:title)` / `validate_presence_of(:title)` matchers both do — so publishing the
@@ -256,6 +265,18 @@ module Rigor
         )
       end
 
+      # ADR-102 WD3 — the models an association loads by name; see {AssociationRoots}. An unavailable
+      # inflector (ADR-39: decline, never approximate) leaves the report as it was.
+      def publish_association_roots(services, index)
+        roots = AssociationRoots.call(index)
+        return if roots.empty?
+
+        services.fact_store.publish(plugin_id: manifest.id, name: :reachability_roots, value: roots)
+      rescue Rigor::Plugin::Inflector::Unavailable
+        nil
+      end
+      private :publish_association_roots
+
       def diagnostics_for_file(path:, scope:, root:)
         index = model_index
         # The schema-load disclosure is independent of whether an index was built: reduced mode still
@@ -401,6 +422,7 @@ module Rigor
 
         if call_node.receiver
           class_call_return_type(call_node, scope, index) ||
+            relation_splat_find_return_type(call_node, scope) ||
             relation_call_return_type(call_node, scope, index) ||
             instance_call_return_type(call_node, scope, index)
         else
@@ -670,6 +692,25 @@ module Rigor
         relation_of(model_name)
       end
 
+      # `relation.find(*ids)` answers by argument count as `Model.find` does (`finder_return_type`), counting a splat or
+      # a `**` hash as one argument, which is the policy the bundled `Relation#find` documents: `find(*ids)` is the
+      # element, and `find(id, *ids)` and `find(*args, **opts)` are Arrays. The engine lets a splat stand for any
+      # number of arguments (#1801), so through the RBS overloads `find(*ids)` would join `Dynamic[Array[Elem] |
+      # Elem]`, on which a following `update` or `save` no longer resolves on the model and loses its
+      # `io.db.write`. Only a block-less call with a splat is answered here; every other `find` stays with the RBS.
+      def relation_splat_find_return_type(call_node, scope)
+        return nil unless call_node.name == :find && call_node.block.nil?
+        return nil unless call_node.arguments&.arguments&.any?(Prism::SplatNode)
+
+        model_name = relation_element_class_name(scope.type_of(call_node.receiver))
+        return nil if model_name.nil?
+
+        model = Rigor::Type::Combinator.nominal_of(model_name)
+        return model if call_argument_count(call_node) < 2
+
+        Rigor::Type::Combinator.nominal_of("Array", type_args: [model])
+      end
+
       # Whether `name` is a declared `scope` on ANY model in the index. A run-lifetime memoised Set so the
       # per-call check in `relation_call_return_type` stays O(1).
       def scope_name?(name, index)

data/plugins/rigor-activerecord/sig/active_record/relation.rbs

@@ -292,7 +292,9 @@ module ActiveRecord
     # loses its `io.db.write`. So a single argument stays `Elem`. A
     # splat and a `**` hash each count as one argument, so `find(*ids)`
     # is `Elem`, while `find(id, *ids)` and `find(*args, **opts)` are
-    # Arrays even when the splat or the hash turns out empty.
+    # Arrays even when the splat or the hash turns out empty. The engine
+    # reads a splat as any number of arguments (#1801), so the plugin
+    # answers a splat call by this count (`relation_splat_find_return_type`).
     #
     # With a block `find` is `Enumerable#find` (`return super if
     # block_given?`), so the id overloads do not apply: no argument

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_collector.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/inference/declaration_walk"
+
+require_relative "resource_index"
+
+module Rigor
+  module Plugin
+    class Alba < Rigor::Plugin::Base
+      # A {Rigor::Inference::DeclarationWalk} collector over one file: the classes it declares, whether each
+      # `include Alba::Resource`s, and the association declarations whose resource
+      # class alba infers from the name.
+      #
+      # An association is recorded only when alba would take the inference path (`Alba::Association#
+      # resource_from`): a literal Symbol/String name, exactly one positional argument, no block, and no
+      # `resource:` / `serializer:` keyword. A keyword splat (`**opts`) might carry either, so it is not
+      # recorded either — a skipped association costs a root, never invents one.
+      class ResourceCollector
+        include Rigor::Inference::DeclarationWalk::Collector
+
+        ASSOCIATION_METHODS = %i[association one many has_one has_many].freeze
+        RESOURCE_MODULE = "Alba::Resource"
+        RESOURCE_KEYWORDS = %i[resource serializer].freeze
+        # The calls whose block alba `class_eval`s on an anonymous class (`name == nil`): an association
+        # lookup inside one sees no nesting. Any other block (`each`, `class_eval`, ...) leaves it alone.
+        ANONYMOUS_CLASS_BLOCK_METHODS = (ASSOCIATION_METHODS + %i[trait nested nested_attribute]).freeze
+        # `Alba.serialize(x) { ... }` / `Alba.hashify` / `Alba.resource_class` evaluate their block on an anonymous
+        # class too, wherever they are written — including inside a namespaced resource.
+        ALBA_ANONYMOUS_BLOCK_METHODS = %i[serialize hashify resource_class].freeze
+
+        attr_reader :classes, :associations
+
+        def initialize
+          @entries = {}
+          @includes = {}
+          @nestings = {}
+          @blocks = []
+          @associations = []
+        end
+
+        def on_declaration(node, context, body_context)
+          return Rigor::Inference::DeclarationWalk::DESCEND unless node.is_a?(Prism::ClassNode)
+
+          name = body_context.prefix.join("::")
+          unless name.empty?
+            @entries[name] = superclass_name(node.superclass)
+            @nestings[name] = context.nesting || []
+          end
+          Rigor::Inference::DeclarationWalk::DESCEND
+        end
+
+        def on_call(node, context)
+          owner = context.prefix.join("::")
+          record_call(node, owner) unless owner.empty? || !node.receiver.nil?
+          remember_block(node)
+          Rigor::Inference::DeclarationWalk::DESCEND
+        end
+
+        # The classes this file declares, as {ResourceIndex::ClassEntry} values.
+        def class_entries
+          @entries.map do |name, superclass|
+            ResourceIndex::ClassEntry.new(
+              name: name, superclass: superclass, nesting: @nestings.fetch(name),
+              includes_resource: @includes.fetch(name, false)
+            )
+          end
+        end
+
+        private
+
+        def record_call(node, owner)
+          if node.name == :include
+            @includes[owner] = true if includes_resource?(node)
+          elsif ASSOCIATION_METHODS.include?(node.name)
+            name = inferred_association_name(node)
+            @associations << ResourceIndex::Association.new(owner: owner, name: name, in_block: in_block?(node)) if name
+          end
+        end
+
+        # The calls are visited outer-first, so a call's block is known before the calls inside it.
+        def remember_block(node)
+          block = node.block
+          return unless block.is_a?(Prism::BlockNode)
+          return unless ANONYMOUS_CLASS_BLOCK_METHODS.include?(node.name) || alba_anonymous_block_call?(node)
+
+          @blocks << (block.location.start_offset...block.location.end_offset)
+        end
+
+        def alba_anonymous_block_call?(node)
+          ALBA_ANONYMOUS_BLOCK_METHODS.include?(node.name) &&
+            constant_name(node.receiver)&.delete_prefix("::") == "Alba"
+        end
+
+        def in_block?(node)
+          offset = node.location.start_offset
+          @blocks.any? { |range| range.cover?(offset) }
+        end
+
+        def includes_resource?(node)
+          arguments = node.arguments&.arguments || []
+          arguments.any? { |argument| constant_name(argument)&.delete_prefix("::") == RESOURCE_MODULE }
+        end
+
+        def inferred_association_name(node)
+          return nil unless node.block.nil?
+
+          arguments = node.arguments&.arguments || []
+          positional = arguments.grep_v(Prism::KeywordHashNode)
+          keywords = arguments.grep(Prism::KeywordHashNode)
+          return nil unless positional.size == 1 && keywords.size <= 1
+          return nil if keywords.any? { |hash| names_resource?(hash) }
+
+          literal_name(positional.first)
+        end
+
+        def names_resource?(hash)
+          hash.elements.any? do |element|
+            !element.is_a?(Prism::AssocNode) || !element.key.is_a?(Prism::SymbolNode) ||
+              RESOURCE_KEYWORDS.include?(element.key.unescaped.to_sym)
+          end
+        end
+
+        def literal_name(node)
+          case node
+          when Prism::SymbolNode, Prism::StringNode then node.unescaped
+          end
+        end
+
+        def superclass_name(node)
+          node && constant_name(node)
+        end
+
+        def constant_name(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parent = node.parent
+            return "::#{node.name}" if parent.nil?
+
+            prefix = constant_name(parent)
+            prefix && "#{prefix}::#{node.name}"
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_discoverer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require "rigor/inference/declaration_walk"
+
+require_relative "resource_collector"
+require_relative "resource_index"
+
+module Rigor
+  module Plugin
+    class Alba < Rigor::Plugin::Base
+      # Reads every `.rb` file under the configured search paths through the plugin's `IoBoundary`, runs a
+      # {ResourceCollector} over each and merges the results into one {ResourceIndex}.
+      class ResourceDiscoverer
+        def initialize(io_boundary:, search_paths:)
+          @io_boundary = io_boundary
+          @search_paths = search_paths
+        end
+
+        def discover
+          entries = []
+          associations = []
+          ruby_files_under(@search_paths).each do |path|
+            contents = read_safely(path)
+            next if contents.nil?
+
+            parsed = Prism.parse(contents)
+            next unless parsed.success?
+
+            collector = ResourceCollector.new
+            Rigor::Inference::DeclarationWalk.run(
+              parsed.value, [collector], Rigor::Inference::DeclarationWalk::Context.root(nesting: [])
+            )
+            entries.concat(collector.class_entries)
+            associations.concat(collector.associations)
+          end
+          ResourceIndex.new(classes: merge(entries), associations: associations)
+        end
+
+        private
+
+        # A class reopened across files: it is a resource if any opening says so.
+        def merge(entries)
+          entries.group_by(&:name).map do |name, openings|
+            headed = openings.find(&:superclass) || openings.first
+            ResourceIndex::ClassEntry.new(
+              name: name,
+              superclass: headed.superclass,
+              nesting: headed.nesting,
+              includes_resource: openings.any?(&:includes_resource)
+            )
+          end
+        end
+
+        def read_safely(path)
+          @io_boundary.read_file(path)
+        rescue Plugin::AccessDeniedError, Errno::ENOENT
+          nil
+        end
+
+        def ruby_files_under(roots)
+          roots.flat_map do |root|
+            absolute = File.expand_path(root)
+            # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
+            next [] unless @io_boundary.directory?(absolute)
+
+            Dir.glob(File.join(absolute, "**", "*.rb"))
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_index.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Plugin
+    class Alba < Rigor::Plugin::Base
+      # The project's alba resource classes, as the {ResourceCollector} found them. A frozen value object the
+      # `:resource_index` producer caches.
+      #
+      # One question is answered from it, and deliberately conservatively — a wrong "no" costs a
+      # missing root, a wrong "yes" costs a false positive or a hidden dead class:
+      #
+      # {#inferred_roots}: which classes alba's association inference would load, for associations that name
+      # neither `resource:` nor `serializer:` (see {ResourceCollector}).
+      class ResourceIndex
+        # `owner` is the enclosing class's full name, which alba hands to `Object.const_get` as `nesting`.
+        # `in_block` is true when the call sits in a block of the resource body (`trait`, `nested`, an
+        # association's own block): alba `class_eval`s those on an anonymous class, whose `name` is nil, so
+        # only the top-level candidates are tried.
+        Association = Data.define(:owner, :name, :in_block)
+
+        # A class the project declares. `superclass` is the constant as written (`nil` when absent) and
+        # `nesting` the `Module.nesting` chain (innermost first) its header was written under, which is where
+        # Ruby resolves that constant.
+        ClassEntry = Data.define(:name, :superclass, :nesting, :includes_resource)
+
+        # The resource-class suffixes alba's `infer_resource_class` tries, in order.
+        SUFFIXES = %w[Resource Serializer].freeze
+        VALID_ASSOCIATION_NAME = /\A[a-z_][a-z0-9_]*\z/
+
+        def initialize(classes:, associations:)
+          @classes = classes.to_h { |entry| [entry.name, entry] }.freeze
+          @associations = associations.freeze
+          freeze
+        end
+
+        def empty?
+          @classes.empty?
+        end
+
+        # The classes alba infers for the associations that name no resource, limited to
+        #   those that exist in the project. The block receives each association name and returns alba's
+        #   `classify` of it (the caller owns the inflector; ADR-39).
+        def inferred_roots(&classify)
+          roots = @associations.filter_map do |association|
+            next unless resource?(association.owner)
+
+            inferred_class(association, classify)
+          end
+          roots.uniq.sort
+        end
+
+        private
+
+        # Alba tries `<Nesting>::<X>Resource`, then the top-level one (`const_get` on a module looks in Object),
+        # and only then the same two for `<X>Serializer`. The first that exists is the one alba loads.
+        def inferred_class(association, classify)
+          return nil unless VALID_ASSOCIATION_NAME.match?(association.name)
+
+          base = classify.call(association.name)
+          return nil unless base.is_a?(String) && /\A[A-Z][A-Za-z0-9]*\z/.match?(base)
+
+          nesting = association.in_block ? "" : association.owner.rpartition("::").first
+          SUFFIXES.each do |suffix|
+            candidates = ["#{base}#{suffix}"]
+            candidates.unshift("#{nesting}::#{base}#{suffix}") unless nesting.empty?
+            found = candidates.find { |candidate| @classes.key?(candidate) }
+            return found if found
+          end
+          nil
+        end
+
+        def resource?(name)
+          resource_chain?(name, {})
+        end
+
+        def resource_chain?(name, seen)
+          entry = @classes[name]
+          return false if entry.nil? || seen[name]
+
+          seen[name] = true
+          return true if entry.includes_resource
+
+          parent = superclass_of(entry)
+          !parent.nil? && resource_chain?(parent, seen)
+        end
+
+        # Resolves the superclass as written the way Ruby does: against the `Module.nesting` chain of the header,
+        # innermost first, then the top level. A compact header (`class Admin::UserResource < Base`) does not put
+        # `Admin` on the chain, so `Base` is not looked up under it.
+        def superclass_of(entry)
+          written = entry.superclass
+          return nil if written.nil?
+
+          if written.start_with?("::")
+            rooted = written.delete_prefix("::")
+            return @classes.key?(rooted) ? rooted : nil
+          end
+
+          (entry.nesting.map { |scope| "#{scope}::#{written}" } + [written]).find { |name| @classes.key?(name) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+require_relative "alba/resource_index"
+require_relative "alba/resource_collector"
+require_relative "alba/resource_discoverer"
+
+module Rigor
+  module Plugin
+    # rigor-alba — recognises the alba JSON serializer (https://github.com/okuramasafumi/alba) in an
+    # application that uses it. Two facets, each of which only removes a diagnostic or adds a root:
+    #
+    # 1. **Block self.** `Alba.serialize(obj) { attributes :id }` and `Alba.hashify(obj) { ... }` `class_eval`
+    #    their block on an anonymous `Class.new { include Alba::Resource }`, so the DSL calls inside resolve
+    #    against `singleton(Alba::Resource)` (alba's own sig declares `[self: singleton(Resource)]` from 4.0) instead of
+    #    firing `call.unresolved-toplevel`.
+    # 2. **`rigor unused` roots.** `many :articles` with no `resource:` makes alba infer `ArticleResource` (or
+    #    `ArticleSerializer`) through `Alba.inflector`; that name appears nowhere in source, so the class would
+    #    be listed as unused. It is published as a root — and only when a class of that name exists.
+    #
+    # No return type is contributed. `Alba.serialize(obj)` runs the project's own `<Class>Resource#serialize`,
+    # which the project may override to return anything, and `hashify` / `to_h` / `as_json` return whatever the
+    # resource's attributes build.
+    #
+    # alba keeps its `sig/` in the repository but does not ship it in the gem, so in a user project the
+    # constant `Alba` is unknown. The bundled `sig/alba.rbs` therefore declares just the two namespaces the
+    # block-self matching needs (`Alba`, `Alba::Resource`), and both are `open_receivers` so no
+    # undeclared call on them is ever diagnosed.
+    class Alba < Rigor::Plugin::Base
+      manifest(
+        id: "alba",
+        target_gems: ["alba"],
+        version: "0.1.0",
+        description: "Types alba's inline-resource block self and roots inferred " \
+                     "association resources for `rigor unused`.",
+        config_schema: {
+          "resource_search_paths" => { kind: :array, default: ["app"] }
+        },
+        signature_paths: ["sig"],
+        open_receivers: %w[Alba Alba::Resource],
+        produces: [:reachability_roots],
+        block_as_methods: [
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Alba",
+            method_names: %i[serialize hashify],
+            self_type: "singleton(Alba::Resource)"
+          )
+        ]
+      )
+
+      producer :resource_index, watch: -> { [[@resource_search_paths, "**/*.rb"]] } do |_params|
+        ResourceDiscoverer.new(io_boundary: io_boundary, search_paths: @resource_search_paths).discover
+      end
+
+      def init(_services)
+        @resource_search_paths = Array(config.fetch("resource_search_paths")).map(&:to_s)
+      end
+
+      # ADR-102 WD3 — the resource classes alba's association inference loads. Published only where the
+      # inferred name resolves to a class the project declares ({ResourceIndex#inferred_roots}); a name nothing
+      # matches contributes nothing, and an unavailable inflector (ADR-39: decline, never approximate) leaves
+      # the report as it was.
+      def prepare(services)
+        index = resource_index
+        return if index.nil?
+
+        roots = index.inferred_roots { |name| Rigor::Plugin::Inflector.classify(name) }
+        return if roots.empty?
+
+        services.fact_store.publish(plugin_id: manifest.id, name: :reachability_roots, value: roots)
+      rescue Rigor::Plugin::Inflector::Unavailable
+        nil
+      end
+
+      private
+
+      def resource_index
+        producer_value(:resource_index)
+      end
+    end
+
+    Rigor::Plugin.register(Alba)
+  end
+end

data/plugins/rigor-alba/lib/rigor-alba.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rigor/plugin/alba"