bootsnap 1.10.2 → 1.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22aca6043d2a55eb7747cb38aec8365879c37e3fbdbd0cdfdd040098dd945fdd
-  data.tar.gz: 69085ad28c61b3dbffeab8e50a49f0655d05c9639cae9e4ba0a9cc2f2b7c9051
+  metadata.gz: 1cc142349008790c310bcbc875a437996403242e579f85fb48f46eceecb383ad
+  data.tar.gz: fa1d21fafa8a4fa4d44ced76d597b773d3321e077dc815ccbcae3fe9dc4e661a
 SHA512:
-  metadata.gz: f63a81e86c721f737e5f29b9696abbcbc118e5bf703bf994dbf275d9939203d1eb6aebabc8ccad927f818b2bf9311d4174dde0338b7cd74f4e71e7e9727e6692
-  data.tar.gz: 3209a8fcdbb446c0f32738f2f580e7adc573d556da298560718c23d25963dc3f9dcf8fd5794a79864bac203089aef6be3da7743fde8bcc906f469b20461bb7aa
+  metadata.gz: 81445538692ae0dc34b7309c44195fce5c864e508afe6eed4124d3d87bc1bfa07fd2ddb2c602faa2409f1537f8da63b885fd692bdc74e961febdd2a39e6e1919
+  data.tar.gz: 6389ce3a667c528660976665ce8184fb61d638da6cd4040e7b2d55441679574bdf691e4991294396c19a6e79bbf185ba1cdca848d5ea499a5b8e197dca143a5f

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Unreleased
 
