rigortype 0.1.4 → 0.1.6

data/lib/rigor/environment/hkt_registry_holder.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # ADR-20 slice 2e — mutable single-slot memoization
+    # container for the per-Environment HKT registry. Held by
+    # {Environment} so the otherwise-frozen instance can
+    # still cache a computed value on first access.
+    #
+    # Concurrent {#fetch} calls from multiple threads against
+    # one Environment are NOT serialised here — the LSP
+    # single-publish-at-a-time discipline and the Ractor
+    # pool's per-worker Environment shape already prevent
+    # cross-thread races. If a future caller introduces a
+    # multi-threaded reader path against a shared
+    # Environment, the synchronisation belongs at that
+    # caller's seam, not here.
+    class HktRegistryHolder
+      def initialize
+        @loaded = false
+        @value = nil
+      end
+
+      def fetch
+        return @value if @loaded
+
+        @value = yield
+        @loaded = true
+        @value
+      end
+    end
+  end
+end

data/lib/rigor/environment/lockfile_resolver.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # Open item O4 Layer 3 — Gemfile.lock parse.
+    #
+    # Parses a target project's `Gemfile.lock` via Bundler's
+    # `LockfileParser` and exposes the locked gem set as a frozen
+    # `Hash[String, LockfileResolver::LockedGem]` keyed by gem
+    # name. Used by {Rigor::Environment::BundleSigDiscovery} as a
+    # filter so the discovered `sig/` directories under the
+    # bundler install root are limited to gems the project
+    # actually declares (and at the version it declared them).
+    #
+    # The resolver is intentionally read-only. It does NOT load
+    # the project's `Gemfile`, does NOT resolve dependencies,
+    # does NOT touch the network, and does NOT require the
+    # target project's Bundler context. It only reads bytes from
+    # the lockfile.
+    #
+    # Failure modes are deliberately quiet: a missing or
+    # malformed lockfile returns an empty map. The auto-detect
+    # path is the configuration default; users who want hard
+    # failures should pass an explicit `bundler.lockfile:` and
+    # check the result via the stats banner.
+    module LockfileResolver
+      # Frozen value object for one locked gem entry.
+      #
+      # `version` is the resolved version string (e.g. "8.0.1");
+      # `platform` is the lockfile's platform tag, normalised to
+      # `"ruby"` when the lockfile records `ruby` and to the
+      # raw String otherwise (e.g. "aarch64-linux-gnu").
+      LockedGem = Data.define(:name, :version, :platform) do
+        def initialize(name:, version:, platform:)
+          super(
+            name: -name.to_s,
+            version: -version.to_s,
+            platform: -platform.to_s
+          )
+        end
+      end
+
+      # @param lockfile_path [String, Pathname, nil] 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 search.
+      # @param auto_detect [Boolean] 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 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)
+        resolved = resolve_lockfile_path(
+          lockfile_path: lockfile_path,
+          project_root: project_root,
+          auto_detect: auto_detect
+        )
+        return EMPTY unless resolved
+
+        parse(resolved)
+      end
+
+      # 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)
+        if lockfile_path
+          path = Pathname.new(File.expand_path(lockfile_path.to_s, project_root))
+          return path if path.file?
+
+          return nil
+        end
+
+        return nil unless auto_detect
+
+        candidate = Pathname.new(File.join(project_root, "Gemfile.lock"))
+        candidate.file? ? candidate : nil
+      end
+
+      EMPTY = {}.freeze
+      private_constant :EMPTY
+
+      # Parses a Gemfile.lock at the given path. Bundler load
+      # errors and malformed lockfile bytes both surface as the
+      # empty frozen hash; analysis must not crash because a
+      # lockfile is malformed. A single warning is emitted to
+      # `$stderr` so the user can see why their lockfile was
+      # ignored.
+      def self.parse(path)
+        require "bundler"
+      rescue LoadError => e
+        warn "rigor: cannot read #{path}: bundler is not available (#{e.message})"
+        EMPTY
+      else
+        do_parse(path)
+      end
+      private_class_method :parse
+
+      def self.do_parse(path)
+        body = File.read(path.to_s)
+        parser = Bundler::LockfileParser.new(body)
+        locked = parser.specs.each_with_object({}) do |spec, h|
+          # `Bundler::LazySpecification` carries name, version,
+          # platform. Platform is `Gem::Platform` or the symbol
+          # `:ruby`; both stringify cleanly. The upstream
+          # bundler RBS shim (references/rbs/sig/shims/bundler.rbs)
+          # does NOT declare `LazySpecification#platform` so the
+          # call site needs a suppression marker.
+          platform = spec.platform.to_s # rigor:disable undefined-method
+          h[spec.name.to_s] = LockedGem.new(
+            name: spec.name, version: spec.version.to_s, platform: platform
+          )
+        end
+        locked.freeze
+      rescue StandardError => e
+        warn "rigor: ignoring malformed #{path} (#{e.class}: #{e.message})"
+        EMPTY
+      end
+      private_class_method :do_parse
+    end
+  end
+end

