bootsnap 1.1.8-java → 1.5.0-java

data/lib/bootsnap/explicit_require.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module ExplicitRequire
     ARCHDIR    = RbConfig::CONFIG['archdir']
@@ -5,7 +6,7 @@ module Bootsnap
     DLEXT      = RbConfig::CONFIG['DLEXT']
 
     def self.from_self(feature)
-      require_relative "../#{feature}"
+      require_relative("../#{feature}")
     end
 
     def self.from_rubylibdir(feature)

data/lib/bootsnap/load_path_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     ReturnFalse = Class.new(StandardError)
@@ -7,6 +9,11 @@ module Bootsnap
     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? }
@@ -21,32 +28,51 @@ 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)
+        unless supported?
+          warn("[bootsnap/setup] Load path caching is not supported on this implementation of Ruby") if $VERBOSE
+          return
+        end
+
         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'
+        require_relative('load_path_cache/core_ext/kernel_require')
+        require_relative('load_path_cache/core_ext/loaded_features')
 
         if active_support
           # this should happen after setting up the initial cache because it
           # loads a lot of code. It's better to do after +require+ is optimized.
-          require 'active_support/dependencies'
+          require('active_support/dependencies')
           @autoload_paths_cache = Cache.new(
             store,
             ::ActiveSupport::Dependencies.autoload_paths,
             development_mode: development_mode
           )
-          require_relative 'load_path_cache/core_ext/active_support'
+          require_relative('load_path_cache/core_ext/active_support')
         end
       end
+
+      def supported?
+        RUBY_ENGINE == 'ruby' &&
+        RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/
+      end
     end
   end
 end
 
-require_relative 'load_path_cache/path_scanner'
-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'
+if Bootsnap::LoadPathCache.supported?
+  require_relative('load_path_cache/path_scanner')
+  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')
+end

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,4 +1,6 @@
-require_relative '../explicit_require'
+# frozen_string_literal: true
+
+require_relative('../explicit_require')
 
 module Bootsnap
   module LoadPathCache
@@ -9,15 +11,15 @@ module Bootsnap
         @development_mode = development_mode
         @store = store
         @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
-        @path_obj = path_obj
+        @path_obj = path_obj.map! { |f| File.exist?(f) ? File.realpath(f) : f }
         @has_relative_paths = nil
         reinitialize
       end
 
-      # Does this directory exist as a child of one of the path items?
-      # e.g. given "/a/b/c/d" exists, and the path is ["/a/b"], has_dir?("c/d")
-      # is true.
-      def has_dir?(dir)
+      # What is the path item that contains the dir as child?
+      # e.g. given "/a/b/c/d" exists, and the path is ["/a/b"], load_dir("c/d")
+      # is "/a/b".
+      def load_dir(dir)
         reinitialize if stale?
         @mutex.synchronize { @dirs[dir] }
       end
@@ -44,9 +46,9 @@ module Bootsnap
       # loadpath.
       def find(feature)
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
-        feature = feature.to_s
+        feature = feature.to_s.freeze
         return feature if absolute_path?(feature)
-        return File.expand_path(feature) if feature.start_with?('./')
+        return expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
           x = search_index(feature)
           return x if x
@@ -56,7 +58,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)
+          raise(LoadPathCache::ReturnFalse, '', []) 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.
@@ -65,7 +67,7 @@ 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 # rubocop:disable Performance/CaseWhenSplat
+          when '', *CACHED_EXTENSIONS
             nil
           # Ruby allows specifying native extensions as '.so' even when DLEXT
           # is '.bundle'. This is where we handle that case.
@@ -73,14 +75,21 @@ module Bootsnap
             x = search_index(feature[0..-4] + DLEXT)
             return x if x
             if DLEXT2
-              search_index(feature[0..-4] + DLEXT2)
+              x = search_index(feature[0..-4] + DLEXT2)
+              return x if x
             end
           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
+            raise(LoadPathCache::FallbackScan, '', [])
           end
         end
+
+        # In development mode, we don't want to confidently return failures for
+        # 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/
@@ -103,20 +112,12 @@ module Bootsnap
         @mutex.synchronize { push_paths_locked(*paths) }
       end
 
-      def each_requirable
-        @mutex.synchronize do
-          @index.each do |rel, entry|
-            yield "#{entry}/#{rel}"
-          end
-        end
-      end
-
       def reinitialize(path_obj = @path_obj)
         @mutex.synchronize do
           @path_obj = path_obj
           ChangeObserver.register(self, @path_obj)
           @index = {}
-          @dirs = Hash.new(false)
+          @dirs = {}
           @generated_at = now
           push_paths_locked(*@path_obj)
         end
@@ -140,10 +141,11 @@ 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
-            dirs.each    { |dir| @dirs[dir]  ||= true }
-            entries.each { |rel| @index[rel] ||= p.expanded_path }
+            dirs.each    { |dir| @dirs[dir] ||= path }
+            entries.each { |rel| @index[rel] ||= expanded_path }
           end
         end
       end
@@ -153,14 +155,19 @@ 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
-            dirs.each    { |dir| @dirs[dir]  = true }
-            entries.each { |rel| @index[rel] = p.expanded_path }
+            dirs.each    { |dir| @dirs[dir]  = path }
+            entries.each { |rel| @index[rel] = expanded_path }
           end
         end
       end
 
+      def expand_path(feature)
+        maybe_append_extension(File.expand_path(feature))
+      end
+
       def stale?
         @development_mode && @generated_at + AGE_THRESHOLD < now
       end
@@ -171,19 +178,31 @@ module Bootsnap
 
       if DLEXT2
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index("#{f}#{DLEXT2}") || try_index(f)
+        end
+
+        def maybe_append_extension(f)
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || try_ext("#{f}#{DLEXT2}") || f
         end
       else
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index(f)
+        end
+
+        def maybe_append_extension(f)
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || f
         end
       end
 
       def try_index(f)
-        if p = @index[f]
-          p + '/' + f
+        if (p = @index[f])
+          "#{p}/#{f}"
         end
       end
+
+      def try_ext(f)
+        f if File.exist?(f)
+      end
     end
   end
 end

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/active_support.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module LoadPathCache
     module CoreExt
@@ -10,6 +11,14 @@ module Bootsnap
           Thread.current[:without_bootsnap_cache] = prev
         end
 
+        def self.allow_bootsnap_retry(allowed)
+          prev = Thread.current[:without_bootsnap_retry] || false
+          Thread.current[:without_bootsnap_retry] = !allowed
+          yield
+        ensure
+          Thread.current[:without_bootsnap_retry] = prev
+        end
+
         module ClassMethods
           def autoload_paths=(o)
             super
@@ -22,17 +31,25 @@ module Bootsnap
               Bootsnap::LoadPathCache.autoload_paths_cache.find(path)
             rescue Bootsnap::LoadPathCache::ReturnFalse
               nil # doesn't really apply here
+            rescue Bootsnap::LoadPathCache::FallbackScan
+              nil # doesn't really apply here
             end
           end
 
           def autoloadable_module?(path_suffix)
-            Bootsnap::LoadPathCache.autoload_paths_cache.has_dir?(path_suffix)
+            Bootsnap::LoadPathCache.autoload_paths_cache.load_dir(path_suffix)
           end
 
           def remove_constant(const)
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
 
+          def require_or_load(*)
+            CoreExt::ActiveSupport.allow_bootsnap_retry(true) do
+              super
+            end
+          end
+
           # If we can't find a constant using the patched implementation of
           # search_for_file, try again with the default implementation.
           #
@@ -40,16 +57,26 @@ 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)
-            super
+            CoreExt::ActiveSupport.allow_bootsnap_retry(false) do
+              super
+            end
           rescue NameError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
+            # This function can end up called recursively, we only want to
+            # retry at the top-level.
+            raise(e) if Thread.current[:without_bootsnap_retry]
+            # If we already had cache disabled, there's no use retrying
+            raise(e) if Thread.current[:without_bootsnap_cache]
             # NoMethodError is a NameError, but we only want to handle actual
             # NameError instances.
-            raise unless e.class == NameError
+            raise(e) 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
+            raise(e) unless e.name == const_name
             # If the constant was actually loaded, something else went wrong?
-            raise if from_mod.const_defined?(const_name)
+            raise(e) if from_mod.const_defined?(const_name)
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
 
@@ -57,7 +84,12 @@ module Bootsnap
           # reiterate it with version polymorphism here...
           def depend_on(*)
             super
-          rescue LoadError
+          rescue LoadError => e
+            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
+            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
+
+            # If we already had cache disabled, there's no use retrying
+            raise(e) if Thread.current[:without_bootsnap_cache]
             CoreExt::ActiveSupport.without_bootsnap_cache { super }
           end
         end
@@ -69,7 +101,7 @@ end
 module ActiveSupport
   module Dependencies
     class << self
-      prepend Bootsnap::LoadPathCache::CoreExt::ActiveSupport::ClassMethods
+      prepend(Bootsnap::LoadPathCache::CoreExt::ActiveSupport::ClassMethods)
     end
   end
 end