bootsnap 1.22.0 → 1.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ab247855b4e6a35b2db80b44f2d3da184fd9780e9a4faa3d35d952e15398839
-  data.tar.gz: c8fd54ed988e11df7e934e9ff4f30f7dfb6440b4b9a2ecd2eaf3dbf9aefa61fd
+  metadata.gz: 9680e880d828e4c61704db75e793e97b4bcaa9142e37335b697d28a14c1d7f9c
+  data.tar.gz: 876136914c8d89c771304fffc2d8587b3b15b0eb6abbf684ad5d4adb39b98550
 SHA512:
-  metadata.gz: 4a7225b866cbe788281af91aa690c75191e19bc09f4d8695a58557e024193d4b0924bbf9892cbb84dad93658eda9ff46c609b113c0b588660ac318e0b9176f1f
-  data.tar.gz: cadb844c862e9185befec65d7fa53beb6940945ebbddbea48ab30fd22b88f19aa773baa856c414522f5acf1a1c2a8aeafa75d72fb5a86cde5ebc8557172d049c
+  metadata.gz: 84bd60feda93f48dfeb2c8149c72a72a619050eb163decf83bf14d78173a3aa52adff84dc6a22f7821ee7d1c937a0449f96686f6199c77e53ff990f123c30359
+  data.tar.gz: 41d345dee52323ba80df2c8165bad4a4ea6c04780d8eb7e459a5e766973b797f68267ac63fbad38a3add47e59041aa8d7786ddb43b5ed0cfb7ac98743cd70ca5

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 1.24.0
+
+* Added a hook API to customize Ruby compilation.
+
+# 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.

data/README.md

@@ -75,6 +75,7 @@ well together.
 `require 'bootsnap/setup'` behavior can be changed using environment variables:
 
 - `BOOTSNAP_CACHE_DIR` allows to define the cache location.
+- `BOOTSNAP_CONFIG` allows to change the default config location (`config/bootsnap.rb`).
 - `DISABLE_BOOTSNAP` allows to entirely disable bootsnap.
 - `DISABLE_BOOTSNAP_LOAD_PATH_CACHE` allows to disable load path caching.
 - `DISABLE_BOOTSNAP_COMPILE_CACHE` allows to disable ISeq and YAML caches.
@@ -320,6 +321,34 @@ open    /c/nope.bundle -> -1
 # (nothing!)
 ```
 
+## Custom Compilers
+
+Bootsnap allows substituing the default Ruby compiler by another one.
+This can be configured from the bootsnap config file (defaults to `config/bootsnap.rb`).
+
+The main use case is to programmatically enable frozen string literals for your project without impacting dependencies:
+
+```ruby
+Bootsnap.enable_frozen_string_literal(app_only: true)
+```
+
+But it can also be used for more fine grained logic, or to implement all sort of Ruby code preprocessing:
+
+```ruby
+# config/bootsnap.rb
+gems_root = File.join(Bundler.bundle_path.cleanpath, "")
+app_root =  File.join(Dir.pwd, "")
+Bootsnap::CompileCache::ISeq.compiler_selector = ->(path) do
+  # Enable `frozen_string_literal: true` for app code, but not gems.
+
+  if path.start_with?(app_root) && !path.start_with?(gems_root)
+    Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+  else
+    Bootsnap::CompileCache::ISeq::DEFAULT
+  end
+end
+```
+
 ## Precompilation
 
 In development environments the bootsnap compilation cache is generated on the fly when source files are loaded.

data/ext/bootsnap/bootsnap.c

@@ -109,13 +109,15 @@ static bool readonly = false;
 static bool revalidation = false;
 static bool perm_issue = false;
 
+static ID id_storage_to_output, id_input_to_output, id_input_to_storage;
+
 /* Functions exposed as module functions on Bootsnap::CompileCache::Native */
 static VALUE bs_instrumentation_enabled_set(VALUE self, VALUE enabled);
 static VALUE bs_readonly_set(VALUE self, VALUE enabled);
 static VALUE bs_revalidation_set(VALUE self, VALUE enabled);
 static VALUE bs_compile_option_crc32_set(VALUE self, VALUE crc32_v);
-static VALUE bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler, VALUE args);
-static VALUE bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler);
+static VALUE bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler, VALUE args);
+static VALUE bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler);
 
 /* Helpers */
 enum cache_status {
@@ -123,7 +125,7 @@ enum cache_status {
   hit,
   stale,
 };
-static void bs_cache_path(const char * cachedir, const VALUE path, char (* cache_path)[MAX_CACHEPATH_SIZE]);
+static void bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_path)[MAX_CACHEPATH_SIZE]);
 static int bs_read_key(int fd, struct bs_cache_key * key);
 static enum cache_status cache_key_equal_fast_path(struct bs_cache_key * k1, struct bs_cache_key * k2);
 static int cache_key_equal_slow_path(struct bs_cache_key * current_key, struct bs_cache_key * cached_key, const VALUE input_data);
@@ -143,7 +145,7 @@ static uint32_t get_ruby_platform(void);
  */
 static int bs_storage_to_output(VALUE handler, VALUE args, VALUE storage_data, VALUE * output_data);
 static VALUE prot_input_to_output(VALUE arg);
-static void bs_input_to_output(VALUE handler, VALUE args, VALUE input_data, VALUE * output_data, int * exception_tag);
+static void bs_input_to_output(VALUE handler, VALUE args, VALUE input_data, VALUE pathval, VALUE * output_data, int * exception_tag);
 static int bs_input_to_storage(VALUE handler, VALUE args, VALUE input_data, VALUE pathval, VALUE * storage_data);
 struct s2o_data;
 struct i2o_data;
@@ -194,8 +196,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)) {
@@ -212,11 +218,8 @@ bs_rb_scan_dir(VALUE self, VALUE abspath)
             }
 
             if (fstatat(dfd, entry->d_name, &st, 0)) {
-                if (errno == ENOENT) {
-                    // Broken symlinK
-                    errno = 0;
-                    continue;
-                }
+                if (errno == ENOENT) continue; // Broken symlink
+
                 int err = errno;
                 closedir(dirp);
                 bs_syserr_fail_dir_entry("fstatat", err, abspath, entry->d_name);
@@ -249,10 +252,15 @@ bs_rb_scan_dir(VALUE self, VALUE abspath)
         }
     }
 
-    if (closedir(dirp)) {
+    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
@@ -269,6 +277,10 @@ Init_bootsnap(void)
 {
   rb_mBootsnap = rb_define_module("Bootsnap");
 
+  id_storage_to_output = rb_intern("storage_to_output");
+  id_input_to_output = rb_intern("input_to_output");
+  id_input_to_storage = rb_intern("input_to_storage");
+
   rb_define_singleton_method(rb_mBootsnap, "rb_get_path", bs_rb_get_path, 1);
 
 #ifdef HAVE_FSTATAT
@@ -296,8 +308,8 @@ Init_bootsnap(void)
   rb_define_module_function(rb_mBootsnap, "instrumentation_enabled=", bs_instrumentation_enabled_set, 1);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "readonly=", bs_readonly_set, 1);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "revalidation=", bs_revalidation_set, 1);
-  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "fetch", bs_rb_fetch, 4);
-  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "precompile", bs_rb_precompile, 3);
+  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "fetch", bs_rb_fetch, 5);
+  rb_define_module_function(rb_mBootsnap_CompileCache_Native, "precompile", bs_rb_precompile, 4);
   rb_define_module_function(rb_mBootsnap_CompileCache_Native, "compile_option_crc32=", bs_compile_option_crc32_set, 1);
 
   current_umask = umask(0777);
@@ -414,13 +426,28 @@ get_ruby_platform(void)
  * The path will look something like: <cachedir>/12/34567890abcdef
  */
 static void
-bs_cache_path(const char * cachedir, const VALUE path, char (* cache_path)[MAX_CACHEPATH_SIZE])
+bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_path)[MAX_CACHEPATH_SIZE])
 {
-  uint64_t hash = fnv1a_64(path);
+  FilePathValue(path_v);
+
+  Check_Type(cachedir_v, T_STRING);
+  Check_Type(path_v, T_STRING);
+  if (!NIL_P(namespace_v)) {
+    Check_Type(namespace_v, T_STRING);
+  }
+
+  if (RSTRING_LEN(cachedir_v) > MAX_CACHEDIR_SIZE) {
+    rb_raise(rb_eArgError, "cachedir too long");
+  }
+
+  const char * cachedir = RSTRING_PTR(cachedir_v);
+  const char * namespace = NIL_P(namespace_v) ? "" : RSTRING_PTR(namespace_v);
+
+  uint64_t hash = fnv1a_64(path_v);
   uint8_t first_byte = (hash >> (64 - 8));
   uint64_t remainder = hash & 0x00ffffffffffffff;
 
-  sprintf(*cache_path, "%s/%02"PRIx8"/%014"PRIx64, cachedir, first_byte, remainder);
+  sprintf(*cache_path, "%s%s/%02"PRIx8"/%014"PRIx64, cachedir, namespace, first_byte, remainder);
 }
 
 /*
@@ -492,25 +519,14 @@ static void bs_cache_key_digest(struct bs_cache_key *key,
  * conversions on the ruby VALUE arguments before passing them along.
  */
 static VALUE
-bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler, VALUE args)
+bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler, VALUE args)
 {
-  FilePathValue(path_v);
-
-  Check_Type(cachedir_v, T_STRING);
-  Check_Type(path_v, T_STRING);
-
-  if (RSTRING_LEN(cachedir_v) > MAX_CACHEDIR_SIZE) {
-    rb_raise(rb_eArgError, "cachedir too long");
-  }
-
-  char * cachedir = RSTRING_PTR(cachedir_v);
-  char * path     = RSTRING_PTR(path_v);
   char cache_path[MAX_CACHEPATH_SIZE];
 
   /* generate cache path to cache_path */
-  bs_cache_path(cachedir, path_v, &cache_path);
+  bs_cache_path(cachedir_v, namespace_v, path_v, &cache_path);
 
-  return bs_fetch(path, path_v, cache_path, handler, args);
+  return bs_fetch(RSTRING_PTR(path_v), path_v, cache_path, handler, args);
 }
 
 /*
@@ -519,25 +535,13 @@ bs_rb_fetch(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler, VALUE arg
  * and doesn't return the content.
  */
 static VALUE
-bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE path_v, VALUE handler)
+bs_rb_precompile(VALUE self, VALUE cachedir_v, VALUE namespace_v, VALUE path_v, VALUE handler)
 {
-  FilePathValue(path_v);
-
-  Check_Type(cachedir_v, T_STRING);
-  Check_Type(path_v, T_STRING);
-
-  if (RSTRING_LEN(cachedir_v) > MAX_CACHEDIR_SIZE) {
-    rb_raise(rb_eArgError, "cachedir too long");
-  }
-
-  char * cachedir = RSTRING_PTR(cachedir_v);
-  char * path     = RSTRING_PTR(path_v);
   char cache_path[MAX_CACHEPATH_SIZE];
-
   /* generate cache path to cache_path */
-  bs_cache_path(cachedir, path_v, &cache_path);
+  bs_cache_path(cachedir_v, namespace_v, path_v, &cache_path);
 
-  return bs_precompile(path, path_v, cache_path, handler);
+  return bs_precompile(RSTRING_PTR(path_v), path_v, cache_path, handler);
 }
 
 static int bs_open_noatime(const char *path, int flags) {
@@ -957,7 +961,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
         exception_message = path_v;
         goto fail_errno;
       }
-      bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+      bs_input_to_output(handler, args, input_data, path_v, &output_data, &exception_tag);
       if (exception_tag != 0) goto raise;
       goto succeed;
     } else if (res == CACHE_MISS || res == CACHE_STALE) valid_cache = 0;
@@ -983,7 +987,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
   /* If input_to_storage raised Bootsnap::CompileCache::Uncompilable, don't try
    * to cache anything; just return input_to_output(input_data) */
   if (storage_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
-    bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+    bs_input_to_output(handler, args, input_data, path_v, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
     goto succeed;
   }
@@ -1003,7 +1007,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
 
   if (output_data == rb_cBootsnap_CompileCache_UNCOMPILABLE) {
     /* If storage_to_output returned `Uncompilable` we fallback to `input_to_output` */
-    bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+    bs_input_to_output(handler, args, input_data, path_v, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
   } else if (NIL_P(output_data)) {
     /* If output_data is nil, delete the cache entry and generate the output
@@ -1017,7 +1021,7 @@ bs_fetch(char * path, VALUE path_v, char * cache_path, VALUE handler, VALUE args
         goto fail_errno;
       }
     }
-    bs_input_to_output(handler, args, input_data, &output_data, &exception_tag);
+    bs_input_to_output(handler, args, input_data, path_v, &output_data, &exception_tag);
     if (exception_tag != 0) goto raise;
   }
 
@@ -1175,6 +1179,7 @@ struct i2o_data {
   VALUE handler;
   VALUE args;
   VALUE input_data;
+  VALUE pathval;
 };
 
 struct i2s_data {
@@ -1187,7 +1192,7 @@ static VALUE
 try_storage_to_output(VALUE arg)
 {
   struct s2o_data * data = (struct s2o_data *)arg;
-  return rb_funcall(data->handler, rb_intern("storage_to_output"), 2, data->storage_data, data->args);
+  return rb_funcall(data->handler, id_storage_to_output, 2, data->storage_data, data->args);
 }
 
 static int
@@ -1204,12 +1209,13 @@ bs_storage_to_output(VALUE handler, VALUE args, VALUE storage_data, VALUE * outp
 }
 
 static void
-bs_input_to_output(VALUE handler, VALUE args, VALUE input_data, VALUE * output_data, int * exception_tag)
+bs_input_to_output(VALUE handler, VALUE args, VALUE input_data, VALUE path_v, VALUE * output_data, int * exception_tag)
 {
   struct i2o_data i2o_data = {
     .handler    = handler,
     .args       = args,
     .input_data = input_data,
+    .pathval    = path_v,
   };
   *output_data = rb_protect(prot_input_to_output, (VALUE)&i2o_data, exception_tag);
 }
@@ -1218,14 +1224,14 @@ static VALUE
 prot_input_to_output(VALUE arg)
 {
   struct i2o_data * data = (struct i2o_data *)arg;
-  return rb_funcall(data->handler, rb_intern("input_to_output"), 2, data->input_data, data->args);
+  return rb_funcall(data->handler, id_input_to_output, 3, data->input_data, data->pathval, data->args);
 }
 
 static VALUE
 try_input_to_storage(VALUE arg)
 {
   struct i2s_data * data = (struct i2s_data *)arg;
-  return rb_funcall(data->handler, rb_intern("input_to_storage"), 2, data->input_data, data->pathval);
+  return rb_funcall(data->handler, id_input_to_storage, 2, data->input_data, data->pathval);
 }
 
 static int

data/lib/bootsnap/cli.rb

@@ -43,6 +43,7 @@ module Bootsnap
           yaml: yaml,
           revalidation: true,
         )
+        Bootsnap.load_config
 
         @work_pool = WorkerPool.create(size: jobs, jobs: {
           ruby: method(:precompile_ruby),

data/lib/bootsnap/compile_cache/iseq.rb

@@ -7,7 +7,8 @@ module Bootsnap
   module CompileCache
     module ISeq
       class << self
-        attr_reader(:cache_dir)
+        attr_reader :cache_dir
+        attr_accessor :compiler_selector, :default_compiler
 
         def cache_dir=(cache_dir)
           @cache_dir = cache_dir.end_with?("/") ? "#{cache_dir}iseq" : "#{cache_dir}-iseq"
@@ -18,71 +19,83 @@ module Bootsnap
         end
       end
 
-      has_ruby_bug_18250 = begin # https://bugs.ruby-lang.org/issues/18250
-        if defined? RubyVM::InstructionSequence
-          RubyVM::InstructionSequence.compile("def foo(*); ->{ super }; end; def foo(**); ->{ super }; end").to_binary
+      class Compiler
+        attr_reader :namespace, :compile_options
+
+        def initialize(namespace = nil, compile_options = nil)
+          @namespace = namespace
+          @compile_options = compile_options
         end
-        false
-      rescue TypeError
-        true
-      end
 
-      if has_ruby_bug_18250
-        def self.input_to_storage(_, path)
-          iseq = begin
-            RubyVM::InstructionSequence.compile_file(path)
-          rescue SyntaxError
-            return UNCOMPILABLE # syntax error
+        has_ruby_bug_18250 = begin # https://bugs.ruby-lang.org/issues/18250
+          if defined? RubyVM::InstructionSequence
+            RubyVM::InstructionSequence.compile("def foo(*); ->{ super }; end; def foo(**); ->{ super }; end").to_binary
           end
+          false
+        rescue TypeError
+          true
+        end
+
+        if has_ruby_bug_18250
+          def input_to_storage(_, path)
+            iseq = RubyVM::InstructionSequence.compile_file(path, @compile_options)
 
-          begin
-            iseq.to_binary
-          rescue TypeError
-            UNCOMPILABLE # ruby bug #18250
+            begin
+              iseq.to_binary
+            rescue TypeError
+              UNCOMPILABLE # ruby bug #18250
+            end
+          end
+        else
+          def input_to_storage(_, path)
+            RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
           end
         end
-      else
-        def self.input_to_storage(_, path)
-          RubyVM::InstructionSequence.compile_file(path).to_binary
-        rescue SyntaxError
-          UNCOMPILABLE # syntax error
+
+        def storage_to_output(binary, _args)
+          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")
+            nil
+          else
+            raise
+          end
         end
-      end
 
-      def self.storage_to_output(binary, _args)
-        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")
-          nil
-        else
-          raise
+        def input_to_output(source, path, _kwargs)
+          RubyVM::InstructionSequence.compile(source, path, path, nil, @compile_options)
         end
       end
 
+      DEFAULT = Compiler.new
+      FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
+      MUTABLE_STRING_LITERAL = Compiler.new("-no-fstr", {frozen_string_literal: false}.freeze)
+      @default_compiler = DEFAULT
+
       def self.fetch(path, cache_dir: ISeq.cache_dir)
+        compiler = compiler_selector&.call(path) || default_compiler
         Bootsnap::CompileCache::Native.fetch(
           cache_dir,
+          compiler.namespace,
           path.to_s,
-          Bootsnap::CompileCache::ISeq,
+          compiler,
           nil,
         )
       end
 
       def self.precompile(path)
+        compiler = compiler_selector&.call(path) || default_compiler
         Bootsnap::CompileCache::Native.precompile(
           cache_dir,
+          compiler.namespace,
           path.to_s,
-          Bootsnap::CompileCache::ISeq,
+          compiler,
         )
       end
 
-      def self.input_to_output(_data, _kwargs)
-        nil # ruby handles this
-      end
-
       module InstructionSequenceMixin
         def load_iseq(path)
           # Having coverage enabled prevents iseq dumping/loading.
@@ -97,7 +110,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

@@ -28,6 +28,7 @@ module Bootsnap
 
           CompileCache::Native.precompile(
             cache_dir,
+            nil,
             path.to_s,
             @implementation,
           )
@@ -175,7 +176,7 @@ module Bootsnap
             result
           end
 
-          def input_to_output(data, kwargs)
+          def input_to_output(data, _path, kwargs)
             ::YAML.unsafe_load(data, **(kwargs || {}))
           end
         end
@@ -215,7 +216,7 @@ module Bootsnap
             end
           end
 
-          def input_to_output(data, kwargs)
+          def input_to_output(data, _path, kwargs)
             ::YAML.load(data, **(kwargs || {}))
           end
         end
@@ -233,6 +234,7 @@ module Bootsnap
 
             CompileCache::Native.fetch(
               CompileCache::YAML.cache_dir,
+              nil,
               File.realpath(path),
               CompileCache::YAML::Psych4::SafeLoad,
               kwargs,
@@ -253,6 +255,7 @@ module Bootsnap
 
             CompileCache::Native.fetch(
               CompileCache::YAML.cache_dir,
+              nil,
               File.realpath(path),
               CompileCache::YAML::Psych4::UnsafeLoad,
               kwargs,
@@ -288,7 +291,7 @@ module Bootsnap
           unpacker.unpack
         end
 
-        def input_to_output(data, kwargs)
+        def input_to_output(data, _path, kwargs)
           ::YAML.load(data, **(kwargs || {}))
         end
 
@@ -305,6 +308,7 @@ module Bootsnap
 
             CompileCache::Native.fetch(
               CompileCache::YAML.cache_dir,
+              nil,
               File.realpath(path),
               CompileCache::YAML::Psych3,
               kwargs,
@@ -325,6 +329,7 @@ module Bootsnap
 
             CompileCache::Native.fetch(
               CompileCache::YAML.cache_dir,
+              nil,
               File.realpath(path),
               CompileCache::YAML::Psych3,
               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)

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -59,7 +59,7 @@ module Bootsnap
       end
 
       def purge_multi(features)
-        rejected_hashes = features.each_with_object({}) { |f, h| h[f.hash] = true }
+        rejected_hashes = features.to_h { |f| [f.hash, true] }
         @mutex.synchronize do
           @lfi.reject! { |_, hash| rejected_hashes.key?(hash) }
         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/version.rb

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

data/lib/bootsnap.rb

@@ -43,6 +43,13 @@ module Bootsnap
       @instrumentation.call(event, path)
     end
 
+    def load_config
+      config_path = File.expand_path(ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb")
+      if File.exist?(config_path)
+        require(config_path)
+      end
+    end
+
     def setup(
       cache_dir:,
       development_mode: true,
@@ -76,6 +83,28 @@ module Bootsnap
         readonly: readonly,
         revalidation: revalidation,
       )
+
+      load_config
+    end
+
+    def enable_frozen_string_literal(app_only: false)
+      if app_only
+        gems_root = File.join(Bundler.bundle_path.cleanpath, "")
+        app_root =  File.join(Dir.pwd, "")
+        Bootsnap::CompileCache::ISeq.default_compiler = Bootsnap::CompileCache::ISeq::DEFAULT
+        Bootsnap::CompileCache::ISeq.compiler_selector = lambda { |path|
+          # Enable `frozen_string_literal: true` for app code, but not gems.
+
+          if path.start_with?(app_root) && !path.start_with?(gems_root)
+            Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+          else
+            Bootsnap::CompileCache::ISeq::DEFAULT
+          end
+        }
+      else
+        Bootsnap::CompileCache::ISeq.compiler_selector = nil
+        Bootsnap::CompileCache::ISeq.default_compiler = Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+      end
     end
 
     def unload_cache!
@@ -150,7 +179,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
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.22.0
+  version: 1.24.0
 platform: ruby
 authors:
 - Burke Libbey
@@ -73,14 +73,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []