bootsnap 1.1.8-java → 1.6.0

data/lib/bootsnap/compile_cache.rb

@@ -1,15 +1,43 @@
+# frozen_string_literal: true
 module Bootsnap
   module CompileCache
+    Error           = Class.new(StandardError)
+    PermissionError = Class.new(Error)
+
     def self.setup(cache_dir:, iseq:, yaml:)
       if iseq
-        require_relative 'compile_cache/iseq'
-        Bootsnap::CompileCache::ISeq.install!(cache_dir)
+        if supported?
+          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")
+        end
       end
 
       if yaml
-        require_relative 'compile_cache/yaml'
-        Bootsnap::CompileCache::YAML.install!(cache_dir)
+        if supported?
+          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}')",
+      )
+    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")
+    end
   end
 end

data/lib/bootsnap/compile_cache/iseq.rb

@@ -1,31 +1,49 @@
-require 'bootsnap/bootsnap'
-require 'zlib'
+# frozen_string_literal: true
+require('bootsnap/bootsnap')
+require('zlib')
 
 module Bootsnap
   module CompileCache
     module ISeq
       class << self
-        attr_accessor :cache_dir
+        attr_accessor(:cache_dir)
       end
 
       def self.input_to_storage(_, path)
         RubyVM::InstructionSequence.compile_file(path).to_binary
       rescue SyntaxError
-        raise Uncompilable, 'syntax error'
+        raise(Uncompilable, 'syntax error')
       end
 
-      def self.storage_to_output(binary)
+      def self.storage_to_output(binary, _args)
         RubyVM::InstructionSequence.load_from_binary(binary)
       rescue RuntimeError => e
         if e.message == 'broken binary format'
-          STDERR.puts "[Bootsnap::CompileCache] warning: rejecting broken binary"
-          return nil
+          STDERR.puts("[Bootsnap::CompileCache] warning: rejecting broken binary")
+          nil
         else
           raise
         end
       end
 
-      def self.input_to_output(_)
+      def self.fetch(path, cache_dir: ISeq.cache_dir)
+        Bootsnap::CompileCache::Native.fetch(
+          cache_dir,
+          path.to_s,
+          Bootsnap::CompileCache::ISeq,
+          nil,
+        )
+      end
+
+      def self.precompile(path, cache_dir: ISeq.cache_dir)
+        Bootsnap::CompileCache::Native.precompile(
+          cache_dir,
+          path.to_s,
+          Bootsnap::CompileCache::ISeq,
+        )
+      end
+
+      def self.input_to_output(_data, _kwargs)
         nil # ruby handles this
       end
 
@@ -34,14 +52,12 @@ module Bootsnap
           # Having coverage enabled prevents iseq dumping/loading.
           return nil if defined?(Coverage) && Bootsnap::CompileCache::Native.coverage_running?
 
-          Bootsnap::CompileCache::Native.fetch(
-            Bootsnap::CompileCache::ISeq.cache_dir,
-            path.to_s,
-            Bootsnap::CompileCache::ISeq
-          )
+          Bootsnap::CompileCache::ISeq.fetch(path.to_s)
+        rescue Errno::EACCES
+          Bootsnap::CompileCache.permission_error(path)
         rescue RuntimeError => e
           if e.message =~ /unmatched platform/
-            puts "unmatched platform for file #{path}"
+            puts("unmatched platform for file #{path}")
           end
           raise
         end
@@ -57,12 +73,13 @@ module Bootsnap
         crc = Zlib.crc32(option.inspect)
         Bootsnap::CompileCache::Native.compile_option_crc32 = crc
       end
+      compile_option_updated
 
       def self.install!(cache_dir)
         Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
         Bootsnap::CompileCache::ISeq.compile_option_updated
         class << RubyVM::InstructionSequence
-          prepend InstructionSequenceMixin
+          prepend(InstructionSequenceMixin)
         end
       end
     end

data/lib/bootsnap/compile_cache/yaml.rb

@@ -1,58 +1,112 @@
-require 'bootsnap/bootsnap'
+# frozen_string_literal: true
+require('bootsnap/bootsnap')
 
 module Bootsnap
   module CompileCache
     module YAML
       class << self
