rigortype 0.4.6 → 0.4.8

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -107,8 +107,9 @@ module Rigor
       # difference is worth stating because the two look like the same problem. There, a stale
       # `bundler/gems/` directory left behind by a gem that moved to a released version made the loader
       # load the WRONG SIGNATURES, collapsing the RBS environment. Here the index's whole output is a gem
-      # NAME, so reading a stale checkout of the same gem yields the same answer; and the rubygems lookup
-      # is consulted FIRST in {.build}, so a gem now installed from RubyGems never reaches this map at all.
+      # NAME, so reading a stale checkout of the same gem yields the same answer; and the RubyGems-layout
+      # bundle directory is consulted FIRST in {.build}, so a gem installed from RubyGems at its locked
+      # version never reaches this map.
       def git_gem_dirs(bundle_path)
         return {} if bundle_path.nil?
 

data/lib/rigor/environment/project_path_gems.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "../analysis/path_expansion"
+
+module Rigor
+  class Environment
+    # Issue #2441 — the locked gems that ARE the analysed project: a `PATH` stanza whose directory Rigor analyses
+    # as project source. `rbs collection install` still fetches community RBS for such a gem (its generator skips
+    # only a `gemspec` source), and the project's `sig/` declares the same classes, so the collection copy would
+    # double-declare every member. The same gem is not `:missing` RBS either, so it must not make an ADR-72
+    # overlay or a WD9 missing-gem index entry eligible.
+    #
+    # "Analysed as project source" means the gem's directory is at or under one of the configured `paths:`
+    # entries, or contains one: rails lists `actionpack/lib` in `paths:` and locks `actionpack` from
+    # `PATH remote: actionpack`. A `PATH` gem no `paths:` entry reaches — a vendored `vendor/gems/foo`, a sibling
+    # checkout — is a dependency and keeps its collection RBS.
+    #
+    # #2592 — a reached gem counts only when the file walker would analyse at least one of its Ruby files: some
+    # `**/*.rb` under the part of the gem a `paths:` entry covers survives `Analysis::PathExpansion.reject_excluded`.
+    # A gem whose Ruby the configuration's `exclude:` patterns all leave out — `vendor/**`, `vendor/**/*.rb`, or
+    # `vendor/gems/foo/lib/**` when `lib/` holds all of it — keeps its collection RBS, and so does a reached
+    # directory with no Ruby at all. A `paths:` entry naming one `.rb` file inside the gem counts that file. The
+    # overlap is found on real paths, so a symlinked spelling of the same directory matches, but the files are
+    # walked and matched against `exclude:` through the `paths:` entry as written, as the walker matches them.
+    module ProjectPathGems
+      module_function
+
+      # @param locked — `{name => LockfileResolver::LockedGem}`.
+      # @param paths — the configured `paths:` entries; relative ones resolve against `root`.
+      # @param exclude_patterns — the configuration's `exclude_patterns`, matched against `exclude_base`.
+      # @return frozen set of gem names. Empty when `paths` is nil or empty.
+      def names(locked, paths:, root: Dir.pwd, exclude_patterns: [], exclude_base: root)
+        entries = Array(paths).map do |path|
+          logical = File.expand_path(path.to_s, root.to_s)
+          [logical, real(logical)]
+        end.uniq
+        return Set.new.freeze if entries.empty?
+
+        locked.each_value.filter_map do |gem|
+          dir = gem.path_source
+          next unless dir
+
+          dir = real(dir)
+          covered = entries.filter_map { |logical, real_entry| covered_part(dir, logical, real_entry) }
+          gem.name if covered.uniq.any? { |part| analysed_ruby?(part, Array(exclude_patterns), exclude_base.to_s) }
+        end.to_set.freeze
+      end
+
+      # The part of the gem at real directory `dir` that the `paths:` entry covers, spelled through the entry as
+      # written (`logical`), as the file walker spells the files it matches `exclude:` against: the entry itself
+      # when it lies at or under the gem, or the gem's directory reached through the entry when the gem lies under
+      # it. Nil when they do not overlap.
+      def covered_part(dir, logical, real_entry)
+        return logical if at_or_under?(real_entry, dir)
+        return unless at_or_under?(dir, real_entry)
+
+        rest = dir.byteslice(real_entry.bytesize..).delete_prefix("/")
+        rest.empty? ? logical : File.join(logical, rest)
+      end
+
+      # True when `path` is `dir` or lies under it. Joined with a `/` only when `dir` does not already end in one,
+      # so `/` reaches everything without spelling `//`, and `/proj/lib2` is not under `/proj/lib`.
+      def at_or_under?(path, dir)
+        return true if path == dir
+
+        path.start_with?(dir.end_with?("/") ? dir : "#{dir}/")
+      end
+
+      # Files are matched in slices as the walk finds them, so a large gem stops at the first slice holding a
+      # surviving file instead of listing its whole tree first (`Dir.glob` with a block still builds the list).
+      EXCLUDE_SLICE = 64
+      private_constant :EXCLUDE_SLICE
+
+      # True when the file walker ({Analysis::PathExpansion.ruby_files}) would analyse some `.rb` file of `part`:
+      # the `.rb` file itself when `part` names one, else a `**/*.rb` under the directory, that survives `patterns`.
+      def analysed_ruby?(part, patterns, base)
+        return surviving?([part], patterns, base) if File.file?(part)
+        return false unless File.directory?(part)
+
+        slice = []
+        found = each_ruby_file(part) do |file|
+          slice << file
+          next false if slice.size < EXCLUDE_SLICE
+
+          hit = surviving?(slice, patterns, base)
+          slice = []
+          hit
+        end
+        found || surviving?(slice, patterns, base)
+      end
+
+      # Walks `dir` as `Dir.glob("dir/**/*.rb")` matches: sorted, no dot-named entries, no descent through a
+      # symlinked directory. Stops and returns true as soon as the block returns true.
+      def each_ruby_file(dir, &)
+        Dir.children(dir).sort.each do |name|
+          next if name.start_with?(".")
+
+          path = File.join(dir, name)
+          if name.end_with?(".rb") && !File.directory?(path)
+            return true if File.exist?(path) && yield(path)
+          elsif File.directory?(path) && !File.symlink?(path)
+            return true if each_ruby_file(path, &)
+          end
+        end
+        false
+      rescue SystemCallError
+        false
+      end
+
+      def surviving?(files, patterns, base)
+        return false if files.empty?
+        return files.any? { |file| file.end_with?(".rb") } if patterns.empty?
+
+        Analysis::PathExpansion.reject_excluded(files, patterns, base: base).any? { |file| file.end_with?(".rb") }
+      end
+
+      def real(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -19,12 +19,16 @@ module Rigor
     # access. Failure modes (missing lockfile, malformed YAML, missing collection directory) silently
     # degrade to an empty list.
     module RbsCollectionDiscovery
-      # `stdlib`-typed entries in the lockfile are loaded into the RBS environment by the standard library
-      # mechanism (rigor's `Environment::DEFAULT_LIBRARIES` already covers this surface). Including them as
-      # `signature_paths:` entries would risk `RBS::DuplicatedDeclarationError` (the same hazard O7's
-      # failure-memo handles). The other documented source types — `git` (the gem_rbs_collection repo),
-      # `rubygems` (sigs lifted from a gem's bundled `sig/`), and `local` (a user-managed RBS dir) — all
-      # produce a directory under the collection root and are admitted.
+      # `stdlib`-typed entries (`source: { type: stdlib }`) name a library rbs ships under its own `stdlib/`, and
+      # produce no directory under the collection root, so {.discover} never returns one. Issue #2946 — they are
+      # loaded all the same, as the `rbs` CLI's `EnvironmentLoader#add_collection` loads them: as RBS LIBRARIES.
+      # {.stdlib_library_names} lists them, and `Environment::BaseLibraries.resolve` appends them to the library list,
+      # which is de-duplicated, so an entry `DEFAULT_LIBRARIES` already names is not loaded twice. A collection
+      # gem that subclasses one (actionview's `NodeParser < ::Ripper`) then builds. An unknown name is dropped by
+      # the loader's `has_library?` filter, as a `libraries:` name is, and `ConfigAudit` reports it. The other
+      # documented source types — `git` (the gem_rbs_collection repo), `rubygems` (sigs lifted from a gem's
+      # bundled `sig/`), and `local` (a user-managed RBS dir) — all produce a directory under the collection root
+      # and are admitted by {.discover}.
       #
       # The `source.type` filter alone is NOT sufficient: gems that were extracted from Ruby's stdlib into
       # standalone default gems (e.g. `cgi`, `logger`, `base64`, `csv`, `bigdecimal`) are published in
@@ -77,6 +81,110 @@ module Rigor
         Rigor::ConfigPath.absolute(lockfile_path.to_s, project_root)
       end
 
+      # Issue #2946 — the `name` of every `source: { type: stdlib }` entry in the lockfile, in lockfile order and
+      # de-duplicated, whether or not rbs ships that library: the caller loads them as RBS libraries, and the
+      # loader's `has_library?` filter drops an unknown one. Unlike {.discover}, the collection directory need not
+      # exist, since a stdlib entry installs nothing there. Returns `[]` when no lockfile resolves or its YAML is
+      # unreadable. A pure YAML read, so the ADR-87 boot-slimming probe can rebuild the library list from it.
+      def self.stdlib_library_names(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        resolved = resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                         auto_detect: auto_detect)
+        return [] if resolved.nil?
+
+        data = read_lockfile_yaml(resolved)
+        return [] if data.nil?
+
+        Array(data["gems"]).filter_map do |entry|
+          next unless entry.is_a?(Hash) && SKIPPED_SOURCE_TYPES.include?(source_type(entry))
+
+          name = entry["name"]
+          name.to_s if name.is_a?(String) && !name.empty?
+        end.uniq
+      end
+
+      # Issue #2971 — the `name` of every lockfile entry that is NOT a `stdlib` source and whose
+      # `<root>/<name>/<version>/` directory exists: the gems whose signatures come from the collection ({.discover}).
+      # The `libraries:` audit uses it so a name the collection provides is not reported as an unknown RBS library.
+      # A pure file read, like {.stdlib_library_names}.
+      def self.collection_gem_names(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        resolved = resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                         auto_detect: auto_detect)
+        return [] if resolved.nil?
+
+        data = read_lockfile_yaml(resolved)
+        return [] if data.nil?
+
+        collection_root = resolve_collection_root(resolved, data)
+        gem_paths_from(collection_root, data, Set.new).map { |dir| dir.parent.basename.to_s }.uniq
+      end
+
+      # Issue #3030 — whether `file`, found under the collection gem directory `root`, sits below a `_`-prefixed
+      # directory (`_test/`, `_scripts/`). Such a file is not part of the gem's signatures: rbs's
+      # `EnvironmentLoader` loads a collection gem as a library, and `RBS::FileFinder.each_file(skip_hidden: true)`
+      # drops every file with a `_`-prefixed directory between it and the library root. A `git` source never
+      # copies them into the collection (`Sources::Git#cp_r` prunes them), but a `local` source symlinks the whole
+      # `<name>/<version>/` directory, so gem_rbs_collection's own `bin/test` setup brings each gem's `_test/`
+      # fixtures along. Only the directories count, as in rbs: a `_`-prefixed file name is loaded.
+      def self.hidden_file?(root, file)
+        relative = Pathname(file.to_s).relative_path_from(Pathname(root.to_s))
+        relative.ascend.drop(1).any? { |part| part.basename.to_s.start_with?("_") }
+      end
+
+      # Issue #3030 — `collection_paths` ({.discover}) without each gem directory a `signature_paths:` root already
+      # loads a copy of. A root is a copy of the entry `<collection>/<name>/<version>` when its real path is the
+      # entry's real path (a `local` source symlinks the working tree in), or when it is a gem_rbs_collection working
+      # tree for the same gem and version, `.../gems/<name>/<version>` (a `git` source installs a copy of it). That is
+      # what an author editing the tree points `signature_paths:` at from its `_test/` directory while the lockfile
+      # installs the same gem, and loading both declares every member twice. The `signature_paths:` copy is kept, as
+      # it is the one being edited. Any other root, such as a partial override `sig/overrides/foo/1.0`, leaves the
+      # collection copy loaded. Real paths are read so `..` and a symlinked spelling answer the same; a root that
+      # does not exist matches nothing.
+      def self.without_signature_path_copies(collection_paths, signature_roots)
+        reals = signature_roots.filter_map { |root| real_path(root) }
+        return collection_paths if reals.empty?
+
+        trees = reals.filter_map do |real|
+          real = Pathname(real)
+          [real.parent.basename.to_s, real.basename.to_s] if real.parent.parent.basename.to_s == "gems"
+        end.to_set
+        reals = reals.to_set
+        collection_paths.reject do |path|
+          path = Pathname(path.to_s)
+          trees.include?([path.parent.basename.to_s, path.basename.to_s]) || reals.include?(real_path(path))
+        end
+      end
+
+      def self.real_path(path)
+        File.realpath(path.to_s)
+      rescue SystemCallError
+        nil
+      end
+      private_class_method :real_path
+
+      # Issue #3030 — why a run with no collection lockfile looks like it was meant to have one: `:collection_test_dir`
+      # when `project_root` is a gem_rbs_collection test directory (`gems/<name>/<version>/_test/`, whose lockfile
+      # gem_rbs_collection's `bin/test` setup writes), `:collection_config` when it holds an `rbs_collection.yaml`
+      # (`rbs collection install` has not run), and nil otherwise, or when a lockfile resolves or the lookup is off.
+      # Rigor resolves no `manifest.yaml` or gemspec dependency itself, so without the lockfile the dependency RBS
+      # is absent. Two `stat`s and no read.
+      def self.missing_lockfile_hint(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
+        return nil if lockfile_path.nil? && !auto_detect
+        return nil if resolve_lockfile_path(lockfile_path: lockfile_path, project_root: project_root,
+                                            auto_detect: auto_detect)
+
+        root = Pathname(File.expand_path(project_root.to_s))
+        return :collection_test_dir if collection_test_dir?(root)
+        return :collection_config if root.join("rbs_collection.yaml").file?
+
+        nil
+      end
+
+      # `gems/<name>/<version>/_test/`, the layout of a gem_rbs_collection working tree.
+      def self.collection_test_dir?(root)
+        root.basename.to_s == "_test" && root.parent.parent.parent.basename.to_s == "gems"
+      end
+      private_class_method :collection_test_dir?
+
       # Returns the resolved lockfile path (`Pathname`) or `nil` when neither explicit nor auto-detect
       # produces one. Public so the stats banner can surface what rigor found.
       def self.resolve_lockfile_path(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
@@ -110,12 +218,19 @@ module Rigor
       end
       private_class_method :resolve_collection_root
 
+      # An entry's `source.type`, or "" when `source:` is absent or not a mapping (`source: stdlib`): a malformed
+      # entry fails soft (ADR-5) instead of raising out of the run.
+      def self.source_type(entry)
+        source = entry["source"]
+        source.is_a?(Hash) ? source["type"].to_s : ""
+      end
+      private_class_method :source_type
+
       def self.gem_paths_from(collection_root, data, skip_gem_names)
         Array(data["gems"]).filter_map do |entry|
           next unless entry.is_a?(Hash)
 
-          source_type = entry.dig("source", "type").to_s
-          next if SKIPPED_SOURCE_TYPES.include?(source_type)
+          next if SKIPPED_SOURCE_TYPES.include?(source_type(entry))
 
           name = entry["name"]
           version = entry["version"]

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -5,8 +5,9 @@ module Rigor
     # Open item O4 Layer 3 slice 3 — graceful-degradation coverage report.
     #
     # When the user has a `Gemfile.lock` (via slice 1) and rigor has resolved its target-project RBS sources
-    # (DEFAULT_LIBRARIES, `data/vendored_gem_sigs/`, slice-1 bundle-shipped `sig/`, slice-2
-    # `rbs_collection.lock.yaml` paths), this module classifies each locked gem by RBS provenance and
+    # (the resolved library list — `Environment::BaseLibraries.resolve`, `data/vendored_gem_sigs/`,
+    # slice-1 bundle-shipped `sig/`, slice-2 `rbs_collection.lock.yaml` paths), this module classifies each
+    # locked gem by RBS provenance and
     # surfaces the "no RBS available" set so the run-start diagnostic in {Rigor::Analysis::Runner} can
     # suggest `rbs collection install` or `dependencies.source_inference:` for the uncovered gems.
     #
@@ -37,9 +38,9 @@ module Rigor
 
       # @param locked_gems — The lockfile-resolved gem set. Empty
       #   hash → no coverage analysis to do.
-      # @param default_libraries — gem names rigor auto-loads through
-      #   `RBS::EnvironmentLoader#add(library:)`. Pass `Rigor::Environment::DEFAULT_LIBRARIES` from callers
-      #   running in a project context.
+      # @param default_libraries — the resolved list of names rigor loads as RBS libraries
+      #   (`Environment::BaseLibraries.resolve`: `DEFAULT_LIBRARIES` + `libraries:` + the collection
+      #   lockfile's stdlib entries). Pass it from callers running in a project context.
       # @param bundle_sig_paths — the discovered `<bundle>/.../gems/<name>-<ver>/sig`
       #   paths from {BundleSigDiscovery.discover}.
       # @param rbs_collection_paths — the discovered `<collection>/<name>/<version>/`
@@ -48,7 +49,7 @@ module Rigor
       def self.classify(locked_gems:, default_libraries:,
                         bundle_sig_paths:, rbs_collection_paths:)
         default_set = default_libraries.to_set
-        bundle_names = extract_gem_names_from_bundle_paths(bundle_sig_paths)
+        bundle_names = extract_gem_names_from_bundle_paths(bundle_sig_paths, locked_gems)
         collection_names = extract_gem_names_from_collection_paths(rbs_collection_paths)
 
         locked_gems.each_value.map do |locked|
@@ -73,11 +74,11 @@ module Rigor
         coverage_rows.select { |row| row.source == :missing }
       end
 
-      def self.extract_gem_names_from_bundle_paths(paths)
-        paths.each_with_object(Set.new) do |path, set|
-          pathname = path.is_a?(Pathname) ? path : Pathname.new(path)
-          set << BundleSigDiscovery.gem_name_from_sig_path(pathname)
-        end
+      # Issue #2978 — each path's gem name as the locked entry it matches ({BundleSigDiscovery.locked_names_of}), not
+      # a parse of its directory name, which reads `foo-2fa-1.0` as `foo` and reported `foo-2fa` as missing RBS.
+      def self.extract_gem_names_from_bundle_paths(paths, locked_gems)
+        pathnames = paths.map { |path| path.is_a?(Pathname) ? path : Pathname.new(path) }
+        BundleSigDiscovery.locked_names_of(pathnames, locked_gems).to_set
       end
       private_class_method :extract_gem_names_from_bundle_paths
 

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require_relative "../typing_state"
+
 module Rigor
   class Environment
     # Small hierarchy oracle backed by RBS instance definitions.
     class RbsHierarchy
+      TypingState.memo_field(self, :@ancestor_names_cache, :@class_ordering_cache,
+                             reason: "keyed on the class names; answered from the loader's RBS environment, fixed " \
+                                     "for the loader's lifetime")
+
       def initialize(loader)
         @loader = loader
         @ancestor_names_cache = {}
@@ -41,21 +47,12 @@ module Rigor
         end
       end
 
-      # Issue #696 review, second pass — the ancestry lookup moved to {RbsLoader#ancestor_names_for}, and
-      # what moved with it is the reason.
-      #
-      # This method used to fetch `Cache::RbsClassAncestorTable` DIRECTLY, bypassing the loader's own
-      # accessor, and branch on `loader.cache_store`: a whole-universe table build with a store, a
-      # single-class demand without one. Same project, same question, three different answers to "which
-      # classes failed to build" — 504 on a cold store, 0 on a warm one, 2 with no store. On the DEFAULT
-      # `--workers=0` path nothing pre-warms the store, so the cold answer was the one written into the
-      # run-result cache and replayed until a file changed.
-      #
-      # The cache-state branch still exists — it is worth 50x on the warm path — but it lives behind the
-      # loader now, where both of its sides are marked as RIGOR'S OWN demand. Ordering two classes is not
-      # the analysis asking whether either one's methods resolve, so neither side reaches the diagnostic,
-      # and the answer is identical on both (the table's producer computes exactly this, keyed the same
-      # way). What this method keeps is its own per-name memo, which is about repeated comparisons.
+      # Issue #696 review, second pass — the ancestry lookup lives in {RbsLoader#ancestor_names_for}.
+      # Read directly from `Cache::RbsClassAncestorTable`, the same question gave 504 failed classes on a
+      # cold store, 0 on a warm one and 2 with no store, and the cold answer was cached into the run result.
+      # Through the loader, both cache states are marked as Rigor's own demand, so ordering two classes
+      # never reaches the "which classes failed to build" diagnostic. The cache-state branch stays behind
+      # the loader (it is worth 50x on the warm path); this method keeps only its per-name memo.
       def ancestor_names(class_name)
         key = normalize_name(class_name)
         return @ancestor_names_cache[key] if @ancestor_names_cache.key?(key)