bootsnap 1.4.5 → 1.18.3

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     module ChangeObserver
@@ -14,18 +16,20 @@ module Bootsnap
           @lpc_observer.push_paths(self, *entries.map(&:to_s))
           super
         end
+        alias_method :append, :push
 
         def unshift(*entries)
           @lpc_observer.unshift_paths(self, *entries.map(&:to_s))
           super
         end
+        alias_method :prepend, :unshift
 
         def concat(entries)
           @lpc_observer.push_paths(self, *entries.map(&:to_s))
           super
         end
 
-        # uniq! keeps the first occurance of each path, otherwise preserving
+        # uniq! keeps the first occurrence of each path, otherwise preserving
         # order, preserving the effective load path
         def uniq!(*args)
           ret = super
@@ -50,12 +54,30 @@ module Bootsnap
             ret
           end
         end
+
+        def dup
+          [] + self
+        end
+
+        alias_method :clone, :dup
       end
 
-      def self.register(observer, arr)
+      def self.register(arr, observer)
         return if arr.frozen? # can't register observer, but no need to.
+
         arr.instance_variable_set(:@lpc_observer, observer)
-        arr.extend(ArrayMixin)
+        ArrayMixin.instance_methods.each do |method_name|
+          arr.singleton_class.send(:define_method, method_name, ArrayMixin.instance_method(method_name))
+        end
+      end
+
+      def self.unregister(arr)
+        return unless arr.instance_variable_defined?(:@lpc_observer) && arr.instance_variable_get(:@lpc_observer)
+
+        ArrayMixin.instance_methods.each do |method_name|
+          arr.singleton_class.send(:remove_method, method_name)
+        end
+        arr.instance_variable_set(:@lpc_observer, nil)
       end
     end
   end

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

@@ -1,92 +1,37 @@
-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
+# frozen_string_literal: true
 
 module Kernel
-  module_function # rubocop:disable Style/ModuleFunction
-
-  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)
+  alias_method :require_without_bootsnap, :require
 
-    if (resolved = Bootsnap::LoadPathCache.load_path_cache.find(path))
-      return require_with_bootsnap_lfi(path, resolved)
-    end
+  alias_method :require, :require # Avoid method redefinition warnings
 
-    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
-    require_with_bootsnap_lfi(path)
-  end
+  def require(path) # rubocop:disable Lint/DuplicateMethods
+    return require_without_bootsnap(path) unless Bootsnap::LoadPathCache.enabled?
 
-  alias_method(:require_relative_without_bootsnap, :require_relative)
-  def require_relative(path)
-    realpath = Bootsnap::LoadPathCache.realpath_cache.call(
-      caller_locations(1..1).first.absolute_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))
-      return load_without_bootsnap(resolved, wrap)
-    end
+    string_path = Bootsnap.rb_get_path(path)
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(string_path)
 
-    # load also allows relative paths from pwd even when not in $:
-    if File.exist?(relative = File.expand_path(path))
-      return load_without_bootsnap(relative, wrap)
+    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?
+      return require_without_bootsnap(path)
+    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
-
-    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
-    load_without_bootsnap(path, wrap)
   end
-end
 
-class Module
-  alias_method(:autoload_without_bootsnap, :autoload)
-  def autoload(const, path)
-    # 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.
-    #
-    # 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
-    autoload_without_bootsnap(const, path)
-  end
+  private :require
 end

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

@@ -1,3 +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

@@ -26,21 +26,22 @@ module Bootsnap
     class LoadedFeaturesIndex
       def initialize
         @lfi = {}
-        @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
+        @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]
-            stripped = strip_extension(short)
+            short = feat[(lpe.length + 1)..]
+            stripped = strip_extension_if_elidable(short)
             @lfi[short] = hash
             @lfi[stripped] = hash
           end
@@ -58,9 +59,9 @@ module Bootsnap
       end
 
       def purge_multi(features)
-        rejected_hashes = features.map(&:hash).to_set
+        rejected_hashes = features.each_with_object({}) { |f, h| h[f.hash] = true }
         @mutex.synchronize do
-          @lfi.reject! { |_, hash| rejected_hashes.include?(hash) }
+          @lfi.reject! { |_, hash| rejected_hashes.key?(hash) }
         end
       end
 
@@ -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..].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,25 +102,19 @@ 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
 
-        # do we have 'bundler' or 'bundler.rb'?
-        altname = if File.extname(short) != ''
-          # strip the path from 'bundler.rb' -> 'bundler'
-          strip_extension(short)
-        elsif long && (ext = File.extname(long))
-          # get the extension from the expanded path if given
-          # 'bundler' + '.rb'
+        # Do we have a filename with an elidable extension, e.g.,
+        # 'bundler.rb', or 'libgit2.so'?
+        altname = if extension_elidable?(short)
+          # Strip the extension off, e.g. 'bundler.rb' -> 'bundler'.
+          strip_extension_if_elidable(short)
+        elsif long && (ext = File.extname(long.freeze))
+          # We already know the extension of the actual file this
+          # resolves to, so put that back on.
           short + ext
         end
 
@@ -108,17 +122,37 @@ module Bootsnap
           @lfi[short] = hash
           (@lfi[altname] = hash) if altname
         end
-
-        ret
       end
 
       private
 
-      STRIP_EXTENSION = /\.[^.]*?$/
+      STRIP_EXTENSION = /\.[^.]*?$/.freeze
       private_constant(:STRIP_EXTENSION)
 
-      def strip_extension(f)
-        f.sub(STRIP_EXTENSION, '')
+      # Might Ruby automatically search for this extension if
+      # someone tries to 'require' the file without it? E.g. Ruby
+      # will implicitly try 'x.rb' if you ask for 'x'.
+      #
+      # This is complex and platform-dependent, and the Ruby docs are a little
+      # handwavy about what will be tried when and in what order.
+      # So optimistically pretend that all known elidable extensions
+      # will be tried on all platforms, and that people are unlikely
+      # to name files in a way that assumes otherwise.
+      # (E.g. It's unlikely that someone will know that their code
+      # will _never_ run on MacOS, and therefore think they can get away
+      # 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?(feature)
+        feature.to_s.end_with?(".rb", ".so", ".o", ".dll", ".dylib")
+      end
+
+      def strip_extension_if_elidable(feature)
+        if extension_elidable?(feature)
+          feature.sub(STRIP_EXTENSION, "")
+        else
+          feature
+        end
       end
     end
   end

data/lib/bootsnap/load_path_cache/path.rb

@@ -1,4 +1,6 @@
-require_relative('path_scanner')
+# frozen_string_literal: true
+
+require_relative "path_scanner"
 
 module Bootsnap
   module LoadPathCache
@@ -19,14 +21,32 @@ module Bootsnap
 
       attr_reader(:path)
 
-      def initialize(path)
-        @path = path.to_s
+      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
+          @real = true
+          self
+        else
+          Path.new(realpath, real: true)
+        end
       end
 
       # True if the path exists, but represents a non-directory object
       def non_directory?
         !File.stat(path).directory?
-      rescue Errno::ENOENT, Errno::ENOTDIR
+      rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EINVAL
         false
       end
 
@@ -42,6 +62,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]
@@ -59,7 +80,11 @@ module Bootsnap
       end
 
       def expanded_path
-        File.expand_path(path)
+        if @real
+          path
+        else
+          @expanded_path ||= File.expand_path(path).freeze
+        end
       end
 
       private
@@ -76,7 +101,7 @@ module Bootsnap
         ["", *dirs].each do |dir|
           curr = begin
             File.mtime("#{path}/#{dir}").to_i
-                 rescue Errno::ENOENT, Errno::ENOTDIR
+                 rescue Errno::ENOENT, Errno::ENOTDIR, Errno::EINVAL
                    -1
           end
           max = curr if curr > max
@@ -91,21 +116,19 @@ module Bootsnap
       VOLATILE = :volatile
 
       # 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']
+      # installed into sitedir, which generally lives under rubylibdir.
+      RUBY_LIBDIR  = RbConfig::CONFIG["rubylibdir"]
+      RUBY_SITEDIR = RbConfig::CONFIG["sitedir"]
 
       def stability
-        @stability ||= begin
-          if Gem.path.detect { |p| expanded_path.start_with?(p.to_s) }
-            STABLE
-          elsif Bootsnap.bundler? && expanded_path.start_with?(Bundler.bundle_path.to_s)
-            STABLE
-          elsif expanded_path.start_with?(RUBY_LIBDIR) && !expanded_path.start_with?(RUBY_SITEDIR)
-            STABLE
-          else
-            VOLATILE
-          end
+        @stability ||= if Gem.path.detect { |p| expanded_path.start_with?(p.to_s) }
+          STABLE
+        elsif Bootsnap.bundler? && expanded_path.start_with?(Bundler.bundle_path.to_s)
+          STABLE
+        elsif expanded_path.start_with?(RUBY_LIBDIR) && !expanded_path.start_with?(RUBY_SITEDIR)
+          STABLE
+        else
+          VOLATILE
         end
       end
     end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -1,49 +1,80 @@
 # frozen_string_literal: true
 
-require_relative('../explicit_require')
+require_relative "../explicit_require"
 
 module Bootsnap
   module LoadPathCache
     module PathScanner
-      ALL_FILES = "/{,**/*/**/}*"
       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
 
-      def self.call(path)
-        path = path.to_s
-
-        relative_slice = (path.size + 1)..-1
-        # If the bundle path is a descendent of this path, we do additional
-        # checks to prevent recursing into the bundle path as we recurse
-        # through this path. We don't want to scan the bundle path because
-        # anything useful in it will be present on other load path items.
-        #
-        # This can happen if, for example, the user adds '.' to the load path,
-        # and the bundle path is '.bundle'.
-        contains_bundle_path = BUNDLE_PATH.start_with?(path)
-
-        dirs = []
-        requirables = []
-
-        Dir.glob(path + ALL_FILES).each do |absolute_path|
-          next if contains_bundle_path && absolute_path.start_with?(BUNDLE_PATH)
-          relative_path = absolute_path.slice(relative_slice)
-
-          if File.directory?(absolute_path)
-            dirs << relative_path
-          elsif REQUIRABLE_EXTENSIONS.include?(File.extname(relative_path))
-            requirables << relative_path
+      @ignored_directories = %w(node_modules)
+
+      class << self
+        attr_accessor :ignored_directories
+
+        def call(path)
+          path = File.expand_path(path.to_s).freeze
+          return [[], []] unless File.directory?(path)
+
+          # If the bundle path is a descendent of this path, we do additional
+          # checks to prevent recursing into the bundle path as we recurse
+          # through this path. We don't want to scan the bundle path because
+          # anything useful in it will be present on other load path items.
+          #
+          # This can happen if, for example, the user adds '.' to the load path,
+          # and the bundle path is '.bundle'.
+          contains_bundle_path = BUNDLE_PATH.start_with?(path)
+
+          dirs = []
+          requirables = []
+          walk(path, nil) do |relative_path, absolute_path, is_directory|
+            if is_directory
+              dirs << os_path(relative_path)
+              !contains_bundle_path || !absolute_path.start_with?(BUNDLE_PATH)
+            elsif relative_path.end_with?(*REQUIRABLE_EXTENSIONS)
+              requirables << os_path(relative_path)
+            end
           end
+          [requirables, dirs]
         end
 
-        [requirables, dirs]
+        def walk(absolute_dir_path, relative_dir_path, &block)
+          Dir.foreach(absolute_dir_path) do |name|
+            next if name.start_with?(".")
+
+            relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
+
+            absolute_path = "#{absolute_dir_path}/#{name}"
+            if File.directory?(absolute_path)
+              next if ignored_directories.include?(name) || ignored_directories.include?(absolute_path)
+
+              if yield relative_path, absolute_path, true
+                walk(absolute_path, relative_path, &block)
+              end
+            else
+              yield relative_path, absolute_path, false
+            end
+          end
+        end
+
+        if RUBY_VERSION >= "3.1"
+          def os_path(path)
+            path.freeze
+          end
+        else
+          def os_path(path)
+            path.force_encoding(Encoding::US_ASCII) if path.ascii_only?
+            path.freeze
+          end
+        end
       end
     end
   end