bootsnap 1.20.1 → 1.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19e8b61a552b7f3c9bb4425cbbd58581aff5fed55607ca105b84bc414bb2dbed
-  data.tar.gz: c9aed95261640936c810231f33392b909039d8f09b33883f0e9082b0cf7ead9f
+  metadata.gz: 4e0ad269f816c24dc901b6544acb59c5ebd65b22432f39ee69bc3387b9c2b04d
+  data.tar.gz: 700f525d90d4e77421ce83e38f8731981a48cc82a8b9a937c29f661972f78d7f
 SHA512:
-  metadata.gz: 65607260e60599f4d0ed4c30bf43bc2b42a8e22611fcba4f1cd3abb3563a1158556e22cb78e05ba16af5c55b97ecf88d45a63c2a65d9f28082bc0d75ec759174
-  data.tar.gz: 0ac04f4093bddc1457fbd3dc9b14083570c36f6cf0f19ab9ac62f93112944502b32f483e01c11b2c112349ca4c2811480a12e3112ed2ddbe8cb0e4f35977928a
+  metadata.gz: f5859d7fd4b81f1969c55e12b33a957b34b1dc2825d03bc3f7ab60a57d34153cbcdda7a60626ea758fd66877b1b74a58d17b276aa2055f41086488d6ced5317b
+  data.tar.gz: c09f2cd48da0ba3bb5e9d3c995ffb86b8b16aec987c311162fc79ca648a66f355e4051d6ae4c5ee486d5ad2d2bc3af32090e15776e1f45129c1ea8c8e6c811ed

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Unreleased
 
+# 1.23.0
+
+* Require Ruby 2.7.
+* Fix support for absolute paths in `BOOTSNAP_IGNORE_DIRECTORIES`.
+
+# 1.22.0
+
+* Better fix for the `opendir` crash.
+* Add `bootsnap/rake` for cleaning the bootsnap cache as part of `rake clobber`.
+
+# 1.21.1
+
+* Prevent a Ruby crash while scanning load path if `opendir` fails without setting `errno`.
+  According to the C spec this should not happen, but according to user reports, it did.
+
+# 1.21.0
+
+* Fix the `require` decorator to handle `Bootsnap.unload_cache!` being called.
+* Minor optimization: Eagerly clear cache buffers to appease the GC.
+
 # 1.20.1
 
 * Handle broken symlinks in load path scanning code.

data/ext/bootsnap/bootsnap.c

@@ -21,6 +21,10 @@
 #include <sys/stat.h>
 #include <dirent.h>
 
+#ifndef RBIMPL_ATTR_NORETURN
+#define RBIMPL_ATTR_NORETURN()
+#endif
+
 #ifdef __APPLE__
   // The symbol is present, however not in the headers
   // See: https://github.com/rails/bootsnap/issues/470
@@ -152,22 +156,37 @@ bs_rb_get_path(VALUE self, VALUE fname)
 }
 
 #ifdef HAVE_FSTATAT
