require-hooks 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 046c644cbb446d1abd3263c3c1ee0c578cddac17693d102172e123f1a880966a
-  data.tar.gz: a102736a0665a9de69c9aba242033a479af9b090bf135fa729e74b9bd8f6e006
+  metadata.gz: 9357c7e14301ad7ab541c2e2fabbda1f03df56e748aee55245dfc44ef98519f4
+  data.tar.gz: 87b05cf3ec16a3c9c4e9c1a46a3ec267ca03717923fe8abdccd4e46deb212791
 SHA512:
-  metadata.gz: 35e088739e021cc4e83827122ce2daa63934439f6e4d0c9597ccafdaf6f6a08b50eba9302cfed1ced10538a62b317406ded4da1882b06f4d04b527a5e4902b47
-  data.tar.gz: 801d491df8a08926067f47b44ee2372d73a53fada8cdfe36b62c0d66191f52f6900499121fc87a326125f00e443848734e5f7756df541d7e92f688ae293e5026
+  metadata.gz: a9e828449e13517a11c03d9521c4170507f08862e6a4e75fa01360a2c17191dbecfa3a745a1433bd7546f190c1599f17be7a4dc76869bbd798fd1e47e859a130
+  data.tar.gz: e1e80635ac8c7ceb90c1580797145c3c15636d463635f3ccf57578024619af150f4dbe94eb279aff7dc62c231ed1de3733b5db3e7a1b38a21002e8ef0ca8a063

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## 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.
+
 ## 0.4.0 (2026-04-29)
 
 - Improved Bootsnap cache invalidation logic on hooks configuration changes.

data/README.md

@@ -124,11 +124,11 @@ 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
 
-- Coverage tracking is only supported if `eval` coverage tracking is enabled (`Coverage.start(eval: true, ...)` or `Simplecov.start { enable_coverage_for_eval; ... }`). Currently requires **Ruby 3.4+**.
+- Coverage tracking is only supported in Ruby 4.0.4+ (or 3.4.10+ for 3.4.x series); for older versions in 3.4 and 4.0 series, you can enable `eval` coverage tracking to make it work with Require Hooks (`Coverage.start(eval: true, ...)` or `SimpleCov.enable_coverage :eval`). For Ruby 3.2.x and 3.3.x, only around hooks are supported.
 - `Kernel#load` with a wrap argument (e.g., `load "some_path", true` or `load "some_path", MyModule)`) is not supported (fallbacked to the original implementation). The biggest challenge here is to support constants nesting.
 - Some very edgy symlinking scenarios are not supported (unlikely to affect real-world projects).
 

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

@@ -28,51 +28,71 @@ 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
           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
@@ -83,18 +103,34 @@ module RequireHooks
 
           iseq.eval
           EMPTY_ISEQ
-        ensure
-          ::Bootsnap::CompileCache::ISeq.cache_dir = LoadIseqExt.orig_cache_dir
         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
 
@@ -109,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.0"
+  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.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Vladimir Dementyev