scint 0.6.0 → 0.7.1

data/lib/scint/cache/validity.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../platform"
+require_relative "../installer/extension_builder"
+
+module Scint
+  module Cache
+    class Telemetry
+      def initialize
+        @counts = Hash.new(0)
+        @mutex = Thread::Mutex.new
+      end
+
+      def increment(key, by = 1)
+        @mutex.synchronize do
+          @counts[key] += by
+        end
+      end
+
+      def counts
+        @mutex.synchronize { @counts.dup }
+      end
+
+      def warn_if_needed(cache_root:, io: $stderr)
+        snapshot = counts
+        return if snapshot.empty?
+
+        header = "Warning: legacy cache fallback used in #{cache_root}"
+        io.puts "#{YELLOW}#{header}#{RESET}"
+        snapshot.sort.each do |key, value|
+          io.puts "  #{key}=#{value}"
+        end
+      end
+    end
+
+    module Validity
+      module_function
+
+      SUPPORTED_MANIFEST_VERSION = 1
+
+      def cached_valid?(spec, layout, abi_key: Platform.abi_key, telemetry: nil)
+        cached_dir = layout.cached_path(spec, abi_key)
+        spec_path = layout.cached_spec_path(spec, abi_key)
+        manifest_path = layout.cached_manifest_path(spec, abi_key)
+
+        return false unless Dir.exist?(cached_dir)
+        return false unless File.exist?(spec_path)
+
+        manifest = read_manifest(manifest_path, telemetry: telemetry)
+        if manifest
+          return false unless manifest_matches?(manifest, spec, abi_key, layout)
+        else
+          return false unless legacy_spec_loadable?(spec_path)
+        end
+
+        true
+      end
+
+      def source_path_for(spec, layout, abi_key: Platform.abi_key, telemetry: nil, allow_legacy: false)
+        cached_dir = layout.cached_path(spec, abi_key)
+        return cached_dir if cached_valid?(spec, layout, abi_key: abi_key, telemetry: telemetry)
+
+        return nil unless allow_legacy
+
+        legacy = layout.extracted_path(spec)
+        return nil unless legacy_extracted_valid?(spec, legacy, layout)
+
+        telemetry&.increment("cache.legacy.extracted")
+        legacy
+      end
+
+      def legacy_extracted_valid?(spec, extracted_dir, layout)
+        return false unless Dir.exist?(extracted_dir)
+
+        legacy_spec_path = layout.spec_cache_path(spec)
+        return true if File.exist?(legacy_spec_path)
+
+        return true if Dir.glob(File.join(extracted_dir, "*.gemspec")).any?
+
+        true
+      rescue StandardError
+        false
+      end
+
+      def read_manifest(path, telemetry: nil)
+        unless File.exist?(path)
+          telemetry&.increment("cache.manifest.missing")
+          return nil
+        end
+
+        raw = File.read(path)
+        raw.force_encoding("UTF-8") unless raw.encoding == Encoding::UTF_8
+        data = JSON.parse(raw)
+        return nil unless data.is_a?(Hash)
+
+        version = data["version"]
+        return data if version == SUPPORTED_MANIFEST_VERSION
+
+        telemetry&.increment("cache.manifest.unsupported")
+        nil
+      rescue StandardError
+        telemetry&.increment("cache.manifest.unsupported")
+        nil
+      end
+
+      def manifest_matches?(manifest, spec, abi_key, layout)
+        manifest["full_name"] == layout.full_name(spec) && manifest["abi"] == abi_key
+      rescue StandardError
+        false
+      end
+
+      def legacy_spec_loadable?(path)
+        Marshal.load(File.binread(path))
+        true
+      rescue StandardError
+        false
+      end
+
+      def extensions_required?(spec, cached_dir)
+        Installer::ExtensionBuilder.needs_build?(spec, cached_dir)
+      rescue StandardError
+        false
+      end
+
+      def extension_build_complete?(spec, layout, abi_key)
+        marker = File.join(layout.cached_path(spec, abi_key), Installer::ExtensionBuilder::BUILD_MARKER)
+        File.exist?(marker)
+      rescue StandardError
+        false
+      end
+    end
+  end
+end

data/lib/scint/cli/cache.rb

@@ -9,6 +9,7 @@ require_relative "../gemfile/parser"
 require_relative "../lockfile/parser"
 require_relative "install"
 require_relative "../fs"
+require_relative "../spec_utils"
 
 module Scint
   module CLI
@@ -175,17 +176,45 @@ module Scint
 
       def clear_packages(packages)
         removed = 0
-        %w[inbound extracted ext].each do |subdir|
-          subdir_path = File.join(cache_root, subdir)
-          next unless Dir.exist?(subdir_path)
 
-          Dir.children(subdir_path).each do |entry|
-            if packages.any? { |pkg| entry.start_with?(pkg) }
-              FileUtils.rm_rf(File.join(subdir_path, entry))
+        packages.each do |pkg|
+          # inbound gems
+          Dir.glob(File.join(cache_root, "inbound", "gems", "#{pkg}-*.gem")).each do |path|
+            FileUtils.rm_rf(path)
+            removed += 1
+          end
+
+          # assembling + cached (per-ABI)
+          %w[assembling cached].each do |subdir|
+            Dir.glob(File.join(cache_root, subdir, "*", "#{pkg}-*")) do |path|
+              FileUtils.rm_rf(path)
+              removed += 1
+            end
+            Dir.glob(File.join(cache_root, subdir, "*", "#{pkg}-*.spec.marshal")) do |path|
+              FileUtils.rm_rf(path)
+              removed += 1
+            end
+            Dir.glob(File.join(cache_root, subdir, "*", "#{pkg}-*.manifest")) do |path|
+              FileUtils.rm_rf(path)
               removed += 1
             end
           end
+
+          # legacy directories (extracted/ext)
+          Dir.glob(File.join(cache_root, "extracted", "#{pkg}-*")) do |path|
+            FileUtils.rm_rf(path)
+            removed += 1
+          end
+          Dir.glob(File.join(cache_root, "extracted", "#{pkg}-*.spec.marshal")) do |path|
+            FileUtils.rm_rf(path)
+            removed += 1
+          end
+          Dir.glob(File.join(cache_root, "ext", "*", "#{pkg}-*")) do |path|
+            FileUtils.rm_rf(path)
+            removed += 1
+          end
         end
+
         removed
       end
 
@@ -306,7 +335,7 @@ module Scint
       def dedupe_specs(specs)
         seen = {}
         specs.each do |spec|
-          key = "#{spec.name}-#{spec.version}-#{spec.platform}"
+          key = SpecUtils.full_key(spec)
           seen[key] ||= spec
         end
         seen.values

data/lib/scint/cli/exec.rb

@@ -3,7 +3,9 @@
 require_relative "../runtime/exec"
 require_relative "../fs"
 require_relative "../platform"
+require_relative "../spec_utils"
 require_relative "../lockfile/parser"
+require "pathname"
 
 module Scint
   module CLI
@@ -68,19 +70,18 @@ module Scint
         data = {}
 
         lockfile.specs.each do |spec|
-          full = spec_full_name(spec)
+          full = SpecUtils.full_name(spec)
           gem_dir = File.join(ruby_dir, "gems", full)
           next unless Dir.exist?(gem_dir)
 
           spec_file = File.join(ruby_dir, "specifications", "#{full}.gemspec")
           require_paths = read_require_paths(spec_file)
           load_paths = require_paths
-            .map { |rp| File.join(gem_dir, rp) }
+            .map { |rp| expand_require_path(gem_dir, rp) }
             .select { |path| Dir.exist?(path) }
 
           lib_path = File.join(gem_dir, "lib")
           load_paths << lib_path if load_paths.empty? && Dir.exist?(lib_path)
-          load_paths.concat(detect_nested_lib_paths(gem_dir))
           load_paths.uniq!
 
           ext_path = File.join(ruby_dir, "extensions",
@@ -102,7 +103,7 @@ module Scint
       end
 
       def detect_ruby_dir(bundle_dir)
-        target = RUBY_VERSION.split(".")[0, 2].join(".") + ".0"
+        target = Platform.ruby_minor_version_dir
         preferred = File.join(bundle_dir, "ruby", target)
         return preferred if Dir.exist?(preferred)
 
@@ -111,39 +112,26 @@ module Scint
       end
 
       def spec_full_name(spec)
-        name = spec[:name]
-        version = spec[:version]
-        platform = spec[:platform]
-        base = "#{name}-#{version}"
-        return base if platform.nil? || platform.to_s == "ruby" || platform.to_s.empty?
-
-        "#{base}-#{platform}"
+        SpecUtils.full_name(spec)
       end
 
       def read_require_paths(spec_file)
         return ["lib"] unless File.exist?(spec_file)
 
-        gemspec = Gem::Specification.load(spec_file)
+        gemspec = SpecUtils.load_gemspec(spec_file)
         paths = Array(gemspec&.require_paths).reject(&:empty?)
         paths.empty? ? ["lib"] : paths
       rescue StandardError
         ["lib"]
       end
 
-      def detect_nested_lib_paths(gem_dir)
-        lib_dir = File.join(gem_dir, "lib")
-        return [] unless Dir.exist?(lib_dir)
-
-        children = Dir.children(lib_dir)
-        top_level_rb = children.any? do |entry|
-          path = File.join(lib_dir, entry)
-          File.file?(path) && entry.end_with?(".rb")
-        end
-        return [] if top_level_rb
+      def expand_require_path(gem_dir, require_path)
+        value = require_path.to_s
+        return value if Pathname.new(value).absolute?
 
-        children
-          .map { |entry| File.join(lib_dir, entry) }
-          .select { |path| File.directory?(path) }
+        File.join(gem_dir, value)
+      rescue StandardError
+        File.join(gem_dir, require_path.to_s)
       end
     end
   end