bootsnap 1.24.4 → 1.24.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64eaf08501294e6e0fd98b67a54eadfff566f5480a0722e2fb852611a28bd1f8
-  data.tar.gz: 8e28bc6d5714952cf5abd837453be6774309dd4b45559c3cd31684ef6658490f
+  metadata.gz: 9f514d9a08cf2cbfa470c7d6745fe6388bfb4800a8cf659b9939bc57c93a67e1
+  data.tar.gz: e623cc84b0ce559e15eeb5ade64617ab6faff50a5004256ecdac5e93267ac5e0
 SHA512:
-  metadata.gz: c92cf4fc73d5241a876647a67e9ff70ee63b2816a6f048f3b9f408de8c460e1f97f00162c883bbcc62b01a90d4f753126e3c3be885aee41d042fa166aad812af
-  data.tar.gz: 3db013dee453d69e531d4c6cc1a0e763aeadce36a3d5254febb449957447bf801c06e06544a4f571b5a103e75d397b60d51d364eede8de5bfce63abd79dc0ddf
+  metadata.gz: 517950fbb71bbfc7e9ecbc0220849bc4c6fba0f410edb3d08db13d7e1e55f6602cef80c0636ed656cd76eab3c100da317a40d7cf7527dbf97bb4e2b250bc820f
+  data.tar.gz: 97fdc6fee1ac2945fba9b79ec3e6b8d65f265c5e90fc9da16ced08aff3b09f6f516bcdec46aa703452666dfbfaff3db319b912282f0bb1b5ed3d355d0a24e5a0

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Unreleased
 
+# 1.24.5
+
+* No longer load the config file by default when setup is done manually. This is so cli applications like homebrew
+  don't mistakenly load another app's boostnap config.
+
 # 1.24.4
 
 * Fix several compatibility issues with Ruby `4.0.4`, particularly the `should not compile with coverage` error. See #547.

data/lib/bootsnap/cli.rb

@@ -43,7 +43,7 @@ module Bootsnap
           yaml: yaml,
           revalidation: true,
         )
-        Bootsnap.load_config
+        Bootsnap.load_config(ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb")
 
         @work_pool = WorkerPool.create(size: jobs, jobs: {
           ruby: method(:precompile_ruby),

data/lib/bootsnap/compile_cache/iseq.rb

@@ -19,180 +19,207 @@ module Bootsnap
         end
       end
 
-      class Compiler
-        attr_reader :namespace, :compile_options
-
-        def initialize(namespace = nil, compile_options = nil)
-          @namespace = namespace
-          @compile_options = compile_options
-        end
+      if supported?
+        class Compiler
+          attr_reader :namespace
+
+          def initialize(namespace = nil, compile_options = nil)
+            @namespace = namespace
+            @options = compile_options.freeze
+            update_options
+          end
 
-        has_ruby_bug_18250 = RUBY_VERSION.start_with?("3.0.") && 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
+          def update_options
+            @compile_options = if @options.nil? || @options < RubyVM::InstructionSequence.compile_option
+              nil
+            else
+              RubyVM::InstructionSequence.compile_option.merge(@options).freeze
+            end
           end
-          false
-        rescue TypeError
-          true
-        end
 
-        has_ruby_bug_22023 = if defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile_file_prism)
-          begin
-            RubyVM::InstructionSequence.compile_file(File.expand_path("../ruby_bug_22023_canary.rb", __FILE__))
+          has_ruby_bug_18250 = RUBY_VERSION.start_with?("3.0.") && begin # https://bugs.ruby-lang.org/issues/18250
+            if defined? RubyVM::InstructionSequence
+              RubyVM::InstructionSequence.compile(<<~RUBY).to_binary
+                def foo(*); ->{ super }; end; def foo(**); ->{ super }; end
+              RUBY
+            end
             false
-          rescue SyntaxError
+          rescue TypeError
             true
           end
-        end
 
-        if has_ruby_bug_22023 && RUBY_DESCRIPTION.include?("+PRISM")
-          module PatchRubyBug22023
-            def compile_file(path, options = nil)
-              compile_file_prism(path, options)
+          has_ruby_bug_22023 = if defined?(RubyVM::InstructionSequence) && RubyVM::InstructionSequence.respond_to?(:compile_file_prism)
+            begin
+              RubyVM::InstructionSequence.compile_file(File.expand_path("../ruby_bug_22023_canary.rb", __FILE__))
+              false
+            rescue SyntaxError
+              true
             end
+          end
+
+          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?
+              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)
+              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
-          RubyVM::InstructionSequence.singleton_class.prepend(PatchRubyBug22023)
-        end
 
-        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
-          def input_to_storage(_, path)
-            RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
-          rescue SyntaxError # Ruby [Bug #22023]
-            UNCOMPILABLE
+          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
+            def input_to_storage(_, path)
+              RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
+            rescue SyntaxError # Ruby [Bug #22023]
+              UNCOMPILABLE
+            end
           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
+          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 input_to_output(source, path, _kwargs)
-          if @compile_options
-            RubyVM::InstructionSequence.compile(
-              source.force_encoding(Encoding.default_external),
-              path,
-              path,
-              nil,
-              @compile_options,
-            )
+          def input_to_output(source, path, _kwargs)
+            if @compile_options
+              if source
+                RubyVM::InstructionSequence.compile(
+                  source.force_encoding(Encoding.default_external),
+                  path,
+                  path,
+                  nil,
+                  @compile_options,
+                )
+              else
+                RubyVM::InstructionSequence.compile_file(path, @compile_options)
+              end
+            end
           end
         end
-      end
 
-      DEFAULT = Compiler.new
-      FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
-      COVERAGE_SUPPORTED = RUBY_VERSION >= "4.0.4"
-      @default_compiler = DEFAULT
-      @coverage_support_warning_emitted = false
-
-      def self.fetch(path, cache_dir: ISeq.cache_dir)
-        compiler = compiler_selector&.call(path) || default_compiler
-
-        # Having coverage enabled prevents iseq dumping/loading.
-        if coverage_on?
-          return nil if compiler.equal?(DEFAULT)
-
-          if COVERAGE_SUPPORTED
-            return compiler.input_to_output(File.read(path.to_s), path.to_s, nil)
-          elsif !@coverage_support_warning_emitted
-            @coverage_support_warning_emitted = true
-            warn(<<~MSG)
-              Using `Bootsnap.enable_frozen_string_literal` with code coverage enabled is only supported on Ruby 4.0.4+.
-              Files loaded while coverage is on, will have mutable string literals.
-            MSG
-          end
+        DEFAULT = Compiler.new
+        FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
+        COVERAGE_SUPPORTED = RUBY_VERSION >= "4.0.4"
 
-          return nil
-        end
+        @default_compiler = DEFAULT
+        @coverage_support_warning_emitted = false
 
-        Bootsnap::CompileCache::Native.fetch(
-          cache_dir,
-          compiler.namespace,
-          path.to_s,
-          compiler,
-          nil,
-        )
-      end
+        def self.fetch(path, cache_dir: ISeq.cache_dir)
+          compiler = compiler_selector&.call(path) || default_compiler
 
-      def self.precompile(path)
-        compiler = compiler_selector&.call(path) || default_compiler
-        Bootsnap::CompileCache::Native.precompile(
-          cache_dir,
-          compiler.namespace,
-          path.to_s,
-          compiler,
-        )
-      end
+          # Having coverage enabled prevents iseq dumping/loading.
+          if coverage_on?
+            return nil if compiler.equal?(DEFAULT)
+
+            if COVERAGE_SUPPORTED
+              return compiler.input_to_output(nil, path.to_s, nil)
+            elsif !@coverage_support_warning_emitted
+              @coverage_support_warning_emitted = true
+              warn(<<~MSG)
+                Using `Bootsnap.enable_frozen_string_literal` with code coverage enabled is only supported on Ruby 4.0.4+.
+                Files loaded while coverage is on, will have mutable string literals.
+              MSG
+            end
 
-      if RUBY_VERSION < "3.1."
-        def self.coverage_on?
-          defined?(Coverage) && Coverage.running?
+            return nil
+          end
+
+          Bootsnap::CompileCache::Native.fetch(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
+            nil,
+          )
         end
-      else
-        def self.coverage_on?
-          defined?(Coverage) && Coverage.state != :idle
+
+        def self.precompile(path)
+          compiler = compiler_selector&.call(path) || default_compiler
+          Bootsnap::CompileCache::Native.precompile(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
+          )
         end
-      end
 
-      module InstructionSequenceMixin
-        def load_iseq(path)
-          Bootsnap::CompileCache::ISeq.fetch(path.to_s)
-        rescue RuntimeError => error
-          if error.message.include?("unmatched platform")
-            puts("unmatched platform for file #{path}")
+        if RUBY_VERSION < "3.1."
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.running?
+          end
+        else
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.state != :idle
           end
-          raise
         end
 
-        def compile_option=(hash)
-          super
-          Bootsnap::CompileCache::ISeq.compile_option_updated
+        module InstructionSequenceMixin
+          def load_iseq(path)
+            Bootsnap::CompileCache::ISeq.fetch(path.to_s)
+          rescue RuntimeError => error
+            if error.message.include?("unmatched platform")
+              puts("unmatched platform for file #{path}")
+            end
+            raise
+          end
+
+          def compile_option=(hash)
+            super
+            Bootsnap::CompileCache::ISeq.compile_option_updated
+          end
         end
-      end
 
-      def self.compile_option_updated
-        option = RubyVM::InstructionSequence.compile_option
-        crc = Zlib.crc32(option.inspect)
-        Bootsnap::CompileCache::Native.compile_option_crc32 = crc
-      end
-      compile_option_updated if supported?
+        def self.compile_option_updated
+          option = RubyVM::InstructionSequence.compile_option
+          crc = Zlib.crc32(option.inspect)
+          Bootsnap::CompileCache::Native.compile_option_crc32 = crc
+          FROZEN_STRING_LITERAL.update_options
+        end
+        compile_option_updated if supported?
 
-      def self.install!(cache_dir)
-        Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
+        def self.install!(cache_dir)
+          Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
 
-        return unless supported?
+          return unless supported?
 
-        Bootsnap::CompileCache::ISeq.compile_option_updated
+          Bootsnap::CompileCache::ISeq.compile_option_updated
+
+          class << RubyVM::InstructionSequence
+            prepend(InstructionSequenceMixin)
+          end
+        end
+      else
+        def self.install!(...)
+          # noop
+        end
 
-        class << RubyVM::InstructionSequence
-          prepend(InstructionSequenceMixin)
+        def self.precompile(...)
+          # noop
         end
       end
     end

data/lib/bootsnap/version.rb

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

data/lib/bootsnap.rb

@@ -43,13 +43,6 @@ 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,
@@ -59,7 +52,8 @@ module Bootsnap
       revalidation: false,
       compile_cache_iseq: true,
       compile_cache_yaml: true,
-      compile_cache_json: (compile_cache_json_unset = true)
+      compile_cache_json: (compile_cache_json_unset = true),
+      config_path: nil
     )
       unless compile_cache_json_unset
         warn("Bootsnap.setup `compile_cache_json` argument is deprecated and has no effect")
