rigortype 0.3.7 → 0.3.9

data/lib/rigor/effects/unknown_label_report.rb

@@ -17,10 +17,9 @@ module Rigor
     # {.for} answers `nil` unless {LabelIntent} says the spelling is evidently a label — the whole
     # point of the diagnostic is that it fires where intent is evident and nowhere else.
     class UnknownLabelReport < Data.define(:token, :suggestion, :retirement)
-      # @param token [String] the spelling as written.
-      # @param registry [Rigor::Effects::Registry, nil] the vocabulary after plugin load.
-      # @param siblings [Array<String>] the other tokens written alongside it.
-      # @return [UnknownLabelReport, nil]
+      # @param token — the spelling as written.
+      # @param registry — the vocabulary after plugin load.
+      # @param siblings — the other tokens written alongside it.
       def self.for(token:, registry:, siblings: [])
         return nil unless LabelIntent.evident?(token, registry, siblings: siblings)
 

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -46,14 +46,14 @@ module Rigor
         "bundler", "rubygems"
       ].freeze
 
-      # @param bundle_path [String, Pathname, nil] explicit path to the bundler install root. When `nil`,
+      # @param bundle_path — explicit path to the bundler install root. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for relative `bundle_path:` and the auto-detect search.
-      # @param auto_detect [Boolean] when true and `bundle_path:` is nil, try `.bundle/config`'s
+      # @param project_root — resolution base for relative `bundle_path:` and the auto-detect search.
+      # @param auto_detect — when true and `bundle_path:` is nil, try `.bundle/config`'s
       #   `BUNDLE_PATH:` and `vendor/bundle/` under `project_root`.
-      # @param skip_gems [Set<String>] gem names to exclude from discovery. Defaults to
+      # @param skip_gems — gem names to exclude from discovery. Defaults to
       #   {SKIPPED_GEMS_BY_DEFAULT}.
-      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}, nil] Optional O4-Layer-3 filter.
+      # @param locked_gems — Optional O4-Layer-3 filter.
       #   When non-nil and non-empty, only `sig/` directories whose gem `(name, version, platform)` tuple
       #   matches a lockfile entry are returned. Bundle entries absent from the lockfile (or at a drifted
       #   version) are silently dropped — the lockfile is treated as the source of truth for "what gems this
@@ -63,7 +63,7 @@ module Rigor
       #   source keeps its stale `bundler/gems/` directory under the SAME name until a `bundle clean`. Pass
       #   `nil` (the default) to keep the pre-Layer-3 behaviour of returning every non-skipped `sig/` under
       #   the bundle.