+
+RBIMPL_ATTR_NORETURN()
+static void
+bs_syserr_fail_path(const char *func_name, int n, VALUE path)
+{
+    rb_syserr_fail_str(n, rb_sprintf("%s @ %s", func_name, RSTRING_PTR(path)));
+}
+
+RBIMPL_ATTR_NORETURN()
+static void
+bs_syserr_fail_dir_entry(const char *func_name, int n, VALUE dir, const char *d_name)
+{
+    rb_syserr_fail_str(n, rb_sprintf("%s @ %s/%s", func_name, RSTRING_PTR(dir), d_name));
+}
+
 static VALUE
 bs_rb_scan_dir(VALUE self, VALUE abspath)
 {
     Check_Type(abspath, T_STRING);
 
-    DIR *dirp = opendir(RSTRING_PTR(abspath));
-
     VALUE dirs = rb_ary_new();
     VALUE requirables = rb_ary_new();
     VALUE result = rb_ary_new_from_args(2, requirables, dirs);
 
+    DIR *dirp = opendir(RSTRING_PTR(abspath));
     if (dirp == NULL) {
         if (errno == ENOTDIR || errno == ENOENT) {
             return result;
         }
-        rb_sys_fail("opendir");
+
+        bs_syserr_fail_path("opendir", errno, abspath);
         return Qundef;
     }
 
@@ -175,8 +194,12 @@ bs_rb_scan_dir(VALUE self, VALUE abspath)
     struct stat st;
     int dfd = -1;
 
-    errno = 0;
-    while ((entry = readdir(dirp))) {
+    while (1) {
+        errno = 0;
+
+        entry = readdir(dirp);
+        if (entry == NULL) break;
+
         if (entry->d_name[0] == '.') continue;
 
         if (RB_UNLIKELY(entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK)) {
@@ -185,17 +208,19 @@ bs_rb_scan_dir(VALUE self, VALUE abspath)
             if (dfd < 0) {
                 dfd = dirfd(dirp);
                 if (dfd < 0) {
-                    rb_sys_fail("dirfd");
+                    int err = errno;
+                    closedir(dirp);
+                    bs_syserr_fail_path("dirfd", err, abspath);
                     return Qundef;
                 }
             }
 
             if (fstatat(dfd, entry->d_name, &st, 0)) {
-                if (errno == ENOENT) {
-                    // Broken symlinK
-                    continue;
-                }
-                rb_sys_fail("fstatat");
+                if (errno == ENOENT) continue; // Broken symlink
+
+                int err = errno;
+                closedir(dirp);
+                bs_syserr_fail_dir_entry("fstatat", err, abspath, entry->d_name);
                 return Qundef;
             }
 
@@ -225,10 +250,15 @@ bs_rb_scan_dir(VALUE self, VALUE abspath)
         }
     }
 
-    if (closedir(dirp)) {
-        rb_sys_fail("closedir");
+    if (errno) {
+      int err = errno;
+      closedir(dirp);
+      bs_syserr_fail_path("readdir", err, abspath);
+    } else if (closedir(dirp)) {
+        bs_syserr_fail_path("closedir", errno, abspath);
         return Qundef;
     }
+
     return result;
 }
 #endif

data/lib/bootsnap/compile_cache/iseq.rb

@@ -50,7 +50,9 @@ module Bootsnap
       end
 
       def self.storage_to_output(binary, _args)
-        RubyVM::InstructionSequence.load_from_binary(binary)
+        iseq = RubyVM::InstructionSequence.load_from_binary(binary)
+        binary.clear
+        iseq
       rescue RuntimeError => error
         if error.message == "broken binary format"
           $stderr.puts("[Bootsnap::CompileCache] warning: rejecting broken binary")
@@ -95,7 +97,7 @@ module Bootsnap
         end
 
         def compile_option=(hash)
-          super(hash)
+          super
           Bootsnap::CompileCache::ISeq.compile_option_updated
         end
       end

data/lib/bootsnap/compile_cache/yaml.rb

@@ -170,7 +170,9 @@ module Bootsnap
             unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
             unpacker.feed(data)
             _safe_loaded = unpacker.unpack
-            unpacker.unpack
+            result = unpacker.unpack
+            data.clear
+            result
           end
 
           def input_to_output(data, kwargs)

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

@@ -5,7 +5,7 @@ module Kernel
 
   alias_method :require, :require # Avoid method redefinition warnings
 
-  def require(path) # rubocop:disable Lint/DuplicateMethods
+  def require(path)
     return require_without_bootsnap(path) unless Bootsnap::LoadPathCache.enabled?
 
     string_path = Bootsnap.rb_get_path(path)
@@ -15,8 +15,11 @@ module Kernel
     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)
+
+        # The file we required may have unloaded the cache
+        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)
@@ -28,7 +31,9 @@ module Kernel
     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)
+
+      # The file we required may have unloaded the cache
+      Bootsnap::LoadPathCache.loaded_features_index&.register(string_path, resolved)
       return ret
     end
   end

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -18,21 +18,12 @@ module Bootsnap
       class << self
         attr_accessor :ignored_directories
 
-        def ruby_call(path)
-          path = File.expand_path(path.to_s).freeze
-          return [] unless File.directory?(path)
-
-          # 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)
+        def ruby_call(root_path)
+          root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names = prepare_scan(root_path)
+          return [] unless File.directory?(root_path)
 
           requirables = []
-          walk(path, nil) do |relative_path, absolute_path, is_directory|
+          walk(root_path, nil, ignored_abs_paths, ignored_dir_names) do |relative_path, absolute_path, is_directory|
             if is_directory
               !contains_bundle_path || !absolute_path.start_with?(BUNDLE_PATH)
             elsif relative_path.end_with?(*REQUIRABLE_EXTENSIONS)
@@ -42,25 +33,6 @@ module Bootsnap
           requirables
         end
 
-        def walk(absolute_dir_path, relative_dir_path, &block)
-          Dir.foreach(absolute_dir_path) do |name|
-            next if name.start_with?(".")
-
-            relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
-
-            absolute_path = "#{absolute_dir_path}/#{name}"
-            if File.directory?(absolute_path)
-              next if ignored_directories.include?(name) || ignored_directories.include?(absolute_path)
-
-              if yield relative_path, absolute_path, true
-                walk(absolute_path, relative_path, &block)
-              end
-            else
-              yield relative_path, absolute_path, false
-            end
-          end
-        end
-
         if RUBY_ENGINE == "ruby" && RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
           require "bootsnap/bootsnap"
         end
@@ -69,33 +41,35 @@ module Bootsnap
           def native_call(root_path)
             # NOTE: if https://bugs.ruby-lang.org/issues/21800 is accepted we should be able
             # to have similar performance with pure Ruby
-
-            # 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?(root_path)
+            root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names = prepare_scan(root_path)
 
             all_requirables, queue = Native.scan_dir(root_path)
             all_requirables.each(&:freeze)
 
             queue.reject! do |dir|
-              ignored_directories.include?(dir) ||
-                (contains_bundle_path && dir.start_with?(BUNDLE_PATH))
+              if ignored_dir_names&.include?(dir)
+                true
+              elsif ignored_abs_paths || contains_bundle_path
+                absolute_dir = File.join(root_path, dir)
+                ignored_abs_paths&.include?(absolute_dir) ||
+                  (contains_bundle_path && absolute_dir.start_with?(BUNDLE_PATH))
+              end
             end
 
-            while (path = queue.pop)
-              requirables, dirs = Native.scan_dir(File.join(root_path, path))
-              dirs.reject! { |dir| ignored_directories.include?(dir) }
-              dirs.map! { |f| File.join(path, f).freeze }
-              requirables.map! { |f| File.join(path, f).freeze }
-
-              if contains_bundle_path
-                dirs.reject! { |dir| dir.start_with?(BUNDLE_PATH) }
+            while (relative_path = queue.pop)
+              absolute_base = File.join(root_path, relative_path)
+              requirables, dirs = Native.scan_dir(absolute_base)
+              dirs.reject! do |dir|
+                if ignored_dir_names&.include?(dir)
+                  true
+                elsif ignored_abs_paths || contains_bundle_path
+                  absolute_dir = File.join(absolute_base, dir)
+                  ignored_abs_paths&.include?(absolute_dir) ||
+                    (contains_bundle_path && absolute_dir.start_with?(BUNDLE_PATH))
+                end
               end
+              dirs.map! { |f| File.join(relative_path, f).freeze }
+              requirables.map! { |f| File.join(relative_path, f).freeze }
 
               all_requirables.concat(requirables)
               queue.concat(dirs)
@@ -107,6 +81,46 @@ module Bootsnap
         else
           alias_method :call, :ruby_call
         end
+
+        private
+
+        def prepare_scan(root_path)
+          root_path = File.expand_path(root_path.to_s).freeze
+
+          # 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?(root_path)
+
+          ignored_abs_paths, ignored_dir_names = ignored_directories.partition { |p| File.absolute_path?(p) }
+          ignored_abs_paths = nil if ignored_abs_paths.empty?
+          ignored_dir_names = nil if ignored_dir_names.empty?
+
+          [root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names]
+        end
+
+        def walk(absolute_dir_path, relative_dir_path, ignored_abs_paths, ignored_dir_names, &block)
+          Dir.foreach(absolute_dir_path) do |name|
+            next if name.start_with?(".")
+
+            relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
+
+            absolute_path = File.join(absolute_dir_path, name)
+            if File.directory?(absolute_path)
+              next if ignored_dir_names&.include?(name) || ignored_abs_paths&.include?(absolute_path)
+
+              if yield relative_path, absolute_path, true
+                walk(absolute_path, relative_path, ignored_abs_paths, ignored_dir_names, &block)
+              end
+            else
+              yield relative_path, absolute_path, false
+            end
+          end
+        end
       end
     end
   end

data/lib/bootsnap/rake.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bootsnap"
+require "rake/clean"
+
+# Typically, should have been set up prior to requiring rake integration.
+# But allow for a streamlined ::default_setup
+require "bootsnap/setup" if Bootsnap.cache_dir.nil?
+
+if Bootsnap.cache_dir
+  CLEAN.include Bootsnap.cache_dir
+else
+  abort "Bootsnap must be set-up prior to rake integration"
+end

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.20.1"
+  VERSION = "1.23.0"
 end

data/lib/bootsnap.rb

@@ -2,14 +2,12 @@
 
 require_relative "bootsnap/version"
 require_relative "bootsnap/bundler"
-require_relative "bootsnap/compile_cache"
-require_relative "bootsnap/load_path_cache"
 
 module Bootsnap
   InvalidConfiguration = Class.new(StandardError)
 
   class << self
-    attr_reader :logger
+    attr_reader :cache_dir, :logger
 
     def log_stats!
       stats = {hit: 0, revalidated: 0, miss: 0, stale: 0}
@@ -60,9 +58,11 @@ module Bootsnap
         warn("Bootsnap.setup `compile_cache_json` argument is deprecated and has no effect")
       end
 
+      @cache_dir = "#{cache_dir}/bootsnap"
+
       if load_path_cache
         Bootsnap::LoadPathCache.setup(
-          cache_path: "#{cache_dir}/bootsnap/load-path-cache",
+          cache_path: "#{@cache_dir}/load-path-cache",
           development_mode: development_mode,
           ignore_directories: ignore_directories,
           readonly: readonly,
@@ -70,7 +70,7 @@ module Bootsnap
       end
 
       Bootsnap::CompileCache.setup(
-        cache_dir: "#{cache_dir}/bootsnap/compile-cache",
+        cache_dir: "#{@cache_dir}/compile-cache",
         iseq: compile_cache_iseq,
         yaml: compile_cache_yaml,
         readonly: readonly,
@@ -150,7 +150,7 @@ module Bootsnap
     end
 
     # Allow the C extension to redefine `rb_get_path` without warning.
-    alias_method :rb_get_path, :rb_get_path # rubocop:disable Lint/DuplicateMethods
+    alias_method :rb_get_path, :rb_get_path
 
     private
 
@@ -164,3 +164,6 @@ module Bootsnap
     end
   end
 end
+
+require_relative "bootsnap/compile_cache"
+require_relative "bootsnap/load_path_cache"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.20.1
+  version: 1.23.0
 platform: ruby
 authors:
 - Burke Libbey
@@ -55,6 +55,7 @@ files:
 - lib/bootsnap/load_path_cache/path.rb
 - lib/bootsnap/load_path_cache/path_scanner.rb
 - lib/bootsnap/load_path_cache/store.rb
+- lib/bootsnap/rake.rb
 - lib/bootsnap/setup.rb
 - lib/bootsnap/version.rb
 homepage: https://github.com/rails/bootsnap
@@ -72,7 +73,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="