ed-precompiled_bootsnap 1.18.6-x86_64-linux

data/lib/bootsnap/load_path_cache/path_scanner.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative "../explicit_require"
+
+module Bootsnap
+  module LoadPathCache
+    module PathScanner
+      REQUIRABLE_EXTENSIONS = [DOT_RB] + DL_EXTENSIONS
+      NORMALIZE_NATIVE_EXTENSIONS = !DL_EXTENSIONS.include?(LoadPathCache::DOT_SO)
+      ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = /\.(o|bundle|dylib)\z/.freeze
+
+      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 call(path)
+          path = File.expand_path(path.to_s).freeze
+          return [[], []] unless File.directory?(path)
+
+          # 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?(path)
+
+          dirs = []
+          requirables = []
+          walk(path, nil) do |relative_path, absolute_path, is_directory|
+            if is_directory
+              dirs << os_path(relative_path)
+              !contains_bundle_path || !absolute_path.start_with?(BUNDLE_PATH)
+            elsif relative_path.end_with?(*REQUIRABLE_EXTENSIONS)
+              requirables << os_path(relative_path)
+            end
+          end
+          [requirables, dirs]
+        end
+
+        def walk(absolute_dir_path, relative_dir_path, &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 = "#{absolute_dir_path}/#{name}"
+            if File.directory?(absolute_path)
+              next if ignored_directories.include?(name) || ignored_directories.include?(absolute_path)
+
+              if yield relative_path, absolute_path, true
+                walk(absolute_path, relative_path, &block)
+              end
+            else
+              yield relative_path, absolute_path, false
+            end
+          end
+        end
+
+        if RUBY_VERSION >= "3.1"
+          def os_path(path)
+            path.freeze
+          end
+        else
+          def os_path(path)
+            path.force_encoding(Encoding::US_ASCII) if path.ascii_only?
+            path.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/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 = "#{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 =~ /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/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/lib/bootsnap/setup.rb

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

data/lib/bootsnap/version.rb

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

data/lib/bootsnap.rb

@@ -0,0 +1,164 @@
+# 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)
+
+  class << self
+    attr_reader :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: true
+    )
+      if load_path_cache
+        Bootsnap::LoadPathCache.setup(
+          cache_path: "#{cache_dir}/bootsnap/load-path-cache",
+          development_mode: development_mode,
+          ignore_directories: ignore_directories,
+          readonly: readonly,
+        )
+      end
+
+      Bootsnap::CompileCache.setup(
+        cache_dir: "#{cache_dir}/bootsnap/compile-cache",
+        iseq: compile_cache_iseq,
+        yaml: compile_cache_yaml,
+        json: compile_cache_json,
+        readonly: readonly,
+        revalidation: revalidation,
+      )
+    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"),
+          compile_cache_json: enabled?("BOOTSNAP_COMPILE_CACHE"),
+          readonly: bool_env("BOOTSNAP_READONLY"),
+          revalidation: bool_env("BOOTSNAP_REVALIDATE"),
+          ignore_directories: ignore_directories,
+        )
+
+        if ENV["BOOTSNAP_LOG"]
+          log!
+        elsif ENV["BOOTSNAP_STATS"]
+          log_stats!
+        end
+      end
+    end
+
+    if RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
+      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 # rubocop:disable Lint/DuplicateMethods
+
+    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

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: ed-precompiled_bootsnap
+version: !ruby/object:Gem::Version
+  version: 1.18.6
+platform: x86_64-linux
+authors:
+- Burke Libbey
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Boot large ruby/rails apps faster
+email:
+- burke.libbey@shopify.com
+executables:
+- bootsnap
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- exe/bootsnap
+- ext/bootsnap/bootsnap.c
+- ext/bootsnap/bootsnap.h
+- ext/bootsnap/extconf.rb
+- lib/bootsnap.rb
+- lib/bootsnap/3.0/bootsnap.so
+- lib/bootsnap/3.1/bootsnap.so
+- lib/bootsnap/3.2/bootsnap.so
+- lib/bootsnap/3.3/bootsnap.so
+- lib/bootsnap/3.4/bootsnap.so
+- lib/bootsnap/bootsnap.so
+- lib/bootsnap/bootsnap_ext.rb
+- lib/bootsnap/bundler.rb
+- lib/bootsnap/cli.rb
+- lib/bootsnap/cli/worker_pool.rb
+- lib/bootsnap/compile_cache.rb
+- lib/bootsnap/compile_cache/iseq.rb
+- lib/bootsnap/compile_cache/json.rb
+- lib/bootsnap/compile_cache/yaml.rb
+- lib/bootsnap/explicit_require.rb
+- lib/bootsnap/load_path_cache.rb
+- lib/bootsnap/load_path_cache/cache.rb
+- lib/bootsnap/load_path_cache/change_observer.rb
+- lib/bootsnap/load_path_cache/core_ext/kernel_require.rb
+- lib/bootsnap/load_path_cache/core_ext/loaded_features.rb
+- lib/bootsnap/load_path_cache/loaded_features_index.rb
+- lib/bootsnap/load_path_cache/path.rb
+- lib/bootsnap/load_path_cache/path_scanner.rb
+- lib/bootsnap/load_path_cache/store.rb
+- lib/bootsnap/setup.rb
+- lib/bootsnap/version.rb
+homepage: https://github.com/rails/bootsnap
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/rails/bootsnap/issues
+  changelog_uri: https://github.com/rails/bootsnap/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rails/bootsnap
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.5.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Boot large ruby/rails apps faster
+test_files: []