bootsnap 1.1.0-java

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -0,0 +1,56 @@
+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)
+
+        # 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)
+        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)
+        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)
+        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)
+        end
+
+        # For each method that modifies the array more aggressively, override
+        # the method to also have the observer completely reconstruct its state
+        # after the modification. Many of these could be made to modify the
+        # internal state of the LoadPathCache::Cache more efficiently, but the
+        # 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+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
+          yield
+        ensure
+          Thread.current[:without_bootsnap_cache] = prev
+        end
+
+        module ClassMethods
+          def autoload_paths=(o)
+            r = super
+            Bootsnap::LoadPathCache.autoload_paths_cache.reinitialize(o)
+            r
+          end
+
+          def search_for_file(path)
+            return super if Thread.current[:without_bootsnap_cache]
+            begin
+              Bootsnap::LoadPathCache.autoload_paths_cache.find(path)
+            rescue Bootsnap::LoadPathCache::ReturnFalse
+              nil # doesn't really apply here
+            end
+          end
+
+          def autoloadable_module?(path_suffix)
+            Bootsnap::LoadPathCache.autoload_paths_cache.has_dir?(path_suffix)
+          end
+
+          def remove_constant(const)
+            CoreExt::ActiveSupport.without_bootsnap_cache { super }
+          end
+
+          # If we can't find a constant using the patched implementation of
+          # search_for_file, try again with the default implementation.
+          #
+          # These methods call search_for_file, and we want to modify its
+          # 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 }
+          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 }
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveSupport
+  module Dependencies
+    class << self
+      prepend Bootsnap::LoadPathCache::CoreExt::ActiveSupport::ClassMethods
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+module Bootsnap
+  module LoadPathCache
+    module CoreExt
+      def self.make_load_error(path)
+        err = LoadError.new("cannot load such file -- #{path}")
+        err.define_singleton_method(:path) { path }
+        err
+      end
+    end
+  end
+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
+
+  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)
+    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)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    require_without_cache(path)
+  end
+
+  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?(relative)
+        return load_without_cache(relative, wrap)
+      end
+      raise Bootsnap::LoadPathCache::CoreExt.make_load_error(path)
+    end
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    load_without_cache(path, wrap)
+  end
+end
+
+class Module
+  alias_method :autoload_without_cache, :autoload
+  def autoload(const, path)
+    autoload_without_cache(const, Bootsnap::LoadPathCache.load_path_cache.find(path) || path)
+  rescue Bootsnap::LoadPathCache::ReturnFalse
+    return false
+  rescue Bootsnap::LoadPathCache::FallbackScan
+    autoload_without_cache(const, path)
+  end
+end

data/lib/bootsnap/load_path_cache/path.rb

@@ -0,0 +1,113 @@
+require_relative 'path_scanner'
+
+module Bootsnap
+  module LoadPathCache
+    class Path
+      # A path is considered 'stable' if it is part of a Gem.path or the ruby
+      # distribution. When adding or removing files in these paths, the cache
+      # must be cleared before the change will be noticed.
+      def stable?
+        stability == STABLE
+      end
+
+      # A path is considered volatile if it doesn't live under a Gem.path or
+      # the ruby distribution root. These paths are scanned for new additions
+      # more frequently.
+      def volatile?
+        stability == VOLATILE
+      end
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path.to_s
+      end
+
+      # True if the path exists, but represents a non-directory object
+      def non_directory?
+        !File.stat(path).directory?
+      rescue Errno::ENOENT
+        false
+      end
+
+      def relative?
+        !path.start_with?(SLASH)
+      end
+
+      # Return a list of all the requirable files and all of the subdirectories
+      # of this +Path+.
+      def entries_and_dirs(store)
+        if stable?
+          # the cached_mtime field is unused for 'stable' paths, but is
+          # 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]
+        end
+
+        cached_mtime, entries, dirs = store.get(expanded_path)
+
+        current_mtime = latest_mtime(expanded_path, dirs || [])
+        return [[], []]        if current_mtime == -1 # path does not exist
+        return [entries, dirs] if cached_mtime == current_mtime
+
+        entries, dirs = scan!
+        store.set(expanded_path, [current_mtime, entries, dirs])
+        [entries, dirs]
+      end
+
+      def expanded_path
+        File.expand_path(path)
+      end
+
+      private
+
+      def scan! # (expensive) returns [entries, dirs]
+        PathScanner.call(expanded_path)
+      end
+
+      # last time a directory was modified in this subtree. +dirs+ should be a
+      # list of relative paths to directories under +path+. e.g. for /a/b and
+      # /a/b/c, pass ('/a/b', ['c'])
+      def latest_mtime(path, dirs)
+        max = -1
+        ["", *dirs].each do |dir|
+          curr = begin
+            File.mtime("#{path}/#{dir}").to_i
+          rescue Errno::ENOENT
+            -1
+          end
+          max = curr if curr > max
+        end
+        max
+      end
+
+      # a Path can be either stable of volatile, depending on how frequently we
+      # expect its contents may change. Stable paths aren't rescanned nearly as
+      # often.
+      STABLE   = :stable
+      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']
+
+      def stability
+        @stability ||= begin
+          if Gem.path.detect { |p| expanded_path.start_with?(p.to_s) }
+            STABLE
+          elsif 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
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -0,0 +1,42 @@
+require_relative '../load_path_cache'
+
+module Bootsnap
+  module LoadPathCache
+    module PathScanner
+      REQUIRABLES_AND_DIRS = "/**/*{#{DOT_RB},#{DL_EXTENSIONS.join(',')},/}"
+      IS_DIR = %r{(.*)/\z}
+      NORMALIZE_NATIVE_EXTENSIONS = !DL_EXTENSIONS.include?(LoadPathCache::DOT_SO)
+      ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/
+      BUNDLE_PATH = (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
+
+      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 + REQUIRABLES_AND_DIRS).each do |absolute_path|
+          next if contains_bundle_path && absolute_path.start_with?(BUNDLE_PATH)
+          relative_path = absolute_path.slice!(relative_slice)
+
+          if md = relative_path.match(IS_DIR)
+            dirs << md[1]
+          else
+            requirables << relative_path
+          end
+        end
+        [requirables, dirs]
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/store.rb

@@ -0,0 +1,77 @@
+require_relative '../explicit_require'
+
+Bootsnap::ExplicitRequire.with_gems('msgpack') { require 'msgpack' }
+Bootsnap::ExplicitRequire.from_rubylibdir('fileutils')
+
+module Bootsnap
+  module LoadPathCache
+    class Store
+      NestedTransactionError = Class.new(StandardError)
+      SetOutsideTransactionNotAllowed = Class.new(StandardError)
+
+      def initialize(store_path)
+        @store_path = store_path
+        load_data
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def fetch(key)
+        raise SetOutsideTransactionNotAllowed unless @in_txn
+        v = get(key)
+        unless v
+          @dirty = true
+          v = yield
+          @data[key] = v
+        end
+        v
+      end
+
+      def set(key, value)
+        raise SetOutsideTransactionNotAllowed unless @in_txn
+        if value != @data[key]
+          @dirty = true
+          @data[key] = value
+        end
+      end
+
+      def transaction
+        raise NestedTransactionError if @in_txn
+        @in_txn = true
+        yield
+      ensure
+        commit_transaction
+        @in_txn = false
+      end
+
+      private
+
+      def commit_transaction
+        if @dirty
+          dump_data
+          @dirty = false
+        end
+      end
+
+      def load_data
+        @data = begin
+          MessagePack.load(File.binread(@store_path))
+        # handle malformed data due to upgrade incompatability
+        rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
+          {}
+        end
+      end
+
+      def dump_data
+        # Change contents atomically so other processes can't get invalid
+        # caches if they read at an inopportune time.
+        tmp = "#{@store_path}.#{(rand * 100000).to_i}.tmp"
+        FileUtils.mkpath(File.dirname(tmp))
+        File.binwrite(tmp, MessagePack.dump(@data))
+        FileUtils.mv(tmp, @store_path)
+      end
+    end
+  end
+end