-      # @return [Array<Pathname>] every `<gem-dir>/sig` directory under the resolved bundle path, minus any
+      # @return every `<gem-dir>/sig` directory under the resolved bundle path, minus any
       #   whose gem name is in `skip_gems` and (when `locked_gems` is supplied) minus any whose `(name,
       #   version, platform)` does not match a lockfile entry.
       def self.discover(bundle_path:, project_root: Dir.pwd, auto_detect: true,

data/lib/rigor/environment/class_registry.rb

@@ -136,8 +136,10 @@ module Rigor
 
       private
 
+      # Allocates only when there is a prefix to strip (see `Environment#normalize_class_name`).
       def normalize_name(name)
-        name.to_s.delete_prefix("::")
+        name = name.to_s
+        name.start_with?("::") ? name.delete_prefix("::") : name
       end
     end
   end

data/lib/rigor/environment/failure_slot.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # Issue #784 — a mutable, first-write-wins record of one shared-build failure, held by the otherwise
+    # frozen {Environment} the way {HktRegistryHolder} holds a memoised value. A lazy build that raises
+    # during per-file analysis records here at its seam instead of raising into every file's
+    # `analyze_body` rescue; the coordinator snapshots the slot after the file loop (the build is lazy, so
+    # a snapshot taken before the loop reads nothing) and the aggregator surfaces it once for the run.
+    #
+    # First-write-wins: the build is memoised, so a second failure can only be the same one re-observed.
+    #
+    # Concurrency: single-threaded use only, the same discipline as {HktRegistryHolder}.
+    class FailureSlot
+      def initialize
+        @value = nil
+      end
+
+      # @param value — a Marshal-clean tuple — the fork pool ships it back from the worker.
+      def record(value)
+        @value = value.freeze if @value.nil?
+      end
+
+      # @return the recorded tuple, or nil when the build never failed.
+      attr_reader :value
+    end
+  end
+end

data/lib/rigor/environment/installed_gem_set.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "lockfile_resolver"
+
+module Rigor
+  class Environment
+    # Issue #530 — the gem set for a project that has NO `Gemfile.lock`.
+    #
+    # ADR-82 WD9's constant-ownership index is driven by the LOCKED gem set, so a project without a
+    # lockfile (a plain library, a `gemspec`-only gem, an app vendored outside Bundler) handed the index
+    # nothing at all: every constant reaching into a real, installed, RBS-less gem recorded the generic
+    # cause, and the entire gem boundary reported as `engine_gap` — "report this to Rigor" — where the
+    # honest story is `add_rbs`. Measured on slim, whose whole Temple boundary lands that way while haml,
+    # which has a lockfile, attributes the same gem correctly.
+    #
+    # Degrading to the gems that are actually INSTALLED keeps ADR-82's honesty criterion intact. A name
+    # here is a gem that exists on disk; the index still has to READ its entry file before claiming any
+    # constant, and its lack of RBS is established by the same {RbsCoverageReport.classify} pass the
+    # lock-driven path uses. The version is the one on disk rather than a declared one — which is the
+    # version a lockfile-less project would load anyway.
+    #
+    # Only the missing-gem provenance index consumes this. The ADR-72 gem overlays stay Gemfile.lock-gated:
+    # an overlay changes what type-checks, so it needs the project's own declaration, while this
+    # side-channel only changes a label.
+    module InstalledGemSet
+      module_function
+
+      # @param bundle_path — the target's resolved bundler install root, or nil.
+      # @return frozen `gem name => LockfileResolver::LockedGem`, the shape
+      #   {RbsCoverageReport.classify} consumes. Empty when neither resolver sees anything, which leaves
+      #   today's generic cause in place.
+      def gems(bundle_path: nil)
+        found = from_bundle_tree(bundle_path)
+        found = from_installed_specs if found.empty?
+        found.freeze
+      end
+
+      # `<bundle>/ruby/X.Y.Z/gems/<name>-<version>/` — the same pure-filesystem layout
+      # {MissingGemConstantIndex.bundle_gem_dirs} walks, preferred over the host's gems so a project that
+      # vendored its bundle without committing the lockfile is read from its own tree. A platform-tagged
+      # directory (`ffi-1.17.4-aarch64-linux-gnu`) does not split into a name/version pair and is skipped:
+      # those gems ship native code, not the pure-Ruby constants this feeds.
+      def from_bundle_tree(bundle_path)
+        return {} if bundle_path.nil?
+
+        base = Pathname.new(bundle_path)
+        return {} unless base.directory?
+
+        Dir.glob(base.join("ruby", "*", "gems", "*")).each_with_object({}) do |dir, acc|
+          name, version = split_name_version(File.basename(dir))
+          next unless name
+
+          acc[name] ||= locked_gem(name, version)
+        end
+      end
+
+      # The gems the RUNNING Ruby can load. For the shipped `gem install rigortype` distribution that IS a
+      # lockfile-less project's gem environment — the same set its own `require` would reach. Under
+      # `bundle exec` it is the analyzer's own bundle instead (the `Gem.paths`-no-ops-under-Bundler
+      # mechanism ADR-90 documents), which yields fewer names, never wrong ones. Highest version per name,
+      # because `stubs` promises no ordering.
+      def from_installed_specs
+        Gem::Specification.stubs.each_with_object({}) do |stub, acc|
+          previous = acc[stub.name]
+          next if previous && Gem::Version.new(previous.version) >= stub.version
+
+          acc[stub.name] = locked_gem(stub.name, stub.version.to_s)
+        end
+      rescue StandardError
+        {}
+      end
+
+      def locked_gem(name, version)
+        LockfileResolver::LockedGem.new(name: name, version: version, platform: "ruby")
+      end
+
+      # Splits a gem install directory's basename. The version tail is anchored on a leading digit and must
+      # carry no further hyphen, which is what excludes the platform-tagged variants above.
+      def split_name_version(basename)
+        match = /\A(.+)-(\d[^-]*)\z/.match(basename)
+        match ? [match[1], match[2]] : nil
+      end
+    end
+  end
+end

data/lib/rigor/environment/lockfile_resolver.rb

@@ -39,13 +39,13 @@ module Rigor
         end
       end
 
-      # @param lockfile_path [String, Pathname, nil] explicit path to the Gemfile.lock. When `nil`, falls
+      # @param lockfile_path — explicit path to the Gemfile.lock. When `nil`, falls
       #   back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for a relative `lockfile_path:` and the auto-detect
+      # @param project_root — resolution base for a relative `lockfile_path:` and the auto-detect
       #   search.
-      # @param auto_detect [Boolean] when true and `lockfile_path:` is nil, look for
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for
       #   `<project_root>/Gemfile.lock`.
-      # @return [Hash{String => LockedGem}] frozen map of gem name → locked entry. Returns the empty frozen
+      # @return frozen map of gem name → locked entry. Returns the empty frozen
       #   hash when no lockfile is resolvable, when the file is unreadable, or when Bundler refuses to parse
       #   it.
       def self.locked_gems(lockfile_path:, project_root: Dir.pwd, auto_detect: true)
@@ -59,6 +59,53 @@ module Rigor
         parse(resolved)
       end
 
+      # The gems the project declares for itself — the lockfile's `DEPENDENCIES` section, which is what a
+      # `Gemfile` actually asked for, as opposed to {locked_gems}'s full resolved graph. A consumer that
+      # advises the user about their own stack has to read this one: `minitest`, `i18n`, `activesupport` and
+      # `ffi` sit in nearly every Rails lock as somebody else's dependency, so matching against the resolved
+      # graph advises about gems the project never chose.
+      #
+      # @param lockfile_path — explicit path to the Gemfile.lock; `nil` falls back to `auto_detect`.
+      # @param project_root — resolution base for a relative `lockfile_path:` and the auto-detect search.
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for `<project_root>/Gemfile.lock`.
+      # @return frozen set of gem names. Empty when no lockfile is resolvable, when it is unreadable, when
+      #   Bundler refuses to parse it, or when the lockfile has no `DEPENDENCIES` section at all.
+      def self.direct_dependency_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 EMPTY_NAMES unless resolved
+
+        parse_dependency_names(resolved)
+      end
+
+      EMPTY_NAMES = Set.new.freeze
+      private_constant :EMPTY_NAMES
+
+      def self.parse_dependency_names(path)
+        require "bundler"
+      rescue LoadError => e
+        warn "rigor: cannot read #{path}: bundler is not available (#{e.message})"
+        EMPTY_NAMES
+      else
+        do_parse_dependency_names(path)
+      end
+      private_class_method :parse_dependency_names
+
+      def self.do_parse_dependency_names(path)
+        parser = Bundler::LockfileParser.new(File.read(path.to_s))
+        # `#dependencies` is the parsed `DEPENDENCIES` section keyed by gem name, so the version constraint
+        # and the pinned-source `!` suffix are already stripped for us. The upstream bundler RBS shim does
+        # not declare it.
+        parser.dependencies.keys.to_set { |name| -name.to_s }.freeze # rigor:disable undefined-method
+      rescue StandardError => e
+        warn "rigor: ignoring malformed #{path} (#{e.class}: #{e.message})"
+        EMPTY_NAMES
+      end
+      private_class_method :do_parse_dependency_names
+
       # Returns the resolved lockfile path (`Pathname`) or `nil` when neither explicit nor auto-detect
       # produces one. Public so the stats banner can show what rigor picked up.
       def self.resolve_lockfile_path(lockfile_path:, project_root: Dir.pwd, auto_detect: true)

data/lib/rigor/environment/missing_gem_constant_index.rb

@@ -37,12 +37,12 @@ module Rigor
     module MissingGemConstantIndex
       module_function
 
-      # @param gems [Enumerable<Array(String, String)>] `[gem_name, version]` pairs (the `:missing` rows of
+      # @param gems — `[gem_name, version]` pairs (the `:missing` rows of
       #   {RbsCoverageReport}).
-      # @param bundle_path [String, Pathname, nil] the target's resolved bundler install root, or nil.
-      # @param spec_resolver [#call] `(name, version) -> String?` fallback dir resolver. Injectable for
+      # @param bundle_path — the target's resolved bundler install root, or nil.
+      # @param spec_resolver — `(name, version) -> String?` fallback dir resolver. Injectable for
       #   specs; the default is the RubyGems-metadata lookup (no code load).
-      # @return [Hash{String => String}] frozen `root constant name => gem name`. On a collision (two gems
+      # @return frozen `root constant name => gem name`. On a collision (two gems
       #   declaring the same top-level constant) the first gem wins — the CAUSE recorded downstream
       #   (external gem without RBS) is true under either owner.
       def build(gems, bundle_path: nil, spec_resolver: method(:installed_gem_dir))

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -37,17 +37,17 @@ module Rigor
       DEFAULT_COLLECTION_PATH = ".gem_rbs_collection"
       private_constant :DEFAULT_COLLECTION_PATH
 
-      # @param lockfile_path [String, Pathname, nil] explicit path to `rbs_collection.lock.yaml`. When `nil`,
+      # @param lockfile_path — explicit path to `rbs_collection.lock.yaml`. When `nil`,
       #   falls back to `auto_detect` if `auto_detect:` is true.
-      # @param project_root [String] resolution base for relative `lockfile_path:` and the auto-detect
+      # @param project_root — resolution base for relative `lockfile_path:` and the auto-detect
       #   search.
-      # @param auto_detect [Boolean] when true and `lockfile_path:` is nil, look for
+      # @param auto_detect — when true and `lockfile_path:` is nil, look for
       #   `<project_root>/rbs_collection.lock.yaml`.
-      # @param skip_gem_names [Array<String>, Set<String>] gem names rigor already loads from its bundled
+      # @param skip_gem_names — gem names rigor already loads from its bundled
       #   stdlib (the merged `DEFAULT_LIBRARIES + libraries:` set). Entries whose `name` is in this set are
       #   dropped regardless of `source.type` to avoid `RBS::DuplicatedDeclarationError` on
       #   stdlib-extracted default gems. Defaults to empty.
-      # @return [Array<Pathname>] every `<collection_path>/<gem-name>/<gem-version>/` directory listed in the
+      # @return every `<collection_path>/<gem-name>/<gem-version>/` directory listed in the
       #   lockfile whose entry has a non-skipped source type, whose `name` is not in `skip_gem_names:`, and
       #   whose directory exists on disk. Returns `[]` when no lockfile is resolvable, when the YAML is
       #   unreadable, or when the collection path doesn't exist.

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -35,16 +35,16 @@ module Rigor
         "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "racc", "redis", "rubygems"
       ].freeze
 
