bootsnap 1.6.0 → 1.18.3

data/lib/bootsnap/compile_cache/yaml.rb

@@ -1,72 +1,111 @@
 # frozen_string_literal: true
-require('bootsnap/bootsnap')
+
+require "bootsnap/bootsnap"
 
 module Bootsnap
   module CompileCache
     module YAML
-      class << self
-        attr_accessor(:msgpack_factory, :cache_dir, :supported_options)
+      Uncompilable = Class.new(StandardError)
+      UnsupportedTags = Class.new(Uncompilable)
 
-        def input_to_storage(contents, _)
-          raise(Uncompilable) if contents.index("!ruby/object")
-          obj = ::YAML.load(contents)
-          msgpack_factory.dump(obj)
-        rescue NoMethodError, RangeError
-          # The object included things that we can't serialize
-          raise(Uncompilable)
-        end
+      SUPPORTED_INTERNAL_ENCODINGS = [
+        nil, # UTF-8
+        Encoding::UTF_8,
+        Encoding::ASCII,
+        Encoding::BINARY,
+      ].freeze
 
-        def storage_to_output(data, kwargs)
-          if kwargs && kwargs.key?(:symbolize_names)
-            kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
-          end
-          msgpack_factory.load(data, kwargs)
-        end
+      class << self
+        attr_accessor(:msgpack_factory, :supported_options)
+        attr_reader(:implementation, :cache_dir)
 
-        def input_to_output(data, kwargs)
-          ::YAML.load(data, **(kwargs || {}))
+        def cache_dir=(cache_dir)
+          @cache_dir = cache_dir.end_with?("/") ? "#{cache_dir}yaml" : "#{cache_dir}-yaml"
         end
 
-        def precompile(path, cache_dir: YAML.cache_dir)
-          Bootsnap::CompileCache::Native.precompile(
+        def precompile(path)
+          return false unless CompileCache::YAML.supported_internal_encoding?
+
+          CompileCache::Native.precompile(
             cache_dir,
             path.to_s,
-            Bootsnap::CompileCache::YAML,
+            @implementation,
           )
         end
 
         def install!(cache_dir)
           self.cache_dir = cache_dir
           init!
-          ::YAML.singleton_class.prepend(Patch)
+          ::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')
-          require('date')
+          require "yaml"
+          require "msgpack"
+          require "date"
+
+          @implementation = ::YAML::VERSION >= "4" ? Psych4 : Psych3
+          if @implementation::Patch.method_defined?(:unsafe_load_file) && !::YAML.respond_to?(:unsafe_load_file)
+            @implementation::Patch.send(:remove_method, :unsafe_load_file)
+          end
+
+          unless const_defined?(:NoTagsVisitor)
+            visitor = Class.new(Psych::Visitors::NoAliasRuby) do
+              def visit(target)
+                if target.tag
+                  raise UnsupportedTags, "YAML tags are not supported: #{target.tag}"
+                end
+
+                super
+              end
+            end
+            const_set(:NoTagsVisitor, visitor)
+          end
 
           # MessagePack serializes symbols as strings by default.
           # 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(
-            MessagePack::Timestamp::TYPE, # or just -1
-            Time,
-            packer: MessagePack::Time::Packer,
-            unpacker: MessagePack::Time::Unpacker
+            0x00,
+            Symbol,
+            packer: :to_msgpack_ext,
+            unpacker: EncodingAwareSymbols.method(:unpack).to_proc,
           )
 
-          marshal_fallback = {
-            packer: ->(value) { Marshal.dump(value) },
-            unpacker: ->(payload) { Marshal.load(payload) },
-          }
-          {
-            Date => 0x01,
-            Regexp => 0x02,
-          }.each do |type, code|
-            factory.register_type(code, type, marshal_fallback)
+          if defined? MessagePack::Timestamp
+            factory.register_type(
+              MessagePack::Timestamp::TYPE, # or just -1
+              Time,
+              packer: MessagePack::Time::Packer,
+              unpacker: MessagePack::Time::Unpacker,
+            )
+
+            marshal_fallback = {
+              packer: ->(value) { Marshal.dump(value) },
+              unpacker: ->(payload) { Marshal.load(payload) },
+            }
+            {
+              Date => 0x01,
+              Regexp => 0x02,
+            }.each do |type, code|
+              factory.register_type(code, type, marshal_fallback)
+            end
           end
 
           self.msgpack_factory = factory
@@ -74,38 +113,224 @@ module Bootsnap
           self.supported_options = []
           params = ::YAML.method(:load).parameters
           if params.include?([:key, :symbolize_names])
-            self.supported_options << :symbolize_names
+            supported_options << :symbolize_names
           end
-          if params.include?([:key, :freeze])
-            if factory.load(factory.dump('yaml'), freeze: true).frozen?
-              self.supported_options << :freeze
-            end
+          if params.include?([:key, :freeze]) && factory.load(factory.dump("yaml"), freeze: true).frozen?
+            supported_options << :freeze
           end
-          self.supported_options.freeze
+          supported_options.freeze
+        end
+
+        def patch
+          @implementation::Patch
+        end
+
+        def strict_load(payload)
+          ast = ::YAML.parse(payload)
+          return ast unless ast
+
+          loader = ::Psych::ClassLoader::Restricted.new(["Symbol"], [])
+          scanner = ::Psych::ScalarScanner.new(loader)
+
+          NoTagsVisitor.new(scanner, loader).visit(ast)
         end
       end
 
-      module Patch
-        def load_file(path, *args)
-          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?
+      module Psych4
+        extend self
+
+        def input_to_storage(contents, _)
+          obj = SafeLoad.input_to_storage(contents, nil)
+          if UNCOMPILABLE.equal?(obj)
+            obj = UnsafeLoad.input_to_storage(contents, nil)
           end
+          obj
+        end
 
-          begin
-            ::Bootsnap::CompileCache::Native.fetch(
-              Bootsnap::CompileCache::YAML.cache_dir,
-              path,
-              ::Bootsnap::CompileCache::YAML,
+        module UnsafeLoad
+          extend self
+
+          def input_to_storage(contents, _)
+            obj = ::YAML.unsafe_load(contents)
+            packer = CompileCache::YAML.msgpack_factory.packer
+            packer.pack(false) # not safe loaded
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE # The object included things that we can't serialize
+            end
+            packer.to_s
+          end
+
+          def storage_to_output(data, kwargs)
+            if kwargs&.key?(:symbolize_names)
+              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+            end
+
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker.feed(data)
+            _safe_loaded = unpacker.unpack
+            unpacker.unpack
+          end
+
+          def input_to_output(data, kwargs)
+            ::YAML.unsafe_load(data, **(kwargs || {}))
+          end
+        end
+
+        module SafeLoad
+          extend self
+
+          def input_to_storage(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
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE
+            end
+            packer.to_s
+          end
+
+          def storage_to_output(data, kwargs)
+            if kwargs&.key?(:symbolize_names)
+              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+            end
+
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker.feed(data)
+            safe_loaded = unpacker.unpack
+            if safe_loaded
+              unpacker.unpack
+            else
+              UNCOMPILABLE
+            end
+          end
+
+          def input_to_output(data, kwargs)
+            ::YAML.load(data, **(kwargs || {}))
+          end
+        end
+
+        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 - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              File.realpath(path),
+              CompileCache::YAML::Psych4::SafeLoad,
+              kwargs,
+            )
+          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 - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              File.realpath(path),
+              CompileCache::YAML::Psych4::UnsafeLoad,
               kwargs,
             )
-          rescue Errno::EACCES
-            ::Bootsnap::CompileCache.permission_error(path)
           end
+
+          ruby2_keywords :unsafe_load_file if respond_to?(:ruby2_keywords, true)
+        end
+      end
+
+      module Psych3
+        extend self
+
+        def input_to_storage(contents, _)
+          obj = ::YAML.load(contents)
+          packer = CompileCache::YAML.msgpack_factory.packer
+          packer.pack(false) # not safe loaded
+          begin
+            packer.pack(obj)
+          rescue NoMethodError, RangeError
+            return UNCOMPILABLE # The object included things that we can't serialize
+          end
+          packer.to_s
+        end
+
+        def storage_to_output(data, kwargs)
+          if kwargs&.key?(:symbolize_names)
+            kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+          end
+          unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+          unpacker.feed(data)
+          _safe_loaded = unpacker.unpack
+          unpacker.unpack
+        end
+
+        def input_to_output(data, kwargs)
+          ::YAML.load(data, **(kwargs || {}))
         end
 
