rigortype 0.4.2 → 0.4.4

data/lib/rigor/cli/skill_describe.rb

@@ -377,7 +377,7 @@ module Rigor
       # Parse a SKILL.md's leading `---`-delimited YAML frontmatter. Returns {} on any missing or malformed block so the
       # catalogue degrades to a name-only entry rather than raising.
       def frontmatter(path)
-        text = File.read(path)
+        text = File.read(path, encoding: Encoding::UTF_8)
         return {} unless text.start_with?("---\n")
 
         closing = text.index("\n---\n", 4)

data/lib/rigor/cli/type_of_command.rb

@@ -220,7 +220,8 @@ module Rigor
       # so probes against files outside the current process's CWD still see the right `sig/` tree.
       # Issue #1700 — an editor buffer is scanned for required features in place of the file it stands for.
       def project_environment(files, configuration, buffer = nil)
-        ProjectEnvironment.build(configuration: configuration, source_files: files,
+        patched = ProjectEnvironment.project_patched_methods(configuration, buffer: buffer)
+        ProjectEnvironment.build(configuration: configuration, source_files: files, project_patched_methods: patched,
                                  feature_sources: ProjectEnvironment.buffer_sources(buffer))
       end
 

data/lib/rigor/cli/unused_command.rb

@@ -49,8 +49,8 @@ module Rigor
 
         configuration = Configuration.load(options.fetch(:config))
         paths = @argv.empty? ? configuration.paths : @argv
-        scan_cache = Analysis::Reachability::ScanCache.open(configuration.cache_path,
-                                                            target_ruby: configuration.target_ruby)
+        establish_root(configuration)
+        scan_cache = open_scan_cache(configuration)
         declarations, references, dynamic_uses, shadows = scan(paths, configuration, scan_cache)
         references.concat(signature_references(configuration))
         dynamic_uses.concat(template_mentions(declarations, scan_cache))
@@ -68,6 +68,47 @@ module Rigor
 
       private
 
+      # A scan's role and the spelling it records depend on the root and the working directory (#1760): a role
+      # reads every spelling below either ({#role_of}), and a relative path argument is recorded as written
+      # relative to the working directory.
+      def open_scan_cache(configuration)
+        cwd = canonical(Dir.pwd)
+        spelled = cwd == @root ? "" : ":#{cwd}"
+        Analysis::Reachability::ScanCache.open(configuration.cache_path, target_ruby: configuration.target_ruby,
+                                                                         root: "#{@root}#{spelled}")
+      end
+
+      # The root, and its spellings: the realpath and the logical directory it was named by.
+      def establish_root(configuration)
+        @root = project_root(configuration)
+        logical = @root == canonical(Dir.pwd) ? Dir.pwd : configuration.exclude_base
+        @root_spellings = [@root, File.absolute_path(logical)].uniq
+      end
+
+      # The project root (#1760), realpath'd: the config file's directory, unless the config sits below the
+      # working directory (`--config=ci/rigor.yml` from the project root), where the working directory is the
+      # project. Run from a subdirectory, or from a directory unrelated to the config, it is the config's.
+      # The root never rises above the config's directory or the working directory, so the role rules, which
+      # anchor `qa/`, `e2e/` and `features/` at the root, keep reading the project; an analysed path outside
+      # it reads as `../…`.
+      def project_root(configuration)
+        base = canonical(configuration.exclude_base)
+        cwd = canonical(Dir.pwd)
+        inside?(base, cwd) && base != cwd ? cwd : base
+      end
+
+      def inside?(path, dir)
+        path.start_with?("#{dir.chomp('/')}/")
+      end
+
+      # The directories the wider corpus is read from: the root, and the working directory when it lies
+      # outside the root. Reading the working directory too keeps the corpus no narrower than it was when
+      # the working directory alone was read; a reference only ever makes a declaration more reachable.
+      def corpus_dirs
+        cwd = canonical(Dir.pwd)
+        cwd == @root || inside?(cwd, @root) ? [@root] : [@root, cwd]
+      end
+
       def build_graph(configuration, options, contribution, declarations:, references:, dynamic_uses:, shadows:)
         Analysis::Reachability::Graph.new(
           declarations: declarations, references: references, dynamic_uses: dynamic_uses, shadows: shadows,
@@ -111,21 +152,52 @@ module Rigor
       # references resolve to first (#1732).
       # Every file is consulted every run — an unchanged one contributes its cached scan, so the
       # whole-project completeness the `--incremental` refusal protects is unaffected.
+      #
+      # A file is parsed once however it is spelled (#1760), but every spelling of it keeps what it referred
+      # to under its own path and role, exactly as when each spelling was scanned separately: dropping a
+      # spelling lost its role, and with it a production reference a `spec/` symlink to the same file would
+      # otherwise have hidden. Only the declarations are taken once, from the first analysed spelling, which
+      # is the one the report prints; any other spelling's declarations are shadows, as a wider-corpus
+      # file's are (#1732).
       def scan(paths, configuration, cache)
-        declaration_files = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns).to_set
-        declarations = []
-        shadows = []
-        references = []
-        dynamic_uses = []
-        (declaration_files + reference_files(paths, configuration)).sort.each do |file|
-          result = cache.serve(:scan, file) { read_and_scan(file, configuration) }
+        out = { declarations: [], references: [], dynamic_uses: [], shadows: [] }
+        file_spellings(paths, configuration).sort.each do |real, list|
+          primary, analysed = list.find { |_, declared| declared } || list.first
+          result = cache.serve(:scan, primary) { read_and_scan(primary, real, configuration) }
           next if result.nil?
 
-          (declaration_files.include?(file) ? declarations : shadows).concat(result.declarations)
-          references.concat(result.references)
-          dynamic_uses.concat(result.dynamic_uses)
+          out[analysed ? :declarations : :shadows].concat(result.declarations)
+          list.map(&:first).each { |file| add_spelling(out, result, file, real, primary) }
         end
-        [declarations, references, dynamic_uses, shadows]
+        out.values_at(:declarations, :references, :dynamic_uses, :shadows)
+      end
+
+      def add_spelling(out, result, file, real, primary)
+        out[:shadows].concat(result.declarations.map { |d| d.with(path: file) }) unless file == primary
+        role = role_of(file, real)
+        out[:references].concat(result.references.map { |r| r.with(path: file, role: role) })
+        out[:dynamic_uses].concat(result.dynamic_uses.map { |u| respelled(u, file, role) })
+      end
+
+      # `{realpath => [[spelling, analysed?], ...]}`: the analysed spellings first, in `paths:` order, then
+      # the wider corpus's.
+      def file_spellings(paths, configuration)
+        analysed = Analysis::PathExpansion.ruby_files(paths, configuration.exclude_patterns,
+                                                      base: configuration.exclude_base)
+        spellings = Hash.new { |hash, real| hash[real] = [] }
+        analysed.each { |file| spellings[canonical(file)] << [file, true] }
+        reference_files(paths, configuration).each { |file| spellings[canonical(file)] << [file, false] }
+        spellings = spellings.transform_values { |list| list.uniq(&:first) }
+        @analysed_spellings = spellings.transform_values do |list|
+          list.filter_map do |file, analysed|
+            file if analysed
+          end
+        end
+        spellings
+      end
+
+      def respelled(use, file, role)
+        use.with(path: file, role: role, site: use.site && "#{file}:#{use.line}")
       end
 
       # The reference corpus is the PROJECT, not the analysed paths. A constant declared in `lib/` is commonly
@@ -133,21 +205,80 @@ module Rigor
       # treating those as absent is what manufactured artifacts on two of three corpus targets in #345.
       # Widening the *declaration* set the same way would cancel the gain (measured: +1 / −3 / +2 candidates,
       # ADR-102 WD2), which is exactly why the two corpora are separated rather than both widened.
+      #
+      # The files are read from every {#corpus_dirs} entry (#1760): running from a subdirectory or through a
+      # symlinked spelling reads the same project.
       def reference_files(_paths, configuration)
-        relative = Analysis::Reachability::ProjectFiles.own(Dir.glob(REFERENCE_GLOB, base: Dir.pwd), Dir.pwd)
-        absolute = relative.map { |rel| File.absolute_path(rel) }
-        Analysis::PathExpansion.reject_excluded(absolute, configuration.exclude_patterns).to_set
+        absolute = project_files(REFERENCE_GLOB)
+        Analysis::PathExpansion.reject_excluded(absolute, configuration.exclude_patterns,
+                                                base: configuration.exclude_base)
       end
 
-      def read_and_scan(file, configuration)
+      # The role is read from the file's realpath relative to the project root (#1760), so `test/helper.rb`
+      # is test code whichever directory the command runs from. A file outside the root reads as `../…`,
+      # which names no directory above the root.
+      def read_and_scan(file, real, configuration)
         Analysis::Reachability::Scan.call(path: file, source: File.read(file),
                                           target_ruby: configuration.target_ruby,
-                                          root: File.absolute_path(Dir.pwd))
+                                          role: role_of(file, real))
       rescue SystemCallError
         nil
       end
 
