bootsnap 1.10.2 → 1.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22aca6043d2a55eb7747cb38aec8365879c37e3fbdbd0cdfdd040098dd945fdd
-  data.tar.gz: 69085ad28c61b3dbffeab8e50a49f0655d05c9639cae9e4ba0a9cc2f2b7c9051
+  metadata.gz: 3dfd9cfb2cde26fc31c82206b73f3940b4b46903a3fa73d0f3f1a4c4a90c6984
+  data.tar.gz: 6dd8acfb2676a2585eb320ed50ba0ddb9f9c847fb415bcda824c7ebff0cce752
 SHA512:
-  metadata.gz: f63a81e86c721f737e5f29b9696abbcbc118e5bf703bf994dbf275d9939203d1eb6aebabc8ccad927f818b2bf9311d4174dde0338b7cd74f4e71e7e9727e6692
-  data.tar.gz: 3209a8fcdbb446c0f32738f2f580e7adc573d556da298560718c23d25963dc3f9dcf8fd5794a79864bac203089aef6be3da7743fde8bcc906f469b20461bb7aa
+  metadata.gz: 219a84be718e4ac5681621739b6f9400d77a16dee631bdc286adad87c0ddf99cc581da7281150add34075c08c59832df2a468524656d2f1ac36ac1613be051bb
+  data.tar.gz: 0e407a034fd081c9e506637e0997d0c2cc0eea312be798f6fd0d573173699f906f1b43a1f3d37ff64ee6efb2f9257228c6c4e7663b7337bfc49d99e5089fccb9

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Unreleased
 
