bootsnap 1.24.4 → 1.24.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 64eaf08501294e6e0fd98b67a54eadfff566f5480a0722e2fb852611a28bd1f8
-  data.tar.gz: 8e28bc6d5714952cf5abd837453be6774309dd4b45559c3cd31684ef6658490f
+  metadata.gz: c89c653bbd5db473e06179c6606268271c8c540a588cca938662f168d64f2d39
+  data.tar.gz: 449c08c79a258dea90e56646c9d62a06e1d696c065ce96c38a7f50ef2fb83f7b
 SHA512:
-  metadata.gz: c92cf4fc73d5241a876647a67e9ff70ee63b2816a6f048f3b9f408de8c460e1f97f00162c883bbcc62b01a90d4f753126e3c3be885aee41d042fa166aad812af
-  data.tar.gz: 3db013dee453d69e531d4c6cc1a0e763aeadce36a3d5254febb449957447bf801c06e06544a4f571b5a103e75d397b60d51d364eede8de5bfce63abd79dc0ddf
+  metadata.gz: 2ea80faffec0206b9bb7b3d19c1419b2e7eefc2dc5f4eb03352862b83afa07ed293d0b15f04fc069d89dac1cd4d4636770626e90e6129ffad77f0cfcb8c3f676
+  data.tar.gz: 82dcb1a4c934a9de29a8aa935ffe2d1a7c6e23ebf36ea743c3d29a4d9a1d8bd42696cdefd37dacdd21a4102f88f0b605d1cc6faef9c15ccdc6d99eef15f4483e

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Unreleased
 
+# 1.24.6
+
+* Fix detection of Ruby bug #22023 on some patch versions of Ruby 3.4, and properly apply the workaround.
+
+# 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/ext/bootsnap/bootsnap.c

@@ -403,11 +403,14 @@ bs_cache_path(VALUE cachedir_v, VALUE namespace_v, VALUE path_v, char (* cache_p
 
   Check_Type(cachedir_v, T_STRING);
   Check_Type(path_v, T_STRING);
+
+  long namespace_len = 0;
   if (!NIL_P(namespace_v)) {
     Check_Type(namespace_v, T_STRING);
+    namespace_len = RSTRING_LEN(namespace_v);
   }
 
-  if (RSTRING_LEN(cachedir_v) > MAX_CACHEDIR_SIZE) {
+  if (RSTRING_LEN(cachedir_v) + namespace_len > MAX_CACHEDIR_SIZE) {
     rb_raise(rb_eArgError, "cachedir too long");
   }
 

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,209 @@ 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)
-            end
+          has_ruby_bug_22023 = case RUBY_VERSION
+          when /^3\.3\./
+            true
+          when /^3\.4\.(\d+)/
+            $1.to_i < 10
+          when /^4\.0\.(\d+)/
+            $1.to_i < 4
+          else
+            false
+          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
+
+            return nil
+          end
 
-      if RUBY_VERSION < "3.1."
-        def self.coverage_on?
-          defined?(Coverage) && Coverage.running?
+          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/compile_cache/ruby_bug_22023_canary.rb

@@ -1,7 +1 @@
-_f = -> {
-  case foo
-  in [one, "a" | "b" => two]
-    puts "#{one} - #{two}"
-  end
-}
 _ = "test"

data/lib/bootsnap/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bootsnap
-  VERSION = "1.24.4"
+  VERSION = "1.24.6"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.24.4
+  version: 1.24.6
 platform: ruby
 authors:
 - Burke Libbey
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Boot large ruby/rails apps faster
 test_files: []