rigortype 0.1.10 → 0.1.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3425a6183f3c9312517a9a82de77b561907c0afd99f8f77844d08741a766fae8
-  data.tar.gz: cef2e0e925fb844e4112552626966319c942ff0f31ff6d2af05b04ec8c2ee93f
+  metadata.gz: 182bad9de02b3b4579fe1c385fa740e30f2df85cad36d8c21647dfb09004b9eb
+  data.tar.gz: 398d4ebc670530522696122117592bd59b60d7f899ae0a8cd58b11c8506ec608
 SHA512:
-  metadata.gz: 749cd171f08f03311d70da91e742b07980974876889d152827ae8e3aa4518d2c2f933475efa889e3c63a7f715eddb96112584445967c3e15fe7c58c38d0ed3cd
-  data.tar.gz: bb5f032e6663cb137b774bfd18d39ad1498b0913d552a92b86c0256fd8a2fb76c1426d9914f01caf3f78359c96079d8dfc7c84f09e2fb473681cf0889ee46e09
+  metadata.gz: abd25775ea4973023dc7ef7132669a0bf556604c7378caef60aa3c2fbae4ef79bc2651cd3499cecb8046507214dbdc4cb56bdb953c301ec42b0ebb86291202b6
+  data.tar.gz: 9281f16a4b2d39847aaaf408844920dfb9f2e6a914df3544182d6d3832f28f03ca63d8a19aa54ca80977f3431351717a59d7ba704f3361ee92697be21d6193ab

data/lib/rigor/analysis/baseline.rb

@@ -52,6 +52,15 @@ module Rigor
     # CLI or `baseline: <path>` in `.rigor.yml`). The presence
     # of `.rigor-baseline.yml` on disk alone never triggers a
     # load — that's the CLI / Configuration's job to enforce.
+    #
+    # ## Path handling
+    #
+    # Baselines store file paths **relative to the project root**
+    # (the working directory when `rigor` is run). This makes the
+    # generated `.rigor-baseline.yml` portable across machines and
+    # checkout locations. When filtering a live diagnostic stream,
+    # the instance normalises each diagnostic's absolute path to a
+    # relative one before the bucket lookup.
     class Baseline
       # The bucket key is intentionally tuple-shaped so rule-ID
       # rows and message-pattern rows can coexist in a single
@@ -69,12 +78,16 @@ module Rigor
         # path is nil (the caller's "no baseline configured"
         # state). Raises {LoadError} on malformed content;
         # callers translate to a user-facing diagnostic.
-        def load(path)
+        #
+        # `project_root:` is the working directory against which
+        # stored relative paths are resolved during filtering.
+        # Defaults to `Dir.pwd`.
+        def load(path, project_root: Dir.pwd)
           return nil if path.nil?
-          return new([]) unless File.exist?(path)
+          return new([], project_root: project_root) unless File.exist?(path)
 
           raw = YAML.safe_load_file(path, permitted_classes: [Symbol])
-          parse_loaded(raw, path: path)
+          parse_loaded(raw, path: path, project_root: project_root)
         end
 
         # Build a baseline from a current run's diagnostic stream.
@@ -82,10 +95,14 @@ module Rigor
         # message-mode generator passes literal messages through
         # `Regexp.escape` so generated rows never accidentally
         # over-match on punctuation.
-        def from_diagnostics(diagnostics, match_mode: :rule)
+        #
+        # `project_root:` is used to convert absolute diagnostic
+        # paths to relative paths in the generated YAML. Defaults
+        # to `Dir.pwd`.
+        def from_diagnostics(diagnostics, match_mode: :rule, project_root: Dir.pwd)
           raise ArgumentError, "match_mode must be :rule or :message" unless %i[rule message].include?(match_mode)
 
-          grouped = group_for_baseline(diagnostics, match_mode)
+          grouped = group_for_baseline(diagnostics, match_mode, project_root)
           buckets = grouped.map do |key, entries|
             Bucket.new(
               file: key[0],
@@ -94,12 +111,12 @@ module Rigor
               count: entries.size
             )
           end
-          new(buckets)
+          new(buckets, project_root: project_root)
         end
 
         private
 
-        def parse_loaded(raw, path:)
+        def parse_loaded(raw, path:, project_root:)
           raise LoadError, "#{path}: expected a Hash at top level, got #{raw.class}" unless raw.is_a?(Hash)
 
           version = raw["version"]
@@ -110,7 +127,8 @@ module Rigor
           rows = raw["ignored"] || []
           raise LoadError, "#{path}: `ignored:` must be an Array" unless rows.is_a?(Array)
 
-          new(rows.each_with_index.map { |row, idx| parse_row(row, path: path, index: idx) })
+          new(rows.each_with_index.map { |row, idx| parse_row(row, path: path, index: idx) },
+              project_root: project_root)
         end
 
         def parse_row(row, path:, index:)
@@ -141,16 +159,19 @@ module Rigor
         # In message mode, each unique message gets its own bucket;
         # in rule mode, every diagnostic for a (file, rule) pair
         # contributes to a single bucket regardless of message.
-        def group_for_baseline(diagnostics, match_mode)
+        # File paths are normalised to relative before keying.
+        def group_for_baseline(diagnostics, match_mode, project_root)
+          root = Pathname.new(project_root)
           diagnostics.each_with_object({}) do |diag, into|
             next if diag.qualified_rule.nil?
             next if diag.path.nil?
 
+            rel = relative_path(diag.path, root)
             key = case match_mode
                   when :rule
-                    [diag.path, diag.qualified_rule, nil]
+                    [rel, diag.qualified_rule, nil]
                   when :message
-                    [diag.path, diag.qualified_rule, message_pattern_for(diag.message)]
+                    [rel, diag.qualified_rule, message_pattern_for(diag.message)]
                   end
             (into[key] ||= []) << diag
           end
@@ -164,13 +185,20 @@ module Rigor
         def message_pattern_for(message)
           Regexp.new(Regexp.escape(message.to_s))
         end
+
+        def relative_path(path, root_pathname)
+          Pathname.new(path).relative_path_from(root_pathname).to_s
+        rescue ArgumentError
+          path # different drive letter on Windows or non-child path
+        end
       end
 
       class LoadError < StandardError; end
 
       attr_reader :buckets
 
-      def initialize(buckets)
+      def initialize(buckets, project_root: Dir.pwd)
+        @project_root = Pathname.new(project_root)
         @buckets = buckets.freeze
         # For each (file, qualified_rule) pair, two arrays:
         # - rule-ID rows (message_regex == nil)
@@ -264,7 +292,7 @@ module Rigor
       # cleared buckets (`actual == 0`) from the on-disk file.
       def without(buckets_to_drop)
         dropset = buckets_to_drop.to_set
-        self.class.new(buckets.reject { |b| dropset.include?(b) })
+        self.class.new(buckets.reject { |b| dropset.include?(b) }, project_root: @project_root)
       end
 
       # Serialise to a YAML string. The generator path writes
@@ -307,6 +335,14 @@ module Rigor
         [bucket.file, bucket.rule, bucket.message_regex&.source]
       end
 
+      def normalize_path(path)
+        return path if path.nil?
+
+        Pathname.new(path).relative_path_from(@project_root).to_s
+      rescue ArgumentError
+        path # different drive letter on Windows or non-child path
+      end
+
       def group_diagnostics_for_filtering(diagnostics)
         # First pass: bin each diagnostic into the bucket that
         # claims it. Message-pattern rows take precedence over
@@ -322,7 +358,7 @@ module Rigor
                   [bucket.file, bucket.rule,
                    bucket.message_regex&.source]
                 else
-                  [diag.path, diag.qualified_rule, :__none__]
+                  [normalize_path(diag.path), diag.qualified_rule, :__none__]
                 end
           bin = (bins[key] ||= { bucket: bucket, diagnostics: [] })
           bin[:diagnostics] << diag
@@ -331,7 +367,7 @@ module Rigor
       end
 
       def claim_bucket_for(diagnostic)
-        candidates = @by_pair[[diagnostic.path, diagnostic.qualified_rule]]
+        candidates = @by_pair[[normalize_path(diagnostic.path), diagnostic.qualified_rule]]
         return nil if candidates.nil? || candidates.empty?
 
         # Tighter (message-pattern) buckets first, then the

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/baseline_command.rb

@@ -84,7 +84,8 @@ module Rigor
         configuration = Configuration.load(options.fetch(:config))
         diagnostics = collect_diagnostics(configuration, options)
 
-        baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode))
+        baseline = Analysis::Baseline.from_diagnostics(diagnostics, match_mode: options.fetch(:match_mode),
+                                                                    project_root: Dir.pwd)
         File.write(path, baseline.to_yaml)
 
         @err.puts(
@@ -149,7 +150,7 @@ module Rigor
         defaults = Configuration::DEFAULTS.merge(
           "paths" => configuration.paths,
           "exclude" => configuration.exclude_patterns,
-          "plugins" => configuration.plugins.map(&:to_h),
+          "plugins" => configuration.plugins,
           "disable" => configuration.disabled_rules,
           "libraries" => configuration.libraries,
           "signature_paths" => configuration.signature_paths,
@@ -372,7 +373,7 @@ module Rigor
           @err.puts("rigor: baseline file not found: #{path}")
           return :error
         end
-        Analysis::Baseline.load(path)
+        Analysis::Baseline.load(path, project_root: Dir.pwd)
       rescue Analysis::Baseline::LoadError => e
         @err.puts("rigor: baseline load failed: #{e.message}")
         :error

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