+# 1.10.3
+
+* Fix Regexp and Date type support in YAML compile cache. (#400)
+
+* Improve the YAML compile cache to support `UTF-8` symbols. (#398, #399)
+  [The default `MessagePack` symbol serializer assumes all symbols are ASCII](https://github.com/msgpack/msgpack-ruby/pull/211),
+  because of this, non-ASCII compatible symbol would be restored with `ASCII_8BIT` encoding (AKA `BINARY`).
+  Bootsnap now properly cache them in `UTF-8`.
+
+  Note that the above only apply for actual YAML symbols (e..g `--- :foo`).
+  The issue is still present for string keys parsed with `YAML.load_file(..., symbolize_names: true)`, that is a bug
+  in `msgpack` that will hopefully be solved soon, see: https://github.com/msgpack/msgpack-ruby/pull/246
+
+* Entirely disable the YAML compile cache if `Encoding.default_internal` is set to an encoding not supported by `msgpack`. (#398)
+  `Psych` coerce strings to `Encoding.default_internal`, but `MessagePack` doesn't. So in this scenario we can't provide
+  YAML caching at all without returning the strings in the wrong encoding.
+  This never came up in practice but might as well be safe.
+
 # 1.10.2
 
 * Reduce the `Kernel.require` extra stack frames some more. Now bootsnap should only add one extra frame per `require` call.
@@ -22,7 +40,7 @@
   Since `1.8.0`, `YAML.load_file` was no longer cached when Psych 4 was used. This is because `load_file` loads
   in safe mode by default, so the Bootsnap cache could defeat that safety.
   Now when precompiling YAML files, Bootsnap first try to parse them in safe mode, and if it can't fallback to unsafe mode,
-  and the cache contains a flag that records wether it was generated in safe mode or not.
+  and the cache contains a flag that records whether it was generated in safe mode or not.
   `YAML.unsafe_load_file` will use safe caches just fine, but `YAML.load_file` will fallback to uncached YAML parsing
   if the cache was generated using unsafe parsing.
 
@@ -63,7 +81,7 @@
 
 # 1.8.0
 
-* Improve support for Pysch 4. (#368)
+* Improve support for Psych 4. (#368)
 
 # 1.7.7
 
@@ -81,8 +99,8 @@
 
 # 1.7.4
 
-* Stop raising errors when encoutering various file system errors. The cache is now best effort,
-  if somehow it can't be saved, bootsnapp will gracefully fallback to the original operation (e.g. `Kernel.require`).
+* Stop raising errors when encountering various file system errors. The cache is now best effort,
+  if somehow it can't be saved, bootsnap will gracefully fallback to the original operation (e.g. `Kernel.require`).
   (#353, #177, #262)
 
 # 1.7.3

data/ext/bootsnap/bootsnap.c

@@ -2,7 +2,7 @@
  * Suggested reading order:
  * 1. Skim Init_bootsnap
  * 2. Skim bs_fetch
- * 3. The rest of everything
+ * 3. The rest of everyrything
  *
  * Init_bootsnap sets up the ruby objects and binds bs_fetch to
  * Bootsnap::CompileCache::Native.fetch.

data/lib/bootsnap/compile_cache/yaml.rb

@@ -5,7 +5,15 @@ require("bootsnap/bootsnap")
 module Bootsnap
   module CompileCache
     module YAML
-      UnsupportedTags = Class.new(StandardError)
+      Uncompilable = Class.new(StandardError)
+      UnsupportedTags = Class.new(Uncompilable)
+
+      SUPPORTED_INTERNAL_ENCODINGS = [
+        nil, # UTF-8
+        Encoding::UTF_8,
+        Encoding::ASCII,
+        Encoding::BINARY,
+      ].freeze
 
       class << self
         attr_accessor(:msgpack_factory, :supported_options)
@@ -16,7 +24,9 @@ module Bootsnap
         end
 
         def precompile(path)
-          Bootsnap::CompileCache::Native.precompile(
+          return false unless CompileCache::YAML.supported_internal_encoding?
+
+          CompileCache::Native.precompile(
             cache_dir,
             path.to_s,
             @implementation,
@@ -29,6 +39,21 @@ module Bootsnap
           ::YAML.singleton_class.prepend(@implementation::Patch)
         end
 
+        # Psych coerce strings to `Encoding.default_internal` but Message Pack only support
+        # UTF-8, US-ASCII and BINARY. So if Encoding.default_internal is set to anything else
+        # we can't safely use the cache
+        def supported_internal_encoding?
+          SUPPORTED_INTERNAL_ENCODINGS.include?(Encoding.default_internal)
+        end
+
+        module EncodingAwareSymbols
+          extend self
+
+          def unpack(payload)
+            (+payload).force_encoding(Encoding::UTF_8).to_sym
+          end
+        end
+
         def init!
           require("yaml")
           require("msgpack")
@@ -43,7 +68,12 @@ module Bootsnap
           # We want them to roundtrip cleanly, so we use a custom factory.
           # see: https://github.com/msgpack/msgpack-ruby/pull/122
           factory = MessagePack::Factory.new
-          factory.register_type(0x00, Symbol)
+          factory.register_type(
+            0x00,
+            Symbol,
+            packer: :to_msgpack_ext,
+            unpacker: EncodingAwareSymbols.method(:unpack).to_proc,
+          )
 
           if defined? MessagePack::Timestamp
             factory.register_type(
@@ -119,13 +149,15 @@ module Bootsnap
           extend self
 
           def input_to_storage(contents, _)
-            obj = CompileCache::YAML.strict_load(contents)
+            obj = ::YAML.unsafe_load(contents)
             packer = CompileCache::YAML.msgpack_factory.packer
             packer.pack(false) # not safe loaded
-            packer.pack(obj)
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE # The object included things that we can't serialize
+            end
             packer.to_s
-          rescue NoMethodError, RangeError, UnsupportedTags
-            UNCOMPILABLE # The object included things that we can't serialize
           end
 
           def storage_to_output(data, kwargs)
@@ -148,13 +180,20 @@ module Bootsnap
           extend self
 
           def input_to_storage(contents, _)
-            obj = ::YAML.load(contents)
+            obj = begin
+              CompileCache::YAML.strict_load(contents)
+            rescue Psych::DisallowedClass, Psych::BadAlias, Uncompilable
+              return UNCOMPILABLE
+            end
+
             packer = CompileCache::YAML.msgpack_factory.packer
             packer.pack(true) # safe loaded
-            packer.pack(obj)
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE
+            end
             packer.to_s
-          rescue NoMethodError, RangeError, Psych::DisallowedClass, Psych::BadAlias
-            UNCOMPILABLE # The object included things that we can't serialize
           end
 
           def storage_to_output(data, kwargs)
@@ -179,44 +218,48 @@ module Bootsnap
 
         module Patch
           def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych4::SafeLoad,
+                CompileCache::YAML::Psych4::SafeLoad,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
           ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
 
           def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych4::UnsafeLoad,
+                CompileCache::YAML::Psych4::UnsafeLoad,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
@@ -228,13 +271,15 @@ module Bootsnap
         extend self
 
         def input_to_storage(contents, _)
-          obj = CompileCache::YAML.strict_load(contents)
+          obj = ::YAML.load(contents)
           packer = CompileCache::YAML.msgpack_factory.packer
           packer.pack(false) # not safe loaded
-          packer.pack(obj)
+          begin
+            packer.pack(obj)
+          rescue NoMethodError, RangeError
+            return UNCOMPILABLE # The object included things that we can't serialize
+          end
           packer.to_s
-        rescue NoMethodError, RangeError, UnsupportedTags
-          UNCOMPILABLE # The object included things that we can't serialize
         end
 
         def storage_to_output(data, kwargs)
@@ -253,44 +298,48 @@ module Bootsnap
 
         module Patch
           def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych3,
+                CompileCache::YAML::Psych3,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 
           ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
 
           def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
             return super if args.size > 1
 
             if (kwargs = args.first)
               return super unless kwargs.is_a?(Hash)
-              return super unless (kwargs.keys - ::Bootsnap::CompileCache::YAML.supported_options).empty?
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
             end
 
             begin
-              ::Bootsnap::CompileCache::Native.fetch(
-                Bootsnap::CompileCache::YAML.cache_dir,
+              CompileCache::Native.fetch(
+                CompileCache::YAML.cache_dir,
                 File.realpath(path),
-                ::Bootsnap::CompileCache::YAML::Psych3,
+                CompileCache::YAML::Psych3,
                 kwargs,
               )
             rescue Errno::EACCES
-              ::Bootsnap::CompileCache.permission_error(path)
+              CompileCache.permission_error(path)
             end
           end
 

data/lib/bootsnap/compile_cache.rb

@@ -3,6 +3,9 @@
 module Bootsnap
   module CompileCache
     UNCOMPILABLE = BasicObject.new
+    def UNCOMPILABLE.inspect
+      "<Bootsnap::UNCOMPILABLE>"
+    end
 
     Error = Class.new(StandardError)
     PermissionError = Class.new(Error)

data/lib/bootsnap/version.rb

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

data/lib/bootsnap.rb

@@ -10,128 +10,128 @@ module Bootsnap
 
   class << self
     attr_reader :logger
-  end
-
-  def self.log!
-    self.logger = $stderr.method(:puts)
-  end
 
-  def self.logger=(logger)
-    @logger = logger
-    self.instrumentation = if logger.respond_to?(:debug)
-      ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") }
-    else
-      ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") }
+    def log!
+      self.logger = $stderr.method(:puts)
     end
-  end
 
-  def self.instrumentation=(callback)
-    @instrumentation = callback
-    if respond_to?(:instrumentation_enabled=, true)
-      self.instrumentation_enabled = !!callback
+    def logger=(logger)
+      @logger = logger
+      self.instrumentation = if logger.respond_to?(:debug)
+        ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") }
+      else
+        ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") }
+      end
     end
-  end
-
-  def self._instrument(event, path)
-    @instrumentation.call(event, path)
-  end
 
-  def self.setup(
-    cache_dir:,
-    development_mode: true,
-    load_path_cache: true,
-    autoload_paths_cache: nil,
-    disable_trace: nil,
-    compile_cache_iseq: true,
-    compile_cache_yaml: true,
-    compile_cache_json: true
-  )
-    unless autoload_paths_cache.nil?
-      warn "[DEPRECATED] Bootsnap's `autoload_paths_cache:` option is deprecated and will be removed. " \
-        "If you use Zeitwerk this option is useless, and if you are still using the classic autoloader " \
-        "upgrading is recommended."
+    def instrumentation=(callback)
+      @instrumentation = callback
+      if respond_to?(:instrumentation_enabled=, true)
+        self.instrumentation_enabled = !!callback
+      end
     end
 
-    unless disable_trace.nil?
-      warn "[DEPRECATED] Bootsnap's `disable_trace:` option is deprecated and will be removed. " \
-        "If you use Ruby 2.5 or newer this option is useless, if not upgrading is recommended."
+    def _instrument(event, path)
+      @instrumentation.call(event, path)
     end
 
-    if compile_cache_iseq && !iseq_cache_supported?
-      warn "Ruby 2.5 has a bug that break code tracing when code is loaded from cache. It is recommened " \
-        "to turn `compile_cache_iseq` off on Ruby 2.5"
-    end
+    def setup(
+      cache_dir:,
+      development_mode: true,
+      load_path_cache: true,
+      autoload_paths_cache: nil,
+      disable_trace: nil,
+      compile_cache_iseq: true,
+      compile_cache_yaml: true,
+      compile_cache_json: true
+    )
+      unless autoload_paths_cache.nil?
+        warn "[DEPRECATED] Bootsnap's `autoload_paths_cache:` option is deprecated and will be removed. " \
+          "If you use Zeitwerk this option is useless, and if you are still using the classic autoloader " \
+          "upgrading is recommended."
+      end
 
-    if load_path_cache
-      Bootsnap::LoadPathCache.setup(
-        cache_path: cache_dir + "/bootsnap/load-path-cache",
-        development_mode: development_mode,
-      )
-    end
+      unless disable_trace.nil?
+        warn "[DEPRECATED] Bootsnap's `disable_trace:` option is deprecated and will be removed. " \
+          "If you use Ruby 2.5 or newer this option is useless, if not upgrading is recommended."
+      end
 
-    Bootsnap::CompileCache.setup(
-      cache_dir: cache_dir + "/bootsnap/compile-cache",
-      iseq: compile_cache_iseq,
-      yaml: compile_cache_yaml,
-      json: compile_cache_json,
-    )
-  end
+      if compile_cache_iseq && !iseq_cache_supported?
+        warn "Ruby 2.5 has a bug that break code tracing when code is loaded from cache. It is recommened " \
+          "to turn `compile_cache_iseq` off on Ruby 2.5"
+      end
 
-  def self.iseq_cache_supported?
-    return @iseq_cache_supported if defined? @iseq_cache_supported
+      if load_path_cache
+        Bootsnap::LoadPathCache.setup(
+          cache_path: cache_dir + "/bootsnap/load-path-cache",
+          development_mode: development_mode,
+        )
+      end
 
-    ruby_version = Gem::Version.new(RUBY_VERSION)
-    @iseq_cache_supported = ruby_version < Gem::Version.new("2.5.0") || ruby_version >= Gem::Version.new("2.6.0")
-  end
+      Bootsnap::CompileCache.setup(
+        cache_dir: cache_dir + "/bootsnap/compile-cache",
+        iseq: compile_cache_iseq,
+        yaml: compile_cache_yaml,
+        json: compile_cache_json,
+      )
+    end
 
-  def self.default_setup
-    env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
-    development_mode = ["", nil, "development"].include?(env)
+    def iseq_cache_supported?
+      return @iseq_cache_supported if defined? @iseq_cache_supported
 
-    unless ENV["DISABLE_BOOTSNAP"]
-      cache_dir = ENV["BOOTSNAP_CACHE_DIR"]
-      unless cache_dir
-        config_dir_frame = caller.detect do |line|
-          line.include?("/config/")
-        end
+      ruby_version = Gem::Version.new(RUBY_VERSION)
+      @iseq_cache_supported = ruby_version < Gem::Version.new("2.5.0") || ruby_version >= Gem::Version.new("2.6.0")
+    end
 
-        unless config_dir_frame
-          $stderr.puts("[bootsnap/setup] couldn't infer cache directory! Either:")
-          $stderr.puts("[bootsnap/setup]   1. require bootsnap/setup from your application's config directory; or")
-          $stderr.puts("[bootsnap/setup]   2. Define the environment variable BOOTSNAP_CACHE_DIR")
+    def default_setup
+      env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
+      development_mode = ["", nil, "development"].include?(env)
 
-          raise("couldn't infer bootsnap cache directory")
-        end
+      unless ENV["DISABLE_BOOTSNAP"]
+        cache_dir = ENV["BOOTSNAP_CACHE_DIR"]
+        unless cache_dir
+          config_dir_frame = caller.detect do |line|
+            line.include?("/config/")
+          end
 
-        path = config_dir_frame.split(/:\d+:/).first
-        path = File.dirname(path) until File.basename(path) == "config"
-        app_root = File.dirname(path)
+          unless config_dir_frame
+            $stderr.puts("[bootsnap/setup] couldn't infer cache directory! Either:")
+            $stderr.puts("[bootsnap/setup]   1. require bootsnap/setup from your application's config directory; or")
+            $stderr.puts("[bootsnap/setup]   2. Define the environment variable BOOTSNAP_CACHE_DIR")
 
-        cache_dir = File.join(app_root, "tmp", "cache")
-      end
+            raise("couldn't infer bootsnap cache directory")
+          end
 
-      setup(
-        cache_dir: cache_dir,
-        development_mode: development_mode,
-        load_path_cache: !ENV["DISABLE_BOOTSNAP_LOAD_PATH_CACHE"],
-        compile_cache_iseq: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"] && iseq_cache_supported?,
-        compile_cache_yaml: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-        compile_cache_json: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
-      )
+          path = config_dir_frame.split(/:\d+:/).first
+          path = File.dirname(path) until File.basename(path) == "config"
+          app_root = File.dirname(path)
+
+          cache_dir = File.join(app_root, "tmp", "cache")
+        end
 
-      if ENV["BOOTSNAP_LOG"]
-        log!
+        setup(
+          cache_dir: cache_dir,
+          development_mode: development_mode,
+          load_path_cache: !ENV["DISABLE_BOOTSNAP_LOAD_PATH_CACHE"],
+          compile_cache_iseq: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"] && iseq_cache_supported?,
+          compile_cache_yaml: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
+          compile_cache_json: !ENV["DISABLE_BOOTSNAP_COMPILE_CACHE"],
+        )
+
+        if ENV["BOOTSNAP_LOG"]
+          log!
+        end
       end
     end
-  end
 
-  if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
-    def self.absolute_path?(path)
-      path[1] == ":"
-    end
-  else
-    def self.absolute_path?(path)
-      path.start_with?("/")
+    if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+      def absolute_path?(path)
+        path[1] == ":"
+      end
+    else
+      def absolute_path?(path)
+        path.start_with?("/")
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.10.2
+  version: 1.10.3
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-01-21 00:00:00.000000000 Z
+date: 2022-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack