bootsnap 1.1.8 → 1.4.0

data/ext/bootsnap/extconf.rb

@@ -1,4 +1,4 @@
-require "mkmf"
+require("mkmf")
 $CFLAGS << ' -O3 '
 $CFLAGS << ' -std=c99'
 
@@ -12,6 +12,7 @@ unless ['0', '', nil].include?(ENV['BOOTSNAP_PEDANTIC'])
 
   $CFLAGS << ' -Wno-unused-parameter' # VALUE self has to be there but we don't care what it is.
   $CFLAGS << ' -Wno-keyword-macro' # hiding return
+  $CFLAGS << ' -Wno-gcc-compat' # ruby.h 2.6.0 on macos 10.14, dunno
 end
 
 create_makefile("bootsnap/bootsnap")

data/lib/bootsnap.rb

@@ -1,7 +1,7 @@
-require_relative 'bootsnap/version'
-require_relative 'bootsnap/bundler'
-require_relative 'bootsnap/load_path_cache'
-require_relative 'bootsnap/compile_cache'
+require_relative('bootsnap/version')
+require_relative('bootsnap/bundler')
+require_relative('bootsnap/load_path_cache')
+require_relative('bootsnap/compile_cache')
 
 module Bootsnap
   InvalidConfiguration = Class.new(StandardError)
@@ -16,7 +16,7 @@ module Bootsnap
     compile_cache_yaml: true
   )
     if autoload_paths_cache && !load_path_cache
-      raise InvalidConfiguration, "feature 'autoload_paths_cache' depends on feature 'load_path_cache'"
+      raise(InvalidConfiguration, "feature 'autoload_paths_cache' depends on feature 'load_path_cache'")
     end
 
     setup_disable_trace if disable_trace
@@ -35,6 +35,13 @@ module Bootsnap
   end
 
   def self.setup_disable_trace
-    RubyVM::InstructionSequence.compile_option = { trace_instruction: false }
+    if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.5.0')
+      warn(
+        "from #{caller_locations(1, 1)[0]}: The 'disable_trace' method is not allowed with this Ruby version. " \
+        "current: #{RUBY_VERSION}, allowed version: < 2.5.0",
+      )
+    else
+      RubyVM::InstructionSequence.compile_option = { trace_instruction: false }
+    end
   end
 end

data/lib/bootsnap/bundler.rb

@@ -1,12 +1,14 @@
 module Bootsnap
-  module_function
+  extend(self)
 
   def bundler?
+    return false unless defined?(::Bundler)
+
     # Bundler environment variable
-    ['BUNDLE_BIN_PATH', 'BUNDLE_GEMFILE'].each do |current|
+    %w(BUNDLE_BIN_PATH BUNDLE_GEMFILE).each do |current|
       return true if ENV.key?(current)
     end
-    
+
     false
   end
 end

data/lib/bootsnap/compile_cache.rb

@@ -2,14 +2,29 @@ module Bootsnap
   module CompileCache
     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.supported?
+      # only enable on 'ruby' (MRI), POSIX (darwin, linux, *bsd), and >= 2.3.0
+      RUBY_ENGINE == 'ruby' &&
+      RUBY_PLATFORM =~ /darwin|linux|bsd/ &&
+      Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.3.0")
+    end
   end
 end

data/lib/bootsnap/compile_cache/iseq.rb

@@ -1,25 +1,25 @@
-require 'bootsnap/bootsnap'
-require 'zlib'
+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)
         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
@@ -41,7 +41,7 @@ module Bootsnap
           )
         rescue RuntimeError => e
           if e.message =~ /unmatched platform/
-            puts "unmatched platform for file #{path}"
+            puts("unmatched platform for file #{path}")
           end
           raise
         end
@@ -62,7 +62,7 @@ module Bootsnap
         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,21 +1,21 @@
-require 'bootsnap/bootsnap'
+require('bootsnap/bootsnap')
 
 module Bootsnap
   module CompileCache
     module YAML
       class << self
-        attr_accessor :msgpack_factory
+        attr_accessor(:msgpack_factory)
       end
 
       def self.input_to_storage(contents, _)
-        raise Uncompilable if contents.index("!ruby/object")
+        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)
+        Marshal.dump(obj)
       end
 
       def self.storage_to_output(data)
@@ -34,8 +34,8 @@ module Bootsnap
       end
 
       def self.install!(cache_dir)
-        require 'yaml'
-        require 'msgpack'
+        require('yaml')
+        require('msgpack')
 
         # MessagePack serializes symbols as strings by default.
         # We want them to roundtrip cleanly, so we use a custom factory.
@@ -48,7 +48,7 @@ module Bootsnap
         klass.send(:define_method, :load_file) do |path|
           Bootsnap::CompileCache::Native.fetch(
             cache_dir,
-            path.to_s,
+            path,
             Bootsnap::CompileCache::YAML
           )
         end

data/lib/bootsnap/explicit_require.rb

@@ -5,7 +5,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

@@ -21,32 +21,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/
+      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,4 @@
-require_relative '../explicit_require'
+require_relative('../explicit_require')
 
 module Bootsnap
   module LoadPathCache
@@ -9,15 +9,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
@@ -56,7 +56,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.
@@ -73,14 +73,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 +110,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 +139,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,10 +153,11 @@ 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
@@ -180,7 +181,7 @@ module Bootsnap
       end
 
       def try_index(f)
-        if p = @index[f]
+        if (p = @index[f])
           p + '/' + f
         end
       end

data/lib/bootsnap/load_path_cache/change_observer.rb

@@ -1,37 +1,36 @@
 module Bootsnap
   module LoadPathCache
     module ChangeObserver
-      def self.register(observer, arr)
-        # Re-overriding these methods on an array that already has them would
-        # cause StackOverflowErrors
-        return if arr.respond_to?(:push_without_lpc)
-
+      module ArrayMixin
         # For each method that adds items to one end or another of the array
         # (<<, push, unshift, concat), override that method to also notify the
         # observer of the change.
-        sc = arr.singleton_class
-        sc.send(:alias_method, :shovel_without_lpc, :<<)
-        arr.define_singleton_method(:<<) do |entry|
-          observer.push_paths(self, entry.to_s)
-          shovel_without_lpc(entry)
+        def <<(entry)
+          @lpc_observer.push_paths(self, entry.to_s)
+          super
+        end
+
+        def push(*entries)
+          @lpc_observer.push_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :push_without_lpc, :push)
-        arr.define_singleton_method(:push) do |*entries|
-          observer.push_paths(self, *entries.map(&:to_s))
-          push_without_lpc(*entries)
+        def unshift(*entries)
+          @lpc_observer.unshift_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :unshift_without_lpc, :unshift)
-        arr.define_singleton_method(:unshift) do |*entries|
-          observer.unshift_paths(self, *entries.map(&:to_s))
-          unshift_without_lpc(*entries)
+        def concat(entries)
+          @lpc_observer.push_paths(self, *entries.map(&:to_s))
+          super
         end
 
-        sc.send(:alias_method, :concat_without_lpc, :concat)
-        arr.define_singleton_method(:concat) do |entries|
-          observer.push_paths(self, *entries.map(&:to_s))
-          concat_without_lpc(entries)
+        # uniq! keeps the first occurance of each path, otherwise preserving
+        # order, preserving the effective load path
+        def uniq!(*args)
+          ret = super
+          @lpc_observer.reinitialize if block_given? || !args.empty?
+          ret
         end
 
         # For each method that modifies the array more aggressively, override
@@ -41,16 +40,22 @@ module Bootsnap
         # accounting cost would be greater than the hit from these, since we
         # actively discourage calling them.
         %i(
-          collect! compact! delete delete_at delete_if fill flatten! insert map!
-          reject! reverse! select! shuffle! shift slice! sort! sort_by!
-        ).each do |meth|
-          sc.send(:alias_method, :"#{meth}_without_lpc", meth)
-          arr.define_singleton_method(meth) do |*a|
-            send(:"#{meth}_without_lpc", *a)
-            observer.reinitialize
+          []= clear collect! compact! delete delete_at delete_if fill flatten!
+          insert keep_if map! pop reject! replace reverse! rotate! select!
+          shift shuffle! slice! sort! sort_by!
+        ).each do |method_name|
+          define_method(method_name) do |*args, &block|
+            ret = super(*args, &block)
+            @lpc_observer.reinitialize
+            ret
           end
         end
       end
+
+      def self.register(observer, arr)
+        arr.instance_variable_set(:@lpc_observer, observer)
+        arr.extend(ArrayMixin)
+      end
     end
   end
 end