bootsnap 1.1.8 → 1.7.2

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -1,37 +1,37 @@
+# frozen_string_literal: true
 module Bootsnap
   module LoadPathCache
     module ChangeObserver
-      def self.register(observer, arr)
-        # Re-overriding these methods on an array that already has them would
-        # cause StackOverflowErrors
-        return if arr.respond_to?(:push_without_lpc)
-
+      module ArrayMixin
         # For each method that adds items to one end or another of the array
         # (<<, push, unshift, concat), override that method to also notify the
         # observer of the change.
-        sc = arr.singleton_class
-        sc.send(:alias_method, :shovel_without_lpc, :<<)
-        arr.define_singleton_method(:<<) do |entry|
-          observer.push_paths(self, entry.to_s)
-          shovel_without_lpc(entry)
+        def <<(entry)
+          @lpc_observer.push_paths(self, entry.to_s)
+          super
+        end
+
+        def push(*entries)
+          @lpc_observer.push_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :push_without_lpc, :push)
-        arr.define_singleton_method(:push) do |*entries|
-          observer.push_paths(self, *entries.map(&:to_s))
-          push_without_lpc(*entries)
+        def unshift(*entries)
+          @lpc_observer.unshift_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :unshift_without_lpc, :unshift)
-        arr.define_singleton_method(:unshift) do |*entries|
-          observer.unshift_paths(self, *entries.map(&:to_s))
-          unshift_without_lpc(*entries)
+        def concat(entries)
+          @lpc_observer.push_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :concat_without_lpc, :concat)
-        arr.define_singleton_method(:concat) do |entries|
-          observer.push_paths(self, *entries.map(&:to_s))
-          concat_without_lpc(entries)
+        # uniq! keeps the first occurrence of each path, otherwise preserving
+        # order, preserving the effective load path
+        def uniq!(*args)
+          ret = super
+          @lpc_observer.reinitialize if block_given? || !args.empty?
+          ret
         end
 
         # For each method that modifies the array more aggressively, override
@@ -41,16 +41,23 @@ module Bootsnap
         # accounting cost would be greater than the hit from these, since we
         # actively discourage calling them.
         %i(
-          collect! compact! delete delete_at delete_if fill flatten! insert map!
-          reject! reverse! select! shuffle! shift slice! sort! sort_by!
-        ).each do |meth|
-          sc.send(:alias_method, :"#{meth}_without_lpc", meth)
-          arr.define_singleton_method(meth) do |*a|
-            send(:"#{meth}_without_lpc", *a)
-            observer.reinitialize
+          []= clear collect! compact! delete delete_at delete_if fill flatten!
+          insert keep_if map! pop reject! replace reverse! rotate! select!
+          shift shuffle! slice! sort! sort_by!
+        ).each do |method_name|
+          define_method(method_name) do |*args, &block|
+            ret = super(*args, &block)
+            @lpc_observer.reinitialize
+            ret
           end
         end
       end
+
+      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
     end
   end
 end

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

@@ -1,8 +1,10 @@
+# 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 = 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
@@ -11,78 +13,93 @@ module Bootsnap
 end
 
 module Kernel
-  alias_method :require_without_cache, :require
-  def require(path)
-    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
-    end
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    return false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
-  end
+  module_function # rubocop:disable Style/ModuleFunction
 
-  alias_method :load_without_cache, :load
-  def load(path, wrap = false)
-    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      load_without_cache(resolved, wrap)
-    else
-      # load also allows relative paths from pwd even when not in $:
-      relative = File.expand_path(path)
-      if File.exist?(File.expand_path(path))
-        return load_without_cache(relative, wrap)
-      end
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+  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
-  rescue Bootsnap::LoadPathCache::ReturnFalse
-    return false
-  rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
   end
-end
 
-class << Kernel
-  alias_method :require_without_cache, :require
   def require(path)
-    if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(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
-    return false
+    false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
+    fallback = true
+  ensure
+    if fallback
+      require_with_bootsnap_lfi(path)
+    end
   end
 
-  alias_method :load_without_cache, :load
+  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)
-      load_without_cache(resolved, wrap)
-    else
-      # load also allows relative paths from pwd even when not in $:
-      relative = File.expand_path(path)
-      if File.exist?(relative)
-        return load_without_cache(relative, wrap)
-      end
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    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
-    return false
+    false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
+    fallback = true
+  ensure
+    if fallback
+      load_without_bootsnap(path, wrap)
+    end
   end
 end
 
 class Module
-  alias_method :autoload_without_cache, :autoload
+  alias_method(:autoload_without_bootsnap, :autoload)
   def autoload(const, path)
-    autoload_without_cache(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || 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
-    return false
+    false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    autoload_without_cache(const, path)
+    fallback = true
+  ensure
+    if fallback
+      autoload_without_bootsnap(const, path)
+    end
   end
 end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+class << $LOADED_FEATURES
+  alias_method(:delete_without_bootsnap, :delete)
+  def delete(key)
+    Bootsnap::LoadPathCache.loaded_features_index.purge(key)
+    delete_without_bootsnap(key)
+  end
+
+  alias_method(:reject_without_bootsnap!, :reject!)
+  def reject!(&block)
+    backup = dup
+
+    # FIXME: if no block is passed we'd need to return a decorated iterator
+    reject_without_bootsnap!(&block)
+
+    Bootsnap::LoadPathCache.loaded_features_index.purge_multi(backup - self)
+  end
+end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  module LoadPathCache
+    # LoadedFeaturesIndex partially mirrors an internal structure in ruby that
+    # we can't easily obtain an interface to.
+    #
+    # This works around an issue where, without bootsnap, *ruby* knows that it
+    # has already required a file by its short name (e.g. require 'bundler') if
+    # a new instance of bundler is added to the $LOAD_PATH which resolves to a
+    # different absolute path. This class makes bootsnap smart enough to
+    # realize that it has already loaded 'bundler', and not just
+    # '/path/to/bundler'.
+    #
+    # If you disable LoadedFeaturesIndex, you can see the problem this solves by:
+    #
+    # 1. `require 'a'`
+    # 2. Prepend a new $LOAD_PATH element containing an `a.rb`
+    # 3. `require 'a'`
+    #
+    # Ruby returns false from step 3.
+    # With bootsnap but with no LoadedFeaturesIndex, this loads two different
+    #   `a.rb`s.
+    # With bootsnap and with LoadedFeaturesIndex, this skips the second load,
+    #   returning false like ruby.
+    class LoadedFeaturesIndex
+      def initialize
+        @lfi = {}
+        @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
+        # 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_if_elidable(short)
+            @lfi[short] = hash
+            @lfi[stripped] = hash
+          end
+        end
+      end
+
+      # We've optimized for initialize and register to be fast, and purge to be tolerable.
+      # If access patterns make this not-okay, we can lazy-invert the LFI on
+      # first purge and work from there.
+      def purge(feature)
+        @mutex.synchronize do
+          feat_hash = feature.hash
+          @lfi.reject! { |_, hash| hash == feat_hash }
+        end
+      end
+
+      def purge_multi(features)
+        rejected_hashes = features.map(&:hash).to_set
+        @mutex.synchronize do
+          @lfi.reject! { |_, hash| rejected_hashes.include?(hash) }
+        end
+      end
+
+      def key?(feature)
+        @mutex.synchronize { @lfi.key?(feature) }
+      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
+      # pass `long` (the full expanded absolute path), then we did are not able
+      # to confidently add the `bundler.rb` form to @lfi.
+      #
+      # We could either:
+      #
+      # 1. Just add `bundler.rb`, `bundler.so`, and so on, which is close but
+      #    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
+
+        hash = long.hash
+
+        # 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
+
+        @mutex.synchronize do
+          @lfi[short] = hash
+          (@lfi[altname] = hash) if altname
+        end
+
+        ret
+      end
+
+      private
+
+      STRIP_EXTENSION = /\.[^.]*?$/
+      private_constant(: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?(f)
+        f.to_s.end_with?('.rb', '.so', '.o', '.dll', '.dylib')
+      end
+
+      def strip_extension_if_elidable(f)
+        if extension_elidable?(f)
+          f.sub(STRIP_EXTENSION, '')
+        else
+          f
+        end
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/path.rb

@@ -1,4 +1,5 @@
-require_relative 'path_scanner'
+# frozen_string_literal: true
+require_relative('path_scanner')
 
 module Bootsnap
   module LoadPathCache
@@ -17,16 +18,16 @@ module Bootsnap
         stability == VOLATILE
       end
 
-      attr_reader :path
+      attr_reader(:path)
 
       def initialize(path)
-        @path = path.to_s
+        @path = path.to_s.freeze
       end
 
       # True if the path exists, but represents a non-directory object
       def non_directory?
         !File.stat(path).directory?
-      rescue Errno::ENOENT
+      rescue Errno::ENOENT, Errno::ENOTDIR
         false
       end
 
@@ -59,7 +60,7 @@ module Bootsnap
       end
 
       def expanded_path
-        File.expand_path(path)
+        File.expand_path(path).freeze
       end
 
       private
@@ -76,8 +77,8 @@ module Bootsnap
         ["", *dirs].each do |dir|
           curr = begin
             File.mtime("#{path}/#{dir}").to_i
-          rescue Errno::ENOENT
-            -1
+                 rescue Errno::ENOENT, Errno::ENOTDIR
+                   -1
           end
           max = curr if curr > max
         end