Skip to content

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.

feat(vcs): compare folder selections with revisions across repositories (#602)

l0ng-ai9e35cfc0640f
diff --git a/crates/ide-host/src/ops/vcs/commands.rs b/crates/ide-host/src/ops/vcs/commands.rs
index efb9a8811..64d47e421 100644
--- a/crates/ide-host/src/ops/vcs/commands.rs
+++ b/crates/ide-host/src/ops/vcs/commands.rs
@@ -746,6 +746,33 @@ pub async fn vcs_remove_worktree(
blocking(move || project.with_repo_at(repo.as_deref(), |r| r.remove_worktree(&path, force))).await
}
+pub async fn vcs_compare_scope(host: &Host, window: &str, paths: Vec<PathBuf>) -> IdeResult<CompareScope> {
+ let project = host.project(window)?;
+ blocking(move || Ok(project.repos().compare_scope(&paths))).await
+}
+
+pub async fn vcs_compare_paths(
+ host: &Host,
+ window: &str,
+ paths: Vec<PathBuf>,
+ revision: String,
+ repositories: Option<Vec<PathBuf>>,
+ request: RequestId,
+) -> IdeResult<CompareResult> {
+ let project = host.project(window)?;
+ let cancel = host.begin_request(request);
+ let result = blocking(move || {
+ let settings = project.settings.effective();
+ if project.is_trusted() {
+ apply_git_executable(&settings);
+ }
+ project.repos().compare_paths(&paths, &revision, repositories.as_deref(), &cancel)
+ })
+ .await;
+ host.end_request(request);
+ result
+}
+
/// Compare with Local: tracked files that differ between `rev` and the working tree.
pub async fn vcs_diff_with_worktree(
host: &Host,
@@ -1040,6 +1067,18 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("vcs_remove_worktree", |c| async move {
vcs_remove_worktree(&c.host, &c.window, c.arg("repo")?, c.arg("path")?, c.arg("force")?).await
});
+ d.add("vcs_compare_scope", |c| async move { vcs_compare_scope(&c.host, &c.window, c.arg("paths")?).await });
+ d.add("vcs_compare_paths", |c| async move {
+ vcs_compare_paths(
+ &c.host,
+ &c.window,
+ c.arg("paths")?,
+ c.arg("revision")?,
+ c.arg("repositories")?,
+ c.arg("request")?,
+ )
+ .await
+ });
d.add("vcs_diff_with_worktree", |c| async move {
vcs_diff_with_worktree(&c.host, &c.window, c.arg("repo")?, c.arg("rev")?).await
});
diff --git a/crates/ide-host/src/trust.rs b/crates/ide-host/src/trust.rs
index 64ec419d5..9e1bfb826 100644
--- a/crates/ide-host/src/trust.rs
+++ b/crates/ide-host/src/trust.rs
@@ -276,6 +276,8 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "vcs_remotes"
| "vcs_worktrees"
| "vcs_diff_with_worktree"
+ | "vcs_compare_scope"
+ | "vcs_compare_paths"
| "vcs_diff_revisions"
| "vcs_merge_base"
| "vcs_shelves"
diff --git a/crates/ide-vcs/src/cli.rs b/crates/ide-vcs/src/cli.rs
index 548094820..051984ed4 100644
--- a/crates/ide-vcs/src/cli.rs
+++ b/crates/ide-vcs/src/cli.rs
@@ -348,6 +348,55 @@ fn run_raw_env_once(
Ok(Output { stdout: out.stdout, stderr: out.stderr, code: out.status.code() })
}
+/// Captures binary/NUL-delimited read output while allowing cancellation to kill git.
+pub(crate) fn run_cancellable(root: &Path, args: &[&str], cancel: &CancellationToken) -> IdeResult<Output> {
+ let out = run_cancellable_raw(root, args, cancel)?;
+ if out.code == Some(0) { Ok(out) } else { Err(failure(args, &out.stderr, &out.stdout, out.code)) }
+}
+
+/// Cancellable capture preserving exit codes for commands with documented non-error states.
+pub(crate) fn run_cancellable_raw(root: &Path, args: &[&str], cancel: &CancellationToken) -> IdeResult<Output> {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let mut cmd = command(root)?;
+ cmd.args(args).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::piped());
+ #[cfg(unix)]
+ {
+ use std::os::unix::process::CommandExt;
+ cmd.process_group(0);
+ }
+ let mut session = CommandSession::start(&mut cmd);
+ let mut child = cmd.spawn().map_err(spawn_error)?;
+ let capture = |mut pipe: Box<dyn Read + Send>| {
+ std::thread::spawn(move || {
+ let mut bytes = Vec::new();
+ pipe.read_to_end(&mut bytes).map(|_| bytes)
+ })
+ };
+ let stdout = capture(Box::new(child.stdout.take().expect("piped stdout")));
+ let stderr = capture(Box::new(child.stderr.take().expect("piped stderr")));
+ let status = loop {
+ if cancel.is_cancelled() {
+ kill(&mut child);
+ let _ = child.wait();
+ let _ = stdout.join();
+ let _ = stderr.join();
+ return Err(IdeError::cancelled());
+ }
+ if let Some(status) = child.try_wait()? {
+ break status;
+ }
+ std::thread::sleep(Duration::from_millis(20));
+ };
+ let join = |thread: std::thread::JoinHandle<std::io::Result<Vec<u8>>>| {
+ thread.join().map_err(|_| IdeError::internal("git output reader panicked"))?.map_err(IdeError::from)
+ };
+ let out = Output { stdout: join(stdout)?, stderr: join(stderr)?, code: status.code() };
+ session.finish(status.success(), &String::from_utf8_lossy(&out.stderr));
+ Ok(out)
+}
+
/// Runs git and maps a non-zero exit status to an error carrying git's message.
pub(crate) fn run(root: &Path, args: &[&str], stdin: Option<&[u8]>) -> IdeResult<Output> {
let out = run_raw(root, args, stdin)?;
diff --git a/crates/ide-vcs/src/compare.rs b/crates/ide-vcs/src/compare.rs
new file mode 100644
index 000000000..d2404185c
--- /dev/null
+++ b/crates/ide-vcs/src/compare.rs
@@ -0,0 +1,521 @@
+//! Selection-scoped revision → working-tree comparison over the existing root registry.
+use crate::{ChangeKind, Repos, cli, ops};
+use ide_core::{CancellationToken, IdeError, IdeResult, IpcPath};
+use serde::{Deserialize, Serialize};
+use specta::Type;
+use std::path::{Path, PathBuf};
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CompareScope {
+ pub repositories: Vec<IpcPath>,
+ /// Selected content outside registered repositories; workspace parents expand to their skipped children.
+ pub skipped_paths: Vec<IpcPath>,
+ pub single_file: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct WorkingTreeChange {
+ pub path: String,
+ pub kind: ChangeKind,
+ pub old_path: Option<String>,
+ pub added: u32,
+ pub removed: u32,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryComparison {
+ pub root: IpcPath,
+ /// Resolved commit, so opening a diff later uses the same left side as the listing.
+ pub revision: Option<String>,
+ pub files: Vec<WorkingTreeChange>,
+ pub error: Option<String>,
+ /// The requested revision does not resolve to a commit in this repository.
+ #[serde(default)]
+ pub missing_revision: bool,
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct CompareResult {
+ pub repositories: Vec<RepositoryComparison>,
+ pub skipped_paths: Vec<IpcPath>,
+}
+
+fn normalized(path: &Path) -> PathBuf {
+ dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
+}
+
+fn comparison_children(path: &Path) -> Vec<PathBuf> {
+ std::fs::read_dir(path)
+ .into_iter()
+ .flatten()
+ .flatten()
+ .filter(|entry| entry.file_name() != ".git" && entry.file_name() != ".openidea")
+ .map(|entry| entry.path())
+ .collect()
+}
+
+impl Repos {
+ pub fn compare_scope(&self, paths: &[PathBuf]) -> CompareScope {
+ let paths: Vec<_> = paths.iter().map(|p| normalized(p)).collect();
+ let repositories = self
+ .all()
+ .iter()
+ .filter(|r| {
+ let root = normalized(r.root());
+ paths.iter().any(|p| {
+ root.starts_with(p)
+ || self.at_root(p).or_else(|| self.for_path(p)).is_some_and(|owner| owner.root() == r.root())
+ })
+ })
+ .map(|r| IpcPath(r.root().to_path_buf()))
+ .collect();
+ let mut skipped = std::collections::BTreeSet::new();
+ for path in &paths {
+ if self.at_root(path).or_else(|| self.for_path(path)).is_some() {
+ continue;
+ }
+ if self.all().iter().any(|r| r.root().starts_with(path)) {
+ for child in comparison_children(path) {
+ if self.has_outside_content(&child) {
+ skipped.insert(child);
+ }
+ }
+ } else {
+ skipped.insert(path.clone());
+ }
+ }
+ let skipped_paths = skipped
+ .into_iter()
+ .map(|mut path| {
+ if path.is_dir() {
+ path.push("");
+ }
+ IpcPath(path)
+ })
+ .collect();
+ CompareScope { repositories, skipped_paths, single_file: paths.len() == 1 && !paths[0].is_dir() }
+ }
+
+ fn has_outside_content(&self, path: &Path) -> bool {
+ if self.at_root(path).or_else(|| self.for_path(path)).is_some() {
+ return false;
+ }
+ !self.all().iter().any(|r| r.root().starts_with(path))
+ || comparison_children(path).iter().any(|child| self.has_outside_content(child))
+ }
+
+ pub fn compare_paths(
+ &self,
+ paths: &[PathBuf],
+ revision: &str,
+ repositories: Option<&[PathBuf]>,
+ cancel: &CancellationToken,
+ ) -> IdeResult<CompareResult> {
+ if revision.trim().is_empty() || revision.starts_with('-') {
+ return Err(IdeError::invalid("invalid revision"));
+ }
+ let scope = self.compare_scope(paths);
+ let paths: Vec<_> = paths.iter().map(|p| normalized(p)).collect();
+ let mut result = CompareResult { repositories: Vec::new(), skipped_paths: scope.skipped_paths };
+ for root in scope.repositories {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ if repositories.is_some_and(|roots| !roots.iter().any(|r| normalized(r) == normalized(&root.0))) {
+ continue;
+ }
+ let repo = self.at_root(&root.0).expect("scope comes from registry");
+ let _scope =
+ crate::ExecutionScope::enter(repo.execution_allowed.load(std::sync::atomic::Ordering::Acquire));
+ let mut missing_revision = false;
+ let mut compare = || -> IdeResult<(String, Vec<WorkingTreeChange>)> {
+ // Worktree comparisons must not run repository-defined clean/process filters
+ // in Restricted Mode. External diff and textconv are disabled below as well.
+ let mut overrides = Vec::new();
+ if !crate::execution_allowed() {
+ let config = cli::run_cancellable(repo.root(), &["config", "--null", "--list"], cancel)?;
+ for record in config.stdout_str().split('\0') {
+ let key = record.split('\n').next().unwrap_or_default();
+ if key.starts_with("filter.")
+ && (key.ends_with(".clean") || key.ends_with(".process") || key.ends_with(".required"))
+ {
+ overrides.push("-c".to_owned());
+ overrides.push(format!("{key}={}", if key.ends_with(".required") { "false" } else { "" }));
+ }
+ }
+ }
+ let run = |args: &[&str]| {
+ let mut full: Vec<&str> = overrides.iter().map(String::as_str).collect();
+ full.extend_from_slice(args);
+ cli::run_cancellable(repo.root(), &full, cancel)
+ };
+ // --quiet documents exit 1 for an unresolved revision; other failures keep their diagnostics.
+ let resolve_args =
+ ["rev-parse", "--verify", "--quiet", "--end-of-options", &format!("{revision}^{{commit}}")];
+ let resolved = cli::run_cancellable_raw(repo.root(), &resolve_args, cancel)?;
+ if resolved.code != Some(0) {
+ missing_revision = resolved.code == Some(1);
+ return Err(cli::failure(&resolve_args, &resolved.stderr, &resolved.stdout, resolved.code));
+ }
+ let resolved = resolved.stdout_str().trim().to_owned();
+ // Disable textconv/external diff; these are also safe in untrusted projects.
+ let names =
+ run(&["diff", "--name-status", "-z", "-M", "--no-ext-diff", "--no-textconv", &resolved, "--"])?;
+ let stats = run(&[
+ "diff",
+ "--numstat",
+ "-z",
+ "--no-renames",
+ "--no-ext-diff",
+ "--no-textconv",
+ &resolved,
+ "--",
+ ])?;
+ let stats: std::collections::HashMap<_, _> = ops::parse_numstat(&stats.stdout_str())
+ .into_iter()
+ .map(|(path, added, removed)| (path, (added, removed)))
+ .collect();
+ let mut files = Vec::new();
+ let contains = |rel: &str| {
+ let absolute = repo.root().join(rel);
+ // Nested clones contribute their own files, never the enclosing repo's entries.
+ let own = self.at_root(&absolute).or_else(|| self.for_path(&absolute));
+ own.is_some_and(|r| r.root() == repo.root()) && paths.iter().any(|p| absolute.starts_with(p))
+ };
+ for mut file in ops::parse_name_status(&names.stdout_str()) {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let new_in = contains(&file.path);
+ let old_in = file.old_path.as_deref().is_some_and(contains);
+ if !new_in && !old_in {
+ continue;
+ }
+ let original = file.path.clone();
+ if file.old_path.is_some() && new_in != old_in {
+ if old_in {
+ file.path = file.old_path.take().unwrap();
+ file.kind = ChangeKind::Deleted;
+ } else {
+ file.old_path = None;
+ file.kind = ChangeKind::Added;
+ }
+ }
+ let count = |path: &str| stats.get(path).copied().unwrap_or_default();
+ let (added, removed) = match &file.old_path {
+ Some(old) => (count(&original).0, count(old).1),
+ None => count(&file.path),
+ };
+ files.push(WorkingTreeChange {
+ path: file.path,
+ kind: file.kind,
+ old_path: file.old_path,
+ added,
+ removed,
+ });
+ }
+ if files.iter().any(|f| f.kind == ChangeKind::Renamed) {
+ let renamed =
+ run(&["diff", "--numstat", "-z", "-M", "--no-ext-diff", "--no-textconv", &resolved, "--"])?;
+ let indexes: std::collections::HashMap<_, _> = files
+ .iter()
+ .enumerate()
+ .filter(|(_, f)| f.kind == ChangeKind::Renamed)
+ .map(|(index, f)| (f.path.clone(), index))
+ .collect();
+ let mut records =
+ renamed.stdout_str().split('\0').map(str::to_owned).collect::<Vec<_>>().into_iter();
+ while let Some(record) = records.next() {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let fields: Vec<_> = record.splitn(3, '\t').collect();
+ if fields.len() == 3 && fields[2].is_empty() {
+ let _old = records.next();
+ if let Some(path) = records.next()
+ && let Some(index) = indexes.get(&path)
+ {
+ let file = &mut files[*index];
+ file.added = fields[0].parse().unwrap_or(0);
+ file.removed = fields[1].parse().unwrap_or(0);
+ }
+ }
+ }
+ }
+ let untracked = run(&["ls-files", "--others", "--exclude-standard", "-z"])?;
+ for path in untracked.stdout_str().split('\0').filter(|p| !p.is_empty() && contains(p)) {
+ if cancel.is_cancelled() {
+ return Err(IdeError::cancelled());
+ }
+ let absolute = repo.root().join(path);
+ // Match the existing diff viewer's large/binary-file policy without loading large files for counts.
+ let added = if std::fs::metadata(&absolute).is_ok_and(|m| m.len() <= 10 * 1024 * 1024) {
+ let bytes = std::fs::read(&absolute).unwrap_or_default();
+ if bytes.contains(&0) {
+ 0
+ } else {
+ (bytes.iter().filter(|b| **b == b'\n').count()
+ + usize::from(!bytes.is_empty() && bytes.last() != Some(&b'\n')))
+ as u32
+ }
+ } else {
+ 0
+ };
+ files.push(WorkingTreeChange {
+ path: path.to_owned(),
+ kind: ChangeKind::Untracked,
+ old_path: None,
+ added,
+ removed: 0,
+ });
+ }
+ files.sort_by(|a, b| a.path.cmp(&b.path));
+ Ok((resolved, files))
+ };
+ let comparison = match compare() {
+ Ok((revision, files)) => {
+ RepositoryComparison { root, revision: Some(revision), files, error: None, missing_revision: false }
+ }
+ Err(_) if cancel.is_cancelled() => return Err(IdeError::cancelled()),
+ Err(e) => RepositoryComparison {
+ root,
+ revision: None,
+ files: Vec::new(),
+ error: (!missing_revision).then_some(e.message),
+ missing_revision,
+ },
+ };
+ result.repositories.push(comparison);
+ }
+ Ok(result)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::process::Command;
+
+ fn git(root: &Path, args: &[&str]) {
+ let output = Command::new("git").current_dir(root).args(args).output().unwrap();
+ assert!(output.status.success(), "{args:?}: {}", String::from_utf8_lossy(&output.stderr));
+ }
+
+ fn write(root: &Path, path: &str, text: &str) {
+ let path = root.join(path);
+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();
+ std::fs::write(path, text).unwrap();
+ }
+
+ fn init(root: &Path, branch: &str) {
+ std::fs::create_dir_all(root).unwrap();
+ git(root, &["init", "-q", "-b", branch]);
+ git(root, &["config", "user.name", "Test"]);
+ git(root, &["config", "user.email", "[email protected]"]);
+ write(root, "src/文件 name.txt", "old\n");
+ write(root, "src/move.txt", "move\n");
+ write(root, "other/stable.txt", "stable\n");
+ git(root, &["add", "."]);
+ git(root, &["commit", "-qm", "initial"]);
+ }
+
+ #[test]
+ fn subtree_union_worktree_untracked_and_rename_boundaries() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root, "main");
+ git(&root, &["switch", "-qc", "feature"]);
+ git(&root, &["mv", "src/move.txt", "other/moved.txt"]);
+ git(&root, &["commit", "-qm", "move out"]);
+ write(&root, "src/文件 name.txt", "old\nnew\n");
+ write(&root, "src/untracked space 中文.txt", "new\nfile\n");
+ write(&root, "other/stable.txt", "changed\n");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let cancel = CancellationToken::new();
+ let result = repos.compare_paths(&[root.join("src")], "main", None, &cancel).unwrap();
+ assert_eq!(result.repositories.len(), 1);
+ let files = &result.repositories[0].files;
+ assert_eq!(files.len(), 3, "{files:?}");
+ let moved = files.iter().find(|f| f.path == "src/move.txt").unwrap();
+ assert_eq!(moved.kind, ChangeKind::Deleted);
+ assert_eq!((moved.added, moved.removed), (0, 1));
+ assert!(moved.old_path.is_none());
+ let changed = files.iter().find(|f| f.path == "src/文件 name.txt").unwrap();
+ assert_eq!((changed.added, changed.removed), (1, 0));
+ let untracked = files.iter().find(|f| f.path == "src/untracked space 中文.txt").unwrap();
+ assert_eq!((untracked.kind, untracked.added), (ChangeKind::Untracked, 2));
+ let union = repos
+ .compare_paths(&[root.join("src"), root.join("other"), root.join("src")], "main", None, &cancel)
+ .unwrap();
+ assert_eq!(union.repositories[0].files.len(), 4);
+ let rename = union.repositories[0].files.iter().find(|f| f.path == "other/moved.txt").unwrap();
+ assert_eq!(rename.kind, ChangeKind::Renamed);
+ assert_eq!(rename.old_path.as_deref(), Some("src/move.txt"));
+ assert_eq!((rename.added, rename.removed), (0, 0));
+ let into = repos.compare_paths(&[root.join("other")], "main", None, &cancel).unwrap();
+ assert_eq!(
+ into.repositories[0].files.iter().find(|f| f.path == "other/moved.txt").unwrap().kind,
+ ChangeKind::Added
+ );
+ }
+
+ #[test]
+ fn workspace_roots_missing_revision_loose_paths_and_empty_results() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ for name in ["client", "server", "admin"] {
+ init(&root.join(name), if name == "admin" { "trunk" } else { "main" });
+ }
+ write(&root, "loose/readme.txt", "not git\n");
+ write(&root.join("client"), "src/new.txt", "client\n");
+ write(&root.join("server"), "src/文件 name.txt", "server\n");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let scope = repos.compare_scope(std::slice::from_ref(&root));
+ assert_eq!(scope.repositories.len(), 3);
+ assert_eq!(scope.skipped_paths, [IpcPath(root.join("loose"))]);
+ assert!(!scope.single_file);
+ assert!(repos.compare_scope(&[root.join("client/src/文件 name.txt")]).single_file);
+ let cancel = CancellationToken::new();
+ let result = repos.compare_paths(&[root.clone(), root.join("loose")], "main", None, &cancel).unwrap();
+ assert_eq!(result.repositories.len(), 3);
+ assert_eq!(result.repositories.iter().filter(|r| r.missing_revision).count(), 1);
+ assert!(result.repositories[0].missing_revision, "admin lacks main");
+ assert!(result.repositories[0].error.is_none());
+ assert_eq!(result.repositories[1].files.len(), 1);
+ assert_eq!(result.repositories[2].files.len(), 1);
+ assert_eq!(result.skipped_paths, [IpcPath(root.join("loose"))]);
+ let filtered =
+ repos.compare_paths(std::slice::from_ref(&root), "main", Some(&[root.join("server")]), &cancel).unwrap();
+ assert_eq!(filtered.repositories.len(), 1);
+ assert_eq!(filtered.repositories[0].root.0, root.join("server"));
+ let empty = repos.compare_paths(&[root.join("server/other")], "main", None, &cancel).unwrap();
+ assert!(empty.repositories[0].files.is_empty());
+ let loose = repos.compare_paths(&[root.join("loose")], "main", None, &cancel).unwrap();
+ assert!(loose.repositories.is_empty());
+ assert_eq!(loose.skipped_paths, [IpcPath(root.join("loose"))]);
+ cancel.cancel();
+ assert!(repos.compare_paths(&[root], "main", None, &cancel).is_err());
+ }
+
+ #[test]
+ fn nested_repositories_are_not_reported_twice_and_binary_counts_are_zero() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root, "main");
+ init(&root.join("nested"), "main");
+ write(&root.join("nested"), "src/new.txt", "nested\n");
+ std::fs::write(root.join("src/image.bin"), [0, 1, 2]).unwrap();
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let result = repos.compare_paths(std::slice::from_ref(&root), "main", None, &CancellationToken::new()).unwrap();
+ assert_eq!(result.repositories.len(), 2);
+ assert_eq!(result.repositories[0].files.len(), 1);
+ assert_eq!(result.repositories[0].files[0].added, 0);
+ assert_eq!(result.repositories[1].files.len(), 1);
+ let nested = repos.compare_paths(&[root.join("nested")], "main", None, &CancellationToken::new()).unwrap();
+ assert_eq!(nested.repositories.len(), 1);
+ assert_eq!(nested.repositories.iter().map(|r| r.files.len()).sum::<usize>(), 1);
+ }
+ #[test]
+ fn skipped_children_only_report_content_outside_repositories() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root.join("services/server"), "main");
+ init(&root.join("client"), "main");
+ write(&root, ".openidea/state.json", "{}");
+ write(&root, ".git/config", "ignored metadata");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ assert!(repos.compare_scope(std::slice::from_ref(&root)).skipped_paths.is_empty());
+ write(&root, "services/notes.txt", "loose nested content");
+ write(&root, "loose/readme.txt", "loose");
+ write(&root, "readme.txt", "loose file");
+ let scope = repos.compare_scope(&[root.clone(), root.join("loose")]);
+ assert_eq!(
+ scope.skipped_paths,
+ [IpcPath(root.join("loose")), IpcPath(root.join("readme.txt")), IpcPath(root.join("services")),]
+ );
+ assert!(scope.skipped_paths[0].0.to_string_lossy().ends_with(std::path::MAIN_SEPARATOR));
+ }
+
+ #[test]
+ fn missing_revision_is_typed_and_other_errors_keep_only_the_message() {
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root, "main");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let cancel = CancellationToken::new();
+ let result = repos.compare_paths(std::slice::from_ref(&root), "missing-revision", None, &cancel).unwrap();
+ assert!(result.repositories[0].missing_revision);
+ assert!(result.repositories[0].error.is_none());
+ std::fs::write(root.join(".git/config"), "[broken").unwrap();
+ let result = repos.compare_paths(&[root], "main", None, &cancel).unwrap();
+ assert!(!result.repositories[0].missing_revision);
+ let error = result.repositories[0].error.as_deref().unwrap();
+ assert!(error.contains("bad config"), "{error}");
+ assert!(!error.starts_with("Internal:"), "{error}");
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn untracked_read_and_metadata_failures_leave_files_with_zero_counts() {
+ use std::os::unix::fs::symlink;
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root, "main");
+ // Reading a directory fails after successful metadata; a dangling link fails metadata.
+ symlink(root.join("src"), root.join("unreadable")).unwrap();
+ symlink(root.join("vanished"), root.join("missing")).unwrap();
+ write(&root, "new.txt", "still counted\n");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let result = repos.compare_paths(&[root], "main", None, &CancellationToken::new()).unwrap();
+ let repo = &result.repositories[0];
+ assert!(repo.error.is_none(), "{repo:?}");
+ assert_eq!(repo.files.len(), 3);
+ for name in ["unreadable", "missing"] {
+ let file = repo.files.iter().find(|f| f.path == name).unwrap();
+ assert_eq!((file.kind, file.added, file.removed), (ChangeKind::Untracked, 0, 0));
+ }
+ assert_eq!(repo.files.iter().find(|f| f.path == "new.txt").unwrap().added, 1);
+ }
+
+ #[cfg(unix)]
+ #[test]
+ fn restricted_comparison_does_not_execute_repository_commands() {
+ use std::os::unix::fs::PermissionsExt;
+ let temp = tempfile::tempdir().unwrap();
+ let root = normalized(temp.path());
+ init(&root, "main");
+ let script = root.join(".git/marker.sh");
+ let marker = root.join(".git/executed");
+ std::fs::write(&script, "#!/bin/sh\ntouch .git/executed\n").unwrap();
+ std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
+ let script = script.to_str().unwrap();
+ for key in [
+ "core.fsmonitor",
+ "filter.marker.clean",
+ "filter.marker.process",
+ "diff.marker.command",
+ "diff.marker.textconv",
+ ] {
+ git(&root, &["config", key, script]);
+ }
+ git(&root, &["config", "filter.marker.required", "true"]);
+ write(&root, ".gitattributes", "*.txt filter=marker diff=marker\n");
+ write(&root, "src/文件 name.txt", "changed\n");
+ write(&root, "new.txt", "untracked\n");
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ for repo in repos.all() {
+ repo.set_execution_allowed(false);
+ }
+ let result = repos.compare_paths(std::slice::from_ref(&root), "main", None, &CancellationToken::new()).unwrap();
+ assert!(result.repositories[0].error.is_none(), "{result:?}");
+ assert_eq!(result.repositories[0].files.len(), 3);
+ assert!(!marker.exists(), "Restricted Mode executed a repository command");
+ // Prove the fixture's fsmonitor hook is active when the shared wrapper is bypassed.
+ git(&root, &["ls-files"]);
+ assert!(marker.exists(), "control invocation did not run fsmonitor");
+ }
+}
diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rs
index ac6f18de2..cca5669ac 100644
--- a/crates/ide-vcs/src/lib.rs
+++ b/crates/ide-vcs/src/lib.rs
@@ -453,6 +453,7 @@ pub struct ChangelistState {
mod blame;
pub mod changelists;
mod cli;
+mod compare;
mod diff;
mod history;
mod ignore;
@@ -464,6 +465,7 @@ mod refs;
mod remotes;
mod repo;
mod roots;
+pub use compare::{CompareResult, CompareScope, RepositoryComparison, WorkingTreeChange};
pub mod shelf;
mod status;
pub use index_writes::is_own_index_write;
diff --git a/crates/ide-vcs/tests/repo.rs b/crates/ide-vcs/tests/repo.rs
index 6db9d76ff..989037d6d 100644
--- a/crates/ide-vcs/tests/repo.rs
+++ b/crates/ide-vcs/tests/repo.rs
@@ -1555,6 +1555,14 @@ fn restricted_reads_ignore_executable_repository_configuration() {
assert!(!repo.log(&LogQuery::default()).unwrap().is_empty());
repo.merge_versions(&f.path("a.txt"), encoding_rs::UTF_8).unwrap();
assert!(!f.path("execution.marker").exists());
+ let repos = ide_vcs::Repos::discover(&f.dir, &|_| false).unwrap();
+ for r in repos.all() {
+ r.set_execution_allowed(false);
+ }
+ let compared =
+ repos.compare_paths(std::slice::from_ref(&f.dir), "HEAD", None, &ide_core::CancellationToken::new()).unwrap();
+ assert!(compared.repositories.iter().all(|r| r.error.is_none()));
+ assert!(!f.path("execution.marker").exists());
// Positive control: the same filter really executes without restriction.
f.git(&["-c", "core.fsmonitor=false", "diff", "--no-ext-diff", "--no-textconv"]);
assert!(f.path("execution.marker").exists());
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index e327a2642..f4d94c85b 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -271,6 +271,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
vcs::vcs_add_worktree,
vcs::vcs_remove_worktree,
vcs::vcs_diff_with_worktree,
+ vcs::vcs_compare_scope,
+ vcs::vcs_compare_paths,
vcs::vcs_diff_revisions,
vcs::vcs_merge_base,
vcs::vcs_create_patch,
diff --git a/src-tauri/src/commands/vcs.rs b/src-tauri/src/commands/vcs.rs
index 1c90bf70b..9f3aaf188 100644
--- a/src-tauri/src/commands/vcs.rs
+++ b/src-tauri/src/commands/vcs.rs
@@ -680,3 +680,26 @@ pub async fn vcs_shelf_import(
) -> IdeResult<()> {
ide_host::ops::vcs::vcs_shelf_import(&state.host, window.label(), name, patch).await
}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn vcs_compare_scope(
+ window: Window,
+ state: State<'_, AppState>,
+ paths: Vec<PathBuf>,
+) -> IdeResult<ide_vcs::CompareScope> {
+ ide_host::ops::vcs::vcs_compare_scope(&state.host, window.label(), paths).await
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn vcs_compare_paths(
+ window: Window,
+ state: State<'_, AppState>,
+ paths: Vec<PathBuf>,
+ revision: String,
+ repositories: Option<Vec<PathBuf>>,
+ request: RequestId,
+) -> IdeResult<ide_vcs::CompareResult> {
+ ide_host::ops::vcs::vcs_compare_paths(&state.host, window.label(), paths, revision, repositories, request).await
+}
diff --git a/src/bindings.ts b/src/bindings.ts
index de0462380..80ddb8f90 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -509,6 +509,8 @@ export const commands = {
vcsRemoveWorktree: (repo: string | null, path: string, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_remove_worktree", { repo, path, force })),
/** Compare with Local: tracked files that differ between `rev` and the working tree. */
vcsDiffWithWorktree: (repo: string | null, rev: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_with_worktree", { repo, rev })),
+ vcsCompareScope: (paths: string[]) => typedError<CompareScope, IdeError>(__TAURI_INVOKE("vcs_compare_scope", { paths })),
+ vcsComparePaths: (paths: string[], revision: string, repositories: string[] | null, request: RequestId) => typedError<CompareResult, IdeError>(__TAURI_INVOKE("vcs_compare_paths", { paths, revision, repositories, request })),
/** Files that differ between two revisions (the "N files updated" of Update Project). */
vcsDiffRevisions: (repo: string | null, from: string, to: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_revisions", { repo, from, to })),
/** The best common ancestor of `a` and `b` (`git merge-base`), if any. */
@@ -1888,6 +1890,18 @@ export type CommitSettings = {
wrapAtMargin?: boolean,
};
+export type CompareResult = {
+ repositories: RepositoryComparison[],
+ skippedPaths: IpcPath[],
+};
+
+export type CompareScope = {
+ repositories: IpcPath[],
+ /** Selected content outside registered repositories; workspace parents expand to their skipped children. */
+ skippedPaths: IpcPath[],
+ singleFile: boolean,
+};
+
export type CompletionItem = {
label: string,
/** e.g. `(req: CreateOrderRequest)` shown right after the label. */
@@ -5125,6 +5139,16 @@ export type ReplaceTarget = {
only?: Pos[] | null,
};
+export type RepositoryComparison = {
+ root: IpcPath,
+ /** Resolved commit, so opening a diff later uses the same left side as the listing. */
+ revision: string | null,
+ files: WorkingTreeChange[],
+ error: string | null,
+ /** The requested revision does not resolve to a commit in this repository. */
+ missingRevision?: boolean,
+};
+
/** A cancellable, streaming backend request issued by the UI. */
export type RequestId = number;
@@ -6294,6 +6318,14 @@ export type WindowTab = {
current: boolean,
};
+export type WorkingTreeChange = {
+ path: string,
+ kind: ChangeKind,
+ oldPath: string | null,
+ added: number,
+ removed: number,
+};
+
export type Workspace = Workspace_Serialize | Workspace_Deserialize;
/** Edits to many files, applied atomically from the user's point of view. */
diff --git a/src/features/project-tree/contextMenu.test.ts b/src/features/project-tree/contextMenu.test.ts
index b1970bb64..622ddf3b0 100644
--- a/src/features/project-tree/contextMenu.test.ts
+++ b/src/features/project-tree/contextMenu.test.ts
@@ -44,6 +44,7 @@ const OTHER_ACTIONS = [
"vcs.addToVcs",
"vcs.annotate",
"vcs.showDiff",
+ "vcs.compareWithBranch",
"vcs.rollback",
"vcs.push",
];
@@ -129,6 +130,17 @@ describe("project view context menu", () => {
}
});
+ it("offers branch comparison for files, folders, their union and the project root", () => {
+ for (const nodes of [
+ [node("/p/a.py")],
+ [node("/p/src", true)],
+ [node("/p/src", true), node("/p/lib", true)],
+ [node("/p", true, true)],
+ ]) {
+ expect(sub(contextMenuItems(nodes), "Git")).toContain("Compare with Branch…");
+ }
+ });
+
it("offers Show History for files, directories, multi-selection and the project root", () => {
const dispose = registerActions([{ id: "vcs.showHistory", title: "Show History", run: () => undefined }]);
try {
diff --git a/src/features/project-tree/contextMenu.ts b/src/features/project-tree/contextMenu.ts
index c235dbf4c..1b35cf483 100644
--- a/src/features/project-tree/contextMenu.ts
+++ b/src/features/project-tree/contextMenu.ts
@@ -335,7 +335,9 @@ export function contextMenuItems(nodes: ProjectNode[]): MenuItem[] {
{ kind: "separator" },
singleFile && act("vcs.annotate", singleFile.path, "Annotate with Git Blame"),
act("vcs.showDiff", arg, "Show Diff"),
- singleFile && act("vcs.compareWithBranch", { path: singleFile.path }, "Compare with Branch…"),
+ nodes.length > 0 &&
+ nodes.every((n) => !n.placeholder) &&
+ act("vcs.compareWithBranch", arg, "Compare with Branch…"),
nodes.length > 0 && nodes.every((n) => !n.placeholder) && act("vcs.showHistory", arg, "Show History"),
act("vcs.rollback", arg, "Rollback…"),
{ kind: "separator" },
diff --git a/src/features/vcs/RevisionChooser.tsx b/src/features/vcs/RevisionChooser.tsx
index f301e25de..9269e5bb1 100644
--- a/src/features/vcs/RevisionChooser.tsx
+++ b/src/features/vcs/RevisionChooser.tsx
@@ -1,26 +1,100 @@
-/** Chooser for "Compare with Branch or Revision…". */
+/** Chooser for revision actions, including a selection spanning multiple repositories. */
import { useEffect, useMemo, useState, type KeyboardEvent } from "react";
import { Dialog, HighlightedText, Icon, List, SearchField, fuzzyMatch, listNavigate } from "@/ui";
import { sortLocal, sortRemote } from "./branches";
import { openDialog } from "./dialogs";
import { call, commands } from "@/platform/ipc";
import type { Branch } from "@/bindings";
-import { currentRepo } from "./store";
+import { currentRepo, repoName } from "./store";
+import { tx } from "@/platform/i18n";
import styles from "./common.module.css";
-interface Item {
+export interface RevisionChoice {
rev: string;
+ /** null applies an entered revision to every repository in the selection. */
+ repositories: string[] | null;
+}
+
+interface Item extends RevisionChoice {
detail: string;
matches: number[] | null;
+ section?: boolean;
+}
+
+export interface RepositoryRevisions {
+ root: string | null;
+ branches: Branch[];
+ tags: string[];
}
export interface ChooseRevisionOptions {
- /** Offer the repository's tags too. */
tags?: boolean;
placeholder?: string;
+ repositories?: string[];
}
-export function chooseRevision(title: string, options: ChooseRevisionOptions = {}): Promise<string | null> {
+/** Shared branches first, followed by each repository's revisions. */
+export function revisionItems(repos: RepositoryRevisions[], query: string): Item[] {
+ const all: Item[] = [{ rev: "HEAD", detail: tx("Last commit"), repositories: null, matches: null }];
+ const multi = repos.length > 1;
+ if (multi) {
+ const shared = new Map<string, string[]>();
+ for (const repo of repos) {
+ for (const name of new Set(repo.branches.map((b) => b.name))) {
+ const roots = shared.get(name) ?? [];
+ if (repo.root) roots.push(repo.root);
+ shared.set(name, roots);
+ }
+ }
+ for (const [rev, repositories] of shared) {
+ if (repositories.length > 1)
+ all.push({ rev, detail: tx`in ${repositories.length} repositories`, repositories, matches: null });
+ }
+ }
+ for (const repo of repos) {
+ if (multi)
+ all.push({
+ rev: repoName(repo.root ?? ""),
+ detail: repo.root ?? "",
+ repositories: [],
+ matches: null,
+ section: true,
+ });
+ const repositories = repo.root ? [repo.root] : null;
+ all.push(
+ ...sortLocal(repo.branches).map((b) => ({
+ rev: b.name,
+ detail: tx(b.current ? "current branch" : "local"),
+ repositories,
+ matches: null,
+ })),
+ ...sortRemote(repo.branches).map((b) => ({ rev: b.name, detail: tx("remote"), repositories, matches: null })),
+ ...repo.tags.map((rev) => ({ rev, detail: tx("tag"), repositories, matches: null })),
+ );
+ }
+ const q = query.trim();
+ if (!q) return all;
+ const filtered = all
+ .flatMap((i) => {
+ if (i.section) return [i];
+ const matches = fuzzyMatch(i.rev, q);
+ return matches ? [{ ...i, matches }] : [];
+ })
+ .filter((i, idx, list) => !i.section || (!!list[idx + 1] && !list[idx + 1]!.section));
+ // Always allow applying a typed revision across the full selection, even when one repo offers it.
+ if (!filtered.some((i) => !i.section && i.rev === q && i.repositories === null))
+ filtered.push({ rev: q, detail: tx("revision"), repositories: null, matches: null });
+ return filtered;
+}
+
+export async function chooseRevision(title: string, options: ChooseRevisionOptions = {}): Promise<string | null> {
+ return (await chooseRepositoryRevision(title, options))?.rev ?? null;
+}
+
+export function chooseRepositoryRevision(
+ title: string,
+ options: ChooseRevisionOptions,
+): Promise<RevisionChoice | null> {
return new Promise((resolve) => {
const close = openDialog(() => (
<Chooser
@@ -42,57 +116,46 @@ function Chooser({
}: {
title: string;
options: ChooseRevisionOptions;
- onDone: (rev: string | null) => void;
+ onDone: (rev: RevisionChoice | null) => void;
}) {
- const [repo] = useState(currentRepo);
- const [branches, setBranches] = useState<Branch[]>([]);
- const [tags, setTags] = useState<string[]>([]);
+ const [roots] = useState(() => options.repositories ?? [currentRepo()]);
+ const [repos, setRepos] = useState<RepositoryRevisions[]>([]);
+ const [error, setError] = useState<string | null>(null);
const [query, setQuery] = useState("");
const [active, setActive] = useState(0);
useEffect(() => {
let alive = true;
- void call(commands.vcsBranches(repo))
- .then((b) => alive && setBranches(b))
- .catch(() => undefined);
- if (options.tags) {
- void call(commands.vcsTags(repo))
- .then((t) => alive && setTags(t))
- .catch(() => undefined);
- }
+ void Promise.all(
+ roots.map(async (root) => {
+ const [branches, tags] = await Promise.allSettled([
+ call(commands.vcsBranches(root)),
+ options.tags ? call(commands.vcsTags(root)) : Promise.resolve<string[]>([]),
+ ]);
+ for (const outcome of [branches, tags])
+ if (outcome.status === "rejected" && alive) setError(`${root ?? ""}: ${String(outcome.reason)}`);
+ return {
+ root,
+ branches: branches.status === "fulfilled" ? branches.value : [],
+ tags: tags.status === "fulfilled" ? tags.value : [],
+ };
+ }),
+ )
+ .then((r) => alive && setRepos(r))
+ .catch((e) => alive && setError(String(e)));
return () => {
alive = false;
};
- }, [options.tags]);
- const items = useMemo(() => {
- const all: Item[] = [
- { rev: "HEAD", detail: "Last commit", matches: null },
- ...sortLocal(branches).map((b) => ({
- rev: b.name,
- detail: b.current ? "current branch" : "local",
- matches: null,
- })),
- ...sortRemote(branches).map((b) => ({ rev: b.name, detail: "remote", matches: null })),
- ...tags.map((t) => ({ rev: t, detail: "tag", matches: null })),
- ];
- const q = query.trim();
- const filtered = q
- ? all.flatMap((i) => {
- const m = fuzzyMatch(i.rev, q);
- return m ? [{ ...i, matches: m }] : [];
- })
- : all;
- if (q && !filtered.some((i) => i.rev === q)) filtered.push({ rev: q, detail: "revision", matches: null });
- return filtered;
- }, [branches, tags, query]);
+ }, [options.tags, roots]);
+ const items = useMemo(() => revisionItems(repos, query), [repos, query]);
const idx = Math.min(active, items.length - 1);
const onKeyDown = (e: KeyboardEvent) => {
if (e.key === "Enter") {
e.preventDefault();
const it = items[idx];
- if (it) onDone(it.rev);
+ if (it && !it.section) onDone(it);
return;
}
- const n = listNavigate(e.key, { items, active: idx, wrap: true });
+ const n = listNavigate(e.key, { items, active: idx, isSection: (i) => !!i.section, wrap: true });
if (n !== null) {
e.preventDefault();
setActive(n);
@@ -114,13 +177,20 @@ function Chooser({
variant="bare"
/>
</div>
+ {error && (
+ <div className={styles.error} role="alert">
+ {error}
+ </div>
+ )}
<div style={{ height: 280, display: "flex", flexDirection: "column", padding: "4px 0" }}>
<List
items={items}
- getKey={(i) => `${i.detail}:${i.rev}`}
+ getKey={(i) => `${i.repositories?.join(":")}:${i.detail}:${i.rev}`}
activeIndex={idx}
onActiveChange={setActive}
- onActivate={(i) => onDone(i.rev)}
+ onActivate={(i) => onDone(i)}
+ isSection={(i) => !!i.section}
+ renderSection={(i) => <span title={i.detail}>{i.rev}</span>}
focusable={false}
hoverSelects
rowHeight={24}
@@ -128,7 +198,10 @@ function Chooser({
className={styles.grow}
renderItem={(i) => (
<span className={styles.fileRow} style={{ flex: 1, padding: 0 }}>
- <Icon name={i.detail === "revision" ? "commit" : i.detail === "tag" ? "tag" : "branch"} size={14} />
+ <Icon
+ name={i.detail === tx("revision") ? "commit" : i.detail === tx("tag") ? "tag" : "branch"}
+ size={14}
+ />
<HighlightedText
className={`${styles.fileName} ${styles.mono}`}
text={i.rev}
diff --git a/src/features/vcs/__tests__/compareActions.test.ts b/src/features/vcs/__tests__/compareActions.test.ts
new file mode 100644
index 000000000..59eb0f0fe
--- /dev/null
+++ b/src/features/vcs/__tests__/compareActions.test.ts
@@ -0,0 +1,26 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { getAction, isActionEnabled } from "@/platform/actions";
+import { provideProjectViewSelection } from "@/workbench/contributions";
+import { registerVcsActions } from "../actions";
+
+const mocks = vi.hoisted(() => ({ compare: vi.fn() }));
+vi.mock("../comparePaths", () => ({ comparePathsWithRevision: mocks.compare, showDirectoryWorkingDiff: vi.fn() }));
+afterEach(() => vi.clearAllMocks());
+
+describe("compare action context", () => {
+ it("is enabled for Git folder selections and uses project selection in menu/Search Everywhere", async () => {
+ const unregister = registerVcsActions();
+ const dispose = provideProjectViewSelection(() => ["/workspace/client", "/workspace/server"]);
+ try {
+ const action = getAction("vcs.compareWithBranch")!;
+ expect(isActionEnabled(action, { vcsAvailable: true, projectViewFocus: true })).toBe(true);
+ await action.run({ arg: undefined, ctx: { vcsAvailable: true } });
+ expect(mocks.compare).toHaveBeenCalledWith(["/workspace/client", "/workspace/server"]);
+ await action.run({ arg: { path: "/workspace/client/a.ts" }, ctx: { vcsAvailable: true } });
+ expect(mocks.compare).toHaveBeenLastCalledWith(["/workspace/client/a.ts"]);
+ } finally {
+ dispose();
+ unregister();
+ }
+ });
+});
diff --git a/src/features/vcs/__tests__/compareFlow.test.ts b/src/features/vcs/__tests__/compareFlow.test.ts
new file mode 100644
index 000000000..50e84ad20
--- /dev/null
+++ b/src/features/vcs/__tests__/compareFlow.test.ts
@@ -0,0 +1,74 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({ scope: vi.fn(), choose: vi.fn(), open: vi.fn(), show: vi.fn(), notify: vi.fn() }));
+vi.mock("@/platform/ipc", async (original) => {
+ const real = await original<typeof import("@/platform/ipc")>();
+ return { ...real, commands: { ...real.commands, vcsCompareScope: mocks.scope } };
+});
+vi.mock("../RevisionChooser", () => ({ chooseRepositoryRevision: mocks.choose }));
+vi.mock("../diffInput", () => ({ openDiff: mocks.open }));
+vi.mock("../operations", () => ({ showPathComparison: mocks.show }));
+vi.mock("@/workbench/contributions", () => ({ notifications: () => ({ notify: mocks.notify }) }));
+import { useProject } from "@/platform/project";
+import { comparePathsWithRevision, showDirectoryWorkingDiff } from "../comparePaths";
+
+afterEach(() => {
+ vi.clearAllMocks();
+ useProject.setState({ project: null });
+});
+
+describe("comparison flow", () => {
+ it("keeps a single file's direct revision → worktree diff and uses its own repository's picker", async () => {
+ mocks.scope.mockResolvedValue({
+ status: "ok",
+ data: { repositories: ["/server"], singleFile: true, skippedPaths: [] },
+ });
+ mocks.choose.mockResolvedValue({ rev: "main", repositories: ["/server"] });
+ await comparePathsWithRevision(["/server/a.ts"]);
+ expect(mocks.choose).toHaveBeenCalledWith("Compare with Branch or Revision", {
+ repositories: ["/server"],
+ tags: true,
+ });
+ expect(mocks.open).toHaveBeenCalledWith({
+ path: "/server/a.ts",
+ left: { type: "rev", rev: "main", label: "main" },
+ right: { type: "worktree" },
+ });
+ expect(mocks.show).not.toHaveBeenCalled();
+ });
+
+ it("applies shared revisions across the selection so missing revisions are reported, and preserves repo-specific choices", async () => {
+ mocks.scope.mockResolvedValue({
+ status: "ok",
+ data: { repositories: ["/client", "/server", "/admin"], singleFile: false, skippedPaths: [] },
+ });
+ mocks.choose.mockResolvedValue({ rev: "main", repositories: ["/client", "/server"] });
+ await comparePathsWithRevision(["/workspace"]);
+ expect(mocks.show).toHaveBeenLastCalledWith(["/workspace"], "main", null);
+ mocks.choose.mockResolvedValue({ rev: "feature", repositories: ["/server"] });
+ await comparePathsWithRevision(["/workspace"]);
+ expect(mocks.show).toHaveBeenLastCalledWith(["/workspace"], "feature", ["/server"]);
+ });
+
+ it("reports non-repository selections before opening a picker", async () => {
+ mocks.scope.mockResolvedValue({
+ status: "ok",
+ data: { repositories: [], singleFile: false, skippedPaths: ["/workspace/loose/"] },
+ });
+ useProject.setState({ project: { root: "/workspace", name: "workspace" } as never });
+ await comparePathsWithRevision(["/workspace/loose"]);
+ expect(mocks.notify).toHaveBeenCalledWith(
+ expect.objectContaining({ title: "Selection is outside Git repositories", body: "loose/" }),
+ );
+ expect(mocks.choose).not.toHaveBeenCalled();
+ });
+
+ it("reuses the tree against HEAD for Show Diff on folders", async () => {
+ mocks.scope.mockResolvedValue({
+ status: "ok",
+ data: { repositories: ["/server"], singleFile: false, skippedPaths: [] },
+ });
+ expect(await showDirectoryWorkingDiff(["/server/src"])).toBe(true);
+ expect(mocks.show).toHaveBeenCalledWith(["/server/src"], "HEAD", null);
+ });
+});
diff --git a/src/features/vcs/__tests__/folderCompare.test.tsx b/src/features/vcs/__tests__/folderCompare.test.tsx
new file mode 100644
index 000000000..c1b806400
--- /dev/null
+++ b/src/features/vcs/__tests__/folderCompare.test.tsx
@@ -0,0 +1,164 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import type { Branch, CompareResult } from "@/bindings";
+
+const mocks = vi.hoisted(() => ({
+ compare: vi.fn(),
+ cancel: vi.fn(),
+ scope: vi.fn(),
+ choose: vi.fn(),
+ open: vi.fn(),
+ show: vi.fn(),
+}));
+vi.mock("@/platform/ipc", async (original) => {
+ const real = await original<typeof import("@/platform/ipc")>();
+ return {
+ ...real,
+ commands: {
+ ...real.commands,
+ vcsComparePaths: mocks.compare,
+ cancelRequest: mocks.cancel,
+ vcsCompareScope: mocks.scope,
+ },
+ };
+});
+vi.mock("../DiffEditor", () => ({
+ DiffEditor: ({ input }: { input: unknown }) => <div data-testid="diff">{JSON.stringify(input)}</div>,
+}));
+import { useProject } from "@/platform/project";
+import { ChangesBetweenDialog, comparisonEmpty } from "../operations";
+import { revisionItems } from "../RevisionChooser";
+
+const branch = (name: string, remote = false) => ({ name, remote, current: false, lastCommitMs: 0 }) as Branch;
+const scope = { paths: ["/workspace"], repositories: null };
+const result: CompareResult = {
+ skippedPaths: ["/workspace/loose/"],
+ repositories: [
+ {
+ root: "/workspace/client",
+ revision: "aaa",
+ error: null,
+ missingRevision: false,
+ files: [{ path: "src/app.ts", kind: "modified", oldPath: null, added: 3, removed: 1 }],
+ },
+ { root: "/workspace/server", revision: null, error: null, missingRevision: true, files: [] },
+ ],
+};
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ useProject.setState({ project: { root: "/workspace", name: "workspace" } as never });
+ mocks.cancel.mockResolvedValue(undefined);
+});
+afterEach(() => {
+ cleanup();
+ useProject.setState({ project: null });
+});
+
+describe("directory comparison", () => {
+ it("offers shared branches plus each repository's local, remote and tag revisions", () => {
+ const repos = [
+ {
+ root: "/workspace/client",
+ branches: [branch("main"), branch("client-only"), branch("origin/main", true)],
+ tags: ["v1"],
+ },
+ { root: "/workspace/server", branches: [branch("main"), branch("server-only")], tags: [] },
+ { root: "/workspace/admin", branches: [branch("main")], tags: [] },
+ ];
+ const items = revisionItems(repos, "");
+ expect(items.find((i) => i.rev === "main" && i.repositories?.length === 3)?.detail).toBe("in 3 repositories");
+ expect(items.filter((i) => i.section).map((i) => i.rev)).toEqual(["client", "server", "admin"]);
+ expect(items.find((i) => i.rev === "origin/main")?.repositories).toEqual(["/workspace/client"]);
+ expect(items.find((i) => i.rev === "v1")?.repositories).toEqual(["/workspace/client"]);
+ expect(revisionItems(repos, "client-only").some((i) => i.rev === "client-only" && i.repositories === null)).toBe(
+ true,
+ );
+ });
+
+ it("shows explicit empty results, skipped paths and repository-specific errors", async () => {
+ mocks.compare.mockResolvedValue({
+ status: "ok",
+ data: { ...result, repositories: result.repositories.map((r) => ({ ...r, files: [] })) },
+ });
+ render(<ChangesBetweenDialog from={{ rev: "main", label: "main" }} to={null} scope={scope} onClose={() => {}} />);
+ expect(await screen.findByText("No changes against main in 1 repository")).toBeInTheDocument();
+ expect(screen.getByText("server has no revision main")).toBeInTheDocument();
+ expect(screen.getByText(/Skipped content/)).toHaveTextContent("Skipped content outside Git repositories: loose/");
+ expect(comparisonEmpty("main", 2)).toBe("No changes against main in 2 repositories");
+ });
+
+ it("shows one calm state when every selected repository lacks the revision", async () => {
+ mocks.compare.mockResolvedValue({
+ status: "ok",
+ data: {
+ ...result,
+ repositories: result.repositories.map((r) => ({ ...r, files: [], revision: null, missingRevision: true })),
+ },
+ });
+ render(
+ <ChangesBetweenDialog
+ from={{ rev: "missing-revision", label: "missing-revision" }}
+ to={null}
+ scope={scope}
+ onClose={() => {}}
+ />,
+ );
+ expect(await screen.findByText("No repository in the selection has revision missing-revision")).toBeInTheDocument();
+ expect(screen.queryByText(/has no revision/)).toBeNull();
+ expect(screen.queryByText(/No changes against/)).toBeNull();
+ expect(screen.queryByRole("alert")).toBeNull();
+ });
+
+ it("keeps other repository errors visible", async () => {
+ mocks.compare.mockResolvedValue({
+ status: "ok",
+ data: {
+ ...result,
+ repositories: [{ ...result.repositories[1], missingRevision: false, error: "fatal: bad config" }],
+ },
+ });
+ render(<ChangesBetweenDialog from={{ rev: "main", label: "main" }} to={null} scope={scope} onClose={() => {}} />);
+ expect(await screen.findByRole("alert")).toHaveTextContent("Cannot compare server against main: fatal: bad config");
+ expect(screen.queryByText(/No changes against/)).toBeNull();
+ });
+
+ it("caps the list of skipped project-relative children", async () => {
+ mocks.compare.mockResolvedValue({
+ status: "ok",
+ data: {
+ ...result,
+ skippedPaths: Array.from({ length: 7 }, (_, i) => `/workspace/loose${i}/`),
+ },
+ });
+ render(<ChangesBetweenDialog from={{ rev: "main", label: "main" }} to={null} scope={scope} onClose={() => {}} />);
+ expect(await screen.findByText(/Skipped content/)).toHaveTextContent(
+ "Skipped content outside Git repositories: loose0/, loose1/, loose2/, loose3/, loose4/ and 2 more",
+ );
+ expect(screen.getByText(/Skipped content/)).not.toHaveTextContent("/workspace");
+ });
+
+ it("groups the existing changes tree by repo, includes counts and loads a diff only on click", async () => {
+ mocks.compare.mockResolvedValue({ status: "ok", data: result });
+ render(<ChangesBetweenDialog from={{ rev: "main", label: "main" }} to={null} scope={scope} onClose={() => {}} />);
+ expect(await screen.findByText("app.ts")).toBeInTheDocument();
+ expect(screen.getByText("client")).toBeInTheDocument();
+ expect(screen.getByText("+3")).toBeInTheDocument();
+ expect(screen.getByText("−1")).toBeInTheDocument();
+ expect(screen.queryByTestId("diff")).toBeNull();
+ fireEvent.mouseDown(screen.getByText("app.ts"), { button: 0 });
+ expect(screen.getByTestId("diff")).toHaveTextContent('"rev":"aaa"');
+ expect(screen.getByTestId("diff")).toHaveTextContent("/workspace/client/src/app.ts");
+ });
+
+ it("cancels the backend request when a running comparison is closed", async () => {
+ mocks.compare.mockReturnValue(new Promise(() => {}));
+ const view = render(
+ <ChangesBetweenDialog from={{ rev: "main", label: "main" }} to={null} scope={scope} onClose={() => {}} />,
+ );
+ await waitFor(() => expect(mocks.compare).toHaveBeenCalled());
+ const request = mocks.compare.mock.calls[0]![3];
+ view.unmount();
+ expect(mocks.cancel).toHaveBeenCalledWith(request);
+ });
+});
diff --git a/src/features/vcs/actions.tsx b/src/features/vcs/actions.tsx
index 832583c65..01582c32f 100644
--- a/src/features/vcs/actions.tsx
+++ b/src/features/vcs/actions.tsx
@@ -5,7 +5,13 @@ import { registerActions, type Action } from "@/platform/actions";
import { getContext } from "@/platform/context";
import { activeEditor, editorsFor } from "@/editor/api";
import { Menu, type MenuItem } from "@/ui";
-import { editorService, maybeEditorService, notifications, toolWindowService } from "@/workbench/contributions";
+import {
+ editorService,
+ maybeEditorService,
+ notifications,
+ projectViewSelection,
+ toolWindowService,
+} from "@/workbench/contributions";
import { annotationsShown, toggleAnnotations } from "./blame";
import { showBranchesPopup } from "./BranchWidget";
import { checkoutRevision, newBranch, newBranchInRepos } from "./branchOps";
@@ -29,7 +35,7 @@ import { openLogTab, revealCommit, selectGitTab, useGitLog } from "./logStore";
import { isModalCommit, openCommit, pushAfterCommit } from "./commitUi";
import { allRepos, runRemote } from "./ops";
import { showPushDialog, showUpdateDialog, type PushTarget } from "./remoteUi";
-import { chooseRevision } from "./RevisionChooser";
+import { comparePathsWithRevision, showDirectoryWorkingDiff } from "./comparePaths";
import { showCloneDialog } from "./clone";
import {
showManageRemotes,
@@ -103,6 +109,7 @@ const OPERATIONS: MenuItem[] = [
{ kind: "action", action: "vcs.showHistory" },
{ kind: "action", action: "vcs.annotate" },
{ kind: "action", action: "vcs.showDiff" },
+ { kind: "action", action: "vcs.compareWithBranch" },
{ kind: "separator" },
{ kind: "action", action: "vcs.branches" },
{ kind: "action", action: "vcs.push" },
@@ -311,11 +318,13 @@ export function registerVcsActions(): () => void {
if (ctx.shelfFocus && arg === undefined) return showShelfDiff();
const line =
arg && typeof arg === "object" && "line" in arg ? Number((arg as { line: unknown }).line) : undefined;
- const paths = contextPaths(arg).filter((p) => !p.endsWith("/"));
+ const selection = arg === undefined ? projectViewSelection() : [];
+ const paths = selection.length ? selection : contextPaths(arg);
if (!paths.length) {
notifications().notify({ group: "vcs", level: "info", title: "Select a changed file to show its diff" });
return;
}
+ if (await showDirectoryWorkingDiff(paths)) return;
for (const p of paths.slice(0, 5)) await openDiff(workingDiffData(p, line), { preview: paths.length === 1 });
},
},
@@ -326,14 +335,13 @@ export function registerVcsActions(): () => void {
icon: "diff",
when: VCS,
run: async ({ arg }) => {
- const path = contextPaths(arg)[0];
- if (!path) {
- notifications().notify({ group: "vcs", level: "info", title: "Open or select a file to compare" });
+ const selection = arg === undefined ? projectViewSelection() : [];
+ const paths = selection.length ? selection : contextPaths(arg);
+ if (!paths.length) {
+ notifications().notify({ group: "vcs", level: "info", title: "Open or select a file or folder to compare" });
return;
}
- const rev = await chooseRevision("Compare with Branch or Revision");
- if (!rev) return;
- await openDiff({ path, left: { type: "rev", rev, label: rev }, right: { type: "worktree" } });
+ await comparePathsWithRevision(paths);
},
},
{
diff --git a/src/features/vcs/common.module.css b/src/features/vcs/common.module.css
index 3fbd5f58a..c18a071e9 100644
--- a/src/features/vcs/common.module.css
+++ b/src/features/vcs/common.module.css
@@ -282,3 +282,49 @@
.manageRowSelected:hover {
background: var(--bg-list-selected);
}
+
+.comparison {
+ display: flex;
+ height: min(520px, 65vh);
+ min-height: 180px;
+ padding: 0 12px 12px;
+ gap: 10px;
+}
+.comparisonTree {
+ flex: 1;
+ min-width: 0;
+ border: 1px solid var(--border);
+}
+.comparisonWithDiff .comparisonTree {
+ flex: 0 0 30%;
+}
+.comparisonDiff {
+ flex: 1;
+ min-width: 0;
+ min-height: 0;
+ overflow: hidden;
+ border: 1px solid var(--border);
+}
+.compareNotice {
+ padding: 6px 14px;
+ color: var(--fg-subtle);
+ overflow-wrap: anywhere;
+}
+.compareAdded {
+ color: var(--vcs-added);
+ font-variant-numeric: tabular-nums;
+}
+.compareRemoved {
+ color: var(--vcs-deleted);
+ font-variant-numeric: tabular-nums;
+}
+@media (max-width: 760px) {
+ .comparisonWithDiff {
+ flex-direction: column;
+ height: 65vh;
+ }
+ .comparisonWithDiff .comparisonTree {
+ flex: 0 0 30%;
+ min-height: 90px;
+ }
+}
diff --git a/src/features/vcs/comparePaths.ts b/src/features/vcs/comparePaths.ts
new file mode 100644
index 000000000..2ebd9a9bc
--- /dev/null
+++ b/src/features/vcs/comparePaths.ts
@@ -0,0 +1,53 @@
+import { call, commands } from "@/platform/ipc";
+import { notifications } from "@/workbench/contributions";
+import { tx } from "@/platform/i18n";
+import { chooseRepositoryRevision } from "./RevisionChooser";
+import { openDiff } from "./diffInput";
+import { showPathComparison } from "./operations";
+import { displayPath } from "./compare";
+
+export async function comparePathsWithRevision(paths: string[], revision?: string) {
+ const scope = await call(commands.vcsCompareScope(paths));
+ if (!scope.repositories.length) {
+ notifications().notify({
+ group: "vcs",
+ level: "info",
+ title: "Selection is outside Git repositories",
+ body: scope.skippedPaths.map((path) => displayPath(path)).join("\n"),
+ });
+ return;
+ }
+ const choice = revision
+ ? { rev: revision, repositories: null }
+ : await chooseRepositoryRevision(tx("Compare with Branch or Revision"), {
+ repositories: scope.repositories,
+ tags: true,
+ });
+ if (!choice) return;
+ if (scope.singleFile && !revision) {
+ await openDiff({
+ path: paths[0]!,
+ left: { type: "rev", rev: choice.rev, label: choice.rev },
+ right: { type: "worktree" },
+ });
+ } else {
+ // A shared branch reviews the selection, including explicit errors for roots lacking it.
+ const repositories = choice.repositories && choice.repositories.length === 1 ? choice.repositories : null;
+ showPathComparison(paths, choice.rev, repositories);
+ }
+}
+
+/** Returns false for a single file, whose existing Show Diff behavior is retained. */
+export async function showDirectoryWorkingDiff(paths: string[]): Promise<boolean> {
+ const scope = await call(commands.vcsCompareScope(paths));
+ if (scope.singleFile) return false;
+ if (!scope.repositories.length) {
+ notifications().notify({
+ group: "vcs",
+ level: "info",
+ title: "Selection is outside Git repositories",
+ body: scope.skippedPaths.map((path) => displayPath(path)).join("\n"),
+ });
+ } else showPathComparison(paths, "HEAD", null);
+ return true;
+}
diff --git a/src/features/vcs/operations.tsx b/src/features/vcs/operations.tsx
index 3cbe13ce8..e0099acd0 100644
--- a/src/features/vcs/operations.tsx
+++ b/src/features/vcs/operations.tsx
@@ -4,20 +4,23 @@ import { commitKey, commitRepo } from "./multiRoot";
* cherry-pick or revert, and the Git Log commit actions (Cherry-Pick, Revert
* Commit, Reset Current Branch to Here, New Tag, Compare with Local).
*/
-import { useEffect, useState } from "react";
-import type { ChangedFile, Commit, ResetMode } from "@/bindings";
+import { useEffect, useMemo, useState } from "react";
+import type { ChangedFile, Commit, CompareResult, ResetMode, WorkingTreeChange } from "@/bindings";
import { executeAction } from "@/platform/actions";
-import { call, commands } from "@/platform/ipc";
-import { Checkbox, Dialog, Icon, Input, List, Spinner, fileIconName, T } from "@/ui";
+import { call, commands, nextRequestId } from "@/platform/ipc";
+import { Checkbox, Dialog, Icon, Input, Tree, Spinner, fileIconName, T } from "@/ui";
import { notifications } from "@/workbench/contributions";
-import { openDiff, type DiffSide } from "./diffInput";
+import { diffInput, openDiff, type DiffData, type DiffSide } from "./diffInput";
import { openDialog, promptText } from "./dialogs";
-import { KIND_COLOR, baseName, dirName } from "./model";
+import { KIND_COLOR, fileCount } from "./model";
import { runGitOperation, runOp } from "./ops";
import { reloadLog, useGitLog } from "./logStore";
-import { conflictedFiles, currentRepo, currentRepoRoot, refreshNow, repoOf, useVcs } from "./store";
+import { conflictedFiles, currentRepo, currentRepoRoot, refreshNow, repoName, repoOf, useVcs } from "./store";
import styles from "./common.module.css";
+import { DiffEditor } from "./DiffEditor";
+import { buildFileTree, dirKeys, type FileTreeNode } from "./fileTree";
import { tx } from "@/platform/i18n";
+import { displayPath } from "./compare";
// ---------------------------------------------------------------------------
// Operation in progress
@@ -479,102 +482,236 @@ export function showCompareRevisions(from: string, to: string, fromLabel = from,
));
}
+export function showPathComparison(paths: string[], rev: string, repositories: string[] | null) {
+ openDialog((close) => (
+ <ChangesBetweenDialog from={{ rev, label: rev }} to={null} scope={{ paths, repositories }} onClose={close} />
+ ));
+}
+
interface Revision {
rev: string;
label: string;
}
-/** Files that differ between `from` and `to` (`null`: the working tree). */
-function ChangesBetweenDialog({ from, to, onClose }: { from: Revision; to: Revision | null; onClose: () => void }) {
+interface ScopedComparison {
+ paths: string[];
+ repositories: string[] | null;
+}
+
+interface ComparisonFile extends ChangedFile {
+ root: string;
+ revision: string;
+ added?: number;
+ removed?: number;
+}
+
+export function comparisonEmpty(revision: string, repositories: number): string {
+ return repositories === 1
+ ? tx`No changes against ${revision} in 1 repository`
+ : tx`No changes against ${revision} in ${repositories} repositories`;
+}
+
+/** Shared branch/commit comparison surface, also used for directory selections. */
+export function ChangesBetweenDialog({
+ from,
+ to,
+ scope,
+ onClose,
+}: {
+ from: Revision;
+ to: Revision | null;
+ scope?: ScopedComparison;
+ onClose: () => void;
+}) {
const [root] = useState(currentRepoRoot);
const [repo] = useState(currentRepo);
- const [files, setFiles] = useState<ChangedFile[] | null>(null);
+ const [files, setFiles] = useState<ComparisonFile[] | null>(null);
+ const [result, setResult] = useState<CompareResult | null>(null);
const [error, setError] = useState<string | null>(null);
- const [active, setActive] = useState(0);
+ const [selected, setSelected] = useState<ReadonlySet<string>>(new Set());
+ const [expanded, setExpanded] = useState<ReadonlySet<string> | null>(null);
+ const [current, setCurrent] = useState<ComparisonFile | null>(null);
const fromRev = from.rev;
const toRev = to?.rev ?? null;
useEffect(() => {
let alive = true;
- call(toRev ? commands.vcsDiffRevisions(repo, fromRev, toRev) : commands.vcsDiffWithWorktree(repo, fromRev))
- .then((f) => alive && setFiles(f))
- .catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));
+ let pending = true;
+ const request = nextRequestId();
+ const load = async () => {
+ if (scope) {
+ const r = await call(commands.vcsComparePaths(scope.paths, fromRev, scope.repositories, request));
+ if (!alive) return;
+ setResult(r);
+ setFiles(
+ r.repositories.flatMap((r) =>
+ r.files.map((f: WorkingTreeChange) => ({ ...f, root: r.root, revision: r.revision! })),
+ ),
+ );
+ } else {
+ const f = await call(
+ toRev ? commands.vcsDiffRevisions(repo, fromRev, toRev) : commands.vcsDiffWithWorktree(repo, fromRev),
+ );
+ if (alive) setFiles(f.map((f) => ({ ...f, root: root ?? "", revision: fromRev })));
+ }
+ };
+ void load()
+ .catch((e) => alive && setError(e instanceof Error ? e.message : String(e)))
+ .finally(() => {
+ pending = false;
+ });
return () => {
alive = false;
+ if (scope && pending) void commands.cancelRequest(request);
};
- }, [fromRev, toRev]);
- const open = (f: ChangedFile) => {
- const repoRoot = root;
+ }, [fromRev, toRev, repo, root, scope]);
+ const tree = useMemo(() => {
+ if (!scope) return buildFileTree(files ?? [], (f) => f.path);
+ return (result?.repositories ?? []).map((r): FileTreeNode<ComparisonFile> => {
+ const list = (files ?? []).filter((f) => f.root === r.root);
+ const prefix = (nodes: FileTreeNode<ComparisonFile>[]): FileTreeNode<ComparisonFile>[] =>
+ nodes.map((n) => ({ ...n, key: `${r.root}:${n.key}`, children: prefix(n.children) }));
+ return {
+ key: r.root,
+ name: repoName(r.root),
+ file: null,
+ count: list.length,
+ children: prefix(buildFileTree(list, (f) => f.path)),
+ };
+ });
+ }, [files, result, scope]);
+ const diffFor = (f: ComparisonFile): DiffData => {
const missing = (label: string): DiffSide => ({ type: "text", text: "", label });
- void openDiff({
- path: `${repoRoot}/${f.path}`,
+ return {
+ path: `${f.root}/${f.path}`,
left:
f.kind === "added" || f.kind === "untracked"
? missing("(does not exist)")
- : { type: "rev", rev: from.rev, label: from.label, path: f.oldPath ? `${repoRoot}/${f.oldPath}` : undefined },
- right: !to
- ? { type: "worktree" }
- : f.kind === "deleted"
+ : {
+ type: "rev",
+ rev: f.revision,
+ label: from.label,
+ path: f.oldPath ? `${f.root}/${f.oldPath}` : undefined,
+ },
+ right:
+ f.kind === "deleted"
? missing("(deleted)")
- : { type: "rev", rev: to.rev, label: to.label },
- });
+ : !to
+ ? { type: "worktree" }
+ : { type: "rev", rev: to.rev, label: to.label },
+ };
};
- const current = files?.[active];
+ const input = current ? diffInput(diffFor(current)) : null;
+ const title = to
+ ? tx`Changes between ${from.label} and ${to.label}`
+ : tx`Changes between ${from.label} and Local Working Tree`;
+ const count = files ? fileCount(files.length) : "";
+ const successful = result?.repositories.filter((r) => !r.error && !r.missingRevision).length ?? 1;
+ const allMissing = !!result?.repositories.length && result.repositories.every((r) => r.missingRevision);
+ const skipped = result?.skippedPaths.map((path) => displayPath(path)) ?? [];
+ const skippedNames = skipped.slice(0, 5).join(", ");
+ const skippedLabel = skipped.length > 5 ? tx`${skippedNames} and ${skipped.length - 5} more` : skippedNames;
return (
<Dialog
open
- title={
- to
- ? tx`Changes between ${from.label} and ${to.label}`
- : tx`Changes between ${from.label} and Local Working Tree`
- }
+ title={files ? `${title} — ${count}` : title}
onClose={onClose}
- width={620}
+ width={input ? 1100 : 680}
buttons={[
- { label: "Show Diff", role: "default", disabled: !current, onClick: () => current && open(current) },
+ {
+ label: "Show Diff",
+ role: "default",
+ disabled: !current,
+ onClick: () => {
+ if (current) {
+ void openDiff(diffFor(current));
+ onClose();
+ }
+ },
+ },
{ label: "Close", role: "cancel" },
]}
>
- <div className={styles.section}>{files ? `${files.length} file${files.length === 1 ? "" : "s"} differ` : ""}</div>
- <div style={{ height: 300, display: "flex", flexDirection: "column", padding: "0 14px 14px" }}>
- {error ? (
- <div className={styles.error}>{error}</div>
- ) : !files ? (
- <div className={styles.empty}>
- <Spinner size={14} />
- </div>
- ) : (
- <List
- items={files}
- getKey={(f) => f.path}
- activeIndex={Math.min(active, Math.max(0, files.length - 1))}
- onActiveChange={setActive}
- rowHeight={22}
- aria-label="Changed files"
- className={styles.boxList}
- empty={
- <span>
- <T>No differences</T>
- </span>
- }
- onActivate={(f, _i, e) => {
- if (e.type === "click" && (e as unknown as MouseEvent).detail < 2) return;
- open(f);
+ {error && (
+ <div className={styles.error} role="alert">
+ {error}
+ </div>
+ )}
+ {result?.skippedPaths.length ? (
+ <div className={styles.compareNotice}>{tx`Skipped content outside Git repositories: ${skippedLabel}`}</div>
+ ) : null}
+ {allMissing ? (
+ <div className={styles.empty} role="status">
+ {tx`No repository in the selection has revision ${from.label}`}
+ </div>
+ ) : (
+ result?.repositories
+ .filter((r) => r.error || r.missingRevision)
+ .map((r) => (
+ <div key={r.root} className={styles.compareNotice} role={r.missingRevision ? "status" : "alert"}>
+ {r.missingRevision
+ ? tx`${repoName(r.root)} has no revision ${from.label}`
+ : tx`Cannot compare ${repoName(r.root)} against ${from.label}: ${r.error}`}
+ </div>
+ ))
+ )}
+ {!files && !error ? (
+ <div className={styles.empty}>
+ <Spinner size={14} />
+ </div>
+ ) : null}
+ {files && !files.length && successful > 0 ? (
+ <div className={styles.empty} role="status">
+ {comparisonEmpty(from.label, successful)}
+ </div>
+ ) : null}
+ {files && files.length > 0 ? (
+ <div className={`${styles.comparison} ${input ? styles.comparisonWithDiff : ""}`}>
+ <Tree<FileTreeNode<ComparisonFile>>
+ roots={tree}
+ getKey={(n) => n.key}
+ getLabel={(n) => n.name}
+ getChildren={(n) => (n.file ? undefined : n.children)}
+ isExpandable={(n) => !n.file}
+ expanded={expanded ?? new Set(dirKeys(tree))}
+ onExpandedChange={setExpanded}
+ selected={selected}
+ onSelectionChange={(sel, lead) => {
+ setSelected(sel);
+ if (lead?.file) setCurrent(lead.file);
}}
- renderItem={(f) => (
- <span className={styles.fileRow} style={{ flex: 1, padding: 0 }}>
- <Icon name={fileIconName(baseName(f.path))} size={14} />
+ onActivate={(n) => n.file && setCurrent(n.file)}
+ aria-label="Changed files"
+ className={styles.comparisonTree}
+ renderNode={(n) => (
+ <span className={styles.fileRow} style={{ flex: 1, padding: 0 }} title={n.file ? n.file.path : n.name}>
+ <Icon name={n.file ? fileIconName(n.name) : "folder"} size={14} />
<span
className={styles.fileName}
- style={{ color: KIND_COLOR[f.kind === "untracked" ? "added" : f.kind] }}
+ style={
+ n.file ? { color: KIND_COLOR[n.file.kind === "untracked" ? "added" : n.file.kind] } : undefined
+ }
>
- {baseName(f.path)}
+ {n.name}
</span>
- <span className={styles.fileDir}>{dirName(f.path)}</span>
+ {n.file ? (
+ <>
+ <span className={styles.fileDir}>{tx(n.file.kind)}</span>
+ {n.file.added !== undefined && <span className={styles.compareAdded}>+{n.file.added}</span>}
+ {n.file.removed !== undefined && <span className={styles.compareRemoved}>−{n.file.removed}</span>}
+ </>
+ ) : (
+ <span className={styles.fileDir}>{n.count}</span>
+ )}
</span>
)}
/>
- )}
- </div>
+ {input && (
+ <div className={styles.comparisonDiff}>
+ <DiffEditor key={input.key} input={input} />
+ </div>
+ )}
+ </div>
+ ) : null}
</Dialog>
);
}
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 2a06b1156..95a21800a 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5348,5 +5348,15 @@
"No debug output available": "暂无可用的调试输出",
"The attached process may not provide standard output to the debugger.": "附加的进程可能不会向调试器提供标准输出。",
"Show in Debug Tool Window": "在调试工具窗口中显示",
- "Suspended": "已暂停"
+ "Suspended": "已暂停",
+ "Cannot compare {root} against {label}: {error}": "无法将 {root} 与 {label} 比较:{error}",
+ "Compare with Branch or Revision": "与分支或修订比较",
+ "No changes against {revision} in 1 repository": "在 1 个仓库中与 {revision} 相比没有更改",
+ "No changes against {revision} in {repositories} repositories": "在 {repositories} 个仓库中与 {revision} 相比没有更改",
+ "Open or select a file or folder to compare": "打开或选择要比较的文件或文件夹",
+ "Selection is outside Git repositories": "所选内容不在 Git 仓库中",
+ "Skipped content outside Git repositories: {skippedLabel}": "已跳过 Git 仓库之外的内容:{skippedLabel}",
+ "in {length} repositories": "在 {length} 个仓库中",
+ "No repository in the selection has revision {label}": "所选内容中的仓库均无版本 {label}",
+ "{repoName} has no revision {label}": "{repoName} 没有版本 {label}"
}