I am not able to really remove all cache.

[a-chacon]

Don't matter how many times I execute the command rv cache clean it will always find a file to remove.

This is happening because of shell integration. The command shell init calls shell env and that is loading Configs and calling best_ruby() method which finally calls discover_rubies_matching in cache_ruby and create this cache. So the cache will never be really empty because shell integration is executed always.

Some solutions:

1. Apply a --no-cache to all shell init scripts. This still will be copying the interpreter to a temporal folder.
2. Why cache a ruby interpreter already installed? I was looking the code and I don't get why to cache it if I already have it installed in the system. Why not just point to that location? I mean, that is what finally happen.

Any other idea?

[deivid-rodriguez]

The reason to "cache ruby" is that rv runs ruby itself in order to extract some information about the ruby installation. See

rv/crates/rv-ruby/src/lib.rs

Lines 221 to 309 in e80cdd5

	/// Extract all Ruby information from the executable in a single call
	#[instrument(skip_all, level = "trace")]
	fn extract_ruby_info(ruby_bin: &Utf8PathBuf) -> Result<Ruby, RubyError> {
	if ruby_bin.as_str().ends_with("0.49/bin/ruby") {
	return ruby_049_version();
	}
	// try the full script with all features (works for most Ruby implementations)
	let full_script = r#"
	puts(Object.const_defined?(:RUBY_ENGINE) ? RUBY_ENGINE : 'ruby')
	puts(Object.const_defined?(:RUBY_ENGINE_VERSION) ? RUBY_ENGINE_VERSION : RUBY_VERSION)
	puts(Object.const_defined?(:RUBY_PLATFORM) ? RUBY_PLATFORM : 'unknown')
	puts(Object.const_defined?(:RbConfig) && RbConfig::CONFIG['host_cpu'] ? RbConfig::CONFIG['host_cpu'] : 'unknown')
	puts(Object.const_defined?(:RbConfig) && RbConfig::CONFIG['host_os'] ? RbConfig::CONFIG['host_os'] : 'unknown')
	puts(begin; require 'rubygems'; Gem.default_dir; rescue ScriptError, NoMethodError; end)
	puts(Object.const_defined?(:RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : '')
	"#;
	// On Windows, .cmd wrappers can't receive arguments containing special characters like (, ), ?
	// due to Rust's CVE-2024-24576 mitigation (1.77.2+). Following uv's pattern: write the probe
	// script to a temp file, then invoke through cmd.exe /c to bypass the restriction entirely.
	let output = if cfg!(windows) && ruby_bin.extension().is_some_and(|ext| ext == "cmd") {
	let probe_script = ruby_bin.with_file_name("_rv_probe.rb");
	std::fs::write(&probe_script, full_script).map_err(|_| RubyError::InvalidRubyExecutable)?;
	let result = Command::new("cmd")
	.args(["/c", ruby_bin.as_str(), probe_script.as_str()])
	.output();
	let _ = std::fs::remove_file(&probe_script);
	result.map_err(|_| RubyError::InvalidRubyExecutable)?
	} else {
	Command::new(ruby_bin)
	.args(["-e", full_script])
	.output()
	.map_err(|_| RubyError::InvalidRubyExecutable)?
	};
	let info = String::from_utf8(output.stdout).unwrap();
	let mut lines = info.trim().lines();
	let ruby_engine = lines.next().unwrap_or("ruby");
	let ruby_version = lines.next().unwrap_or_default();
	let ruby_platform = lines.next().unwrap_or("unknown");
	let host_cpu = lines.next().unwrap_or("unknown");
	let host_os = lines.next().unwrap_or("unknown");
	let gem_root = lines.next().unwrap_or_default();
	let description = lines.next().unwrap_or_default();
	let ruby_description = parse_description(description);
	let host_cpu = if host_cpu != "unknown" {
	host_cpu.to_string()
	} else {
	extract_arch_from_platform(ruby_platform)
	};
	let host_os = if host_os != "unknown" {
	host_os.to_string()
	} else {
	extract_os_from_platform(ruby_platform)
	};
	// Normalize architecture and OS names to match common conventions
	let arch = normalize_arch(&host_cpu);
	let os = normalize_os(&host_os);
	let version: RubyVersion = if let Some(d) = ruby_description {
	let desc_version = &d["version"];
	format!("{ruby_engine}-{desc_version}").parse()?
	} else {
	format!("{ruby_engine}-{ruby_version}").parse()?
	};
	let gem_root = if gem_root.is_empty() {
	None
	} else {
	Some(Utf8PathBuf::from(gem_root))
	};
	let key = format!("{version}-{os}-{arch}");
	Ok(Ruby {
	key,
	version,
	arch,
	os,
	gem_root,
	managed: false,
	// path and symlink are replaced in the caller
	path: Default::default(),
	symlink: Default::default(),
	})
	}

. Since shelling out to ruby is potentially slow, rv caches the information retrieved.

I do wonder whether this is really necessary though.