@@ -84,7 +78,16 @@ module Bootsnap
         revalidation: revalidation,
       )
 
-      load_config
+      load_config(config_path)
+    end
+
+    def load_config(config_path)
+      if config_path
+        config_path = File.expand_path(config_path)
+        if File.exist?(config_path)
+          require(config_path)
+        end
+      end
     end
 
     def enable_frozen_string_literal(app_only: false)
@@ -102,8 +105,8 @@ module Bootsnap
           end
         }
       else
-        Bootsnap::CompileCache::ISeq.compiler_selector = nil
-        Bootsnap::CompileCache::ISeq.default_compiler = Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+        options = RubyVM::InstructionSequence.compile_option.merge(frozen_string_literal: true)
+        RubyVM::InstructionSequence.compile_option = options
       end
     end
 
@@ -150,6 +153,7 @@ module Bootsnap
           readonly: bool_env("BOOTSNAP_READONLY"),
           revalidation: bool_env("BOOTSNAP_REVALIDATE"),
           ignore_directories: ignore_directories,
+          config_path: ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb",
         )
 
         if ENV["BOOTSNAP_LOG"]

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.24.4
+  version: 1.24.5
 platform: ruby
 authors:
 - Burke Libbey
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -67,6 +68,7 @@ metadata:
   changelog_uri: https://github.com/rails/bootsnap/blob/main/CHANGELOG.md
   source_code_uri: https://github.com/rails/bootsnap
   allowed_push_host: https://rubygems.org
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -81,7 +83,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []