Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Fix remote worktree path separators (#55486)

hayatosc7b2acab04046
diff --git a/crates/agent_ui/src/thread_worktree_archive.rs b/crates/agent_ui/src/thread_worktree_archive.rs
index 73b0a426b30..b510da96b4e 100644
--- a/crates/agent_ui/src/thread_worktree_archive.rs
+++ b/crates/agent_ui/src/thread_worktree_archive.rs
@@ -12,7 +12,7 @@ use project::{
};
use remote::{RemoteConnectionOptions, same_remote_connection_identity};
use settings::Settings;
-use util::ResultExt;
+use util::{ResultExt, paths::PathStyle};
use workspace::{AppState, MultiWorkspace, Workspace};
use crate::thread_metadata_store::{ArchivedGitWorktree, ThreadId, ThreadMetadataStore};
@@ -77,9 +77,13 @@ fn archived_worktree_ref_name(id: i64) -> String {
/// This intentionally reads the *global* `git.worktree_directory` setting
/// rather than any project-local override, because Zed always uses the
/// global value when creating worktrees and the archive check must match.
-fn worktrees_base_for_repo(main_repo_path: &Path, cx: &App) -> Option<PathBuf> {
+fn worktrees_base_for_repo(
+ main_repo_path: &Path,
+ path_style: PathStyle,
+ cx: &App,
+) -> Option<PathBuf> {
let setting = &ProjectSettings::get_global(cx).git.worktree_directory;
- worktrees_directory_for_repo(main_repo_path, setting).log_err()
+ worktrees_directory_for_repo(main_repo_path, setting, path_style).log_err()
}
/// Builds a [`RootPlan`] for archiving the git worktree at `path`.
@@ -165,7 +169,7 @@ pub fn build_root_plan(
// Only archive worktrees that live inside the Zed-managed worktrees
// directory (configured via `git.worktree_directory`). Worktrees the
// user created outside that directory should be left untouched.
- let worktrees_base = worktrees_base_for_repo(&main_repo_path, cx)?;
+ let worktrees_base = worktrees_base_for_repo(&main_repo_path, linked_snapshot.path_style, cx)?;
if !path.starts_with(&worktrees_base) {
return None;
}
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index 8f49e4c9183..b39f24bb4ce 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -6824,10 +6824,15 @@ impl Repository {
.unwrap_or(self.common_dir_abs_path.as_ref());
let project_name = repository_anchor
.file_name()
+ .and_then(|name| name.to_str())
.ok_or_else(|| anyhow!("git repo must have a directory name"))?;
- let directory =
- worktrees_directory_for_repo(repository_anchor, worktree_directory_setting)?;
- Ok(directory.join(branch_name).join(project_name))
+ let directory = worktrees_directory_for_repo(
+ repository_anchor,
+ worktree_directory_setting,
+ self.path_style,
+ )?;
+ let directory = self.path_style.join_path(&directory, branch_name)?;
+ self.path_style.join_path(&directory, project_name)
}
pub fn worktrees(&mut self) -> oneshot::Receiver<Result<Vec<GitWorktree>>> {
@@ -7123,7 +7128,12 @@ impl Repository {
let managed_worktree_base = cx.update(|cx| {
let setting = &ProjectSettings::get_global(cx).git.worktree_directory;
- worktrees_directory_for_repo(&repository_anchor_path, setting).log_err()
+ worktrees_directory_for_repo(
+ &repository_anchor_path,
+ setting,
+ PathStyle::local(),
+ )
+ .log_err()
});
if let Some(managed_worktree_base) = managed_worktree_base {
@@ -8145,14 +8155,14 @@ pub async fn resolve_git_worktree_to_main_repo(fs: &dyn Fs, path: &Path) -> Opti
pub fn worktrees_directory_for_repo(
repository_anchor_path: &Path,
worktree_directory_setting: &str,
+ path_style: PathStyle,
) -> Result<PathBuf> {
// Check the original setting before trimming, since a path like "///"
// is absolute but becomes "" after stripping trailing separators.
// Also check for leading `/` or `\` explicitly, because on Windows
// `Path::is_absolute()` requires a drive letter — so `/tmp/worktrees`
// would slip through even though it's clearly not a relative path.
- if Path::new(worktree_directory_setting).is_absolute()
- || worktree_directory_setting.starts_with('/')
+ if path_style.is_absolute(worktree_directory_setting)
|| worktree_directory_setting.starts_with('\\')
{
anyhow::bail!(
@@ -8169,12 +8179,19 @@ pub fn worktrees_directory_for_repo(
anyhow::bail!("git.worktree_directory must not be \"..\" (use \"../some-name\" instead)");
}
- let joined = repository_anchor_path.join(trimmed);
- let resolved = util::normalize_path(&joined);
+ let joined = path_style.join_path(repository_anchor_path, trimmed)?;
+ let resolved = if path_style.is_posix() {
+ joined
+ } else {
+ util::normalize_path(&joined)
+ };
let resolved = if resolved.starts_with(repository_anchor_path) {
resolved
- } else if let Some(repo_dir_name) = repository_anchor_path.file_name() {
- resolved.join(repo_dir_name)
+ } else if let Some(repo_dir_name) = repository_anchor_path
+ .file_name()
+ .and_then(|name| name.to_str())
+ {
+ path_style.join_path(&resolved, repo_dir_name)?
} else {
resolved
};
@@ -8659,7 +8676,7 @@ mod tests {
use rand::{SeedableRng, rngs::StdRng};
use serde_json::json;
use settings::SettingsStore;
- use std::path::Path;
+ use std::path::{Path, PathBuf};
fn init_test(cx: &mut TestAppContext) {
cx.update(|cx| {
@@ -8668,6 +8685,22 @@ mod tests {
});
}
+ #[test]
+ fn test_new_worktree_path_uses_posix_style_for_remote_paths() {
+ let work_dir = Path::new("/home/user/dev/lsp-tests");
+ let directory =
+ worktrees_directory_for_repo(work_dir, "../worktrees", PathStyle::Posix).unwrap();
+ let directory = PathStyle::Posix
+ .join_path(&directory, "nimble-sky")
+ .unwrap();
+ let path = PathStyle::Posix.join_path(&directory, "lsp-tests").unwrap();
+
+ assert_eq!(
+ path,
+ PathBuf::from("/home/user/dev/worktrees/lsp-tests/nimble-sky/lsp-tests")
+ );
+ }
+
fn verify_invariants(repository: &Repository) -> anyhow::Result<()> {
match &repository.commit_data_handler {
CommitDataHandlerState::Open(handler) => {
diff --git a/crates/project/tests/integration/git_store.rs b/crates/project/tests/integration/git_store.rs
index 3f752a279f2..05d3843f018 100644
--- a/crates/project/tests/integration/git_store.rs
+++ b/crates/project/tests/integration/git_store.rs
@@ -1182,7 +1182,7 @@ mod git_worktrees {
use serde_json::json;
use settings::SettingsStore;
use std::path::{Path, PathBuf};
- use util::path;
+ use util::{path, paths::PathStyle};
fn init_test(cx: &mut gpui::TestAppContext) {
zlog::init_test();
@@ -1198,43 +1198,61 @@ mod git_worktrees {
let work_dir = Path::new("/code/my-project");
// Valid: sibling
- assert!(worktrees_directory_for_repo(work_dir, "../worktrees").is_ok());
+ assert!(worktrees_directory_for_repo(work_dir, "../worktrees", PathStyle::Posix).is_ok());
// Valid: subdirectory
- assert!(worktrees_directory_for_repo(work_dir, ".git/zed-worktrees").is_ok());
- assert!(worktrees_directory_for_repo(work_dir, "my-worktrees").is_ok());
+ assert!(
+ worktrees_directory_for_repo(work_dir, ".git/zed-worktrees", PathStyle::Posix).is_ok()
+ );
+ assert!(worktrees_directory_for_repo(work_dir, "my-worktrees", PathStyle::Posix).is_ok());
// Invalid: just ".." would resolve back to the working directory itself
- let err = worktrees_directory_for_repo(work_dir, "..").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "..", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("must not be \"..\""));
// Invalid: ".." with trailing separators
- let err = worktrees_directory_for_repo(work_dir, "..\\").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "..\\", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("must not be \"..\""));
- let err = worktrees_directory_for_repo(work_dir, "../").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "../", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("must not be \"..\""));
// Invalid: empty string would resolve to the working directory itself
- let err = worktrees_directory_for_repo(work_dir, "").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("must not be empty"));
// Invalid: absolute path
- let err = worktrees_directory_for_repo(work_dir, "/tmp/worktrees").unwrap_err();
+ let err =
+ worktrees_directory_for_repo(work_dir, "/tmp/worktrees", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("relative path"));
// Invalid: "/" is absolute on Unix
- let err = worktrees_directory_for_repo(work_dir, "/").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "/", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("relative path"));
// Invalid: "///" is absolute
- let err = worktrees_directory_for_repo(work_dir, "///").unwrap_err();
+ let err = worktrees_directory_for_repo(work_dir, "///", PathStyle::Posix).unwrap_err();
assert!(err.to_string().contains("relative path"));
// Invalid: escapes too far up
- let err = worktrees_directory_for_repo(work_dir, "../../other-project/wt").unwrap_err();
+ let err =
+ worktrees_directory_for_repo(work_dir, "../../other-project/wt", PathStyle::Posix)
+ .unwrap_err();
assert!(err.to_string().contains("outside"));
}
+ #[test]
+ fn test_worktree_directory_uses_remote_path_style() {
+ let work_dir = Path::new("/home/user/dev/lsp-tests");
+
+ let directory =
+ worktrees_directory_for_repo(work_dir, "../worktrees", PathStyle::Posix).unwrap();
+
+ assert_eq!(
+ directory,
+ PathBuf::from("/home/user/dev/worktrees/lsp-tests")
+ );
+ }
+
#[gpui::test]
async fn test_git_worktrees_list_and_create(cx: &mut TestAppContext) {
init_test(cx);
diff --git a/crates/util/src/paths.rs b/crates/util/src/paths.rs
index 94877af090f..d0baca0f476 100644
--- a/crates/util/src/paths.rs
+++ b/crates/util/src/paths.rs
@@ -416,6 +416,68 @@ impl PathStyle {
}
}
+ pub fn join_path(
+ self,
+ left: impl AsRef<Path>,
+ right: impl AsRef<Path>,
+ ) -> anyhow::Result<PathBuf> {
+ let left = left
+ .as_ref()
+ .to_str()
+ .ok_or_else(|| anyhow::anyhow!("Path contains invalid UTF-8"))?;
+ let right = right.as_ref();
+ let right_string = right
+ .to_str()
+ .ok_or_else(|| anyhow::anyhow!("Path contains invalid UTF-8"))?;
+ let joined = self
+ .join(left, right_string)
+ .ok_or_else(|| anyhow::anyhow!("Path must be relative: {right:?}"))?;
+ Ok(PathBuf::from(self.normalize(&joined)))
+ }
+
+ pub fn normalize(self, path_like: &str) -> String {
+ match self {
+ PathStyle::Windows => crate::normalize_path(Path::new(path_like))
+ .to_string_lossy()
+ .into_owned(),
+ PathStyle::Posix => {
+ let is_absolute = path_like.starts_with('/');
+ let remainder = if is_absolute {
+ path_like.trim_start_matches('/')
+ } else {
+ path_like
+ };
+
+ let mut components = Vec::new();
+ for component in remainder.split(self.separators_ch()) {
+ match component {
+ "" | "." => {}
+ ".." => {
+ if components
+ .last()
+ .is_some_and(|component| *component != "..")
+ {
+ components.pop();
+ } else if !is_absolute {
+ components.push(component);
+ }
+ }
+ component => components.push(component),
+ }
+ }
+
+ let normalized = components.join(self.primary_separator());
+ if is_absolute && normalized.is_empty() {
+ "/".to_string()
+ } else if is_absolute {
+ format!("/{normalized}")
+ } else {
+ normalized
+ }
+ }
+ }
+ }
+
pub fn split(self, path_like: &str) -> (Option<&str>, &str) {
let Some(pos) = path_like.rfind(self.primary_separator()) else {
return (None, path_like);
@@ -1566,6 +1628,34 @@ mod tests {
use super::*;
use util_macros::perf;
+ #[test]
+ fn test_join_path_uses_path_style_separator() {
+ let posix_path = PathStyle::Posix
+ .join_path(Path::new("/home/user/dev"), "worktrees")
+ .unwrap();
+ let windows_path = PathStyle::Windows
+ .join_path(Path::new("C:\\Users\\user\\dev"), "worktrees")
+ .unwrap();
+
+ assert_eq!(posix_path, PathBuf::from("/home/user/dev/worktrees"));
+ assert_eq!(
+ windows_path.to_string_lossy(),
+ "C:\\Users\\user\\dev\\worktrees"
+ );
+ }
+
+ #[test]
+ fn test_normalize_uses_path_style_separator() {
+ assert_eq!(
+ PathStyle::Posix.normalize("/home/user/dev/../worktrees/./zed"),
+ "/home/user/worktrees/zed"
+ );
+ assert_eq!(
+ PathStyle::Windows.normalize("C:\\Users\\user\\dev\\worktrees"),
+ "C:\\Users\\user\\dev\\worktrees"
+ );
+ }
+
fn rel_path_entry(path: &'static str, is_file: bool) -> (&'static RelPath, bool) {
(RelPath::unix(path).unwrap(), is_file)
}