rigortype 0.4.1 → 0.4.2

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"

data/plugins/rigor-alba/sig/alba.rbs

@@ -0,0 +1,4 @@
+module Alba
+  module Resource
+  end
+end

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

@@ -13,7 +13,7 @@ module Rigor
           when Prism::SymbolNode
             node.unescaped.to_sym
           when Prism::StringNode
-            node.unescaped.to_sym
+            Rigor::Source::Literals.symbol_or_string(node)
           when Prism::CallNode
             extract_symbol(node.receiver) if node.name == :to_sym && node.receiver
           end
@@ -24,7 +24,7 @@ module Rigor
           when Prism::SymbolNode
             node.unescaped.to_sym
           when Prism::StringNode
-            node.unescaped.to_sym
+            Rigor::Source::Literals.symbol_or_string(node)
           when Prism::ConstantReadNode, Prism::ConstantPathNode
             node.slice.to_sym
           when Prism::CallNode

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/target_detector.rb

@@ -3,43 +3,60 @@
 module Rigor
   module Plugin
     class FFI < Base
+      # Issue #1652 — given the plugin's {Rigor::Plugin::IoBoundary} (`io:`), every read goes through it, so the
+      # files the target was detected from are dependency rows of every cache built on the run. The
+      # `--incremental` run-result slot and the plain run-result cache serve an unchanged run without loading
+      # this plugin, and see a target flip only through those rows. `io: nil` reads the filesystem directly.
       module TargetDetector
         module_function
 
+        EXTCONF_GLOB = "ext/**/extconf.rb"
+
         # Detects whether the project targets ffx or the classic ffi gem per WD6.
-        def detect(root:, config: {})
+        def detect(root:, config: {}, io: nil)
           explicit = config["target"] || config[:target]
           return explicit.to_sym if explicit && explicit != "auto"
 
-          return :ffx if extconf_uses_ffx?(root)
-          return :ffx if lockfile_has_ffx?(root)
+          return :ffx if extconf_uses_ffx?(root, io)
+          return :ffx if lockfile_has_ffx?(root, io)
 
           :ffi
         end
 
-        def extconf_uses_ffx?(root)
+        def extconf_uses_ffx?(root, io = nil)
           return false if root.nil?
 
-          Dir.glob(File.join(root.to_s, "ext/**/extconf.rb")).any? do |extconf|
-            File.read(extconf).include?("FFX.create_makefile")
+          extconfs = io ? io.glob(root.to_s, EXTCONF_GLOB) : Dir.glob(File.join(root.to_s, EXTCONF_GLOB))
+          extconfs.any? do |extconf|
+            read_text(extconf, io).include?("FFX.create_makefile")
           rescue SystemCallError
             false
           end
         end
 
-        def lockfile_has_ffx?(root)
+        def lockfile_has_ffx?(root, io = nil)
           return false if root.nil?
 
           lockfile = File.join(root.to_s, "Gemfile.lock")
-          return false unless File.file?(lockfile)
+          return false unless io ? io.file?(lockfile) : File.file?(lockfile)
 
-          File.foreach(lockfile) do |line|
-            return true if line =~ /^\s{4}ffx\s/
-          end
-          false
+          read_text(lockfile, io).each_line.any? { |line| line.match?(/^\s{4}ffx\s/) }
         rescue SystemCallError
           false
         end
+
+        # A path outside the boundary's trust policy is refused there and read directly here: the target does
+        # not depend on the policy, and the boundary has noted the refusal (ADR-2 accepts that such a read
+        # leaves no row). Only a root outside every read root reaches it: a `root:` configured elsewhere, or a
+        # path spelled through a symlink (#959). Each extconf glob match is read here, not just listed: the
+        # glob's row records membership only, and this read's row carries an edit.
+        def read_text(path, io)
+          return File.read(path) if io.nil?
+
+          io.read_file(path)
+        rescue Rigor::Plugin::AccessDeniedError
+          File.read(path)
+        end
       end
     end
   end

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

@@ -127,21 +127,22 @@ module Rigor
 
       def init(_services)
         root = config["root"] || Dir.pwd
-        @target = TargetDetector.detect(root: root, config: config)
+        @target = TargetDetector.detect(root: root, config: config, io: io_boundary)
         @exceptions = config["exceptions"] || []
       end
 
       def prepare(_services)
         root = config["root"] || Dir.pwd
-        @target = TargetDetector.detect(root: root, config: config)
+        @target = TargetDetector.detect(root: root, config: config, io: io_boundary)
         @exceptions = config["exceptions"] || []
       end
 
       # ADR-88 channel (c) — the detected `:ffx` / `:ffi` target decides whether the `plugin.ffi.ffx.unsupported-*`
-      # rules fire, and {TargetDetector} reads `<root>/Gemfile.lock` and `ext/**/extconf.rb` directly, not the
-      # lockfile `bundler.lockfile:` resolves to — so neither the `--incremental` snapshot's gem-set digest nor an
-      # edit to an analysed file covers a change in them. Declaring the target makes a flip send the warm
-      # snapshot cold. Everything else this plugin contributes is per-file or comes from the `ffi_catalog`
+      # rules fire, and {TargetDetector} reads `<root>/Gemfile.lock` and `ext/**/extconf.rb`, not the lockfile
+      # `bundler.lockfile:` resolves to — so neither the `--incremental` snapshot's gem-set digest nor an edit to
+      # an analysed file covers a change in them. Declaring the target makes a flip send the warm snapshot cold.
+      # The run-result caches never load the plugin to ask; they see the flip through the boundary rows of those
+      # reads (#1652). Everything else this plugin contributes is per-file or comes from the `ffi_catalog`
       # producer (channel b).
       def incremental_state_fingerprint
         "target:#{@target || :ffi}"