-        attr_accessor :msgpack_factory
-      end
-
-      def self.input_to_storage(contents, _)
-        raise Uncompilable if contents.index("!ruby/object")
-        obj = ::YAML.load(contents)
-        msgpack_factory.packer.write(obj).to_s
-      rescue NoMethodError, RangeError
-        # if the object included things that we can't serialize, fall back to
-        # Marshal. It's a bit slower, but can encode anything yaml can.
-        # NoMethodError is unexpected types; RangeError is Bignums
-        return Marshal.dump(obj)
-      end
+        attr_accessor(:msgpack_factory, :cache_dir, :supported_options)
 
-      def self.storage_to_output(data)
-        # This could have a meaning in messagepack, and we're being a little lazy
-        # about it. -- but a leading 0x04 would indicate the contents of the YAML
-        # is a positive integer, which is rare, to say the least.
-        if data[0] == 0x04.chr && data[1] == 0x08.chr
-          Marshal.load(data)
-        else
-          msgpack_factory.unpacker.feed(data).read
+        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
-      end
-
-      def self.input_to_output(data)
-        ::YAML.load(data)
-      end
 
-      def self.install!(cache_dir)
-        require 'yaml'
-        require 'msgpack'
+        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
 
-        # 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)
-        Bootsnap::CompileCache::YAML.msgpack_factory = factory
+        def input_to_output(data, kwargs)
+          ::YAML.load(data, **(kwargs || {}))
+        end
 
-        klass = class << ::YAML; self; end
-        klass.send(:define_method, :load_file) do |path|
-          Bootsnap::CompileCache::Native.fetch(
+        def precompile(path, cache_dir: YAML.cache_dir)
+          Bootsnap::CompileCache::Native.precompile(
             cache_dir,
             path.to_s,
-            Bootsnap::CompileCache::YAML
+            Bootsnap::CompileCache::YAML,
+          )
+        end
+
+        def install!(cache_dir)
+          self.cache_dir = cache_dir
+          init!
+          ::YAML.singleton_class.prepend(Patch)
+        end
+
+        def init!
+          require('yaml')
+          require('msgpack')
+          require('date')
+
+          # 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
           )
+
+          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
+
+          self.msgpack_factory = factory
+
+          self.supported_options = []
+          params = ::YAML.method(:load).parameters
+          if params.include?([:key, :symbolize_names])
+            self.supported_options << :symbolize_names
+          end
+          if params.include?([:key, :freeze])
+            if factory.load(factory.dump('yaml'), freeze: true).frozen?
+              self.supported_options << :freeze
+            end
+          end
+          self.supported_options.freeze
         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?
+          end
+
+          begin
+            ::Bootsnap::CompileCache::Native.fetch(
+              Bootsnap::CompileCache::YAML.cache_dir,
+              path,
+              ::Bootsnap::CompileCache::YAML,
+              kwargs,
+            )
+          rescue Errno::EACCES
+            ::Bootsnap::CompileCache.permission_error(path)
+          end
+        end
+
+        ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
+      end
     end
   end
 end

data/lib/bootsnap/explicit_require.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module ExplicitRequire
     ARCHDIR    = RbConfig::CONFIG['archdir']
@@ -5,7 +6,7 @@ module Bootsnap
     DLEXT      = RbConfig::CONFIG['DLEXT']
 
     def self.from_self(feature)
-      require_relative "../#{feature}"
+      require_relative("../#{feature}")
     end
 
     def self.from_rubylibdir(feature)

data/lib/bootsnap/load_path_cache.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Bootsnap
   module LoadPathCache
     ReturnFalse = Class.new(StandardError)
@@ -7,6 +9,11 @@ module Bootsnap
     DOT_SO = '.so'
     SLASH  = '/'
 
+    # If a NameError happens several levels deep, don't re-handle it
+    # all the way up the chain: mark it once and bubble it up without
+    # more retries.
+    ERROR_TAG_IVAR = :@__bootsnap_rescued
+
     DL_EXTENSIONS = ::RbConfig::CONFIG
       .values_at('DLEXT', 'DLEXT2')
       .reject { |ext| !ext || ext.empty? }
@@ -21,32 +28,51 @@ module Bootsnap
     CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
 
     class << self
-      attr_reader :load_path_cache, :autoload_paths_cache
+      attr_reader(:load_path_cache, :autoload_paths_cache,
+        :loaded_features_index, :realpath_cache)
 
       def setup(cache_path:, development_mode:, active_support: true)
+        unless supported?
+          warn("[bootsnap/setup] Load path caching is not supported on this implementation of Ruby") if $VERBOSE
+          return
+        end
+
         store = Store.new(cache_path)
 
+        @loaded_features_index = LoadedFeaturesIndex.new
+        @realpath_cache = RealpathCache.new
+
         @load_path_cache = Cache.new(store, $LOAD_PATH, development_mode: development_mode)
-        require_relative 'load_path_cache/core_ext/kernel_require'
+        require_relative('load_path_cache/core_ext/kernel_require')
+        require_relative('load_path_cache/core_ext/loaded_features')
 
         if active_support
           # this should happen after setting up the initial cache because it
           # loads a lot of code. It's better to do after +require+ is optimized.
-          require 'active_support/dependencies'
+          require('active_support/dependencies')
           @autoload_paths_cache = Cache.new(
             store,
             ::ActiveSupport::Dependencies.autoload_paths,
             development_mode: development_mode
           )
-          require_relative 'load_path_cache/core_ext/active_support'
+          require_relative('load_path_cache/core_ext/active_support')
         end
       end
+
+      def supported?
+        RUBY_ENGINE == 'ruby' &&
+        RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/
+      end
     end
   end
 end
 
-require_relative 'load_path_cache/path_scanner'
-require_relative 'load_path_cache/path'
-require_relative 'load_path_cache/cache'
-require_relative 'load_path_cache/store'
-require_relative 'load_path_cache/change_observer'
+if Bootsnap::LoadPathCache.supported?
+  require_relative('load_path_cache/path_scanner')
+  require_relative('load_path_cache/path')
+  require_relative('load_path_cache/cache')
+  require_relative('load_path_cache/store')
+  require_relative('load_path_cache/change_observer')
+  require_relative('load_path_cache/loaded_features_index')
+  require_relative('load_path_cache/realpath_cache')
+end

data/lib/bootsnap/load_path_cache/cache.rb

@@ -1,4 +1,6 @@
-require_relative '../explicit_require'
+# frozen_string_literal: true
+
+require_relative('../explicit_require')
 
 module Bootsnap
   module LoadPathCache
@@ -9,15 +11,15 @@ module Bootsnap
         @development_mode = development_mode
         @store = store
         @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
-        @path_obj = path_obj
+        @path_obj = path_obj.map! { |f| File.exist?(f) ? File.realpath(f) : f }
         @has_relative_paths = nil
         reinitialize
       end
 
-      # Does this directory exist as a child of one of the path items?
-      # e.g. given "/a/b/c/d" exists, and the path is ["/a/b"], has_dir?("c/d")
-      # is true.
-      def has_dir?(dir)
+      # What is the path item that contains the dir as child?
+      # e.g. given "/a/b/c/d" exists, and the path is ["/a/b"], load_dir("c/d")
+      # is "/a/b".
+      def load_dir(dir)
         reinitialize if stale?
         @mutex.synchronize { @dirs[dir] }
       end
@@ -44,9 +46,9 @@ module Bootsnap
       # loadpath.
       def find(feature)
         reinitialize if (@has_relative_paths && dir_changed?) || stale?
-        feature = feature.to_s
+        feature = feature.to_s.freeze
         return feature if absolute_path?(feature)
-        return File.expand_path(feature) if feature.start_with?('./')
+        return expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
           x = search_index(feature)
           return x if x
@@ -56,7 +58,7 @@ module Bootsnap
           # returns false as if it were already loaded; however, there is no
           # file to find on disk. We've pre-built a list of these, and we
           # return false if any of them is loaded.
-          raise LoadPathCache::ReturnFalse if BUILTIN_FEATURES.key?(feature)
+          raise(LoadPathCache::ReturnFalse, '', []) if BUILTIN_FEATURES.key?(feature)
 
           # The feature wasn't found on our preliminary search through the index.
           # We resolve this differently depending on what the extension was.
@@ -65,7 +67,7 @@ module Bootsnap
           # native dynamic extension, e.g. .bundle or .so), we know it was a
           # failure and there's nothing more we can do to find the file.
           # no extension, .rb, (.bundle or .so)
-          when '', *CACHED_EXTENSIONS # rubocop:disable Performance/CaseWhenSplat
+          when '', *CACHED_EXTENSIONS
             nil
           # Ruby allows specifying native extensions as '.so' even when DLEXT
           # is '.bundle'. This is where we handle that case.
@@ -73,14 +75,21 @@ module Bootsnap
             x = search_index(feature[0..-4] + DLEXT)
             return x if x
             if DLEXT2
-              search_index(feature[0..-4] + DLEXT2)
+              x = search_index(feature[0..-4] + DLEXT2)
+              return x if x
             end
           else
             # other, unknown extension. For example, `.rake`. Since we haven't
             # cached these, we legitimately need to run the load path search.
-            raise LoadPathCache::FallbackScan
+            raise(LoadPathCache::FallbackScan, '', [])
           end
         end
+
+        # In development mode, we don't want to confidently return failures for
+        # cases where the file doesn't appear to be on the load path. We should
+        # be able to detect newly-created files without rebooting the
+        # application.
+        raise(LoadPathCache::FallbackScan, '', []) if @development_mode
       end
 
       if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
@@ -103,20 +112,12 @@ module Bootsnap
         @mutex.synchronize { push_paths_locked(*paths) }
       end
 
-      def each_requirable
-        @mutex.synchronize do
-          @index.each do |rel, entry|
-            yield "#{entry}/#{rel}"
-          end
-        end
-      end
-
       def reinitialize(path_obj = @path_obj)
         @mutex.synchronize do
           @path_obj = path_obj
           ChangeObserver.register(self, @path_obj)
           @index = {}
-          @dirs = Hash.new(false)
+          @dirs = {}
           @generated_at = now
           push_paths_locked(*@path_obj)
         end
@@ -140,10 +141,11 @@ module Bootsnap
             p = Path.new(path)
             @has_relative_paths = true if p.relative?
             next if p.non_directory?
+            expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # push -> low precedence -> set only if unset
-            dirs.each    { |dir| @dirs[dir]  ||= true }
-            entries.each { |rel| @index[rel] ||= p.expanded_path }
+            dirs.each    { |dir| @dirs[dir] ||= path }
+            entries.each { |rel| @index[rel] ||= expanded_path }
           end
         end
       end
@@ -153,14 +155,19 @@ module Bootsnap
           paths.map(&:to_s).reverse_each do |path|
             p = Path.new(path)
             next if p.non_directory?
+            expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # unshift -> high precedence -> unconditional set
-            dirs.each    { |dir| @dirs[dir]  = true }
-            entries.each { |rel| @index[rel] = p.expanded_path }
+            dirs.each    { |dir| @dirs[dir]  = path }
+            entries.each { |rel| @index[rel] = expanded_path }
           end
         end
       end
 
+      def expand_path(feature)
+        maybe_append_extension(File.expand_path(feature))
+      end
+
       def stale?
         @development_mode && @generated_at + AGE_THRESHOLD < now
       end
@@ -171,19 +178,31 @@ module Bootsnap
 
       if DLEXT2
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f + DLEXT2) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index("#{f}#{DLEXT2}") || try_index(f)
+        end
+
+        def maybe_append_extension(f)
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || try_ext("#{f}#{DLEXT2}") || f
         end
       else
         def search_index(f)
-          try_index(f + DOT_RB) || try_index(f + DLEXT) || try_index(f)
+          try_index("#{f}#{DOT_RB}") || try_index("#{f}#{DLEXT}") || try_index(f)
+        end
+
+        def maybe_append_extension(f)
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || f
         end
       end
 
       def try_index(f)
-        if p = @index[f]
-          p + '/' + f
+        if (p = @index[f])
+          "#{p}/#{f}"
         end
       end
+
+      def try_ext(f)
+        f if File.exist?(f)
+      end
     end
   end
 end