scint 0.7.0 → 0.8.0

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

@@ -176,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
 

data/lib/scint/cli/exec.rb

@@ -118,7 +118,7 @@ module Scint
       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