bootsnap 1.1.8-java → 1.5.0-java

data/ext/bootsnap/extconf.rb

@@ -1,4 +1,5 @@
-require "mkmf"
+# frozen_string_literal: true
+require("mkmf")
 $CFLAGS << ' -O3 '
 $CFLAGS << ' -std=c99'
 
@@ -12,6 +13,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,9 @@
-require_relative 'bootsnap/version'
-require_relative 'bootsnap/bundler'
-require_relative 'bootsnap/load_path_cache'
-require_relative 'bootsnap/compile_cache'
+# frozen_string_literal: true
+
+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 +18,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 +37,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,15 @@
+# frozen_string_literal: true
 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/cli.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'bootsnap'
+require 'optparse'
+require 'fileutils'
+
+module Bootsnap
+  class CLI
+    unless Regexp.method_defined?(:match?)
+      module RegexpMatchBackport
+        refine Regepx do
+          def match?(string)
+            !!match(string)
+          end
+        end
+      end
+      using RegexpMatchBackport
+    end
+
+    attr_reader :cache_dir, :argv
+
+    attr_accessor :compile_gemfile, :exclude
+
+    def initialize(argv)
+      @argv = argv
+      self.cache_dir = 'tmp/cache'
+      self.compile_gemfile = false
+      self.exclude = nil
+    end
+
+    def precompile_command(*sources)
+      require 'bootsnap/compile_cache/iseq'
+
+      Bootsnap::CompileCache::ISeq.cache_dir = self.cache_dir
+
+      if compile_gemfile
+        sources += $LOAD_PATH
+      end
+
+      sources.map { |d| File.expand_path(d) }.each do |path|
+        if !exclude || !exclude.match?(path)
+          list_ruby_files(path).each do |ruby_file|
+            if !exclude || !exclude.match?(ruby_file)
+              CompileCache::ISeq.fetch(ruby_file, cache_dir: cache_dir)
+            end
+          end
+        end
+      end
+      0
+    end
+
+    dir_sort = begin
+      Dir['.', sort: false]
+      true
+    rescue ArgumentError, TypeError
+      false
+    end
+
+    if dir_sort
+      def list_ruby_files(path)
+        if File.directory?(path)
+          Dir[File.join(path, '**/*.rb'), sort: false]
+        elsif File.exist?(path)
+          [path]
+        else
+          []
+        end
+      end
+    else
+      def list_ruby_files(path)
+        if File.directory?(path)
+          Dir[File.join(path, '**/*.rb')]
+        elsif File.exist?(path)
+          [path]
+        else
+          []
+        end
+      end
+    end
+
+    def run
+      parser.parse!(argv)
+      command = argv.shift
+      method = "#{command}_command"
+      if respond_to?(method)
+        public_send(method, *argv)
+      else
+        invalid_usage!("Unknown command: #{command}")
+      end
+    end
+
+    private
+
+    def invalid_usage!(message)
+      STDERR.puts message
+      STDERR.puts
+      STDERR.puts parser
+      1
+    end
+
+    def cache_dir=(dir)
+      @cache_dir = File.expand_path(File.join(dir, 'bootsnap-compile-cache'))
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: bootsnap COMMAND [ARGS]"
+        opts.separator ""
+        opts.separator "GLOBAL OPTIONS"
+        opts.separator ""
+
+        help = <<~EOS
+          Path to the bootsnap cache directory. Defaults to tmp/cache
+        EOS
+        opts.on('--cache-dir DIR', help.strip) do |dir|
+          self.cache_dir = dir
+        end
+
+        opts.separator ""
+        opts.separator "COMMANDS"
+        opts.separator ""
+        opts.separator "    precompile [DIRECTORIES...]: Precompile all .rb files in the passed directories"
+
+        help = <<~EOS
+          Precompile the gems in Gemfile
+        EOS
+        opts.on('--gemfile', help) { self.compile_gemfile = true }
+
+        help = <<~EOS
+          Path pattern to not precompile. e.g. --exclude 'aws-sdk|google-api'
+        EOS
+        opts.on('--exclude PATTERN', help) { |pattern| self.exclude = Regexp.new(pattern) }
+      end
+    end
+  end
+end

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,41 @@
-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)
+      def self.input_to_storage(_, path, _args)
         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.input_to_output(_, _)
         nil # ruby handles this
       end
 
@@ -34,14 +44,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 +65,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,56 +1,89 @@
-require 'bootsnap/bootsnap'
+# 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
-        return 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 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 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
-      end
 
-      def self.input_to_output(data)
-        ::YAML.load(data)
+        def input_to_output(data, kwargs)
+          ::YAML.load(data, **(kwargs || {}))
+        end
+
+        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'
-
-        # 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
-
-        klass = class << ::YAML; self; end
-        klass.send(:define_method, :load_file) do |path|
-          Bootsnap::CompileCache::Native.fetch(
-            cache_dir,
-            path.to_s,
-            Bootsnap::CompileCache::YAML
-          )
+      module Patch
+        extend self
+
+        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
       end
     end