bootsnap 1.23.0 → 1.24.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e0ad269f816c24dc901b6544acb59c5ebd65b22432f39ee69bc3387b9c2b04d
-  data.tar.gz: 700f525d90d4e77421ce83e38f8731981a48cc82a8b9a937c29f661972f78d7f
+  metadata.gz: 31d64e50bd32368c8dffe927b63fa6e62243b697a2606ca3e2330c4694ec816b
+  data.tar.gz: 5dfc374040409d1d20e893abc6a8c6052de02cf560c15e7678a5db2084bd722c
 SHA512:
-  metadata.gz: f5859d7fd4b81f1969c55e12b33a957b34b1dc2825d03bc3f7ab60a57d34153cbcdda7a60626ea758fd66877b1b74a58d17b276aa2055f41086488d6ced5317b
-  data.tar.gz: c09f2cd48da0ba3bb5e9d3c995ffb86b8b16aec987c311162fc79ca648a66f355e4051d6ae4c5ee486d5ad2d2bc3af32090e15776e1f45129c1ea8c8e6c811ed
+  metadata.gz: ff9e6b5b2c47d0337fa8d46c487fd6881bc567f5ae01a17f85aa3821df9b7f8416283764f8309de6207d94eb00e6cd6ee845a1307dd601659e4d26cd6abbc7ea
+  data.tar.gz: e34adc7c5162da87d94358a99a5990d0dfbc6497fb141e7407614e181328e1091bd708fac0aa96e6bce8731283a367db6a5aa6e8a2afe3b848b2d0f6b73e3ba4

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Unreleased
 
+# 1.24.3
+
+* Fix the `1.24.2` workaround to parse Ruby files with UTF-8 even when the `LANG` environment variable
+  is unset or set to `C`.
+
+# 1.24.2
+
+* Workaround two Ruby bugs in `RubyVM::InstructionSequence.compile_file`, that were causing
+  files to be loaded with the old Ruby parser instead of Prism, causing issues with some pattern matching syntax.
+  Ref: https://bugs.ruby-lang.org/issues/22023
+
+# 1.24.1
+
+* Fix encoding of Ruby source files loaded when `BOOTSNAP_READONLY` is set.
+  Files would incorectly be loaded in `ASCII-8BIT` causing literal strings outside
+  the pure ASCII range to have `ASCII-8BIT` encoding instead of `UTF-8`.
+  This bug was introduced in `1.24.0`.
+
+# 1.24.0
+
+* Added a hook API to customize Ruby compilation.
+
 # 1.23.0
 
 * Require Ruby 2.7.

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;
@@ -275,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
@@ -302,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);
@@ -420,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);
 }
 
 /*
@@ -498,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);
 }
 
 /*
@@ -525,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) {
@@ -963,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;
@@ -989,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;
   }
@@ -1009,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
@@ -1023,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;
   }
 
@@ -1181,6 +1179,7 @@ struct i2o_data {
   VALUE handler;
   VALUE args;
   VALUE input_data;
+  VALUE pathval;
 };
 
 struct i2s_data {
@@ -1193,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
@@ -1210,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);
 }
@@ -1224,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,117 @@ 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
 
+        has_ruby_bug_22023 = if defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile_file_prism)
           begin
-            iseq.to_binary
-          rescue TypeError
-            UNCOMPILABLE # ruby bug #18250
+            RubyVM::InstructionSequence.compile_file(File.expand_path("../ruby_bug_22023_canary.rb", __FILE__))
+            false
+          rescue SyntaxError
+            true
           end
         end
-      else
-        def self.input_to_storage(_, path)
-          RubyVM::InstructionSequence.compile_file(path).to_binary
-        rescue SyntaxError
-          UNCOMPILABLE # syntax error
+
+        if has_ruby_bug_22023 && RUBY_DESCRIPTION.include?("+PRISM")
+          module PatchRubyBug22023
+            def compile_file(path, options = nil)
+              compile_file_prism(path, options)
+            end
+
+            has_ruby_bug_22023_bis = !RubyVM::InstructionSequence.compile_file_prism(
+              File.expand_path("../ruby_bug_22023_canary.rb", __FILE__),
+              {frozen_string_literal: true},
+            ).eval.frozen?
+
+            if has_ruby_bug_22023_bis
+              def compile_file_prism(path, options = nil)
+                compile_prism(::File.read(path, encoding: Encoding::UTF_8), path, path, nil, options)
+              end
+            end
+          end
+          RubyVM::InstructionSequence.singleton_class.prepend(PatchRubyBug22023)
         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
+        if has_ruby_bug_18250
+          def input_to_storage(_, path)
+            iseq = RubyVM::InstructionSequence.compile_file(path, @compile_options)
+            iseq.to_binary
+          rescue TypeError, SyntaxError # Ruby [Bug #18250] & [Bug #22023]
+            UNCOMPILABLE
+          end
         else
-          raise
+          def input_to_storage(_, path)
+            RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
+          rescue SyntaxError # Ruby [Bug #22023]
+            UNCOMPILABLE
+          end
+        end
+
+        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
+
+        def input_to_output(source, path, _kwargs)
+          RubyVM::InstructionSequence.compile(
+            source.force_encoding(Encoding.default_external),
+            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.

data/lib/bootsnap/compile_cache/ruby_bug_22023_canary.rb

@@ -0,0 +1,10 @@
+# rubocop:disable Style/FrozenStringLiteralComment
+def foo(bars)
+  case bars
+  in [one, "a" | "b" => two]
+    puts "#{one} - #{two}"
+  end
+end
+
+_ = "test"
+# rubocop:enable Style/FrozenStringLiteralComment

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

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.23.0"
+  VERSION = "1.24.3"
 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!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.23.0
+  version: 1.24.3
 platform: ruby
 authors:
 - Burke Libbey
@@ -44,6 +44,7 @@ files:
 - lib/bootsnap/cli/worker_pool.rb
 - lib/bootsnap/compile_cache.rb
 - lib/bootsnap/compile_cache/iseq.rb
+- lib/bootsnap/compile_cache/ruby_bug_22023_canary.rb
 - lib/bootsnap/compile_cache/yaml.rb
 - lib/bootsnap/explicit_require.rb
 - lib/bootsnap/load_path_cache.rb
@@ -80,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []