pigeonhole-db 1.1.0

data/vendor/bundle/ruby/3.4.0/gems/rb_sys-0.9.130/lib/rb_sys/extensiontask.rb

@@ -0,0 +1,188 @@
+require_relative "cargo/metadata"
+require_relative "error"
+
+begin
+  require "rake/extensiontask"
+rescue LoadError
+  abort "Please install rake-compiler to use this feature"
+end
+
+module RbSys
+  # ExtensionTask is a Rake::ExtensionTask subclass that is used to tailored for
+  # Rust extensions. It has the same options a `Rake::ExtensionTask`.
+  #
+  # @see https://www.rubydoc.info/gems/rake-compiler/Rake/ExtensionTask
+  #
+  # @example
+  #   RbSys::ExtensionTask.new("my-crate", my_gemspec) do |ext|
+  #     ext.lib_dir = "lib/my-crate"
+  #   end
+  #
+  # @param name [String] the crate name to build
+  # @param gem_spec [Gem::Specification] the gem specification to build (needed for cross-compiling)
+  # @return [Rake::ExtensionTask]
+  class ExtensionTask < Rake::ExtensionTask
+    def initialize(name = nil, gem_spec = :undefined)
+      super
+    end
+
+    def init(name = nil, gem_spec = nil)
+      super(name, lint_gem_spec(name, gem_spec))
+
+      @original_ext_dir = @ext_dir
+      @ext_dir = cargo_manifest_directory
+      @source_pattern = nil
+      @compiled_pattern = "*.{obj,so,bundle,dSYM}"
+      @cross_compile = ENV.key?("RUBY_TARGET")
+      @cross_platform = [ENV["RUBY_TARGET"]].compact
+      @cross_compiling_blocks = []
+      @cross_compiling_blocks << proc do |gemspec|
+        warn "Removing unneeded dependencies from native gemspec"
+        gemspec.dependencies.reject! { |d| d.name == "rb_sys" }
+      end
+      @cross_compiling_blocks << proc do |gemspec|
+        warn "Removing source files from native gemspec"
+        gemspec.files.reject! { |f| f.end_with?(".rs") }
+        gemspec.files.reject! { |f| f.match?(/Cargo.(toml|lock)$/) }
+        gemspec.files.reject! { |f| extconf.end_with?(f) }
+        gemspec.extensions.reject! { |f| f.end_with?("Cargo.toml") }
+      end
+    end
+
+    def define
+      super
+      define_env_tasks
+
+      CLEAN.include(target_directory) if defined?(CLEAN)
+    end
+
+    def cargo_metadata
+      @cargo_metadata ||= Cargo::Metadata.new_or_inferred(@name)
+    end
+
+    def extconf
+      File.join(ext_dir, "extconf.rb")
+    end
+
+    def binary(_platf)
+      super.tr("-", "_")
+    end
+
+    # I'm not sure why this is necessary, can it be removed?
+    def source_files
+      list = FileList[
+        "#{ext_dir}/**/*.{rs,rb,c,h,toml}",
+        "**/Cargo.{toml,lock}",
+        "**/.cargo/**/*",
+        "#{ext_dir}/lib/**/*"
+      ]
+      list.include("#{ext_dir}/#{@source_pattern}") if @source_pattern
+      list.exclude(File.join(target_directory, "**/*"))
+      list
+    end
+
+    def cross_compiling(&block)
+      @cross_compiling_blocks << block if block
+    end
+
+    def target_directory
+      return fallback_target_directory if @cargo_metadata_unavailable
+
+      cargo_metadata.target_directory
+    end
+
+    def define_native_tasks(for_platform = nil, ruby_ver = RUBY_VERSION, callback = nil)
+      cb = proc do |gemspec|
+        callback&.call(gemspec)
+
+        @cross_compiling_blocks.each do |block|
+          block.call(gemspec)
+        end
+      end
+
+      super(for_platform, ruby_ver, cb)
+    end
+
+    def define_env_tasks
+      task "rb_sys:env:default" do
+        ENV["RB_SYS_CARGO_TARGET_DIR"] ||= target_directory
+        ENV["RB_SYS_CARGO_MANIFEST_DIR"] ||= File.expand_path(ext_dir)
+        ENV["RB_SYS_CARGO_PROFILE"] ||= "release"
+      end
+
+      desc "Use the debug profile for building native Rust extensions"
+      task "rb_sys:env:dev" do
+        ENV["RB_SYS_CARGO_PROFILE"] = "dev"
+      end
+
+      desc "Use the release profile for building native Rust extensions"
+      task "rb_sys:env:release" do
+        ENV["RB_SYS_CARGO_PROFILE"] = "release"
+      end
+
+      file extconf => "rb_sys:env:default"
+
+      desc 'Compile the native Rust extension with the "dev" profile'
+      task "compile:dev" => ["rb_sys:env:dev", "compile"]
+
+      desc 'Compile the native Rust extension with the "release" profile'
+      task "compile:release" => ["rb_sys:env:release", "compile"]
+    end
+
+    private
+
+    def cargo_manifest_directory
+      cargo_metadata.manifest_directory
+    rescue CargoMetadataError
+      raise unless force_install_rust_toolchain?
+
+      # Let the generated Makefile install Cargo before the extension is built.
+      @cargo_metadata_unavailable = true
+      File.expand_path(configured_extension_directory)
+    end
+
+    def configured_extension_directory
+      extension = @gem_spec&.extensions&.find do |path|
+        %w[Cargo.toml extconf.rb].include?(File.basename(path))
+      end
+
+      extension ? File.dirname(extension) : @original_ext_dir
+    end
+
+    def fallback_target_directory
+      File.expand_path(ENV["RB_SYS_CARGO_TARGET_DIR"] || ENV["CARGO_TARGET_DIR"] || "target")
+    end
+
+    def force_install_rust_toolchain?
+      value = ENV["RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN"]
+      value && value != "false"
+    end
+
+    def lint_gem_spec(name, gs)
+      gem_spec = case gs
+      when :undefined
+        return
+      when Gem::Specification
+        gs
+      when String
+        Gem::Specification.load(gem_spec) || raise(ArgumentError, "Unable to load gemspec from file #{gs.inspect}")
+      else
+        raise ArgumentError, "gem_spec must be a Gem::Specification, got #{gs.class}"
+      end
+
+      gem_spec.files.each do |f|
+        if /\.(dll|so|dylib|lib|bundle)$/.match?(f)
+          warn "⚠️ gemspec includes native artifact (#{f}), please remove it."
+        end
+      end
+
+      if (gem_crate_name = gem_spec.metadata["cargo_crate_name"])
+        if name != gem_crate_name
+          warn "⚠️ cargo_crate_name (#{gem_crate_name}) does not match extension task crate name (#{name})"
+        end
+      end
+
+      gem_spec
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rb_sys-0.9.130/lib/rb_sys/mkmf/config.rb

@@ -0,0 +1,75 @@
+# Root module
+module RbSys
+  # Helper class for creating Rust Makefiles
+  module Mkmf
+    # Config that delegates to CargoBuilder if needded
+    class Config
+      # Force the installation of the Rust toolchain when building
+      attr_accessor :force_install_rust_toolchain
+
+      # Clean artifacts after install (default: true if invoked by Rubygems)
+      attr_accessor :clean_after_install
+
+      # Target directory for cargo artifacts
+      attr_accessor :target_dir
+
+      # Automatically install the Rust toolchain when building (default: true)
+      attr_accessor :auto_install_rust_toolchain
+
+      # Directories to clean after installing with Rubygems
+      attr_accessor :rubygems_clean_dirs
+
+      # Extra targets to install
+      attr_accessor :extra_rustup_targets
+
+      # Use compiled C code fallback for stable API for ruby-head (default: false)
+      attr_accessor :use_stable_api_compiled_fallback
+
+      # Instead of the default `cargo rustc` behaviour, just call `cargo build`.
+      # Requires manually setting relevant rb-sys environment (default: false)
+      attr_accessor :use_cargo_build
+
+      def initialize(builder)
+        @builder = builder
+        @builder.config = self
+        @force_install_rust_toolchain = false
+        @auto_install_rust_toolchain = true
+        @use_stable_api_compiled_fallback = false
+        @clean_after_install = rubygems_invoked?
+        @rubygems_clean_dirs = ["./cargo-vendor"]
+        @extra_rustup_targets = []
+      end
+
+      # @api private
+      def cross_compiling?
+        RbConfig::CONFIG["CROSS_COMPILING"] == "yes"
+      end
+
+      # @api private
+      def method_missing(name, *args, &blk)
+        @builder.send(name, *args, &blk)
+      end
+
+      # @api private
+      def respond_to_missing?(name, include_private = false)
+        @builder.respond_to?(name) || super
+      end
+
+      # Unfortunate, but this seems to be the only way to reliably know if we
+      # were invoked by Rubygems. We want to know this so we can cleanup the
+      # target directory after an install, to remove bloat.
+      #
+      # Note: we avoid nix environments so we do not force recompilation in
+      # development, and accept that the "clean" task will not automatically
+      # run.
+      #
+      def rubygems_invoked?
+        ENV.key?("SOURCE_DATE_EPOCH") && ENV["RB_SYS_TEST"] != "1" && !ENV.key?("NIX_STORE")
+      end
+
+      def use_stable_api_compiled_fallback?
+        @use_stable_api_compiled_fallback
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/rb_sys-0.9.130/lib/rb_sys/mkmf.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require "rubygems/ext"
+require "open3"
+require "shellwords"
+require_relative "cargo_builder"
+require_relative "mkmf/config"
+
+# rubocop:disable Style/GlobalVars
+# Root module
+module RbSys
+  # Helper class for creating Rust Makefiles
+  module Mkmf
+    # Helper for building Rust extensions by creating a Ruby compatible makefile
+    # for Rust. By using this class, your rust extension will be 100% compatible
+    # with the rake-compiler gem, which allows for easy cross compilation.
+    #
+    # @example Basic
+    #   require 'mkmf'
+    #   require 'rb_sys/mkmf'
+    #
+    #   create_rust_makefile("my_extension") #=> Generate a Makefile in the current directory
+    #
+    # @example Configure a custom build profile
+    #   require 'mkmf'
+    #   require 'rb_sys/mkmf'
+    #
+    #   create_rust_makefile("my_extension") do |r|
+    #     # All of these are optional
+    #     r.env = { 'FOO' => 'bar' }
+    #     r.profile = ENV.fetch('RB_SYS_CARGO_PROFILE', :dev).to_sym
+    #     r.features = %w[some_cargo_feature]
+    #     r.extra_rustflags = %w[--cfg=foo]
+    #     r.target_dir = "some/target/dir"
+    #   end
+    def create_rust_makefile(target, &blk)
+      if target.include?("/")
+        target_prefix, target = File.split(target)
+        target_prefix[0, 0] = "/"
+      else
+        target_prefix = ""
+      end
+
+      spec = Struct.new(:name, :metadata).new(target, {})
+      cargo_builder = CargoBuilder.new(spec)
+      builder = Config.new(cargo_builder)
+
+      yield builder if blk
+
+      srcprefix = File.join("$(srcdir)", builder.ext_dir.gsub(/\A\.\/?/, "")).chomp("/")
+      RbConfig.expand(srcdir = srcprefix.dup)
+
+      full_cargo_command = cargo_command(srcdir, builder)
+
+      global_rustflags = []
+      # Re-enable if this causes issues, but it should be fine and it prevents unnecessary recompilation
+      # global_rustflags << "--cfg=rb_sys_gem" unless builder.use_cargo_build
+      global_rustflags << "--cfg=rb_sys_use_stable_api_compiled_fallback" if builder.use_stable_api_compiled_fallback?
+
+      make_install = <<~MAKE
+        #{conditional_assign("RB_SYS_BUILD_DIR", File.join(Dir.pwd, ".rb-sys"))}
+        #{conditional_assign("CARGO", "cargo")}
+        #{conditional_assign("CARGO_BUILD_TARGET", builder.target)}
+        #{conditional_assign("SOEXT", builder.so_ext)}
+        #{try_load_bundled_libclang(builder)}
+
+        # Determine the prefix Cargo uses for the lib.
+        #{if_neq_stmt("$(SOEXT)", "dll")}
+        #{conditional_assign("SOEXT_PREFIX", "lib", indent: 1)}
+        #{endif_stmt}
+
+        #{set_cargo_profile(builder)}
+        #{conditional_assign("RB_SYS_CARGO_FEATURES", builder.features.join(","))}
+        #{conditional_assign("RB_SYS_GLOBAL_RUSTFLAGS", global_rustflags.join(" "))}
+        #{conditional_assign("RB_SYS_EXTRA_RUSTFLAGS", builder.extra_rustflags.join(" "))}
+        #{conditional_assign("RB_SYS_EXTRA_CARGO_ARGS", builder.extra_cargo_args.join(" "))}
+        #{conditional_assign("RB_SYS_CARGO_MANIFEST_DIR", builder.manifest_dir)}
+
+        # Set dirname for the profile, since the profiles do not directly map to target dir (i.e. dev -> debug)
+        #{if_eq_stmt("$(RB_SYS_CARGO_PROFILE)", "dev")}
+        #{conditional_assign("RB_SYS_CARGO_PROFILE_DIR", "debug", indent: 1)}
+        #{else_stmt}
+        #{conditional_assign("RB_SYS_CARGO_PROFILE_DIR", "$(RB_SYS_CARGO_PROFILE)", indent: 1)}
+        #{endif_stmt}
+
+        # Set the build profile (dev, release, etc.).
+        #{assign_stmt("RB_SYS_CARGO_PROFILE_FLAG", "--profile $(RB_SYS_CARGO_PROFILE)", indent: 1)}
+
+        # Account for sub-directories when using `--target` argument with Cargo
+        #{conditional_assign("RB_SYS_CARGO_TARGET_DIR", "target")}
+        #{if_neq_stmt("$(CARGO_BUILD_TARGET)", "")}
+        #{assign_stmt("RB_SYS_FULL_TARGET_DIR", "$(RB_SYS_CARGO_TARGET_DIR)/$(CARGO_BUILD_TARGET)", indent: 1)}
+        #{else_stmt}
+        #{assign_stmt("RB_SYS_FULL_TARGET_DIR", "$(RB_SYS_CARGO_TARGET_DIR)", indent: 1)}
+        #{endif_stmt}
+
+        target_prefix = #{target_prefix}
+        TARGET_NAME = #{target[/\A\w+/]}
+        TARGET_ENTRY = #{RbConfig::CONFIG["EXPORT_PREFIX"]}Init_$(TARGET_NAME)
+        RUBYARCHDIR = $(sitearchdir)$(target_prefix)
+        TARGET = #{target}
+        DLLIB = $(TARGET).#{RbConfig::CONFIG["DLEXT"]}
+        RUSTLIBDIR = $(RB_SYS_FULL_TARGET_DIR)/$(RB_SYS_CARGO_PROFILE_DIR)
+        RUSTLIB = $(RUSTLIBDIR)/$(SOEXT_PREFIX)$(TARGET_NAME).$(SOEXT)
+        TIMESTAMP_DIR = .
+        POSTLINK = #{RbConfig::CONFIG["POSTLINK"] || "$(ECHO) skipping postlink"}
+
+        CLEANOBJS = $(RUSTLIBDIR) $(RB_SYS_BUILD_DIR)
+        CLEANLIBS = $(DLLIB) $(RUSTLIB)
+        RUBYGEMS_CLEAN_DIRS = $(CLEANOBJS) $(CLEANFILES) #{builder.rubygems_clean_dirs.join(" ")}
+
+        #{base_makefile(srcdir)}
+
+        .PHONY: gemclean
+
+        #{if_neq_stmt("$(RB_SYS_VERBOSE)", "")}
+        #{assign_stmt("Q", "$(0=@)", indent: 1)}
+        #{endif_stmt}
+
+        #{env_vars(builder)}
+        #{export_env("RUSTFLAGS", "$(RB_SYS_GLOBAL_RUSTFLAGS) $(RB_SYS_EXTRA_RUSTFLAGS) $(RUSTFLAGS)")}
+
+        FORCE: ;
+
+        #{optional_rust_toolchain(builder)}
+
+        #{timestamp_file("sitearchdir")}:
+        \t$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+        \t$(Q) $(TOUCH) $@
+
+        $(RUSTLIB): FORCE
+        \t$(ECHO) generating $(@) \\("$(RB_SYS_CARGO_PROFILE)"\\)
+        \t#{full_cargo_command}
+
+        $(DLLIB): $(RUSTLIB)
+        \t$(Q) $(COPY) "$(RUSTLIB)" $@
+        \t$(Q) $(POSTLINK)
+
+        install-so: $(DLLIB) #{timestamp_file("sitearchdir")}
+        \t$(ECHO) installing $(DLLIB) to $(RUBYARCHDIR)
+        \t#{fixup_libnames}
+        \t$(Q) $(MAKEDIRS) $(RUBYARCHDIR)
+        \t$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+
+        gemclean: install-so
+        \t$(ECHO) Cleaning gem artifacts
+        \t-$(Q)$(RM_RF) $(RUBYGEMS_CLEAN_DIRS) 2> /dev/null || true
+
+        install: #{builder.clean_after_install ? "gemclean" : "install-so"}
+
+        all: #{$extout ? "install" : "$(DLLIB)"}
+      MAKE
+
+      make_install = gsub_cargo_command!(make_install.dup, builder: builder)
+
+      File.write("Makefile", make_install)
+    end
+
+    private
+
+    def base_makefile(cargo_dir)
+      base_makefile = dummy_makefile(__dir__).join("\n")
+      base_makefile.gsub!("all install static install-so install-rb", "all static install-rb")
+      base_makefile.gsub!(/^srcdir = .*$/, "srcdir = #{cargo_dir}")
+      base_makefile
+    end
+
+    def cargo_command(cargo_dir, builder)
+      builder.ext_dir = cargo_dir
+      dest_path = builder.target_dir || File.join(Dir.pwd, "target")
+      args = []
+      args = ARGV.dup.shift if args.first == "--"
+      cargo_cmd = builder.cargo_command(dest_path, args)
+      cmd = Shellwords.join(cargo_cmd)
+      cmd.gsub!("\\=", "=")
+      if builder.use_cargo_build
+        cmd.gsub!(/\Acargo rustc/, "$(CARGO) build $(RB_SYS_EXTRA_CARGO_ARGS) --manifest-path $(RB_SYS_CARGO_MANIFEST_DIR)/Cargo.toml")
+      else
+        cmd.gsub!(/\Acargo rustc/, "$(CARGO) rustc $(RB_SYS_EXTRA_CARGO_ARGS) --manifest-path $(RB_SYS_CARGO_MANIFEST_DIR)/Cargo.toml")
+      end
+      cmd.gsub!(/-v=\d/, "")
+      cmd
+    end
+
+    def env_vars(builder)
+      lines = []
+
+      if (cc = env_or_makefile_config("CC", builder)) && find_executable(cc)
+        lines << assign_stmt("CC", cc)
+      end
+
+      if (cxx = env_or_makefile_config("CXX", builder)) && find_executable(cxx)
+        lines << assign_stmt("CXX", cxx)
+      end
+
+      if (ar = env_or_makefile_config("AR", builder)) && find_executable(ar)
+        lines << assign_stmt("AR", ar)
+      end
+
+      lines += builder.build_env.map { |k, v| env_line(k, v) }
+      lines.compact.join("\n")
+    end
+
+    def env_line(k, v)
+      return unless v
+      export_env(k, strip_cmd(v.gsub("\n", '\n')))
+    end
+
+    def strip_cmd(cmd)
+      cmd.gsub("-nologo", "").strip
+    end
+
+    def env_or_makefile_config(key, builder)
+      builder.env[key] || ENV[key] || RbConfig::MAKEFILE_CONFIG[key]
+    end
+
+    def gsub_cargo_command!(cargo_command, builder:)
+      cargo_command.gsub!(/--profile [\w-]+/, "$(RB_SYS_CARGO_PROFILE_FLAG)")
+      cargo_command.gsub!(%r{--features \S+}, "--features $(RB_SYS_CARGO_FEATURES)")
+      cargo_command.gsub!(%r{--target \S+}, "--target $(CARGO_BUILD_TARGET)")
+      cargo_command.gsub!(/--target-dir (?:\\.|[^[:space:]])+/, "--target-dir $(RB_SYS_CARGO_TARGET_DIR)")
+      cargo_command
+    end
+
+    def rust_toolchain_env(builder)
+      <<~MAKE
+        #{conditional_assign("RB_SYS_RUSTUP_PROFILE", "minimal")}
+
+        # If the user passed true, we assume stable Rust. Otherwise, use what
+        # was specified (i.e. RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN=beta)
+        #{if_eq_stmt("$(RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN)", "true")}
+          RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN = stable
+        #{endif_stmt}
+
+        # If a $RUST_TARGET is specified (i.e. for rake-compiler-dock), append
+        # that to the profile.
+        #{if_eq_stmt("$(RUST_TARGET)", "")}
+          RB_SYS_DEFAULT_TOOLCHAIN = $(RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN)
+        #{else_stmt}
+          RB_SYS_DEFAULT_TOOLCHAIN = $(RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN)-$(RUST_TARGET)
+        #{endif_stmt}
+
+        # Since we are forcing the installation of the Rust toolchain, we need
+        # to set these env vars unconditionally for the build.
+        #{export_env("CARGO_HOME", "$(RB_SYS_BUILD_DIR)/$(RB_SYS_DEFAULT_TOOLCHAIN)/cargo")}
+        #{export_env("RUSTUP_HOME", "$(RB_SYS_BUILD_DIR)/$(RB_SYS_DEFAULT_TOOLCHAIN)/rustup")}
+        #{export_env("PATH", "$(CARGO_HOME)/bin:$(RUSTUP_HOME)/bin:$(PATH)")}
+        #{export_env("RUSTUP_TOOLCHAIN", "$(RB_SYS_DEFAULT_TOOLCHAIN)")}
+        #{export_env("CARGO", "$(CARGO_HOME)/bin/cargo")}
+      MAKE
+    end
+
+    def optional_rust_toolchain(builder)
+      rustup_default_cmd = "$(Q) $(CARGO_HOME)/bin/rustup default $(RB_SYS_DEFAULT_TOOLCHAIN)"
+      rustup_toolchain_cmd = "$(Q) $(CARGO_HOME)/bin/rustup toolchain install $(RB_SYS_DEFAULT_TOOLCHAIN) --profile $(RB_SYS_RUSTUP_PROFILE)"
+
+      <<~MAKE
+        #{conditional_assign("RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN", force_install_rust_toolchain?(builder))}
+
+        # Only run if the we are told to explicitly install the Rust toolchain
+        #{if_neq_stmt("$(RB_SYS_FORCE_INSTALL_RUST_TOOLCHAIN)", "false")}
+        #{rust_toolchain_env(builder)}
+
+        $(CARGO):
+        \t$(Q) $(MAKEDIRS) $(CARGO_HOME) $(RUSTUP_HOME)
+        \t$(Q) curl --proto '=https' --tlsv1.2 --retry 10 --retry-connrefused -fsSL "https://sh.rustup.rs" | sh -s -- --no-modify-path --profile $(RB_SYS_RUSTUP_PROFILE) --default-toolchain none -y
+        \t#{rustup_toolchain_cmd} || (sleep 5; #{rustup_toolchain_cmd}) || (sleep 5; #{rustup_toolchain_cmd})
+        \t#{rustup_default_cmd} || (sleep 5; #{rustup_default_cmd}) || (sleep 5; #{rustup_default_cmd})
+        #{install_extra_rustup_targets(builder)}
+
+        $(RUSTLIB): $(CARGO)
+        #{endif_stmt}
+      MAKE
+    end
+
+    def install_extra_rustup_targets(builder)
+      builder.extra_rustup_targets.map do |target|
+        "\t$(Q) $(CARGO_HOME)/bin/rustup target add #{target}"
+      end.join("\n")
+    end
+
+    def force_install_rust_toolchain?(builder)
+      return builder.force_install_rust_toolchain if builder.force_install_rust_toolchain
+      return false unless builder.rubygems_invoked? && builder.auto_install_rust_toolchain
+
+      find_executable("cargo").nil?
+    end
+
+    def fixup_libnames
+      # Try to find install_name_tool, checking multiple possible names:
+      # 1. Native macOS install_name_tool
+      # 2. Target-prefixed version from osxcross (e.g., aarch64-apple-darwin-install_name_tool)
+      tool = if find_executable("install_name_tool")
+        "install_name_tool"
+      elsif find_executable("$(CARGO_BUILD_TARGET)-install_name_tool")
+        "$(CARGO_BUILD_TARGET)-install_name_tool"
+      else
+        return
+      end
+
+      %($(Q) #{tool} -id "$(notdir $(DLLIB))" $(DLLIB))
+    end
+
+    def if_eq_stmt(a, b)
+      if $nmake
+        "!IF #{a.inspect} == #{b.inspect}"
+      else
+        "ifeq (#{a},#{b})"
+      end
+    end
+
+    def if_neq_stmt(a, b)
+      if $nmake
+        "!IF #{a.inspect} != #{b.inspect}"
+      else
+        "ifneq (#{a},#{b})"
+      end
+    end
+
+    def else_stmt
+      if $nmake
+        "!ELSE"
+      else
+        "else"
+      end
+    end
+
+    def endif_stmt
+      if $nmake
+        "!ENDIF"
+      else
+        "endif"
+      end
+    end
+
+    def conditional_assign(a, b, export: false, indent: 0)
+      if $nmake
+        result = "!IFNDEF #{a}\n#{a} = #{b}\n!ENDIF\n"
+        result << export_env(a, b) if export
+        result
+      else
+        "#{"\t" * indent}#{"export " if export}#{a} ?= #{b}"
+      end
+    end
+
+    def assign_stmt(a, b, indent: 0)
+      if $nmake
+        "#{a} = #{b}"
+      else
+        "#{"\t" * indent}#{a} = #{b}"
+      end
+    end
+
+    def export_env(k, v)
+      if $nmake
+        "!if [set #{k}=#{v}]\n!endif"
+      else
+        "export #{k} := #{v}"
+      end
+    end
+
+    def try_load_bundled_libclang(builder)
+      require "libclang"
+      assert_libclang_version_valid!
+
+      config = [export_env("LIBCLANG_PATH", Libclang.libdir)]
+      if (include_dir = compiler_builtin_include_dir(builder))
+        clang_args = Shellwords.join(["-isystem", include_dir])
+        config << conditional_assign("BINDGEN_EXTRA_CLANG_ARGS", clang_args, export: true)
+      end
+      config.join("\n")
+    rescue LoadError
+      # If we can't load the bundled libclang, just continue
+    end
+
+    def compiler_builtin_include_dir(builder)
+      cc = env_or_makefile_config("CC", builder)
+      return unless cc
+
+      stdout, _stderr, status = Open3.capture3(*Shellwords.split(cc), "-print-file-name=include")
+      return unless status.success?
+
+      path = stdout.strip
+      return if path.empty? || path == "include"
+
+      include_dir = File.expand_path(path)
+      include_dir if Dir.exist?(include_dir)
+    rescue Errno::ENOENT
+      nil
+    end
+
+    def assert_libclang_version_valid!
+      libclang_version = Gem::Version.new(Libclang.version)
+
+      if libclang_version < Gem::Version.new("5.0.0")
+        raise "libclang version 5.0.0 or greater is required (current #{libclang_version})"
+      end
+
+      if libclang_version >= Gem::Version.new("17.0.0")
+        raise "libclang version < 17.0.0 or greater is required (current #{libclang_version})"
+      end
+    end
+
+    def set_cargo_profile(builder)
+      return assign_stmt("RB_SYS_CARGO_PROFILE", "release") if builder.rubygems_invoked?
+
+      conditional_assign("RB_SYS_CARGO_PROFILE", builder.profile)
+    end
+  end
+end
+# rubocop:enable Style/GlobalVars
+
+include RbSys::Mkmf # rubocop:disable Style/MixinUsage

data/vendor/bundle/ruby/3.4.0/gems/rb_sys-0.9.130/lib/rb_sys/toolchain_info/data.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# THIS FILE IS AUTO-GENERATED BY `rake data:derive`
+
+module RbSys
+  class ToolchainInfo
+    # @private
+    DATA = {"arm-linux" => {"rust-target" => "arm-unknown-linux-gnueabihf", "rake-compiler-dock" => {"cc" => "arm-linux-gnueabihf-gcc"}, "docker-platform" => "linux/arm/v7", "supported" => true}, "arm-linux-musl" => {"rust-target" => "arm-unknown-linux-musleabihf", "rake-compiler-dock" => {"cc" => "arm-linux-musleabihf-gcc"}, "docker-platform" => "linux/arm/v7", "supported" => true}, "aarch64-linux" => {"aliases" => ["aarch64-linux-gnu", "aarch64-unknown-linux-gnu"], "rust-target" => "aarch64-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "aarch64-linux-gnu-gcc"}, "docker-platform" => "linux/arm64/v8", "supported" => true}, "aarch64-linux-musl" => {"rust-target" => "aarch64-unknown-linux-musl", "rake-compiler-dock" => {"cc" => "aarch64-linux-musl-gcc"}, "docker-platform" => "linux/arm64/v8", "supported" => true}, "arm64-darwin" => {"rust-target" => "aarch64-apple-darwin", "rake-compiler-dock" => {"cc" => "aarch64-apple-darwin-clang"}, "docker-platform" => "linux/arm64/v8", "supported" => true}, "x64-mingw-ucrt" => {"rust-target" => "x86_64-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "x86_64-windows-gnu-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "aarch64-mingw-ucrt" => {"rust-target" => "aarch64-pc-windows-gnullvm", "rake-compiler-dock" => {"cc" => "aarch64-w64-mingw32-clang"}, "docker-platform" => "linux/amd64", "supported" => true}, "x64-mingw32" => {"rust-target" => "x86_64-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "x86_64-windows-gnu-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86-linux" => {"rust-target" => "i686-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "i686-redhat-linux-gcc"}, "docker-platform" => "linux/i386", "supported" => false}, "x86-mingw32" => {"rust-target" => "i686-pc-windows-gnu", "rake-compiler-dock" => {"cc" => "i686-w64-mingw32-gcc"}, "docker-platform" => "linux/i386", "supported" => false}, "x86_64-darwin" => {"rust-target" => "x86_64-apple-darwin", "rake-compiler-dock" => {"cc" => "x86_64-apple-darwin-clang"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86_64-linux" => {"aliases" => ["x86_64-linux-gnu", "x86_64-unknown-linux-gnu"], "rust-target" => "x86_64-unknown-linux-gnu", "rake-compiler-dock" => {"cc" => "x86_64-redhat-linux-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}, "x86_64-linux-musl" => {"rust-target" => "x86_64-unknown-linux-musl", "rake-compiler-dock" => {"cc" => "x86_64-unknown-linux-musl-gcc"}, "docker-platform" => "linux/amd64", "supported" => true}}
+  end
+end