bootsnap 1.4.4 → 1.4.9.rc1

data/ext/bootsnap/extconf.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require("mkmf")
 $CFLAGS << ' -O3 '
 $CFLAGS << ' -std=c99'

data/lib/bootsnap.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative('bootsnap/version')
 require_relative('bootsnap/bundler')
 require_relative('bootsnap/load_path_cache')

data/lib/bootsnap/bundler.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   extend(self)
 

data/lib/bootsnap/compile_cache.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module CompileCache
     Error           = Class.new(StandardError)
@@ -28,14 +29,14 @@ module Bootsnap
       raise(
         PermissionError,
         "bootsnap doesn't have permission to write cache entries in '#{cpath}' " \
-        "(or, less likely, doesn't have permisison to read '#{path}')",
+        "(or, less likely, doesn't have permission to read '#{path}')",
       )
     end
 
     def self.supported?
-      # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), and >= 2.3.0
+      # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), Windows (RubyInstaller2) and >= 2.3.0
       RUBY_ENGINE == 'ruby' &&
-      RUBY_PLATFORM =~ /darwin|linux|bsd/ &&
+      RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/ &&
       Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
     end
   end

data/lib/bootsnap/compile_cache/iseq.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require('bootsnap/bootsnap')
 require('zlib')
 
@@ -8,13 +9,13 @@ module Bootsnap
         attr_accessor(:cache_dir)
       end
 
-      def self.input_to_storage(_, path)
+      def self.input_to_storage(_, path, _args)
         RubyVM::InstructionSequence.compile_file(path).to_binary
       rescue SyntaxError
         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'
@@ -25,7 +26,7 @@ module Bootsnap
         end
       end
 
-      def self.input_to_output(_)
+      def self.input_to_output(_, _)
         nil # ruby handles this
       end
 
@@ -37,7 +38,8 @@ module Bootsnap
           Bootsnap::CompileCache::Native.fetch(
             Bootsnap::CompileCache::ISeq.cache_dir,
             path.to_s,
-            Bootsnap::CompileCache::ISeq
+            Bootsnap::CompileCache::ISeq,
+            nil,
           )
         rescue Errno::EACCES
           Bootsnap::CompileCache.permission_error(path)

data/lib/bootsnap/compile_cache/yaml.rb

@@ -1,59 +1,88 @@
+# frozen_string_literal: true
 require('bootsnap/bootsnap')
 
 module Bootsnap
   module CompileCache
     module YAML
       class << self
-        attr_accessor(:msgpack_factory)
-      end
+        attr_accessor(:msgpack_factory, :cache_dir, :supported_options)
 
-      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
-        Marshal.dump(obj)
-      end
+        def input_to_storage(contents, _, kwargs)
+          raise(Uncompilable) if contents.index("!ruby/object")
+          obj = ::YAML.load(contents, **(kwargs || {}))
+          msgpack_factory.dump(obj)
+        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
+          Marshal.dump(obj)
+        end
+
+        def storage_to_output(data, kwargs)
+          # 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.load(data, **(kwargs || {}))
+          end
+        end
 
-      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_output(data, kwargs)
+          ::YAML.load(data, **(kwargs || {}))
         end
-      end
 
-      def self.input_to_output(data)
-        ::YAML.load(data)
+        def install!(cache_dir)
+          self.cache_dir = cache_dir
+          init!
+          ::YAML.singleton_class.prepend(Patch)
+        end
+
+        def init!
+          require('yaml')
+          require('msgpack')
+
+          # 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)
+          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
 
-      def self.install!(cache_dir)
-        require('yaml')
-        require('msgpack')
+      module Patch
+        extend self
 
-        # 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 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
 
-        klass = class << ::YAML; self; end
-        klass.send(:define_method, :load_file) do |path|
           begin
-            Bootsnap::CompileCache::Native.fetch(
-              cache_dir,
+            ::Bootsnap::CompileCache::Native.fetch(
+              Bootsnap::CompileCache::YAML.cache_dir,
               path,
-              Bootsnap::CompileCache::YAML
+              ::Bootsnap::CompileCache::YAML,
+              kwargs,
             )
           rescue Errno::EACCES
-            Bootsnap::CompileCache.permission_error(path)
+            ::Bootsnap::CompileCache.permission_error(path)
           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']

data/lib/bootsnap/load_path_cache.rb

@@ -61,7 +61,7 @@ module Bootsnap
 
       def supported?
         RUBY_ENGINE == 'ruby' &&
-        RUBY_PLATFORM =~ /darwin|linux|bsd/
+        RUBY_PLATFORM =~ /darwin|linux|bsd|mswin|mingw|cygwin/
       end
     end
   end

data/lib/bootsnap/load_path_cache/cache.rb

@@ -46,7 +46,7 @@ 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 expand_path(feature) if feature.start_with?('./')
         @mutex.synchronize do
@@ -67,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.
@@ -144,7 +144,7 @@ module Bootsnap
             expanded_path = p.expanded_path
             entries, dirs = p.entries_and_dirs(@store)
             # push -> low precedence -> set only if unset
-            dirs.each    { |dir| @dirs[dir]  ||= path }
+            dirs.each    { |dir| @dirs[dir] ||= path }
             entries.each { |rel| @index[rel] ||= expanded_path }
           end
         end
@@ -178,25 +178,25 @@ 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
+          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
+          try_ext("#{f}#{DOT_RB}") || try_ext("#{f}#{DLEXT}") || f
         end
       end
 
       def try_index(f)
         if (p = @index[f])
-          p + '/' + f
+          "#{p}/#{f}"
         end
       end
 

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module LoadPathCache
     module ChangeObserver
@@ -25,7 +26,7 @@ module Bootsnap
           super
         end
 
-        # uniq! keeps the first occurance of each path, otherwise preserving
+        # uniq! keeps the first occurrence of each path, otherwise preserving
         # order, preserving the effective load path
         def uniq!(*args)
           ret = super

data/lib/bootsnap/load_path_cache/core_ext/active_support.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Bootsnap
   module LoadPathCache
     module CoreExt

data/lib/bootsnap/load_path_cache/core_ext/kernel_require.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
 module Bootsnap
   module LoadPathCache
     module CoreExt
       def self.make_load_error(path)
-        err = LoadError.new("cannot load such file -- #{path}")
+        err = LoadError.new(+"cannot load such file -- #{path}")
         err.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
         err.define_singleton_method(:path) { path }
         err
@@ -37,7 +38,11 @@ module Kernel
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    require_with_bootsnap_lfi(path)
+    fallback = true
+  ensure
+    if fallback
+      require_with_bootsnap_lfi(path)
+    end
   end
 
   alias_method(:require_relative_without_bootsnap, :require_relative)
@@ -55,7 +60,7 @@ module Kernel
     end
 
     # load also allows relative paths from pwd even when not in $:
-    if File.exist?(relative = File.expand_path(path))
+    if File.exist?(relative = File.expand_path(path).freeze)
       return load_without_bootsnap(relative, wrap)
     end
 
@@ -66,7 +71,11 @@ module Kernel
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    load_without_bootsnap(path, wrap)
+    fallback = true
+  ensure
+    if fallback
+      load_without_bootsnap(path, wrap)
+    end
   end
 end
 
@@ -87,6 +96,10 @@ class Module
   rescue Bootsnap::LoadPathCache::ReturnFalse
     false
   rescue Bootsnap::LoadPathCache::FallbackScan
-    autoload_without_bootsnap(const, path)
+    fallback = true
+  ensure
+    if fallback
+      autoload_without_bootsnap(const, path)
+    end
   end
 end

data/lib/bootsnap/load_path_cache/core_ext/loaded_features.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 class << $LOADED_FEATURES
   alias_method(:delete_without_bootsnap, :delete)
   def delete(key)

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -40,7 +40,7 @@ module Bootsnap
             # /a/b/lib/my/foo.rb
             #          ^^^^^^^^^
             short = feat[(lpe.length + 1)..-1]
-            stripped = strip_extension(short)
+            stripped = strip_extension_if_elidable(short)
             @lfi[short] = hash
             @lfi[stripped] = hash
           end
@@ -94,13 +94,14 @@ module Bootsnap
 
         hash = long.hash
 
-        # do we have 'bundler' or 'bundler.rb'?
-        altname = if File.extname(short) != ''
-          # strip the path from 'bundler.rb' -> 'bundler'
-          strip_extension(short)
-        elsif long && (ext = File.extname(long))
-          # get the extension from the expanded path if given
-          # 'bundler' + '.rb'
+        # Do we have a filename with an elidable extension, e.g.,
+        # 'bundler.rb', or 'libgit2.so'?
+        altname = if extension_elidable?(short)
+          # Strip the extension off, e.g. 'bundler.rb' -> 'bundler'.
+          strip_extension_if_elidable(short)
+        elsif long && (ext = File.extname(long.freeze))
+          # We already know the extension of the actual file this
+          # resolves to, so put that back on.
           short + ext
         end
 
@@ -117,8 +118,30 @@ module Bootsnap
       STRIP_EXTENSION = /\.[^.]*?$/
       private_constant(:STRIP_EXTENSION)
 
-      def strip_extension(f)
-        f.sub(STRIP_EXTENSION, '')
+      # Might Ruby automatically search for this extension if
+      # someone tries to 'require' the file without it? E.g. Ruby
+      # will implicitly try 'x.rb' if you ask for 'x'.
+      #
+      # This is complex and platform-dependent, and the Ruby docs are a little
+      # handwavy about what will be tried when and in what order.
+      # So optimistically pretend that all known elidable extensions
+      # will be tried on all platforms, and that people are unlikely
+      # to name files in a way that assumes otherwise.
+      # (E.g. It's unlikely that someone will know that their code
+      # will _never_ run on MacOS, and therefore think they can get away
+      # with calling a Ruby file 'x.dylib.rb' and then requiring it as 'x.dylib'.)
+      #
+      # See <https://ruby-doc.org/core-2.6.4/Kernel.html#method-i-require>.
+      def extension_elidable?(f)
+        f.to_s.end_with?('.rb', '.so', '.o', '.dll', '.dylib')
+      end
+
+      def strip_extension_if_elidable(f)
+        if extension_elidable?(f)
+          f.sub(STRIP_EXTENSION, '')
+        else
+          f
+        end
       end
     end
   end

data/lib/bootsnap/load_path_cache/path.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require_relative('path_scanner')
 
 module Bootsnap
@@ -20,7 +21,7 @@ module Bootsnap
       attr_reader(:path)
 
       def initialize(path)
-        @path = path.to_s
+        @path = path.to_s.freeze
       end
 
       # True if the path exists, but represents a non-directory object
@@ -59,7 +60,7 @@ module Bootsnap
       end
 
       def expanded_path
-        File.expand_path(path)
+        File.expand_path(path).freeze
       end
 
       private