fix(ruby): retry Ruby tool resolution with a real cwd

vitallium · vitallium · commit d11bc41cc06c · 2026-05-11T21:11:40.000+02:00
The previous PWD-based attempt did not change the child process working
directory, so Bundler and RubyGems could still resolve the wrong Ruby.
Run extension-side bundle/ruby/gem probes through a worktree-root shell
wrapper instead, and allow that wrapper in the manifest so fallback
installation uses the same project context as the final language server.
diff --git a/extension.toml b/extension.toml
@@ -89,5 +89,10 @@ kind = "process:exec"
 command = "ruby"
 args = ["--version"]
 
+[[capabilities]]
+kind = "process:exec"
+command = "sh"
+args = ["-c", "*"]
+
 [debug_adapters.rdbg]
 [debug_locators.ruby]
diff --git a/src/bundler.rs b/src/bundler.rs
@@ -1,4 +1,4 @@
-use crate::{command_executor::CommandExecutor, environment::shell_env_with_pwd};
+use crate::command_executor::CommandExecutor;
 use anyhow::{bail, Context, Result};
 use std::path::PathBuf;
 
@@ -53,22 +53,27 @@ impl<E: CommandExecutor> Bundler<E> {
         })?;
 
         let full_args: Vec<&str> = std::iter::once(cmd).chain(args.iter().copied()).collect();
-        let mut command_envs: Vec<(String, String)> = envs
+        let command_envs: Vec<(String, String)> = envs
             .iter()
             .copied()
             .filter(|(key, _)| *key != "BUNDLE_GEMFILE")
             .map(|(key, value)| (key.to_string(), value.to_string()))
             .collect();
-        command_envs.push(("BUNDLE_GEMFILE".to_string(), bundle_gemfile.to_string()));
-        let command_envs = shell_env_with_pwd(command_envs, working_dir_str);
+        let command_envs = command_envs
+            .into_iter()
+            .chain(std::iter::once((
+                "BUNDLE_GEMFILE".to_string(),
+                bundle_gemfile.to_string(),
+            )))
+            .collect::<Vec<_>>();
         let command_env_refs = command_envs
             .iter()
             .map(|(key, value)| (key.as_str(), value.as_str()))
             .collect::<Vec<_>>();
 
         let output = self
             .command_executor
-            .execute("bundle", &full_args, &command_env_refs)
+            .execute_in_dir("bundle", &full_args, &command_env_refs, working_dir_str)
             .map_err(|e| anyhow::anyhow!(e))?;
 
         match output.status {
@@ -171,10 +176,7 @@ mod tests {
             .to_string_lossy()
             .into_owned();
 
-        vec![
-            ("BUNDLE_GEMFILE".to_string(), gemfile_path),
-            ("PWD".to_string(), dir.to_string()),
-        ]
+        vec![("BUNDLE_GEMFILE".to_string(), gemfile_path)]
     }
 
     fn env_refs(envs: &[(String, String)]) -> Vec<(&str, &str)> {
@@ -216,7 +218,7 @@ mod tests {
     }
 
     #[test]
-    fn test_installed_gem_version_overrides_pwd_and_bundle_gemfile_envs() {
+    fn test_installed_gem_version_overrides_bundle_gemfile_env() {
         let mock_executor = MockCommandExecutor::new();
         let mut expected_command_envs = vec![("PATH".to_string(), "/usr/bin".to_string())];
         expected_command_envs.extend(expected_envs("test_dir"));
@@ -237,11 +239,7 @@ mod tests {
         let version = bundler
             .installed_gem_version(
                 "rails",
-                &[
-                    ("PWD", "wrong_dir"),
-                    ("BUNDLE_GEMFILE", "wrong/Gemfile"),
-                    ("PATH", "/usr/bin"),
-                ],
+                &[("BUNDLE_GEMFILE", "wrong/Gemfile"), ("PATH", "/usr/bin")],
             )
             .expect("Expected successful version");
 
diff --git a/src/command_executor.rs b/src/command_executor.rs
@@ -22,6 +22,17 @@ pub trait CommandExecutor {
         args: &[&str],
         envs: &[(&str, &str)],
     ) -> zed::Result<zed::process::Output>;
+
+    fn execute_in_dir(
+        &self,
+        cmd: &str,
+        args: &[&str],
+        envs: &[(&str, &str)],
+        working_dir: &str,
+    ) -> zed::Result<zed::process::Output> {
+        let _ = working_dir;
+        self.execute(cmd, args, envs)
+    }
 }
 
 /// An implementation of `CommandExecutor` that executes commands
@@ -41,4 +52,36 @@ impl CommandExecutor for RealCommandExecutor {
             .envs(envs.iter().copied())
             .output()
     }
+
+    fn execute_in_dir(
+        &self,
+        cmd: &str,
+        args: &[&str],
+        envs: &[(&str, &str)],
+        working_dir: &str,
+    ) -> zed::Result<zed::process::Output> {
+        let script = sh_command_in_dir(working_dir, cmd, args);
+
+        eprintln!("Executing in dir via sh: {script}");
+
+        zed::Command::new("sh")
+            .args(["-c", script.as_str()])
+            .envs(envs.iter().copied())
+            .output()
+    }
+}
+
+fn sh_command_in_dir(working_dir: &str, cmd: &str, args: &[&str]) -> String {
+    format!(
+        "cd -- {} && exec {}{}",
+        sh_quote(working_dir),
+        sh_quote(cmd),
+        args.iter()
+            .map(|arg| format!(" {}", sh_quote(arg)))
+            .collect::<String>()
+    )
+}
+
+fn sh_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "'\"'\"'"))
 }
diff --git a/src/environment.rs b/src/environment.rs
diff --git a/src/gemset.rs b/src/gemset.rs
@@ -13,8 +13,17 @@ pub fn versioned_gem_home(
     envs: &[(&str, &str)],
     executor: &dyn CommandExecutor,
 ) -> Result<PathBuf> {
+    let working_dir = envs
+        .iter()
+        .find_map(|(key, value)| (*key == "PWD").then_some(*value));
+
     let output = executor
-        .execute("ruby", &["--version"], envs)
+        .execute_in_dir(
+            "ruby",
+            &["--version"],
+            envs,
+            working_dir.unwrap_or(base_dir.to_string_lossy().as_ref()),
+        )
         .map_err(|e| anyhow::anyhow!(e))
         .context("Failed to detect Ruby version")?;
 
@@ -34,6 +43,7 @@ pub fn versioned_gem_home(
 /// A simple wrapper around the `gem` command.
 pub struct Gemset {
     gem_home: PathBuf,
+    working_dir: Option<String>,
     envs: Vec<(String, String)>,
     cached_env: OnceLock<Vec<(String, String)>>,
     command_executor: Box<dyn CommandExecutor>,
@@ -47,6 +57,10 @@ impl Gemset {
     ) -> Self {
         Self {
             gem_home,
+            working_dir: envs.and_then(|envs| {
+                envs.iter()
+                    .find_map(|(key, value)| (*key == "PWD").then_some((*value).to_string()))
+            }),
             envs: envs.map_or(Vec::new(), |envs| {
                 envs.iter()
                     .map(|&(k, v)| (k.to_string(), v.to_string()))
@@ -181,7 +195,14 @@ impl Gemset {
 
         let output = self
             .command_executor
-            .execute("gem", &full_args, &merged_envs)
+            .execute_in_dir(
+                "gem",
+                &full_args,
+                &merged_envs,
+                self.working_dir
+                    .as_deref()
+                    .unwrap_or(self.gem_home.to_string_lossy().as_ref()),
+            )
             .map_err(|e| anyhow!(e))?;
 
         match output.status {
diff --git a/src/language_servers/language_server.rs b/src/language_servers/language_server.rs
@@ -4,7 +4,6 @@ use std::collections::HashMap;
 use crate::{
     bundler::Bundler,
     command_executor::RealCommandExecutor,
-    environment::shell_env_with_pwd,
     gemset::{versioned_gem_home, Gemset},
 };
 use std::path::PathBuf;
@@ -151,7 +150,7 @@ pub trait LanguageServer {
             zed::settings::LspSettings::for_worktree(language_server_id.as_ref(), worktree)?;
 
         let worktree_root = worktree.root_path();
-        let shell_env = shell_env_with_pwd(worktree.shell_env(), worktree_root.clone());
+        let shell_env = worktree.shell_env();
 
         if let Some(binary_settings) = &lsp_settings.binary {
             if let Some(path) = &binary_settings.path {
@@ -197,7 +196,14 @@ pub trait LanguageServer {
                     env: Some(shell_env),
                 })
             }
-            Err(_e) => self.try_find_on_path_or_extension_gemset(language_server_id, worktree),
+            Err(e) => {
+                eprintln!(
+                    "Bundler probe failed for {} in {}: {e:#}",
+                    Self::GEM_NAME,
+                    worktree_root
+                );
+                self.try_find_on_path_or_extension_gemset(language_server_id, worktree)
+            }
         }
     }
 
@@ -206,8 +212,7 @@ pub trait LanguageServer {
         language_server_id: &zed::LanguageServerId,
         worktree: &zed::Worktree,
     ) -> zed::Result<LanguageServerBinary> {
-        let worktree_root = worktree.root_path();
-        let shell_env = shell_env_with_pwd(worktree.shell_env(), worktree_root);
+        let shell_env = worktree.shell_env();
 
         if let Some(path) = worktree.which(Self::EXECUTABLE_NAME) {
             Ok(LanguageServerBinary {
@@ -228,8 +233,7 @@ pub trait LanguageServer {
         let base_dir = std::env::current_dir()
             .map_err(|e| format!("Failed to get extension directory: {e:#}"))?;
 
-        let worktree_root = worktree.root_path();
-        let worktree_shell_env = shell_env_with_pwd(worktree.shell_env(), worktree_root);
+        let worktree_shell_env = worktree.shell_env();
         let worktree_shell_env_vars: Vec<(&str, &str)> = worktree_shell_env
             .iter()
             .map(|(key, value)| (key.as_str(), value.as_str()))
@@ -239,6 +243,12 @@ pub trait LanguageServer {
             versioned_gem_home(&base_dir, &worktree_shell_env_vars, &RealCommandExecutor)
                 .map_err(|e| format!("{:#}", e))?;
 
+        eprintln!(
+            "Using extension gemset for {} with gem home {}",
+            Self::GEM_NAME,
+            gem_home.display()
+        );
+
         let gemset = Gemset::new(
             gem_home,
             Some(&worktree_shell_env_vars),
diff --git a/src/ruby.rs b/src/ruby.rs
@@ -1,6 +1,5 @@
 mod bundler;
 mod command_executor;
-mod environment;
 mod gemset;
 mod language_servers;
 
@@ -135,14 +134,15 @@ impl zed::Extension for RubyExtension {
         _: Option<String>,
         worktree: &Worktree,
     ) -> Result<DebugAdapterBinary, String> {
+        let worktree_root = worktree.root_path();
         let shell_env = worktree.shell_env();
         let env_vars: Vec<(&str, &str)> = shell_env
             .iter()
             .map(|(key, value)| (key.as_str(), value.as_str()))
             .collect();
 
         let (command, mut arguments) = {
-            let bundler = Bundler::new(PathBuf::from(worktree.root_path()), RealCommandExecutor);
+            let bundler = Bundler::new(PathBuf::from(&worktree_root), RealCommandExecutor);
             if bundler.installed_gem_version("debug", &env_vars).is_ok() {
                 let bundle = worktree.which("bundle").ok_or_else(|| {
                     "debug gem present, but unable to find 'bundle' command".to_string()
@@ -177,7 +177,7 @@ impl zed::Extension for RubyExtension {
         if let Some(configuration) = configuration.as_object_mut() {
             configuration
                 .entry("cwd")
-                .or_insert_with(|| worktree.root_path().into());
+                .or_insert_with(|| worktree_root.clone().into());
         }
 
         let ruby_config: RubyDebugConfig = serde_json::from_value(configuration.clone())
@@ -240,7 +240,7 @@ impl zed::Extension for RubyExtension {
             command: Some(command),
             arguments,
             connection: Some(connection),
-            cwd: ruby_config.cwd.or(Some(worktree.root_path())),
+            cwd: ruby_config.cwd.or(Some(worktree_root)),
             envs: ruby_config.env.into_iter().collect(),
             request_args: StartDebuggingRequestArguments {
                 configuration: configuration.to_string(),