+# 1.11.1
+
+* Fix the `can't modify frozen Hash` error on load path cache mutation. See #411.
+
+# 1.11.0
+
+* Drop dependency on `fileutils`.
+
+* Better respect `Kernel#require` duck typing. While it almost never comes up in practice, `Kernel#require`
+  follow a fairly intricate duck-typing protocol on its argument implemented as `rb_get_path(VALUE)` in MRI.
+  So when applicable we bind `rb_get_path` and use it for improved compatibility. See #396 and #406.
+
+* Get rid of the `Kernel.require_relative` decorator by resolving `$LOAD_PATH` members to their real path.
+  This way we handle symlinks in `$LOAD_PATH` much more efficiently. See #402 for the detailed explanation.
+  
+* Drop support for Ruby 2.3 (to allow getting rid of the `Kernel.require_relative` decorator).
+
+# 1.10.3
+
+* Fix Regexp and Date type support in YAML compile cache. (#400)
+
+* Improve the YAML compile cache to support `UTF-8` symbols. (#398, #399)
+  [The default `MessagePack` symbol serializer assumes all symbols are ASCII](https://github.com/msgpack/msgpack-ruby/pull/211),
+  because of this, non-ASCII compatible symbol would be restored with `ASCII_8BIT` encoding (AKA `BINARY`).
+  Bootsnap now properly cache them in `UTF-8`.
+
+  Note that the above only apply for actual YAML symbols (e..g `--- :foo`).
+  The issue is still present for string keys parsed with `YAML.load_file(..., symbolize_names: true)`, that is a bug
+  in `msgpack` that will hopefully be solved soon, see: https://github.com/msgpack/msgpack-ruby/pull/246
+
+* Entirely disable the YAML compile cache if `Encoding.default_internal` is set to an encoding not supported by `msgpack`. (#398)
+  `Psych` coerce strings to `Encoding.default_internal`, but `MessagePack` doesn't. So in this scenario we can't provide
+  YAML caching at all without returning the strings in the wrong encoding.
+  This never came up in practice but might as well be safe.
+
 # 1.10.2
 
 * Reduce the `Kernel.require` extra stack frames some more. Now bootsnap should only add one extra frame per `require` call.
@@ -22,7 +57,7 @@
   Since `1.8.0`, `YAML.load_file` was no longer cached when Psych 4 was used. This is because `load_file` loads
   in safe mode by default, so the Bootsnap cache could defeat that safety.
   Now when precompiling YAML files, Bootsnap first try to parse them in safe mode, and if it can't fallback to unsafe mode,
-  and the cache contains a flag that records wether it was generated in safe mode or not.
+  and the cache contains a flag that records whether it was generated in safe mode or not.
   `YAML.unsafe_load_file` will use safe caches just fine, but `YAML.load_file` will fallback to uncached YAML parsing
   if the cache was generated using unsafe parsing.
 
@@ -63,7 +98,7 @@
 
 # 1.8.0
 
-* Improve support for Pysch 4. (#368)
+* Improve support for Psych 4. (#368)
 
 # 1.7.7
 
@@ -81,8 +116,8 @@
 
 # 1.7.4
 
-* Stop raising errors when encoutering various file system errors. The cache is now best effort,
-  if somehow it can't be saved, bootsnapp will gracefully fallback to the original operation (e.g. `Kernel.require`).
+* Stop raising errors when encountering various file system errors. The cache is now best effort,
+  if somehow it can't be saved, bootsnap will gracefully fallback to the original operation (e.g. `Kernel.require`).
   (#353, #177, #262)
 
 # 1.7.3

data/ext/bootsnap/bootsnap.c

@@ -135,6 +135,12 @@ bs_rb_coverage_running(VALUE self)
   return RTEST(cov) ? Qtrue : Qfalse;
 }
 
+static VALUE
+bs_rb_get_path(VALUE self, VALUE fname)
+{
+    return rb_get_path(fname);
+}
+
 /*
  * Ruby C extensions are initialized by calling Init_<extname>.
  *
@@ -146,6 +152,9 @@ void
 Init_bootsnap(void)
 {
   rb_mBootsnap = rb_define_module("Bootsnap");
+
+  rb_define_singleton_method(rb_mBootsnap, "rb_get_path", bs_rb_get_path, 1);
+
   rb_mBootsnap_CompileCache = rb_define_module_under(rb_mBootsnap, "CompileCache");
   rb_mBootsnap_CompileCache_Native = rb_define_module_under(rb_mBootsnap_CompileCache, "Native");
   rb_cBootsnap_CompileCache_UNCOMPILABLE = rb_const_get(rb_mBootsnap_CompileCache, rb_intern("UNCOMPILABLE"));

data/lib/bootsnap/compile_cache/yaml.rb

@@ -5,7 +5,15 @@ require("bootsnap/bootsnap")
 module Bootsnap
   module CompileCache
     module YAML
-      UnsupportedTags = Class.new(StandardError)
+      Uncompilable = Class.new(StandardError)
+      UnsupportedTags = Class.new(Uncompilable)
+
+      SUPPORTED_INTERNAL_ENCODINGS = [
+        nil, # UTF-8
+        Encoding::UTF_8,
+        Encoding::ASCII,
+        Encoding::BINARY,
+      ].freeze
 
       class << self
         attr_accessor(:msgpack_factory, :supported_options)
@@ -16,7 +24,9 @@ module Bootsnap
         end
 
         def precompile(path)
-          Bootsnap::CompileCache::Native.precompile(
+          return false unless CompileCache::YAML.supported_internal_encoding?
+
+          CompileCache::Native.precompile(
             cache_dir,
             path.to_s,
             @implementation,
@@ -29,6 +39,21 @@ module Bootsnap
           ::YAML.singleton_class.prepend(@implementation::Patch)
         end
 
+        # Psych coerce strings to `Encoding.default_internal` but Message Pack only support
+        # UTF-8, US-ASCII and BINARY. So if Encoding.default_internal is set to anything else
+        # we can't safely use the cache
+        def supported_internal_encoding?
+          SUPPORTED_INTERNAL_ENCODINGS.include?(Encoding.default_internal)
+        end
+
+        module EncodingAwareSymbols
+          extend self
+
+          def unpack(payload)
+            (+payload).force_encoding(Encoding::UTF_8).to_sym
+          end
+        end
+
         def init!
           require("yaml")
           require("msgpack")
@@ -43,7 +68,12 @@ module Bootsnap
           # We want them to roundtrip cleanly, so we use a custom factory.
           # see: https://github.com/msgpack/msgpack-ruby/pull/122
           factory = MessagePack::Factory.new
-          factory.register_type(0x00, Symbol)
+          factory.register_type(
+            0x00,
+            Symbol,
+            packer: :to_msgpack_ext,
+            unpacker: EncodingAwareSymbols.method(:unpack).to_proc,
+          )
 
           if defined? MessagePack::Timestamp
             factory.register_type(
@@ -119,13 +149,15 @@ module Bootsnap
           extend self
 
           def input_to_storage(contents, _)
-            obj = CompileCache::YAML.strict_load(contents)
+            obj = ::YAML.unsafe_load(contents)
             packer = CompileCache::YAML.msgpack_factory.packer
             packer.pack(false) # not safe loaded
-            packer.pack(obj)
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE # The object included things that we can't serialize
+            end
             packer.to_s
-          rescue NoMethodError, RangeError, UnsupportedTags
-            UNCOMPILABLE # The object included things that we can't serialize
           end
 
           def storage_to_output(data, kwargs)
@@ -148,13 +180,20 @@ module Bootsnap
           extend self
 
           def input_to_storage(contents, _)
-            obj = ::YAML.load(contents)
+            obj = begin
+              CompileCache::YAML.strict_load(contents)
+            rescue Psych::DisallowedClass, Psych::BadAlias, Uncompilable
+              return UNCOMPILABLE
+            end
+
             packer = CompileCache::YAML.msgpack_factory.packer
             packer.pack(true) # safe loaded
-            packer.pack(obj)
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE
+            end
             packer.to_s
-          rescue NoMethodError, RangeError, Psych::DisallowedClass, Psych::BadAlias
-            UNCOMPILABLE # The object included things that we can't serialize
           end
 
           def storage_to_output(data, kwargs)
@@ -179,44 +218,48 @@ module Bootsnap
 
         module Patch
           def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych4::SafeLoad,
+                CompileCache::YAML::Psych4::SafeLoad,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
           ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
 
           def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych4::UnsafeLoad,
+                CompileCache::YAML::Psych4::UnsafeLoad,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
@@ -228,13 +271,15 @@ module Bootsnap
         extend self
 
         def input_to_storage(contents, _)
-          obj = CompileCache::YAML.strict_load(contents)
+          obj = ::YAML.load(contents)
           packer = CompileCache::YAML.msgpack_factory.packer
           packer.pack(false) # not safe loaded
-          packer.pack(obj)
+          begin
+            packer.pack(obj)
+          rescue NoMethodError, RangeError
+            return UNCOMPILABLE # The object included things that we can't serialize
+          end
           packer.to_s
-        rescue NoMethodError, RangeError, UnsupportedTags
-          UNCOMPILABLE # The object included things that we can't serialize
         end
 
         def storage_to_output(data, kwargs)
@@ -253,44 +298,48 @@ module Bootsnap
 
         module Patch
           def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych3,
+                CompileCache::YAML::Psych3,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
           ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
 
           def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych3,
+                CompileCache::YAML::Psych3,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 

data/lib/bootsnap/compile_cache.rb

@@ -3,6 +3,9 @@
 module Bootsnap
   module CompileCache
     UNCOMPILABLE = BasicObject.new
+    def UNCOMPILABLE.inspect
+      "<Bootsnap::UNCOMPILABLE>"
+    end
 
     Error = Class.new(StandardError)
     PermissionError = Class.new(Error)
@@ -47,9 +50,7 @@ module Bootsnap
 
     def self.supported?
       # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), Windows (RubyInstaller2) and >= 2.3.0
-      RUBY_ENGINE == "ruby" &&
-        RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/ &&
-        Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
+      RUBY_ENGINE == "ruby" && RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
     end
   end
 end

data/lib/bootsnap/load_path_cache/cache.rb

@@ -142,6 +142,8 @@ module Bootsnap
             @has_relative_paths = true if p.relative?
             next if p.non_directory?
 
+            p = p.to_realpath
+
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # push -> low precedence -> set only if unset
@@ -157,6 +159,8 @@ module Bootsnap
             p = Path.new(path)
             next if p.non_directory?
 
+            p = p.to_realpath
+
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # unshift -> high precedence -> unconditional set

data/lib/bootsnap/load_path_cache/core_ext/kernel_require.rb

@@ -6,7 +6,7 @@ module Kernel
   alias_method(:require_without_bootsnap, :require)
 
   def require(path)
-    string_path = path.to_s
+    string_path = Bootsnap.rb_get_path(path)
     return false if Bootsnap::LoadPathCache.loaded_features_index.key?(string_path)
 
     resolved = Bootsnap::LoadPathCache.load_path_cache.find(string_path)
@@ -33,18 +33,9 @@ module Kernel
     end
   end
 
-  alias_method(:require_relative_without_bootsnap, :require_relative)
-  def require_relative(path)
-    location = caller_locations(1..1).first
-    realpath = Bootsnap::LoadPathCache.realpath_cache.call(
-      location.absolute_path || location.path, path
-    )
-    require(realpath)
-  end
-
   alias_method(:load_without_bootsnap, :load)
   def load(path, wrap = false)
-    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(path, try_extensions: false))
+    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(Bootsnap.rb_get_path(path), try_extensions: false))
       load_without_bootsnap(resolved, wrap)
     else
       load_without_bootsnap(path, wrap)
@@ -62,7 +53,7 @@ class Module
     # The challenge is that we don't control the point at which the entry gets
     # added to $LOADED_FEATURES and won't be able to hook that modification
     # since it's done in C-land.
-    resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
+    resolved = Bootsnap::LoadPathCache.load_path_cache.find(Bootsnap.rb_get_path(path))
     if Bootsnap::LoadPathCache::FALLBACK_SCAN.equal?(resolved)
       autoload_without_bootsnap(const, path)
     elsif resolved == false

data/lib/bootsnap/load_path_cache/path.rb

@@ -21,8 +21,26 @@ module Bootsnap
 
       attr_reader(:path)
 
-      def initialize(path)
+      def initialize(path, real: false)
         @path = path.to_s.freeze
+        @real = real
+      end
+
+      def to_realpath
+        return self if @real
+
+        realpath = begin
+          File.realpath(path)
+        rescue Errno::ENOENT
+          return self
+        end
+
+        if realpath != path
+          Path.new(realpath, real: true)
+        else
+          @real = true
+          self
+        end
       end
 
       # True if the path exists, but represents a non-directory object
@@ -62,7 +80,11 @@ module Bootsnap
       end
 
       def expanded_path
-        File.expand_path(path).freeze
+        if @real
+          path
+        else
+          @expanded_path ||= File.expand_path(path).freeze
+        end
       end
 
       private

data/lib/bootsnap/load_path_cache/store.rb

@@ -29,8 +29,8 @@ module Bootsnap
 
         v = get(key)
         unless v
-          @dirty = true
           v = yield
+          mark_for_mutation!
           @data[key] = v
         end
         v
@@ -40,7 +40,7 @@ module Bootsnap
         raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
 
         if value != @data[key]
-          @dirty = true
+          mark_for_mutation!
           @data[key] = value
         end
       end
@@ -59,6 +59,11 @@ module Bootsnap
 
       private
 
+      def mark_for_mutation!
+        @dirty = true
+        @data = @data.dup if @data.frozen?
+      end
+
       def commit_transaction
         if @dirty
           dump_data
@@ -69,7 +74,7 @@ module Bootsnap
       def load_data
         @data = begin
           data = File.open(@store_path, encoding: Encoding::BINARY) do |io|
-            MessagePack.load(io)
+            MessagePack.load(io, freeze: true)
           end
           if data.is_a?(Hash) && data[VERSION_KEY] == CURRENT_VERSION
             data
@@ -89,19 +94,17 @@ module Bootsnap
       end
 
       def dump_data
-        require "fileutils" unless defined? FileUtils
-
         # Change contents atomically so other processes can't get invalid
         # caches if they read at an inopportune time.
         tmp = "#{@store_path}.#{Process.pid}.#{(rand * 100_000).to_i}.tmp"
-        FileUtils.mkpath(File.dirname(tmp))
+        mkdir_p(File.dirname(tmp))
         exclusive_write = File::Constants::CREAT | File::Constants::EXCL | File::Constants::WRONLY
         # `encoding:` looks redundant wrt `binwrite`, but necessary on windows
         # because binary is part of mode.
         File.open(tmp, mode: exclusive_write, encoding: Encoding::BINARY) do |io|
-          MessagePack.dump(@data, io, freeze: true)
+          MessagePack.dump(@data, io)
         end
-        FileUtils.mv(tmp, @store_path)
+        File.rename(tmp, @store_path)
       rescue Errno::EEXIST
         retry
       rescue SystemCallError
@@ -110,6 +113,21 @@ module Bootsnap
       def default_data
         {VERSION_KEY => CURRENT_VERSION}
       end
+
+      def mkdir_p(path)
+        stack = []
+        until File.directory?(path)
+          stack.push path
+          path = File.dirname(path)
+        end
+        stack.reverse_each do |dir|
+          begin
+            Dir.mkdir(dir)
+          rescue SystemCallError
+            raise unless File.directory?(dir)
+          end
+        end
+      end
     end
   end
 end

data/lib/bootsnap/load_path_cache.rb

@@ -22,7 +22,7 @@ module Bootsnap
     CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
 
     class << self
-      attr_reader(:load_path_cache, :loaded_features_index, :realpath_cache)
+      attr_reader(:load_path_cache, :loaded_features_index)
 
       def setup(cache_path:, development_mode:)
         unless supported?
@@ -33,7 +33,6 @@ module Bootsnap
         store = Store.new(cache_path)
 
         @loaded_features_index = LoadedFeaturesIndex.new
-        @realpath_cache = RealpathCache.new
 
         @load_path_cache = Cache.new(store, $LOAD_PATH, development_mode: development_mode)
         require_relative("load_path_cache/core_ext/kernel_require")
@@ -55,5 +54,4 @@ if Bootsnap::LoadPathCache.supported?
   require_relative("load_path_cache/store")
   require_relative("load_path_cache/change_observer")
   require_relative("load_path_cache/loaded_features_index")
-  require_relative("load_path_cache/realpath_cache")
 end

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.10.2"
+  VERSION = "1.11.1"
 end

data/lib/bootsnap.rb

@@ -10,128 +10,139 @@ module Bootsnap
 
   class << self
     attr_reader :logger
-  end
-
-  def self.log!
-    self.logger = $stderr.method(:puts)
-  end
 
-  def self.logger=(logger)
-    @logger = logger
-    self.instrumentation = if logger.respond_to?(:debug)
-      ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") }
-    else
-      ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") }
+    def log!
+      self.logger = $stderr.method(:puts)
     end
-  end
 
-  def self.instrumentation=(callback)
-    @instrumentation = callback
-    if respond_to?(:instrumentation_enabled=, true)
-      self.instrumentation_enabled = !!callback
+    def logger=(logger)
+      @logger = logger
+      self.instrumentation = if logger.respond_to?(:debug)
+        ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") }
+      else
+        ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") }
+      end
     end
-  end
-
-  def self._instrument(event, path)
-    @instrumentation.call(event, path)
-  end
 
-  def self.setup(
-    cache_dir:,
-    development_mode: true,
-    load_path_cache: true,
-    autoload_paths_cache: nil,
-    disable_trace: nil,
-    compile_cache_iseq: true,
-    compile_cache_yaml: true,
-    compile_cache_json: true
-  )
-    unless autoload_paths_cache.nil?
-      warn "[DEPRECATED] Bootsnap's `autoload_paths_cache:` option is deprecated and will be removed. " \
-        "If you use Zeitwerk this option is useless, and if you are still using the classic autoloader " \
-        "upgrading is recommended."
+    def instrumentation=(callback)
+      @instrumentation = callback
+      if respond_to?(:instrumentation_enabled=, true)
+        self.instrumentation_enabled = !!callback
+      end
     end
 
-    unless disable_trace.nil?
-      warn "[DEPRECATED] Bootsnap's `disable_trace:` option is deprecated and will be removed. " \
-        "If you use Ruby 2.5 or newer this option is useless, if not upgrading is recommended."
+    def _instrument(event, path)
+      @instrumentation.call(event, path)
     end
 
-    if compile_cache_iseq && !iseq_cache_supported?
-      warn "Ruby 2.5 has a bug that break code tracing when code is loaded from cache. It is recommened " \
-        "to turn `compile_cache_iseq` off on Ruby 2.5"
-    end
+    def setup(
+      cache_dir:,
+      development_mode: true,
+      load_path_cache: true,
+      autoload_paths_cache: nil,
+      disable_trace: nil,
+      compile_cache_iseq: true,
+      compile_cache_yaml: true,
+      compile_cache_json: true
+    )
+      unless autoload_paths_cache.nil?
+        warn "[DEPRECATED] Bootsnap's `autoload_paths_cache:` option is deprecated and will be removed. " \
+          "If you use Zeitwerk this option is useless, and if you are still using the classic autoloader " \
+          "upgrading is recommended."
+      end
 
-    if load_path_cache
-      Bootsnap::LoadPathCache.setup(
-        cache_path: cache_dir + "/bootsnap/load-path-cache",
-        development_mode: development_mode,
+      unless disable_trace.nil?
+        warn "[DEPRECATED] Bootsnap's `disable_trace:` option is deprecated and will be removed. " \
+          "If you use Ruby 2.5 or newer this option is useless, if not upgrading is recommended."
+      end
+
+      if compile_cache_iseq && !iseq_cache_supported?
+        warn "Ruby 2.5 has a bug that break code tracing when code is loaded from cache. It is recommened " \
+          "to turn `compile_cache_iseq` off on Ruby 2.5"
+      end
+
+      if load_path_cache
+        Bootsnap::LoadPathCache.setup(
+          cache_path: cache_dir + "/bootsnap/load-path-cache",
+          development_mode: development_mode,
+        )
+      end
+
+      Bootsnap::CompileCache.setup(
+        cache_dir: cache_dir + "/bootsnap/compile-cache",
+        iseq: compile_cache_iseq,
+        yaml: compile_cache_yaml,
+        json: compile_cache_json,
       )
     end
 
-    Bootsnap::CompileCache.setup(
-      cache_dir: cache_dir + "/bootsnap/compile-cache",
-      iseq: compile_cache_iseq,
-      yaml: compile_cache_yaml,
-      json: compile_cache_json,
-    )
-  end
+    def iseq_cache_supported?
+      return @iseq_cache_supported if defined? @iseq_cache_supported
 
-  def self.iseq_cache_supported?
-    return @iseq_cache_supported if defined? @iseq_cache_supported
+      ruby_version = Gem::Version.new(RUBY_VERSION)
+      @iseq_cache_supported = ruby_version < Gem::Version.new("2.5.0") || ruby_version >= Gem::Version.new("2.6.0")
+    end
 
-    ruby_version = Gem::Version.new(RUBY_VERSION)
-    @iseq_cache_supported = ruby_version < Gem::Version.new("2.5.0") || ruby_version >= Gem::Version.new("2.6.0")
-  end
+    def default_setup
+      env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
+      development_mode = ["", nil, "development"].include?(env)
 
-  def self.default_setup
-    env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
-    development_mode = ["", nil, "development"].include?(env)
+      unless ENV["DISABLE_BOOTSNAP"]
+        cache_dir = ENV["BOOTSNAP_CACHE_DIR"]
+        unless cache_dir
+          config_dir_frame = caller.detect do |line|
+            line.include?("/config/")
+          end
 
-    unless ENV["DISABLE_BOOTSNAP"]
-      cache_dir = ENV["BOOTSNAP_CACHE_DIR"]
-      unless cache_dir
-        config_dir_frame = caller.detect do |line|
-          line.include?("/config/")
-        end
+          unless config_dir_frame
+            $stderr.puts("[bootsnap/setup] couldn't infer cache directory! Either:")
+            $stderr.puts("[bootsnap/setup]   1. require bootsnap/setup from your application's config directory; or")
+            $stderr.puts("[bootsnap/setup]   2. Define the environment variable BOOTSNAP_CACHE_DIR")
 
-        unless config_dir_frame
-          $stderr.puts("[bootsnap/setup] couldn't infer cache directory! Either:")
-          $stderr.puts("[bootsnap/setup]   1. require bootsnap/setup from your application's config directory; or")
-          $stderr.puts("[bootsnap/setup]   2. Define the environment variable BOOTSNAP_CACHE_DIR")
+            raise("couldn't infer bootsnap cache directory")
+          end
 
-          raise("couldn't infer bootsnap cache directory")
-        end
+          path = config_dir_frame.split(/:\d+:/).first
+          path = File.dirname(path) until File.basename(path) == "config"
+          app_root = File.dirname(path)
 
-        path = config_dir_frame.split(/:\d+:/).first
-        path = File.dirname(path) until File.basename(path) == "config"
-        app_root = File.dirname(path)
+          cache_dir = File.join(app_root, "tmp", "cache")
+        end
 
-        cache_dir = File.join(app_root, "tmp", "cache")
+        setup(
+          cache_dir: cache_dir,
+          development_mode: development_mode,
+          load_path_cache: !ENV["DISABLE_BOOTSNAP_LOAD_PATH_CACHE"],
+          compile_cache_iseq: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"] && iseq_cache_supported?,
+          compile_cache_yaml: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
+          compile_cache_json: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
+        )
+
+        if ENV["BOOTSNAP_LOG"]
+          log!
+        end
       end
+    end
 
-      setup(
-        cache_dir: cache_dir,
-        development_mode: development_mode,
-        load_path_cache: !ENV["DISABLE_BOOTSNAP_LOAD_PATH_CACHE"],
-        compile_cache_iseq: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"] && iseq_cache_supported?,
-        compile_cache_yaml: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-        compile_cache_json: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-      )
-
-      if ENV["BOOTSNAP_LOG"]
-        log!
+    if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+      def absolute_path?(path)
+        path[1] == ":"
+      end
+    else
+      def absolute_path?(path)
+        path.start_with?("/")
       end
     end
-  end
 
-  if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
-    def self.absolute_path?(path)
-      path[1] == ":"
-    end
-  else
-    def self.absolute_path?(path)
-      path.start_with?("/")
+    # This is a semi-accurate ruby implementation of the native `rb_get_path(VALUE)` function.
+    # The native version is very intricate and may behave differently on windows etc.
+    # But we only use it for non-MRI platform.
+    def rb_get_path(fname)
+      path_path = fname.respond_to?(:to_path) ? fname.to_path : fname
+      String.try_convert(path_path) || raise(TypeError, "no implicit conversion of #{path_path.class} into String")
     end
+
+    # Allow the C extension to redefine `rb_get_path` without warning.
+    alias_method :rb_get_path, :rb_get_path # rubocop:disable Lint/DuplicateMethods
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.10.2
+  version: 1.11.1
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -57,7 +57,6 @@ files:
 - lib/bootsnap/load_path_cache/loaded_features_index.rb
 - lib/bootsnap/load_path_cache/path.rb
 - lib/bootsnap/load_path_cache/path_scanner.rb
-- lib/bootsnap/load_path_cache/realpath_cache.rb
 - lib/bootsnap/load_path_cache/store.rb
 - lib/bootsnap/setup.rb
 - lib/bootsnap/version.rb
@@ -77,7 +76,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/bootsnap/load_path_cache/realpath_cache.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Bootsnap
-  module LoadPathCache
-    class RealpathCache
-      def initialize
-        @cache = Hash.new { |h, k| h[k] = realpath(*k) }
-      end
-
-      def call(*key)
-        @cache[key]
-      end
-
-      private
-
-      def realpath(caller_location, path)
-        base = File.dirname(caller_location)
-        abspath = File.expand_path(path, base).freeze
-        find_file(abspath)
-      end
-
-      def find_file(name)
-        return File.realpath(name).freeze if File.exist?(name)
-
-        CACHED_EXTENSIONS.each do |ext|
-          filename = "#{name}#{ext}"
-          return File.realpath(filename).freeze if File.exist?(filename)
-        end
-        name
-      end
-    end
-  end
-end