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): Support several git repositories in one project (multi-root)

l0ng-ai059a5193ff27
diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rs
index 14f6f8f3f..4151a6c06 100644
--- a/crates/ide-vcs/src/lib.rs
+++ b/crates/ide-vcs/src/lib.rs
@@ -268,6 +268,7 @@ mod patch;
mod refs;
mod remotes;
mod repo;
+mod roots;
pub mod shelf;
mod status;
mod write;
@@ -275,6 +276,7 @@ mod write;
pub use cli::{detected_git_executable, git_version, set_git_executable};
pub use diff::build_partial_patch;
pub use remotes::Remote;
+pub use roots::Repos;
/// Clones `url` into `dest` (which must not exist or be empty), streaming progress.
pub fn clone(url: &str, dest: &Path, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {
@@ -320,6 +322,10 @@ impl Repo {
pub fn branch_info(&self) -> IdeResult<BranchInfo> {
refs::branch_info(self)
}
+ /// Merge / rebase / cherry-pick… in progress (cheap: no ref walking).
+ pub fn operation(&self) -> IdeResult<Option<String>> {
+ Ok(refs::operation(&self.gix()?))
+ }
/// Content of `path` at `rev` (default HEAD); `None` if absent there.
/// `rev` may be any revision git understands, or `":"` / `":0"` for the index.
pub fn file_at(&self, path: &Path, rev: Option<&str>) -> IdeResult<Option<String>> {
diff --git a/crates/ide-vcs/src/refs.rs b/crates/ide-vcs/src/refs.rs
index 985b353fb..5b7903054 100644
--- a/crates/ide-vcs/src/refs.rs
+++ b/crates/ide-vcs/src/refs.rs
@@ -30,7 +30,7 @@ pub(crate) fn branch_info(r: &Repo) -> IdeResult<BranchInfo> {
Ok(info)
}
-fn operation(repo: &gix::Repository) -> Option<String> {
+pub(crate) fn operation(repo: &gix::Repository) -> Option<String> {
use gix::state::InProgress::*;
let op = match repo.state()? {
ApplyMailbox | ApplyMailboxRebase => "am",
diff --git a/crates/ide-vcs/src/roots.rs b/crates/ide-vcs/src/roots.rs
new file mode 100644
index 000000000..d71abe72c
--- /dev/null
+++ b/crates/ide-vcs/src/roots.rs
@@ -0,0 +1,203 @@
+//! The repositories of a project (IDEA's VCS roots): the one containing the project
+//! root plus those nested below it (separate clones side by side, submodules).
+
+use crate::{FileStatus, Repo};
+use ide_core::IdeResult;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+
+/// How deep below the project root nested repositories are looked for.
+const MAX_DEPTH: usize = 4;
+
+/// Folders never searched for nested repositories (dependencies, build output).
+const SKIPPED: &[&str] = &["node_modules", "target", "build", "dist", "out", "vendor", "venv", "__pycache__"];
+
+/// The repositories of a project, sorted by root; lookups pick the innermost one.
+#[derive(Clone, Default)]
+pub struct Repos {
+ repos: Vec<Arc<Repo>>,
+ primary: Option<usize>,
+}
+
+impl Repos {
+ /// The repository containing `project_root` and every repository whose worktree
+ /// root lies below it (up to [`MAX_DEPTH`] levels; hidden and dependency folders and
+ /// folders `skip` rejects are not searched).
+ pub fn discover(project_root: &Path, skip: &dyn Fn(&Path) -> bool) -> IdeResult<Self> {
+ let mut repos: Vec<Repo> = Vec::new();
+ if let Some(r) = Repo::discover(project_root)? {
+ repos.push(r);
+ }
+ let mut stack: Vec<(PathBuf, usize)> = vec![(project_root.to_path_buf(), 0)];
+ while let Some((dir, depth)) = stack.pop() {
+ let Ok(entries) = std::fs::read_dir(&dir) else { continue };
+ for entry in entries.flatten() {
+ if !entry.file_type().is_ok_and(|t| t.is_dir()) {
+ continue;
+ }
+ let name = entry.file_name();
+ let name = name.to_string_lossy();
+ let path = entry.path();
+ if name.starts_with('.') || SKIPPED.contains(&name.as_ref()) || skip(&path) {
+ continue;
+ }
+ if path.join(".git").exists()
+ && let Ok(Some(r)) = Repo::discover(&path)
+ && r.root() == path
+ && !repos.iter().any(|x| x.root() == r.root())
+ {
+ repos.push(r);
+ }
+ if depth + 1 < MAX_DEPTH {
+ stack.push((path, depth + 1));
+ }
+ }
+ }
+ Ok(Self::new(repos, project_root))
+ }
+
+ /// Only the repository containing `project_root` (the quick lookup on project open).
+ pub fn enclosing(project_root: &Path) -> IdeResult<Self> {
+ Ok(Self::new(Repo::discover(project_root)?.into_iter().collect(), project_root))
+ }
+
+ /// Worktree roots, sorted.
+ pub fn roots(&self) -> Vec<PathBuf> {
+ self.repos.iter().map(|r| r.root().to_path_buf()).collect()
+ }
+
+ fn new(mut repos: Vec<Repo>, project_root: &Path) -> Self {
+ repos.sort_by(|a, b| a.root().cmp(b.root()));
+ let repos: Vec<Arc<Repo>> = repos.into_iter().map(Arc::new).collect();
+ let primary = Self::innermost(&repos, project_root).or((!repos.is_empty()).then_some(0));
+ Self { repos, primary }
+ }
+
+ fn innermost(repos: &[Arc<Repo>], path: &Path) -> Option<usize> {
+ repos
+ .iter()
+ .enumerate()
+ .filter(|(_, r)| path.starts_with(r.root()))
+ .max_by_key(|(_, r)| r.root().as_os_str().len())
+ .map(|(i, _)| i)
+ }
+
+ pub fn is_empty(&self) -> bool {
+ self.repos.is_empty()
+ }
+
+ pub fn all(&self) -> &[Arc<Repo>] {
+ &self.repos
+ }
+
+ /// The repository of the project root, else the first one.
+ pub fn primary(&self) -> Option<&Arc<Repo>> {
+ self.primary.map(|i| &self.repos[i])
+ }
+
+ /// The innermost repository containing `path` (a file, folder or repository root).
+ pub fn for_path(&self, path: &Path) -> Option<&Arc<Repo>> {
+ Self::innermost(&self.repos, path).map(|i| &self.repos[i]).or_else(|| {
+ // Another spelling of the same location (symlinks, /var vs /private/var).
+ let canon = dunce::canonicalize(path).ok()?;
+ self.repos
+ .iter()
+ .filter(|r| dunce::canonicalize(r.root()).is_ok_and(|root| canon.starts_with(root)))
+ .max_by_key(|r| r.root().as_os_str().len())
+ })
+ }
+
+ /// `paths` grouped by the repository each belongs to (paths outside every repository are dropped).
+ pub fn group(&self, paths: &[PathBuf]) -> Vec<(Arc<Repo>, Vec<PathBuf>)> {
+ let mut out: Vec<(Arc<Repo>, Vec<PathBuf>)> = Vec::new();
+ for p in paths {
+ let Some(repo) = self.for_path(p) else { continue };
+ match out.iter_mut().find(|(r, _)| Arc::ptr_eq(r, repo)) {
+ Some((_, list)) => list.push(p.clone()),
+ None => out.push((repo.clone(), vec![p.clone()])),
+ }
+ }
+ out
+ }
+
+ /// Changes of every repository. A nested repository reports its own files, so the
+ /// enclosing one's "untracked folder" entry for it is dropped.
+ pub fn status(&self) -> IdeResult<Vec<FileStatus>> {
+ let mut out = Vec::new();
+ for repo in &self.repos {
+ let nested: Vec<&Path> = self
+ .repos
+ .iter()
+ .map(|r| r.root())
+ .filter(|r| *r != repo.root() && r.starts_with(repo.root()))
+ .collect();
+ out.extend(repo.status()?.into_iter().filter(|f| {
+ let untracked_root =
+ f.unstaged == Some(crate::ChangeKind::Untracked) && nested.iter().any(|n| f.path.0 == *n);
+ !untracked_root
+ }));
+ }
+ Ok(out)
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use std::process::Command;
+
+ fn git_init(dir: &Path) {
+ std::fs::create_dir_all(dir).unwrap();
+ let ok = Command::new("git").args(["init", "-q"]).current_dir(dir).status().is_ok_and(|s| s.success());
+ assert!(ok, "git init in {}", dir.display());
+ }
+
+ #[test]
+ fn finds_nested_repositories_and_routes_paths() {
+ let tmp = tempfile::tempdir().unwrap();
+ let root = dunce::canonicalize(tmp.path()).unwrap();
+ git_init(&root);
+ git_init(&root.join("services/api"));
+ git_init(&root.join("web"));
+ git_init(&root.join("node_modules/dep"));
+ git_init(&root.join(".cache/repo"));
+ std::fs::write(root.join("services/api/main.rs"), "fn main() {}").unwrap();
+ std::fs::write(root.join("README.md"), "x").unwrap();
+
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ let roots: Vec<&Path> = repos.all().iter().map(|r| r.root()).collect();
+ assert_eq!(roots, [root.as_path(), &root.join("services/api"), &root.join("web")]);
+ assert_eq!(repos.primary().unwrap().root(), root);
+ assert_eq!(repos.for_path(&root.join("services/api/main.rs")).unwrap().root(), root.join("services/api"));
+ assert_eq!(repos.for_path(&root.join("services/other.txt")).unwrap().root(), root);
+
+ let status = repos.status().unwrap();
+ let paths: Vec<String> =
+ status.iter().map(|f| f.path.0.strip_prefix(&root).unwrap().to_string_lossy().into_owned()).collect();
+ assert!(paths.contains(&"README.md".to_owned()), "{paths:?}");
+ assert!(paths.contains(&"services/api/main.rs".to_owned()), "{paths:?}");
+ assert!(
+ !paths.iter().any(|p| p.trim_end_matches('/') == "web"),
+ "nested root is not an untracked folder: {paths:?}"
+ );
+
+ let groups = repos.group(&[root.join("README.md"), root.join("services/api/main.rs"), root.join("web/x")]);
+ assert_eq!(groups.len(), 3);
+ assert_eq!(groups[1].1, [root.join("services/api/main.rs")]);
+
+ let skipped = Repos::discover(&root, &|p| p.ends_with("services")).unwrap();
+ assert_eq!(skipped.all().len(), 2);
+ }
+
+ #[test]
+ fn side_by_side_repositories_without_an_enclosing_one() {
+ let tmp = tempfile::tempdir().unwrap();
+ let root = dunce::canonicalize(tmp.path()).unwrap();
+ git_init(&root.join("a"));
+ git_init(&root.join("b"));
+ let repos = Repos::discover(&root, &|_| false).unwrap();
+ assert_eq!(repos.all().len(), 2);
+ assert_eq!(repos.primary().unwrap().root(), root.join("a"), "the first when none contains the project root");
+ assert!(repos.for_path(&root.join("c.txt")).is_none());
+ }
+}
diff --git a/src-tauri/src/commands/app.rs b/src-tauri/src/commands/app.rs
index 34ed04aff..df5641283 100644
--- a/src-tauri/src/commands/app.rs
+++ b/src-tauri/src/commands/app.rs
@@ -71,7 +71,7 @@ pub async fn open_project(window: Window, path: PathBuf) -> IdeResult<ProjectInf
fn project_info(project: &crate::state::Project) -> ProjectInfo {
ProjectInfo {
name: project.root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default(),
- is_git: project.repo.lock().is_some(),
+ is_git: !project.repos.read().is_empty(),
settings: project.settings.effective(),
root: project.root.clone().into(),
}
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index e56caeb2f..4c4f60fab 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -129,6 +129,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
lsp::apply_workspace_edit,
lsp::lsp_execute_command,
vcs::vcs_status,
+ vcs::vcs_roots,
vcs::vcs_branch_info,
vcs::vcs_line_hunks,
vcs::vcs_file_at,
diff --git a/src-tauri/src/commands/vcs.rs b/src-tauri/src/commands/vcs.rs
index 196076c57..8fd0da6f6 100644
--- a/src-tauri/src/commands/vcs.rs
+++ b/src-tauri/src/commands/vcs.rs
@@ -1,4 +1,4 @@
-use crate::state::AppState;
+use crate::state::{AppState, Project};
use ide_core::{IdeResult, RequestId};
use ide_vcs::*;
use serde::{Deserialize, Serialize};
@@ -13,18 +13,59 @@ pub(crate) fn apply_git_executable(settings: &ide_core::settings::Settings) {
ide_vcs::set_git_executable((!exe.is_empty()).then(|| Path::new(exe)));
}
+/// Changes of every repository of the project.
#[tauri::command]
#[specta::specta]
pub async fn vcs_status(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<FileStatus>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.status())).await
+ blocking(move || {
+ let settings = project.settings.effective();
+ apply_git_executable(&settings);
+ let repos = project.repos();
+ if repos.is_empty() {
+ return Err(ide_core::IdeError::unavailable("project is not a git repository"));
+ }
+ for r in repos.all() {
+ r.set_ignored_names(settings.ignored_names());
+ }
+ repos.status()
+ })
+ .await
+}
+
+/// A repository of the project (IDEA's VCS root).
+#[derive(Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub struct VcsRoot {
+ /// Worktree root.
+ pub root: ide_core::IpcPath,
+ /// Merge / rebase / cherry-pick / revert in progress.
+ pub operation: Option<String>,
}
+/// The project's repositories, the primary one first.
#[tauri::command]
#[specta::specta]
-pub async fn vcs_branch_info(window: Window, state: State<'_, AppState>) -> IdeResult<BranchInfo> {
+pub fn vcs_roots(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<VcsRoot>> {
+ let repos = state.project(window.label())?.repos();
+ let primary = repos.primary().map(|r| r.root().to_path_buf());
+ let mut all: Vec<&std::sync::Arc<Repo>> = repos.all().iter().collect();
+ all.sort_by_key(|r| Some(r.root()) != primary.as_deref());
+ Ok(all
+ .into_iter()
+ .map(|r| VcsRoot { root: r.root().to_path_buf().into(), operation: r.operation().ok().flatten() })
+ .collect())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn vcs_branch_info(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+) -> IdeResult<BranchInfo> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.branch_info())).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branch_info())).await
}
/// Gutter change markers for a file, computed against its current (unsaved) text.
@@ -33,7 +74,7 @@ pub async fn vcs_branch_info(window: Window, state: State<'_, AppState>) -> IdeR
pub fn vcs_line_hunks(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<LineHunk>> {
let project = state.project(window.label())?;
let text = project.text_of(&path)?;
- project.with_repo(|r| r.line_hunks(&path, &text, false))
+ project.with_repo_at(Some(&path), |r| r.line_hunks(&path, &text, false))
}
#[tauri::command]
@@ -45,7 +86,7 @@ pub async fn vcs_file_at(
rev: Option<String>,
) -> IdeResult<Option<String>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.file_at(&path, rev.as_deref()))).await
+ blocking(move || project.with_repo_at(Some(&path), |r| r.file_at(&path, rev.as_deref()))).await
}
#[tauri::command]
@@ -53,14 +94,19 @@ pub async fn vcs_file_at(
pub async fn vcs_blame(window: Window, state: State<'_, AppState>, path: PathBuf) -> IdeResult<Vec<BlameLine>> {
let project = state.project(window.label())?;
let text = project.documents.text_of(&path);
- blocking(move || project.with_repo(|r| r.blame(&path, text.as_deref()))).await
+ blocking(move || project.with_repo_at(Some(&path), |r| r.blame(&path, text.as_deref()))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_log(window: Window, state: State<'_, AppState>, query: LogQuery) -> IdeResult<Vec<Commit>> {
+pub async fn vcs_log(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ query: LogQuery,
+) -> IdeResult<Vec<Commit>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.log(&query))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.log(&query))).await
}
#[tauri::command]
@@ -68,38 +114,39 @@ pub async fn vcs_log(window: Window, state: State<'_, AppState>, query: LogQuery
pub async fn vcs_commit_files(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
commit: String,
) -> IdeResult<Vec<ChangedFile>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.commit_files(&commit))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commit_files(&commit))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_branches(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<Branch>> {
+pub async fn vcs_branches(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Branch>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.branches())).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.branches())).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_stashes(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<Stash>> {
+pub async fn vcs_stashes(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<Stash>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.stashes())).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.stashes())).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_stage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.stage(&paths))).await
+ blocking(move || per_repo(&project, &paths, None, |r, paths| r.stage(paths))).await
}
#[tauri::command]
#[specta::specta]
pub async fn vcs_unstage(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.unstage(&paths))).await
+ blocking(move || per_repo(&project, &paths, None, |r, paths| r.unstage(paths))).await
}
#[tauri::command]
@@ -113,7 +160,7 @@ pub async fn vcs_stage_patch(window: Window, state: State<'_, AppState>, patch:
#[specta::specta]
pub async fn vcs_discard(window: Window, state: State<'_, AppState>, paths: Vec<PathBuf>) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo_recorded(Some("Rollback"), |r| r.discard(&paths))).await
+ blocking(move || per_repo(&project, &paths, Some("Rollback"), |r, paths| r.discard(paths))).await
}
#[tauri::command]
@@ -121,19 +168,27 @@ pub async fn vcs_discard(window: Window, state: State<'_, AppState>, paths: Vec<
pub async fn vcs_commit(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
message: String,
options: CommitOptions,
) -> IdeResult<String> {
// Commit hooks may run for a long time.
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.commit_with(&message, &options))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.commit_with(&message, &options))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_checkout(window: Window, state: State<'_, AppState>, branch: String, create: bool) -> IdeResult<()> {
+pub async fn vcs_checkout(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ branch: String,
+ create: bool,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo_recorded(Some("Git checkout"), |r| r.checkout(&branch, create))).await
+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git checkout"), |r| r.checkout(&branch, create)))
+ .await
}
/// New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out.
@@ -142,22 +197,31 @@ pub async fn vcs_checkout(window: Window, state: State<'_, AppState>, branch: St
pub async fn vcs_create_branch(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
name: String,
start: Option<String>,
checkout: bool,
) -> IdeResult<()> {
let project = state.project(window.label())?;
let recorded = checkout.then_some("Git checkout");
- blocking(move || project.with_repo_recorded(recorded, |r| r.create_branch(&name, start.as_deref(), checkout))).await
+ blocking(move || {
+ project.with_repo_recorded(repo.as_deref(), recorded, |r| r.create_branch(&name, start.as_deref(), checkout))
+ })
+ .await
}
/// Undo Commit: moves HEAD back to the commit's parent, keeping its changes staged.
/// Returns the undone commit's message.
#[tauri::command]
#[specta::specta]
-pub async fn vcs_undo_commit(window: Window, state: State<'_, AppState>, commit: String) -> IdeResult<String> {
+pub async fn vcs_undo_commit(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ commit: String,
+) -> IdeResult<String> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.undo_commit(&commit))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.undo_commit(&commit))).await
}
#[tauri::command]
@@ -165,32 +229,49 @@ pub async fn vcs_undo_commit(window: Window, state: State<'_, AppState>, commit:
pub async fn vcs_delete_branch(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
branch: String,
force: bool,
) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.delete_branch(&branch, force))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.delete_branch(&branch, force))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_rename_branch(window: Window, state: State<'_, AppState>, from: String, to: String) -> IdeResult<()> {
+pub async fn vcs_rename_branch(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ from: String,
+ to: String,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.rename_branch(&from, &to))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.rename_branch(&from, &to))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_merge(window: Window, state: State<'_, AppState>, branch: String) -> IdeResult<()> {
+pub async fn vcs_merge(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ branch: String,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo_recorded(Some("Git merge"), |r| r.merge(&branch))).await
+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git merge"), |r| r.merge(&branch))).await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_rebase(window: Window, state: State<'_, AppState>, onto: String) -> IdeResult<()> {
+pub async fn vcs_rebase(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ onto: String,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo_recorded(Some("Git rebase"), |r| r.rebase(&onto))).await
+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git rebase"), |r| r.rebase(&onto))).await
}
#[tauri::command]
@@ -198,28 +279,43 @@ pub async fn vcs_rebase(window: Window, state: State<'_, AppState>, onto: String
pub async fn vcs_stash_push(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
message: Option<String>,
include_untracked: bool,
) -> IdeResult<()> {
let project = state.project(window.label())?;
blocking(move || {
- project.with_repo_recorded(Some("Git stash"), |r| r.stash_push(message.as_deref(), include_untracked))
+ project.with_repo_recorded(repo.as_deref(), Some("Git stash"), |r| {
+ r.stash_push(message.as_deref(), include_untracked)
+ })
})
.await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_stash_apply(window: Window, state: State<'_, AppState>, index: u32, pop: bool) -> IdeResult<()> {
+pub async fn vcs_stash_apply(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ index: u32,
+ pop: bool,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo_recorded(Some("Git unstash"), |r| r.stash_apply(index, pop))).await
+ blocking(move || project.with_repo_recorded(repo.as_deref(), Some("Git unstash"), |r| r.stash_apply(index, pop)))
+ .await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_stash_drop(window: Window, state: State<'_, AppState>, index: u32) -> IdeResult<()> {
+pub async fn vcs_stash_drop(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ index: u32,
+) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.stash_drop(index))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.stash_drop(index))).await
}
#[derive(Clone, Serialize, Deserialize, Type)]
@@ -258,6 +354,7 @@ pub enum RemoteOp {
pub async fn vcs_remote(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
request: RequestId,
op: RemoteOp,
on_output: Channel<String>,
@@ -269,7 +366,7 @@ pub async fn vcs_remote(
let _ = on_output.send(line);
};
let recorded = matches!(op, RemoteOp::Pull { .. }).then_some("Git pull");
- project.with_repo_recorded(recorded, |r| match op {
+ project.with_repo_recorded(repo.as_deref(), recorded, |r| match op {
RemoteOp::Fetch => r.fetch(&cancel, &out),
RemoteOp::Pull { rebase } => r.pull(rebase, &cancel, &out),
RemoteOp::Push { force_with_lease, set_upstream, tags } => {
@@ -304,7 +401,7 @@ pub async fn vcs_conflict_versions(
) -> IdeResult<ConflictVersions> {
let project = state.project(window.label())?;
blocking(move || {
- project.with_repo(|r| {
+ project.with_repo_at(Some(&path), |r| {
r.conflict_versions(&path).map(|(base, ours, theirs)| ConflictVersions { base, ours, theirs })
})
})
@@ -320,7 +417,7 @@ pub async fn vcs_diff_text(
staged: bool,
) -> IdeResult<String> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.diff_text(&path, staged))).await
+ blocking(move || project.with_repo_at(Some(&path), |r| r.diff_text(&path, staged))).await
}
/// Line hunks between two arbitrary texts (diff viewer, commit dialog).
@@ -337,7 +434,7 @@ pub fn vcs_diff_hunks(old_text: String, new_text: String) -> Vec<LineHunk> {
pub fn vcs_stage_hunks(window: Window, state: State<'_, AppState>, path: PathBuf, hunks: Vec<u32>) -> IdeResult<()> {
let project = state.project(window.label())?;
let current = ide_vfs::load_text(&path)?.text;
- project.with_repo(|r| {
+ project.with_repo_at(Some(&path), |r| {
let index_text = r.file_at(&path, Some(":0"))?.unwrap_or_default();
let rel = path.strip_prefix(r.root()).unwrap_or(&path).to_string_lossy().replace('\\', "/");
let selected: Vec<usize> = hunks.iter().map(|&h| h as usize).collect();
@@ -408,9 +505,14 @@ pub fn vcs_detected_git() -> Option<String> {
/// `git config --get <key>` in the project repository; `None` when unset.
#[tauri::command]
#[specta::specta]
-pub async fn vcs_config_get(window: Window, state: State<'_, AppState>, key: String) -> IdeResult<Option<String>> {
+pub async fn vcs_config_get(
+ window: Window,
+ state: State<'_, AppState>,
+ repo: Option<PathBuf>,
+ key: String,
+) -> IdeResult<Option<String>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.config_get(&key))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.config_get(&key))).await
}
// ---- in-progress operations, history rewriting (Git Log actions) ----
@@ -448,6 +550,7 @@ pub enum GitOperation {
pub async fn vcs_operation(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
request: RequestId,
op: GitOperation,
on_output: Channel<String>,
@@ -465,7 +568,7 @@ pub async fn vcs_operation(
GitOperation::InteractiveRebase { .. } => Some("Git rebase"),
_ => None,
};
- project.with_repo_recorded(recorded, |r| match op {
+ project.with_repo_recorded(repo.as_deref(), recorded, |r| match op {
GitOperation::Continue => r.continue_operation(&cancel, &out),
GitOperation::Abort => r.abort_operation(&cancel, &out),
GitOperation::Skip => r.skip_operation(&cancel, &out),
@@ -488,20 +591,22 @@ pub async fn vcs_operation(
pub async fn vcs_create_tag(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
name: String,
commit: String,
message: Option<String>,
force: bool,
) -> IdeResult<()> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.create_tag(&name, &commit, message.as_deref(), force))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.create_tag(&name, &commit, message.as_deref(), force)))
+ .await
}
#[tauri::command]
#[specta::specta]
-pub async fn vcs_tags(window: Window, state: State<'_, AppState>) -> IdeResult<Vec<String>> {
+pub async fn vcs_tags(window: Window, state: State<'_, AppState>, repo: Option<PathBuf>) -> IdeResult<Vec<String>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.tags())).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.tags())).await
}
/// Compare with Local: tracked files that differ between `rev` and the working tree.
@@ -510,10 +615,28 @@ pub async fn vcs_tags(window: Window, state: State<'_, AppState>) -> IdeResult<V
pub async fn vcs_diff_with_worktree(
window: Window,
state: State<'_, AppState>,
+ repo: Option<PathBuf>,
rev: String,
) -> IdeResult<Vec<ChangedFile>> {
let project = state.project(window.label())?;
- blocking(move || project.with_repo(|r| r.diff_with_worktree(&rev))).await
+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.diff_with_worktree(&rev))).await
+}
+
+/// Runs `f` once per repository with the `paths` that belong to it.
+fn per_repo(
+ project: &Project,
+ paths: &[PathBuf],
+ recorded: Option<&str>,
+ f: impl Fn(&Repo, &[PathBuf]) -> IdeResult<()>,
+) -> IdeResult<()> {
+ let groups = project.repos().group(paths);
+ if groups.is_empty() {
+ return project.with_repo_recorded(None, recorded, |r| f(r, paths));
+ }
+ for (repo, paths) in groups {
+ project.with_repo_recorded(Some(repo.root()), recorded, |r| f(r, &paths))?;
+ }
+ Ok(())
}
async fn blocking<T: Send + 'static>(f: impl FnOnce() -> IdeResult<T> + Send + 'static) -> IdeResult<T> {
@@ -587,7 +710,7 @@ pub async fn vcs_shelve(
let project = state.project(window.label())?;
blocking(move || {
keep_private(&project.root);
- project.with_repo_recorded(Some("Shelve"), |r| r.shelve(&shelf_dir(&project.root), &name, &paths))
+ project.with_repo_recorded(None, Some("Shelve"), |r| r.shelve(&shelf_dir(&project.root), &name, &paths))
})
.await
}
@@ -611,7 +734,7 @@ pub async fn vcs_unshelve(
) -> IdeResult<ApplyOutcome> {
let project = state.project(window.label())?;
blocking(move || {
- project.with_repo_recorded(Some("Unshelve"), |r| r.unshelve(&shelf_dir(&project.root), &id, remove))
+ project.with_repo_recorded(None, Some("Unshelve"), |r| r.unshelve(&shelf_dir(&project.root), &id, remove))
})
.await
}
diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs
index 02fd62738..5fe94c1d1 100644
--- a/src-tauri/src/state.rs
+++ b/src-tauri/src/state.rs
@@ -8,7 +8,7 @@ use ide_run::ProcessManager;
use ide_syntax::StructureService;
use ide_terminal::TerminalManager;
use ide_text::{AppliedChange, ByteEdit};
-use ide_vcs::Repo;
+use ide_vcs::{Repo, Repos};
use ide_vfs::Watcher;
use ide_workspace::documents::DocumentObserver;
use ide_workspace::{
@@ -56,7 +56,8 @@ pub struct Project {
pub moves: FileMoves,
pub index: Arc<ProjectIndex>,
pub lsp: Arc<LspManager>,
- pub repo: Mutex<Option<Repo>>,
+ /// Git repositories: the one containing the project root and those nested below it.
+ pub repos: Arc<RwLock<Repos>>,
/// Incrementally maintained syntax trees of the open documents.
pub syntax: Arc<SyntaxCache>,
/// Tree-sitter structure queries (LSP fallback) over `syntax`.
@@ -279,7 +280,10 @@ impl AppState {
documents.add_observer(Arc::new(LspObserver(lsp.clone())));
documents.add_observer(Arc::new(HistoryObserver(history.clone())));
+ let repos = Arc::new(RwLock::new(Repos::enclosing(&root)?));
let watcher = {
+ let repos = repos.clone();
+ let settings = settings.clone();
let index = index.clone();
let documents = documents.clone();
let sink = sink.clone();
@@ -305,6 +309,12 @@ impl AppState {
sink.emit(IdeEvent::ProjectRootsChanged { root: root.clone().into() });
}
}
+ // A repository was cloned / initialised / removed below the project.
+ let git_dirs =
+ changed.iter().chain(&batch.removed).any(|p| p.file_name().is_some_and(|n| n == ".git"));
+ if git_dirs {
+ scan_repositories(&root, &repos, &settings, &sink);
+ }
sink.emit(IdeEvent::VcsChanged { root: root.clone().into() });
}),
)?
@@ -331,8 +341,13 @@ impl AppState {
};
mark("watcher");
- let repo = Repo::discover(&root)?;
- let branch = repo.as_ref().and_then(|r| r.branch_info().ok()).and_then(|b| b.head);
+ let branch = repos.read().primary().and_then(|r| r.branch_info().ok()).and_then(|b| b.head);
+ {
+ let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());
+ std::thread::Builder::new()
+ .name("openidea-vcs-roots".into())
+ .spawn(move || scan_repositories(&root, &repos, &settings, &sink))?;
+ }
mark("git");
self.recent.touch(&root, branch)?;
mark("recent");
@@ -349,7 +364,7 @@ impl AppState {
moves: FileMoves::new(),
index,
lsp,
- repo: Mutex::new(repo),
+ repos,
structure: Arc::new(StructureService::new(syntax.clone())),
syntax,
detected_roots,
@@ -391,12 +406,39 @@ impl AppState {
}
}
+/// Looks for repositories nested below the project (and the one containing it);
+/// emits `VcsChanged` when the set of roots changed.
+fn scan_repositories(root: &Path, repos: &RwLock<Repos>, settings: &SettingsStore, sink: &SharedSink) {
+ let ignored = settings.effective().ignored_names();
+ let skip = |p: &Path| p.file_name().is_some_and(|n| ignored.is_ignored_name(&n.to_string_lossy()));
+ match Repos::discover(root, &skip) {
+ Ok(found) => {
+ if found.roots() != repos.read().roots() {
+ *repos.write() = found;
+ sink.emit(IdeEvent::VcsChanged { root: root.to_path_buf().into() });
+ }
+ }
+ Err(e) => tracing::warn!("looking for git repositories: {e}"),
+ }
+}
+
impl Project {
- /// Runs `f` with the git repository, or fails when the project is not under git.
- pub fn with_repo<T>(&self, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {
+ /// The project's git repositories.
+ pub fn repos(&self) -> Repos {
+ self.repos.read().clone()
+ }
+
+ /// Runs `f` with the repository containing `at` (a path in it or its root), the
+ /// project's primary repository when `None`; fails when there is none.
+ pub fn with_repo_at<T>(&self, at: Option<&Path>, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {
let settings = self.settings.effective();
crate::commands::vcs::apply_git_executable(&settings);
- match self.repo.lock().as_ref() {
+ let repos = self.repos();
+ let repo = match at {
+ Some(path) => repos.for_path(path),
+ None => repos.primary(),
+ };
+ match repo {
Some(repo) => {
repo.set_ignored_names(settings.ignored_names());
f(repo)
@@ -405,25 +447,31 @@ impl Project {
}
}
+ /// Runs `f` with the project's primary git repository, or fails when the project is not under git.
+ pub fn with_repo<T>(&self, f: impl FnOnce(&Repo) -> IdeResult<T>) -> IdeResult<T> {
+ self.with_repo_at(None, f)
+ }
+
/// Runs a VCS operation that rewrites the working tree (checkout, merge,
/// rebase, pull, reset, stash, rollback): Local History gets a label and a
/// snapshot of every locally changed file before, and a label after.
/// `None` runs `f` like [`with_repo`](Self::with_repo) (operations that keep the working tree).
pub fn with_repo_recorded<T>(
&self,
+ at: Option<&Path>,
operation: Option<&str>,
f: impl FnOnce(&Repo) -> IdeResult<T>,
) -> IdeResult<T> {
- let Some(name) = operation else { return self.with_repo(f) };
+ let Some(name) = operation else { return self.with_repo_at(at, f) };
self.history_label(&format!("Before {name}"));
- if let Ok(changed) = self.with_repo(|r| r.status()) {
+ if let Ok(changed) = self.with_repo_at(at, |r| r.status()) {
for file in changed.iter().take(HISTORY_BATCH_LIMIT) {
if let Err(e) = self.history.record_file(&file.path, &format!("Before {name}"), false) {
tracing::debug!("local history: {e}");
}
}
}
- let result = self.with_repo(f);
+ let result = self.with_repo_at(at, f);
self.history_label(&format!("After {name}"));
result
}
diff --git a/src/bindings.ts b/src/bindings.ts
index c5ce3d46e..2afc23058 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -251,37 +251,39 @@ export const commands = {
lspExecuteCommand: (doc: DocId, command: Command) => typedError<null, IdeError>(__TAURI_INVOKE("lsp_execute_command", { doc, command })),
/** Changes of every repository of the project. */
vcsStatus: () => typedError<FileStatus[], IdeError>(__TAURI_INVOKE("vcs_status")),
- vcsBranchInfo: () => typedError<BranchInfo, IdeError>(__TAURI_INVOKE("vcs_branch_info")),
+ /** The project's repositories, the primary one first. */
+ vcsRoots: () => typedError<VcsRoot[], IdeError>(__TAURI_INVOKE("vcs_roots")),
+ vcsBranchInfo: (repo: string | null) => typedError<BranchInfo, IdeError>(__TAURI_INVOKE("vcs_branch_info", { repo })),
/** Gutter change markers for a file, computed against its current (unsaved) text. */
vcsLineHunks: (path: string) => typedError<LineHunk[], IdeError>(__TAURI_INVOKE("vcs_line_hunks", { path })),
vcsFileAt: (path: string, rev: string | null) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_file_at", { path, rev })),
vcsBlame: (path: string) => typedError<BlameLine[], IdeError>(__TAURI_INVOKE("vcs_blame", { path })),
- vcsLog: (query: LogQuery) => typedError<Commit[], IdeError>(__TAURI_INVOKE("vcs_log", { query })),
- vcsCommitFiles: (commit: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_commit_files", { commit })),
- vcsBranches: () => typedError<Branch[], IdeError>(__TAURI_INVOKE("vcs_branches")),
- vcsStashes: () => typedError<Stash[], IdeError>(__TAURI_INVOKE("vcs_stashes")),
+ vcsLog: (repo: string | null, query: LogQuery) => typedError<Commit[], IdeError>(__TAURI_INVOKE("vcs_log", { repo, query })),
+ vcsCommitFiles: (repo: string | null, commit: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_commit_files", { repo, commit })),
+ vcsBranches: (repo: string | null) => typedError<Branch[], IdeError>(__TAURI_INVOKE("vcs_branches", { repo })),
+ vcsStashes: (repo: string | null) => typedError<Stash[], IdeError>(__TAURI_INVOKE("vcs_stashes", { repo })),
vcsStage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage", { paths })),
vcsUnstage: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_unstage", { paths })),
vcsStagePatch: (patch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stage_patch", { patch })),
vcsDiscard: (paths: string[]) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_discard", { paths })),
- vcsCommit: (message: string, options: CommitOptions) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_commit", { message, options })),
- vcsCheckout: (branch: string, create: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_checkout", { branch, create })),
- vcsDeleteBranch: (branch: string, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_delete_branch", { branch, force })),
+ vcsCommit: (repo: string | null, message: string, options: CommitOptions) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_commit", { repo, message, options })),
+ vcsCheckout: (repo: string | null, branch: string, create: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_checkout", { repo, branch, create })),
+ vcsDeleteBranch: (repo: string | null, branch: string, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_delete_branch", { repo, branch, force })),
/** New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out. */
- vcsCreateBranch: (name: string, start: string | null, checkout: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_branch", { name, start, checkout })),
+ vcsCreateBranch: (repo: string | null, name: string, start: string | null, checkout: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_branch", { repo, name, start, checkout })),
/**
* Undo Commit: moves HEAD back to the commit's parent, keeping its changes staged.
* Returns the undone commit's message.
*/
- vcsUndoCommit: (commit: string) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_undo_commit", { commit })),
- vcsRenameBranch: (from: string, to: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rename_branch", { from, to })),
- vcsMerge: (branch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_merge", { branch })),
- vcsRebase: (onto: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rebase", { onto })),
- vcsStashPush: (message: string | null, includeUntracked: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_push", { message, includeUntracked })),
- vcsStashApply: (index: number, pop: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_apply", { index, pop })),
- vcsStashDrop: (index: number) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_drop", { index })),
+ vcsUndoCommit: (repo: string | null, commit: string) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_undo_commit", { repo, commit })),
+ vcsRenameBranch: (repo: string | null, from: string, to: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rename_branch", { repo, from, to })),
+ vcsMerge: (repo: string | null, branch: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_merge", { repo, branch })),
+ vcsRebase: (repo: string | null, onto: string) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_rebase", { repo, onto })),
+ vcsStashPush: (repo: string | null, message: string | null, includeUntracked: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_push", { repo, message, includeUntracked })),
+ vcsStashApply: (repo: string | null, index: number, pop: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_apply", { repo, index, pop })),
+ vcsStashDrop: (repo: string | null, index: number) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_stash_drop", { repo, index })),
/** Network operation; progress lines stream through `on_output`. Cancellable. */
- vcsRemote: (request: RequestId, op: RemoteOp, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_remote", { request, op, onOutput })),
+ vcsRemote: (repo: string | null, request: RequestId, op: RemoteOp, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_remote", { repo, request, op, onOutput })),
vcsConflictVersions: (path: string) => typedError<ConflictVersions, IdeError>(__TAURI_INVOKE("vcs_conflict_versions", { path })),
vcsDiffText: (path: string, staged: boolean) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_diff_text", { path, staged })),
/** Line hunks between two arbitrary texts (diff viewer, commit dialog). */
@@ -301,16 +303,16 @@ export const commands = {
/** The auto-detected git executable (shown as the field's placeholder). */
vcsDetectedGit: () => __TAURI_INVOKE<string | null>("vcs_detected_git"),
/** `git config --get <key>` in the project repository; `None` when unset. */
- vcsConfigGet: (key: string) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_config_get", { key })),
+ vcsConfigGet: (repo: string | null, key: string) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_config_get", { repo, key })),
/**
* Local history operation that may take a while (hooks, large checkouts); git's
* output streams through `on_output`. Cancellable.
*/
- vcsOperation: (request: RequestId, op: GitOperation, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_operation", { request, op, onOutput })),
- vcsCreateTag: (name: string, commit: string, message: string | null, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_tag", { name, commit, message, force })),
- vcsTags: () => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_tags")),
+ vcsOperation: (repo: string | null, request: RequestId, op: GitOperation, onOutput: Channel<string>) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_operation", { repo, request, op, onOutput })),
+ vcsCreateTag: (repo: string | null, name: string, commit: string, message: string | null, force: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_tag", { repo, name, commit, message, force })),
+ vcsTags: (repo: string | null) => typedError<string[], IdeError>(__TAURI_INVOKE("vcs_tags", { repo })),
/** Compare with Local: tracked files that differ between `rev` and the working tree. */
- vcsDiffWithWorktree: (rev: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_with_worktree", { rev })),
+ vcsDiffWithWorktree: (repo: string | null, rev: string) => typedError<ChangedFile[], IdeError>(__TAURI_INVOKE("vcs_diff_with_worktree", { repo, rev })),
vcsCreatePatch: (source: PatchSource) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_create_patch", { source })),
vcsPatchPreview: (patch: string) => typedError<PatchFile[], IdeError>(__TAURI_INVOKE("vcs_patch_preview", { patch })),
vcsApplyPatch: (patch: string) => typedError<ApplyOutcome, IdeError>(__TAURI_INVOKE("vcs_apply_patch", { patch })),
@@ -3898,6 +3900,14 @@ export type VcsConfirmationSettings = {
onDelete?: string,
};
+/** A repository of the project (IDEA's VCS root). */
+export type VcsRoot = {
+ /** Worktree root. */
+ root: IpcPath,
+ /** Merge / rebase / cherry-pick / revert in progress. */
+ operation: string | null,
+};
+
/** Version Control (main page) and its sub-pages. */
export type VcsSettings = {
/** Colour folders that contain changed files (project tree, tabs). */
diff --git a/src/features/github/dialogs.tsx b/src/features/github/dialogs.tsx
index 1505d1524..7f6a49a1c 100644
--- a/src/features/github/dialogs.tsx
+++ b/src/features/github/dialogs.tsx
@@ -71,7 +71,7 @@ function CreateDialog(props: {
useEffect(() => {
let alive = true;
// Base candidates: branches of the remotes (without `origin/`), the default first.
- call(commands.vcsBranches())
+ call(commands.vcsBranches(null))
.then((branches) => {
const names = new Set<string>();
if (props.defaultBase) names.add(props.defaultBase);
diff --git a/src/features/github/ops.ts b/src/features/github/ops.ts
index c90d47d69..27805772d 100644
--- a/src/features/github/ops.ts
+++ b/src/features/github/ops.ts
@@ -89,7 +89,7 @@ export async function createPullRequest() {
let needsPush = true;
let title = "";
try {
- const info = await call(commands.vcsBranchInfo());
+ const info = await call(commands.vcsBranchInfo(null));
head = info.head;
needsPush = !info.upstream || info.ahead > 0;
if (head) title = head.replace(/^[^/]+\//, "").replace(/[-_]+/g, " ").replace(/^\w/, (c) => c.toUpperCase());
diff --git a/src/features/vcs/BranchWidget.module.css b/src/features/vcs/BranchWidget.module.css
index 4ac83eec5..ba171ece7 100644
--- a/src/features/vcs/BranchWidget.module.css
+++ b/src/features/vcs/BranchWidget.module.css
@@ -18,6 +18,48 @@
overflow: hidden;
text-overflow: ellipsis;
}
+.repo {
+ flex: none;
+ max-width: 120px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ color: var(--fg-muted);
+}
+.repo::after {
+ content: " /";
+ color: var(--fg-subtle);
+}
+.repos {
+ flex: none;
+ display: flex;
+ flex-wrap: wrap;
+ gap: 4px;
+ padding: 6px 8px;
+ border-bottom: 1px solid var(--border-popup);
+}
+.repoButton {
+ max-width: 160px;
+ height: 22px;
+ padding: 0 8px;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ white-space: nowrap;
+ border: none;
+ border-radius: var(--radius-small);
+ background: transparent;
+ color: var(--fg-secondary);
+ font: inherit;
+ font-size: var(--fs-small);
+ cursor: pointer;
+}
+.repoButton:hover {
+ background: var(--bg-hover);
+}
+.repoSelected,
+.repoSelected:hover {
+ background: var(--bg-selected);
+ color: var(--fg);
+}
.operation {
color: var(--warning);
font-size: var(--fs-tiny);
diff --git a/src/features/vcs/BranchWidget.tsx b/src/features/vcs/BranchWidget.tsx
index c91c575f3..64574a255 100644
--- a/src/features/vcs/BranchWidget.tsx
+++ b/src/features/vcs/BranchWidget.tsx
@@ -19,7 +19,7 @@ import { buildBranchRows, type BranchRow, type PopupAction } from "./branches";
import { branchMenu } from "./branchMenu";
import { recentBranches } from "./branchOps";
import { inProgress, operationTitle, type InProgress } from "./operations";
-import { loadBranches, useVcs } from "./store";
+import { loadBranches, repoName, selectRepo, useVcs } from "./store";
import styles from "./BranchWidget.module.css";
export const useBranchesPopup = create<{ open: boolean }>(() => ({ open: false }));
@@ -34,6 +34,8 @@ export function headLabel(branch: { head: string | null; headCommit: string | nu
export function BranchWidget() {
const available = useVcs((s) => s.available);
const branch = useVcs((s) => s.branch);
+ // With several repositories the widget names the selected one, like IDEA's.
+ const repo = useVcs((s) => (s.roots.length > 1 && s.repo ? repoName(s.repo) : null));
const open = useBranchesPopup((s) => s.open);
const ref = useRef<HTMLButtonElement>(null);
if (!available || !branch) return null;
@@ -43,6 +45,7 @@ export function BranchWidget() {
branch.ahead > 0 ? `${branch.ahead} outgoing` : "",
].filter(Boolean);
const tooltip =
+ (repo ? `Repository: ${repo}\n` : "") +
(branch.upstream
? `Git branch: ${headLabel(branch)}${op}\nTracking ${branch.upstream}`
: `Git branch: ${headLabel(branch)}${op}`) + (sync.length ? `\n${sync.join(", ")} commits` : "");
@@ -58,6 +61,7 @@ export function BranchWidget() {
onClick={() => useBranchesPopup.setState({ open: !open })}
>
<Icon name={branch.head ? "branch" : "commit"} size={16} className={styles.icon} />
+ {repo && <span className={styles.repo}>{repo}</span>}
<span className={styles.name}>
{inProgress(branch.operation) ? operationTitle(inProgress(branch.operation)!, branch.head) : headLabel(branch)}
</span>
@@ -179,6 +183,7 @@ function BranchesPopup({ anchor, onClose }: { anchor: RefObject<HTMLElement | nu
aria-label="Git Branches"
className={styles.popup}
>
+ <RepositoryBar />
<div className={styles.search}>
<SearchField
data-autofocus
@@ -237,6 +242,29 @@ function BranchesPopup({ anchor, onClose }: { anchor: RefObject<HTMLElement | nu
);
}
+/** Repository switcher (several repositories): branches, log and push act on the selected one. */
+function RepositoryBar() {
+ const roots = useVcs((s) => s.roots);
+ const repo = useVcs((s) => s.repo);
+ if (roots.length < 2) return null;
+ return (
+ <div className={styles.repos} role="group" aria-label="Repository">
+ {roots.map((r) => (
+ <button
+ key={r}
+ type="button"
+ className={clsx(styles.repoButton, r === repo && styles.repoSelected)}
+ aria-pressed={r === repo}
+ title={r}
+ onClick={() => void selectRepo(r).then(() => loadBranches().catch(() => undefined))}
+ >
+ {repoName(r)}
+ </button>
+ ))}
+ </div>
+ );
+}
+
function BranchRowView({ row }: { row: BranchRow }) {
if (row.type === "action") {
const keys = shortcutLabel(row.action.id);
diff --git a/src/features/vcs/CommitView.tsx b/src/features/vcs/CommitView.tsx
index 40d08035f..9555c62e7 100644
--- a/src/features/vcs/CommitView.tsx
+++ b/src/features/vcs/CommitView.tsx
@@ -43,7 +43,7 @@ import { KIND_COLOR, KIND_LABEL, formatTime, stashLabel, stripSlash } from "./mo
import { call, commands } from "@/platform/ipc";
import { OperationBanner } from "./operations";
import { ShelfPanel, loadShelves, useShelf } from "./shelf";
-import { loadStashes, refreshNow, useVcs } from "./store";
+import { currentRepo, loadStashes, refreshNow, useVcs } from "./store";
import styles from "./CommitView.module.css";
/** MIME type of changed files dragged between change lists (absolute paths, newline-separated). */
@@ -243,7 +243,11 @@ function ChangesPanel() {
const treeRef = useRef<TreeHandle>(null);
const viewRef = useRef<HTMLButtonElement>(null);
- const roots = useMemo(() => buildChangeTree(status, root, groupByDir, lists), [status, root, groupByDir, lists]);
+ const repos = useVcs((s) => s.roots);
+ const roots = useMemo(
+ () => buildChangeTree(status, root, groupByDir, lists, repos),
+ [status, root, groupByDir, lists, repos],
+ );
const [byKey, parents] = useMemo(() => {
const m = new Map<string, ChangeNode>();
const up = new Map<string, string>();
@@ -556,7 +560,15 @@ function CommitMessage({ included }: { included: number }) {
if (v && !useCommit.getState().message.trim()) {
try {
const [last] = await call(
- commands.vcsLog({ branch: "HEAD", path: null, author: null, text: null, range: null, skip: 0, limit: 1 }),
+ commands.vcsLog(currentRepo(), {
+ branch: "HEAD",
+ path: null,
+ author: null,
+ text: null,
+ range: null,
+ skip: 0,
+ limit: 1,
+ }),
);
if (last && !useCommit.getState().message.trim()) {
amendMessage.current = last.message;
diff --git a/src/features/vcs/CompareBranches.tsx b/src/features/vcs/CompareBranches.tsx
index 9db91f8b3..f2aacb868 100644
--- a/src/features/vcs/CompareBranches.tsx
+++ b/src/features/vcs/CompareBranches.tsx
@@ -6,7 +6,7 @@ import { call, commands } from "@/platform/ipc";
import { Dialog, List, Spinner, Tabs, T } from "@/ui";
import { openDialog } from "./dialogs";
import { formatTime } from "./model";
-import { useVcs } from "./store";
+import { currentRepo, useVcs } from "./store";
import styles from "./common.module.css";
const LIMIT = 2000;
@@ -14,7 +14,7 @@ const LIMIT = 2000;
/** Commits reachable from `to` but not from `from` (git's `from..to`), computed by git, unbounded by any window. */
const commitsBetween = (from: string, to: string) =>
call(
- commands.vcsLog({
+ commands.vcsLog(currentRepo(), {
branch: null,
path: null,
author: null,
diff --git a/src/features/vcs/GitLog.tsx b/src/features/vcs/GitLog.tsx
index d2f1e2ad4..2c6818e58 100644
--- a/src/features/vcs/GitLog.tsx
+++ b/src/features/vcs/GitLog.tsx
@@ -48,7 +48,7 @@ import {
} from "./logStore";
import { KIND_COLOR, baseName, formatTime, relTo, type EffectiveKind } from "./model";
import { clearConsole, useVcsConsole } from "./ops";
-import { loadBranches, useVcs } from "./store";
+import { currentRepo, loadBranches, useVcs } from "./store";
import { checkoutBranch, loadFavoriteBranches, newBranch, useFavoriteBranches } from "./branchOps";
import { branchMenu } from "./branchMenu";
import { branchFolderKeys, branchGroupKeys, buildBranchTree, filterBranchTree, type BranchTreeNode } from "./branches";
@@ -711,7 +711,7 @@ function CommitDetails({ commits }: { commits: Commit[] }) {
useEffect(() => {
if (!selected) return;
let alive = true;
- call(commands.vcsCommitFiles(selected))
+ call(commands.vcsCommitFiles(currentRepo(), selected))
.then((f) => alive && setFiles(f))
.catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));
return () => {
diff --git a/src/features/vcs/__tests__/changes.test.ts b/src/features/vcs/__tests__/changes.test.ts
index df1297a5f..d30500ae0 100644
--- a/src/features/vcs/__tests__/changes.test.ts
+++ b/src/features/vcs/__tests__/changes.test.ts
@@ -1,6 +1,14 @@
import { describe, expect, it } from "vitest";
import type { FileStatus } from "@/bindings";
-import { aggregateCheck, buildChangeTree, initialCheck, planCommit, type CheckState, type ChangeNode } from "../changes";
+import {
+ aggregateCheck,
+ buildChangeTree,
+ commitRepos,
+ initialCheck,
+ planCommit,
+ type CheckState,
+ type ChangeNode,
+} from "../changes";
const fs = (rel: string, staged: FileStatus["staged"], unstaged: FileStatus["unstaged"]): FileStatus => ({
path: `/r/${rel}`,
@@ -54,6 +62,48 @@ describe("buildChangeTree", () => {
});
});
+describe("several repositories", () => {
+ const nested = [...status, fs("libs/core/Lib.kt", null, "modified"), fs("libs/core/new.txt", null, "untracked")];
+ const repos = ["/r", "/r/libs/core"];
+
+ it("groups each change group by repository", () => {
+ expect(shape(buildChangeTree(nested, "/r", false, undefined, repos))).toEqual([
+ "Merge Conflicts",
+ " r",
+ " conf.yml",
+ "Changes",
+ " r",
+ " App.kt",
+ " AppTest.kt",
+ " Partial.kt",
+ " README.md",
+ " libs/core",
+ " Lib.kt",
+ "Unversioned Files",
+ " r",
+ " notes.txt",
+ " libs/core",
+ " new.txt",
+ ]);
+ const changes = buildChangeTree(nested, "/r", true, undefined, repos)[1]!;
+ expect(changes.children!.map((n) => [n.label, n.path])).toEqual([
+ ["r", "/r"],
+ ["libs/core", "/r/libs/core"],
+ ]);
+ expect(shape(changes.children![1]!.children!)).toEqual(["Lib.kt"]);
+ // One repository: no repository level.
+ const single = buildChangeTree(status, "/r", false, undefined, ["/r"]);
+ expect(shape(single)).toEqual(shape(buildChangeTree(status, "/r", false)));
+ });
+
+ it("commits every repository with included changes, the selected one last", () => {
+ const included = [nested[0]!, nested[7]!];
+ expect(commitRepos(included, repos, "/r")).toEqual(["/r/libs/core", "/r"]);
+ expect(commitRepos(included.slice(0, 1), repos, "/r/libs/core")).toEqual(["/r"]);
+ expect(commitRepos([], repos, "/r/libs/core")).toEqual(["/r/libs/core"]);
+ });
+});
+
describe("commit inclusion", () => {
it("defaults: tracked changes included, partial files keep their staged part, unversioned excluded", () => {
expect(initialCheck(status[0]!)).toBe("all");
diff --git a/src/features/vcs/__tests__/gitOps.test.ts b/src/features/vcs/__tests__/gitOps.test.ts
index b95bc62ce..b27ee3cd0 100644
--- a/src/features/vcs/__tests__/gitOps.test.ts
+++ b/src/features/vcs/__tests__/gitOps.test.ts
@@ -11,6 +11,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
...real.commands,
vcsStatus: () => vcsStatus(),
vcsBranchInfo: async () => ({ status: "ok", data: info() }),
+ vcsRoots: async () => ({ status: "ok", data: [{ root: "/p", operation: null }] }),
},
};
});
diff --git a/src/features/vcs/__tests__/workflow.test.ts b/src/features/vcs/__tests__/workflow.test.ts
index 3a09b468a..40d0cca89 100644
--- a/src/features/vcs/__tests__/workflow.test.ts
+++ b/src/features/vcs/__tests__/workflow.test.ts
@@ -1,7 +1,8 @@
import { describe, expect, it } from "vitest";
import { messageProblems, wrapAtMargin } from "../CommitView";
import { linkifyIssues } from "../issueLinks";
-import { isProtectedBranch, isPushRejected } from "../remoteUi";
+import { defaultPushChecked, isProtectedBranch, isPushRejected, pushCandidates, type RepoPush } from "../remoteUi";
+import { attentionRepo } from "../store";
import { statusDecorations } from "../model";
const cfg = { blankLineAfterSubject: true, limitSubject: true, subjectLimit: 10, limitBody: true, bodyLimit: 8 };
@@ -59,3 +60,34 @@ describe("git settings helpers", () => {
expect(statusDecorations(status, false).get("/p/src/a.ts")?.propagate).toBeUndefined();
});
});
+
+describe("several repositories", () => {
+ it("selects a repository that just stopped in an operation", () => {
+ expect(attentionRepo("/p", {}, { "/p/lib": "merge" })).toBe("/p/lib");
+ expect(attentionRepo("/p", { "/p/lib": "merge" }, { "/p/lib": "merge" })).toBeNull();
+ expect(attentionRepo("/p", {}, { "/p": "rebase", "/p/lib": "merge" })).toBeNull();
+ expect(attentionRepo("/p", {}, {})).toBeNull();
+ });
+
+ it("lists repositories with something to push", () => {
+ const branch = (head: string | null, upstream: string | null) => ({
+ head,
+ headCommit: "c1",
+ upstream,
+ ahead: 0,
+ behind: 0,
+ operation: null,
+ });
+ const commit = { id: "c1", shortId: "c1" } as RepoPush["commits"][number];
+ const repos: RepoPush[] = [
+ { root: "/p", branch: branch("main", "origin/main"), commits: [commit] },
+ { root: "/p/a", branch: branch("main", "origin/main"), commits: [] },
+ { root: "/p/b", branch: branch("feature", null), commits: [commit] },
+ { root: "/p/c", branch: branch(null, null), commits: [] },
+ ];
+ const candidates = pushCandidates(repos);
+ expect(candidates.map((r) => r.root)).toEqual(["/p", "/p/b"]);
+ expect([...defaultPushChecked(candidates, "/p")]).toEqual(["/p"]);
+ expect([...defaultPushChecked(candidates, "/p/b")]).toEqual(["/p", "/p/b"]);
+ });
+});
diff --git a/src/features/vcs/actions.tsx b/src/features/vcs/actions.tsx
index 7139151ff..883292416 100644
--- a/src/features/vcs/actions.tsx
+++ b/src/features/vcs/actions.tsx
@@ -16,7 +16,7 @@ import { openDialog } from "./dialogs";
import { gotoChange } from "./gutter";
import { openLocalHistory } from "./localHistoryKind";
import { revealCommit, setLogFilters, useGitLog, emptyFilters } from "./logStore";
-import { runRemote } from "./ops";
+import { allRepos, runRemote } from "./ops";
import { showPushDialog, showUpdateDialog, type PushTarget } from "./remoteUi";
import { chooseRevision } from "./RevisionChooser";
import { showCloneDialog } from "./clone";
@@ -150,7 +150,7 @@ export function registerVcsActions(): () => void {
category: "Git",
icon: "git-fetch",
when: VCS,
- run: () => void runRemote({ op: "fetch" }),
+ run: () => void runRemote({ op: "fetch" }, undefined, allRepos()),
},
{
id: "vcs.refresh",
diff --git a/src/features/vcs/branchOps.ts b/src/features/vcs/branchOps.ts
index eb664fcbb..039c924c2 100644
--- a/src/features/vcs/branchOps.ts
+++ b/src/features/vcs/branchOps.ts
@@ -7,7 +7,7 @@ import { notifications } from "@/workbench/contributions";
import { isFavoriteBranch, pushRecent, shortRemoteName } from "./branches";
import { confirmDialog, promptText } from "./dialogs";
import { runOp, runRemote, saveAll } from "./ops";
-import { conflictedFiles, refreshNow, useVcs } from "./store";
+import { conflictedFiles, currentRepo, refreshNow, useVcs } from "./store";
const recentKey = () => `openidea.vcs.recentBranches:${useVcs.getState().root ?? ""}`;
@@ -46,7 +46,7 @@ export function validateBranchName(name: string): string | null {
export async function checkoutBranch(name: string) {
const previous = useVcs.getState().branch?.head;
await saveAll();
- const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(name, false)), {
+ const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(currentRepo(), name, false)), {
success: () => `Checked out ${useVcs.getState().branch?.head ?? name}`,
});
if (ok !== undefined) {
@@ -72,7 +72,8 @@ export async function newBranch(from?: string) {
const checkout = r.checked;
const previous = useVcs.getState().branch?.head;
if (checkout) await saveAll();
- const ok = await runOp(`Create branch ${r.value}`, () => call(commands.vcsCreateBranch(r.value, from ?? null, checkout)), {
+ const create = () => call(commands.vcsCreateBranch(currentRepo(), r.value, from ?? null, checkout));
+ const ok = await runOp(`Create branch ${r.value}`, create, {
success: checkout ? `Created and checked out ${r.value}` : `Created branch ${r.value}`,
});
if (ok !== undefined && checkout) {
@@ -91,7 +92,7 @@ export async function checkoutRevision() {
});
if (!r) return;
await saveAll();
- await runOp(`Checkout ${r.value}`, () => call(commands.vcsCheckout(r.value, false)), {
+ await runOp(`Checkout ${r.value}`, () => call(commands.vcsCheckout(currentRepo(), r.value, false)), {
success: `Checked out ${r.value}`,
});
}
@@ -116,7 +117,7 @@ async function openConflictsInstead(): Promise<boolean> {
export async function mergeIntoCurrent(branch: string) {
const current = useVcs.getState().branch?.head ?? "HEAD";
await saveAll();
- await runOp(`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(branch)), {
+ await runOp(`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(currentRepo(), branch)), {
success: `Merged ${branch} into ${current}`,
errorActions: conflictActions,
onError: openConflictsInstead,
@@ -126,7 +127,7 @@ export async function mergeIntoCurrent(branch: string) {
export async function rebaseOnto(branch: string) {
const current = useVcs.getState().branch?.head ?? "HEAD";
await saveAll();
- await runOp(`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(branch)), {
+ await runOp(`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(currentRepo(), branch)), {
success: `Rebased ${current} onto ${branch}`,
errorActions: conflictActions,
onError: openConflictsInstead,
@@ -144,7 +145,7 @@ export async function renameBranch(name: string) {
});
if (!r) return;
const to = r.value.trim();
- const ok = await runOp(`Rename branch ${name}`, () => call(commands.vcsRenameBranch(name, to)), {
+ const ok = await runOp(`Rename branch ${name}`, () => call(commands.vcsRenameBranch(currentRepo(), name, to)), {
success: `Renamed branch ${name} to ${to}`,
});
if (ok !== undefined) {
@@ -164,7 +165,7 @@ export async function deleteBranch(name: string) {
danger: true,
});
if (!ok) return;
- await runOp(`Delete branch ${name}`, () => call(commands.vcsDeleteBranch(name, false)), {
+ await runOp(`Delete branch ${name}`, () => call(commands.vcsDeleteBranch(currentRepo(), name, false)), {
success: `Deleted branch ${name}`,
errorActions: (m) =>
/not fully merged/i.test(m)
@@ -172,7 +173,7 @@ export async function deleteBranch(name: string) {
{
label: "Force Delete",
run: () =>
- void runOp(`Force delete ${name}`, () => call(commands.vcsDeleteBranch(name, true)), {
+ void runOp(`Force delete ${name}`, () => call(commands.vcsDeleteBranch(currentRepo(), name, true)), {
success: `Deleted branch ${name}`,
}),
},
@@ -198,7 +199,7 @@ export async function checkoutAndRebase(name: string) {
const current = useVcs.getState().branch?.head;
if (!current) return;
await saveAll();
- const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(name, false)));
+ const ok = await runOp(`Checkout ${name}`, () => call(commands.vcsCheckout(currentRepo(), name, false)));
if (ok === undefined) return;
rememberBranch(current);
rememberBranch(name);
diff --git a/src/features/vcs/changeOps.tsx b/src/features/vcs/changeOps.tsx
index 2242a9710..b24bffe4d 100644
--- a/src/features/vcs/changeOps.tsx
+++ b/src/features/vcs/changeOps.tsx
@@ -4,14 +4,14 @@ import type { FileStatus } from "@/bindings";
import { call, commands } from "@/platform/ipc";
import { Checkbox, Dialog, Icon, fileIconName } from "@/ui";
import { notifications } from "@/workbench/contributions";
-import { groupOf, planCommit, renamedFromPath } from "./changes";
+import { commitRepos, groupOf, planCommit, renamedFromPath } from "./changes";
import { useChangelists, withListDefaults } from "./changelists";
import { runCommitChecks } from "./commitChecks";
import { rememberMessage, useCommit } from "./commitStore";
import { confirmDialog, openDialog, promptText } from "./dialogs";
import { KIND_COLOR, baseName, dirName, effectiveKind, relTo, stripSlash } from "./model";
import { logConsole, runOp, saveAll } from "./ops";
-import { loadStashes, refreshNow, useVcs } from "./store";
+import { currentRepo, loadStashes, refreshNow, useVcs } from "./store";
import styles from "./common.module.css";
export function firstLine(message: string): string {
@@ -48,18 +48,24 @@ export async function commitChanges(): Promise<string | undefined> {
}
const candidates = plan.included.map((f) => ({ path: stripSlash(f.path), exists: effectiveKind(f) !== "deleted" }));
if (!(await runCommitChecks(candidates, amend))) return undefined;
+ // Like IDEA, every repository with included changes gets a commit with the same message.
+ const repos = commitRepos(plan.included, useVcs.getState().roots, currentRepo());
const id = await runOp(
amend ? "Amend commit" : "Commit",
async () => {
if (plan.unstage.length) await call(commands.vcsUnstage(plan.unstage));
if (plan.stage.length) await call(commands.vcsStage(plan.stage));
- return call(commands.vcsCommit(message.trim(), { amend, signOff, author: author.trim() || null, runHooks }));
+ const options = { amend, signOff, author: author.trim() || null, runHooks };
+ let id = "";
+ for (const repo of repos) id = await call(commands.vcsCommit(repo, message.trim(), options));
+ return id;
},
{
success: () => {
const n = plan.included.length;
const summary = firstLine(message);
- return `${n} file${n === 1 ? "" : "s"} ${amend ? "amended" : "committed"}${summary ? `: ${summary}` : ""}`;
+ const where = repos.length > 1 ? ` in ${repos.length} repositories` : "";
+ return `${n} file${n === 1 ? "" : "s"} ${amend ? "amended" : "committed"}${where}${summary ? `: ${summary}` : ""}`;
},
},
);
@@ -221,7 +227,7 @@ export async function stashChanges() {
});
if (!r) return;
await saveAll();
- await runOp("Stash changes", () => call(commands.vcsStashPush(r.value || null, r.checked)), {
+ await runOp("Stash changes", () => call(commands.vcsStashPush(currentRepo(), r.value || null, r.checked)), {
success: "Changes stashed",
});
void loadStashes().catch(() => undefined);
@@ -229,7 +235,7 @@ export async function stashChanges() {
export async function applyStash(index: number, pop: boolean) {
await saveAll();
- await runOp(`${pop ? "Pop" : "Apply"} stash@{${index}}`, () => call(commands.vcsStashApply(index, pop)), {
+ await runOp(`${pop ? "Pop" : "Apply"} stash@{${index}}`, () => call(commands.vcsStashApply(currentRepo(), index, pop)), {
success: pop ? `Unstashed stash@{${index}}` : `Applied stash@{${index}}`,
});
void loadStashes().catch((e) => logConsole("err", String(e)));
@@ -243,7 +249,7 @@ export async function dropStash(index: number, message: string) {
danger: true,
});
if (!ok) return;
- await runOp(`Drop stash@{${index}}`, () => call(commands.vcsStashDrop(index)), {
+ await runOp(`Drop stash@{${index}}`, () => call(commands.vcsStashDrop(currentRepo(), index)), {
success: `Dropped stash@{${index}}`,
});
void loadStashes().catch((e) => logConsole("err", String(e)));
diff --git a/src/features/vcs/changes.ts b/src/features/vcs/changes.ts
index 49e24f9e2..f0b3c47ad 100644
--- a/src/features/vcs/changes.ts
+++ b/src/features/vcs/changes.ts
@@ -1,6 +1,6 @@
/** Commit tool window model: change groups, directory tree, inclusion (pure). */
import type { ChangelistState, FileStatus } from "@/bindings";
-import { baseName, dirName, effectiveKind, relTo, stripSlash, type EffectiveKind } from "./model";
+import { baseName, dirName, effectiveKind, relTo, repoLabel, rootOf, stripSlash, type EffectiveKind } from "./model";
export type GroupId = "conflicts" | "changes" | "unversioned";
@@ -156,6 +156,37 @@ function childNodes(files: readonly FileStatus[], root: string, group: GroupId,
.map((f) => fileNode(f, root, group, true, scope));
}
+/** With several repositories, a node per repository (IDEA's "Group by Repository") above the files. */
+function repoNodes(
+ files: readonly FileStatus[],
+ root: string,
+ group: GroupId,
+ groupByDir: boolean,
+ scope: string,
+ repos: readonly string[],
+): ChangeNode[] {
+ if (repos.length < 2) return childNodes(files, root, group, groupByDir, scope);
+ const byRepo = new Map<string, FileStatus[]>();
+ for (const f of files) {
+ const repo = rootOf(f.path, repos) ?? root;
+ let list = byRepo.get(repo);
+ if (!list) byRepo.set(repo, (list = []));
+ list.push(f);
+ }
+ const order = (r: string) => (repos.includes(r) ? repos.indexOf(r) : repos.length);
+ return [...byRepo]
+ .sort(([a], [b]) => order(a) - order(b))
+ .map(([repo, own]) => ({
+ key: `${scope}:repo:${repo}`,
+ type: "dir" as const,
+ label: repoLabel(repo, root),
+ group,
+ children: childNodes(own, repo, group, groupByDir, `${scope}@${repo}`),
+ files: own,
+ path: repo,
+ }));
+}
+
function tagList(nodes: ChangeNode[], id: string): ChangeNode[] {
for (const n of nodes) {
n.changelist = id;
@@ -167,13 +198,15 @@ function tagList(nodes: ChangeNode[], id: string): ChangeNode[] {
/**
* Group roots (Merge Conflicts / Changes / Unversioned Files) with flat or directory
* children. With change lists, "Changes" is split into one group per list
- * (`ChangelistState.files` keys are project-relative paths).
+ * (`ChangelistState.files` keys are project-relative paths). With several
+ * repositories (`repos`), each group's files are grouped by repository first.
*/
export function buildChangeTree(
status: readonly FileStatus[],
root: string,
groupByDir: boolean,
lists?: ChangelistState,
+ repos: readonly string[] = [],
): ChangeNode[] {
const byGroup = new Map<GroupId, FileStatus[]>();
for (const fs of status) {
@@ -202,7 +235,7 @@ export function buildChangeTree(
type: "group",
label: l.name,
group: g,
- children: tagList(childNodes(own, root, g, groupByDir, scope), l.id),
+ children: tagList(repoNodes(own, root, g, groupByDir, scope, repos), l.id),
files: own,
changelist: l.id,
active: l.id === lists.active,
@@ -212,7 +245,7 @@ export function buildChangeTree(
continue;
}
if (!files.length) continue;
- const children = childNodes(files, root, g, groupByDir, g);
+ const children = repoNodes(files, root, g, groupByDir, g, repos);
roots.push({ key: `group:${g}`, type: "group", label: GROUP_LABEL[g], group: g, children, files });
}
return roots;
@@ -225,6 +258,20 @@ export interface CommitPlan {
included: FileStatus[];
}
+/**
+ * Repositories to commit: those holding `included` files (the selected one last, so its
+ * commit id is returned), else just the selected one (amend, concluding a merge).
+ */
+export function commitRepos(
+ included: readonly FileStatus[],
+ roots: readonly string[],
+ selected: string | null,
+): Array<string | null> {
+ const repos = [...new Set(included.map((f) => rootOf(f.path, roots)).filter((r): r is string => !!r))];
+ if (!repos.length) return [selected];
+ return selected && repos.includes(selected) ? [...repos.filter((r) => r !== selected), selected] : repos;
+}
+
/** Absolute path of the source of a staged rename (`renamedFrom` is repository-relative). */
export function renamedFromPath(fs: FileStatus): string | null {
if (!fs.renamedFrom) return null;
diff --git a/src/features/vcs/commitChecks.tsx b/src/features/vcs/commitChecks.tsx
index 0ddb8bee3..3119a30d0 100644
--- a/src/features/vcs/commitChecks.tsx
+++ b/src/features/vcs/commitChecks.tsx
@@ -13,7 +13,7 @@ import { maybeEditorService, toolWindowService } from "@/workbench/contributions
import { ask } from "@/workbench/messages";
import { baseName, relTo } from "./model";
import { logConsole } from "./ops";
-import { useVcs } from "./store";
+import { currentRepo, useVcs } from "./store";
import styles from "./common.module.css";
// ---------------------------------------------------------------------------
@@ -308,7 +308,7 @@ export async function runCommitChecks(files: readonly CommitCandidate[], amend:
}
if (git.warnCrlf) {
- const autocrlf = (await call(commands.vcsConfigGet("core.autocrlf")).catch(() => null))?.toLowerCase();
+ const autocrlf = (await call(commands.vcsConfigGet(currentRepo(), "core.autocrlf")).catch(() => null))?.toLowerCase();
if (autocrlf !== "true" && autocrlf !== "input") {
const crlf: string[] = [];
for (const p of existing) {
diff --git a/src/features/vcs/historyActions.tsx b/src/features/vcs/historyActions.tsx
index 39a8871a1..4a8ad4272 100644
--- a/src/features/vcs/historyActions.tsx
+++ b/src/features/vcs/historyActions.tsx
@@ -42,7 +42,7 @@ import {
} from "./rebase";
import { showApplyPatch, showCreatePatchForChanges, showCreatePatchForCommits } from "./patches";
import { deleteShelf, renameShelf, shelveChanges, showShelf, unshelve, useShelf } from "./shelf";
-import { useVcs } from "./store";
+import { currentRepo, useVcs } from "./store";
const VCS = "vcsAvailable";
const IN_GIT_LOG = "vcsAvailable && activeToolWindow == git";
@@ -83,7 +83,7 @@ function withCommits(fn: (cs: Commit[]) => unknown) {
async function openCommitInBrowser(c: Commit) {
const upstream = useVcs.getState().branch?.upstream;
const remote = upstream ? upstream.slice(0, upstream.indexOf("/")) : "origin";
- const url = await call(commands.vcsConfigGet(`remote.${remote}.url`)).catch(() => null);
+ const url = await call(commands.vcsConfigGet(currentRepo(), `remote.${remote}.url`)).catch(() => null);
const page = url ? commitWebUrl(url, c.id) : null;
if (page) await openUrl(page);
else notifications().notify({ group: "vcs", level: "warning", title: `No web URL for remote '${remote}'` });
@@ -122,7 +122,7 @@ function shelfArg(arg: unknown) {
async function checkoutCommit(c: Commit) {
await saveAll();
- await runOp(`Checkout ${c.shortId}`, () => call(commands.vcsCheckout(c.id, false)), {
+ await runOp(`Checkout ${c.shortId}`, () => call(commands.vcsCheckout(currentRepo(), c.id, false)), {
success: `Checked out ${c.shortId} (detached HEAD)`,
});
}
diff --git a/src/features/vcs/incoming.ts b/src/features/vcs/incoming.ts
index dfe244577..ca177604d 100644
--- a/src/features/vcs/incoming.ts
+++ b/src/features/vcs/incoming.ts
@@ -8,7 +8,7 @@ import { Channel } from "@tauri-apps/api/core";
import { call, commands, isTauri, nextRequestId } from "@/platform/ipc";
import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";
import { logConsole } from "./ops";
-import { loadBranches, refreshNow, useVcs } from "./store";
+import { currentRepo, loadBranches, refreshNow, useVcs } from "./store";
const FIRST_DELAY = 20_000;
const INTERVAL = 15 * 60_000;
@@ -32,7 +32,7 @@ export function installIncomingCheck(): () => void {
const channel = new Channel<string>();
channel.onmessage = () => undefined;
try {
- await call(commands.vcsRemote(nextRequestId(), { op: "fetch" }, channel));
+ await call(commands.vcsRemote(currentRepo(), nextRequestId(), { op: "fetch" }, channel));
await refreshNow();
if (useVcs.getState().branchesLoaded) void loadBranches().catch(() => undefined);
} catch (e) {
diff --git a/src/features/vcs/logStore.ts b/src/features/vcs/logStore.ts
index eaaab18cb..beb575d61 100644
--- a/src/features/vcs/logStore.ts
+++ b/src/features/vcs/logStore.ts
@@ -5,7 +5,7 @@ import { call, commands } from "@/platform/ipc";
import { workflowSettings } from "@/platform/workflowSettings";
import { computeGraph, emptyGraphState, type GraphRow, type GraphState } from "./graph";
import { clearConsole, errorMessage } from "./ops";
-import { useVcs } from "./store";
+import { currentRepo, repoOf, selectRepo, useVcs } from "./store";
export interface LogFilters {
branch: string | null;
@@ -71,19 +71,33 @@ export const useGitLog = create<LogState>(() => ({ ...initialLog(), generation:
let loadPromise: Promise<void> | null = null;
-/** Another repository (the window switched projects): forget its commits, filters, selection and console. */
+/**
+ * Another project (the window switched projects): forget its commits, filters, selection
+ * and console. Another repository of the project selected: show its log.
+ */
export function installGitLog(): () => void {
return useVcs.subscribe((s, prev) => {
- if (s.root === prev.root) return;
- loadPromise = null;
- useGitLog.setState((l) => ({ ...initialLog(), tab: l.tab, generation: l.generation + 1 }));
- clearConsole();
+ if (s.root !== prev.root) {
+ loadPromise = null;
+ useGitLog.setState((l) => ({ ...initialLog(), tab: l.tab, generation: l.generation + 1 }));
+ clearConsole();
+ } else if (s.repo !== prev.repo && prev.repo !== null) {
+ const l = useGitLog.getState();
+ if (l.generation === 0 && !l.filters.path) return;
+ const { path } = useGitLog.getState().filters;
+ // A path filter belongs to the repository it is in.
+ if (path && repoOf(path) !== s.repo) useGitLog.setState((l) => ({ filters: { ...l.filters, path: null } }));
+ void reloadLog();
+ }
});
}
export function setLogFilters(patch: Partial<LogFilters>) {
useGitLog.setState((s) => ({ filters: { ...s.filters, ...patch } }));
- void reloadLog();
+ // History of a file in another repository: that repository's log.
+ const repo = patch.path ? repoOf(patch.path) : null;
+ if (repo && repo !== currentRepo()) void selectRepo(repo);
+ else void reloadLog();
}
/** Drops loaded commits and loads the first page. */
@@ -106,7 +120,15 @@ async function loadOutgoing() {
if (!upstream) return useGitLog.setState({ outgoing: null });
try {
const commits = await call(
- commands.vcsLog({ branch: "HEAD", path: null, author: null, text: null, range: "@{u}..HEAD", skip: 0, limit: 0 }),
+ commands.vcsLog(currentRepo(), {
+ branch: "HEAD",
+ path: null,
+ author: null,
+ text: null,
+ range: "@{u}..HEAD",
+ skip: 0,
+ limit: 0,
+ }),
);
useGitLog.setState({ outgoing: new Set(commits.map((c) => c.id)) });
} catch {
@@ -137,7 +159,7 @@ export function loadMore(): Promise<void> {
const p = (async () => {
try {
const page = await call(
- commands.vcsLog({
+ commands.vcsLog(currentRepo(), {
branch: f.branch,
path: f.path,
author: f.author.trim() || null,
diff --git a/src/features/vcs/model.ts b/src/features/vcs/model.ts
index 197b3ec99..8b9cbad13 100644
--- a/src/features/vcs/model.ts
+++ b/src/features/vcs/model.ts
@@ -92,6 +92,20 @@ export function relTo(root: string, path: string): string {
return path.startsWith(root + "/") ? path.slice(root.length + 1) : path;
}
+/** The innermost of `roots` (repository roots) containing `path`. */
+export function rootOf(path: string, roots: readonly string[]): string | null {
+ const p = stripSlash(path);
+ let best: string | null = null;
+ for (const r of roots) if ((p === r || p.startsWith(`${r}/`)) && (!best || r.length > best.length)) best = r;
+ return best;
+}
+
+/** Repository name for display: its folder relative to the project, else its folder name. */
+export function repoLabel(root: string, projectRoot: string | null): string {
+ if (projectRoot && root.startsWith(`${projectRoot}/`)) return root.slice(projectRoot.length + 1);
+ return baseName(root) || root;
+}
+
export function baseName(path: string): string {
const p = stripSlash(path);
const i = p.lastIndexOf("/");
diff --git a/src/features/vcs/operations.tsx b/src/features/vcs/operations.tsx
index db340c71f..1ca9bcf3b 100644
--- a/src/features/vcs/operations.tsx
+++ b/src/features/vcs/operations.tsx
@@ -14,7 +14,7 @@ import { openDialog, promptText } from "./dialogs";
import { KIND_COLOR, baseName, dirName } from "./model";
import { runGitOperation, runOp } from "./ops";
import { reloadLog, useGitLog } from "./logStore";
-import { conflictedFiles, refreshNow, useVcs } from "./store";
+import { conflictedFiles, currentRepo, refreshNow, repoOf, useVcs } from "./store";
import styles from "./common.module.css";
// ---------------------------------------------------------------------------
@@ -84,7 +84,10 @@ export async function controlOperation(control: "continue" | "skip" | "abort", e
await refreshNow();
const op = inProgress();
if (!op || (expected && op !== expected)) return notInProgress(expected);
- if (control === "continue" && conflictedFiles().length) {
+ // Only the selected repository's conflicts block it (others may be in their own merge).
+ const repo = currentRepo();
+ const conflicts = conflictedFiles().filter((f) => !repo || repoOf(f.path) === repo);
+ if (control === "continue" && conflicts.length) {
notifications().notify({ group: "vcs", level: "warning", title: "Resolve all conflicts before continuing" });
void executeAction("vcs.resolveConflicts");
return;
@@ -301,7 +304,7 @@ export function validateTagName(name: string, existing: readonly string[] = []):
/** Log › New Tag…: a lightweight tag on the selected commit. */
export async function newTagOn(commit: Commit) {
- const existing = await call(commands.vcsTags()).catch(() => [] as string[]);
+ const existing = await call(commands.vcsTags(currentRepo())).catch(() => [] as string[]);
const r = await promptText({
title: `Create New Tag On ${short(commit.id)}`,
label: "Enter the name of new tag:",
@@ -310,7 +313,8 @@ export async function newTagOn(commit: Commit) {
validate: (v) => validateTagName(v, existing),
});
if (!r) return;
- const ok = await runOp(`Create tag ${r.value}`, () => call(commands.vcsCreateTag(r.value, commit.id, null, false)), {
+ const create = () => call(commands.vcsCreateTag(currentRepo(), r.value, commit.id, null, false));
+ const ok = await runOp(`Create tag ${r.value}`, create, {
success: `Created tag ${r.value} on ${short(commit.id)}`,
});
// Tags are not part of the refs signature that reloads the log.
@@ -329,7 +333,7 @@ function TagDialog({ onClose }: { onClose: () => void }) {
const [force, setForce] = useState(false);
const [existing, setExisting] = useState<string[]>([]);
useEffect(() => {
- void call(commands.vcsTags()).then(setExisting, () => undefined);
+ void call(commands.vcsTags(currentRepo())).then(setExisting, () => undefined);
}, []);
const error = validateTagName(name, force ? [] : existing);
const run = async () => {
@@ -338,7 +342,7 @@ function TagDialog({ onClose }: { onClose: () => void }) {
const tag = name.trim();
const ok = await runOp(
`Create tag ${tag}`,
- () => call(commands.vcsCreateTag(tag, commit.trim() || "HEAD", message || null, force)),
+ () => call(commands.vcsCreateTag(currentRepo(), tag, commit.trim() || "HEAD", message || null, force)),
{ success: `Created tag ${tag}` },
);
if (ok !== undefined && useGitLog.getState().commits.length) void reloadLog();
@@ -405,7 +409,7 @@ function CompareWithLocalDialog({ rev, label, onClose }: { rev: string; label: s
const [active, setActive] = useState(0);
useEffect(() => {
let alive = true;
- call(commands.vcsDiffWithWorktree(rev))
+ call(commands.vcsDiffWithWorktree(currentRepo(), rev))
.then((f) => alive && setFiles(f))
.catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));
return () => {
diff --git a/src/features/vcs/ops.ts b/src/features/vcs/ops.ts
index b613683e4..3342b0323 100644
--- a/src/features/vcs/ops.ts
+++ b/src/features/vcs/ops.ts
@@ -9,7 +9,7 @@ import { call, commands, emitLocalIdeEvent, isCancelled, nextRequestId } from "@
import { editorsFor } from "@/editor/api";
import { maybeEditorService, notifications } from "@/workbench/contributions";
import { progressFraction } from "./model";
-import { refreshNow, useVcs } from "./store";
+import { currentRepo, refreshNow, repoName, useVcs } from "./store";
// ---------------------------------------------------------------------------
// Console (Git tool window → Console tab)
@@ -130,8 +130,21 @@ export function cancelRemote() {
if (activeRemote !== null) void commands.cancelRequest(activeRemote);
}
-/** Runs fetch / pull / push with progress in the status bar and output in the console. */
-export async function runRemote(op: RemoteOp, detail?: string): Promise<boolean> {
+/** Every repository of the project (Fetch and Update Project act on all of them, as in IDEA). */
+export function allRepos(): Array<string | null> {
+ const roots = useVcs.getState().roots;
+ return roots.length ? roots : [null];
+}
+
+/**
+ * Runs fetch / pull / push with progress in the status bar and output in the console,
+ * in each of `repos` (default: the selected repository) in turn.
+ */
+export async function runRemote(
+ op: RemoteOp,
+ detail?: string,
+ repos: ReadonlyArray<string | null> = [currentRepo()],
+): Promise<boolean> {
if (useVcs.getState().remoteBusy) {
notifications().notify({ group: "vcs", level: "warning", title: "Another remote operation is in progress" });
return false;
@@ -163,7 +176,10 @@ export async function runRemote(op: RemoteOp, detail?: string): Promise<boolean>
task(text || null, progressFraction(text), false);
};
try {
- await call(commands.vcsRemote(request, op, channel));
+ for (const repo of repos) {
+ if (repos.length > 1 && repo) logConsole("info", repoName(repo));
+ await call(commands.vcsRemote(repo, request, op, channel));
+ }
lastRemoteError = null;
notifications().notify({
group: "vcs",
@@ -239,7 +255,7 @@ export async function runGitOperation(op: GitOperation, opts: GitOperationOption
task(line.trim() || null, false);
};
try {
- await call(commands.vcsOperation(request, op, channel));
+ await call(commands.vcsOperation(currentRepo(), request, op, channel));
let success = opts.success;
if (typeof success === "function") {
await refreshNow();
diff --git a/src/features/vcs/rebase.tsx b/src/features/vcs/rebase.tsx
index f1a5455a1..262d041af 100644
--- a/src/features/vcs/rebase.tsx
+++ b/src/features/vcs/rebase.tsx
@@ -26,7 +26,7 @@ import {
type RebaseRange,
type RebaseRow,
} from "./rebasePlan";
-import { refreshNow, useVcs } from "./store";
+import { currentRepo, refreshNow, useVcs } from "./store";
import styles from "./common.module.css";
const short = (id: string) => id.slice(0, 8);
@@ -56,7 +56,8 @@ export async function undoCommit(commit: Commit) {
});
if (!ok) return;
}
- const message = await runOp(`Undo commit ${short(commit.id)}`, () => call(commands.vcsUndoCommit(commit.id)), {
+ const undo = () => call(commands.vcsUndoCommit(currentRepo(), commit.id));
+ const message = await runOp(`Undo commit ${short(commit.id)}`, undo, {
success: `Undid commit ${short(commit.id)} “${commit.summary}”; its changes are staged`,
});
// IDEA offers the undone message for the next commit.
@@ -78,7 +79,7 @@ async function rangeFrom(target: Commit, verb: string): Promise<RebaseRange | nu
const parent = target.parents[0];
try {
const history = await call(
- commands.vcsLog({
+ commands.vcsLog(currentRepo(), {
branch: "HEAD",
path: null,
author: null,
diff --git a/src/features/vcs/remoteUi.tsx b/src/features/vcs/remoteUi.tsx
index 2efda3781..7a968df7c 100644
--- a/src/features/vcs/remoteUi.tsx
+++ b/src/features/vcs/remoteUi.tsx
@@ -1,14 +1,14 @@
/** Update Project and Push dialogs. */
import { useEffect, useState } from "react";
-import type { Commit, PushTags, RemoteOp } from "@/bindings";
+import type { BranchInfo, Commit, PushTags, RemoteOp } from "@/bindings";
import { call, commands } from "@/platform/ipc";
import { workflowSettings } from "@/platform/workflowSettings";
import { notifications } from "@/workbench/contributions";
import { Checkbox, Dialog, List, Select, Spinner, T } from "@/ui";
import { openDialog } from "./dialogs";
import { formatTime } from "./model";
-import { lastRemoteFailure, runRemote, saveAll } from "./ops";
-import { refreshNow, useVcs } from "./store";
+import { allRepos, lastRemoteFailure, runRemote, saveAll } from "./ops";
+import { currentRepo, refreshNow, repoName, useVcs } from "./store";
import styles from "./common.module.css";
export function showUpdateDialog() {
@@ -22,7 +22,14 @@ function UpdateDialog({ onClose }: { onClose: () => void }) {
const run = async () => {
onClose();
await saveAll();
- await runRemote({ op: "pull", rebase }, branch?.upstream ? `${branch.head} ← ${branch.upstream}` : undefined);
+ const repos = allRepos();
+ const detail =
+ repos.length > 1
+ ? `${repos.length} repositories`
+ : branch?.upstream
+ ? `${branch.head} ← ${branch.upstream}`
+ : undefined;
+ await runRemote({ op: "pull", rebase }, detail, repos);
};
return (
<Dialog
@@ -70,8 +77,8 @@ function UpdateDialog({ onClose }: { onClose: () => void }) {
);
}
-const logOf = (branch: string, limit: number, range: string | null = null) =>
- call(commands.vcsLog({ branch, path: null, author: null, text: null, range, skip: 0, limit }));
+const logOf = (branch: string, limit: number, range: string | null = null, repo = currentRepo()) =>
+ call(commands.vcsLog(repo, { branch, path: null, author: null, text: null, range, skip: 0, limit }));
/** Outgoing commits of the current branch: `@{u}..HEAD`, or recent HEAD history without an upstream. */
export function outgoingQuery(upstream: string | null): { branch: string; range: string | null; limit: number } {
@@ -87,7 +94,169 @@ export interface PushTarget {
export async function showPushDialog(target: PushTarget = {}) {
await refreshNow();
- openDialog((close) => <PushDialog target={target} onClose={close} />);
+ // Several repositories: IDEA's dialog lists each one with outgoing commits.
+ const multi = useVcs.getState().roots.length > 1 && !target.branch && !target.revision;
+ openDialog((close) => (multi ? <MultiPushDialog onClose={close} /> : <PushDialog target={target} onClose={close} />));
+}
+
+/** A repository in the multi-repository Push dialog. */
+export interface RepoPush {
+ root: string;
+ branch: BranchInfo;
+ commits: Commit[];
+}
+
+/** Repositories with something to push: outgoing commits, or a branch without upstream. */
+export function pushCandidates(repos: readonly RepoPush[]): RepoPush[] {
+ return repos.filter((r) => r.branch.head && (r.branch.upstream ? r.commits.length > 0 : true));
+}
+
+/** Checked by default: repositories with outgoing commits (a new branch only in the selected one). */
+export function defaultPushChecked(repos: readonly RepoPush[], selected: string | null): Set<string> {
+ return new Set(repos.filter((r) => (r.branch.upstream ? r.commits.length > 0 : r.root === selected)).map((r) => r.root));
+}
+
+type PushRow = { type: "repo"; repo: RepoPush } | { type: "commit"; repo: RepoPush; commit: Commit };
+
+function MultiPushDialog({ onClose }: { onClose: () => void }) {
+ const roots = useVcs((s) => s.roots);
+ const [repos, setRepos] = useState<RepoPush[] | null>(null);
+ const [checked, setChecked] = useState<Set<string>>(() => new Set());
+ const [error, setError] = useState<string | null>(null);
+ const [force, setForce] = useState(false);
+ const [pushTags, setPushTags] = useState(false);
+ const [tagsMode, setTagsMode] = useState<PushTags>("all");
+
+ useEffect(() => {
+ let alive = true;
+ Promise.all(
+ roots.map(async (root) => {
+ const branch = await call(commands.vcsBranchInfo(root));
+ const q = outgoingQuery(branch.upstream);
+ const commits = branch.head ? await logOf(q.branch, q.limit, q.range, root) : [];
+ return { root, branch, commits };
+ }),
+ )
+ .then((all) => {
+ if (!alive) return;
+ const list = pushCandidates(all);
+ setRepos(list);
+ setChecked(defaultPushChecked(list, currentRepo()));
+ })
+ .catch((e) => alive && setError(e instanceof Error ? e.message : String(e)));
+ return () => {
+ alive = false;
+ };
+ }, [roots]);
+
+ const toggle = (root: string) =>
+ setChecked((prev) => {
+ const next = new Set(prev);
+ if (!next.delete(root)) next.add(root);
+ return next;
+ });
+ const targetOf = (r: RepoPush) => (r.branch.upstream ? r.branch.upstream.slice(r.branch.upstream.indexOf("/") + 1) : r.branch.head!);
+ const picked = (repos ?? []).filter((r) => checked.has(r.root));
+ const push = async () => {
+ onClose();
+ for (const r of picked) {
+ const upstream = r.branch.upstream;
+ const ok = await pushWithAutoUpdate(
+ {
+ op: "push",
+ force_with_lease: force && !isProtectedBranch(targetOf(r)),
+ set_upstream: !upstream,
+ tags: pushTags ? tagsMode : null,
+ },
+ `${repoName(r.root)}: ${r.branch.head} → ${upstream ?? "new remote branch"}`,
+ r.root,
+ );
+ if (!ok) return;
+ }
+ };
+ const rows: PushRow[] = (repos ?? []).flatMap((repo) => [
+ { type: "repo" as const, repo },
+ ...repo.commits.map((commit) => ({ type: "commit" as const, repo, commit })),
+ ]);
+
+ return (
+ <Dialog
+ open
+ title="Push Commits"
+ onClose={onClose}
+ width={620}
+ footerStart={
+ <>
+ <Checkbox checked={force} onChange={setForce} label="Force (with lease)" />
+ <Checkbox checked={pushTags} onChange={setPushTags} label="Push tags:" />
+ <Select<PushTags>
+ value={tagsMode}
+ disabled={!pushTags}
+ aria-label="Tags to push"
+ onChange={setTagsMode}
+ options={[
+ { value: "all", label: "All" },
+ { value: "currentBranch", label: "Current Branch" },
+ ]}
+ />
+ </>
+ }
+ buttons={[
+ {
+ label: force ? "Force Push" : "Push",
+ role: "default",
+ autoFocus: true,
+ disabled: !picked.length,
+ onClick: () => void push(),
+ },
+ { label: "Cancel", role: "cancel" },
+ ]}
+ >
+ <div style={{ height: 340, display: "flex", flexDirection: "column", padding: "14px" }}>
+ {error ? (
+ <div className={styles.error}>{error}</div>
+ ) : !repos ? (
+ <div className={styles.empty}>
+ <Spinner size={14} />
+ </div>
+ ) : (
+ <List
+ items={rows}
+ getKey={(r) => (r.type === "repo" ? `repo:${r.repo.root}` : `${r.repo.root}:${r.commit.id}`)}
+ rowHeight={22}
+ aria-label="Outgoing commits"
+ className={styles.boxList}
+ // Clicks on the checkbox toggle it themselves.
+ onActivate={(r, _i, e) => {
+ if (r.type === "repo" && !(e.target as HTMLElement | null)?.closest?.("label")) toggle(r.repo.root);
+ }}
+ empty={<span>Everything is up to date</span>}
+ renderItem={(r) =>
+ r.type === "repo" ? (
+ <span className={styles.commitRow} style={{ flex: 1, padding: 0 }}>
+ <Checkbox
+ checked={checked.has(r.repo.root)}
+ onChange={() => toggle(r.repo.root)}
+ label={repoName(r.repo.root)}
+ />
+ <span className={styles.commitMeta}>
+ {r.repo.branch.head} → {r.repo.branch.upstream ?? "new remote branch"}
+ </span>
+ </span>
+ ) : (
+ <span className={styles.commitRow} style={{ flex: 1, padding: "0 0 0 24px" }}>
+ <span className={styles.commitHash}>{r.commit.shortId}</span>
+ <span className={styles.commitSubject}>{r.commit.summary}</span>
+ <span className={styles.commitMeta}>{r.commit.author}</span>
+ <span className={styles.commitMeta}>{formatTime(r.commit.timeMs)}</span>
+ </span>
+ )
+ }
+ />
+ )}
+ </div>
+ </Dialog>
+ );
}
function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onClose: () => void }) {
@@ -262,16 +431,20 @@ export function isPushRejected(message: string): boolean {
* update method) and pushes again ("Auto-update if push of the current branch
* was rejected") or offers to.
*/
-export async function pushWithAutoUpdate(op: Extract<RemoteOp, { op: "push" }>, detail: string): Promise<boolean> {
- if (await runRemote(op, detail)) return true;
+export async function pushWithAutoUpdate(
+ op: Extract<RemoteOp, { op: "push" }>,
+ detail: string,
+ repo: string | null = currentRepo(),
+): Promise<boolean> {
+ if (await runRemote(op, detail, [repo])) return true;
const error = lastRemoteFailure();
if (!error || op.force_with_lease || !isPushRejected(error)) return false;
const git = workflowSettings().vcs.git;
const updateAndPush = async () => {
await saveAll();
- if (!(await runRemote({ op: "pull", rebase: git.updateMethod === "rebase" }, "updating after rejected push")))
- return false;
- return runRemote(op, detail);
+ const pull = { op: "pull" as const, rebase: git.updateMethod === "rebase" };
+ if (!(await runRemote(pull, "updating after rejected push", [repo]))) return false;
+ return runRemote(op, detail, [repo]);
};
if (git.autoUpdateOnPushRejected) return updateAndPush();
notifications().notify({
diff --git a/src/features/vcs/store.ts b/src/features/vcs/store.ts
index 49e3ad003..3e71f0e3d 100644
--- a/src/features/vcs/store.ts
+++ b/src/features/vcs/store.ts
@@ -2,6 +2,11 @@
* Repository state shared by all VCS views: working tree status, HEAD /
* upstream info, branches and stashes. Refreshed (debounced) on `vcsChanged`
* and `fsChanged` events and after every operation.
+ *
+ * A project may hold several repositories (IDEA's VCS roots: nested clones,
+ * submodules). Status covers all of them; branch info, branches and stashes are
+ * those of the selected repository (`repo`), which branch / log / remote
+ * operations act on.
*/
import { onWorkflowSettingsChange, workflowSettings } from "@/platform/workflowSettings";
import { create } from "zustand";
@@ -10,12 +15,18 @@ import { call, commands, isTauri, onIdeEvent } from "@/platform/ipc";
import { setContext } from "@/platform/context";
import { useProject } from "@/platform/project";
import { setFileDecorations } from "@/workbench/contributions";
-import { effectiveKind, statusDecorations, stripSlash } from "./model";
+import { effectiveKind, repoLabel, rootOf, statusDecorations, stripSlash } from "./model";
export interface VcsState {
/** The open project is a git repository. */
available: boolean;
root: string | null;
+ /** Repository roots, the project's own repository first. */
+ roots: string[];
+ /** Root → merge / rebase / cherry-pick / revert in progress there. */
+ operations: Record<string, string>;
+ /** The selected repository's root (branch widget, log, push…). */
+ repo: string | null;
status: FileStatus[];
/** `status` reflects the repository (false until the first refresh). */
statusLoaded: boolean;
@@ -37,6 +48,9 @@ export interface VcsState {
const initial: VcsState = {
available: false,
root: null,
+ roots: [],
+ operations: {},
+ repo: null,
status: [],
statusLoaded: false,
byPath: new Map(),
@@ -53,6 +67,42 @@ const initial: VcsState = {
export const useVcs = create<VcsState>(() => ({ ...initial }));
+/** Root of the selected repository; `null` = the project's primary one. */
+export function currentRepo(): string | null {
+ return useVcs.getState().repo;
+}
+
+/** Root of the innermost repository containing `path`. */
+export function repoOf(path: string, roots: readonly string[] = useVcs.getState().roots): string | null {
+ return rootOf(path, roots);
+}
+
+/** Repository name for display. */
+export function repoName(root: string): string {
+ return repoLabel(root, useVcs.getState().root);
+}
+
+/**
+ * A repository that just stopped in a merge / rebase / cherry-pick / revert (e.g. on
+ * conflicts after Update Project) while `shown` has none in progress: it is selected so
+ * the banner, the branch widget and Continue / Abort act on it.
+ */
+export function attentionRepo(
+ shown: string | null,
+ before: Record<string, string>,
+ now: Record<string, string>,
+): string | null {
+ if (shown && now[shown]) return null;
+ return Object.keys(now).find((root) => !before[root]) ?? null;
+}
+
+/** Selects the repository branch / log / remote operations act on. */
+export function selectRepo(root: string): Promise<void> {
+ if (useVcs.getState().repo === root) return Promise.resolve();
+ useVcs.setState({ repo: root, branches: [], branchesLoaded: false, stashes: [], stashesLoaded: false });
+ return refreshNow();
+}
+
export function conflictedFiles(status: readonly FileStatus[] = useVcs.getState().status): FileStatus[] {
return status.filter((f) => effectiveKind(f) === "conflicted");
}
@@ -98,14 +148,27 @@ export function refreshNow(): Promise<void> {
useVcs.setState({ loading: true });
try {
const s = useVcs.getState();
- const [status, branch, branches, stashes] = await Promise.all([
+ const [vcsRoots, status, branch, branches, stashes] = await Promise.all([
+ call(commands.vcsRoots()),
call(commands.vcsStatus()),
- call(commands.vcsBranchInfo()),
- s.branchesLoaded ? call(commands.vcsBranches()) : Promise.resolve(s.branches),
- s.stashesLoaded ? call(commands.vcsStashes()) : Promise.resolve(s.stashes),
+ call(commands.vcsBranchInfo(s.repo)),
+ s.branchesLoaded ? call(commands.vcsBranches(s.repo)) : Promise.resolve(s.branches),
+ s.stashesLoaded ? call(commands.vcsStashes(s.repo)) : Promise.resolve(s.stashes),
]);
+ const roots = vcsRoots.map((r) => r.root);
+ const operations = Object.fromEntries(vcsRoots.filter((r) => r.operation).map((r) => [r.root, r.operation!]));
+ // `null` (before the first refresh) is the primary repository, listed first.
+ const shown = s.repo && roots.includes(s.repo) ? s.repo : (roots[0] ?? null);
+ const repo = attentionRepo(shown, s.operations, operations) ?? shown;
+ useVcs.setState({ operations });
+ if (repo !== s.repo || roots.join("\n") !== s.roots.join("\n")) useVcs.setState({ roots, repo });
applyStatus(status, branch);
useVcs.setState({ branches, stashes, error: null });
+ // Branch info and branches above are of another repository: load the selected one's.
+ if (repo !== shown || (s.repo && repo !== s.repo)) {
+ useVcs.setState({ branchesLoaded: false, stashesLoaded: false });
+ void refreshNow();
+ }
} catch (e) {
useVcs.setState({ error: e instanceof Error ? e.message : String(e) });
} finally {
@@ -127,13 +190,13 @@ export function applyStatus(status: FileStatus[], branch: BranchInfo | null) {
}
export async function loadBranches(): Promise<Branch[]> {
- const branches = await call(commands.vcsBranches());
+ const branches = await call(commands.vcsBranches(currentRepo()));
useVcs.setState({ branches, branchesLoaded: true });
return branches;
}
export async function loadStashes(): Promise<Stash[]> {
- const stashes = await call(commands.vcsStashes());
+ const stashes = await call(commands.vcsStashes(currentRepo()));
useVcs.setState({ stashes, stashesLoaded: true });
return stashes;
}
@@ -142,6 +205,17 @@ export function statusOf(path: string): FileStatus | undefined {
return useVcs.getState().byPath.get(stripSlash(path));
}
+/** Repositories found below a project that is not itself under git (scanned in the background). */
+async function discoverRoots() {
+ const root = useVcs.getState().root;
+ if (!root || !isTauri()) return;
+ const roots = await call(commands.vcsRoots()).catch(() => []);
+ if (!roots.length || useVcs.getState().root !== root || useVcs.getState().available) return;
+ useVcs.setState({ available: true });
+ setContext("vcsAvailable", true);
+ void refreshNow();
+}
+
/** Tracks the open project and backend events. Returns a disposer. */
export function installVcsStore(): () => void {
const onProject = () => {
@@ -154,12 +228,16 @@ export function installVcsStore(): () => void {
setContext("vcsAvailable", available);
setFileDecorations("vcs", new Map());
if (available && isTauri()) void refreshNow();
+ else if (project) void discoverRoots();
};
onProject();
const unsubProject = useProject.subscribe((s, prev) => {
if (s.project !== prev.project) onProject();
});
- const offVcs = onIdeEvent("vcsChanged", () => scheduleRefresh(200));
+ const offVcs = onIdeEvent("vcsChanged", () => {
+ if (useVcs.getState().available) scheduleRefresh(200);
+ else void discoverRoots();
+ });
const offFs = onIdeEvent("fsChanged", () => scheduleRefresh(250));
const offSettings = onWorkflowSettingsChange(
(s) => s.vcs.showDirtyDirectories,