The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(ruby): Ruby LSP no longer crash-loops on dead shims or a spaced gem home (#1534)
Jacob Kjeldahl653ebd578af4
diff --git a/crates/ide-core/src/tool_path.rs b/crates/ide-core/src/tool_path.rsindex 266f5bae0..bc25dd6d2 100644--- a/crates/ide-core/src/tool_path.rs+++ b/crates/ide-core/src/tool_path.rs@@ -30,6 +30,21 @@ pub fn search_path() -> OsString {std::env::join_paths(dirs).unwrap_or_default()}+/// Ruby code printing where `gem install` puts executables: the Ruby's own `Gem.bindir`, which+/// Homebrew's Ruby keeps off `PATH`, and the `--user-install` one.+pub const RUBY_GEM_BIN_SCRIPT: &str = "puts Gem.bindir, File.join(Gem.user_dir, 'bin')";++/// The directories [`RUBY_GEM_BIN_SCRIPT`] printed that exist.+pub fn gem_bin_dirs(output: &str) -> Vec<PathBuf> {+ let mut dirs: Vec<PathBuf> = Vec::new();+ for dir in output.lines().map(str::trim).map(PathBuf::from) {+ if dir.is_absolute() && dir.is_dir() && !dirs.contains(&dir) {+ dirs.push(dir);+ }+ }+ dirs+}+/// Resolves a command on the shared path, or an explicit path relative to `root`.pub fn find_command(command: &str, search: &OsStr, root: &Path) -> Option<PathBuf> {let path = Path::new(command);diff --git a/crates/ide-host/src/ops/tools.rs b/crates/ide-host/src/ops/tools.rsindex b92399c2f..d3188b77a 100644--- a/crates/ide-host/src/ops/tools.rs+++ b/crates/ide-host/src/ops/tools.rs@@ -24,7 +24,11 @@ fn tools(host: &Host, window: &str) -> IdeResult<Tools> {.collect();// Godot is usually an app bundle / Flatpak outside the search path.let found = ide_sdk::godot::find(None).map(|p| (ide_sdk::godot::COMMAND.to_owned(), p));- Ok(Tools::new(&data).with_custom_paths(custom).with_found_paths(found.into_iter().collect()))+ let work_dir = (!root.as_os_str().is_empty()).then_some(root);+ Ok(Tools::new(&data)+ .with_custom_paths(custom)+ .with_found_paths(found.into_iter().collect())+ .with_work_dir(work_dir))}/// The language definitions plus the servers defined in the window's settings.diff --git a/crates/ide-lsp/src/launch.rs b/crates/ide-lsp/src/launch.rsindex c8f68f0e0..e7ce586b5 100644--- a/crates/ide-lsp/src/launch.rs+++ b/crates/ide-lsp/src/launch.rs@@ -4,7 +4,7 @@ use ide_core::CancellationToken;use ide_core::tool_path::search_path;use ide_jsonrpc::{Handler, Peer};use ide_language::LanguageServerConfig;-use std::ffi::OsString;+use std::ffi::{OsStr, OsString};use std::path::{Path, PathBuf};use std::sync::Arc;@@ -100,7 +100,8 @@ impl Launcher for ProcessLauncher {// A plugin's server: the approved program, unchanged since.Some(pin) => Some(pin.verify().map_err(LaunchError::Failed)?.to_path_buf()),None => ide_core::tool_path::find_command(&config.command, &search, root)- .and_then(|b| resolve_rustup_proxy(&config.command, b)),+ .and_then(|b| resolve_rustup_proxy(&config.command, b))+ .and_then(|b| reject_dead_shim(b, &search, root)),};let mut env: Vec<(String, String)> = vec![("PATH".into(), search.to_string_lossy().into_owned())];env.extend(config.env.iter().filter(|(k, _)| *k != "PATH").map(|(k, v)| (k.clone(), v.clone())));@@ -136,6 +137,60 @@ fn server_search_path(config: &LanguageServerConfig) -> OsString {config.env.get("PATH").map(OsString::from).unwrap_or_else(search_path)}+/// What a version manager's shim says when the active version has no such tool.+const DEAD_SHIM_MESSAGES: &[&str] =+ &["no version is set for", "no preset version", "command not found", "exists in these", "is not installed"];++/// `~/.local/share/mise/shims/ruby-lsp` exists for every version of the runtime that ever+/// had the tool, but exits with an error when the version active in `root` lacks it. A+/// server that dies like that on every start is missing (an install hint), not crashing.+/// Anything but a clear "not installed" answer from the shim counts as working.+fn reject_dead_shim(binary: PathBuf, search: &OsStr, root: &Path) -> Option<PathBuf> {+ if !binary.parent().is_some_and(|d| d.file_name().is_some_and(|n| n == "shims")) {+ return Some(binary);+ }+ let Ok(mut child) = ide_core::process::prepare(&mut std::process::Command::new(&binary))+ .arg("--version")+ .current_dir(root)+ .env("PATH", search)+ .stdin(std::process::Stdio::null())+ .stdout(std::process::Stdio::null())+ .stderr(std::process::Stdio::piped())+ .spawn()+ else {+ return Some(binary);+ };+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);+ let status = loop {+ match child.try_wait() {+ Ok(Some(status)) => break status,+ Ok(None) if std::time::Instant::now() < deadline => {+ std::thread::sleep(std::time::Duration::from_millis(20))+ }+ // Slow or unwaitable: let the real start decide.+ _ => {+ let _ = child.kill();+ let _ = child.wait();+ return Some(binary);+ }+ }+ };+ if status.success() {+ return Some(binary);+ }+ let mut stderr = String::new();+ if let Some(mut pipe) = child.stderr.take() {+ let _ = std::io::Read::read_to_string(&mut pipe, &mut stderr);+ }+ let stderr = stderr.to_lowercase();+ if DEAD_SHIM_MESSAGES.iter().any(|m| stderr.contains(m)) {+ tracing::info!("{} is a version-manager shim without the tool: {}", binary.display(), stderr.trim());+ None+ } else {+ Some(binary)+ }+}+/// `~/.cargo/bin/<tool>` is usually a rustup proxy that fails when the active/// toolchain lacks the component (common for rust-analyzer). In that case use/// the newest installed toolchain that ships the binary; with none, the tool is@@ -219,6 +274,34 @@ mod tests {std::fs::remove_dir_all(&tmp).unwrap();}+ #[cfg(unix)]+ #[test]+ fn shims_without_the_tool_are_missing() {+ use std::os::unix::fs::PermissionsExt;+ let tmp = tempfile::tempdir().unwrap();+ let shims = tmp.path().join("mise/shims");+ std::fs::create_dir_all(&shims).unwrap();+ let script = |name: &str, body: &str| {+ let p = shims.join(name);+ std::fs::write(&p, format!("#!/bin/sh\n{body}\n")).unwrap();+ std::fs::set_permissions(&p, std::fs::Permissions::from_mode(0o755)).unwrap();+ p+ };+ let search = OsString::from("/usr/bin:/bin");+ let dead = script("ruby-lsp", "echo 'mise ERROR No version is set for shim: ruby-lsp' >&2; exit 1");+ assert_eq!(reject_dead_shim(dead, &search, tmp.path()), None);+ let works = script("good", "echo 1.0");+ assert_eq!(reject_dead_shim(works.clone(), &search, tmp.path()), Some(works));+ // A tool with no `--version` that fails for its own reasons still starts.+ let odd = script("odd", "echo 'usage: odd' >&2; exit 2");+ assert_eq!(reject_dead_shim(odd.clone(), &search, tmp.path()), Some(odd));+ // Only shims are probed.+ let plain = tmp.path().join("ruby-lsp");+ std::fs::write(&plain, "#!/bin/sh\necho 'No version is set for' >&2; exit 1\n").unwrap();+ std::fs::set_permissions(&plain, std::fs::Permissions::from_mode(0o755)).unwrap();+ assert_eq!(reject_dead_shim(plain.clone(), &search, tmp.path()), Some(plain));+ }+#[test]fn marked_root_needs_a_marker() {let tmp = tempfile::tempdir().unwrap();diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rsindex 11888554c..2ee3a07e2 100644--- a/crates/ide-sdk/src/apply.rs+++ b/crates/ide-sdk/src/apply.rs@@ -691,6 +691,13 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_rootpath_dirs.push(dir);}+ // Gems install to the Ruby's bindir, which is not always on `PATH` (Homebrew).+ if name == "ruby-lsp"+ && let Some(ruby) = ruby_interpreter(root, s)+ {+ path_dirs.extend(crate::ruby::gem_bin_dirs(&ruby, server_root));+ }+if !path_dirs.is_empty() {let dirs: Vec<&Path> = path_dirs.iter().map(PathBuf::as_path).collect();cfg.env.insert("PATH".into(), path_with(&dirs));@@ -1301,3 +1308,29 @@ mod maven_linkage_tests {assert!(serde_json::to_value(cfg.initialization_options).unwrap().get("projectConfigurations").is_none());}}++#[cfg(all(test, unix))]+mod ruby_lsp_tests {+ use super::*;+ use std::os::unix::fs::PermissionsExt;++ #[test]+ fn ruby_lsp_is_found_in_the_rubys_gem_bindir_when_that_is_off_path() {+ let tmp = tempfile::tempdir().unwrap();+ let bindir = tmp.path().join("gems/bin");+ std::fs::create_dir_all(&bindir).unwrap();+ // Homebrew's Ruby: `Gem.bindir` is not on `PATH`.+ let ruby = tmp.path().join("ruby");+ std::fs::write(&ruby, format!("#!/bin/sh\necho '{}'\necho '/nonexistent/user/bin'\n", bindir.display()))+ .unwrap();+ std::fs::set_permissions(&ruby, std::fs::Permissions::from_mode(0o755)).unwrap();+ let mut s = Settings::default();+ s.languages.ruby.interpreter = ruby.to_string_lossy().into_owned();+ let mut cfg = custom_server("ruby-lsp", &LanguageServerSettings::default());+ configure_server(&mut cfg, tmp.path(), tmp.path(), &s);+ let path = cfg.env.get("PATH").expect("PATH set");+ let dirs: Vec<PathBuf> = std::env::split_paths(path).collect();+ assert!(dirs.contains(&bindir), "{dirs:?}");+ assert!(!dirs.iter().any(|d| d.starts_with("/nonexistent")), "{dirs:?}");+ }+}diff --git a/crates/ide-sdk/src/ruby.rs b/crates/ide-sdk/src/ruby.rsindex b7ce8df4b..c0bbed7ca 100644--- a/crates/ide-sdk/src/ruby.rs+++ b/crates/ide-sdk/src/ruby.rs@@ -140,6 +140,14 @@ pub fn bin_dir_of(ruby: &Path) -> Option<PathBuf> {ruby.parent().map(Path::to_path_buf)}+/// Where `ruby` installs gem executables (`Gem.bindir`, the `--user-install` one) that exist, asked+/// of the Ruby that version managers select in `root`: Homebrew's keeps its bindir off `PATH`.+pub fn gem_bin_dirs(ruby: &Path, root: &Path) -> Vec<PathBuf> {+ query_in(ruby, &["-e", ide_core::tool_path::RUBY_GEM_BIN_SCRIPT], Some(root), &[], QUERY_TIMEOUT)+ .map(|out| ide_core::tool_path::gem_bin_dirs(&out))+ .unwrap_or_default()+}+type NamedRoots = Vec<(String, PathBuf)>;/// Standard-library / site directories (`ruby/3.3.0`) and the gems Bundler resolvesdiff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rsindex 881393d6c..d0a8b65d5 100644--- a/crates/ide-tools/src/lib.rs+++ b/crates/ide-tools/src/lib.rs@@ -154,7 +154,11 @@ fn managed_bin_dir(root: &Path, spec: &ToolSpec, platform: Platform) -> Option<PMethod::PipVenv { .. } => {Some(root.join(spec.name).join("venv").join(if platform.os == Os::Windows { "Scripts" } else { "bin" }))}- Method::Bundled { .. } | Method::Rustup { .. } | Method::PipUser { .. } | Method::PipTarget { .. } => None,+ Method::Bundled { .. }+ | Method::Rustup { .. }+ | Method::PipUser { .. }+ | Method::PipTarget { .. }+ | Method::GemActive { .. } => None,}}@@ -429,6 +433,9 @@ pub struct Tools {/// Executables found outside the search path (app bundles), by command.found: BTreeMap<String, PathBuf>,version_timeout: Duration,+ /// The project the tools are used for: tools that install into "the active runtime" (gems) run here,+ /// so a version manager picks the project's Ruby.+ work_dir: Option<PathBuf>,}impl Tools {@@ -450,6 +457,7 @@ impl Tools {custom: BTreeMap::new(),found: BTreeMap::new(),version_timeout: Duration::from_secs(4),+ work_dir: None,}}@@ -465,10 +473,25 @@ impl Tools {self}+ /// Runs per-project installs (see [`registry::Method::GemActive`]) in `dir`.+ pub fn with_work_dir(mut self, dir: Option<PathBuf>) -> Self {+ self.work_dir = dir.filter(|d| d.is_dir());+ self+ }+pub fn root(&self) -> &Path {&self.root}+ /// [`Tools::command`] in the project directory.+ fn command_in_project(&self, program: impl AsRef<std::ffi::OsStr>) -> Command {+ let mut cmd = self.command(program);+ if let Some(dir) = &self.work_dir {+ cmd.current_dir(dir);+ }+ cmd+ }+fn which(&self, cmd: &str) -> Option<PathBuf> {ide_core::tool_path::find_command(cmd, &self.system_path, &self.root)}@@ -614,7 +637,9 @@ impl Tools {"npm or pnpm is required: install Node.js (https://nodejs.org)",),Method::Go { .. } => need(self.which("go").is_some(), "Go is required (https://go.dev/dl)"),- Method::Gem { .. } => need(self.which("gem").is_some(), "Ruby is required (https://www.ruby-lang.org)"),+ Method::Gem { .. } | Method::GemActive { .. } => {+ need(self.which("gem").is_some(), "Ruby is required (https://www.ruby-lang.org)")+ }Method::DotnetTool { .. } => {need(self.which("dotnet").is_some(), ".NET SDK is required (https://dotnet.microsoft.com/download)")}@@ -772,6 +797,22 @@ impl Tools {_ => (ToolStatus::Missing, None, None),}}+ Method::GemActive { gem } => {+ // Installed for the Ruby active in the project, not merely a shim of some other version's.+ let Some(gem_cmd) = self.which("gem") else { return (ToolStatus::Missing, None, None) };+ let mut c = self.command_in_project(&gem_cmd);+ c.args(["list", "--exact", gem]);+ match run_quiet(c, Duration::from_secs(10)) {+ Some((true, out)) if out.contains(&format!("{gem} (")) => {+ // Homebrew's Ruby keeps its gem bindir off PATH: ask the Ruby where it is.+ match self.gem_executable(main) {+ Some(path) => (ToolStatus::OnPath, Some(path), parse_version(&out)),+ None => (ToolStatus::Missing, None, None),+ }+ }+ _ => (ToolStatus::Missing, None, None),+ }+ }_ => match self.which(main) {Some(path) => {let version = self.query_version(spec, &path);@@ -868,6 +909,7 @@ impl Tools {Method::Npm { packages } => self.install_npm(packages, cancel, emit)?,Method::Go { module } => self.install_go(spec, module, cancel, emit)?,Method::Gem { gem } => self.install_gem(spec, gem, cancel, emit)?,+ Method::GemActive { gem } => self.install_gem_active(gem, cancel, emit)?,Method::DotnetTool { package } => self.install_dotnet_tool(spec, package, cancel, emit)?,Method::PipVenv { package } => self.install_venv(spec, package, cancel, emit)?,Method::PipUser { package, .. } => self.install_pip_user(package, cancel, emit)?,@@ -953,6 +995,41 @@ impl Tools {self.write_manifest(spec.name, &Manifest { version, source: Some(module.to_string()) })}+ /// Where the project's Ruby installs gem executables (`Gem.bindir`, `Gem.user_dir`'s `bin`).+ fn gem_bin_dirs(&self) -> Vec<PathBuf> {+ let Some(ruby) = self.which("ruby") else { return Vec::new() };+ let mut c = self.command_in_project(ruby);+ c.args(["-e", ide_core::tool_path::RUBY_GEM_BIN_SCRIPT]);+ match run_quiet(c, Duration::from_secs(10)) {+ Some((true, out)) => ide_core::tool_path::gem_bin_dirs(&out),+ _ => Vec::new(),+ }+ }++ /// An installed gem's executable: on the search path, else in one of the Ruby's gem bin directories.+ fn gem_executable(&self, cmd: &str) -> Option<PathBuf> {+ self.which(cmd).or_else(|| self.gem_bin_dirs().iter().find_map(|d| self.exe_in(d, cmd)))+ }++ /// `gem install` into the active Ruby, then makes version-manager shims see the new executable.+ fn install_gem_active(&self, gem: &str, cancel: &CancellationToken, emit: Emit) -> IdeResult<()> {+ let mut c = self.command_in_project(self.which("gem").expect("checked"));+ c.args(["install", "--no-document", gem]);+ run_streamed(c, cancel, emit)?;+ // mise / asdf / rbenv list executables in shims written at install time; a gem installed+ // afterwards has none until they are regenerated. Best effort: the tool may not be installed.+ for (manager, args) in+ [("mise", &["reshim"][..]), ("asdf", &["reshim", "ruby"][..]), ("rbenv", &["rehash"][..])]+ {+ if let Some(path) = self.which(manager) {+ let mut c = self.command_in_project(path);+ c.args(args);+ let _ = run_quiet(c, Duration::from_secs(30));+ }+ }+ Ok(())+ }+fn install_gem(&self, spec: &ToolSpec, gem: &str, cancel: &CancellationToken, emit: Emit) -> IdeResult<()> {let dir = self.root.join(spec.name);let _ = std::fs::remove_dir_all(&dir);@@ -1310,6 +1387,18 @@ impl Tools {run_streamed(c, &cancel, &quiet)?;}}+ Method::GemActive { gem } => {+ if let Some(gem_cmd) = self.which("gem") {+ let mut c = self.command_in_project(&gem_cmd);+ c.args(["uninstall", "--all", "--executables", "--ignore-dependencies", gem]);+ run_streamed(c, &cancel, &quiet)?;+ }+ // A copy an older version installed under the tools directory.+ let dir = self.root.join(spec.name);+ if dir.exists() {+ std::fs::remove_dir_all(&dir)?;+ }+ }Method::Go { .. }| Method::Gem { .. }| Method::DotnetTool { .. }diff --git a/crates/ide-tools/src/registry.rs b/crates/ide-tools/src/registry.rsindex 494482f76..50b503ca7 100644--- a/crates/ide-tools/src/registry.rs+++ b/crates/ide-tools/src/registry.rs@@ -49,6 +49,11 @@ pub enum Method {PipTarget { package: &'static str, module: &'static str },/// `gem install` into `<tools>/<name>/gems`, launched through `GEM_HOME` wrappers in `bin/`.Gem { gem: &'static str },+ /// `gem install <gem>` into the active Ruby (the project's, installed from a project window),+ /// launched through that Ruby's own executables. For tools that re-launch themselves under+ /// Bundler (ruby-lsp), which breaks in a gem home under a path with spaces+ /// (`~/Library/Application Support`: Bundler `exec`s a lone path string, and Ruby splits it).+ GemActive { gem: &'static str },/// `dotnet tool install --tool-path <tools>/<name>/tool <package>`, launched/// through `DOTNET_ROOT` wrappers in `bin/`.DotnetTool { package: &'static str },@@ -64,6 +69,7 @@ impl Method {Method::Npm { .. } => "npm",Method::Go { .. } => "go install",Method::Gem { .. } => "gem",+ Method::GemActive { .. } => "gem (project Ruby)",Method::DotnetTool { .. } => "dotnet tool",Method::PipVenv { .. } => "pip (virtualenv)",Method::PipUser { .. } => "pip --user",@@ -940,7 +946,7 @@ pub static TOOLS: &[ToolSpec] = &[display: "Ruby LSP (Shopify)",kind: LanguageServer,commands: &["ruby-lsp"],- method: Method::Gem { gem: "ruby-lsp" },+ method: Method::GemActive { gem: "ruby-lsp" },fallback: None,version: V,homepage: "https://shopify.github.io/ruby-lsp",diff --git a/crates/ide-tools/src/tests.rs b/crates/ide-tools/src/tests.rsindex de4ff670d..f3ab5530d 100644--- a/crates/ide-tools/src/tests.rs+++ b/crates/ide-tools/src/tests.rs@@ -590,6 +590,51 @@ printf '#!/bin/sh\necho "$GEM_HOME"\n' > "$bin/solargraph"; /bin/chmod +x "$bin/assert_eq!(String::from_utf8_lossy(&out.stdout).trim(), env.root.join("solargraph/gems").to_string_lossy());}+#[cfg(unix)]+#[test]+fn ruby_lsp_installs_into_the_project_ruby_not_a_private_gem_home() {+ let env = Env::new();+ let project = env._tmp.path().join("project");+ fs::create_dir_all(&project).unwrap();+ let marker = env._tmp.path().join("installed");+ // Homebrew's Ruby: the gem bindir is not on the search path; only the Ruby knows it.+ let bindir = env._tmp.path().join("gems/bin");+ fs::create_dir_all(&bindir).unwrap();+ env.script(&env.sys, "ruby", &format!("echo '{}'", bindir.display()));+ // `gem list --exact ruby-lsp` knows the gem once `gem install ruby-lsp` ran, in the cwd it was given.+ env.script(+ &env.sys,+ "gem",+ &format!(+ r#"case "$1" in+install) echo "$PWD $@" > '{m}'; printf '#!/bin/sh\n' > '{b}/ruby-lsp'; /bin/chmod +x '{b}/ruby-lsp' ;;+list) [ -f '{m}' ] && echo "ruby-lsp (0.26.11)" ;;+uninstall) /bin/rm -f '{m}' ;;+esac"#,+ m = marker.display(),+ b = bindir.display()+ ),+ );+ let tools = env.tools().with_work_dir(Some(project.clone()));+ assert_eq!(find(&tools.list(&langs()), "ruby-lsp").status, ToolStatus::Missing);+ let info = tools.install("ruby-lsp", &langs(), &CancellationToken::new(), &|_| {}).unwrap();+ assert_eq!(info.status, ToolStatus::OnPath);+ assert_eq!(info.version.as_deref(), Some("0.26.11"));+ // Found in the Ruby's own bindir, not reported as the `gem` command.+ assert_eq!(info.path.as_deref(), Some(bindir.join("ruby-lsp").as_path()));+ // Run in the project (so a version manager picks its Ruby), into the Ruby's own gem home.+ let log = fs::read_to_string(&marker).unwrap();+ assert!(log.starts_with(&*project.canonicalize().unwrap().to_string_lossy()), "{log}");+ assert!(log.contains("install --no-document ruby-lsp") && !log.contains("--install-dir"), "{log}");+ // No private gem home, no wrapper directory on the search path.+ assert!(!env.root.join("ruby-lsp").exists());+ // Uninstalling removes the gem, and an older managed copy.+ fs::create_dir_all(env.root.join("ruby-lsp/gems")).unwrap();+ let info = tools.uninstall("ruby-lsp", &langs()).unwrap();+ assert_eq!(info.status, ToolStatus::Missing);+ assert!(!env.root.join("ruby-lsp").exists());+}+#[cfg(unix)]#[test]fn dotnet_tool_install_into_tool_path() {