data/lib/rigor/environment/rbs_collection_discovery.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Rigor
+  class Environment
+    # Open item O4 Layer 3 slice 2 — `rbs collection install`
+    # awareness.
+    #
+    # When the target project has been set up with `rbs
+    # collection install` (the standard RBS-ecosystem flow for
+    # pulling community RBS from
+    # https://github.com/ruby/gem_rbs_collection), a
+    # `rbs_collection.lock.yaml` records the resolved (gem,
+    # version, source) triples and `.gem_rbs_collection/<name>/
+    # <version>/` carries the actual `.rbs` files. This module
+    # parses the lockfile and returns the per-gem RBS directory
+    # paths so they can be appended to `RbsLoader`'s
+    # `signature_paths:`.
+    #
+    # The discovery is intentionally a pure file-system + YAML
+    # walk — no Bundler API call, no network 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.
+      SKIPPED_SOURCE_TYPES = Set["stdlib"].freeze
+
+      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`, falls
+      #   back to `auto_detect` if `auto_detect:` is true.
+      # @param project_root [String] resolution base for
+      #   relative `lockfile_path:` and the auto-detect search.
+      # @param auto_detect [Boolean] when true and
+      #   `lockfile_path:` is nil, look for
+      #   `<project_root>/rbs_collection.lock.yaml`.
+      # @return [Array<Pathname>] every
+      #   `<collection_path>/<gem-name>/<gem-version>/`
+      #   directory listed in the lockfile whose entry has a
+      #   non-skipped source type 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.
+      def self.discover(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)
+        return [] unless collection_root.directory?
+
+        gem_paths_from(collection_root, data)
+      end
+
+      # 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)
+        if lockfile_path
+          path = Pathname.new(File.expand_path(lockfile_path.to_s, project_root))
+          return path if path.file?
+
+          return nil
+        end
+
+        return nil unless auto_detect
+
+        candidate = Pathname.new(File.join(project_root, "rbs_collection.lock.yaml"))
+        candidate.file? ? candidate : nil
+      end
+
+      def self.read_lockfile_yaml(path)
+        data = YAML.safe_load_file(path.to_s, aliases: false)
+        data.is_a?(Hash) ? data : nil
+      rescue StandardError
+        nil
+      end
+      private_class_method :read_lockfile_yaml
+
+      def self.resolve_collection_root(lockfile_pathname, data)
+        rel = data["path"]
+        rel = DEFAULT_COLLECTION_PATH if rel.nil? || rel.to_s.empty?
+        # `path:` is documented as relative to the directory
+        # holding the lockfile (RBS::Collection::Config::Lockfile#fullpath).
+        lockfile_pathname.parent + Pathname.new(rel.to_s)
+      end
+      private_class_method :resolve_collection_root
+
+      def self.gem_paths_from(collection_root, data)
+        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)
+
+          name = entry["name"]
+          version = entry["version"]
+          next if name.nil? || version.nil?
+
+          gem_root = collection_root + name.to_s + version.to_s
+          gem_root if gem_root.directory?
+        end
+      end
+      private_class_method :gem_paths_from
+    end
+  end
+end

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Environment
+    # 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 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.
+    #
+    # The classification is a pure function over the inputs
+    # (`locked_gems`, two arrays of resolved sig paths). It does
+    # NOT touch the filesystem on its own — the caller passes in
+    # what discovery returned.
+    module RbsCoverageReport
+      # Frozen result row.
+      #
+      # `source` is a Symbol naming where RBS for this gem
+      # resolves; `:missing` means none of the four resolution
+      # paths covered it.
+      Coverage = Data.define(:gem_name, :version, :source) do
+        def initialize(gem_name:, version:, source:)
+          super(
+            gem_name: -gem_name.to_s,
+            version: -version.to_s,
+            source: source
+          )
+        end
+      end
+
+      # Names of gems whose RBS ships under
+      # `data/vendored_gem_sigs/`. Kept in sync with the
+      # vendored-stubs directory listing; when a new gem is
+      # vendored, add its name here too. (The set is small
+      # enough that hard-coding is acceptable; a directory walk
+      # at every call would add stat-cost to no benefit.)
+      VENDORED_GEM_NAMES = Set[
+        "bcrypt", "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "redis"
+      ].freeze
+
+      # @param locked_gems [Hash{String => LockfileResolver::LockedGem}]
+      #   The lockfile-resolved gem set. Empty hash → no
+      #   coverage analysis to do.
+      # @param default_libraries [Array<String>] 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` paths
+      #   from {BundleSigDiscovery.discover}.
+      # @param rbs_collection_paths [Array<Pathname, String>] the
+      #   discovered `<collection>/<name>/<version>/` paths from
+      #   {RbsCollectionDiscovery.discover}.
+      # @return [Array<Coverage>] 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
+        bundle_names = extract_gem_names_from_bundle_paths(bundle_sig_paths)
+        collection_names = extract_gem_names_from_collection_paths(rbs_collection_paths)
+
+        locked_gems.each_value.map do |locked|
+          name = locked.name
+          source = if default_set.include?(name)
+                     :default_library
+                   elsif VENDORED_GEM_NAMES.include?(name)
+                     :vendored_gem_sig
+                   elsif bundle_names.include?(name)
+                     :bundle_sig
+                   elsif collection_names.include?(name)
+                     :rbs_collection
+                   else
+                     :missing
+                   end
+          Coverage.new(gem_name: name, version: locked.version, source: source)
+        end.sort_by(&:gem_name)
+      end
+
+      # Convenience accessor for the run-start diagnostic.
+      # Filters {classify} down to `:missing` rows.
+      def self.missing(coverage_rows)
+        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
+      end
+      private_class_method :extract_gem_names_from_bundle_paths
+
+      def self.extract_gem_names_from_collection_paths(paths)
+        # `RbsCollectionDiscovery.discover` returns
+        # `<collection_root>/<name>/<version>/` so the parent
+        # basename is the gem name.
+        paths.each_with_object(Set.new) do |path, set|
+          pathname = path.is_a?(Pathname) ? path : Pathname.new(path)
+          set << pathname.parent.basename.to_s
+        end
+      end
+      private_class_method :extract_gem_names_from_collection_paths
+    end
+  end
+end