mini-max-rb 0.0.1

data/bootsnap-1.24.6/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative "../explicit_require"
+
+module Bootsnap
+  module LoadPathCache
+    module PathScanner
+      REQUIRABLE_EXTENSIONS = [DOT_RB] + DL_EXTENSIONS
+
+      BUNDLE_PATH = if Bootsnap.bundler?
+        (Bundler.bundle_path.cleanpath.to_s << LoadPathCache::SLASH).freeze
+      else
+        ""
+      end
+
+      @ignored_directories = %w(node_modules)
+
+      class << self
+        attr_accessor :ignored_directories
+
+        def ruby_call(root_path)
+          root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names = prepare_scan(root_path)
+          return [] unless File.directory?(root_path)
+
+          requirables = []
+          walk(root_path, nil, ignored_abs_paths, ignored_dir_names) do |relative_path, absolute_path, is_directory|
+            if is_directory
+              !contains_bundle_path || !absolute_path.start_with?(BUNDLE_PATH)
+            elsif relative_path.end_with?(*REQUIRABLE_EXTENSIONS)
+              requirables << relative_path.freeze
+            end
+          end
+          requirables
+        end
+
+        if RUBY_ENGINE == "ruby" && RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
+          require "bootsnap/bootsnap"
+        end
+
+        if defined?(Native.scan_dir)
+          def native_call(root_path)
+            # NOTE: if https://bugs.ruby-lang.org/issues/21800 is accepted we should be able
+            # to have similar performance with pure Ruby
+            root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names = prepare_scan(root_path)
+
+            all_requirables, queue = Native.scan_dir(root_path)
+            all_requirables.each(&:freeze)
+
+            queue.reject! do |dir|
+              if ignored_dir_names&.include?(dir)
+                true
+              elsif ignored_abs_paths || contains_bundle_path
+                absolute_dir = File.join(root_path, dir)
+                ignored_abs_paths&.include?(absolute_dir) ||
+                  (contains_bundle_path && absolute_dir.start_with?(BUNDLE_PATH))
+              end
+            end
+
+            while (relative_path = queue.pop)
+              absolute_base = File.join(root_path, relative_path)
+              requirables, dirs = Native.scan_dir(absolute_base)
+              dirs.reject! do |dir|
+                if ignored_dir_names&.include?(dir)
+                  true
+                elsif ignored_abs_paths || contains_bundle_path
+                  absolute_dir = File.join(absolute_base, dir)
+                  ignored_abs_paths&.include?(absolute_dir) ||
+                    (contains_bundle_path && absolute_dir.start_with?(BUNDLE_PATH))
+                end
+              end
+              dirs.map! { |f| File.join(relative_path, f).freeze }
+              requirables.map! { |f| File.join(relative_path, f).freeze }
+
+              all_requirables.concat(requirables)
+              queue.concat(dirs)
+            end
+
+            all_requirables
+          end
+          alias_method :call, :native_call
+        else
+          alias_method :call, :ruby_call
+        end
+
+        private
+
+        def prepare_scan(root_path)
+          root_path = File.expand_path(root_path.to_s).freeze
+
+          # If the bundle path is a descendent of this path, we do additional
+          # checks to prevent recursing into the bundle path as we recurse
+          # through this path. We don't want to scan the bundle path because
+          # anything useful in it will be present on other load path items.
+          #
+          # This can happen if, for example, the user adds '.' to the load path,
+          # and the bundle path is '.bundle'.
+          contains_bundle_path = BUNDLE_PATH.start_with?(root_path)
+
+          ignored_abs_paths, ignored_dir_names = ignored_directories.partition { |p| File.absolute_path?(p) }
+          ignored_abs_paths = nil if ignored_abs_paths.empty?
+          ignored_dir_names = nil if ignored_dir_names.empty?
+
+          [root_path, contains_bundle_path, ignored_abs_paths, ignored_dir_names]
+        end
+
+        def walk(absolute_dir_path, relative_dir_path, ignored_abs_paths, ignored_dir_names, &block)
+          Dir.foreach(absolute_dir_path) do |name|
+            next if name.start_with?(".")
+
+            relative_path = relative_dir_path ? File.join(relative_dir_path, name) : name
+
+            absolute_path = File.join(absolute_dir_path, name)
+            if File.directory?(absolute_path)
+              next if ignored_dir_names&.include?(name) || ignored_abs_paths&.include?(absolute_path)
+
+              if yield relative_path, absolute_path, true
+                walk(absolute_path, relative_path, ignored_abs_paths, ignored_dir_names, &block)
+              end
+            else
+              yield relative_path, absolute_path, false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/bootsnap-1.24.6/lib/bootsnap/load_path_cache/store.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "../explicit_require"
+
+Bootsnap::ExplicitRequire.with_gems("msgpack") { require "msgpack" }
+
+module Bootsnap
+  module LoadPathCache
+    class Store
+      VERSION_KEY = "__bootsnap_ruby_version__"
+      CURRENT_VERSION = "#{VERSION}-#{RUBY_REVISION}-#{RUBY_PLATFORM}".freeze # rubocop:disable Style/RedundantFreeze
+
+      NestedTransactionError = Class.new(StandardError)
+      SetOutsideTransactionNotAllowed = Class.new(StandardError)
+
+      def initialize(store_path, readonly: false)
+        @store_path = store_path
+        @txn_mutex = Mutex.new
+        @dirty = false
+        @readonly = readonly
+        load_data
+      end
+
+      def get(key)
+        @data[key]
+      end
+
+      def fetch(key)
+        raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
+
+        v = get(key)
+        unless v
+          v = yield
+          mark_for_mutation!
+          @data[key] = v
+        end
+        v
+      end
+
+      def set(key, value)
+        raise(SetOutsideTransactionNotAllowed) unless @txn_mutex.owned?
+
+        if value != @data[key]
+          mark_for_mutation!
+          @data[key] = value
+        end
+      end
+
+      def transaction
+        raise(NestedTransactionError) if @txn_mutex.owned?
+
+        @txn_mutex.synchronize do
+          yield
+        ensure
+          commit_transaction
+        end
+      end
+
+      private
+
+      def mark_for_mutation!
+        @dirty = true
+        @data = @data.dup if @data.frozen?
+      end
+
+      def commit_transaction
+        if @dirty && !@readonly
+          dump_data
+          @dirty = false
+        end
+      end
+
+      def load_data
+        @data = begin
+          data = File.open(@store_path, encoding: Encoding::BINARY) do |io|
+            MessagePack.load(io, freeze: true)
+          end
+          if data.is_a?(Hash) && data[VERSION_KEY] == CURRENT_VERSION
+            data
+          else
+            default_data
+          end
+        # handle malformed data due to upgrade incompatibility
+        rescue Errno::ENOENT, MessagePack::MalformedFormatError, MessagePack::UnknownExtTypeError, EOFError
+          default_data
+        rescue ArgumentError => error
+          if error.message.include?("negative array size")
+            default_data
+          else
+            raise
+          end
+        end
+      end
+
+      def dump_data
+        # Change contents atomically so other processes can't get invalid
+        # caches if they read at an inopportune time.
+        tmp = "#{@store_path}.#{Process.pid}.#{(rand * 100_000).to_i}.tmp"
+        mkdir_p(File.dirname(tmp))
+        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.open(tmp, mode: exclusive_write, encoding: Encoding::BINARY) do |io|
+          MessagePack.dump(@data, io)
+        end
+        File.rename(tmp, @store_path)
+      rescue Errno::EEXIST
+        retry
+      rescue SystemCallError
+      end
+
+      def default_data
+        {VERSION_KEY => CURRENT_VERSION}
+      end
+
+      def mkdir_p(path)
+        stack = []
+        until File.directory?(path)
+          stack.push path
+          path = File.dirname(path)
+        end
+        stack.reverse_each do |dir|
+          Dir.mkdir(dir)
+        rescue SystemCallError
+          # Check for broken symlinks. Calling File.realpath will raise Errno::ENOENT if that is the case
+          File.realpath(dir) if File.symlink?(dir)
+          raise unless File.directory?(dir)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  module LoadPathCache
+    FALLBACK_SCAN = BasicObject.new
+
+    DOT_RB = ".rb"
+    DOT_SO = ".so"
+    SLASH  = "/"
+
+    DL_EXTENSIONS = ::RbConfig::CONFIG
+      .values_at("DLEXT", "DLEXT2")
+      .reject { |ext| !ext || ext.empty? }
+      .map    { |ext| ".#{ext}" }
+      .freeze
+    DLEXT = DL_EXTENSIONS[0]
+    # This is nil on linux and darwin, but I think it's '.o' on some other
+    # platform.  I'm not really sure which, but it seems better to replicate
+    # ruby's semantics as faithfully as possible.
+    DLEXT2 = DL_EXTENSIONS[1]
+
+    CACHED_EXTENSIONS = DLEXT2 ? [DOT_RB, DLEXT, DLEXT2] : [DOT_RB, DLEXT]
+
+    @enabled = false
+
+    class << self
+      attr_reader(:load_path_cache, :loaded_features_index, :enabled)
+      alias_method :enabled?, :enabled
+      remove_method(:enabled)
+
+      def setup(cache_path:, development_mode:, ignore_directories:, readonly: false)
+        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, readonly: readonly)
+
+        @loaded_features_index = LoadedFeaturesIndex.new
+
+        PathScanner.ignored_directories = ignore_directories if ignore_directories
+        @load_path_cache = Cache.new(store, $LOAD_PATH, development_mode: development_mode)
+        @enabled = true
+        require_relative "load_path_cache/core_ext/kernel_require"
+        require_relative "load_path_cache/core_ext/loaded_features"
+      end
+
+      def unload!
+        @enabled = false
+        @loaded_features_index = nil
+        @realpath_cache = nil
+        @load_path_cache = nil
+        ChangeObserver.unregister($LOAD_PATH) if supported?
+      end
+
+      def supported?
+        if RUBY_PLATFORM.match?(/darwin|linux|bsd|mswin|mingw|cygwin/)
+          case RUBY_ENGINE
+          when "truffleruby"
+            # https://github.com/oracle/truffleruby/issues/3131
+            RUBY_ENGINE_VERSION >= "23.1.0"
+          when "ruby"
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end
+
+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"
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bootsnap"
+require "rake/clean"
+
+# Typically, should have been set up prior to requiring rake integration.
+# But allow for a streamlined ::default_setup
+require "bootsnap/setup" if Bootsnap.cache_dir.nil?
+
+if Bootsnap.cache_dir
+  CLEAN.include Bootsnap.cache_dir
+else
+  abort "Bootsnap must be set-up prior to rake integration"
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "../bootsnap"
+
+Bootsnap.default_setup

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Bootsnap
+  VERSION = "1.24.6"
+end

data/bootsnap-1.24.6/lib/bootsnap.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require_relative "bootsnap/version"
+require_relative "bootsnap/bundler"
+
+module Bootsnap
+  InvalidConfiguration = Class.new(StandardError)
+
+  class << self
+    attr_reader :cache_dir, :logger
+
+    def log_stats!
+      stats = {hit: 0, revalidated: 0, miss: 0, stale: 0}
+      self.instrumentation = ->(event, _path) { stats[event] += 1 }
+      Kernel.at_exit do
+        stats.each do |event, count|
+          $stderr.puts "bootsnap #{event}: #{count}"
+        end
+      end
+    end
+
+    def log!
+      self.logger = $stderr.method(:puts)
+    end
+
+    def logger=(logger)
+      @logger = logger
+      self.instrumentation = if logger.respond_to?(:debug)
+        ->(event, path) { @logger.debug("[Bootsnap] #{event} #{path}") unless event == :hit }
+      else
+        ->(event, path) { @logger.call("[Bootsnap] #{event} #{path}") unless event == :hit }
+      end
+    end
+
+    def instrumentation=(callback)
+      @instrumentation = callback
+      if respond_to?(:instrumentation_enabled=, true)
+        self.instrumentation_enabled = !!callback
+      end
+    end
+
+    def _instrument(event, path)
+      @instrumentation.call(event, path)
+    end
+
+    def setup(
+      cache_dir:,
+      development_mode: true,
+      load_path_cache: true,
+      ignore_directories: nil,
+      readonly: false,
+      revalidation: false,
+      compile_cache_iseq: true,
+      compile_cache_yaml: true,
+      compile_cache_json: (compile_cache_json_unset = true),
+      config_path: nil
+    )
+      unless compile_cache_json_unset
+        warn("Bootsnap.setup `compile_cache_json` argument is deprecated and has no effect")
+      end
+
+      @cache_dir = "#{cache_dir}/bootsnap"
+
+      if load_path_cache
+        Bootsnap::LoadPathCache.setup(
+          cache_path: "#{@cache_dir}/load-path-cache",
+          development_mode: development_mode,
+          ignore_directories: ignore_directories,
+          readonly: readonly,
+        )
+      end
+
+      Bootsnap::CompileCache.setup(
+        cache_dir: "#{@cache_dir}/compile-cache",
+        iseq: compile_cache_iseq,
+        yaml: compile_cache_yaml,
+        readonly: readonly,
+        revalidation: revalidation,
+      )
+
+      load_config(config_path)
+    end
+
+    def load_config(config_path)
+      if config_path
+        config_path = File.expand_path(config_path)
+        if File.exist?(config_path)
+          require(config_path)
+        end
+      end
+    end
+
+    def enable_frozen_string_literal(app_only: false)
+      if app_only
+        gems_root = File.join(Bundler.bundle_path.cleanpath, "")
+        app_root =  File.join(Dir.pwd, "")
+        Bootsnap::CompileCache::ISeq.default_compiler = Bootsnap::CompileCache::ISeq::DEFAULT
+        Bootsnap::CompileCache::ISeq.compiler_selector = lambda { |path|
+          # Enable `frozen_string_literal: true` for app code, but not gems.
+
+          if path.start_with?(app_root) && !path.start_with?(gems_root)
+            Bootsnap::CompileCache::ISeq::FROZEN_STRING_LITERAL
+          else
+            Bootsnap::CompileCache::ISeq::DEFAULT
+          end
+        }
+      else
+        options = RubyVM::InstructionSequence.compile_option.merge(frozen_string_literal: true)
+        RubyVM::InstructionSequence.compile_option = options
+      end
+    end
+
+    def unload_cache!
+      LoadPathCache.unload!
+    end
+
+    def default_setup
+      env = ENV["RAILS_ENV"] || ENV["RACK_ENV"] || ENV["ENV"]
+      development_mode = ["", nil, "development"].include?(env)
+
+      if enabled?("BOOTSNAP")
+        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
+
+        ignore_directories = if ENV.key?("BOOTSNAP_IGNORE_DIRECTORIES")
+          ENV["BOOTSNAP_IGNORE_DIRECTORIES"].split(",")
+        end
+
+        setup(
+          cache_dir: cache_dir,
+          development_mode: development_mode,
+          load_path_cache: enabled?("BOOTSNAP_LOAD_PATH_CACHE"),
+          compile_cache_iseq: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          compile_cache_yaml: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          readonly: bool_env("BOOTSNAP_READONLY"),
+          revalidation: bool_env("BOOTSNAP_REVALIDATE"),
+          ignore_directories: ignore_directories,
+          config_path: ENV["BOOTSNAP_CONFIG"] || "config/bootsnap.rb",
+        )
+
+        if ENV["BOOTSNAP_LOG"]
+          log!
+        elsif ENV["BOOTSNAP_STATS"]
+          log_stats!
+        end
+      end
+    end
+
+    if /mswin|mingw|cygwin/.match?(RbConfig::CONFIG["host_os"])
+      def absolute_path?(path)
+        path[1] == ":"
+      end
+    else
+      def absolute_path?(path)
+        path.start_with?("/")
+      end
+    end
+
+    # This is a semi-accurate ruby implementation of the native `rb_get_path(VALUE)` function.
+    # The native version is very intricate and may behave differently on windows etc.
+    # But we only use it for non-MRI platform.
+    def rb_get_path(fname)
+      path_path = fname.respond_to?(:to_path) ? fname.to_path : fname
+      String.try_convert(path_path) || raise(TypeError, "no implicit conversion of #{path_path.class} into String")
+    end
+
+    # Allow the C extension to redefine `rb_get_path` without warning.
+    alias_method :rb_get_path, :rb_get_path
+
+    private
+
+    def enabled?(key)
+      !ENV["DISABLE_#{key}"]
+    end
+
+    def bool_env(key, default: false)
+      value = ENV.fetch(key) { default }
+      !["0", "false", false].include?(value)
+    end
+  end
+end
+
+require_relative "bootsnap/compile_cache"
+require_relative "bootsnap/load_path_cache"

data/mini-max-rb.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s|
+  s.name        = "mini-max-rb"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on bootsnap"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+  s.metadata    = { "source_code_uri" => "https://github.com/Andrey78/mini-max-rb" }
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: mini-max-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on bootsnap
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bootsnap-1.24.6/CHANGELOG.md
+- bootsnap-1.24.6/LICENSE.txt
+- bootsnap-1.24.6/README.md
+- bootsnap-1.24.6/exe/bootsnap
+- bootsnap-1.24.6/ext/bootsnap/bootsnap.c
+- bootsnap-1.24.6/ext/bootsnap/extconf.rb
+- bootsnap-1.24.6/lib/bootsnap.rb
+- bootsnap-1.24.6/lib/bootsnap/bundler.rb
+- bootsnap-1.24.6/lib/bootsnap/cli.rb
+- bootsnap-1.24.6/lib/bootsnap/cli/worker_pool.rb
+- bootsnap-1.24.6/lib/bootsnap/compile_cache.rb
+- bootsnap-1.24.6/lib/bootsnap/compile_cache/iseq.rb
+- bootsnap-1.24.6/lib/bootsnap/compile_cache/ruby_bug_22023_canary.rb
+- bootsnap-1.24.6/lib/bootsnap/compile_cache/yaml.rb
+- bootsnap-1.24.6/lib/bootsnap/explicit_require.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/cache.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/change_observer.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/core_ext/kernel_require.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/core_ext/loaded_features.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/loaded_features_index.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/path.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/path_scanner.rb
+- bootsnap-1.24.6/lib/bootsnap/load_path_cache/store.rb
+- bootsnap-1.24.6/lib/bootsnap/rake.rb
+- bootsnap-1.24.6/lib/bootsnap/setup.rb
+- bootsnap-1.24.6/lib/bootsnap/version.rb
+- mini-max-rb.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/Andrey78/mini-max-rb
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []