mini-max-rb 0.0.1

data/bootsnap-1.24.6/lib/bootsnap/compile_cache/iseq.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "bootsnap/bootsnap"
+require "zlib"
+
+module Bootsnap
+  module CompileCache
+    module ISeq
+      class << self
+        attr_reader :cache_dir
+        attr_accessor :compiler_selector, :default_compiler
+
+        def cache_dir=(cache_dir)
+          @cache_dir = cache_dir.end_with?("/") ? "#{cache_dir}iseq" : "#{cache_dir}-iseq"
+        end
+
+        def supported?
+          CompileCache.supported? && defined?(RubyVM)
+        end
+      end
+
+      if supported?
+        class Compiler
+          attr_reader :namespace
+
+          def initialize(namespace = nil, compile_options = nil)
+            @namespace = namespace
+            @options = compile_options.freeze
+            update_options
+          end
+
+          def update_options
+            @compile_options = if @options.nil? || @options < RubyVM::InstructionSequence.compile_option
+              nil
+            else
+              RubyVM::InstructionSequence.compile_option.merge(@options).freeze
+            end
+          end
+
+          has_ruby_bug_18250 = RUBY_VERSION.start_with?("3.0.") && begin # https://bugs.ruby-lang.org/issues/18250
+            if defined? RubyVM::InstructionSequence
+              RubyVM::InstructionSequence.compile(<<~RUBY).to_binary
+                def foo(*); ->{ super }; end; def foo(**); ->{ super }; end
+              RUBY
+            end
+            false
+          rescue TypeError
+            true
+          end
+
+          has_ruby_bug_22023 = case RUBY_VERSION
+          when /^3\.3\./
+            true
+          when /^3\.4\.(\d+)/
+            $1.to_i < 10
+          when /^4\.0\.(\d+)/
+            $1.to_i < 4
+          else
+            false
+          end
+
+          if has_ruby_bug_22023 && RUBY_DESCRIPTION.include?("+PRISM")
+            module PatchRubyBug22023
+              def compile_file(path, options = nil)
+                compile_file_prism(path, options)
+              end
+
+              has_ruby_bug_22023_bis = !RubyVM::InstructionSequence.compile_file_prism(
+                File.expand_path("../ruby_bug_22023_canary.rb", __FILE__),
+                {frozen_string_literal: true},
+              ).eval.frozen?
+
+              if has_ruby_bug_22023_bis
+                def compile_file_prism(path, options = nil)
+                  compile_prism(::File.read(path, encoding: Encoding::UTF_8), path, path, nil, options)
+                end
+              end
+            end
+            RubyVM::InstructionSequence.singleton_class.prepend(PatchRubyBug22023)
+          end
+
+          if has_ruby_bug_18250
+            def input_to_storage(_, path)
+              iseq = RubyVM::InstructionSequence.compile_file(path, @compile_options)
+              iseq.to_binary
+            rescue TypeError, SyntaxError # Ruby [Bug #18250] & [Bug #22023]
+              UNCOMPILABLE
+            end
+          else
+            def input_to_storage(_, path)
+              RubyVM::InstructionSequence.compile_file(path, @compile_options).to_binary
+            rescue SyntaxError # Ruby [Bug #22023]
+              UNCOMPILABLE
+            end
+          end
+
+          def storage_to_output(binary, _args)
+            iseq = RubyVM::InstructionSequence.load_from_binary(binary)
+            binary.clear
+            iseq
+          rescue RuntimeError => error
+            if error.message == "broken binary format"
+              $stderr.puts("[Bootsnap::CompileCache] warning: rejecting broken binary")
+              nil
+            else
+              raise
+            end
+          end
+
+          def input_to_output(source, path, _kwargs)
+            if @compile_options
+              if source
+                RubyVM::InstructionSequence.compile(
+                  source.force_encoding(Encoding.default_external),
+                  path,
+                  path,
+                  nil,
+                  @compile_options,
+                )
+              else
+                RubyVM::InstructionSequence.compile_file(path, @compile_options)
+              end
+            end
+          end
+        end
+
+        DEFAULT = Compiler.new
+        FROZEN_STRING_LITERAL = Compiler.new("-fstr", {frozen_string_literal: true}.freeze)
+        COVERAGE_SUPPORTED = RUBY_VERSION >= "4.0.4"
+
+        @default_compiler = DEFAULT
+        @coverage_support_warning_emitted = false
+
+        def self.fetch(path, cache_dir: ISeq.cache_dir)
+          compiler = compiler_selector&.call(path) || default_compiler
+
+          # Having coverage enabled prevents iseq dumping/loading.
+          if coverage_on?
+            return nil if compiler.equal?(DEFAULT)
+
+            if COVERAGE_SUPPORTED
+              return compiler.input_to_output(nil, path.to_s, nil)
+            elsif !@coverage_support_warning_emitted
+              @coverage_support_warning_emitted = true
+              warn(<<~MSG)
+                Using `Bootsnap.enable_frozen_string_literal` with code coverage enabled is only supported on Ruby 4.0.4+.
+                Files loaded while coverage is on, will have mutable string literals.
+              MSG
+            end
+
+            return nil
+          end
+
+          Bootsnap::CompileCache::Native.fetch(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
+            nil,
+          )
+        end
+
+        def self.precompile(path)
+          compiler = compiler_selector&.call(path) || default_compiler
+          Bootsnap::CompileCache::Native.precompile(
+            cache_dir,
+            compiler.namespace,
+            path.to_s,
+            compiler,
+          )
+        end
+
+        if RUBY_VERSION < "3.1."
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.running?
+          end
+        else
+          def self.coverage_on?
+            defined?(Coverage) && Coverage.state != :idle
+          end
+        end
+
+        module InstructionSequenceMixin
+          def load_iseq(path)
+            Bootsnap::CompileCache::ISeq.fetch(path.to_s)
+          rescue RuntimeError => error
+            if error.message.include?("unmatched platform")
+              puts("unmatched platform for file #{path}")
+            end
+            raise
+          end
+
+          def compile_option=(hash)
+            super
+            Bootsnap::CompileCache::ISeq.compile_option_updated
+          end
+        end
+
+        def self.compile_option_updated
+          option = RubyVM::InstructionSequence.compile_option
+          crc = Zlib.crc32(option.inspect)
+          Bootsnap::CompileCache::Native.compile_option_crc32 = crc
+          FROZEN_STRING_LITERAL.update_options
+        end
+        compile_option_updated if supported?
+
+        def self.install!(cache_dir)
+          Bootsnap::CompileCache::ISeq.cache_dir = cache_dir
+
+          return unless supported?
+
+          Bootsnap::CompileCache::ISeq.compile_option_updated
+
+          class << RubyVM::InstructionSequence
+            prepend(InstructionSequenceMixin)
+          end
+        end
+      else
+        def self.install!(...)
+          # noop
+        end
+
+        def self.precompile(...)
+          # noop
+        end
+      end
+    end
+  end
+end

data/bootsnap-1.24.6/lib/bootsnap/compile_cache/ruby_bug_22023_canary.rb

@@ -0,0 +1 @@
+_ = "test"

data/bootsnap-1.24.6/lib/bootsnap/compile_cache/yaml.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require "bootsnap/bootsnap"
+
+module Bootsnap
+  module CompileCache
+    module YAML
+      Uncompilable = Class.new(StandardError)
+      UnsupportedTags = Class.new(Uncompilable)
+
+      SUPPORTED_INTERNAL_ENCODINGS = [
+        nil, # UTF-8
+        Encoding::UTF_8,
+        Encoding::ASCII,
+        Encoding::BINARY,
+      ].freeze
+
+      class << self
+        attr_accessor(:msgpack_factory, :supported_options)
+        attr_reader(:implementation, :cache_dir)
+
+        def cache_dir=(cache_dir)
+          @cache_dir = cache_dir.end_with?("/") ? "#{cache_dir}yaml" : "#{cache_dir}-yaml"
+        end
+
+        def precompile(path)
+          return false unless CompileCache::YAML.supported_internal_encoding?
+
+          CompileCache::Native.precompile(
+            cache_dir,
+            nil,
+            path.to_s,
+            @implementation,
+          )
+        end
+
+        def install!(cache_dir)
+          self.cache_dir = cache_dir
+          init!
+          ::YAML.singleton_class.prepend(@implementation::Patch)
+        end
+
+        # Psych coerce strings to `Encoding.default_internal` but Message Pack only support
+        # UTF-8, US-ASCII and BINARY. So if Encoding.default_internal is set to anything else
+        # we can't safely use the cache
+        def supported_internal_encoding?
+          SUPPORTED_INTERNAL_ENCODINGS.include?(Encoding.default_internal)
+        end
+
+        module EncodingAwareSymbols
+          extend self
+
+          def unpack(payload)
+            (+payload).force_encoding(Encoding::UTF_8).to_sym
+          end
+        end
+
+        def init!
+          require "yaml"
+          require "msgpack"
+          require "date"
+
+          @implementation = ::YAML::VERSION >= "4" ? Psych4 : Psych3
+          if @implementation::Patch.method_defined?(:unsafe_load_file) && !::YAML.respond_to?(:unsafe_load_file)
+            @implementation::Patch.send(:remove_method, :unsafe_load_file)
+          end
+
+          unless const_defined?(:NoTagsVisitor)
+            visitor = Class.new(Psych::Visitors::NoAliasRuby) do
+              def visit(target)
+                if target.tag
+                  raise UnsupportedTags, "YAML tags are not supported: #{target.tag}"
+                end
+
+                super
+              end
+            end
+            const_set(:NoTagsVisitor, visitor)
+          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,
+            packer: :to_msgpack_ext,
+            unpacker: EncodingAwareSymbols.method(:unpack).to_proc,
+          )
+
+          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 = []
+          params = ::YAML.method(:load).parameters
+          if params.include?([:key, :symbolize_names])
+            supported_options << :symbolize_names
+          end
+          if params.include?([:key, :freeze]) && factory.load(factory.dump("yaml"), freeze: true).frozen?
+            supported_options << :freeze
+          end
+          supported_options.freeze
+        end
+
+        def patch
+          @implementation::Patch
+        end
+
+        def strict_load(payload)
+          ast = ::YAML.parse(payload)
+          return ast unless ast
+
+          loader = ::Psych::ClassLoader::Restricted.new(["Symbol"], [])
+          scanner = ::Psych::ScalarScanner.new(loader)
+
+          NoTagsVisitor.new(scanner, loader).visit(ast)
+        end
+      end
+
+      module Psych4
+        extend self
+
+        def input_to_storage(contents, _)
+          obj = SafeLoad.input_to_storage(contents, nil)
+          if UNCOMPILABLE.equal?(obj)
+            obj = UnsafeLoad.input_to_storage(contents, nil)
+          end
+          obj
+        end
+
+        module UnsafeLoad
+          extend self
+
+          def input_to_storage(contents, _)
+            obj = ::YAML.unsafe_load(contents)
+            packer = CompileCache::YAML.msgpack_factory.packer
+            packer.pack(false) # not safe loaded
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE # The object included things that we can't serialize
+            end
+            packer.to_s
+          end
+
+          def storage_to_output(data, kwargs)
+            if kwargs&.key?(:symbolize_names)
+              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+            end
+
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker.feed(data)
+            _safe_loaded = unpacker.unpack
+            result = unpacker.unpack
+            data.clear
+            result
+          end
+
+          def input_to_output(data, _path, kwargs)
+            ::YAML.unsafe_load(data, **(kwargs || {}))
+          end
+        end
+
+        module SafeLoad
+          extend self
+
+          def input_to_storage(contents, _)
+            obj = begin
+              CompileCache::YAML.strict_load(contents)
+            rescue Psych::DisallowedClass, Psych::BadAlias, Uncompilable
+              return UNCOMPILABLE
+            end
+
+            packer = CompileCache::YAML.msgpack_factory.packer
+            packer.pack(true) # safe loaded
+            begin
+              packer.pack(obj)
+            rescue NoMethodError, RangeError
+              return UNCOMPILABLE
+            end
+            packer.to_s
+          end
+
+          def storage_to_output(data, kwargs)
+            if kwargs&.key?(:symbolize_names)
+              kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+            end
+
+            unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+            unpacker.feed(data)
+            safe_loaded = unpacker.unpack
+            if safe_loaded
+              unpacker.unpack
+            else
+              UNCOMPILABLE
+            end
+          end
+
+          def input_to_output(data, _path, kwargs)
+            ::YAML.load(data, **(kwargs || {}))
+          end
+        end
+
+        module Patch
+          def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
+            return super if args.size > 1
+
+            if (kwargs = args.first)
+              return super unless kwargs.is_a?(Hash)
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              nil,
+              File.realpath(path),
+              CompileCache::YAML::Psych4::SafeLoad,
+              kwargs,
+            )
+          end
+
+          ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
+
+          def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
+            return super if args.size > 1
+
+            if (kwargs = args.first)
+              return super unless kwargs.is_a?(Hash)
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              nil,
+              File.realpath(path),
+              CompileCache::YAML::Psych4::UnsafeLoad,
+              kwargs,
+            )
+          end
+
+          ruby2_keywords :unsafe_load_file if respond_to?(:ruby2_keywords, true)
+        end
+      end
+
+      module Psych3
+        extend self
+
+        def input_to_storage(contents, _)
+          obj = ::YAML.load(contents)
+          packer = CompileCache::YAML.msgpack_factory.packer
+          packer.pack(false) # not safe loaded
+          begin
+            packer.pack(obj)
+          rescue NoMethodError, RangeError
+            return UNCOMPILABLE # The object included things that we can't serialize
+          end
+          packer.to_s
+        end
+
+        def storage_to_output(data, kwargs)
+          if kwargs&.key?(:symbolize_names)
+            kwargs[:symbolize_keys] = kwargs.delete(:symbolize_names)
+          end
+          unpacker = CompileCache::YAML.msgpack_factory.unpacker(kwargs)
+          unpacker.feed(data)
+          _safe_loaded = unpacker.unpack
+          unpacker.unpack
+        end
+
+        def input_to_output(data, _path, kwargs)
+          ::YAML.load(data, **(kwargs || {}))
+        end
+
+        module Patch
+          def load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
+            return super if args.size > 1
+
+            if (kwargs = args.first)
+              return super unless kwargs.is_a?(Hash)
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              nil,
+              File.realpath(path),
+              CompileCache::YAML::Psych3,
+              kwargs,
+            )
+          end
+
+          ruby2_keywords :load_file if respond_to?(:ruby2_keywords, true)
+
+          def unsafe_load_file(path, *args)
+            return super unless CompileCache::YAML.supported_internal_encoding?
+
+            return super if args.size > 1
+
+            if (kwargs = args.first)
+              return super unless kwargs.is_a?(Hash)
+              return super unless (kwargs.keys - CompileCache::YAML.supported_options).empty?
+            end
+
+            CompileCache::Native.fetch(
+              CompileCache::YAML.cache_dir,
+              nil,
+              File.realpath(path),
+              CompileCache::YAML::Psych3,
+              kwargs,
+            )
+          end
+
+          ruby2_keywords :unsafe_load_file if respond_to?(:ruby2_keywords, true)
+        end
+      end
+    end
+  end
+end

data/bootsnap-1.24.6/lib/bootsnap/compile_cache.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  module CompileCache
+    UNCOMPILABLE = BasicObject.new
+    def UNCOMPILABLE.inspect
+      "<Bootsnap::UNCOMPILABLE>"
+    end
+
+    Error = Class.new(StandardError)
+
+    def self.setup(cache_dir:, iseq:, yaml:, json: (json_unset = true), readonly: false, revalidation: false)
+      unless json_unset
+        warn("Bootsnap::CompileCache.setup `json` argument is deprecated and has no effect")
+      end
+
+      if iseq
+        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
+        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
+
+      if supported? && defined?(Bootsnap::CompileCache::Native)
+        Bootsnap::CompileCache::Native.readonly = readonly
+        Bootsnap::CompileCache::Native.revalidation = revalidation
+      end
+    end
+
+    def self.supported?
+      # only enable on 'ruby' (MRI) and TruffleRuby for POSIX (darwin, linux, *bsd), Windows (RubyInstaller2)
+      %w[ruby truffleruby].include?(RUBY_ENGINE) &&
+        RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
+    end
+  end
+end

data/bootsnap-1.24.6/lib/bootsnap/explicit_require.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  module ExplicitRequire
+    ARCHDIR    = RbConfig::CONFIG["archdir"]
+    RUBYLIBDIR = RbConfig::CONFIG["rubylibdir"]
+    DLEXT      = RbConfig::CONFIG["DLEXT"]
+
+    def self.from_self(feature)
+      require_relative("../#{feature}")
+    end
+
+    def self.from_rubylibdir(feature)
+      require(File.join(RUBYLIBDIR, "#{feature}.rb"))
+    end
+
+    def self.from_archdir(feature)
+      require(File.join(ARCHDIR, "#{feature}.#{DLEXT}"))
+    end
+
+    # Given a set of gems, run a block with the LOAD_PATH narrowed to include
+    # only core ruby source paths and these gems -- that is, roughly,
+    # temporarily remove all gems not listed in this call from the LOAD_PATH.
+    #
+    # This is useful before bootsnap is fully-initialized to load gems that it
+    # depends on, without forcing full LOAD_PATH traversals.
+    def self.with_gems(*gems)
+      # Ensure the gems are activated (their paths are in $LOAD_PATH)
+      gems.each do |gem_name|
+        gem gem_name
+      end
+
+      orig = $LOAD_PATH.dup
+      $LOAD_PATH.clear
+      gems.each do |gem|
+        pat = %r{
+          /
+          (gems|extensions/[^/]+/[^/]+)          # "gems" or "extensions/x64_64-darwin16/2.3.0"
+          /
+          #{Regexp.escape(gem)}-(\h{12}|(\d+\.)) # msgpack-1.2.3 or msgpack-1234567890ab
+        }x
+        $LOAD_PATH.concat(orig.grep(pat))
+      end
+      $LOAD_PATH << ARCHDIR
+      $LOAD_PATH << RUBYLIBDIR
+      begin
+        yield
+      rescue LoadError
+        $LOAD_PATH.replace(orig)
+        yield
+      end
+    ensure
+      $LOAD_PATH.replace(orig)
+    end
+  end
+end