bootsnap 1.10.1 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c66adff2d954aee5f0f0b6beae724c2ec1a2abedb6cc6ffd1b3eb84a0481acf
-  data.tar.gz: 91a512ba361da721632679a2942d84128fe301bfc0750b48ec3c98989433072b
+  metadata.gz: af127c58fb31e53309de406862116407d9f57d43514937d400a0f87c13080447
+  data.tar.gz: 497f3a471eed46b68e624f8cda87bc6d5e97d5a17bdf4cbeb2221019fb21d531
 SHA512:
-  metadata.gz: 74613cfa0f4b1b337cf60c2e60f8f51c8726321953addfc1166708af567bdae486ea38b5ff9f1ad63ec13bee2c7142be0cde9fd9d68bf2eca4c044936b575f17
-  data.tar.gz: 9449f4e75ebe813e5df1fd2c71c1e334853c67feaa0a4e5351a0bcc53d6479993ffc59b37412f81853dce6154e36a165e5e5fb6c311c2ef5cf561afc889a51e2
+  metadata.gz: 32c3bba78bf66bb71b47d78e06592e4a670735d581c84043b4c125704fb91d4cff900da0e2884c910f3c66ddf9e31f4860a33718da978cc9f2719e32a9f1f617
+  data.tar.gz: 11a5bdee97b35fc99d346ae2cd44e95e8fc3cfd949bddc06a7561b7329fd42a0e63ef5e747a90fa599125100cc368d9ef6c9ad207a1a69fe51f6c32e71992611

data/CHANGELOG.md

@@ -1,8 +1,47 @@
 # Unreleased
 
+# 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.
+
+* Better check `freeze` option support in JSON compile cache.
+  Previously `JSON.load_file(..., freeze: true)` would be cached even when the msgpack version is missing support for it.
+
 # 1.10.1
 
-* Fix `Kernel#autoload`'s fallback path always bing executed.
+* Fix `Kernel#autoload`'s fallback path always being executed.
+
 * Consider `unlink` failing with `ENOENT` as a success.
 
 # 1.10.0
@@ -14,7 +53,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.
 
@@ -55,7 +94,7 @@
 
 # 1.8.0
 
-* Improve support for Pysch 4. (#368)
+* Improve support for Psych 4. (#368)
 
 # 1.7.7
 
@@ -73,8 +112,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/json.rb

@@ -52,7 +52,9 @@ module Bootsnap
           self.msgpack_factory = MessagePack::Factory.new
           self.supported_options = [:symbolize_names]
           if ::JSON.parse('["foo"]', freeze: true).first.frozen?
-            self.supported_options = [:freeze]
+            if MessagePack.load(MessagePack.dump("foo"), freeze: true).frozen?
+              self.supported_options = [:freeze]
+            end
           end
           supported_options.freeze
         end

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

@@ -65,7 +65,7 @@ module Bootsnap
           # returns false as if it were already loaded; however, there is no
           # file to find on disk. We've pre-built a list of these, and we
           # return false if any of them is loaded.
-          raise(LoadPathCache::ReturnFalse, "", []) if BUILTIN_FEATURES.key?(feature)
+          return false if BUILTIN_FEATURES.key?(feature)
 
           # The feature wasn't found on our preliminary search through the index.
           # We resolve this differently depending on what the extension was.
@@ -89,7 +89,7 @@ module Bootsnap
           else
             # other, unknown extension. For example, `.rake`. Since we haven't
             # cached these, we legitimately need to run the load path search.
-            raise(LoadPathCache::FallbackScan, "", [])
+            return FALLBACK_SCAN
           end
         end
 
@@ -97,7 +97,7 @@ module Bootsnap
         # cases where the file doesn't appear to be on the load path. We should
         # be able to detect newly-created files without rebooting the
         # application.
-        raise(LoadPathCache::FallbackScan, "", []) if @development_mode
+        return FALLBACK_SCAN if @development_mode
       end
 
       def unshift_paths(sender, *paths)
@@ -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

@@ -1,70 +1,41 @@
 # frozen_string_literal: true
 
-module Bootsnap
-  module LoadPathCache
-    module CoreExt
-      def self.make_load_error(path)
-        err = LoadError.new(+"cannot load such file -- #{path}")
-        err.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-        err.define_singleton_method(:path) { path }
-        err
-      end
-    end
-  end
-end
-
 module Kernel
   module_function
 
   alias_method(:require_without_bootsnap, :require)
 
   def require(path)
-    fallback = false
-    string_path = path.to_s
+    string_path = Bootsnap.rb_get_path(path)
     return false if Bootsnap::LoadPathCache.loaded_features_index.key?(string_path)
 
-    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(string_path))
-      # Note that require registers to $LOADED_FEATURES while load does not.
-      ret = require_without_bootsnap(resolved)
-      Bootsnap::LoadPathCache.loaded_features_index.register(string_path, resolved)
-      return ret
-    end
-
-    raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
-  rescue LoadError => error
-    error.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-    raise(error)
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    fallback = true
-  ensure
-    # We raise from `ensure` so that any further exception don't have FallbackScan as a cause
-    # See: https://github.com/Shopify/bootsnap/issues/250
-    if fallback
+    resolved = Bootsnap::LoadPathCache.load_path_cache.find(string_path)
+    if Bootsnap::LoadPathCache::FALLBACK_SCAN.equal?(resolved)
       if (cursor = Bootsnap::LoadPathCache.loaded_features_index.cursor(string_path))
         ret = require_without_bootsnap(path)
         resolved = Bootsnap::LoadPathCache.loaded_features_index.identify(string_path, cursor)
         Bootsnap::LoadPathCache.loaded_features_index.register(string_path, resolved)
-        ret
-      else # If we're not given a cursor, it means we don't need to register the path (likely an absolute path)
-        require_without_bootsnap(path)
+        return ret
+      else
+        return require_without_bootsnap(path)
       end
+    elsif false == resolved
+      return false
+    elsif resolved.nil?
+      error = LoadError.new(+"cannot load such file -- #{path}")
+      error.instance_variable_set(:@path, path)
+      raise error
+    else
+      # Note that require registers to $LOADED_FEATURES while load does not.
+      ret = require_without_bootsnap(resolved)
+      Bootsnap::LoadPathCache.loaded_features_index.register(string_path, resolved)
+      return ret
     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)
@@ -75,7 +46,6 @@ end
 class Module
   alias_method(:autoload_without_bootsnap, :autoload)
   def autoload(const, path)
-    fallback = false
     # NOTE: This may defeat LoadedFeaturesIndex, but it's not immediately
     # obvious how to make it work. This feels like a pretty niche case, unclear
     # if it will ever burn anyone.
@@ -83,19 +53,13 @@ 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.
-    autoload_without_bootsnap(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
-  rescue LoadError => error
-    error.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-    raise(error)
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    fallback = true
-  ensure
-    # We raise from `ensure` so that any further exception don't have FallbackScan as a cause
-    # See: https://github.com/Shopify/bootsnap/issues/250
-    if fallback
+    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
+      return false
+    else
+      autoload_without_bootsnap(const, resolved || path)
     end
   end
 end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -92,7 +92,7 @@ module Bootsnap
       # entry:
       #
       # If the user asked for e.g. `require 'bundler'`, and we went through the
-      # `FallbackScan` pathway in `kernel_require.rb` and therefore did not
+      # `FALLBACK_SCAN` pathway in `kernel_require.rb` and therefore did not
       # pass `long` (the full expanded absolute path), then we did are not able
       # to confidently add the `bundler.rb` form to @lfi.
       #

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

@@ -69,7 +69,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 +89,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 +108,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

@@ -2,18 +2,12 @@
 
 module Bootsnap
   module LoadPathCache
-    ReturnFalse = Class.new(StandardError)
-    FallbackScan = Class.new(StandardError)
+    FALLBACK_SCAN = BasicObject.new
 
     DOT_RB = ".rb"
     DOT_SO = ".so"
     SLASH  = "/"
 
-    # If a NameError happens several levels deep, don't re-handle it
-    # all the way up the chain: mark it once and bubble it up without
-    # more retries.
-    ERROR_TAG_IVAR = :@__bootsnap_rescued
-
     DL_EXTENSIONS = ::RbConfig::CONFIG
       .values_at("DLEXT", "DLEXT2")
       .reject { |ext| !ext || ext.empty? }
@@ -28,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?
@@ -39,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")
@@ -61,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.1"
+  VERSION = "1.11.0"
 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.1
+  version: 1.11.0
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-17 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