-        ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
+        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 - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              File.realpath(path),
+              CompileCache::YAML::Psych3,
+              kwargs,
+            )
+          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 - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              File.realpath(path),
+              CompileCache::YAML::Psych3,
+              kwargs,
+            )
+          end
+
+          ruby2_keywords :unsafe_load_file if respond_to?(:ruby2_keywords, true)
+        end
       end
     end
   end

data/lib/bootsnap/compile_cache.rb

@@ -1,13 +1,18 @@
 # frozen_string_literal: true
+
 module Bootsnap
   module CompileCache
-    Error           = Class.new(StandardError)
-    PermissionError = Class.new(Error)
+    UNCOMPILABLE = BasicObject.new
+    def UNCOMPILABLE.inspect
+      "<Bootsnap::UNCOMPILABLE>"
+    end
+
+    Error = Class.new(StandardError)
 
-    def self.setup(cache_dir:, iseq:, yaml:)
+    def self.setup(cache_dir:, iseq:, yaml:, json:, readonly: false, revalidation: false)
       if iseq
         if supported?
-          require_relative('compile_cache/iseq')
+          require_relative "compile_cache/iseq"
           Bootsnap::CompileCache::ISeq.install!(cache_dir)
         elsif $VERBOSE
           warn("[bootsnap/setup] bytecode caching is not supported on this implementation of Ruby")
@@ -16,28 +21,32 @@ module Bootsnap
 
       if yaml
         if supported?
-          require_relative('compile_cache/yaml')
+          require_relative "compile_cache/yaml"
           Bootsnap::CompileCache::YAML.install!(cache_dir)
         elsif $VERBOSE
           warn("[bootsnap/setup] YAML parsing caching is not supported on this implementation of Ruby")
         end
       end
-    end
 
-    def self.permission_error(path)
-      cpath = Bootsnap::CompileCache::ISeq.cache_dir
-      raise(
-        PermissionError,
-        "bootsnap doesn't have permission to write cache entries in '#{cpath}' " \
-        "(or, less likely, doesn't have permission to read '#{path}')",
-      )
+      if json
+        if supported?
+          require_relative "compile_cache/json"
+          Bootsnap::CompileCache::JSON.install!(cache_dir)
+        elsif $VERBOSE
+          warn("[bootsnap/setup] JSON parsing caching is not supported on this implementation of Ruby")
+        end
+      end
+
+      if supported? && defined?(Bootsnap::CompileCache::Native)
+        Bootsnap::CompileCache::Native.readonly = readonly
+        Bootsnap::CompileCache::Native.revalidation = revalidation
+      end
     end
 
     def self.supported?
-      # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), Windows (RubyInstaller2) and >= 2.3.0
-      RUBY_ENGINE == 'ruby' &&
-      RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/ &&
-      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
+      # only enable on 'ruby' (MRI) and TruffleRuby for POSIX (darwin, linux, *bsd), Windows (RubyInstaller2)
+      %w[ruby truffleruby].include?(RUBY_ENGINE) &&
+        RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
     end
   end
 end

data/lib/bootsnap/explicit_require.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
+
 module Bootsnap
   module ExplicitRequire
-    ARCHDIR    = RbConfig::CONFIG['archdir']
-    RUBYLIBDIR = RbConfig::CONFIG['rubylibdir']
-    DLEXT      = RbConfig::CONFIG['DLEXT']
+    ARCHDIR    = RbConfig::CONFIG["archdir"]
+    RUBYLIBDIR = RbConfig::CONFIG["rubylibdir"]
+    DLEXT      = RbConfig::CONFIG["DLEXT"]
 
     def self.from_self(feature)
       require_relative("../#{feature}")