ed-precompiled_bootsnap 1.18.6-x64-mingw-ucrt

data/lib/bootsnap/load_path_cache/cache.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require_relative "../explicit_require"
+
+module Bootsnap
+  module LoadPathCache
+    class Cache
+      AGE_THRESHOLD = 30 # seconds
+
+      def initialize(store, path_obj, development_mode: false)
+        @development_mode = development_mode
+        @store = store
+        @mutex = Mutex.new
+        @path_obj = path_obj.map! { |f| PathScanner.os_path(File.exist?(f) ? File.realpath(f) : f.dup) }
+        @has_relative_paths = nil
+        reinitialize
+      end
+
+      # 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
+
+      TRUFFLERUBY_LIB_DIR_PREFIX = if RUBY_ENGINE == "truffleruby"
+        "#{File.join(RbConfig::CONFIG['libdir'], 'truffle')}#{File::SEPARATOR}"
+      end
+
+      # { 'enumerator' => nil, 'enumerator.so' => nil, ... }
+      BUILTIN_FEATURES = $LOADED_FEATURES.each_with_object({}) do |feat, features|
+        if TRUFFLERUBY_LIB_DIR_PREFIX && feat.start_with?(TRUFFLERUBY_LIB_DIR_PREFIX)
+          feat = feat.byteslice(TRUFFLERUBY_LIB_DIR_PREFIX.bytesize..-1)
+        end
+
+        # Builtin features are of the form 'enumerator.so'.
+        # All others include paths.
+        next unless feat.size < 20 && !feat.include?("/")
+
+        base = File.basename(feat, ".*") # enumerator.so -> enumerator
+        ext  = File.extname(feat) # .so
+
+        features[feat] = nil # enumerator.so
+        features[base] = nil # enumerator
+
+        next unless [DOT_SO, *DL_EXTENSIONS].include?(ext)
+
+        DL_EXTENSIONS.each do |dl_ext|
+          features["#{base}#{dl_ext}"] = nil # enumerator.bundle
+        end
+      end.freeze
+
+      # Try to resolve this feature to an absolute path without traversing the
+      # loadpath.
+      def find(feature)
+        reinitialize if (@has_relative_paths && dir_changed?) || stale?
+        feature = feature.to_s.freeze
+
+        return feature if Bootsnap.absolute_path?(feature)
+
+        if feature.start_with?("./", "../")
+          return expand_path(feature)
+        end
+
+        @mutex.synchronize do
+          x = search_index(feature)
+          return x if x
+
+          # Ruby has some built-in features that require lies about.
+          # For example, 'enumerator' is built in. If you require it, ruby
+          # 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.
+          return false 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.
+          case File.extname(feature)
+          # 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.
+          # no extension, .rb, (.bundle or .so)
+          when "", *CACHED_EXTENSIONS
+            nil
+          # Ruby allows specifying native extensions as '.so' even when DLEXT
+          # is '.bundle'. This is where we handle that case.
+          when DOT_SO
+            x = search_index(feature[0..-4] + DLEXT)
+            return x if x
+
+            if 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.
+            return FALLBACK_SCAN
+          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.
+        return FALLBACK_SCAN if @development_mode
+      end
+
+      def unshift_paths(sender, *paths)
+        return unless sender == @path_obj
+
+        @mutex.synchronize { unshift_paths_locked(*paths) }
+      end
+
+      def push_paths(sender, *paths)
+        return unless sender == @path_obj
+
+        @mutex.synchronize { push_paths_locked(*paths) }
+      end
+
+      def reinitialize(path_obj = @path_obj)
+        @mutex.synchronize do
+          @path_obj = path_obj
+          ChangeObserver.register(@path_obj, self)
+          @index = {}
+          @dirs = {}
+          @generated_at = now
+          push_paths_locked(*@path_obj)
+        end
+      end
+
+      private
+
+      def dir_changed?
+        @prev_dir ||= Dir.pwd
+        if @prev_dir == Dir.pwd
+          false
+        else
+          @prev_dir = Dir.pwd
+          true
+        end
+      end
+
+      def push_paths_locked(*paths)
+        @store.transaction do
+          paths.map(&:to_s).each do |path|
+            p = Path.new(path)
+            @has_relative_paths = true if p.relative?
+            next if p.non_directory?
+
+            p = p.to_realpath
+
+            expanded_path = p.expanded_path
+            entries, dirs = p.entries_and_dirs(@store)
+            # push -> low precedence -> set only if unset
+            dirs.each    { |dir| @dirs[dir] ||= path }
+            entries.each { |rel| @index[rel] ||= expanded_path }
+          end
+        end
+      end
+
+      def unshift_paths_locked(*paths)
+        @store.transaction do
+          paths.map(&:to_s).reverse_each do |path|
+            p = Path.new(path)
+            next if p.non_directory?
+
+            p = p.to_realpath
+
+            expanded_path = p.expanded_path
+            entries, dirs = p.entries_and_dirs(@store)
+            # unshift -> high precedence -> unconditional set
+            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
+
+      def now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC).to_i
+      end
+
+      if DLEXT2
+        def search_index(feature)
+          try_index(feature + DOT_RB) ||
+            try_index(feature + DLEXT) ||
+            try_index(feature + DLEXT2) ||
+            try_index(feature)
+        end
+
+        def maybe_append_extension(feature)
+          try_ext(feature + DOT_RB) ||
+            try_ext(feature + DLEXT) ||
+            try_ext(feature + DLEXT2) ||
+            feature
+        end
+      else
+        def search_index(feature)
+          try_index(feature + DOT_RB) || try_index(feature + DLEXT) || try_index(feature)
+        end
+
+        def maybe_append_extension(feature)
+          try_ext(feature + DOT_RB) || try_ext(feature + DLEXT) || feature
+        end
+      end
+
+      s = rand.to_s.force_encoding(Encoding::US_ASCII).freeze
+      if s.respond_to?(:-@)
+        if ((-s).equal?(s) && (-s.dup).equal?(s)) || RUBY_VERSION >= "2.7"
+          def try_index(feature)
+            if (path = @index[feature])
+              -File.join(path, feature).freeze
+            end
+          end
+        else
+          def try_index(feature)
+            if (path = @index[feature])
+              -File.join(path, feature).untaint
+            end
+          end
+        end
+      else
+        def try_index(feature)
+          if (path = @index[feature])
+            File.join(path, feature)
+          end
+        end
+      end
+
+      def try_ext(feature)
+        feature if File.exist?(feature)
+      end
+    end
+  end
+end

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  module LoadPathCache
+    module ChangeObserver
+      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.
+        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
+        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 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
+        # 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(
+          []= 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
+
+        def dup
+          [] + self
+        end
+
+        alias_method :clone, :dup
+      end
+
+      def self.register(arr, observer)
+        return if arr.frozen? # can't register observer, but no need to.
+
+        arr.instance_variable_set(:@lpc_observer, observer)
+        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
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Kernel
+  alias_method :require_without_bootsnap, :require
+
+  alias_method :require, :require # Avoid method redefinition warnings
+
+  def require(path) # rubocop:disable Lint/DuplicateMethods
+    return require_without_bootsnap(path) unless Bootsnap::LoadPathCache.enabled?
+
+    string_path = Bootsnap.rb_get_path(path)
+    return false if Bootsnap::LoadPathCache.loaded_features_index.key?(string_path)
+
+    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
+  end
+
+  private :require
+end

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

@@ -0,0 +1,19 @@
+# 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,159 @@
+# 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)..]
+            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.each_with_object({}) { |f, h| h[f.hash] = true }
+        @mutex.synchronize do
+          @lfi.reject! { |_, hash| rejected_hashes.key?(hash) }
+        end
+      end
+
+      def key?(feature)
+        @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
+      # `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.
+      #
+      # 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)
+        return if Bootsnap.absolute_path?(short)
+
+        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
+      end
+
+      private
+
+      STRIP_EXTENSION = /\.[^.]*?$/.freeze
+      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://docs.ruby-lang.org/en/master/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
+end

data/lib/bootsnap/load_path_cache/path.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+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, 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, Errno::EINVAL
+        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
+        if @real
+          path
+        else
+          @expanded_path ||= File.expand_path(path).freeze
+        end
+      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, Errno::ENOTDIR, Errno::EINVAL
+                   -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 rubylibdir.
+      RUBY_LIBDIR  = RbConfig::CONFIG["rubylibdir"]
+      RUBY_SITEDIR = RbConfig::CONFIG["sitedir"]
+
+      def stability
+        @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
+  end
+end