piko-lite-gem 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