bootsnap 1.1.1 → 1.3.0

data/lib/bootsnap.rb

@@ -1,4 +1,5 @@
 require_relative 'bootsnap/version'
+require_relative 'bootsnap/bundler'
 require_relative 'bootsnap/load_path_cache'
 require_relative 'bootsnap/compile_cache'
 

data/lib/bootsnap/bundler.rb

@@ -0,0 +1,12 @@
+module Bootsnap
+  module_function
+
+  def bundler?
+    # Bundler environment variable
+    ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+      return true if ENV.key?(current)
+    end
+    
+    false
+  end
+end

data/lib/bootsnap/compile_cache/iseq.rb

@@ -68,4 +68,3 @@ module Bootsnap
     end
   end
 end
-

data/lib/bootsnap/compile_cache/yaml.rb

@@ -8,6 +8,7 @@ module Bootsnap
       end
 
       def self.input_to_storage(contents, _)
+        raise Uncompilable if contents.index("!ruby/object")
         obj = ::YAML.load(contents)
         msgpack_factory.packer.write(obj).to_s
       rescue NoMethodError, RangeError

data/lib/bootsnap/explicit_require.rb

@@ -36,7 +36,12 @@ module Bootsnap
       end
       $LOAD_PATH << ARCHDIR
       $LOAD_PATH << RUBYLIBDIR
-      yield
+      begin
+        yield
+      rescue LoadError
+        $LOAD_PATH.replace(orig)
+        yield
+      end
     ensure
       $LOAD_PATH.replace(orig)
     end

data/lib/bootsnap/load_path_cache.rb

@@ -21,11 +21,15 @@ module Bootsnap
     CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
 
     class << self
-      attr_reader :load_path_cache, :autoload_paths_cache
+      attr_reader :load_path_cache, :autoload_paths_cache,
+                  :loaded_features_index, :realpath_cache
 
       def setup(cache_path:, development_mode:, active_support: true)
         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'
 
@@ -50,3 +54,5 @@ require_relative 'load_path_cache/path'
 require_relative 'load_path_cache/cache'
 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'

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,4 +1,3 @@
-require_relative '../load_path_cache'
 require_relative '../explicit_require'
 
 module Bootsnap
@@ -9,8 +8,9 @@ module Bootsnap
       def initialize(store, path_obj, development_mode: false)
         @development_mode = development_mode
         @store = store
-        @mutex = ::Thread::Mutex.new
-        @path_obj = path_obj
+        @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
+        @path_obj = path_obj.map! { |f| File.exist?(f) ? File.realpath(f) : f }
+        @has_relative_paths = nil
         reinitialize
       end
 
@@ -23,24 +23,21 @@ module Bootsnap
       end
 
       # { 'enumerator' => nil, 'enumerator.so' => nil, ... }
-      BUILTIN_FEATURES = $LOADED_FEATURES.reduce({}) do |acc, feat|
+      BUILTIN_FEATURES = $LOADED_FEATURES.each_with_object({}) do |feat, features|
         # Builtin features are of the form 'enumerator.so'.
         # All others include paths.
-        next acc unless feat.size < 20 && !feat.include?('/')
+        next unless feat.size < 20 && !feat.include?('/')
 
         base = File.basename(feat, '.*') # enumerator.so -> enumerator
         ext  = File.extname(feat) # .so
 
-        acc[feat] = nil # enumerator.so
-        acc[base] = nil # enumerator
+        features[feat] = nil # enumerator.so
+        features[base] = nil # enumerator
 
-        if [DOT_SO, *DL_EXTENSIONS].include?(ext)
-          DL_EXTENSIONS.each do |ext|
-            acc["#{base}#{ext}"] = nil # enumerator.bundle
-          end
+        next unless [DOT_SO, *DL_EXTENSIONS].include?(ext)
+        DL_EXTENSIONS.each do |dl_ext|
+          features["#{base}#{dl_ext}"] = nil # enumerator.bundle
         end
-
-        acc
       end.freeze
 
       # Try to resolve this feature to an absolute path without traversing the
@@ -67,7 +64,8 @@ module Bootsnap
           # If the extension was one of the ones we explicitly cache (.rb and the
           # 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.
-          when '', *CACHED_EXTENSIONS # no extension, .rb, (.bundle or .so)
+          # no extension, .rb, (.bundle or .so)
+          when '', *CACHED_EXTENSIONS # rubocop:disable Performance/CaseWhenSplat
             nil
           # Ruby allows specifying native extensions as '.so' even when DLEXT
           # is '.bundle'. This is where we handle that case.
@@ -152,7 +150,7 @@ module Bootsnap
 
       def unshift_paths_locked(*paths)
         @store.transaction do
-          paths.map(&:to_s).reverse.each do |path|
+          paths.map(&:to_s).reverse_each do |path|
             p = Path.new(path)
             next if p.non_directory?
             entries, dirs = p.entries_and_dirs(@store)

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

@@ -2,15 +2,6 @@ module Bootsnap
   module LoadPathCache
     module CoreExt
       module ActiveSupport
-        def self.with_bootsnap_fallback(error)
-          yield
-        rescue error => e
-          # NoMethodError is a NameError, but we only want to handle actual
-          # NameError instances.
-          raise unless e.class == error
-          without_bootsnap_cache { yield }
-        end
-
         def self.without_bootsnap_cache
           prev = Thread.current[:without_bootsnap_cache] || false
           Thread.current[:without_bootsnap_cache] = true
@@ -21,9 +12,8 @@ module Bootsnap
 
         module ClassMethods
           def autoload_paths=(o)
-            r = super
+            super
             Bootsnap::LoadPathCache.autoload_paths_cache.reinitialize(o)
-            r
           end
 
           def search_for_file(path)
@@ -50,13 +40,25 @@ module Bootsnap
           # behaviour.  The gymnastics here are a bit awkward, but it prevents
           # 200+ lines of monkeypatches.
           def load_missing_constant(from_mod, const_name)
-            CoreExt::ActiveSupport.with_bootsnap_fallback(NameError) { super }
+            super
+          rescue NameError => e
+            # NoMethodError is a NameError, but we only want to handle actual
+            # NameError instances.
+            raise unless e.class == NameError
+            # We can only confidently handle cases when *this* constant fails
+            # to load, not other constants referred to by it.
+            raise unless e.name == const_name
+            # If the constant was actually loaded, something else went wrong?
+            raise if from_mod.const_defined?(const_name)
+            CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
 
           # Signature has changed a few times over the years; easiest to not
           # reiterate it with version polymorphism here...
           def depend_on(*)
-            CoreExt::ActiveSupport.with_bootsnap_fallback(LoadError) { super }
+            super
+          rescue LoadError
+            CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
         end
       end

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

@@ -11,78 +11,122 @@ module Bootsnap
 end
 
 module Kernel
-  alias_method :require_without_cache, :require
+  private
+
+  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)
+
     if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+      return require_with_bootsnap_lfi(path, resolved)
     end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
+    require_with_bootsnap_lfi(path)
   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?(File.expand_path(path))
-        return load_without_cache(relative, wrap)
-      end
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(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))
+      return load_without_bootsnap(relative, wrap)
+    end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
+    load_without_bootsnap(path, wrap)
   end
 end
 
 class << Kernel
-  alias_method :require_without_cache, :require
+  alias_method :require_without_bootsnap, :require
+
+  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)
+
     if resolved = Bootsnap::LoadPathCache.load_path_cache.find(path)
-      require_without_cache(resolved)
-    else
-      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+      return require_with_bootsnap_lfi(path, resolved)
     end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_without_cache(path)
+    require_with_bootsnap_lfi(path)
   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)
+      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))
+      return load_without_bootsnap(relative, wrap)
+    end
+
+    raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
   rescue Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_cache(path, wrap)
+    load_without_bootsnap(path, wrap)
   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 Bootsnap::LoadPathCache::ReturnFalse
     return false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    autoload_without_cache(const, path)
+    autoload_without_bootsnap(const, path)
   end
 end

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -0,0 +1,95 @@
+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 = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
+
+        # 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|
+          $LOAD_PATH.each do |lpe|
+            next unless feat.start_with?(lpe)
+            # /a/b/lib/my/foo.rb
+            #          ^^^^^^^^^
+            short = feat[(lpe.length + 1)..-1]
+            @lfi[short] = true
+            @lfi[strip_extension(short)] = true
+          end
+        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)
+        ret = yield
+
+        # 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'
+          short + ext
+        end
+
+        @mutex.synchronize do
+          @lfi[short] = true
+          (@lfi[altname] = true) if altname
+        end
+
+        ret
+      end
+
+      private
+
+      STRIP_EXTENSION = /\..*?$/
+      private_constant :STRIP_EXTENSION
+
+      def strip_extension(f)
+        f.sub(STRIP_EXTENSION, '')
+      end
+    end
+  end
+end