From dcafaa2de94ef6b2c9a1281ec3268e2c7473a6da Mon Sep 17 00:00:00 2001 From: Vitaly Slobodin Date: Thu, 4 Sep 2025 18:47:02 +0200 Subject: [PATCH 1/3] fix(gemset): allow custom env vars for gem commands --- src/gemset.rs | 99 ++++++++++++++++++++----- src/language_servers/language_server.rs | 10 +-- src/ruby.rs | 2 +- 3 files changed, 85 insertions(+), 26 deletions(-) diff --git a/src/gemset.rs b/src/gemset.rs index 59fc688..76b7847 100644 --- a/src/gemset.rs +++ b/src/gemset.rs @@ -61,7 +61,7 @@ impl Gemset { .collect() } - pub fn install_gem(&self, name: &str) -> Result<(), String> { + pub fn install_gem(&self, name: &str, envs: Option<&[(&str, &str)]>) -> Result<(), String> { let args = &[ "--no-user-install", "--no-format-executable", @@ -69,32 +69,41 @@ impl Gemset { name, ]; - self.execute_gem_command("install", args) + self.execute_gem_command("install", args, envs) .map_err(|e| format!("Failed to install gem '{name}': {e}"))?; Ok(()) } - pub fn update_gem(&self, name: &str) -> Result<(), String> { - self.execute_gem_command("update", &[name]) + pub fn update_gem(&self, name: &str, envs: Option<&[(&str, &str)]>) -> Result<(), String> { + self.execute_gem_command("update", &[name], envs) .map_err(|e| format!("Failed to update gem '{name}': {e}"))?; Ok(()) } - pub fn uninstall_gem(&self, name: &str, version: &str) -> Result<(), String> { + pub fn uninstall_gem( + &self, + name: &str, + version: &str, + envs: Option<&[(&str, &str)]>, + ) -> Result<(), String> { let args = &[name, "--version", version]; - self.execute_gem_command("uninstall", args) + self.execute_gem_command("uninstall", args, envs) .map_err(|e| format!("Failed to uninstall gem '{name}': {e}"))?; Ok(()) } - pub fn installed_gem_version(&self, name: &str) -> Result, String> { + pub fn installed_gem_version( + &self, + name: &str, + envs: Option<&[(&str, &str)]>, + ) -> Result, String> { let re = Regex::new(r"^(\S+) \((.+)\)$").map_err(|e| format!("Failed to compile regex: {e}"))?; let args = &["--exact", name]; - let output_str = self.execute_gem_command("list", args)?; + let output_str = self.execute_gem_command("list", args, envs)?; for line in output_str.lines() { let captures = match re.captures(line) { @@ -112,15 +121,25 @@ impl Gemset { Ok(None) } - pub fn is_outdated_gem(&self, name: &str) -> Result { - self.execute_gem_command("outdated", &[]).map(|output| { - output - .lines() - .any(|line| line.split_whitespace().next().is_some_and(|n| n == name)) - }) + pub fn is_outdated_gem( + &self, + name: &str, + envs: Option<&[(&str, &str)]>, + ) -> Result { + self.execute_gem_command("outdated", &[], envs) + .map(|output| { + output + .lines() + .any(|line| line.split_whitespace().next().is_some_and(|n| n == name)) + }) } - fn execute_gem_command(&self, cmd: &str, args: &[&str]) -> Result { + fn execute_gem_command( + &self, + cmd: &str, + args: &[&str], + envs: Option<&[(&str, &str)]>, + ) -> Result { let full_args: Vec<&str> = std::iter::once(cmd) .chain(std::iter::once("--norc")) .chain(args.iter().copied()) @@ -134,14 +153,23 @@ impl Gemset { .to_str() .ok_or("Failed to convert working_dir path to string")?; - let command_envs = &[ + let command_envs = vec![ ("GEM_HOME", gem_home_str), ("GEM_PATH", gem_home_str), ("RBENV_DIR", working_dir_str), ]; + let merged_envs: Vec<(&str, &str)> = if let Some(envs) = envs { + command_envs + .into_iter() + .chain(envs.iter().copied()) + .collect() + } else { + command_envs + }; + self.command_executor - .execute("gem", &full_args, command_envs) + .execute("gem", &full_args, &merged_envs) .and_then(|output| match output.status { Some(0) => Ok(String::from_utf8_lossy(&output.stdout).into_owned()), Some(status) => { @@ -331,7 +359,38 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - assert!(gemset.install_gem(gem_name).is_ok()); + assert!(gemset.install_gem(gem_name, None).is_ok()); + } + + #[test] + fn test_install_gem_with_custom_env() { + let mock_executor = MockGemCommandExecutor::new(); + let gem_name = "ruby-lsp"; + mock_executor.expect( + "gem", + &[ + "install", + "--norc", + "--no-user-install", + "--no-format-executable", + "--no-document", + gem_name, + ], + &[ + ("GEM_HOME", TEST_GEM_HOME), + ("GEM_PATH", TEST_GEM_HOME), + ("CUSTOM_VAR", "custom_value"), + ], + Ok(Output { + status: Some(0), + stdout: "Successfully installed ruby-lsp-1.0.0".as_bytes().to_vec(), + stderr: Vec::new(), + }), + ); + let gemset = create_gemset(mock_executor); + assert!(gemset + .install_gem(gem_name, Some(&[("CUSTOM_VAR", "custom_value")])) + .is_ok()); } #[test] @@ -360,7 +419,7 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - let result = gemset.install_gem(gem_name); + let result = gemset.install_gem(gem_name, None); assert!(result.is_err()); assert!(result .unwrap_err() @@ -386,7 +445,7 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - assert!(gemset.update_gem(gem_name).is_ok()); + assert!(gemset.update_gem(gem_name, None).is_ok()); } #[test] diff --git a/src/language_servers/language_server.rs b/src/language_servers/language_server.rs index 82b1931..1aea6be 100644 --- a/src/language_servers/language_server.rs +++ b/src/language_servers/language_server.rs @@ -238,10 +238,10 @@ pub trait LanguageServer { &zed::LanguageServerInstallationStatus::CheckingForUpdate, ); - match gemset.installed_gem_version(Self::GEM_NAME) { + match gemset.installed_gem_version(Self::GEM_NAME, Some(&worktree_shell_env_vars)) { Ok(Some(version)) => { if gemset - .is_outdated_gem(Self::GEM_NAME) + .is_outdated_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) .map_err(|e| e.to_string())? { zed::set_language_server_installation_status( @@ -250,11 +250,11 @@ pub trait LanguageServer { ); gemset - .update_gem(Self::GEM_NAME) + .update_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) .map_err(|e| e.to_string())?; gemset - .uninstall_gem(Self::GEM_NAME, &version) + .uninstall_gem(Self::GEM_NAME, &version, Some(&worktree_shell_env_vars)) .map_err(|e| e.to_string())?; } @@ -275,7 +275,7 @@ pub trait LanguageServer { ); gemset - .install_gem(Self::GEM_NAME) + .install_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) .map_err(|e| e.to_string())?; let executable_path = gemset diff --git a/src/ruby.rs b/src/ruby.rs index a9f4874..ece0157 100644 --- a/src/ruby.rs +++ b/src/ruby.rs @@ -160,7 +160,7 @@ impl zed::Extension for RubyExtension { Box::new(RealCommandExecutor), ); - match gemset.install_gem("debug") { + match gemset.install_gem("debug", None) { Ok(_) => rdbg_path = gemset.gem_bin_path("rdbg")?, Err(e) => return Err(format!("Failed to install debug gem: {e}")), } From c586b5be6fa99f3160d394299fa5a245abc05ff0 Mon Sep 17 00:00:00 2001 From: Vitaly Slobodin Date: Thu, 11 Sep 2025 13:10:26 +0200 Subject: [PATCH 2/3] feat(gemset): store env vars in struct Refactor Gemset to store environment variables in the struct instead of passing them to each method call. --- src/gemset.rs | 91 ++++++++++++------------- src/language_servers/language_server.rs | 21 +++--- src/ruby.rs | 3 +- 3 files changed, 55 insertions(+), 60 deletions(-) diff --git a/src/gemset.rs b/src/gemset.rs index 76b7847..633dd10 100644 --- a/src/gemset.rs +++ b/src/gemset.rs @@ -6,6 +6,7 @@ use std::path::PathBuf; pub struct Gemset { gem_home: PathBuf, working_dir: PathBuf, + envs: Vec<(String, String)>, command_executor: Box, } @@ -13,11 +14,17 @@ impl Gemset { pub fn new( gem_home: PathBuf, working_dir: PathBuf, + envs: Option<&[(&str, &str)]>, command_executor: Box, ) -> Self { Self { gem_home, working_dir, + envs: envs.map_or(Vec::new(), |envs| { + envs.iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect() + }), command_executor, } } @@ -61,7 +68,7 @@ impl Gemset { .collect() } - pub fn install_gem(&self, name: &str, envs: Option<&[(&str, &str)]>) -> Result<(), String> { + pub fn install_gem(&self, name: &str) -> Result<(), String> { let args = &[ "--no-user-install", "--no-format-executable", @@ -69,41 +76,32 @@ impl Gemset { name, ]; - self.execute_gem_command("install", args, envs) + self.execute_gem_command("install", args) .map_err(|e| format!("Failed to install gem '{name}': {e}"))?; Ok(()) } - pub fn update_gem(&self, name: &str, envs: Option<&[(&str, &str)]>) -> Result<(), String> { - self.execute_gem_command("update", &[name], envs) + pub fn update_gem(&self, name: &str) -> Result<(), String> { + self.execute_gem_command("update", &[name]) .map_err(|e| format!("Failed to update gem '{name}': {e}"))?; Ok(()) } - pub fn uninstall_gem( - &self, - name: &str, - version: &str, - envs: Option<&[(&str, &str)]>, - ) -> Result<(), String> { + pub fn uninstall_gem(&self, name: &str, version: &str) -> Result<(), String> { let args = &[name, "--version", version]; - self.execute_gem_command("uninstall", args, envs) + self.execute_gem_command("uninstall", args) .map_err(|e| format!("Failed to uninstall gem '{name}': {e}"))?; Ok(()) } - pub fn installed_gem_version( - &self, - name: &str, - envs: Option<&[(&str, &str)]>, - ) -> Result, String> { + pub fn installed_gem_version(&self, name: &str) -> Result, String> { let re = Regex::new(r"^(\S+) \((.+)\)$").map_err(|e| format!("Failed to compile regex: {e}"))?; let args = &["--exact", name]; - let output_str = self.execute_gem_command("list", args, envs)?; + let output_str = self.execute_gem_command("list", args)?; for line in output_str.lines() { let captures = match re.captures(line) { @@ -121,25 +119,15 @@ impl Gemset { Ok(None) } - pub fn is_outdated_gem( - &self, - name: &str, - envs: Option<&[(&str, &str)]>, - ) -> Result { - self.execute_gem_command("outdated", &[], envs) - .map(|output| { - output - .lines() - .any(|line| line.split_whitespace().next().is_some_and(|n| n == name)) - }) + pub fn is_outdated_gem(&self, name: &str) -> Result { + self.execute_gem_command("outdated", &[]).map(|output| { + output + .lines() + .any(|line| line.split_whitespace().next().is_some_and(|n| n == name)) + }) } - fn execute_gem_command( - &self, - cmd: &str, - args: &[&str], - envs: Option<&[(&str, &str)]>, - ) -> Result { + fn execute_gem_command(&self, cmd: &str, args: &[&str]) -> Result { let full_args: Vec<&str> = std::iter::once(cmd) .chain(std::iter::once("--norc")) .chain(args.iter().copied()) @@ -159,14 +147,10 @@ impl Gemset { ("RBENV_DIR", working_dir_str), ]; - let merged_envs: Vec<(&str, &str)> = if let Some(envs) = envs { - command_envs - .into_iter() - .chain(envs.iter().copied()) - .collect() - } else { - command_envs - }; + let merged_envs: Vec<(&str, &str)> = command_envs + .into_iter() + .chain(self.envs.iter().map(|(k, v)| (k.as_str(), v.as_str()))) + .collect(); self.command_executor .execute("gem", &full_args, &merged_envs) @@ -273,6 +257,7 @@ mod tests { Gemset::new( TEST_GEM_HOME.into(), TEST_WORKING_DIR.into(), + None, Box::new(mock_executor), ) } @@ -282,6 +267,7 @@ mod tests { let gemset = Gemset::new( TEST_GEM_HOME.into(), TEST_WORKING_DIR.into(), + None, Box::new(MockGemCommandExecutor::new()), ); let path = gemset.gem_bin_path("ruby-lsp").unwrap(); @@ -293,6 +279,7 @@ mod tests { let gemset = Gemset::new( TEST_GEM_HOME.into(), TEST_WORKING_DIR.into(), + None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(None); @@ -306,6 +293,7 @@ mod tests { let gemset = Gemset::new( TEST_GEM_HOME.into(), TEST_WORKING_DIR.into(), + None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(Some(&[("GEM_HOME", "/home/user/.gem")])); @@ -322,6 +310,7 @@ mod tests { let gemset = Gemset::new( TEST_GEM_HOME.into(), TEST_WORKING_DIR.into(), + None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(Some(&[("GEM_PATH", "/home/user/.gem")])); @@ -359,7 +348,7 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - assert!(gemset.install_gem(gem_name, None).is_ok()); + assert!(gemset.install_gem(gem_name).is_ok()); } #[test] @@ -379,6 +368,7 @@ mod tests { &[ ("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME), + ("RBENV_DIR", TEST_WORKING_DIR), ("CUSTOM_VAR", "custom_value"), ], Ok(Output { @@ -387,10 +377,13 @@ mod tests { stderr: Vec::new(), }), ); - let gemset = create_gemset(mock_executor); - assert!(gemset - .install_gem(gem_name, Some(&[("CUSTOM_VAR", "custom_value")])) - .is_ok()); + let gemset = Gemset::new( + TEST_GEM_HOME.into(), + TEST_WORKING_DIR.into(), + Some(&[("CUSTOM_VAR", "custom_value")]), + Box::new(mock_executor), + ); + assert!(gemset.install_gem(gem_name).is_ok()); } #[test] @@ -419,7 +412,7 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - let result = gemset.install_gem(gem_name, None); + let result = gemset.install_gem(gem_name); assert!(result.is_err()); assert!(result .unwrap_err() @@ -445,7 +438,7 @@ mod tests { }), ); let gemset = create_gemset(mock_executor); - assert!(gemset.update_gem(gem_name, None).is_ok()); + assert!(gemset.update_gem(gem_name).is_ok()); } #[test] diff --git a/src/language_servers/language_server.rs b/src/language_servers/language_server.rs index 1aea6be..b29ce0c 100644 --- a/src/language_servers/language_server.rs +++ b/src/language_servers/language_server.rs @@ -222,26 +222,27 @@ pub trait LanguageServer { .to_string_lossy() .to_string(); - let gemset = Gemset::new( - PathBuf::from(&gem_home), - PathBuf::from(worktree.root_path()), - Box::new(RealCommandExecutor), - ); 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())) .collect(); + let gemset = Gemset::new( + PathBuf::from(&gem_home), + PathBuf::from(worktree.root_path()), + Some(&worktree_shell_env_vars), + Box::new(RealCommandExecutor), + ); zed::set_language_server_installation_status( language_server_id, &zed::LanguageServerInstallationStatus::CheckingForUpdate, ); - match gemset.installed_gem_version(Self::GEM_NAME, Some(&worktree_shell_env_vars)) { + match gemset.installed_gem_version(Self::GEM_NAME) { Ok(Some(version)) => { if gemset - .is_outdated_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) + .is_outdated_gem(Self::GEM_NAME) .map_err(|e| e.to_string())? { zed::set_language_server_installation_status( @@ -250,11 +251,11 @@ pub trait LanguageServer { ); gemset - .update_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) + .update_gem(Self::GEM_NAME) .map_err(|e| e.to_string())?; gemset - .uninstall_gem(Self::GEM_NAME, &version, Some(&worktree_shell_env_vars)) + .uninstall_gem(Self::GEM_NAME, &version) .map_err(|e| e.to_string())?; } @@ -275,7 +276,7 @@ pub trait LanguageServer { ); gemset - .install_gem(Self::GEM_NAME, Some(&worktree_shell_env_vars)) + .install_gem(Self::GEM_NAME) .map_err(|e| e.to_string())?; let executable_path = gemset diff --git a/src/ruby.rs b/src/ruby.rs index ece0157..b1d567d 100644 --- a/src/ruby.rs +++ b/src/ruby.rs @@ -157,10 +157,11 @@ impl zed::Extension for RubyExtension { let gemset = Gemset::new( gem_home, PathBuf::from(worktree.root_path()), + Some(&env_vars), Box::new(RealCommandExecutor), ); - match gemset.install_gem("debug", None) { + match gemset.install_gem("debug") { Ok(_) => rdbg_path = gemset.gem_bin_path("rdbg")?, Err(e) => return Err(format!("Failed to install debug gem: {e}")), } From c9b3bc7fd12c0e1dbac2fcd1bcd1903c26c4c991 Mon Sep 17 00:00:00 2001 From: Vitaly Slobodin Date: Thu, 11 Sep 2025 14:30:10 +0200 Subject: [PATCH 3/3] revert(gemset): add `cwd` to Gemset and set `RBENV_DIR` env var (#173) This reverts commit 63eb48fdcff2b2e46e7e64328fce938ea3721fc7. --- src/gemset.rs | 146 +++++------------------- src/language_servers/language_server.rs | 1 - src/ruby.rs | 8 +- 3 files changed, 29 insertions(+), 126 deletions(-) diff --git a/src/gemset.rs b/src/gemset.rs index 633dd10..7c63001 100644 --- a/src/gemset.rs +++ b/src/gemset.rs @@ -5,7 +5,6 @@ use std::path::PathBuf; /// A simple wrapper around the `gem` command. pub struct Gemset { gem_home: PathBuf, - working_dir: PathBuf, envs: Vec<(String, String)>, command_executor: Box, } @@ -13,13 +12,11 @@ pub struct Gemset { impl Gemset { pub fn new( gem_home: PathBuf, - working_dir: PathBuf, envs: Option<&[(&str, &str)]>, command_executor: Box, ) -> Self { Self { gem_home, - working_dir, envs: envs.map_or(Vec::new(), |envs| { envs.iter() .map(|(k, v)| (k.to_string(), v.to_string())) @@ -39,33 +36,18 @@ impl Gemset { } pub fn env(&self, envs: Option<&[(&str, &str)]>) -> Vec<(String, String)> { - let gem_bin_path = self.gem_home.join("bin"); - let gem_bin_str = gem_bin_path.display().to_string(); - let gem_path = ( + let mut env_map: std::collections::HashMap = envs + .unwrap_or(&[]) + .iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect(); + + env_map.insert( "GEM_PATH".to_string(), format!("{}:$GEM_PATH", self.gem_home.display()), ); - let path_override = { - let existing_path = envs - .unwrap_or(&[]) - .iter() - .find(|(k, _)| *k == "PATH") - .map(|(_, v)| v) - .map_or("$PATH", |v| v); - - ( - "PATH".to_string(), - format!("{}:{}", gem_bin_str, existing_path), - ) - }; - - envs.unwrap_or(&[]) - .iter() - .filter(|(k, _)| *k != "GEM_PATH" || *k != "PATH") - .map(|(k, v)| (k.to_string(), v.to_string())) - .chain([gem_path, path_override]) - .collect() + env_map.into_iter().collect() } pub fn install_gem(&self, name: &str) -> Result<(), String> { @@ -136,16 +118,8 @@ impl Gemset { .gem_home .to_str() .ok_or("Failed to convert gem_home path to string")?; - let working_dir_str = self - .working_dir - .to_str() - .ok_or("Failed to convert working_dir path to string")?; - let command_envs = vec![ - ("GEM_HOME", gem_home_str), - ("GEM_PATH", gem_home_str), - ("RBENV_DIR", working_dir_str), - ]; + let command_envs = vec![("GEM_HOME", gem_home_str), ("GEM_PATH", gem_home_str)]; let merged_envs: Vec<(&str, &str)> = command_envs .into_iter() @@ -251,22 +225,15 @@ mod tests { } const TEST_GEM_HOME: &str = "/test/gem_home"; - const TEST_WORKING_DIR: &str = "/test/my_project"; fn create_gemset(mock_executor: MockGemCommandExecutor) -> Gemset { - Gemset::new( - TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), - None, - Box::new(mock_executor), - ) + Gemset::new(TEST_GEM_HOME.into(), None, Box::new(mock_executor)) } #[test] fn test_gem_bin_path() { let gemset = Gemset::new( TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), None, Box::new(MockGemCommandExecutor::new()), ); @@ -278,12 +245,11 @@ mod tests { fn test_gem_env() { let gemset = Gemset::new( TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(None); - assert_eq!(env.len(), 2); + assert_eq!(env.len(), 1); assert_eq!(env[0].0, "GEM_PATH"); assert_eq!(env[0].1, "/test/gem_home:$GEM_PATH"); } @@ -292,34 +258,30 @@ mod tests { fn test_gem_env_with_env_vars() { let gemset = Gemset::new( TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(Some(&[("GEM_HOME", "/home/user/.gem")])); - assert_eq!(env.len(), 3); + assert_eq!(env.len(), 2); let env_map: std::collections::HashMap = env.into_iter().collect(); assert_eq!(env_map.get("GEM_HOME").unwrap(), "/home/user/.gem"); assert_eq!(env_map.get("GEM_PATH").unwrap(), "/test/gem_home:$GEM_PATH"); - assert_eq!(env_map.get("PATH").unwrap(), "/test/gem_home/bin:$PATH"); } #[test] fn test_gem_env_with_env_vars_overwrite() { let gemset = Gemset::new( TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), None, Box::new(MockGemCommandExecutor::new()), ); let env = gemset.env(Some(&[("GEM_PATH", "/home/user/.gem")])); - assert_eq!(env.len(), 3); + assert_eq!(env.len(), 1); // GEM_PATH should be overwritten with our value let env_map: std::collections::HashMap = env.into_iter().collect(); assert_eq!(env_map.get("GEM_PATH").unwrap(), "/test/gem_home:$GEM_PATH"); - assert_eq!(env_map.get("PATH").unwrap(), "/test/gem_home/bin:$PATH"); } #[test] @@ -336,11 +298,7 @@ mod tests { "--no-document", gem_name, ], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: "Successfully installed ruby-lsp-1.0.0".as_bytes().to_vec(), @@ -368,7 +326,6 @@ mod tests { &[ ("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), ("CUSTOM_VAR", "custom_value"), ], Ok(Output { @@ -379,7 +336,6 @@ mod tests { ); let gemset = Gemset::new( TEST_GEM_HOME.into(), - TEST_WORKING_DIR.into(), Some(&[("CUSTOM_VAR", "custom_value")]), Box::new(mock_executor), ); @@ -400,11 +356,7 @@ mod tests { "--no-document", gem_name, ], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(1), stdout: Vec::new(), @@ -426,11 +378,7 @@ mod tests { mock_executor.expect( "gem", &["update", "--norc", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: "Gems updated: ruby-lsp".as_bytes().to_vec(), @@ -448,11 +396,7 @@ mod tests { mock_executor.expect( "gem", &["update", "--norc", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(1), stdout: Vec::new(), @@ -480,11 +424,7 @@ mod tests { mock_executor.expect( "gem", &["list", "--norc", "--exact", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: gem_list_output.as_bytes().to_vec(), @@ -509,11 +449,7 @@ mod tests { mock_executor.expect( "gem", &["list", "--norc", "--exact", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: gem_list_output.as_bytes().to_vec(), @@ -534,11 +470,7 @@ mod tests { mock_executor.expect( "gem", &["list", "--norc", "--exact", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: gem_list_output.as_bytes().to_vec(), @@ -557,11 +489,7 @@ mod tests { mock_executor.expect( "gem", &["list", "--norc", "--exact", gem_name], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(127), stdout: Vec::new(), @@ -588,11 +516,7 @@ mod tests { mock_executor.expect( "gem", &["outdated", "--norc"], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: outdated_output.as_bytes().to_vec(), @@ -613,11 +537,7 @@ mod tests { mock_executor.expect( "gem", &["outdated", "--norc"], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: outdated_output.as_bytes().to_vec(), @@ -636,11 +556,7 @@ mod tests { mock_executor.expect( "gem", &["outdated", "--norc"], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(1), stdout: Vec::new(), @@ -664,11 +580,7 @@ mod tests { mock_executor.expect( "gem", &["uninstall", "--norc", gem_name, "--version", gem_version], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(0), stdout: format!("Successfully uninstalled {gem_name}-{gem_version}") @@ -690,7 +602,7 @@ mod tests { mock_executor.expect( "gem", &["uninstall", "--norc", gem_name, "--version", gem_version], - &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME), ("RBENV_DIR", TEST_WORKING_DIR)], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Ok(Output { status: Some(1), stdout: Vec::new(), @@ -716,11 +628,7 @@ mod tests { mock_executor.expect( "gem", &["uninstall", "--norc", gem_name, "--version", gem_version], - &[ - ("GEM_HOME", TEST_GEM_HOME), - ("GEM_PATH", TEST_GEM_HOME), - ("RBENV_DIR", TEST_WORKING_DIR), - ], + &[("GEM_HOME", TEST_GEM_HOME), ("GEM_PATH", TEST_GEM_HOME)], Err("Command not found: gem".to_string()), ); let gemset = create_gemset(mock_executor); diff --git a/src/language_servers/language_server.rs b/src/language_servers/language_server.rs index b29ce0c..1380282 100644 --- a/src/language_servers/language_server.rs +++ b/src/language_servers/language_server.rs @@ -230,7 +230,6 @@ pub trait LanguageServer { let gemset = Gemset::new( PathBuf::from(&gem_home), - PathBuf::from(worktree.root_path()), Some(&worktree_shell_env_vars), Box::new(RealCommandExecutor), ); diff --git a/src/ruby.rs b/src/ruby.rs index b1d567d..1d651a9 100644 --- a/src/ruby.rs +++ b/src/ruby.rs @@ -154,12 +154,8 @@ impl zed::Extension for RubyExtension { Err(_e) => { let gem_home = std::env::current_dir() .map_err(|e| format!("Failed to get extension directory: {e}"))?; - let gemset = Gemset::new( - gem_home, - PathBuf::from(worktree.root_path()), - Some(&env_vars), - Box::new(RealCommandExecutor), - ); + let gemset = + Gemset::new(gem_home, Some(&env_vars), Box::new(RealCommandExecutor)); match gemset.install_gem("debug") { Ok(_) => rdbg_path = gemset.gem_bin_path("rdbg")?,