rigortype 0.3.8 → 0.4.0

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

@@ -22,17 +22,19 @@ module Rigor
 
         module_function
 
-        # @param paths [Array<String>] absolute paths to `.rb` files the project's `paths:` resolves to.
-        # @return [Array<String>] frozen, sorted list of recognized contract class FQNs (e.g.
+        # @param paths — absolute paths to `.rb` files the project's `paths:` resolves to.
+        # @param io_boundary — the plugin's {Rigor::Plugin::IoBoundary}; every source read goes
+        #   through it (#630) so each scanned file is a recorded cache dependency.
+        # @return frozen, sorted list of recognized contract class FQNs (e.g.
         #   `["App::NewUserContract", "Types::EmailContract"]`).
-        def scan(paths:)
+        def scan(paths:, io_boundary:)
           contracts = []
-          paths.each { |path| contracts.concat(scan_file(path)) }
+          paths.each { |path| contracts.concat(scan_file(path, io_boundary)) }
           contracts.uniq.sort.freeze
         end
 
-        def scan_file(path)
-          source = File.read(path)
+        def scan_file(path, io_boundary)
+          source = io_boundary.read_file(path)
           parse_result = Prism.parse(source, filepath: path)
           return [] unless parse_result.errors.empty?
 
@@ -50,24 +52,24 @@ module Rigor
         # not a degrade-gracefully fallback, because this plugin ships no required/optional walker of
         # its own.
         #
-        # @return [Hash{String => Hash{Symbol => Hash}}] contract FQN => `{params: <shape>}` and/or
+        # @return contract FQN => `{params: <shape>}` and/or
         #   `{json: <shape>}` (only the recognised key(s) are present; a contract with neither present
         #   contributes nothing). Each `<shape>` is exactly {DrySchema::SchemaScanner.collect_schema_shape}'s
         #   `{required:, optional:, unmodelled:}` return.
-        def scan_schema_blocks(paths:, type_aliases: {})
+        def scan_schema_blocks(paths:, io_boundary:, type_aliases: {})
           return {} unless Rigor::Plugin.registered_for("dry-schema")
 
           table = {}
           paths.each do |path|
-            scan_file_schema_blocks(path, type_aliases).each do |fqn, shapes|
+            scan_file_schema_blocks(path, io_boundary, type_aliases).each do |fqn, shapes|
               table[fqn] ||= shapes
             end
           end
           table.freeze
         end
 
-        def scan_file_schema_blocks(path, type_aliases)
-          source = File.read(path)
+        def scan_file_schema_blocks(path, io_boundary, type_aliases)
+          source = io_boundary.read_file(path)
           parse_result = Prism.parse(source, filepath: path)
           return {} unless parse_result.errors.empty?
 

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

@@ -44,6 +44,7 @@ module Rigor
     class DryValidation < Rigor::Plugin::Base
       manifest(
         id: "dry-validation",
+        target_gems: ["dry-validation"],
         version: "0.1.0",
         description: "Recognises `class T < Dry::Validation::Contract` subclasses, publishes the " \
                      "contract FQN set, and (with rigor-dry-schema loaded) refines each contract's " \
@@ -94,7 +95,7 @@ module Rigor
       end
 
       def prepare(services)
-        contracts = ContractScanner.scan(paths: scannable_paths(services))
+        contracts = ContractScanner.scan(paths: scannable_paths(services), io_boundary: io_boundary)
         unless contracts.empty?
           services.fact_store.publish(
             plugin_id: manifest.id,
@@ -104,7 +105,9 @@ module Rigor
         end
 
         type_aliases = services.fact_store.read(plugin_id: "dry-types", name: :dry_type_aliases) || {}
-        params_table = ContractScanner.scan_schema_blocks(paths: scannable_paths(services), type_aliases: type_aliases)
+        params_table = ContractScanner.scan_schema_blocks(paths: scannable_paths(services),
+                                                          io_boundary: io_boundary,
+                                                          type_aliases: type_aliases)
         return if params_table.empty?
 
         services.fact_store.publish(
@@ -137,11 +140,13 @@ module Rigor
         shapes[name] = row.nil? ? nil : ParamsShape.build(row)
       end
 
+      # ADR-45 WD1b (#613 / #630) — the classification probes go through the boundary, so an entry that
+      # is not there yet (or stops being a directory) is a recorded dependency of the scan's input set.
       def scannable_paths(services)
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
-          if File.directory?(entry)
+          if io_boundary.directory?(entry)
             Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
-          elsif File.file?(entry) && entry.end_with?(".rb")
+          elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else
             []

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

@@ -8,6 +8,7 @@ module Rigor
     class Ethon < Base
       manifest(
         id: "ethon",
+        target_gems: ["ethon"],
         version: "0.1.0",
         description: "Models Ethon / Libcurl options, dynamic return types, and multi-loop operations.",
         signature_paths: ["sig"]
@@ -22,6 +23,7 @@ module Rigor
         response_body: -> { Rigor::Type::Combinator.nominal_of("String") },
         response_headers: -> { Rigor::Type::Combinator.nominal_of("String") }
       }.freeze
+      Ractor.make_shareable(EASY_RETURN_TYPES)
 
       dynamic_return receivers: ["Ethon::Easy"], methods: EASY_RETURN_TYPES.keys do |call_node, _scope|
         builder = EASY_RETURN_TYPES[call_node.name]

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

@@ -28,11 +28,6 @@ module Rigor
         # The violations for a single entry call (`FactoryBot.create(...)` etc.), or `[]` when the node
         # is not an entry call or its first argument is not a literal factory name. ADR-37: the engine
         # owns the walk.
-        #
-        # @param call_node [Prism::Node]
-        # @param factory_index [FactoryIndex]
-        # @param model_index [Hash, nil]
-        # @return [Array<Violation>]
         def violations_for(call_node:, factory_index:, model_index: nil)
           return [] unless entry_call?(call_node)
 

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

@@ -37,7 +37,6 @@ module Rigor
           @search_paths = search_paths
         end
 
-        # @return [FactoryIndex]
         def discover
           entries = {}
           ruby_files_under(@search_paths).each do |path|

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

@@ -29,7 +29,6 @@ module Rigor
           freeze
         end
 
-        # @return [Entry, nil]
         def find(factory_name)
           @entries[factory_name.to_s]
         end

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

@@ -58,6 +58,7 @@ module Rigor
     class Factorybot < Rigor::Plugin::Base
       manifest(
         id: "factorybot",
+        target_gems: ["factory_bot"],
         # Bumped 2026-08-16 — publishes `:reachability_references` for `rigor unused` (ADR-102 WD3 / #350).
         version: "0.3.0",
         description: "Validates FactoryBot.create / build / attributes_for call shapes; " \
@@ -69,7 +70,7 @@ module Rigor
         consumes: [
           { plugin_id: "activerecord", name: :model_index, optional: true }
         ],
-        produces: [:reachability_references]
+        produces: %i[reachability_references factory_index]
       )
 
       producer :factory_index, watch: -> { [[@factory_search_paths, "**/*.rb"]] } do |_params|
@@ -101,6 +102,12 @@ module Rigor
         index = producer_value(:factory_index)
         return if index.nil? || index.empty?
 
+        # The producer value and the ADR-9 fact are different channels (#921) — `producer_value` is this
+        # plugin's own cached computation, read back via `producer_value` above; `fact_store.publish` is
+        # what makes it visible to another plugin's `read_fact`, which is how rigor-rspec binds
+        # `create(:name)` to the factory's model class.
+        services.fact_store.publish(plugin_id: manifest.id, name: :factory_index, value: index)
+
         references = index.entries.values.filter_map do |entry|
           { name: entry.model_class, role: :test } if entry.model_class
         end.uniq

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

@@ -20,7 +20,7 @@ module Rigor
         ].to_set.freeze
 
         # Regex anchor must match end of string \z
-        NOMINAL_OPAQUE_REGEX = Regexp.new("(_ptr|_handle|Ptr|Handle)\\z")
+        NOMINAL_OPAQUE_REGEX = Regexp.new("(_ptr|_handle|Ptr|Handle)\\z").freeze
 
         BOOL_TYPE = Rigor::Type::Combinator.union(
           Rigor::Type::Combinator.constant_of(true),

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

@@ -13,9 +13,21 @@ module Rigor
     class FFI < Base
       manifest(
         id: "ffi",
-        version: "0.1.0",
+        target_gems: ["ffi"],
+        # Bumped 2026-09-10 (#918) — declares `config_schema` for the two `.rigor.yml` surfaces ADR-30
+        # WD4 (`exceptions`) and WD6 (`target`) already read off `config` but the manifest never
+        # published, so both keys were rejected by `Manifest#validate_config` as unknown.
+        version: "0.2.0",
         description: "Models FFI library bindings, struct layouts, callbacks, carrier types, and ffx target compatibility.",
-        signature_paths: ["sig"]
+        signature_paths: ["sig"],
+        config_schema: {
+          # WD4 — typedef alias names the nominal-opaque-pointer heuristic should treat as a transparent
+          # `:pointer` alias even though they match the `_ptr$` / `_handle$` naming pattern.
+          "exceptions" => { kind: :array, default: [] },
+          # WD6 — forces ffx-target detection instead of the `extconf.rb` / `Gemfile.lock` cascade.
+          # `"auto"` (the default) keeps the cascade; `"ffi"` / `"ffx"` pin the target outright.
+          "target" => { kind: :string, default: "auto" }
+        }
       )
 
       producer :ffi_catalog do
@@ -25,7 +37,13 @@ module Rigor
 
       # Dynamic return rule for attached FFI functions
       # Gated on known FFI library receivers and attached function names
-      dynamic_return receivers: -> { producer_value(:ffi_catalog)&.libraries || [] },
+      #
+      # Issue #701 — both receiver kinds are declared because the block below already resolved
+      # `Nominal` and `Singleton` alike: `attach_function` installs the binding on the library module
+      # itself (`MyLib.strlen`) and `include`ing that module makes the same name an instance call, so
+      # neither kind is an accident. The kind-aware gate makes that intent explicit rather than relying
+      # on a `receivers:` entry answering for both.
+      dynamic_return receivers: -> { both_receiver_kinds(producer_value(:ffi_catalog)&.libraries) },
                      methods: -> { producer_value(:ffi_catalog)&.function_method_names || [] } do |call_node, scope|
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
@@ -51,7 +69,11 @@ module Rigor
 
       # Dynamic return rule for FFI struct field accessors
       # Gated on known FFI struct class names and field names
-      dynamic_return receivers: -> { producer_value(:ffi_catalog)&.struct_names || [] },
+      #
+      # Issue #701 — both kinds again, for the same reason: the block resolves the receiver itself and
+      # answers only for a name the discovered layout carries, so restricting the gate to instances
+      # would narrow a shipped rule on a shape nothing in the corpus has adjudicated.
+      dynamic_return receivers: -> { both_receiver_kinds(producer_value(:ffi_catalog)&.struct_names) },
                      methods: -> { producer_value(:ffi_catalog)&.struct_field_names || [] } do |call_node, scope|
         catalog = producer_value(:ffi_catalog)
         next nil if catalog.nil?
@@ -114,6 +136,16 @@ module Rigor
         @target = TargetDetector.detect(root: root, config: config)
         @exceptions = config["exceptions"] || []
       end
+
+      private
+
+      # Every discovered name in both `dynamic_return receivers:` kinds (#701), for the two rules whose
+      # blocks accept an instance and a class receiver alike.
+      #
+      # @param names — discovered class / module names, or nil when the catalog producer did not run
+      def both_receiver_kinds(names)
+        Array(names).flat_map { |name| [name, "singleton(#{name})"] }
+      end
     end
   end
 end

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

@@ -8,6 +8,7 @@ module Rigor
     class FFIRZMQ < Base
       manifest(
         id: "ffi-rzmq",
+        target_gems: ["ffi-rzmq"],
         version: "0.1.0",
         description: "Models ffi-rzmq / LibZMQ wrappers, socket operations, and cross-gem bindings.",
         signature_paths: ["sig"]

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+module Rigor
+  module Plugin
+    # rigor-grape — recognises the Grape endpoint-declaration DSL (`class API < Grape::API`) and the
+    # grape-entity exposure DSL (`class E < Grape::Entity`) so the calls stop reading `Dynamic[top]`
+    # (issue #1099; gitlab's `lib/api` accounted for ~10k opaque implicit-self sends in the
+    # 2026-09-19 survey — `expose` ~3.9k, `optional` ~2.2k, `route_setting` ~1.5k, `desc` ~1.4k,
+    # `requires` ~1.4k).
+    #
+    # Grape is more dynamic than the frameworks the ADR-16 substrate was built for:
+    #
+    # - `Grape::API` subclasses have NO static class methods — every declaration call is forwarded
+    #   to the base `Grape::API::Instance` class object at runtime (`delegate_missing_to` +
+    #   `override_all_methods!`, `lib/grape/api.rb`). The bundled sig declares the shared surface
+    #   once in `Grape::DSL::ClassMethods` and `extend`s it onto both `Grape::API` (reached from
+    #   source subclasses via `rbs_complete_ancestors`, ADR-43 WD4) and `Grape::API::Instance`
+    #   (reached inside `namespace` bodies, whose `self` is the Instance class object).
+    # - Block `self` bindings differ per macro family — `params` bodies `instance_eval` on a
+    #   `Grape::Validations::ParamsScope` instance, `namespace`/`route_param`/`version`/`given`/
+    #   `mounted` bodies on the Instance class object, and verb bodies run as `Grape::Endpoint`
+    #   instance methods. `block_as_methods` entries carry a named `self_type` ("Foo" /
+    #   "singleton(Foo)") so each body binds the object Grape actually evaluates it on.
+    # - `Grape::Entity`'s `expose` bodies run via `block.call` — `self` stays the Entity class
+    #   object — so nested `expose` calls need no entry; the `def self.` declarations cover them.
+    #
+    # ## Deferred (documented in README)
+    #
+    # - `helpers do ... end` bodies (`class_eval` on an anonymous Module — unnamed self).
+    # - Typing `present`/`declared` results against the declared entity/params (runtime shape).
+    class Grape < Rigor::Plugin::Base
+      # `namespace`-family bodies evaluate as instance methods of the Instance *class object*
+      # (`Instance.nest` / `evaluate_as_instance_with_configuration` do `instance_eval(&block)`).
+      # `scope` belongs here too: `Grape::DSL::Routing#scope` is `within_namespace { nest(block) }`,
+      # so its body `instance_eval`s on the same Instance class object as `namespace`.
+      NAMESPACE_METHODS = %i[
+        namespace group resource resources segment scope route_param version given mounted
+      ].freeze
+      # HTTP verb macros are generated over `Grape::HTTP_SUPPORTED_METHODS` and delegate to `route`;
+      # their bodies run inside `Grape::Endpoint` instances.
+      VERB_METHODS = %i[get put post delete head patch options route].freeze
+      # `params` bodies evaluate on a `ParamsScope` instance; the block-carrying scope macros re-enter
+      # a child scope the same way.
+      PARAMS_SCOPE_METHODS = %i[requires optional given with].freeze
+
+      manifest(
+        id: "grape",
+        target_gems: %w[grape grape-entity],
+        version: "0.1.0",
+        description: "Types the Grape endpoint-declaration DSL (`Grape::API` subclasses: `params`, " \
+                     "`namespace`, HTTP verb macros, `desc`, `route_setting`, `helpers`) and the " \
+                     "grape-entity exposure DSL (`Grape::Entity` subclasses: `expose`), including " \
+                     "the `instance_eval`'d block `self` bindings.",
+        signature_paths: ["sig"],
+        # ADR-43 WD4 — `Grape::API`/`Grape::Entity` subclasses bridge their class-level DSL calls to
+        # the bundled sig's `def self.` declarations. Justified because the bundled sig IS the
+        # authority (neither gem ships RBS) and the declared surface is what the DSL exposes.
+        rbs_complete_ancestors: %w[
+          Grape::API
+          Grape::Entity
+        ],
+        # All five classes have genuinely open runtime surfaces (`override_all_methods!` generates
+        # and forwards methods on API subclasses; ParamsScope/Endpoint pick up DSL modules) — calls
+        # we don't declare must stay opaque, not diagnosed.
+        open_receivers: %w[
+          Grape::API
+          Grape::API::Instance
+          Grape::Entity
+          Grape::Validations::ParamsScope
+          Grape::Endpoint
+        ],
+        block_as_methods: [
+          # Class-body context: `class API < Grape::API; namespace :x do ... end`.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: NAMESPACE_METHODS,
+            self_type: "singleton(Grape::API::Instance)"
+          ),
+          # Inside an already-narrowed namespace body (self is the Instance class object), nested
+          # `namespace`/`version`/`given` calls re-enter the same context.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: NAMESPACE_METHODS,
+            self_type: "singleton(Grape::API::Instance)"
+          ),
+          # `params do ... end` — body `instance_eval`s on a `ParamsScope` instance.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: %i[params],
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: %i[params],
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          # `requires :x, type: Hash do ... end` inside a params body re-enters a child ParamsScope —
+          # the receiver is already the `Nominal[ParamsScope]` `self` of the enclosing body, which is
+          # what named-instance `self_type` entries additionally match.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::Validations::ParamsScope",
+            method_names: PARAMS_SCOPE_METHODS,
+            self_type: "Grape::Validations::ParamsScope"
+          ),
+          # `desc 'x' do ... end` — the config block `instance_exec`s on a generated
+          # `SettingsContainer` subclass (`StrictHashConfiguration.config_class(*Desc::
+          # ROUTE_ATTRIBUTES)` in dsl/desc.rb): `detail`, `success`, `failure`, `tags`, `entity`,
+          # `hidden`, `is_array`, `consumes`, `headers`, … each take one value and return it.
+          # Modelled as the `Grape::DSL::Desc::ConfigContext` sig carrier — a closed surface, so a
+          # misspelt or invented setter still reads `call.undefined-method`, matching the runtime
+          # NoMethodError.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: %i[desc],
+            self_type: "Grape::DSL::Desc::ConfigContext"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: %i[desc],
+            self_type: "Grape::DSL::Desc::ConfigContext"
+          ),
+          # Verb bodies run inside `Grape::Endpoint` instances.
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API",
+            method_names: VERB_METHODS,
+            self_type: "Grape::Endpoint"
+          ),
+          Rigor::Plugin::Macro::BlockAsMethod.new(
+            receiver_constraint: "Grape::API::Instance",
+            method_names: VERB_METHODS,
+            self_type: "Grape::Endpoint"
+          )
+        ]
+      )
+    end
+
+    Rigor::Plugin.register(Grape)
+  end
+end

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

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Gem entry point. Required by Rigor's plugin loader when `.rigor.yml` lists `rigor-grape` under
+# `plugins:`. The loader expects this `require` to side-effect a call to `Rigor::Plugin.register`,
+# which the body of `lib/rigor/plugin/grape.rb` performs at load time.
+require_relative "rigor/plugin/grape"