bootsnap 1.9.1 → 1.10.3

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative('../explicit_require')
+require_relative("../explicit_require")
 
 module Bootsnap
   module LoadPathCache
@@ -28,15 +28,16 @@ module Bootsnap
       BUILTIN_FEATURES = $LOADED_FEATURES.each_with_object({}) do |feat, features|
         # Builtin features are of the form 'enumerator.so'.
         # All others include paths.
-        next unless feat.size < 20 && !feat.include?('/')
+        next unless feat.size < 20 && !feat.include?("/")
 
-        base = File.basename(feat, '.*') # enumerator.so -> enumerator
+        base = File.basename(feat, ".*") # enumerator.so -> enumerator
         ext  = File.extname(feat) # .so
 
         features[feat] = nil # enumerator.so
         features[base] = nil # enumerator
 
         next unless [DOT_SO, *DL_EXTENSIONS].include?(ext)
+
         DL_EXTENSIONS.each do |dl_ext|
           features["#{base}#{dl_ext}"] = nil # enumerator.bundle
         end
@@ -44,21 +45,27 @@ module Bootsnap
 
       # Try to resolve this feature to an absolute path without traversing the
       # loadpath.
-      def find(feature)
+      def find(feature, try_extensions: true)
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
         feature = feature.to_s.freeze
-        return feature if absolute_path?(feature)
-        return expand_path(feature) if feature.start_with?('./')
+
+        return feature if Bootsnap.absolute_path?(feature)
+
+        if feature.start_with?("./", "../")
+          return try_extensions ? expand_path(feature) : File.expand_path(feature).freeze
+        end
+
         @mutex.synchronize do
-          x = search_index(feature)
+          x = search_index(feature, try_extensions: try_extensions)
           return x if x
+          return unless try_extensions
 
           # Ruby has some built-in features that require lies about.
           # For example, 'enumerator' is built in. If you require it, ruby
           # 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.
@@ -67,13 +74,14 @@ module Bootsnap
           # native dynamic extension, e.g. .bundle or .so), we know it was a
           # failure and there's nothing more we can do to find the file.
           # no extension, .rb, (.bundle or .so)
-          when '', *CACHED_EXTENSIONS
+          when "", *CACHED_EXTENSIONS
             nil
           # Ruby allows specifying native extensions as '.so' even when DLEXT
           # is '.bundle'. This is where we handle that case.
           when DOT_SO
             x = search_index(feature[0..-4] + DLEXT)
             return x if x
+
             if DLEXT2
               x = search_index(feature[0..-4] + DLEXT2)
               return x if x
@@ -81,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
 
@@ -89,26 +97,18 @@ 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
-      end
-
-      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-        def absolute_path?(path)
-          path[1] == ':'
-        end
-      else
-        def absolute_path?(path)
-          path.start_with?(SLASH)
-        end
+        return FALLBACK_SCAN if @development_mode
       end
 
       def unshift_paths(sender, *paths)
         return unless sender == @path_obj
+
         @mutex.synchronize { unshift_paths_locked(*paths) }
       end
 
       def push_paths(sender, *paths)
         return unless sender == @path_obj
+
         @mutex.synchronize { push_paths_locked(*paths) }
       end
 
@@ -141,6 +141,7 @@ module Bootsnap
             p = Path.new(path)
             @has_relative_paths = true if p.relative?
             next if p.non_directory?
+
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # push -> low precedence -> set only if unset
@@ -155,6 +156,7 @@ module Bootsnap
           paths.map(&:to_s).reverse_each do |path|
             p = Path.new(path)
             next if p.non_directory?
+
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # unshift -> high precedence -> unconditional set
@@ -177,48 +179,62 @@ module Bootsnap
       end
 
       if DLEXT2
-        def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
+        def search_index(feature, try_extensions: true)
+          if try_extensions
+            try_index(feature + DOT_RB) ||
+              try_index(feature + DLEXT) ||
+              try_index(feature + DLEXT2) ||
+              try_index(feature)
+          else
+            try_index(feature)
+          end
         end
 
-        def maybe_append_extension(f)
-          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || try_ext(f + DLEXT2) || f
+        def maybe_append_extension(feature)
+          try_ext(feature + DOT_RB) ||
+            try_ext(feature + DLEXT) ||
+            try_ext(feature + DLEXT2) ||
+            feature
         end
       else
-        def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
+        def search_index(feature, try_extensions: true)
+          if try_extensions
+            try_index(feature + DOT_RB) || try_index(feature + DLEXT) || try_index(feature)
+          else
+            try_index(feature)
+          end
         end
 
-        def maybe_append_extension(f)
-          try_ext(f + DOT_RB) || try_ext(f + DLEXT) || f
+        def maybe_append_extension(feature)
+          try_ext(feature + DOT_RB) || try_ext(feature + DLEXT) || feature
         end
       end
 
       s = rand.to_s.force_encoding(Encoding::US_ASCII).freeze
       if s.respond_to?(:-@)
-        if (-s).equal?(s) && (-s.dup).equal?(s) || RUBY_VERSION >= '2.7'
-          def try_index(f)
-            if (p = @index[f])
-              -(File.join(p, f).freeze)
+        if (-s).equal?(s) && (-s.dup).equal?(s) || RUBY_VERSION >= "2.7"
+          def try_index(feature)
+            if (path = @index[feature])
+              -File.join(path, feature).freeze
             end
           end
         else
-          def try_index(f)
-            if (p = @index[f])
-              -File.join(p, f).untaint
+          def try_index(feature)
+            if (path = @index[feature])
+              -File.join(path, feature).untaint
             end
           end
         end
       else
-        def try_index(f)
-          if (p = @index[f])
-            File.join(p, f)
+        def try_index(feature)
+          if (path = @index[feature])
+            File.join(path, feature)
           end
         end
       end
 
-      def try_ext(f)
-        f if File.exist?(f)
+      def try_ext(feature)
+        feature if File.exist?(feature)
       end
     end
   end

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     module ChangeObserver
@@ -57,6 +58,7 @@ module Bootsnap
 
       def self.register(observer, arr)
         return if arr.frozen? # can't register observer, but no need to.
+
         arr.instance_variable_set(:@lpc_observer, observer)
         arr.extend(ArrayMixin)
       end

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

@@ -1,47 +1,35 @@
 # 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 # rubocop:disable Style/ModuleFunction
+  module_function
 
   alias_method(:require_without_bootsnap, :require)
 
-  # Note that require registers to $LOADED_FEATURES while load does not.
-  def require_with_bootsnap_lfi(path, resolved = nil)
-    Bootsnap::LoadPathCache.loaded_features_index.register(path, resolved) do
-      require_without_bootsnap(resolved || path)
-    end
-  end
-
   def require(path)
-    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(path)
+    string_path = path.to_s
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(string_path)
 
-    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(path))
-      return require_with_bootsnap_lfi(path, resolved)
-    end
-
-    raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
-  rescue LoadError => e
-    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-    raise(e)
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    fallback = true
-  ensure
-    if fallback
-      require_with_bootsnap_lfi(path)
+    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)
+        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
 
@@ -56,25 +44,9 @@ module Kernel
 
   alias_method(:load_without_bootsnap, :load)
   def load(path, wrap = false)
-    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(path))
-      return load_without_bootsnap(resolved, wrap)
-    end
-
-    # load also allows relative paths from pwd even when not in $:
-    if File.exist?(relative = File.expand_path(path).freeze)
-      return load_without_bootsnap(relative, wrap)
-    end
-
-    raise(Bootsnap::LoadPathCache::CoreExt.make_load_error(path))
-  rescue LoadError => e
-    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-    raise(e)
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    fallback = true
-  ensure
-    if fallback
+    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(path, try_extensions: false))
+      load_without_bootsnap(resolved, wrap)
+    else
       load_without_bootsnap(path, wrap)
     end
   end
@@ -90,17 +62,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 => e
-    e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-    raise(e)
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    fallback = true
-  ensure
-    if fallback
+    resolved = Bootsnap::LoadPathCache.load_path_cache.find(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/core_ext/loaded_features.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class << $LOADED_FEATURES
   alias_method(:delete_without_bootsnap, :delete)
   def delete(key)

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -29,14 +29,15 @@ module Bootsnap
         @mutex = Mutex.new
 
         # In theory the user could mutate $LOADED_FEATURES and invalidate our
-        # cache. If this ever comes up in practice — or if you, the
-        # enterprising reader, feels inclined to solve this problem — we could
+        # cache. If this ever comes up in practice - or if you, the
+        # enterprising reader, feels inclined to solve this problem - we could
         # parallel the work done with ChangeObserver on $LOAD_PATH to mirror
         # updates to our @lfi.
         $LOADED_FEATURES.each do |feat|
           hash = feat.hash
           $LOAD_PATH.each do |lpe|
             next unless feat.start_with?(lpe)
+
             # /a/b/lib/my/foo.rb
             #          ^^^^^^^^^
             short = feat[(lpe.length + 1)..-1]
@@ -68,11 +69,30 @@ module Bootsnap
         @mutex.synchronize { @lfi.key?(feature) }
       end
 
+      def cursor(short)
+        unless Bootsnap.absolute_path?(short.to_s)
+          $LOADED_FEATURES.size
+        end
+      end
+
+      def identify(short, cursor)
+        $LOADED_FEATURES[cursor..-1].detect do |feat|
+          offset = 0
+          while (offset = feat.index(short, offset))
+            if feat.index(".", offset + 1) && !feat.index("/", offset + 2)
+              break true
+            else
+              offset += 1
+            end
+          end
+        end
+      end
+
       # There is a relatively uncommon case where we could miss adding an
       # 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.
       #
@@ -82,15 +102,8 @@ module Bootsnap
       #    not quite right; or
       # 2. Inspect $LOADED_FEATURES upon return from yield to find the matching
       #    entry.
-      def register(short, long = nil)
-        if long.nil?
-          pat = %r{/#{Regexp.escape(short)}(\.[^/]+)?$}
-          len = $LOADED_FEATURES.size
-          ret = yield
-          long = $LOADED_FEATURES[len..-1].detect { |feat| feat =~ pat }
-        else
-          ret = yield
-        end
+      def register(short, long)
+        return if Bootsnap.absolute_path?(short)
 
         hash = long.hash
 
@@ -109,13 +122,11 @@ module Bootsnap
           @lfi[short] = hash
           (@lfi[altname] = hash) if altname
         end
-
-        ret
       end
 
       private
 
-      STRIP_EXTENSION = /\.[^.]*?$/
+      STRIP_EXTENSION = /\.[^.]*?$/.freeze
       private_constant(:STRIP_EXTENSION)
 
       # Might Ruby automatically search for this extension if
@@ -132,15 +143,15 @@ module Bootsnap
       # with calling a Ruby file 'x.dylib.rb' and then requiring it as 'x.dylib'.)
       #
       # See <https://ruby-doc.org/core-2.6.4/Kernel.html#method-i-require>.
-      def extension_elidable?(f)
-        f.to_s.end_with?('.rb', '.so', '.o', '.dll', '.dylib')
+      def extension_elidable?(feature)
+        feature.to_s.end_with?(".rb", ".so", ".o", ".dll", ".dylib")
       end
 
-      def strip_extension_if_elidable(f)
-        if extension_elidable?(f)
-          f.sub(STRIP_EXTENSION, '')
+      def strip_extension_if_elidable(feature)
+        if extension_elidable?(feature)
+          feature.sub(STRIP_EXTENSION, "")
         else
-          f
+          feature
         end
       end
     end

data/lib/bootsnap/load_path_cache/path.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require_relative('path_scanner')
+
+require_relative("path_scanner")
 
 module Bootsnap
   module LoadPathCache
@@ -43,6 +44,7 @@ module Bootsnap
           # set to zero anyway, just in case we change the stability heuristics.
           _, entries, dirs = store.get(expanded_path)
           return [entries, dirs] if entries # cache hit
+
           entries, dirs = scan!
           store.set(expanded_path, [0, entries, dirs])
           return [entries, dirs]
@@ -93,8 +95,8 @@ module Bootsnap
 
       # Built-in ruby lib stuff doesn't change, but things can occasionally be
       # installed into sitedir, which generally lives under libdir.
-      RUBY_LIBDIR  = RbConfig::CONFIG['libdir']
-      RUBY_SITEDIR = RbConfig::CONFIG['sitedir']
+      RUBY_LIBDIR  = RbConfig::CONFIG["libdir"]
+      RUBY_SITEDIR = RbConfig::CONFIG["sitedir"]
 
       def stability
         @stability ||= begin

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require_relative('../explicit_require')
+require_relative("../explicit_require")
 
 module Bootsnap
   module LoadPathCache
     module PathScanner
       REQUIRABLE_EXTENSIONS = [DOT_RB] + DL_EXTENSIONS
       NORMALIZE_NATIVE_EXTENSIONS = !DL_EXTENSIONS.include?(LoadPathCache::DOT_SO)
-      ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/
+      ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/.freeze
 
       BUNDLE_PATH = if Bootsnap.bundler?
         (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
       else
-        ''
+        ""
       end
 
       class << self
@@ -44,7 +44,8 @@ module Bootsnap
 
         def walk(absolute_dir_path, relative_dir_path, &block)
           Dir.foreach(absolute_dir_path) do |name|
-            next if name.start_with?('.')
+            next if name.start_with?(".")
+
             relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
 
             absolute_path = "#{absolute_dir_path}/#{name}"
@@ -58,7 +59,7 @@ module Bootsnap
           end
         end
 
-        if RUBY_VERSION >= '3.1'
+        if RUBY_VERSION >= "3.1"
           def os_path(path)
             path.freeze
           end

data/lib/bootsnap/load_path_cache/realpath_cache.rb

@@ -21,6 +21,7 @@ module Bootsnap
 
       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)

data/lib/bootsnap/load_path_cache/store.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
-require_relative('../explicit_require')
 
-Bootsnap::ExplicitRequire.with_gems('msgpack') { require('msgpack') }
-Bootsnap::ExplicitRequire.from_rubylibdir('fileutils')
+require_relative("../explicit_require")
+
+Bootsnap::ExplicitRequire.with_gems("msgpack") { require("msgpack") }
 
 module Bootsnap
   module LoadPathCache
     class Store
+      VERSION_KEY = "__bootsnap_ruby_version__"
+      CURRENT_VERSION = "#{RUBY_REVISION}-#{RUBY_PLATFORM}".freeze # rubocop:disable Style/RedundantFreeze
+
       NestedTransactionError = Class.new(StandardError)
       SetOutsideTransactionNotAllowed = Class.new(StandardError)
 
@@ -23,6 +26,7 @@ module Bootsnap
 
       def fetch(key)
         raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
+
         v = get(key)
         unless v
           @dirty = true
@@ -34,6 +38,7 @@ module Bootsnap
 
       def set(key, value)
         raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
+
         if value != @data[key]
           @dirty = true
           @data[key] = value
@@ -42,6 +47,7 @@ module Bootsnap
 
       def transaction
         raise(NestedTransactionError) if @txn_mutex.owned?
+
         @txn_mutex.synchronize do
           begin
             yield
@@ -62,15 +68,20 @@ module Bootsnap
 
       def load_data
         @data = begin
-          File.open(@store_path, encoding: Encoding::BINARY) do |io|
+          data = File.open(@store_path, encoding: Encoding::BINARY) do |io|
             MessagePack.load(io)
           end
+          if data.is_a?(Hash) && data[VERSION_KEY] == CURRENT_VERSION
+            data
+          else
+            default_data
+          end
         # handle malformed data due to upgrade incompatibility
         rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
-          {}
+          default_data
         rescue ArgumentError => error
           if error.message =~ /negative array size/
-            {}
+            default_data
           else
             raise
           end
@@ -78,9 +89,11 @@ 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 * 100000).to_i}.tmp"
+        tmp = "#{@store_path}.#{Process.pid}.#{(rand * 100_000).to_i}.tmp"
         FileUtils.mkpath(File.dirname(tmp))
         exclusive_write = File::Constants::CREAT | File::Constants::EXCL | File::Constants::WRONLY
         # `encoding:` looks redundant wrt `binwrite`, but necessary on windows
@@ -93,6 +106,10 @@ module Bootsnap
         retry
       rescue SystemCallError
       end
+
+      def default_data
+        {VERSION_KEY => CURRENT_VERSION}
+      end
     end
   end
 end