rigortype 0.1.11 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c5853d88c57eb0ded87f9fbf801e3cfbbc7672be2a16bcc3171bd7e3f33122c
-  data.tar.gz: d3f3b9d936dd4aab4a10c93b7879b34bee26aa1313007619baadb1381b87310c
+  metadata.gz: 6f7d66cf2c7a6c883fbbab59a805b1d1bca62867022e42d9b68d0b788525e831
+  data.tar.gz: c327399cf8c239da46f383de404cd15843d8ce220b5538f1905d72f4e082a59f
 SHA512:
-  metadata.gz: bebba3258c508b893a7ca22e98b17838bcc7267399882956a4ced9c214e87947754f5a15ecf80029cf601eed58c93fc53ffcb50636002df9f75c00d498a0585b
-  data.tar.gz: 4ac6679d930144ffc5a675a9189ed7ce20d500c5ae9d61820b44fcfbf3e02149b615b3b11a44fa48760c17a75b57ec6d6b5ee3e4a80a4b9139514c742c9c612a
+  metadata.gz: a69935a6c878eba22f3050041d044855b9f98eefa8dc3ab55bd33ca2ecce12efc5abffb2dd0fbc57edfd7736fe5ee4eb985694e4fbcddbc63f2e231bf48483a4
+  data.tar.gz: 58839858c8a5adcf8db74ef9d8c5ed2999c4459854a85c330b107ce3a933d08cb024cacc6c1303c638ab12ae1f5bc6559c14922ac13d17f41a5609631220fc28

data/lib/rigor/analysis/check_rules.rb

@@ -57,6 +57,7 @@ module Rigor
       # system; new rules MUST register here so user configuration
       # can refer to them.
       RULE_UNDEFINED_METHOD = "call.undefined-method"
+      RULE_UNRESOLVED_TOPLEVEL = "call.unresolved-toplevel"
       RULE_WRONG_ARITY = "call.wrong-arity"
       RULE_ARGUMENT_TYPE = "call.argument-type-mismatch"
       RULE_NIL_RECEIVER = "call.possible-nil-receiver"
@@ -72,6 +73,7 @@ module Rigor
 
       ALL_RULES = [
         RULE_UNDEFINED_METHOD,
+        RULE_UNRESOLVED_TOPLEVEL,
         RULE_WRONG_ARITY,
         RULE_ARGUMENT_TYPE,
         RULE_NIL_RECEIVER,
@@ -162,6 +164,7 @@ module Rigor
       def call_node_diagnostics(path, node, scope_index)
         [
           undefined_method_diagnostic(path, node, scope_index),
+          unresolved_toplevel_diagnostic(path, node, scope_index),
           wrong_arity_diagnostic(path, node, scope_index),
           argument_type_diagnostic(path, node, scope_index),
           nil_receiver_diagnostic(path, node, scope_index),
@@ -365,10 +368,14 @@ module Rigor
           return nil if open_receiver?(class_name, scope)
 
           # Slice 7 phase 12 — suppress when the user has
-          # declared the method in source (instance `def`,
-          # `def self.foo`, or recognised `define_method`).
+          # declared the method in source (`def` /
+          # `define_method`) OR in a `pre_eval:` monkey-patch
+          # file (ADR-17). Both paths are project-side method
+          # contributions the dispatcher already resolved; the
+          # rule must not surface a false `undefined-method`
+          # for them.
           kind = receiver_type.is_a?(Type::Singleton) ? :singleton : :instance
-          return nil if scope.discovered_method?(class_name, call_node.name, kind)
+          return nil if source_declared_method?(scope, class_name, call_node.name, kind)
 
           return nil unless Rigor::Reflection.rbs_class_known?(class_name, scope: scope)
 
@@ -404,6 +411,92 @@ module Rigor
           scope.environment.rbs_module?(receiver_type.class_name)
         end
 
+        # Combined suppression probe for `undefined-method` /
+        # `unresolved-toplevel`. Returns true when the method is
+        # declared by any project-side contributor the dispatcher
+        # already resolves: an in-source `def` / `define_method`
+        # (`scope.discovered_method?`) OR an ADR-17 `pre_eval:`
+        # monkey-patch (`Environment#project_patched_methods`).
+        # Both paths sit at the same dispatcher precedence; the
+        # check must hold them together so neither rule fires a
+        # false positive.
+        def source_declared_method?(scope, class_name, method_name, kind)
+          return true if scope.discovered_method?(class_name, method_name, kind)
+
+          project_patched_method?(scope, class_name, method_name, kind)
+        end
+
+        # ADR-17 § "Inference contract" — consults
+        # `Environment#project_patched_methods` so a `def` declared
+        # in a `pre_eval:` file suppresses the diagnostic at the
+        # same dispatcher precedence the registry holds for type
+        # inference (between plugins and dependency-source).
+        # Returns false when the environment carries no registry
+        # (legacy path) or the lookup misses.
+        def project_patched_method?(scope, class_name, method_name, kind)
+          environment = scope.environment
+          registry = environment&.project_patched_methods
+          return false if registry.nil? || registry.empty?
+
+          !registry.lookup(class_name: class_name.to_s, method_name: method_name.to_sym, kind: kind).nil?
+        end
+
+        # ADR-34 — `call.unresolved-toplevel`. Fires on an
+        # implicit-self call (no explicit receiver) at toplevel
+        # scope (`scope.toplevel?`, i.e. outside any class /
+        # module body) whose name does not resolve against:
+        #
+        # 1. A same-file toplevel `def` via
+        #    {Scope#top_level_def_for}.
+        # 2. The ADR-17 `ProjectPatchedMethods` registry under
+        #    `(Object, name, :instance)` — projects declare
+        #    their toplevel-injecting monkey-patches in
+        #    `.rigor.yml`'s `pre_eval:` array as the canonical
+        #    opt-out per ADR-34 WD2.
+        # 3. The standard `Kernel` / `Object` private-method
+        #    surface (`puts`, `p`, `require`, `loop`, `raise`,
+        #    …) drawn from the loaded RBS environment.
+        #
+        # The rule deliberately does NOT generalise to
+        # implicit-self calls inside `def` / `class` / `module`
+        # bodies — ADR-24 WD3's lenient-on-unresolved default
+        # stays in force there. ADR-24 WD4's gated class-body
+        # diagnostic is a separate decision this ADR does not
+        # open.
+        #
+        # Authored severity is `:warning`; the severity profile
+        # remaps it (`strict` → `:error`, `balanced` →
+        # `:warning`, `lenient` → `:off` / suppressed).
+        def unresolved_toplevel_diagnostic(path, call_node, scope_index)
+          return nil unless call_node.receiver.nil?
+
+          scope = scope_index[call_node]
+          return nil if scope.nil?
+          return nil unless scope.toplevel?
+
+          name = call_node.name
+          return nil if scope.top_level_def_for(name)
+          return nil if source_declared_method?(scope, "Object", name, :instance)
+          return nil if Rigor::Reflection.instance_method_definition("Object", name, scope: scope)
+
+          build_unresolved_toplevel_diagnostic(path, call_node)
+        end
+
+        def build_unresolved_toplevel_diagnostic(path, call_node)
+          location = call_node.message_loc || call_node.location
+          Diagnostic.new(
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "unresolved toplevel call to `#{call_node.name}`. " \
+                     "If a project file defines `#{call_node.name}` via a toplevel " \
+                     "`def` or a monkey-patch on Object/Kernel, list that file in " \
+                     "`.rigor.yml`'s `pre_eval:` (ADR-17) so the analyzer sees it.",
+            severity: :warning,
+            rule: RULE_UNRESOLVED_TOPLEVEL
+          )
+        end
+
         # Returns a qualified class name for the in-scope check.
         # Nominal / Singleton carry a single-class identity
         # directly. Constant projects to its value's class.

data/lib/rigor/analysis/erb_template_detector.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Analysis
+    # Detects when a `.rb` file is actually an ERB template — a Rails
+    # generator `templates/foo.rb` shape that uses `<%= ... %>` to
+    # interpolate identifiers. Prism rejects the template as invalid
+    # Ruby and the analyzer emits one parse-error diagnostic per scrap
+    # the parser tripped over (≈ 20 on Redmine's
+    # `lib/generators/redmine_plugin_model/templates/migration.rb`),
+    # all of them noise from the user's perspective. The runner / worker
+    # consults this detector before turning parse errors into
+    # diagnostics; an ERB-shaped source is silently skipped.
+    #
+    # Detection is byte-level on the raw source: any occurrence of the
+    # `%>` closing marker proves the file is an ERB template. `%>`
+    # cannot appear in valid Ruby — `%` is a binary operator that
+    # requires an operand on its right side, never `>`. The opening
+    # `<%` is ambiguous in principle (`x<%y` parses as `x < %y`, a
+    # comparison against a `%`-literal) but a real Ruby file with that
+    # shape would still not contain the closing `%>`.
+    module ErbTemplateDetector
+      ERB_CLOSING_MARKER = /%>/
+
+      module_function
+
+      # @param parse_result [Prism::ParseResult]
+      # @return [Boolean] true when the parsed source looks like an
+      #   ERB template (parse errors expected; analysis should skip).
+      def template?(parse_result)
+        source = parse_result.source.source
+        return false unless source.is_a?(String) && !source.empty?
+
+        ERB_CLOSING_MARKER.match?(source)
+      end
+    end
+  end
+end

data/lib/rigor/analysis/runner.rb

@@ -20,6 +20,7 @@ require_relative "buffer_binding"
 require_relative "check_rules"
 require_relative "dependency_source_inference"
 require_relative "diagnostic"
+require_relative "erb_template_detector"
 require_relative "project_scan"
 require_relative "result"
 require_relative "run_stats"
@@ -1457,7 +1458,11 @@ module Rigor
 
       def analyze_file(path, environment) # rubocop:disable Metrics/MethodLength
         parse_result = parse_source(path)
-        return parse_diagnostics(path, parse_result) unless parse_result.errors.empty?
+        unless parse_result.errors.empty?
+          return [] if ErbTemplateDetector.template?(parse_result)
+
+          return parse_diagnostics(path, parse_result)
+        end
 
         scope = seed_project_scope(Scope.empty(environment: environment, source_path: path))
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)

data/lib/rigor/analysis/worker_session.rb

@@ -15,6 +15,7 @@ require_relative "../inference/method_dispatcher/file_folding"
 require_relative "check_rules"
 require_relative "dependency_source_inference"
 require_relative "diagnostic"
+require_relative "erb_template_detector"
 
 module Rigor
   module Analysis
@@ -158,7 +159,11 @@ module Rigor
       # is a per-run aggregate concern handled by the caller.
       def analyze(path)
         parse_result = parse_source(path)
-        return parse_diagnostics(path, parse_result) unless parse_result.errors.empty?
+        unless parse_result.errors.empty?
+          return [] if ErbTemplateDetector.template?(parse_result)
+
+          return parse_diagnostics(path, parse_result)
+        end
 
         scope = Scope.empty(environment: @environment, source_path: path)
         index = Inference::ScopeIndexer.index(parse_result.value, default_scope: scope)

data/lib/rigor/cli/plugins_command.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require_relative "../configuration"
+require_relative "../plugin"
+require_relative "../plugin/loader"
+require_relative "../plugin/services"
+require_relative "../reflection"
+require_relative "../type/combinator"
+require_relative "plugins_renderer"
+
+module Rigor
+  class CLI
+    # `rigor plugins` — reports the activation status of every
+    # plugin entry in `.rigor.yml` so users (and the
+    # `rigor-project-init` SKILL, CI gates, `rigor init`) can
+    # verify their plugin configuration is actually doing what
+    # they think.
+    #
+    # The command is read-only and idempotent: it loads the
+    # project's `.rigor.yml` (same discovery as `rigor check`),
+    # runs `Plugin::Loader.load` to attempt instantiation, then
+    # prints a table of:
+    #
+    # - load status (`loaded` / `load-error` with reason);
+    # - resolved manifest id, version, description;
+    # - `signature_paths:` (absolute paths + per-dir `.rbs` count);
+    # - every manifest-declared extension surface
+    #   (`open_receivers:` / `owns_receivers:` / `produces:` /
+    #   `consumes:` / `block_as_methods:` / `heredoc_templates:` /
+    #   `trait_registries:` / `external_files:` /
+    #   `type_node_resolvers:` / `hkt_registrations:` /
+    #   `hkt_definitions:` / `protocol_contracts:` /
+    #   `source_rbs_synthesizer:`).
+    #
+    # Output formats: `text` (default, human-readable table) and
+    # `json` (for tooling — SKILLs, CI gates, editor integrations).
+    #
+    # Exit codes:
+    # - `0` — every configured plugin loaded.
+    # - `1` — at least one plugin failed to load AND `--strict`
+    #   was passed. Without `--strict` the command always exits 0;
+    #   load errors are reported but not treated as a gate failure
+    #   (matching `rigor triage`'s advisory shape).
+    #
+    # Future expansion (not in this slice):
+    # - Per-plugin diagnostic counts (would require running the
+    #   full analysis pipeline; out of scope for an inspection
+    #   command).
+    # - Verification that `signature_paths` actually merged into
+    #   the RBS environment without conflict (requires constructing
+    #   the Environment, which is heavier than the loader-only
+    #   pass this slice does).
+    class PluginsCommand
+      USAGE = "Usage: rigor plugins [options]"
+
+      def initialize(argv:, out: $stdout, err: $stderr)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        config_path = options.fetch(:config) || Configuration.discover
+        configuration = Configuration.load(options.fetch(:config))
+        rows = build_rows(configuration)
+
+        renderer = PluginsRenderer.new(rows: rows, configuration_path: config_path)
+        @out.puts(options.fetch(:format) == "json" ? renderer.json : renderer.text)
+
+        any_load_errors = rows.any? { |row| row.fetch(:status) == :load_error }
+        return 1 if any_load_errors && options.fetch(:strict)
+
+        0
+      end
+
+      private
+
+      def parse_options
+        options = { config: nil, format: "text", strict: false }
+        OptionParser.new do |opts|
+          opts.banner = USAGE
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          opts.on("--format=FORMAT", "Output format: text (default) or json") { |v| options[:format] = v }
+          opts.on("--strict", "Exit 1 if any plugin failed to load (CI gate)") { options[:strict] = true }
+        end.parse!(@argv)
+        validate!(options)
+        options
+      end
+
+      def validate!(options)
+        return if %w[text json].include?(options.fetch(:format))
+
+        raise OptionParser::InvalidArgument, "unsupported format: #{options.fetch(:format)}"
+      end
+
+      # Runs the plugin loader against the project configuration
+      # and returns a row per declared plugin entry. Each row is
+      # a plain Hash with the fields enumerated in the class
+      # docstring so the renderer (text + JSON) reads from a
+      # single shape.
+      #
+      # The loader catches require / init failures and surfaces
+      # them through `registry.load_errors`; we merge those back
+      # into the per-entry rows by matching on `plugin_ref`.
+      def build_rows(configuration)
+        services = build_services(configuration)
+        registry = Plugin::Loader.load(configuration: configuration, services: services)
+
+        rows = configuration.plugins.map { |entry| row_for_entry(entry, registry) }
+        # Surface registry-level errors that did not bind to an
+        # entry (e.g. dependency-cycle errors that name multiple
+        # plugins). The renderer treats these as "orphan" errors.
+        orphan_errors = orphan_load_errors(registry, rows)
+        rows + orphan_errors
+      end
+
+      def build_services(configuration)
+        Plugin::Services.new(
+          reflection: Reflection,
+          type: Type::Combinator,
+          configuration: configuration,
+          cache_store: nil
+        )
+      end
+
+      def row_for_entry(entry, registry)
+        gem_name = entry_gem_name(entry)
+        config = entry_config(entry)
+        plugin = registry.plugins.find do |p|
+          # The loader has already matched the entry to a plugin
+          # class; we can identify it by either the gem name (when
+          # the entry was a String) or the explicit id (when the
+          # entry was a Hash with `id:`).
+          plugin_matches_entry?(p, gem_name, entry_id(entry))
+        end
+
+        if plugin
+          loaded_row(plugin, gem_name, config)
+        else
+          # Find the load error whose plugin_ref names this entry
+          # (the ref is set by Loader to the gem name on require
+          # failures and to the manifest id on later failures).
+          error = registry.load_errors.find do |e|
+            ref = e.plugin_ref.to_s
+            ref == gem_name || ref == entry_id(entry).to_s
+          end
+          load_error_row(gem_name, entry_id(entry), config, error)
+        end
+      end
+
+      def plugin_matches_entry?(plugin, gem_name, entry_id)
+        return true if entry_id && plugin.manifest.id == entry_id
+
+        # A bare gem entry conventionally has manifest.id equal to
+        # the gem name with the `rigor-` prefix stripped.
+        derived_id = gem_name.delete_prefix("rigor-")
+        [derived_id, gem_name].include?(plugin.manifest.id)
+      end
+
+      def loaded_row(plugin, gem_name, config)
+        manifest = plugin.manifest
+        identity_fields(gem_name, manifest, config)
+          .merge(extension_fields(plugin, manifest))
+          .merge(load_error: nil)
+      end
+
+      def identity_fields(gem_name, manifest, config)
+        {
+          gem: gem_name,
+          status: :loaded,
+          id: manifest.id,
+          version: manifest.version,
+          description: manifest.description,
+          config: config
+        }
+      end
+
+      def extension_fields(plugin, manifest)
+        {
+          signature_paths: signature_path_rows(plugin),
+          open_receivers: manifest.open_receivers.dup,
+          owns_receivers: manifest.owns_receivers.dup,
+          produces: manifest.produces.map(&:to_s),
+          consumes: manifest.consumes.map { |c| "#{c.plugin_id}/#{c.name}#{'?' if c.optional}" },
+          source_rbs_synthesizer: !manifest.source_rbs_synthesizer.nil?
+        }.merge(extension_count_fields(manifest))
+      end
+
+      def extension_count_fields(manifest)
+        {
+          block_as_methods: manifest.block_as_methods.size,
+          heredoc_templates: manifest.heredoc_templates.size,
+          trait_registries: manifest.trait_registries.size,
+          external_files: manifest.external_files.size,
+          type_node_resolvers: manifest.type_node_resolvers.size,
+          hkt_registrations: manifest.hkt_registrations.size,
+          hkt_definitions: manifest.hkt_definitions.size,
+          protocol_contracts: manifest.protocol_contracts.size
+        }
+      end
+
+      def load_error_row(gem_name, entry_id, config, error)
+        {
+          gem: gem_name,
+          status: :load_error,
+          id: entry_id,
+          version: nil,
+          description: nil,
+          config: config,
+          signature_paths: [],
+          open_receivers: [],
+          owns_receivers: [],
+          produces: [],
+          consumes: [],
+          block_as_methods: 0,
+          heredoc_templates: 0,
+          trait_registries: 0,
+          external_files: 0,
+          type_node_resolvers: 0,
+          hkt_registrations: 0,
+          hkt_definitions: 0,
+          protocol_contracts: 0,
+          source_rbs_synthesizer: false,
+          load_error: error&.message || "plugin did not register or could not be matched to a registered class"
+        }
+      end
+
+      # For each `signature_paths:` directory the plugin resolves
+      # against its gem root, report the absolute path and a
+      # quick `.rbs`-file count. The count is a sanity signal:
+      # an empty bundle directory loads silently today but
+      # contributes nothing.
+      def signature_path_rows(plugin)
+        plugin.signature_paths.map do |abs|
+          {
+            path: abs,
+            exists: File.directory?(abs),
+            rbs_files: rbs_file_count(abs)
+          }
+        end
+      end
+
+      def rbs_file_count(dir)
+        return 0 unless File.directory?(dir)
+
+        Dir.glob(File.join(dir, "**", "*.rbs")).size
+      end
+
+      def entry_gem_name(entry)
+        case entry
+        when String then entry
+        when Hash
+          string_keyed = entry.to_h { |k, v| [k.to_s, v] }
+          (string_keyed["gem"] || string_keyed["id"]).to_s
+        else entry.to_s
+        end
+      end
+
+      def entry_id(entry)
+        case entry
+        when Hash
+          string_keyed = entry.to_h { |k, v| [k.to_s, v] }
+          string_keyed["id"]
+        end
+      end
+
+      def entry_config(entry)
+        case entry
+        when Hash
+          string_keyed = entry.to_h { |k, v| [k.to_s, v] }
+          string_keyed["config"] || {}
+        else {}
+        end
+      end
+
+      # Build orphan-error rows for load errors whose `plugin_ref`
+      # did not bind to any configured plugin entry (e.g. a
+      # dependency-cycle naming a plugin we already accounted for
+      # but reported alongside another). De-duplicates against
+      # errors we already attached.
+      def orphan_load_errors(registry, rows)
+        attached_refs = rows.compact.flat_map { |row| [row[:gem], row[:id]].compact }.to_set
+        unattached = registry.load_errors.reject { |error| attached_refs.include?(error.plugin_ref.to_s) }
+        unattached.map do |error|
+          {
+            gem: error.plugin_ref.to_s,
+            status: :load_error,
+            id: nil,
+            version: nil,
+            description: nil,
+            config: {},
+            signature_paths: [],
+            open_receivers: [], owns_receivers: [], produces: [], consumes: [],
+            block_as_methods: 0, heredoc_templates: 0, trait_registries: 0,
+            external_files: 0, type_node_resolvers: 0,
+            hkt_registrations: 0, hkt_definitions: 0,
+            protocol_contracts: 0, source_rbs_synthesizer: false,
+            load_error: error.message
+          }
+        end
+      end
+    end
+  end
+end