bootsnap 1.5.1 → 1.7.2

data/lib/bootsnap/compile_cache/iseq.rb

@@ -9,7 +9,7 @@ module Bootsnap
         attr_accessor(:cache_dir)
       end
 
-      def self.input_to_storage(_, path, _args)
+      def self.input_to_storage(_, path)
         RubyVM::InstructionSequence.compile_file(path).to_binary
       rescue SyntaxError
         raise(Uncompilable, 'syntax error')
@@ -35,6 +35,14 @@ module Bootsnap
         )
       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

data/lib/bootsnap/compile_cache/yaml.rb

@@ -7,32 +7,34 @@ module Bootsnap
       class << self
         attr_accessor(:msgpack_factory, :cache_dir, :supported_options)
 
-        def input_to_storage(contents, _, kwargs)
+        def input_to_storage(contents, _)
           raise(Uncompilable) if contents.index("!ruby/object")
-          obj = ::YAML.load(contents, **(kwargs || {}))
+          obj = ::YAML.load(contents)
           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)
+          # The object included things that we can't serialize
+          raise(Uncompilable)
         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 || {}))
+          if kwargs && kwargs.key?(:symbolize_names)
+            kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
           end
+          msgpack_factory.load(data, kwargs)
         end
 
         def input_to_output(data, kwargs)
           ::YAML.load(data, **(kwargs || {}))
         end
 
+        def precompile(path, cache_dir: YAML.cache_dir)
+          Bootsnap::CompileCache::Native.precompile(
+            cache_dir,
+            path.to_s,
+            Bootsnap::CompileCache::YAML,
+          )
+        end
+
         def install!(cache_dir)
           self.cache_dir = cache_dir
           init!
@@ -42,12 +44,34 @@ module Bootsnap
         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)
+
+          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
 
           self.supported_options = []
@@ -65,8 +89,6 @@ module Bootsnap
       end
 
       module Patch
-        extend self
-
         def load_file(path, *args)
           return super if args.size > 1
           if kwargs = args.first
@@ -77,7 +99,7 @@ module Bootsnap
           begin
             ::Bootsnap::CompileCache::Native.fetch(
               Bootsnap::CompileCache::YAML.cache_dir,
-              path,
+              File.realpath(path),
               ::Bootsnap::CompileCache::YAML,
               kwargs,
             )
@@ -85,6 +107,8 @@ module Bootsnap
             ::Bootsnap::CompileCache.permission_error(path)
           end
         end
+
+        ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
       end
     end
   end

data/lib/bootsnap/load_path_cache.rb

@@ -28,10 +28,9 @@ module Bootsnap
     CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
 
     class << self
-      attr_reader(:load_path_cache, :autoload_paths_cache,
-        :loaded_features_index, :realpath_cache)
+      attr_reader(:load_path_cache, :loaded_features_index, :realpath_cache)
 
-      def setup(cache_path:, development_mode:, active_support: true)
+      def setup(cache_path:, development_mode:)
         unless supported?
           warn("[bootsnap/setup] Load path caching is not supported on this implementation of Ruby") if $VERBOSE
           return
@@ -45,18 +44,6 @@ module Bootsnap
         @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/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')
-          @autoload_paths_cache = Cache.new(
-            store,
-            ::ActiveSupport::Dependencies.autoload_paths,
-            development_mode: development_mode
-          )
-          require_relative('load_path_cache/core_ext/active_support')
-        end
       end
 
       def supported?

data/lib/bootsnap/load_path_cache/cache.rb

@@ -10,8 +10,8 @@ module Bootsnap
       def initialize(store, path_obj, development_mode: false)
         @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.map! { |f| File.exist?(f) ? File.realpath(f) : f }
+        @mutex = Mutex.new
+        @path_obj = path_obj.map! { |f| PathScanner.os_path(File.exist?(f) ? File.realpath(f) : f.dup) }
         @has_relative_paths = nil
         reinitialize
       end
@@ -178,25 +178,42 @@ 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}"
+      s = rand.to_s.force_encoding(Encoding::US_ASCII).freeze
+      if s.respond_to?(:-@)
+        if (-s).equal?(s) && (-s.dup).equal?(s)
+          def try_index(f)
+            if (p = @index[f])
+              -(File.join(p, f).freeze)
+            end
+          end
+        else
+          def try_index(f)
+            if (p = @index[f])
+              -File.join(p, f).untaint
+            end
+          end
+        end
+      else
+        def try_index(f)
+          if (p = @index[f])
+            File.join(p, f)
+          end
         end
       end
 

data/lib/bootsnap/load_path_cache/loaded_features_index.rb

@@ -26,7 +26,7 @@ module Bootsnap
     class LoadedFeaturesIndex
       def initialize
         @lfi = {}
-        @mutex = defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new # TODO: Remove once Ruby 2.2 support is dropped.
+        @mutex = Mutex.new
 
         # In theory the user could mutate $LOADED_FEATURES and invalidate our
         # cache. If this ever comes up in practice — or if you, the

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -33,10 +33,10 @@ module Bootsnap
           requirables = []
           walk(path, nil) do |relative_path, absolute_path, is_directory|
             if is_directory
-              dirs << relative_path
+              dirs << os_path(relative_path)
               !contains_bundle_path || !absolute_path.start_with?(BUNDLE_PATH)
             elsif relative_path.end_with?(*REQUIRABLE_EXTENSIONS)
-              requirables << relative_path
+              requirables << os_path(relative_path)
             end
           end
           [requirables, dirs]
@@ -45,7 +45,7 @@ module Bootsnap
         def walk(absolute_dir_path, relative_dir_path, &block)
           Dir.foreach(absolute_dir_path) do |name|
             next if name.start_with?('.')
-            relative_path = relative_dir_path ? "#{relative_dir_path}/#{name}" : name.freeze
+            relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
 
             absolute_path = "#{absolute_dir_path}/#{name}"
             if File.directory?(absolute_path)
@@ -57,6 +57,17 @@ module Bootsnap
             end
           end
         end
+
+        if RUBY_VERSION >= '3.1'
+          def os_path(path)
+            path.freeze
+          end
+        else
+          def os_path(path)
+            path.force_encoding(Encoding::US_ASCII) if path.ascii_only?
+            path.freeze
+          end
+        end
       end
     end
   end

data/lib/bootsnap/load_path_cache/store.rb

@@ -12,8 +12,7 @@ module Bootsnap
 
       def initialize(store_path)
         @store_path = store_path
-        # TODO: Remove conditional once Ruby 2.2 support is dropped.
-        @txn_mutex =  defined?(::Mutex) ? ::Mutex.new : ::Thread::Mutex.new
+        @txn_mutex = Mutex.new
         @dirty = false
         load_data
       end
@@ -63,12 +62,18 @@ module Bootsnap
 
       def load_data
         @data = begin
-          MessagePack.load(File.binread(@store_path))
-                # handle malformed data due to upgrade incompatibility
-                rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
-                  {}
-                rescue ArgumentError => e
-                  e.message =~ /negative array size/ ? {} : raise
+          File.open(@store_path, encoding: Encoding::BINARY) do |io|
+            MessagePack.load(io)
+          end
+        # handle malformed data due to upgrade incompatibility
+        rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
+          {}
+        rescue ArgumentError => error
+          if error.message =~ /negative array size/
+            {}
+          else
+            raise
+          end
         end
       end
 
@@ -80,7 +85,9 @@ module Bootsnap
         exclusive_write = File::Constants::CREAT | File::Constants::EXCL | File::Constants::WRONLY
         # `encoding:` looks redundant wrt `binwrite`, but necessary on windows
         # because binary is part of mode.
-        File.binwrite(tmp, MessagePack.dump(@data), mode: exclusive_write, encoding: Encoding::BINARY)
+        File.open(tmp, mode: exclusive_write, encoding: Encoding::BINARY) do |io|
+          MessagePack.dump(@data, io, freeze: true)
+        end
         FileUtils.mv(tmp, @store_path)
       rescue Errno::EEXIST
         retry

data/lib/bootsnap/setup.rb

@@ -1,39 +1,4 @@
 # frozen_string_literal: true
 require_relative('../bootsnap')
 
-env = ENV['RAILS_ENV'] || ENV['RACK_ENV'] || ENV['ENV']
-development_mode = ['', nil, 'development'].include?(env)
-
-cache_dir = ENV['BOOTSNAP_CACHE_DIR']
-unless cache_dir
-  config_dir_frame = caller.detect do |line|
-    line.include?('/config/')
-  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")
-
-    raise("couldn't infer bootsnap cache directory")
-  end
-
-  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
-
-ruby_version = Gem::Version.new(RUBY_VERSION)
-iseq_cache_enabled = ruby_version < Gem::Version.new('2.5.0') || ruby_version >= Gem::Version.new('2.6.0')
-
-Bootsnap.setup(
-  cache_dir:            cache_dir,
-  development_mode:     development_mode,
-  load_path_cache:      true,
-  autoload_paths_cache: true, # assume rails. open to PRs to impl. detection
-  disable_trace:        false,
-  compile_cache_iseq:   iseq_cache_enabled,
-  compile_cache_yaml:   true,
-)
+Bootsnap.default_setup

data/lib/bootsnap/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Bootsnap
-  VERSION = "1.5.1"
+  VERSION = "1.7.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bootsnap
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.7.2
 platform: ruby
 authors:
 - Burke Libbey
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-10 00:00:00.000000000 Z
+date: 2021-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - lib/bootsnap.rb
 - lib/bootsnap/bundler.rb
 - lib/bootsnap/cli.rb
+- lib/bootsnap/cli/worker_pool.rb
 - lib/bootsnap/compile_cache.rb
 - lib/bootsnap/compile_cache/iseq.rb
 - lib/bootsnap/compile_cache/yaml.rb
@@ -120,7 +121,6 @@ files:
 - lib/bootsnap/load_path_cache.rb
 - lib/bootsnap/load_path_cache/cache.rb
 - lib/bootsnap/load_path_cache/change_observer.rb
-- lib/bootsnap/load_path_cache/core_ext/active_support.rb
 - lib/bootsnap/load_path_cache/core_ext/kernel_require.rb
 - lib/bootsnap/load_path_cache/core_ext/loaded_features.rb
 - lib/bootsnap/load_path_cache/loaded_features_index.rb

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-module Bootsnap
-  module LoadPathCache
-    module CoreExt
-      module ActiveSupport
-        def self.without_bootsnap_cache
-          prev = Thread.current[:without_bootsnap_cache] || false
-          Thread.current[:without_bootsnap_cache] = true
-          yield
-        ensure
-          Thread.current[:without_bootsnap_cache] = prev
-        end
-
-        def self.allow_bootsnap_retry(allowed)
-          prev = Thread.current[:without_bootsnap_retry] || false
-          Thread.current[:without_bootsnap_retry] = !allowed
-          yield
-        ensure
-          Thread.current[:without_bootsnap_retry] = prev
-        end
-
-        module ClassMethods
-          def autoload_paths=(o)
-            super
-            Bootsnap::LoadPathCache.autoload_paths_cache.reinitialize(o)
-          end
-
-          def search_for_file(path)
-            return super if Thread.current[:without_bootsnap_cache]
-            begin
-              Bootsnap::LoadPathCache.autoload_paths_cache.find(path)
-            rescue Bootsnap::LoadPathCache::ReturnFalse
-              nil # doesn't really apply here
-            rescue Bootsnap::LoadPathCache::FallbackScan
-              nil # doesn't really apply here
-            end
-          end
-
-          def autoloadable_module?(path_suffix)
-            Bootsnap::LoadPathCache.autoload_paths_cache.load_dir(path_suffix)
-          end
-
-          def remove_constant(const)
-            CoreExt::ActiveSupport.without_bootsnap_cache { super }
-          end
-
-          def require_or_load(*)
-            CoreExt::ActiveSupport.allow_bootsnap_retry(true) do
-              super
-            end
-          end
-
-          # If we can't find a constant using the patched implementation of
-          # search_for_file, try again with the default implementation.
-          #
-          # These methods call search_for_file, and we want to modify its
-          # behaviour.  The gymnastics here are a bit awkward, but it prevents
-          # 200+ lines of monkeypatches.
-          def load_missing_constant(from_mod, const_name)
-            CoreExt::ActiveSupport.allow_bootsnap_retry(false) do
-              super
-            end
-          rescue NameError => e
-            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
-            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-
-            # This function can end up called recursively, we only want to
-            # retry at the top-level.
-            raise(e) if Thread.current[:without_bootsnap_retry]
-            # If we already had cache disabled, there's no use retrying
-            raise(e) if Thread.current[:without_bootsnap_cache]
-            # NoMethodError is a NameError, but we only want to handle actual
-            # NameError instances.
-            raise(e) unless e.class == NameError
-            # We can only confidently handle cases when *this* constant fails
-            # to load, not other constants referred to by it.
-            raise(e) unless e.name == const_name
-            # If the constant was actually loaded, something else went wrong?
-            raise(e) if from_mod.const_defined?(const_name)
-            CoreExt::ActiveSupport.without_bootsnap_cache { super }
-          end
-
-          # Signature has changed a few times over the years; easiest to not
-          # reiterate it with version polymorphism here...
-          def depend_on(*)
-            super
-          rescue LoadError => e
-            raise(e) if e.instance_variable_defined?(Bootsnap::LoadPathCache::ERROR_TAG_IVAR)
-            e.instance_variable_set(Bootsnap::LoadPathCache::ERROR_TAG_IVAR, true)
-
-            # If we already had cache disabled, there's no use retrying
-            raise(e) if Thread.current[:without_bootsnap_cache]
-            CoreExt::ActiveSupport.without_bootsnap_cache { super }
-          end
-        end
-      end
-    end
-  end
-end
-
-module ActiveSupport
-  module Dependencies
-    class << self
-      prepend(Bootsnap::LoadPathCache::CoreExt::ActiveSupport::ClassMethods)
-    end
-  end
-end