-      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}] The lockfile-resolved gem set. Empty
+      # @param locked_gems — The lockfile-resolved gem set. Empty
       #   hash → no coverage analysis to do.
-      # @param default_libraries [Array<String>] gem names rigor auto-loads through
+      # @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 bundle_sig_paths [Array<Pathname, String>] the discovered `<bundle>/.../gems/<name>-<ver>/sig`
+      # @param bundle_sig_paths — the discovered `<bundle>/.../gems/<name>-<ver>/sig`
       #   paths from {BundleSigDiscovery.discover}.
-      # @param rbs_collection_paths [Array<Pathname, String>] the discovered `<collection>/<name>/<version>/`
+      # @param rbs_collection_paths — the discovered `<collection>/<name>/<version>/`
       #   paths from {RbsCollectionDiscovery.discover}.
-      # @return [Array<Coverage>] one row per locked gem; sorted by gem name for deterministic output.
+      # @return one row per locked gem; sorted by gem name for deterministic output.
       def self.classify(locked_gems:, default_libraries:,
                         bundle_sig_paths:, rbs_collection_paths:)
         default_set = default_libraries.to_set

data/lib/rigor/environment/rbs_hierarchy.rb

@@ -63,8 +63,10 @@ module Rigor
         @ancestor_names_cache[key] = loader.ancestor_names_for(key)
       end
 
+      # Allocates only when there is a prefix to strip (see `Environment#normalize_class_name`).
       def normalize_name(name)
-        name.to_s.delete_prefix("::")
+        name = name.to_s
+        name.start_with?("::") ? name.delete_prefix("::") : name
       end
     end
   end