require-hooks 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5179f6010729ac30b40c0040f2d00956164c8f765d41e2d095eeefa9b96da842
-  data.tar.gz: f836cd71ec64084e4145ac572a555b7a32b7abdacd7d7d25965766bca2d264bc
+  metadata.gz: 9357c7e14301ad7ab541c2e2fabbda1f03df56e748aee55245dfc44ef98519f4
+  data.tar.gz: 87b05cf3ec16a3c9c4e9c1a46a3ec267ca03717923fe8abdccd4e46deb212791
 SHA512:
-  metadata.gz: 93559e1cc1b84d23e17b60abb8f92e47c67ea6f66f1dcbc4243b34f3d68345674c96da73aa890ba8c79e226209877a48aa4438343a51ba3ce736160403597abb
-  data.tar.gz: 4c36e011286728aee0f43a81411875c38fee956e34105c4dcba87bc4cf52aaee6a2d4e97d332bd2727551c85bc009ddba646b3a9764ca19c3521b7687bf43a1c
+  metadata.gz: a9e828449e13517a11c03d9521c4170507f08862e6a4e75fa01360a2c17191dbecfa3a745a1433bd7546f190c1599f17be7a4dc76869bbd798fd1e47e859a130
+  data.tar.gz: e1e80635ac8c7ceb90c1580797145c3c15636d463635f3ccf57578024619af150f4dbe94eb279aff7dc62c231ed1de3733b5db3e7a1b38a21002e8ef0ca8a063

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 0.5.0 (2026-08-26)
+
+- Use Bootsnap compiler namespaces for cache invalidation without changing Bootsnap's cache directory.
+
 ## 0.4.1 (2026-07-22)
 
 - Bring back Ruby 2.3 compatibility.

data/README.md

@@ -124,7 +124,7 @@ require "require-hooks/setup"
 
 The _around load_ hooks are executed for all files independently of whether they are cached or not. Source transformation and hijacking is only done for non-cached files.
 
-Thus, if you introduce new source transformers or hijackers, you must invalidate the cache. (We plan to implement automatic invalidation in future versions.)
+Require Hooks separates cached instructions by hook configuration. New source transformers and hijackers invalidate affected cache entries automatically.
 
 ## Limitations
 

data/lib/require-hooks/mode/bootsnap.rb

@@ -28,75 +28,109 @@ module RequireHooks
       end
     end
 
-    # For new Bootsnap
-    module CompilerExt
-      def input_to_storage(source, path, *)
+    # Bootsnap before 1.24 does not support compiler namespaces.
+    module LegacyCacheExt
+      def fetch(path, cache_dir: self.cache_dir)
         ctx = RequireHooks.context_for(path)
-        return super if ctx.empty?
+        cache_dir = File.join(cache_dir, RequireHooks::Bootsnap.version_hash) unless ctx.empty?
+
+        super
+      end
+    end
 
+    # Bootsnap 1.24+ compiler wrapper. Its namespace isolates transformed ISeqs
+    # without changing Bootsnap's process-wide cache directory.
+    class VersionedCompiler
+      attr_reader :namespace
+
+      def initialize(compiler)
+        @compiler = compiler
+        @namespace = "#{compiler.namespace}-require-hooks-#{RequireHooks::Bootsnap.version_hash}"
+      end
+
+      def input_to_storage(source, path, *args)
+        iseq = compile(RequireHooks.context_for(path), path, nil)
+        return @compiler.input_to_storage(source, path, *args) unless iseq
+
+        iseq.to_binary
+      rescue SyntaxError, TypeError
+        ::Bootsnap::CompileCache::UNCOMPILABLE
+      end
+
+      def storage_to_output(*args)
+        @compiler.storage_to_output(*args)
+      end
+
+      def input_to_output(source, path, args)
+        compile(RequireHooks.context_for(path), path, args) || @compiler.input_to_output(source, path, args)
+      end
+
+      private
+
+      def compile(ctx, path, args)
         new_contents = ctx.perform_source_transform(path)
         hijacked = ctx.try_hijack_load(path, new_contents)
 
         if hijacked
-          raise TypeError, "Unsupported bytecode format for #{path}: #{hijack.class}" unless hijacked.is_a?(::RubyVM::InstructionSequence)
-          return hijacked.to_binary
-        elsif new_contents
-          return RubyVM::InstructionSequence.compile(new_contents, path, path, 1, @compile_options).to_binary
+          raise TypeError, "Unsupported bytecode format for #{path}: #{hijacked.class}" unless hijacked.is_a?(::RubyVM::InstructionSequence)
+          return hijacked
         end
 
-        super
-      rescue SyntaxError, TypeError
-        ::Bootsnap::CompileCache::UNCOMPILABLE
+        return unless new_contents
+
+        @compiler.input_to_output(new_contents, path, args) ||
+          RubyVM::InstructionSequence.compile(new_contents, path, path, 1)
       end
     end
 
     module LoadIseqExt
-      class << self
-        attr_accessor :orig_cache_dir
-      end
-
       # Around hooks must be performed every time we trigger a file load, even if
       # the file is already cached.
       def load_iseq(path)
         ctx = RequireHooks.context_for(path)
-        # Early-return for non-trackable paths
-        if ctx.empty?
-          ::Bootsnap::CompileCache::ISeq.cache_dir = LoadIseqExt.orig_cache_dir if LoadIseqExt.orig_cache_dir
-          return super
-        end
-
-        LoadIseqExt.orig_cache_dir ||= ::Bootsnap::CompileCache::ISeq.cache_dir
-        ::Bootsnap::CompileCache::ISeq.cache_dir = File.join(LoadIseqExt.orig_cache_dir, RequireHooks::Bootsnap.version_hash)
+        return super if ctx.empty?
 
         ctx.run_around_load_callbacks(path) do
-          begin
-            iseq = super
+          iseq = super
 
-            ::Bootsnap::CompileCache::ISeq.cache_dir = LoadIseqExt.orig_cache_dir
+          # Bootsnap returns nil when the coverage is on,
+          # we fallback to our custom #compile_with_coverage
+          unless iseq
+            next unless defined?(Coverage) && Coverage.running?
 
-            # Bootsnap returns nil when the coverage is on,
-            # we fallback to our custom #compile_with_coverage
-            unless iseq
-              next unless defined?(Coverage) && Coverage.running?
-
-              iseq = RequireHooks::Iseq.compile_with_coverage(ctx, path)
-            end
-
-            iseq.eval
-            EMPTY_ISEQ
-          ensure
-            ::Bootsnap::CompileCache::ISeq.cache_dir = LoadIseqExt.orig_cache_dir
+            iseq = RequireHooks::Iseq.compile_with_coverage(ctx, path)
           end
+
+          iseq.eval
+          EMPTY_ISEQ
         end
       end
     end
 
     class << self
+      def install_compiler_selector
+        iseq = ::Bootsnap::CompileCache::ISeq
+        @original_compiler_selector = iseq.compiler_selector
+        @compilers = {}.compare_by_identity
+        iseq.compiler_selector = method(:compiler_for)
+      end
+
+      def compiler_for(path)
+        iseq = ::Bootsnap::CompileCache::ISeq
+        compiler = @original_compiler_selector&.call(path) || iseq.default_compiler
+        return compiler if RequireHooks.context_for(path).empty?
+
+        @compilers[compiler] ||= VersionedCompiler.new(compiler)
+      end
+
       def version_hash
-        @version_key ||= RequireHooks.contexts.values.map(&:to_cache_key).join("-")
+        @version_hash ||= RequireHooks.contexts.values.map(&:to_cache_key).join("-")
       end
 
-      attr_writer :version_hash
+      def version_hash=(version_hash)
+        @version_hash = version_hash
+        @compilers&.clear
+      end
     end
   end
 
@@ -111,6 +145,10 @@ module RequireHooks
   end
 end
 
-Bootsnap::CompileCache::ISeq.singleton_class.prepend(RequireHooks::Bootsnap::CompileCacheExt)
-Bootsnap::CompileCache::ISeq::Compiler.prepend(RequireHooks::Bootsnap::CompilerExt) if defined?(Bootsnap::CompileCache::ISeq::Compiler)
+if defined?(Bootsnap::CompileCache::ISeq::Compiler)
+  RequireHooks::Bootsnap.install_compiler_selector
+else
+  Bootsnap::CompileCache::ISeq.singleton_class.prepend(RequireHooks::Bootsnap::CompileCacheExt)
+  Bootsnap::CompileCache::ISeq.singleton_class.prepend(RequireHooks::Bootsnap::LegacyCacheExt)
+end
 RubyVM::InstructionSequence.singleton_class.prepend(RequireHooks::Bootsnap::LoadIseqExt)

data/lib/require-hooks/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RequireHooks
-  VERSION = "0.4.1"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: require-hooks
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Vladimir Dementyev