-      # A glob is matched against the declaration's path AND its path relative to the working directory:
+      # Absolute paths of the project's own files matching `glob`, under every corpus directory.
+      def project_files(glob)
+        corpus_dirs.flat_map do |dir|
+          Analysis::Reachability::ProjectFiles.own(Dir.glob(glob, base: dir), dir).map { |rel| File.join(dir, rel) }
+        end.uniq
+      end
+
+      def canonical(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.absolute_path(path)
+      end
+
+      # A file's role (#1760), read from its spellings as written below the project root or the working
+      # directory: the first one below the root decides, and any of them reading as test code makes it test
+      # code, so a `features/` tree below a subdirectory run's working directory stays test code as it was when
+      # the working directory was the only root. The realpath is read only when no written spelling lies below
+      # either: a symlink whose target runs through a `test/` directory must not turn the production files
+      # reached through it into test code.
+      def role_of(file, real)
+        spellings = below(file, @root_spellings) + below(file, cwd_spellings)
+        spellings = below(real, @root_spellings) + below(real, cwd_spellings) if spellings.empty?
+        role_for = Analysis::Reachability::Scan.method(:role_for)
+        return :test if spellings.uniq.any? { |path| role_for.call(path) == :test }
+
+        role_for.call(spellings.first || relative_to_root(real))
+      end
+
+      # `path` relative to every directory in `dirs` it lies below.
+      def below(path, dirs)
+        absolute = File.absolute_path(path)
+        dirs.filter_map { |dir| absolute.delete_prefix("#{dir.chomp('/')}/") if inside?(absolute, dir) }.uniq
+      end
+
+      # The working directory as its realpath and, when the shell's `PWD` names it, as that logical spelling.
+      def cwd_spellings
+        @cwd_spellings ||= begin
+          logical = ENV.fetch("PWD", nil)
+          real = canonical(Dir.pwd)
+          logical && canonical(logical) == real ? [real, Dir.pwd, logical].uniq : [real, Dir.pwd].uniq
+        end
+      end
+
+      def relative_to_root(real)
+        prefix = "#{@root.chomp('/')}/"
+        return real.delete_prefix(prefix) if real.start_with?(prefix)
+
+        Pathname.new(real).relative_path_from(Pathname.new(@root)).to_s
+      rescue ArgumentError
+        real
+      end
+
+      # A glob is matched against every analysed spelling of the declaration's file, and each of them and its
+      # realpath relative to the project root (#1760) and to the working directory:
       # `configuration.paths` are expanded to absolute, so a user-written `--entry-point=lib/entry.rb` would
       # otherwise never match anything and silently produce a root set of zero.
       # A constant named only from the project's own `sig/` is referenced — the #345 probe reported exactly this
@@ -181,8 +312,8 @@ module Rigor
         names = declarations.map(&:fqn)
         return [] if names.empty?
 
-        Analysis::Reachability::ProjectFiles.own(Dir.glob(TEMPLATE_GLOB, base: Dir.pwd), Dir.pwd).flat_map do |rel|
-          absolute = File.absolute_path(rel)
+        project_files(TEMPLATE_GLOB).flat_map do |absolute|
+          rel = relative_to_root(absolute)
           haystack = cache.serve(:runs, absolute) { constant_bearing_text(File.read(absolute).scrub) }
           names.filter_map do |fqn|
             next unless haystack.include?(fqn)
@@ -213,10 +344,12 @@ module Rigor
         return [] if globs.empty?
 
         matcher = Analysis::Reachability::ProjectFiles.method(:entry_point_match?)
-        cwd = "#{File.absolute_path(Dir.pwd)}/"
         declarations.filter_map do |d|
-          relative = d.path.delete_prefix(cwd)
-          d.fqn if globs.any? { |g| matcher.call(g, d.path) || matcher.call(g, relative) }
+          real = canonical(d.path)
+          dirs = @root_spellings + cwd_spellings
+          written = @analysed_spellings.fetch(real, [d.path]) | [d.path]
+          spellings = [*written, relative_to_root(real), *written.flat_map { |w| below(w, dirs) }, *below(real, dirs)]
+          d.fqn if globs.any? { |g| spellings.any? { |path| matcher.call(g, path) } }
         end
       end
 

data/lib/rigor/cli.rb

@@ -51,6 +51,7 @@ module Rigor
       "init" => :run_init,
       "annotate" => :run_annotate,
       "type-of" => :run_type_of,
+      "lens" => :run_lens,
       "trace" => :run_trace,
       "type-scan" => :run_type_scan,
       "effects" => :run_effects,
@@ -291,18 +292,36 @@ module Rigor
 
     # The settings `rigor init` writes: the defaults, with `test_paths:` spelled out as the test roots found now, so
     # the project's config says where its tests are rather than leaving it to auto-detection. The roots are written
-    # relative to the config file's directory, which is what {Configuration.load} resolves them against.
+    # relative to the config file's directory, which is what {Configuration.load} resolves them against. `paths:`
+    # is written the same way: the default `lib` is resolved against the physical cwd, so a config written to
+    # `config/rigor.yml` must say `../lib`, or it loads back as `config/lib` (#1399).
     #
     # `target_ruby` is left out (the template writes it commented): a written key is a statement about the runtime
     # (#1692), and the starter must not make one the user never chose.
     def init_settings(path)
+      config_dir = config_dir_of(path)
       settings = Configuration::DEFAULTS.except("target_ruby")
+      settings = settings.merge("paths" => roots_relative_to(settings.fetch("paths"), config_dir))
       test_paths = Configuration.new.resolved_test_paths
       return settings if test_paths.empty?
 
-      config_dir = Pathname(File.absolute_path(File.dirname(path)))
-      relative = test_paths.map { |root| Pathname(root).relative_path_from(config_dir).to_s }
-      settings.merge("test_paths" => relative)
+      settings.merge("test_paths" => roots_relative_to(test_paths, config_dir))
+    end
+
+    # The directory the config file's roots are written relative to. An absolute `--path` is taken through its
+    # physical directory: the roots are resolved against the physical cwd (`Dir.pwd` is getcwd), so a logical
+    # spelling through a symlink makes the lexical `..` climb a different tree than the kernel does (#1399 review).
+    # A relative `--path` stays lexical, as {Configuration.load} resolves it.
+    def config_dir_of(path)
+      dir = File.dirname(path)
+      Pathname(Pathname(path).absolute? ? File.realdirpath(dir) : File.absolute_path(dir))
+    end
+
+    # Each root is resolved against the physical cwd (where `rigor` reads it from), then written relative to the config
+    # dir. With the config at the project root, both sides are the same physical directory, so the roots come out as
+    # they are spelled from it (`lib`, `spec`), which is master's output for the default config.
+    def roots_relative_to(roots, config_dir)
+      roots.map { |root| Pathname(File.absolute_path(root)).relative_path_from(config_dir).to_s }
     end
 
     def run_annotate
@@ -317,6 +336,12 @@ module Rigor
       TypeOfCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_lens
+      require_relative "cli/lens_command"
+
+      LensCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_trace
       require_relative "cli/trace_command"
 
@@ -463,6 +488,7 @@ module Rigor
           init       Create a starter .rigor.yml
           annotate   Print FILE with each line's last-expression type
           type-of    Print inferred types at FILE:LINE[:COL] positions
+          lens       Map a file's declarations with their types and provenance (experimental)
           trace      Replay how the engine typed FILE as a terminal animation
           type-scan  Report Scope#type_of coverage across PATHs
           effects    Report each method's effect labels, and the committed effect snapshot

data/lib/rigor/config_audit.rb

@@ -26,11 +26,12 @@ module Rigor
   #
   # Every check is held to the same bar that {SignaturePathAudit} set: it mirrors the
   # loader's own acceptance test, so a warning means the loader really did load nothing, and
-  # it never fires on a setup that works. In particular the rule-token check only flags a
-  # token under a built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*` rule id
-  # (whose family Rigor cannot statically enumerate, since a `node_rule` block emits any
-  # `rule:` string it likes) is left alone, so disabling a plugin rule is never mistaken for
-  # a typo.
+  # it never fires on a setup that works. In particular the `severity_overrides:` check only
+  # flags a key under a built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*`
+  # rule id (whose family Rigor cannot statically enumerate, since a `node_rule` block emits
+  # any `rule:` string it likes) is left alone. The `disable:` check goes further because the
+  # list's reach is enumerable (issue #1953): a plugin's row answers only to its qualified
+  # `plugin.<id>.<rule>` id, so a bare plugin rule there is inert (see {.disable_token_warning}).
   module ConfigAudit
     # One config-level finding. `kind` discriminates the source key (`:signature_path`,
     # `:bundled_plugin_signature_path`, `:library`, `:disabled_rule`, `:severity_override`,
@@ -146,18 +147,13 @@ module Rigor
       []
     end
 
-    # `disable:` tokens and `severity_overrides:` keys that name no rule. Restricted to
-    # tokens under a built-in family so a plugin rule id is never mis-flagged (see the module
-    # docstring).
+    # `disable:` tokens that reach no row ({.disable_token_warning}) and `severity_overrides:` keys
+    # that name no rule. An override key is flagged only under a built-in family, so a plugin
+    # rule id is never mis-flagged (see the module docstring).
     def self.rule_token_warnings(configuration)
+      plugin_ids = configured_plugin_ids(configuration.plugins)
       disable = Array(configuration.disabled_rules).filter_map do |token|
-        next unless inert_builtin_token?(token.to_s)
-
-        Warning.new(
-          kind: :disabled_rule,
-          message: "disable: #{token.to_s.inspect} is not a recognized rule id; the suppression has no effect",
-          fields: { "token" => token.to_s }
-        )
+        disable_token_warning(token.to_s, plugin_ids)
       end
       overrides = configuration.severity_overrides.keys.filter_map do |key|
         next unless inert_builtin_token?(key.to_s)
@@ -171,6 +167,106 @@ module Rigor
       disable + overrides
     end
 
+    # Issue #1953 — the run-level rows the diagnostic policy keeps on `severity_overrides:` and the
+    # baseline. `disable:` does not reach them by any spelling, so naming one there is inert.
+    RESERVED_RUN_LEVEL_FAMILIES = %w[plugin_loader plugin_trust rbs.coverage dynamic.dependency-source].freeze
+    RESERVED_RUN_LEVEL_IDS = %w[load-error runtime-error pool-degraded].freeze
+    private_constant :RESERVED_RUN_LEVEL_FAMILIES, :RESERVED_RUN_LEVEL_IDS
+
+    # A warning for a `disable:` token that can reach no row, or nil. Since issue #1953 the list's
+    # reach is exactly enumerable for three shapes, and those are what this flags:
+    #
+    # - a token naming a reserved run-level row ({RESERVED_RUN_LEVEL_FAMILIES} /
+    #   {RESERVED_RUN_LEVEL_IDS}), which the list never reaches;
+    # - a `plugin.`-qualified token naming no plugin `plugins:` configures — checked only when
+    #   every entry's manifest id is known without loading it ({.configured_plugin_ids});
+    # - any other token that is not `all`, a family, a legacy alias or a catalogue / `pre-eval.*`
+    #   id. A bare id never reaches a plugin's row, so a plugin's bare rule is inert here too.
+    #
+    # A token under a non-check engine family (`rbs_extended.*`, `rbs.*`, `dynamic.*`) or a known
+    # non-catalogue engine id stays unflagged: under-warning is this module's FP-safe direction.
+    def self.disable_token_warning(token, plugin_ids)
+      return nil if effective_disable_token?(token)
+
+      reason = disable_token_problem(token, plugin_ids)
+      return nil if reason.nil?
+
+      Warning.new(kind: :disabled_rule, message: "disable: #{token.inspect} #{reason}",
+                  fields: { "token" => token })
+    end
+
+    def self.disable_token_problem(token, plugin_ids)
+      if reserved_run_level_token?(token)
+        "names a run-level row, which `disable:` does not reach; use `severity_overrides:` or a baseline"
+      elsif token.start_with?(Analysis::CheckRules::PLUGIN_FAMILY_PREFIX)
+        unless plugin_ids.nil? || plausible_plugin_token?(token, plugin_ids)
+          "names no plugin `plugins:` configures; the suppression has no effect"
+        end
+      elsif inert_builtin_token?(token)
+        "is not a recognized rule id; the suppression has no effect"
+      elsif !non_check_engine_token?(token)
+        "is not a recognized rule id; the suppression has no effect " \
+          "(if this is a plugin's rule, write it as `plugin.<id>.<rule>`)"
+      end
+    end
+    private_class_method :disable_token_problem
+
+    def self.effective_disable_token?(token)
+      return true if token == "all"
+
+      !Array(Analysis::CheckRules.resolve_rule_token(token)).empty?
+    end
+    private_class_method :effective_disable_token?
+
+    def self.reserved_run_level_token?(token)
+      RESERVED_RUN_LEVEL_IDS.include?(token) ||
+        RESERVED_RUN_LEVEL_FAMILIES.any? { |family| token == family || token.start_with?("#{family}.") }
+    end
+    private_class_method :reserved_run_level_token?
+
+    def self.non_check_engine_token?(token)
+      Analysis::CheckRules::NON_CHECK_DIAGNOSTIC_IDS.include?(token) ||
+        Analysis::CheckRules::NON_CHECK_DIAGNOSTIC_FAMILIES.include?(token.split(".").first)
+    end
+    private_class_method :non_check_engine_token?
+
+    # `plugin.<id>` or `plugin.<id>.<rule>` for a configured id. A manifest id may itself hold a
+    # dot, so the token is matched against each id rather than split.
+    def self.plausible_plugin_token?(token, plugin_ids)
+      rest = token.delete_prefix(Analysis::CheckRules::PLUGIN_FAMILY_PREFIX)
+      plugin_ids.any? { |id| rest == id || rest.start_with?("#{id}.") }
+    end
+    private_class_method :plausible_plugin_token?
+
+    # The manifest id of every `plugins:` entry, or nil when one cannot be known without loading
+    # the plugin. An explicit `id:` is the id; a bundled plugin's id is its gem name minus the
+    # `rigor-` prefix ({Plugin::FirstParty}); a third-party gem named without `id:` may register
+    # any id, so its presence turns the plugin-token check off. An `enabled: false` entry counts:
+    # the user has found the plugin, and under-warning is the FP-safe direction.
+    def self.configured_plugin_ids(plugins)
+      Array(plugins).each_with_object(Set.new) do |raw, ids|
+        entry = raw.is_a?(Hash) ? raw.to_h { |key, value| [key.to_s, value] } : { "gem" => raw.to_s }
+        if entry["id"]
+          ids << entry["id"].to_s
+        elsif bundled_plugin_gem?(entry["gem"].to_s)
+          ids << entry["gem"].to_s.delete_prefix(BUNDLED_GEM_PREFIX)
+        else
+          return nil
+        end
+      end
+    end
+    private_class_method :configured_plugin_ids
+
+    BUNDLED_GEM_PREFIX = "rigor-"
+    private_constant :BUNDLED_GEM_PREFIX
+
+    def self.bundled_plugin_gem?(gem)
+      return false unless gem.start_with?(BUNDLED_GEM_PREFIX)
+
+      File.file?(File.join(SignaturePathAudit::BUNDLED_PLUGINS_ROOT, gem, "lib", "#{gem}.rb"))
+    end
+    private_class_method :bundled_plugin_gem?
+
     # True when `token` looks like a built-in rule id but matches none — its first segment
     # is a built-in family yet it is neither a bare family wildcard nor a known canonical id.
     # A token whose family is not built-in (a plugin / `rbs_extended.*` rule, or a bare

data/lib/rigor/configuration/dependencies.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../configuration_error"
+
 module Rigor
   class Configuration
     # Parsed `dependencies:` section of `.rigor.yml`. Per
@@ -56,7 +58,7 @@ module Rigor
       # Hash with `source_inference:` and / or `budget_per_gem:` / `budget_overrun_strategy:` present.
       def self.from_h(data)
         return new([]) if data.nil?
-        raise ArgumentError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
+        raise ConfigurationError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
 
         raw_entries = coerce_source_inference(data["source_inference"])
         entries, warnings = dedupe_entries(raw_entries)
@@ -139,7 +141,7 @@ module Rigor
           return [] if value.nil? || value == false
 
           unless value.is_a?(Array)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference: must be a list of entries " \
                   "(or false / omitted to disable), got #{value.inspect}"
           end
@@ -149,7 +151,7 @@ module Rigor
 
         def coerce_entry(raw)
           unless raw.is_a?(Hash)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference[] entry must be a Hash, got #{raw.inspect}"
           end
 
@@ -162,7 +164,7 @@ module Rigor
 
         def coerce_gem(value)
           unless value.is_a?(String) && !value.empty?
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.source_inference[].gem must be a non-empty String, got #{value.inspect}"
           end
 
@@ -170,28 +172,34 @@ module Rigor
         end
 
         def coerce_mode(value)
-          mode = (value || "when_missing").to_sym
+          mode = config_symbol(value || "when_missing")
           return mode if VALID_MODES.include?(mode)
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.source_inference[].mode must be one of " \
                 "#{VALID_MODES.inspect}, got #{value.inspect}"
         end
 
+        # The Symbol a String / Symbol value names, or nil for any other YAML shape (a number, a list, a mapping), which
+        # the caller then reports as not one of its valid values rather than crashing on `#to_sym`.
+        def config_symbol(value)
+          value.to_sym if value.is_a?(String) || value.is_a?(Symbol)
+        end
+
         def coerce_roots(raw)
           roots = Array(raw.fetch("roots", DEFAULT_ROOTS)).map(&:to_s).freeze
           return roots unless roots.empty?
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.source_inference[].roots must not be empty when supplied " \
                 "(omit the key to fall back to the default #{DEFAULT_ROOTS.inspect})"
         end
 
         def coerce_budget_overrun_strategy(value)
-          symbol = value.to_sym
+          symbol = config_symbol(value)
           return symbol if VALID_BUDGET_OVERRUN_STRATEGIES.include?(symbol)
 
-          raise ArgumentError,
+          raise ConfigurationError,
                 "dependencies.budget_overrun_strategy must be one of " \
                 "#{VALID_BUDGET_OVERRUN_STRATEGIES.inspect}, got #{value.inspect}"
         end
@@ -201,13 +209,13 @@ module Rigor
         # MIN_BUDGET_PER_GEM .. MAX_BUDGET_PER_GEM (i.e. 0.25× – 4× of the default).
         def coerce_budget_per_gem(value)
           unless value.is_a?(Integer)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.budget_per_gem must be an Integer, " \
                   "got #{value.inspect}"
           end
 
           unless value.between?(MIN_BUDGET_PER_GEM, MAX_BUDGET_PER_GEM)
-            raise ArgumentError,
+            raise ConfigurationError,
                   "dependencies.budget_per_gem must be in the range " \
                   "#{MIN_BUDGET_PER_GEM}..#{MAX_BUDGET_PER_GEM}, " \
                   "got #{value.inspect}"

data/lib/rigor/configuration.rb

@@ -356,6 +356,13 @@ module Rigor
         data = DEFAULTS.merge(raw)
       end
       new(autowire_default_plugins(data), effects_key_present, target_ruby_key_present || false)
+        .with_exclude_base(resolved && File.exist?(resolved) ? File.dirname(resolved) : nil)
+    end
+
+    # #1576 — the directory relative `exclude:` patterns are matched against: the directory of the config file in
+    # use (the base `paths:` resolve against), or the working directory when no config file is used.
+    def exclude_base
+      @base_dir || Dir.pwd
     end
 
     # ADR-93 WD2 — the one bundled plugin default-wired without a `plugins:` entry. `rigor-rbs-inline` is the
@@ -746,6 +753,14 @@ module Rigor
       copy.freeze
     end
 
+    # #1576 — a sibling Configuration whose relative `exclude:` patterns match against `dir` (nil: the working
+    # directory). {Configuration.load} sets it to the loaded config file's directory.
+    def with_exclude_base(dir)
+      copy = dup
+      copy.instance_variable_set(:@base_dir, dir && File.absolute_path(dir).freeze)
+      copy.freeze
+    end
+
     # #1777 — a sibling Configuration with only `baseline:` unset, every other field (including the
     # explicitness of `target_ruby`) shared with the receiver. `rigor baseline generate` analyses with
     # this so the generating run sees exactly the configuration `rigor check` will, minus the filter it

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -118,15 +118,19 @@ module Rigor
       # `{name => LockedGem}` → set of canonical bundler gem directory basenames. Pure-Ruby gems install as
       # `<name>-<version>`; platform-specific gems install as `<name>-<version>-<platform>` (e.g.
       # `ffi-1.17.4-aarch64-linux-gnu`). Lockfile platform `"ruby"` is the pure-Ruby case; any other value is
-      # treated as a platform tag.
+      # treated as a platform tag. Every locked variant contributes a directory (#1844): the set only selects
+      # among directories that are actually installed, so admitting another platform's name costs nothing,
+      # while dropping the host's would discard its `sig/`.
       def self.expected_gem_dirs(locked_gems)
         locked_gems.each_value.with_object(Set.new) do |locked, set|
-          base = "#{locked.name}-#{locked.version}"
-          set << if locked.platform == "ruby" || locked.platform.empty?
-                   base
-                 else
-                   "#{base}-#{locked.platform}"
-                 end
+          locked.variants.each do |version, platform|
+            base = "#{locked.name}-#{version}"
+            set << if platform == "ruby" || platform.empty?
+                     base
+                   else
+                     "#{base}-#{platform}"
+                   end
+          end
         end
       end
       private_class_method :expected_gem_dirs