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.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(vcs): update, push, rebase, tags and file history behave as expected (#1708)
l0ng-aifc938ac567e2
diff --git a/crates/ide-host/src/ops/vcs/commands.rs b/crates/ide-host/src/ops/vcs/commands.rsindex d076c717d..29f4d58a9 100644--- a/crates/ide-host/src/ops/vcs/commands.rs+++ b/crates/ide-host/src/ops/vcs/commands.rs@@ -103,12 +103,20 @@ pub enum RemoteOp {Pull {rebase: bool,},+ /// Update Project › Reset to the Remote Branch.+ ResetToUpstream,Push {force_with_lease: bool,set_upstream: bool,/// Push dialog › Push tags.#[serde(default)]tags: Option<PushTags>,+ /// Plain `--force` (Force push anyway).+ #[serde(default)]+ force: bool,+ /// Push dialog › Run Git hooks unchecked (`--no-verify`).+ #[serde(default)]+ no_verify: bool,},/// Deletes a remote branch; `branch` is the remote-tracking name (`origin/feature`).DeleteBranch {@@ -125,6 +133,23 @@ pub enum RemoteOp {target: Option<String>,#[serde(default)]remote: Option<String>,+ #[serde(default)]+ force: bool,+ /// Record the target as upstream (Push dialog › Set upstream).+ #[serde(default)]+ set_upstream: bool,+ #[serde(default)]+ no_verify: bool,+ },+ /// Push Tag › Push to `remote`.+ PushTag {+ tag: String,+ remote: String,+ },+ /// Deletes tag `tag` on `remote` (Delete on Remote).+ DeleteRemoteTag {+ tag: String,+ remote: String,},/// Fast-forwards local `branch` (not checked out) to its upstream.UpdateBranch {@@ -155,6 +180,8 @@ pub struct GitExecutableInfo {pub enum GitOperation {/// Continue the merge / rebase / cherry-pick / revert in progress.Continue,+ /// Stage and Retry: stage the changes of tracked files, then continue.+ StageAndContinue,Abort,Skip,/// Commits oldest first; `record_origin` adds "(cherry picked from commit …)".@@ -613,6 +640,19 @@ pub async fn vcs_delete_branch(}/// "Restore" of the branch-deleted notification.+/// Deletes a local tag; the result restores it.+pub async fn vcs_delete_tag(host: &Host, window: &str, repo: Option<PathBuf>, name: String) -> IdeResult<DeletedTag> {+ host.require_trust(window)?;+ let project = host.project(window)?;+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.delete_tag(&name))).await+}++pub async fn vcs_restore_tag(host: &Host, window: &str, repo: Option<PathBuf>, deleted: DeletedTag) -> IdeResult<()> {+ host.require_trust(window)?;+ let project = host.project(window)?;+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.restore_tag(&deleted))).await+}+pub async fn vcs_restore_branch(host: &Host,window: &str,@@ -708,26 +748,42 @@ pub async fn vcs_remote(let out = |line: String| {let _ = on_output.send(line);};- let recorded = matches!(op, RemoteOp::Pull { .. } | RemoteOp::PullFrom { .. }).then_some("Git pull");+ let recorded = matches!(op, RemoteOp::Pull { .. } | RemoteOp::PullFrom { .. } | RemoteOp::ResetToUpstream)+ .then_some("Git pull");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 } => {- r.push_with_tags(force_with_lease, set_upstream, tags, &cancel, &out)+ RemoteOp::ResetToUpstream => r.reset_to_upstream(&cancel, &out),+ RemoteOp::Push { force_with_lease, set_upstream, tags, force, no_verify } => {+ r.push_with(PushOptions { force_with_lease, force, set_upstream, tags, no_verify }, &cancel, &out)}RemoteOp::DeleteBranch { branch } => r.delete_remote_branch(&branch, &cancel, &out),- RemoteOp::PushBranch { branch, revision, force_with_lease, target, remote } => r.push_branch_to(+ RemoteOp::PushBranch {+ branch,+ revision,+ force_with_lease,+ target,+ remote,+ force,+ set_upstream,+ no_verify,+ } => r.push_branch_to(&branch,PushBranchOptions {revision: revision.as_deref(),target: target.as_deref(),remote: remote.as_deref(),force_with_lease,+ force,+ set_upstream,+ no_verify,},&cancel,&out,),RemoteOp::UpdateBranch { branch } => r.update_branch(&branch, &cancel, &out),+ RemoteOp::PushTag { tag, remote } => r.push_tag(&tag, &remote, &cancel, &out),+ RemoteOp::DeleteRemoteTag { tag, remote } => r.delete_remote_tag(&tag, &remote, &cancel, &out),RemoteOp::PullFrom { remote, branches, rebase, options } => {r.pull_from(&remote, &branches, rebase, &options, &cancel, &out)}@@ -863,6 +919,7 @@ pub async fn vcs_operation(};project.with_repo_recorded(repo.as_deref(), recorded, |r| match op {GitOperation::Continue => r.continue_operation(&cancel, &out),+ GitOperation::StageAndContinue => r.stage_and_continue(&cancel, &out),GitOperation::Abort => r.abort_operation(&cancel, &out),GitOperation::Skip => r.skip_operation(&cancel, &out),GitOperation::CherryPick { commits, record_origin } => {@@ -1051,6 +1108,12 @@ pub async fn vcs_diff_numstat(blocking(move || project.with_log_repo_at(repo.as_deref(), |r| r.diff_numstat(&from, &to, &paths))).await}+/// Whether the repository has the executable Git hook `name` (Push dialog › Run Git hooks).+pub async fn vcs_has_hook(host: &Host, window: &str, repo: Option<PathBuf>, name: String) -> IdeResult<bool> {+ let project = host.project(window)?;+ blocking(move || project.with_repo_at(repo.as_deref(), |r| r.has_hook(&name))).await+}+/// The best common ancestor of `a` and `b` (`git merge-base`), if any: the New Pull/// Request tab's three-dot diff.pub async fn vcs_merge_base(@@ -1287,6 +1350,13 @@ pub(crate) fn register(d: &mut Dispatcher) {d.add("vcs_delete_branch", |c| async move {vcs_delete_branch(&c.host, &c.window, c.arg("repo")?, c.arg("branch")?).await});+ d.add(+ "vcs_delete_tag",+ |c| async move { vcs_delete_tag(&c.host, &c.window, c.arg("repo")?, c.arg("name")?).await },+ );+ d.add("vcs_restore_tag", |c| async move {+ vcs_restore_tag(&c.host, &c.window, c.arg("repo")?, c.arg("deleted")?).await+ });d.add("vcs_restore_branch", |c| async move {vcs_restore_branch(&c.host, &c.window, c.arg("repo")?, c.arg("deleted")?).await});@@ -1410,6 +1480,7 @@ pub(crate) fn register(d: &mut Dispatcher) {d.add("vcs_diff_numstat", |c| async move {vcs_diff_numstat(&c.host, &c.window, c.arg("repo")?, c.arg("from")?, c.arg("to")?, c.arg("paths")?).await});+ d.add("vcs_has_hook", |c| async move { vcs_has_hook(&c.host, &c.window, c.arg("repo")?, c.arg("name")?).await });d.add("vcs_merge_base", |c| async move {vcs_merge_base(&c.host, &c.window, c.arg("repo")?, c.arg("a")?, c.arg("b")?).await});diff --git a/crates/ide-host/src/trust.rs b/crates/ide-host/src/trust.rsindex 5b8749cab..8ab29e669 100644--- a/crates/ide-host/src/trust.rs+++ b/crates/ide-host/src/trust.rs@@ -341,6 +341,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {| "vcs_diff_revisions"| "vcs_diff_numstat"| "vcs_merge_base"+ | "vcs_has_hook"| "vcs_shelves"| "vcs_shelf_patch"| "vcs_changelists_load"diff --git a/crates/ide-vcs/src/history.rs b/crates/ide-vcs/src/history.rsindex 14873f7b3..593dcbc88 100644--- a/crates/ide-vcs/src/history.rs+++ b/crates/ide-vcs/src/history.rs@@ -93,6 +93,131 @@ fn git_select(Ok(ids)}+/// The commits of a file's history and the path it had in each. The commits that changed+/// the path, merges included (`--full-history --simplify-merges`); where it appears, a+/// rename from any parent continues the history under the old path from that parent.+/// Unlike `--follow`, this sees renames done in merges and history merged in from other+/// branches.+fn file_history(+ r: &Repo,+ scopes: &[String],+ rel: &str,+ first_parent: bool,+ cancel: &CancellationToken,+) -> IdeResult<(HashSet<ObjectId>, HashMap<ObjectId, String>)> {+ let mut ids = HashSet::new();+ let mut paths = HashMap::new();+ let mut starts: std::collections::VecDeque<(Vec<String>, String)> =+ scopes.iter().map(|s| (s.split_whitespace().map(str::to_string).collect(), rel.to_string())).collect();+ let mut started = HashSet::new();+ while let Some((revs, path)) = starts.pop_front() {+ if !started.insert((revs.clone(), path.clone())) {+ continue;+ }+ let mut args: Vec<String> =+ ["log", "--format=%x00%H", "--name-status", "-z", "--full-history", "--simplify-merges", "--no-follow"]+ .map(String::from)+ .into();+ if first_parent {+ args.push("--first-parent".into());+ }+ args.push("--end-of-options".into());+ args.extend(revs);+ let pathspec = ["--".to_string(), format!(":(literal){path}")];+ let run = |args: &[String]| -> IdeResult<Vec<(ObjectId, Option<char>)>> {+ let argv: Vec<&str> = args.iter().chain(&pathspec).map(String::as_str).collect();+ Ok(parse_name_status_log(&crate::cli::run_cancellable(r.root(), &argv, cancel)?.stdout_str()))+ };+ let records = run(&args)?;+ // Where the file appears its history ends: what is behind that is another file of+ // the same name (a rename continues the history below). The commits of the history+ // are those not behind a creation; the statuses come from the full listing (with+ // its parents excluded a merge shows no changes).+ let created: Vec<ObjectId> = records.iter().filter(|(_, s)| *s == Some('A')).map(|(id, _)| *id).collect();+ let kept: Option<HashSet<ObjectId>> = if created.is_empty() {+ None+ } else {+ args.extend(created.iter().map(|id| format!("^{id}^@")));+ Some(run(&args)?.into_iter().map(|(id, _)| id).collect())+ };+ let mut created = Vec::new();+ for (id, first_status) in records {+ if kept.as_ref().is_some_and(|k| !k.contains(&id)) || !ids.insert(id) {+ continue;+ }+ paths.insert(id, path.clone());+ if first_status == Some('A') {+ created.push(id);+ }+ }+ for commit in created {+ let line = crate::cli::run_cancellable(+ r.root(),+ &["rev-list", "--parents", "-n", "1", "--end-of-options", &commit.to_string()],+ cancel,+ )?+ .stdout_str();+ let parents: Vec<&str> =+ line.split_whitespace().skip(1).take(if first_parent { 1 } else { usize::MAX }).collect();+ for parent in parents {+ if let Some(old) = renamed_from(r, parent, &commit.to_string(), &path, cancel)? {+ starts.push_back((vec![parent.to_string()], old));+ }+ }+ }+ }+ Ok((ids, paths))+}++/// `git log --format=%x00%H --name-status -z`: each commit with the status letter of its+/// first change (none for a merge listed without changes).+fn parse_name_status_log(text: &str) -> Vec<(ObjectId, Option<char>)> {+ let mut out: Vec<(ObjectId, Option<char>)> = Vec::new();+ let mut tokens = text.split('\0');+ while let Some(token) = tokens.next() {+ let token = token.trim_start_matches('\n');+ if let Ok(id) = ObjectId::from_hex(token.as_bytes()) {+ out.push((id, None));+ continue;+ }+ let Some(status) = token.chars().next().filter(|c| c.is_ascii_uppercase()) else { continue };+ if !token[1..].bytes().all(|b| b.is_ascii_digit()) {+ continue;+ }+ let paths = if matches!(status, 'R' | 'C') { 2 } else { 1 };+ for _ in 0..paths {+ tokens.next();+ }+ if let Some(last) = out.last_mut() {+ last.1.get_or_insert(status);+ }+ }+ out+}++/// The path `path` had in `parent` when `commit` renamed it.+fn renamed_from(+ r: &Repo,+ parent: &str,+ commit: &str,+ path: &str,+ cancel: &CancellationToken,+) -> IdeResult<Option<String>> {+ let args = ["diff", "-M", "--name-status", "-z", "--diff-filter=R", "--no-ext-diff", parent, commit, "--"];+ let text = crate::cli::run_cancellable(r.root(), &args, cancel)?.stdout_str();+ let mut tokens = text.split('\0');+ while let Some(status) = tokens.next() {+ if !status.starts_with('R') {+ continue;+ }+ let (Some(old), Some(new)) = (tokens.next(), tokens.next()) else { break };+ if new == path {+ return Ok(Some(old.to_string()));+ }+ }+ Ok(None)+}+pub(crate) fn log(r: &Repo, q: &LogQuery, cancel: &CancellationToken) -> IdeResult<Vec<Commit>> {if cancel.is_cancelled() {return Err(IdeError::cancelled());@@ -230,45 +355,8 @@ fn log_indexed(let path_ids = if paths.is_empty() {None} else if q.follow && paths.len() == 1 {- let mut ids = HashSet::new();- let rel = &paths[0];- let mut args = vec![- "log".to_string(),- "--format=%x00%H".into(),- "--name-status".into(),- "-z".into(),- "--follow".into(),- "--topo-order".into(),- ];- if q.first_parent {- args.push("--first-parent".into());- }- args.push("--end-of-options".into());- for scope in &scopes {- let mut args = args.clone();- args.extend(scope.split_whitespace().map(str::to_string));- args.extend(["--".into(), rel.clone()]);- let output =- crate::cli::run_cancellable(r.root(), &args.iter().map(String::as_str).collect::<Vec<_>>(), cancel)?;- let text = output.stdout_str();- let mut tokens = text.split('\0').peekable();- let mut current_path = rel.clone();- while let Some(token) = tokens.next() {- let token = token.trim_start_matches('\n');- if let Ok(id) = ObjectId::from_hex(token.as_bytes()) {- ids.insert(id);- history_paths.insert(id, current_path.clone());- } else if token.starts_with('R') && token[1..].bytes().all(|b| b.is_ascii_digit()) {- if let (Some(old), Some(new)) = (tokens.next(), tokens.next())- && new == current_path- {- current_path = old.to_string();- }- } else if ["A", "D", "M", "T", "U"].contains(&token) {- tokens.next();- }- }- }+ let (ids, at) = file_history(r, &scopes, &paths[0], q.first_parent, cancel)?;+ history_paths = at;Some(ids)} else {Some(git_select(r, &scopes, &[], &paths, q.first_parent, cancel)?)diff --git a/crates/ide-vcs/src/lib.rs b/crates/ide-vcs/src/lib.rsindex f5ef2206d..8595d72d8 100644--- a/crates/ide-vcs/src/lib.rs+++ b/crates/ide-vcs/src/lib.rs@@ -362,6 +362,27 @@ pub struct PushBranchOptions<'a> {pub remote: Option<&'a str>,/// `git push --force-with-lease`.pub force_with_lease: bool,+ /// `git push --force` (Force push anyway after a rejected force-with-lease push).+ pub force: bool,+ /// Record the target as the branch's upstream even when it already has one.+ pub set_upstream: bool,+ /// Skip the pre-push hook (`--no-verify`).+ pub no_verify: bool,+}++/// Options of [`Repo::push_with`]: the Push dialog's choices for the current branch.+#[derive(Clone, Copy, Debug, Default)]+pub struct PushOptions {+ /// `git push --force-with-lease`.+ pub force_with_lease: bool,+ /// `git push --force` (Force push anyway after a rejected force-with-lease push).+ pub force: bool,+ /// Push to the branch's remote under the same name and record it as upstream.+ pub set_upstream: bool,+ /// Push tags too.+ pub tags: Option<PushTags>,+ /// Skip the pre-push hook (`--no-verify`).+ pub no_verify: bool,}/// What an interactive rebase does with one commit.@@ -523,6 +544,15 @@ pub struct DeletedBranch {pub unmerged: bool,}+/// A deleted tag, enough to restore it (Restore in the tag-deleted notification).+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct DeletedTag {+ pub name: String,+ /// What the tag pointed at: its tag object (annotated tags) or commit.+ pub target: String,+}+/// Who stands on each side of the conflicts of the operation in progress (merge editor/// titles, as IDEA labels them).#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]@@ -594,6 +624,7 @@ mod manage;mod ops;mod patch;mod preserve;+pub use ops::UNSTAGED_CHANGES_PREVENT_REBASE;mod refs;mod remotes;mod repo;@@ -1169,8 +1200,7 @@ impl Repo {cancel: &CancellationToken,on_output: &dyn Fn(String),) -> IdeResult<()> {- let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));- write::push(self, force_with_lease, set_upstream, None, cancel, on_output)+ self.push_with(PushOptions { force_with_lease, set_upstream, ..Default::default() }, cancel, on_output)}/// [`Repo::push`] that also pushes tags (Push dialog › Push tags).pub fn push_with_tags(@@ -1180,9 +1210,23 @@ impl Repo {tags: Option<PushTags>,cancel: &CancellationToken,on_output: &dyn Fn(String),+ ) -> IdeResult<()> {+ self.push_with(PushOptions { force_with_lease, set_upstream, tags, ..Default::default() }, cancel, on_output)+ }+ /// Pushes the current branch with the Push dialog's options.+ pub fn push_with(+ &self,+ options: PushOptions,+ cancel: &CancellationToken,+ on_output: &dyn Fn(String),) -> IdeResult<()> {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));- write::push(self, force_with_lease, set_upstream, tags, cancel, on_output)+ write::push(self, options, cancel, on_output)+ }+ /// Whether the repository has an executable hook `name` (e.g. `pre-push`), wherever+ /// `core.hooksPath` puts it: the Push dialog then offers to skip it.+ pub fn has_hook(&self, name: &str) -> IdeResult<bool> {+ write::has_hook(self, name)}/// Pushes a local branch, or its history up to `revision`, to its upstream (Git Log/// › Push…, Push All up to Here).@@ -1216,6 +1260,12 @@ impl Repo {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));write::push_branch(self, branch, options, cancel, on_output)}+ /// Update Project › Reset to the Remote Branch: the current branch is moved to its+ /// freshly fetched tracked branch; local commits are dropped, local changes kept.+ pub fn reset_to_upstream(&self, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ write::reset_to_upstream(self, cancel, on_output)+ }/// Fast-forwards a local branch that is not checked out to its upstream (Branches ›/// Update). Fails when the branch has diverged.pub fn update_branch(&self, branch: &str, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {@@ -1228,7 +1278,12 @@ impl Repo {/// conflicts are unresolved.pub fn continue_operation(&self, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));- ops::continue_op(self, cancel, on_output)+ ops::continue_op(self, false, cancel, on_output)+ }+ /// Stage and Retry: stages the changes of tracked files, then continues.+ pub fn stage_and_continue(&self, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ ops::continue_op(self, true, cancel, on_output)}pub fn abort_operation(&self, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));@@ -1293,6 +1348,38 @@ impl Repo {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));ops::create_tag(self, name, commit, message, force)}+ /// Deletes a local tag, returning what [`Repo::restore_tag`] needs to undo it.+ pub fn delete_tag(&self, name: &str) -> IdeResult<DeletedTag> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ ops::delete_tag(self, name)+ }+ /// Recreates a deleted tag (annotated ones with their message).+ pub fn restore_tag(&self, deleted: &DeletedTag) -> IdeResult<()> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ ops::restore_tag(self, deleted)+ }+ /// Pushes one tag to `remote` (Push Tag › Push to …).+ pub fn push_tag(+ &self,+ tag: &str,+ remote: &str,+ cancel: &CancellationToken,+ on_output: &dyn Fn(String),+ ) -> IdeResult<()> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ ops::push_tag(self, tag, remote, false, cancel, on_output)+ }+ /// Deletes a tag on `remote` (Delete on Remote, after deleting it locally).+ pub fn delete_remote_tag(+ &self,+ tag: &str,+ remote: &str,+ cancel: &CancellationToken,+ on_output: &dyn Fn(String),+ ) -> IdeResult<()> {+ let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));+ ops::push_tag(self, tag, remote, true, cancel, on_output)+ }pub fn tags(&self) -> IdeResult<Vec<String>> {let _scope = crate::ExecutionScope::enter(self.execution_allowed.load(std::sync::atomic::Ordering::Acquire));ops::tags(self)diff --git a/crates/ide-vcs/src/ops.rs b/crates/ide-vcs/src/ops.rsindex 844a95902..b8d58275c 100644--- a/crates/ide-vcs/src/ops.rs+++ b/crates/ide-vcs/src/ops.rs@@ -5,6 +5,7 @@ use crate::cli::{self, run};use crate::repo::{gx, resolve};use crate::{ChangeKind, ChangedFile, FileLineStats, MergeSides, RebaseAction, RebaseEntry, Repo, ResetMode};use ide_core::{CancellationToken, IdeError, IdeResult};+use std::collections::HashSet;/// The in-progress operation git can continue / abort / skip.fn sequencer(r: &Repo) -> IdeResult<&'static str> {@@ -114,13 +115,38 @@ fn check_commits(commits: &[String]) -> IdeResult<()> {Ok(())}+/// Why a rebase can't continue: tracked files changed while it was stopped, not staged.+pub const UNSTAGED_CHANGES_PREVENT_REBASE: &str =+ "There are unstaged changes in tracked files preventing rebase from continuing";++fn changed_paths(r: &Repo, args: &[&str]) -> IdeResult<Vec<String>> {+ let text = run(r.root(), args, None)?.stdout_str();+ Ok(text.split('\0').filter(|p| !p.is_empty()).map(str::to_string).collect())+}+/// Concludes the operation in progress once every conflict is resolved (staged).-pub(crate) fn continue_op(r: &Repo, cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {+/// `stage` first stages the changes of tracked files (Stage and Retry). Without it a+/// rebase stages only edits of files already staged (made while resolving them) and+/// otherwise fails with [`UNSTAGED_CHANGES_PREVENT_REBASE`].+pub(crate) fn continue_op(r: &Repo, stage: bool, cancel: &CancellationToken, out: &dyn Fn(String)) -> IdeResult<()> {let op = sequencer(r)?;let unresolved = unmerged_paths(r)?;if !unresolved.is_empty() {return Err(IdeError::invalid(format!("resolve all conflicts before continuing: {}", unresolved.join(", "))));}+ if stage {+ run(r.root(), &["add", "-u"], None)?;+ } else if op == "rebase" {+ let unstaged = changed_paths(r, &["diff", "--name-only", "-z", "--no-ext-diff"])?;+ if !unstaged.is_empty() {+ let staged: HashSet<String> =+ changed_paths(r, &["diff", "--cached", "--name-only", "-z", "--no-ext-diff"])?.into_iter().collect();+ if !unstaged.iter().all(|p| staged.contains(p)) {+ return Err(IdeError::invalid(UNSTAGED_CHANGES_PREVENT_REBASE));+ }+ cli::run_paths(r.root(), &["add", "-u"], &unstaged)?;+ }+ }let args: &[&str] = match op {// `git merge --continue` commits with the prepared MERGE_MSG."merge" => &["merge", "--continue"],@@ -328,7 +354,7 @@ pub(crate) fn interactive_rebase(let file = work.join(format!("msg-{i}"));std::fs::write(&file, m)?;todo.push_str(&format!(- "exec git commit --amend --allow-empty --no-verify --quiet --cleanup=strip -F {}\n",+ "exec git commit --amend --allow-empty --no-verify --quiet --cleanup=whitespace -F {}\n",quote(&file)));}@@ -383,6 +409,51 @@ pub(crate) fn create_tag(r: &Repo, name: &str, commit: &str, message: Option<&strun(r.root(), &args, message.map(str::as_bytes)).map(|_| ())}+fn tag_ref(name: &str) -> IdeResult<String> {+ let name = name.trim();+ if name.is_empty() || name.starts_with('-') || name.contains("..") || name.contains(':') {+ return Err(IdeError::invalid(format!("'{name}' is not a valid tag name")));+ }+ Ok(format!("refs/tags/{name}"))+}++pub(crate) fn delete_tag(r: &Repo, name: &str) -> IdeResult<crate::DeletedTag> {+ let tag = tag_ref(name)?;+ let target = run(r.root(), &["rev-parse", "-q", "--verify", &tag], None)+ .map_err(|_| IdeError::invalid(format!("Could not find tag {name}")))?+ .stdout_str();+ let target = target.trim().to_string();+ run(r.root(), &["update-ref", "-d", &tag, &target], None)?;+ Ok(crate::DeletedTag { name: name.trim().to_string(), target })+}++pub(crate) fn restore_tag(r: &Repo, deleted: &crate::DeletedTag) -> IdeResult<()> {+ let tag = tag_ref(&deleted.name)?;+ let target = deleted.target.trim();+ if target.is_empty() || target.starts_with('-') {+ return Err(IdeError::invalid("invalid tag target"));+ }+ // Only recreates it: a tag made with that name meanwhile stays.+ run(r.root(), &["update-ref", &tag, target, ""], None).map(|_| ())+}++pub(crate) fn push_tag(+ r: &Repo,+ name: &str,+ remote: &str,+ delete: bool,+ cancel: &CancellationToken,+ on_output: &dyn Fn(String),+) -> IdeResult<()> {+ let tag = tag_ref(name)?;+ let remote = remote.trim();+ if remote.is_empty() || remote.starts_with('-') {+ return Err(IdeError::invalid(format!("invalid remote '{remote}'")));+ }+ let spec = if delete { format!(":{tag}") } else { format!("{tag}:{tag}") };+ cli::run_streaming(r.root(), &["push", "--progress", remote, &spec], cancel, on_output)+}+/// Tag names, sorted.pub(crate) fn tags(r: &Repo) -> IdeResult<Vec<String>> {let repo = r.gix()?;diff --git a/crates/ide-vcs/src/write.rs b/crates/ide-vcs/src/write.rsindex 1c6ab0d09..1e4549744 100644--- a/crates/ide-vcs/src/write.rs+++ b/crates/ide-vcs/src/write.rs@@ -927,20 +927,16 @@ pub(crate) fn delete_remote_branch(pub(crate) fn push(r: &Repo,- force_with_lease: bool,- set_upstream: bool,- tags: Option<crate::PushTags>,+ o: crate::PushOptions,cancel: &CancellationToken,on_output: &dyn Fn(String),) -> IdeResult<()> {let mut args: Vec<String> = vec!["push".into(), "--progress".into()];- if force_with_lease {- args.push("--force-with-lease".into());- }- if tags == Some(crate::PushTags::CurrentBranch) {+ args.extend(force_args(o.force, o.force_with_lease, o.no_verify));+ if o.tags == Some(crate::PushTags::CurrentBranch) {args.push("--follow-tags".into());}- if set_upstream {+ if o.set_upstream {let repo = r.gix()?;let head =repo.head_name().map_err(gx)?.ok_or_else(|| IdeError::invalid("cannot set upstream: HEAD is detached"))?;@@ -963,14 +959,49 @@ pub(crate) fn push(}let argv: Vec<&str> = args.iter().map(String::as_str).collect();cli::run_streaming(r.root(), &argv, cancel, on_output)?;- if tags == Some(crate::PushTags::All) {+ if o.tags == Some(crate::PushTags::All) {// `git push --tags` alone pushes only tags, so it runs after the branch push.let remote = push_remote(r)?;- cli::run_streaming(r.root(), &["push", "--progress", &remote, "--tags"], cancel, on_output)?;+ let mut args = vec!["push", "--progress"];+ if o.no_verify {+ args.push("--no-verify");+ }+ args.extend([remote.as_str(), "--tags"]);+ cli::run_streaming(r.root(), &args, cancel, on_output)?;}Ok(())}+/// `--force` / `--force-with-lease` and `--no-verify` of a push.+fn force_args(force: bool, force_with_lease: bool, no_verify: bool) -> Vec<String> {+ let mut args = Vec::new();+ if force {+ args.push("--force".into());+ } else if force_with_lease {+ args.push("--force-with-lease".into());+ }+ if no_verify {+ args.push("--no-verify".into());+ }+ args+}++pub(crate) fn has_hook(r: &Repo, name: &str) -> IdeResult<bool> {+ if name.is_empty() || name.contains(['/', '\\']) {+ return Err(IdeError::invalid(format!("invalid hook name '{name}'")));+ }+ let path = run(r.root(), &["rev-parse", "--git-path", &format!("hooks/{name}")], None)?.stdout_str();+ let path = r.root().join(path.trim());+ let Ok(meta) = std::fs::metadata(&path) else { return Ok(false) };+ #[cfg(unix)]+ {+ use std::os::unix::fs::PermissionsExt;+ Ok(meta.is_file() && meta.permissions().mode() & 0o111 != 0)+ }+ #[cfg(not(unix))]+ Ok(meta.is_file())+}+/// Remote and branch name a local branch pulls from (`branch.<b>.remote` / `.merge`).fn branch_upstream(r: &Repo, branch: &str) -> Option<(String, String)> {let get = |key: &str| {@@ -1001,10 +1032,18 @@ pub(crate) fn push_branch(cancel: &CancellationToken,on_output: &dyn Fn(String),) -> IdeResult<()> {- let PushBranchOptions { revision, target, remote: remote_override, force_with_lease } = opts;+ let PushBranchOptions {+ revision,+ target,+ remote: remote_override,+ force_with_lease,+ force,+ set_upstream,+ no_verify,+ } = opts;check_local_branch(r, branch)?;let remote_override = remote_override.map(str::trim).filter(|s| !s.is_empty());- let (remote, mut name, set_upstream) = match (remote_override, branch_upstream(r, branch)) {+ let (remote, mut name, untracked) = match (remote_override, branch_upstream(r, branch)) {// An explicit remote keeps the upstream's branch name but pushes elsewhere.(Some(remote), Some((_, name))) => (check_rev(remote)?.to_string(), name, false),(Some(remote), None) => (check_rev(remote)?.to_string(), branch.to_string(), revision.is_none()),@@ -1025,10 +1064,8 @@ pub(crate) fn push_branch(None => format!("refs/heads/{branch}"),};let mut args: Vec<String> = vec!["push".into(), "--progress".into()];- if force_with_lease {- args.push("--force-with-lease".into());- }- if set_upstream {+ args.extend(force_args(force, force_with_lease, no_verify));+ if untracked || (set_upstream && revision.is_none()) {args.push("--set-upstream".into());}args.extend([remote, format!("{source}:refs/heads/{target}")]);@@ -1050,6 +1087,27 @@ pub(crate) fn update_branch(cli::run_streaming(r.root(), &["fetch", "--progress", &remote, &refspec], cancel, on_output)}+/// Update Project › Reset to the Remote Branch: fetches the current branch's tracked+/// branch and moves the branch to it, dropping local commits. Local changes are put+/// aside and brought back (an error with the conflicts left in place when they clash).+pub(crate) fn reset_to_upstream(r: &Repo, cancel: &CancellationToken, on_output: &dyn Fn(String)) -> IdeResult<()> {+ let head = run(r.root(), &["symbolic-ref", "-q", "--short", "HEAD"], None)+ .map_err(|_| IdeError::invalid("cannot reset: HEAD is detached"))?+ .stdout_str();+ let head = head.trim();+ let no_tracked =+ || IdeError::invalid(format!("no tracked branch configured for branch {head} or the branch doesn't exist"));+ let (remote, name) = branch_upstream(r, head).ok_or_else(no_tracked)?;+ cli::run_streaming(r.root(), &["fetch", "--progress", &remote], cancel, on_output)?;+ let tracked = format!("refs/remotes/{remote}/{name}");+ if run(r.root(), &["rev-parse", "-q", "--verify", &format!("{tracked}^{{commit}}")], None).is_err() {+ return Err(no_tracked());+ }+ crate::preserve::around(r, "Local changes saved before reset", || {+ run(r.root(), &["reset", "-q", "--keep", &tracked], None).map(|_| ())+ })+}+/// The remote the current branch pushes to (`origin`, or the only remote, by default)./// The remote and ref HEAD's branch tracks when the ref has another name: a plain/// `git push` refuses that under the default `push.default=simple`.diff --git a/crates/ide-vcs/tests/git_workflows.rs b/crates/ide-vcs/tests/git_workflows.rsindex be30861b0..4103350ec 100644--- a/crates/ide-vcs/tests/git_workflows.rs+++ b/crates/ide-vcs/tests/git_workflows.rs@@ -306,6 +306,17 @@ fn interactive_rebase_reorder_squash_fixup_reword_drop() {assert_eq!(fx.git(&["show", "--format=", "--name-only", "HEAD"]), "f1.txt\nf2.txt\nf3.txt");}+#[test]+fn interactive_rebase_reword_keeps_lines_starting_with_a_hash() {+ let (fx, ids) = linear();+ let (cancel, out) = quiet();+ let message = "Subject\n\n#body starting with a hash";+ fx.repo()+ .interactive_rebase(Some(&ids[2]), &[entry(&ids[3], RebaseAction::Reword, Some(message))], &cancel, &out)+ .unwrap();+ assert_eq!(fx.git(&["log", "-1", "--format=%B"]), message);+}+#[test]fn interactive_rebase_squash_without_message_combines_messages() {let (fx, ids) = linear();@@ -407,6 +418,89 @@ fn interactive_rebase_conflict_stops_then_continues_with_reword() {assert_eq!(fx.subjects(), vec!["one", "two first", "base"]);}+/// `main` and `feature` both change `c.txt`: rebasing feature onto main stops on it.+fn rebase_stopped_on_a_conflict() -> (Fixture, Repo) {+ let fx = Fixture::new();+ fx.write("c.txt", "base\n");+ fx.write("other.txt", "other\n");+ fx.commit_all("base");+ fx.git(&["switch", "-q", "-c", "feature"]);+ fx.write("c.txt", "feature\n");+ fx.commit_all("feature change");+ fx.git(&["switch", "-q", "main"]);+ fx.write("c.txt", "main\n");+ fx.commit_all("main change");+ fx.git(&["switch", "-q", "feature"]);+ let repo = fx.repo();+ assert!(repo.rebase("main").is_err());+ assert_eq!(repo.branch_info().unwrap().operation.as_deref(), Some("rebase"));+ (fx, repo)+}++#[test]+fn edits_of_a_resolved_file_go_with_it_when_the_rebase_continues() {+ let (fx, repo) = rebase_stopped_on_a_conflict();+ fx.write("c.txt", "resolved\n");+ repo.stage(&[fx.path("c.txt")]).unwrap();+ fx.write("c.txt", "resolved\nmore\n");+ let (cancel, out) = quiet();+ repo.continue_operation(&cancel, &out).unwrap();+ assert_eq!(repo.branch_info().unwrap().operation, None);+ assert_eq!(fx.git(&["show", "HEAD:c.txt"]), "resolved\nmore");+}++#[test]+fn unstaged_changes_of_other_files_stop_the_rebase_until_staged() {+ let (fx, repo) = rebase_stopped_on_a_conflict();+ fx.write("c.txt", "resolved\n");+ repo.stage(&[fx.path("c.txt")]).unwrap();+ fx.write("other.txt", "changed while stopped\n");+ let (cancel, out) = quiet();+ let err = repo.continue_operation(&cancel, &out).unwrap_err();+ assert_eq!(err.message, UNSTAGED_CHANGES_PREVENT_REBASE);+ assert_eq!(repo.branch_info().unwrap().operation.as_deref(), Some("rebase"));+ repo.stage_and_continue(&cancel, &out).unwrap();+ assert_eq!(repo.branch_info().unwrap().operation, None);+ assert_eq!(fx.git(&["show", "HEAD:other.txt"]), "changed while stopped");+}++#[test]+fn stage_and_retry_after_editing_a_commit() {+ let (fx, ids) = linear();+ let repo = fx.repo();+ let (cancel, out) = quiet();+ let plan = [entry(&ids[2], RebaseAction::Edit, None), entry(&ids[3], RebaseAction::Pick, None)];+ repo.interactive_rebase(Some(&ids[1]), &plan, &cancel, &out).unwrap();+ assert_eq!(repo.branch_info().unwrap().operation.as_deref(), Some("rebase"));+ fx.write("f1.txt", "edited\n");+ std::fs::remove_file(fx.path("f2.txt")).unwrap();+ assert!(repo.continue_operation(&cancel, &out).is_err());+ repo.stage_and_continue(&cancel, &out).unwrap();+ assert_eq!(repo.branch_info().unwrap().operation, None);+ assert_eq!(fx.git(&["status", "--porcelain"]), "");+ assert!(!fx.exists("f2.txt"));+}++#[test]+fn rebase_and_merge_onto_a_branch_named_like_a_tag_use_the_branch() {+ let fx = Fixture::new();+ fx.write("a.txt", "a\n");+ fx.commit_all("base");+ fx.git(&["tag", "main"]);+ fx.write("m.txt", "m\n");+ let tip = fx.commit_all("main moved on");+ fx.git(&["switch", "-q", "-c", "feature", "HEAD~1"]);+ fx.write("f.txt", "f\n");+ fx.commit_all("feature");+ let repo = fx.repo();+ repo.rebase("refs/heads/main").unwrap();+ assert_eq!(fx.git(&["rev-parse", "HEAD~1"]), tip);+ fx.git(&["reset", "-q", "--hard", "HEAD~1"]);+ fx.git(&["switch", "-q", "-c", "other", "refs/heads/main~1"]);+ repo.merge("refs/heads/main").unwrap();+ assert_eq!(fx.head(), tip, "fast-forwarded to the branch, not the tag");+}+#[test]fn interactive_rebase_edit_stops_for_amend() {let (fx, ids) = linear();@@ -524,6 +618,157 @@ fn update_merge_with_local_changes_to_the_same_file() {assert_eq!(fx.git(&["rev-list", "--count", "--merges", "HEAD"]), "1");}+#[test]+fn update_with_rebase_keeps_a_file_added_then_deleted_added_to_the_index() {+ let (fx, bare) = Fixture::with_origin();+ fx.push_from_other(&bare, "remote.txt", "r\n");+ fx.write("local.txt", "l\n");+ fx.commit_all("local");+ fx.write("ad.txt", "x\n");+ fx.git(&["add", "ad.txt"]);+ std::fs::remove_file(fx.path("ad.txt")).unwrap();+ let (cancel, out) = quiet();+ fx.repo().pull(true, &cancel, &out).unwrap();+ assert!(fx.exists("remote.txt"));+ assert!(fx.git(&["status", "--porcelain", "--", "ad.txt"]).starts_with('A'), "still added");+}++#[test]+fn reset_to_the_remote_branch_drops_local_commits_and_keeps_local_changes() {+ let (fx, bare) = Fixture::with_origin();+ for i in 0..3 {+ fx.push_from_other(&bare, "bro.txt", &format!("bro {i}\n"));+ }+ fx.write("local1.txt", "1\n");+ fx.commit_all("local commit");+ fx.write("untracked.txt", "u\n");+ fx.write("a.txt", "edited\n");+ fx.git(&["add", "a.txt"]);+ let (cancel, out) = quiet();+ fx.repo().reset_to_upstream(&cancel, &out).unwrap();+ assert_eq!(fx.head(), fx.git(&["rev-parse", "origin/main"]));+ assert!(!fx.exists("local1.txt"), "files of local commits are gone");+ assert!(fx.exists("untracked.txt"));+ assert_eq!(fx.git(&["status", "--porcelain", "--", "a.txt"]), "M a.txt", "staged changes stay staged");+ assert_eq!(fx.git(&["stash", "list"]), "");+}++#[test]+fn reset_to_the_remote_branch_without_new_remote_commits_drops_local_ones() {+ let (fx, _bare) = Fixture::with_origin();+ let before = fx.head();+ fx.write("local1.txt", "1\n");+ fx.commit_all("local commit");+ let (cancel, out) = quiet();+ fx.repo().reset_to_upstream(&cancel, &out).unwrap();+ assert_eq!(fx.head(), before);+}++#[test]+fn reset_to_the_remote_branch_leaves_conflicting_local_changes_to_resolve() {+ let (fx, bare) = Fixture::with_origin();+ fx.push_from_other(&bare, "bro.txt", "bro\n");+ fx.write("bro.txt", "local content\n");+ fx.git(&["add", "bro.txt"]);+ let (cancel, out) = quiet();+ assert!(fx.repo().reset_to_upstream(&cancel, &out).is_err());+ assert_eq!(fx.head(), fx.git(&["rev-parse", "origin/main"]));+ assert!(fx.read("bro.txt").contains("<<<<<<<"), "the clash is left to resolve");+ assert_eq!(fx.git(&["stash", "list"]).lines().count(), 1, "a copy stays in the stash");+}++#[test]+fn reset_to_the_remote_branch_needs_a_tracked_branch_that_exists() {+ let (fx, bare) = Fixture::with_origin();+ let (cancel, out) = quiet();+ fx.git(&["branch", "--unset-upstream"]);+ let err = fx.repo().reset_to_upstream(&cancel, &out).unwrap_err();+ assert!(err.message.contains("no tracked branch"), "{}", err.message);++ fx.git(&["push", "-q", "-u", "origin", "main:feature"]);+ fx.git(&["switch", "-q", "-c", "feature", "--track", "origin/feature"]);+ git_in(&bare, &["branch", "-D", "feature"]);+ fx.git(&["fetch", "-q", "--prune"]);+ let err = fx.repo().reset_to_upstream(&cancel, &out).unwrap_err();+ assert!(err.message.contains("no tracked branch"), "{}", err.message);+}++#[cfg(unix)]+#[test]+fn push_can_skip_a_failing_pre_push_hook() {+ use std::os::unix::fs::PermissionsExt;+ let (fx, _bare) = Fixture::with_origin();+ let repo = fx.repo();+ assert!(!repo.has_hook("pre-push").unwrap());+ let hook = fx.path(".git/hooks/pre-push");+ std::fs::create_dir_all(hook.parent().unwrap()).unwrap();+ std::fs::write(&hook, "#!/bin/sh\necho refused >&2\nexit 1\n").unwrap();+ std::fs::set_permissions(&hook, std::fs::Permissions::from_mode(0o755)).unwrap();+ assert!(repo.has_hook("pre-push").unwrap());++ fx.write("local.txt", "l\n");+ fx.commit_all("local");+ let (cancel, out) = quiet();+ assert!(repo.push(false, false, &cancel, &out).is_err(), "the hook refuses the push");+ let options = PushOptions { no_verify: true, ..Default::default() };+ repo.push_with(options, &cancel, &out).unwrap();+ assert_eq!(fx.head(), fx.git(&["rev-parse", "origin/main"]));+}++#[test]+fn force_push_without_lease_overwrites_a_remote_that_moved() {+ let (fx, bare) = Fixture::with_origin();+ fx.write("local.txt", "l\n");+ fx.commit_all("local");+ fx.push_from_other(&bare, "remote.txt", "r\n");+ fx.git(&["fetch", "-q"]);+ fx.push_from_other(&bare, "remote2.txt", "r\n");+ let repo = fx.repo();+ let (cancel, out) = quiet();+ let lease = PushOptions { force_with_lease: true, ..Default::default() };+ let err = repo.push_with(lease, &cancel, &out).unwrap_err();+ assert!(err.message.contains("stale info"), "{}", err.message);+ repo.push_with(PushOptions { force: true, ..Default::default() }, &cancel, &out).unwrap();+ assert_eq!(git_in(&bare, &["rev-parse", "main"]), fx.head());+}++#[test]+fn push_to_another_branch_can_make_it_the_upstream() {+ let (fx, _bare) = Fixture::with_origin();+ fx.write("local.txt", "l\n");+ fx.commit_all("local");+ let repo = fx.repo();+ let (cancel, out) = quiet();+ let to = |target, set_upstream| PushBranchOptions { target: Some(target), set_upstream, ..Default::default() };+ repo.push_branch_to("main", to("feature", false), &cancel, &out).unwrap();+ assert_eq!(fx.git(&["rev-parse", "--abbrev-ref", "main@{u}"]), "origin/main", "upstream kept");+ repo.push_branch_to("main", to("feature-1", true), &cancel, &out).unwrap();+ assert_eq!(fx.git(&["rev-parse", "--abbrev-ref", "main@{u}"]), "origin/feature-1");+}++#[test]+fn tags_are_pushed_one_at_a_time_deleted_restored_and_deleted_on_the_remote() {+ let (fx, bare) = Fixture::with_origin();+ fx.git(&["tag", "-a", "v1", "-m", "release one"]);+ fx.git(&["tag", "v2"]);+ let repo = fx.repo();+ let (cancel, out) = quiet();+ repo.push_tag("v1", "origin", &cancel, &out).unwrap();+ assert_eq!(git_in(&bare, &["tag"]), "v1", "only the chosen tag goes");+ repo.push_tag("v1", "origin", &cancel, &out).unwrap();++ let deleted = repo.delete_tag("v1").unwrap();+ assert_eq!(fx.git(&["tag"]), "v2");+ repo.restore_tag(&deleted).unwrap();+ assert_eq!(fx.git(&["cat-file", "-t", "v1"]), "tag", "annotated, as it was");+ assert!(fx.git(&["tag", "-n1", "v1"]).contains("release one"));++ repo.delete_tag("v1").unwrap();+ repo.delete_remote_tag("v1", "origin", &cancel, &out).unwrap();+ assert_eq!(git_in(&bare, &["tag"]), "");+ assert!(repo.delete_tag("missing").is_err());+}+#[test]fn fetch_prunes_deleted_remote_branches() {let (fx, bare) = Fixture::with_origin();diff --git a/crates/ide-vcs/tests/log_projection.rs b/crates/ide-vcs/tests/log_projection.rsindex a10d7dd63..451613663 100644--- a/crates/ide-vcs/tests/log_projection.rs+++ b/crates/ide-vcs/tests/log_projection.rs@@ -462,3 +462,153 @@ fn case_insensitive_text_folds_non_ascii() {assert_eq!(ids(LogQuery { text: Some("ärger привет".into()), ..Default::default() }), vec![hit.clone()]);assert!(ids(LogQuery { text: Some("ärger".into()), text_match_case: true, ..Default::default() }).is_empty());}++/// File history (Show History of a file) as (subject, path at that revision), newest first.+fn file_history(dir: &Path, path: &str) -> Vec<(String, String)> {+ let repo = Repo::discover(dir).unwrap().unwrap();+ let log = repo.log(&LogQuery { path: Some(path.into()), follow: true, ..Default::default() }).unwrap();+ log.into_iter().map(|c| (c.summary, c.history_path.unwrap_or_default())).collect()+}++fn history_repo() -> (tempfile::TempDir, std::path::PathBuf) {+ let tmp = tempfile::tempdir().unwrap();+ let dir = tmp.path().to_path_buf();+ git(&dir, &["init", "-q"]);+ (tmp, dir)+}++fn pairs(list: &[(&str, &str)]) -> Vec<(String, String)> {+ list.iter().map(|(a, b)| (a.to_string(), b.to_string())).collect()+}++#[test]+fn file_history_goes_through_a_rename_on_a_merged_branch() {+ let (_tmp, dir) = history_repo();+ commit(&dir, "file.txt", "Created");+ git(&dir, &["switch", "-qc", "feature"]);+ git(&dir, &["mv", "file.txt", "renamed.txt"]);+ git(&dir, &["commit", "-qm", "Renamed"]);+ git(&dir, &["switch", "-q", "main"]);+ commit(&dir, "other.txt", "Unrelated");+ git(&dir, &["merge", "-q", "--no-ff", "-m", "Merged", "feature"]);+ commit(&dir, "renamed.txt", "Modified");+ let history = file_history(&dir, "renamed.txt");+ assert_eq!(history, pairs(&[("Modified", "renamed.txt"), ("Renamed", "renamed.txt"), ("Created", "file.txt")]));+}++#[test]+fn file_history_goes_through_a_rename_done_in_a_merge_commit() {+ let (_tmp, dir) = history_repo();+ commit(&dir, "file.txt", "Created");+ git(&dir, &["switch", "-qc", "feature"]);+ commit(&dir, "side.txt", "Side");+ git(&dir, &["switch", "-q", "main"]);+ git(&dir, &["merge", "-q", "--no-ff", "--no-commit", "feature"]);+ git(&dir, &["mv", "file.txt", "renamed.txt"]);+ git(&dir, &["commit", "-qm", "Merge with rename"]);+ let history = file_history(&dir, "renamed.txt");+ assert_eq!(history, pairs(&[("Merge with rename", "renamed.txt"), ("Created", "file.txt")]));+}++#[test]+fn file_history_shows_merges_that_change_the_file_but_not_trivial_ones() {+ let (_tmp, dir) = history_repo();+ std::fs::write(dir.join("file.txt"), "one\ntwo\nthree\n").unwrap();+ git(&dir, &["add", "-A"]);+ git(&dir, &["commit", "-qm", "Created"]);+ git(&dir, &["switch", "-qc", "feature"]);+ std::fs::write(dir.join("file.txt"), "one\ntwo\nthree\nfeature\n").unwrap();+ git(&dir, &["commit", "-qam", "Feature"]);+ git(&dir, &["switch", "-q", "main"]);+ commit(&dir, "other.txt", "Other");+ git(&dir, &["merge", "-q", "--no-ff", "-m", "Trivial merge", "feature"]);+ assert_eq!(+ file_history(&dir, "file.txt").into_iter().map(|(s, _)| s).collect::<Vec<_>>(),+ vec!["Feature", "Created"]+ );++ git(&dir, &["switch", "-qc", "second", "HEAD~1"]);+ std::fs::write(dir.join("file.txt"), "zero\none\ntwo\nthree\n").unwrap();+ git(&dir, &["commit", "-qam", "Second"]);+ git(&dir, &["switch", "-q", "main"]);+ git(&dir, &["merge", "-q", "--no-ff", "--no-commit", "second"]);+ std::fs::write(dir.join("file.txt"), "zero\none\ntwo\nthree\nfeature\nresolved\n").unwrap();+ git(&dir, &["commit", "-qam", "Non-trivial merge"]);+ let subjects: Vec<String> = file_history(&dir, "file.txt").into_iter().map(|(s, _)| s).collect();+ assert_eq!(subjects[0], "Non-trivial merge");+ assert!(subjects.contains(&"Second".to_string()) && subjects.contains(&"Feature".to_string()));+}++#[test]+fn file_history_through_a_monorepo_merge_keeps_each_side() {+ let (_tmp, dir) = history_repo();+ commit(&dir, "file1.txt", "Created file1");+ git(&dir, &["switch", "-q", "--orphan", "repo2"]);+ commit(&dir, "file2.txt", "Created file2");+ git(&dir, &["switch", "-q", "main"]);+ git(&dir, &["merge", "-q", "--no-commit", "--allow-unrelated-histories", "repo2"]);+ std::fs::create_dir_all(dir.join("repo1")).unwrap();+ std::fs::create_dir_all(dir.join("repo2")).unwrap();+ git(&dir, &["mv", "file1.txt", "repo1/file1.txt"]);+ git(&dir, &["mv", "file2.txt", "repo2/file2.txt"]);+ git(&dir, &["commit", "-qm", "monorepo merge"]);+ assert_eq!(+ file_history(&dir, "repo1/file1.txt"),+ pairs(&[("monorepo merge", "repo1/file1.txt"), ("Created file1", "file1.txt")])+ );+ assert_eq!(+ file_history(&dir, "repo2/file2.txt"),+ pairs(&[("monorepo merge", "repo2/file2.txt"), ("Created file2", "file2.txt")])+ );+}++#[test]+fn file_history_through_parallel_renames_names_the_path_of_each_revision() {+ let (_tmp, dir) = history_repo();+ std::fs::write(dir.join("file.txt"), "base\n").unwrap();+ git(&dir, &["add", "-A"]);+ git(&dir, &["commit", "-qm", "Created"]);+ git(&dir, &["switch", "-qc", "other"]);+ std::fs::write(dir.join("file.txt"), "base\nother\n").unwrap();+ git(&dir, &["commit", "-qam", "Modified on other"]);+ git(&dir, &["mv", "file.txt", "renamed.txt"]);+ git(&dir, &["commit", "-qm", "Renamed on other"]);+ git(&dir, &["switch", "-q", "main"]);+ std::fs::write(dir.join("file.txt"), "main\nbase\n").unwrap();+ git(&dir, &["commit", "-qam", "Modified on main"]);+ git(&dir, &["mv", "file.txt", "renamed.txt"]);+ git(&dir, &["commit", "-qm", "Renamed on main"]);+ // Both sides changed the file: the merge stops for the resolution.+ let _ = Command::new("git").current_dir(&dir).args(["merge", "-q", "--no-ff", "--no-commit", "other"]).output();+ std::fs::write(dir.join("renamed.txt"), "main\nbase\nother\nmerged\n").unwrap();+ git(&dir, &["add", "-A"]);+ git(&dir, &["commit", "-qm", "Merged other"]);+ let mut history = file_history(&dir, "renamed.txt");+ history.sort();+ assert_eq!(+ history,+ pairs(&[+ ("Created", "file.txt"),+ ("Merged other", "renamed.txt"),+ ("Modified on main", "file.txt"),+ ("Modified on other", "file.txt"),+ ("Renamed on main", "renamed.txt"),+ ("Renamed on other", "renamed.txt"),+ ])+ );+}++#[test]+fn file_history_through_a_cyclic_rename() {+ let (_tmp, dir) = history_repo();+ commit(&dir, "a.txt", "Created a");+ git(&dir, &["mv", "a.txt", "b.txt"]);+ git(&dir, &["commit", "-qm", "a to b"]);+ commit(&dir, "b.txt", "Modified b");+ git(&dir, &["mv", "b.txt", "a.txt"]);+ git(&dir, &["commit", "-qm", "b to a"]);+ assert_eq!(+ file_history(&dir, "a.txt"),+ pairs(&[("b to a", "a.txt"), ("Modified b", "b.txt"), ("a to b", "b.txt"), ("Created a", "a.txt")])+ );+}diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex 62e190609..ccf96577e 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -278,6 +278,8 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {vcs::vcs_checkout,vcs::vcs_delete_branch,vcs::vcs_restore_branch,+ vcs::vcs_delete_tag,+ vcs::vcs_restore_tag,vcs::vcs_create_branch,vcs::vcs_undo_commit,vcs::vcs_reword,@@ -313,6 +315,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {vcs::vcs_compare_paths,vcs::vcs_diff_revisions,vcs::vcs_diff_numstat,+ vcs::vcs_has_hook,vcs::vcs_merge_base,vcs::vcs_create_patch,vcs::vcs_patch_preview,diff --git a/src-tauri/src/commands/vcs.rs b/src-tauri/src/commands/vcs.rsindex 6ed81767d..29cc34b92 100644--- a/src-tauri/src/commands/vcs.rs+++ b/src-tauri/src/commands/vcs.rs@@ -323,6 +323,30 @@ pub async fn vcs_delete_branch(ide_host::ops::vcs::vcs_delete_branch(&state.host, window.label(), repo, branch).await}+/// Tag › Delete: the result is what "Restore" needs.+#[tauri::command]+#[specta::specta]+pub async fn vcs_delete_tag(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ name: String,+) -> IdeResult<ide_vcs::DeletedTag> {+ ide_host::ops::vcs::vcs_delete_tag(&state.host, window.label(), repo, name).await+}++/// "Restore" of the tag-deleted notification.+#[tauri::command]+#[specta::specta]+pub async fn vcs_restore_tag(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ deleted: ide_vcs::DeletedTag,+) -> IdeResult<()> {+ ide_host::ops::vcs::vcs_restore_tag(&state.host, window.label(), repo, deleted).await+}+/// "Restore" of the branch-deleted notification.#[tauri::command]#[specta::specta]@@ -673,6 +697,18 @@ pub async fn vcs_diff_numstat(ide_host::ops::vcs::vcs_diff_numstat(&state.host, window.label(), repo, from, to, paths).await}+/// Whether the repository has the executable Git hook `name` (Push dialog › Run Git hooks).+#[tauri::command]+#[specta::specta]+pub async fn vcs_has_hook(+ window: Window,+ state: State<'_, AppState>,+ repo: Option<PathBuf>,+ name: String,+) -> IdeResult<bool> {+ ide_host::ops::vcs::vcs_has_hook(&state.host, window.label(), repo, name).await+}+/// The best common ancestor of `a` and `b` (`git merge-base`), if any.#[tauri::command]#[specta::specta]diff --git a/src/bindings.ts b/src/bindings.tsindex 5255bfb30..9082906df 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -523,6 +523,10 @@ export const commands = {vcsDeleteBranch: (repo: string | null, branch: string) => typedError<DeletedBranch, IdeError>(__TAURI_INVOKE("vcs_delete_branch", { repo, branch })),/** "Restore" of the branch-deleted notification. */vcsRestoreBranch: (repo: string | null, deleted: DeletedBranch) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_restore_branch", { repo, deleted })),+ /** Tag › Delete: the result is what "Restore" needs. */+ vcsDeleteTag: (repo: string | null, name: string) => typedError<DeletedTag, IdeError>(__TAURI_INVOKE("vcs_delete_tag", { repo, name })),+ /** "Restore" of the tag-deleted notification. */+ vcsRestoreTag: (repo: string | null, deleted: DeletedTag) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_restore_tag", { repo, deleted })),/** New Branch: creates `name` at `start` (HEAD when absent), optionally checking it out. */vcsCreateBranch: (repo: string | null, name: string, start: string | null, checkout: boolean) => typedError<null, IdeError>(__TAURI_INVOKE("vcs_create_branch", { repo, name, start, checkout })),/**@@ -595,6 +599,8 @@ export const commands = {* `paths` limits the diff to those repository-relative paths; empty diffs every file.*/vcsDiffNumstat: (repo: string | null, from: string, to: string, paths: string[]) => typedError<FileLineStats[], IdeError>(__TAURI_INVOKE("vcs_diff_numstat", { repo, from, to, paths })),+ /** Whether the repository has the executable Git hook `name` (Push dialog › Run Git hooks). */+ vcsHasHook: (repo: string | null, name: string) => typedError<boolean, IdeError>(__TAURI_INVOKE("vcs_has_hook", { repo, name })),/** The best common ancestor of `a` and `b` (`git merge-base`), if any. */vcsMergeBase: (repo: string | null, a: string, b: string) => typedError<string | null, IdeError>(__TAURI_INVOKE("vcs_merge_base", { repo, a, b })),vcsCreatePatch: (repo: string | null, source: PatchSource) => typedError<string, IdeError>(__TAURI_INVOKE("vcs_create_patch", { repo, source })),@@ -2934,6 +2940,13 @@ export type DeletedBranch = {unmerged: boolean,};+/** A deleted tag, enough to restore it (Restore in the tag-deleted notification). */+export type DeletedTag = {+ name: string,+ /** What the tag pointed at: its tag object (annotated tags) or commit. */+ target: string,+};+export type DependencyUpdate = {latest: string,replacement: string,@@ -3922,7 +3935,9 @@ export type GitExecutableInfo = {export type GitOperation =/** Continue the merge / rebase / cherry-pick / revert in progress. */-{ op: "continue" } | { op: "abort" } | { op: "skip" } |+{ op: "continue" } |+/** Stage and Retry: stage the changes of tracked files, then continue. */+{ op: "stageAndContinue" } | { op: "abort" } | { op: "skip" } |/** Commits oldest first; `record_origin` adds "(cherry picked from commit …)". */{ op: "cherryPick"; commits: string[]; recordOrigin?: boolean } |/** Commits newest first. */@@ -6236,9 +6251,15 @@ export type RemoteLaunch = {path: string,};-export type RemoteOp = { op: "fetch" } | { op: "pull"; rebase: boolean } | { op: "push"; force_with_lease: boolean; set_upstream: boolean;+export type RemoteOp = { op: "fetch" } | { op: "pull"; rebase: boolean } |+/** Update Project › Reset to the Remote Branch. */+{ op: "resetToUpstream" } | { op: "push"; force_with_lease: boolean; set_upstream: boolean;/** Push dialog › Push tags. */-tags?: PushTags | null } |+tags?: PushTags | null;+/** Plain `--force` (Force push anyway). */+force?: boolean;+/** Push dialog › Run Git hooks unchecked (`--no-verify`). */+no_verify?: boolean } |/** Deletes a remote branch; `branch` is the remote-tracking name (`origin/feature`). */{ op: "deleteBranch"; branch: string } |/**@@ -6246,7 +6267,13 @@ tags?: PushTags | null } |* remote branch `target`; `remote` overrides the upstream's remote (Push dialog's* remote picker).*/-{ op: "pushBranch"; branch: string; revision: string | null; force_with_lease: boolean; target?: string | null; remote?: string | null } |+{ op: "pushBranch"; branch: string; revision: string | null; force_with_lease: boolean; target?: string | null; remote?: string | null; force?: boolean;+/** Record the target as upstream (Push dialog › Set upstream). */+set_upstream?: boolean; no_verify?: boolean } |+/** Push Tag › Push to `remote`. */+{ op: "pushTag"; tag: string; remote: string } |+/** Deletes tag `tag` on `remote` (Delete on Remote). */+{ op: "deleteRemoteTag"; tag: string; remote: string } |/** Fast-forwards local `branch` (not checked out) to its upstream. */{ op: "updateBranch"; branch: string } |/** Pull dialog: `branches` of `remote` (none = the configured merge branch). */diff --git a/src/features/vcs/__tests__/changelists.test.ts b/src/features/vcs/__tests__/changelists.test.tsindex 9a46f76b6..b17872e96 100644--- a/src/features/vcs/__tests__/changelists.test.ts+++ b/src/features/vcs/__tests__/changelists.test.ts@@ -68,6 +68,15 @@ describe("change list model", () => {expect(next.files).toEqual({ "src/b.ts": feature, "new.ts": feature });});+ it("keeps the lists of files whose changes a merge, rebase or update put aside", () => {+ const { state, feature } = twoLists();+ // The rebase stashed every change: nothing looks changed until they come back.+ const aside = syncAssignments(state, [], true);+ expect(aside?.files ?? state.files).toEqual(state.files);+ const back = syncAssignments(aside ?? state, ["src/b.ts"]);+ expect((back ?? aside ?? state).files).toEqual({ "src/b.ts": feature });+ });+it("files without an assignment belong to the active list", () => {const { state, feature } = twoLists();expect(listOf(state, "src/b.ts")).toBe(feature);diff --git a/src/features/vcs/__tests__/confirmations.test.ts b/src/features/vcs/__tests__/confirmations.test.tsindex 181403923..ae25ea66e 100644--- a/src/features/vcs/__tests__/confirmations.test.ts+++ b/src/features/vcs/__tests__/confirmations.test.ts@@ -16,7 +16,7 @@ vi.mock("@/platform/workflowSettings", () => ({}));vi.mock("../store", async () => {const { create } = await import("zustand");- return { useVcs: create(() => ({})), refreshNow: mocks.refresh };+ return { useVcs: create(() => ({})), refreshNow: mocks.refresh, beginGitWork: () => () => {} };});import { notifyFileOperation } from "@/platform/fileOps";import { useProject } from "@/platform/project";diff --git a/src/features/vcs/__tests__/pushRejected.test.ts b/src/features/vcs/__tests__/pushRejected.test.tsnew file mode 100644index 000000000..c60cd8826--- /dev/null+++ b/src/features/vcs/__tests__/pushRejected.test.ts@@ -0,0 +1,121 @@+import { beforeEach, describe, expect, it, vi } from "vitest";+import type { RemoteOp } from "@/bindings";++const mocks = vi.hoisted(() => ({+ ask: vi.fn(),+ ops: [] as Array<{ repo: string | null; op: RemoteOp }>,+ /** Results of the coming pushes, in order: an error message, or null for success. */+ pushes: [] as Array<string | null>,+ settings: [] as Array<[string, string]>,+}));++vi.mock("@tauri-apps/api/core", async (importOriginal) => ({+ ...(await importOriginal<typeof import("@tauri-apps/api/core")>()),+ Channel: class {+ onmessage: (line: string) => void = () => {};+ },+}));++vi.mock("@/platform/ipc", async (importOriginal) => {+ const real = await importOriginal<typeof import("@/platform/ipc")>();+ const ok = (data: unknown) => Promise.resolve({ status: "ok" as const, data });+ return {+ ...real,+ commands: {+ ...real.commands,+ vcsBranchInfo: () =>+ ok({ head: "main", headCommit: "c1", upstream: "origin/main", ahead: 1, behind: 0, operation: null }),+ vcsRemote: (repo: string | null, _request: number, op: RemoteOp) => {+ mocks.ops.push({ repo, op });+ const error = op.op === "push" ? (mocks.pushes.shift() ?? null) : null;+ return error ? Promise.resolve({ status: "error", error: { kind: "failed", message: error } }) : ok(null);+ },+ vcsLog: () => ok([]),+ vcsStatus: () => ok([]),+ settingsSet: (_scope: string, key: string, value: string) => {+ mocks.settings.push([key, value]);+ return ok({});+ },+ cancelRequest: () => ok(null),+ },+ };+});+vi.mock("@/workbench/messages", () => ({ ask: mocks.ask, showError: vi.fn() }));++import { provideNotificationService } from "@/workbench/contributions";+import { pushWithAutoUpdate } from "../remoteUi";+import { useVcs } from "../store";++const REJECTED = " ! [rejected] main -> main (fetch first)";+const STALE = " ! [rejected] main -> main (stale info)";+const push = { op: "push", force_with_lease: false, set_upstream: false, tags: null } as const;+const kinds = () => mocks.ops.map((o) => (o.op.op === "pull" ? `pull:${o.op.rebase ? "rebase" : "merge"}` : o.op.op));+type Note = { title: string; actions?: Array<{ label: string }> };+let notes: Note[] = [];++beforeEach(() => {+ mocks.ask.mockReset();+ mocks.ops = [];+ mocks.pushes = [];+ mocks.settings = [];+ notes = [];+ useVcs.setState({ roots: ["/a", "/b"], remoteBusy: null });+ provideNotificationService({ notify: (n) => void notes.push(n as Note), expire: () => {} });+});++describe("a push rejected because the remote has new commits", () => {+ it("asks how to update, updates every repository and pushes again", async () => {+ mocks.pushes = [REJECTED];+ mocks.ask.mockResolvedValue({ button: "rebase", checked: false });+ expect(await pushWithAutoUpdate(push, "main → origin/main", "/a")).toBe(true);+ expect(mocks.ask).toHaveBeenCalledTimes(1);+ expect(mocks.ask.mock.calls[0]![0].title).toBe("Push Rejected");+ expect(kinds()).toEqual(["push", "pull:rebase", "pull:rebase", "push"]);+ expect(mocks.ops.filter((o) => o.op.op === "pull").map((o) => o.repo)).toEqual(["/a", "/b"]);+ // The chosen method becomes the update method; silent updates stay off.+ expect(mocks.settings).toEqual([["vcs.git.updateMethod", '"rebase"']]);+ });++ it("keeps the chosen method while the push keeps being rejected, without asking again", async () => {+ mocks.pushes = [REJECTED, REJECTED];+ mocks.ask.mockResolvedValue({ button: "merge", checked: true });+ expect(await pushWithAutoUpdate(push, "", "/a")).toBe(true);+ expect(mocks.ask).toHaveBeenCalledTimes(1);+ expect(kinds()).toEqual(["push", "pull:merge", "pull:merge", "push", "pull:merge", "pull:merge", "push"]);+ expect(mocks.settings).toContainEqual(["vcs.git.autoUpdateOnPushRejected", "true"]);+ });++ it("gives up after ten attempts", async () => {+ mocks.pushes = Array.from({ length: 20 }, () => REJECTED);+ mocks.ask.mockResolvedValue({ button: "merge", checked: false });+ expect(await pushWithAutoUpdate(push, "", "/a")).toBe(false);+ expect(kinds().filter((k) => k === "push")).toHaveLength(10);+ });++ it("doesn't update on Cancel", async () => {+ mocks.pushes = [REJECTED];+ mocks.ask.mockResolvedValue({ button: "cancel", checked: false });+ expect(await pushWithAutoUpdate(push, "", "/a")).toBe(false);+ expect(kinds()).toEqual(["push"]);+ // The dialog, not an error balloon, reported the rejection; cancelling it leaves "Push rejected".+ expect(notes.map((n) => n.title).filter((t) => /fail|reject/i.test(t))).toEqual(["Push rejected"]);+ });+});++describe("a rejected forced push", () => {+ it("is not followed by an update; a stale lease offers to force push anyway", async () => {+ mocks.pushes = [STALE];+ expect(await pushWithAutoUpdate({ ...push, force_with_lease: true }, "", "/a")).toBe(false);+ expect(mocks.ask).not.toHaveBeenCalled();+ expect(kinds()).toEqual(["push"]);+ const offer = notes.at(-1)!;+ expect(offer.actions?.map((a) => a.label)).toEqual(["Force push anyway"]);+ });++ it("with a lease rejected for another reason only reports it", async () => {+ mocks.pushes = [REJECTED];+ expect(await pushWithAutoUpdate({ ...push, force_with_lease: true }, "", "/a")).toBe(false);+ expect(mocks.ask).not.toHaveBeenCalled();+ expect(kinds()).toEqual(["push"]);+ });+});diff --git a/src/features/vcs/__tests__/workflow.test.ts b/src/features/vcs/__tests__/workflow.test.tsindex 4506da6a1..7a4e9389d 100644--- a/src/features/vcs/__tests__/workflow.test.ts+++ b/src/features/vcs/__tests__/workflow.test.ts@@ -5,6 +5,7 @@ import { linkifyIssues } from "../issueLinks";import {defaultPushChecked,isProtectedBranch,+ isLeaseRejected,isPushRejected,pushCandidates,pushRepoCommits,@@ -73,6 +74,16 @@ describe("git settings helpers", () => {it("recognises rejected pushes", () => {expect(isPushRejected(" ! [rejected] main -> main (fetch first)")).toBe(true);expect(isPushRejected("Permission denied (publickey)")).toBe(false);+ expect(isPushRejected(" ! [rejected] main -> main (non-fast-forward)")).toBe(true);+ // A tag that exists on the remote, a hook or the server refusing: updating doesn't help.+ expect(+ isPushRejected(+ " ! [rejected] v1 -> v1 (already exists)\nhint: Updates were rejected because the tag already exists in the remote.",+ ),+ ).toBe(false);+ expect(isPushRejected(" ! [remote rejected] main -> main (pre-receive hook declined)")).toBe(false);+ expect(isPushRejected(" ! [rejected] main -> main (stale info)")).toBe(false);+ expect(isLeaseRejected(" ! [rejected] main -> main (stale info)")).toBe(true);});it("propagates folder colours only when enabled", () => {diff --git a/src/features/vcs/branchMenu.ts b/src/features/vcs/branchMenu.tsindex cdf4cc9c1..2facfcde1 100644--- a/src/features/vcs/branchMenu.ts+++ b/src/features/vcs/branchMenu.ts@@ -4,6 +4,7 @@ import { executeAction } from "@/platform/actions";import type { MenuItem } from "@/ui";import { isFavoriteBranch } from "./branches";import {+ branchRef,checkoutAndRebase,checkoutBranch,checkoutDetached,@@ -11,6 +12,9 @@ import {deleteBranch,deleteInRepos,deleteRemoteBranch,+ deleteTag,+ knownRemotes,+ pushTag,mergeInRepos,newBranchInRepos,rebaseInRepos,@@ -81,8 +85,11 @@ export function branchMenu(b: Branch, current: string | null, done: () => void ={ label: "Show Diff with Working Tree", run: run(() => showDiffWithWorkingTree(b.name)) },history,{ kind: "separator" },- { label: tx`Rebase '${cur}' onto '${b.name}'`, run: run(() => rebaseOnto(b.name)) },- { label: tx`Merge '${b.name}' into '${cur}'`, run: run(() => mergeIntoCurrent(b.name)) },+ { label: tx`Rebase '${cur}' onto '${b.name}'`, run: run(() => rebaseOnto(b.name, branchRef(b.name, b.remote))) },+ {+ label: tx`Merge '${b.name}' into '${cur}'`,+ run: run(() => mergeIntoCurrent(b.name, undefined, branchRef(b.name, b.remote))),+ },];if (b.remote)items.push(@@ -122,6 +129,12 @@ export function tagMenu(tag: string, done: () => void = () => {}): MenuItem[] {{ label: "Compare with Current", icon: "diff", run: run(() => showCompareBranches(tag)) },{ label: "Show Diff with Working Tree", run: run(() => showDiffWithWorkingTree(tag)) },{ label: "Show History", icon: "history", run: run(() => executeAction("vcs.showLog", { branch: tag })) },+ ...knownRemotes().flatMap((remote, i): MenuItem[] => [+ ...(i === 0 ? [{ kind: "separator" } as const] : []),+ { label: tx`Push to ${remote}`, icon: "git-push", run: run(() => pushTag(tag, remote)) },+ ]),+ { kind: "separator" },+ { label: "Delete", danger: true, icon: "trash", run: run(() => deleteTag(tag)) },];}diff --git a/src/features/vcs/branchOps.ts b/src/features/vcs/branchOps.tsindex 808856a98..d2f6c0dfa 100644--- a/src/features/vcs/branchOps.ts+++ b/src/features/vcs/branchOps.ts@@ -203,8 +203,12 @@ export async function checkoutRevision() {}export function conflictActions(message: string) {- return conflictedFiles().length || /conflict/i.test(message)- ? [{ label: "Resolve Conflicts…", run: () => void executeAction("vcs.resolveConflicts") }]+ if (conflictedFiles().length || /conflict/i.test(message))+ return [{ label: "Resolve Conflicts…", run: () => void executeAction("vcs.resolveConflicts") }];+ // Stopped for another reason (the status was refreshed by openConflictsInstead): Abort.+ const op = useVcs.getState().branch?.operation;+ return op === "rebase" || op === "merge"+ ? [{ label: "Abort", run: () => void executeAction(`vcs.${op}.abort`) }]: [];}@@ -219,21 +223,26 @@ export async function openConflictsInstead(): Promise<boolean> {return true;}-export async function mergeIntoCurrent(branch: string, repo: string | null = currentRepo()) {+/** The full ref of a branch, so a tag of the same name isn't taken instead. */+export function branchRef(name: string, remote: boolean): string {+ return remote ? `refs/remotes/${name}` : `refs/heads/${name}`;+}++export async function mergeIntoCurrent(branch: string, repo: string | null = currentRepo(), ref = branch) {const current = (repo === currentRepo() ? useVcs.getState().branch?.head : null) ?? "HEAD";await saveAll();- await runOp(tx`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(repo, branch)), {+ await runOp(tx`Merge ${branch} into ${current}`, () => call(commands.vcsMerge(repo, ref)), {success: tx`Merged ${branch} into ${current}`,errorActions: conflictActions,onError: openConflictsInstead,});}-export async function rebaseOnto(branch: string) {+export async function rebaseOnto(branch: string, ref = branch) {const repo = currentRepo();const current = useVcs.getState().branch?.head ?? "HEAD";await saveAll();- await runOp(tx`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(repo, branch)), {+ await runOp(tx`Rebase ${current} onto ${branch}`, () => call(commands.vcsRebase(repo, ref)), {success: tx`Rebased ${current} onto ${branch}`,errorActions: conflictActions,onError: openConflictsInstead,@@ -312,6 +321,65 @@ export async function deleteBranch(name: string) {});}+/** Remotes of the selected repository, as its remote-tracking branches name them. */+export function knownRemotes(): string[] {+ const names = useVcs+ .getState()+ .branches.filter((b) => b.remote)+ .map((b) => b.name.slice(0, b.name.indexOf("/")))+ .filter(Boolean);+ return [...new Set(names)];+}++/** Tag › Delete: deletes the local tag; the notification restores it or deletes it on the remotes too. */+export async function deleteTag(name: string) {+ const repo = currentRepo();+ const deleted = await runOp(tx`Delete tag ${name}`, () => call(commands.vcsDeleteTag(repo, name)));+ if (!deleted) return;+ const remotes = knownRemotes();+ const key = `vcs.deletedTag.${name}`;+ const done = () => notifications().expire?.(key);+ notifications().notify({+ group: "vcs",+ level: "info",+ key,+ title: tx`Deleted tag ${name}`,+ actions: [+ {+ label: "Restore",+ run: () => {+ done();+ void runOp(tx`Restore tag ${name}`, () => call(commands.vcsRestoreTag(repo, deleted)), {+ success: tx`Restored tag ${name}`,+ });+ },+ },+ ...(remotes.length+ ? [+ {+ label: remotes.length === 1 ? "Delete on Remote" : "Delete on Remotes",+ run: () => {+ done();+ void deleteRemoteTag(name, remotes, repo);+ },+ },+ ]+ : []),+ ],+ });+}++async function deleteRemoteTag(tag: string, remotes: readonly string[], repo: string | null) {+ for (const remote of remotes) {+ if (!(await runRemote({ op: "deleteRemoteTag", tag, remote }, `${remote}: ${tag}`, [repo]))) return;+ }+}++/** Push Tag › Push to `remote`. */+export async function pushTag(tag: string, remote: string) {+ await runRemote({ op: "pushTag", tag, remote }, `${tag} → ${remote}`);+}+/** Deletes a branch on its remote (`git push <remote> --delete <name>`); `name` is e.g. `origin/feature`. */export async function deleteRemoteBranch(name: string) {const ok = await confirmDialog({@@ -333,7 +401,7 @@ export async function checkoutAndRebase(name: string) {rememberBranch(current);rememberBranch(name);await refreshNow();- await rebaseOnto(current);+ await rebaseOnto(current, branchRef(current, false));}/** Update for a branch other than the current one: fast-forwards it to its upstream. */diff --git a/src/features/vcs/changelists.ts b/src/features/vcs/changelists.tsindex b0e57e4a3..9822df04e 100644--- a/src/features/vcs/changelists.ts+++ b/src/features/vcs/changelists.ts@@ -11,7 +11,7 @@ import { setLocalChanges, type LocalChangelist } from "@/workbench/contributionsimport type { CheckState } from "./changes";import { groupOf } from "./changes";import { effectiveKind, relTo, stripSlash } from "./model";-import { useVcs } from "./store";+import { localChangesMayBeAside, useVcs } from "./store";export const DEFAULT_LIST_ID = "default";export const DEFAULT_LIST_NAME = "Changes";@@ -32,14 +32,20 @@ export function activeList(state: ChangelistState): Changelist {/*** Pins files that just became changed to the active list and forgets files that- * are no longer changed. Returns null when nothing changed.+ * are no longer changed, unless `keepGone`: while a merge, rebase or update has the+ * local changes put aside, their files keep their lists for when they come back.+ * Returns null when nothing changed.*/-export function syncAssignments(state: ChangelistState, changed: readonly string[]): ChangelistState | null {+export function syncAssignments(+ state: ChangelistState,+ changed: readonly string[],+ keepGone = false,+): ChangelistState | null {const live = new Set(changed);const files: Record<string, string> = {};let dirty = false;for (const [rel, id] of Object.entries(state.files ?? {})) {- if (live.has(rel) && state.lists.some((l) => l.id === id)) files[rel] = id;+ if ((keepGone || live.has(rel)) && state.lists.some((l) => l.id === id)) files[rel] = id;else dirty = true;}for (const rel of changed) {@@ -195,7 +201,7 @@ export function installChangelists(): () => void {const sync = () => {const { status, root, available, statusLoaded } = useVcs.getState();if (!available || !root || !statusLoaded || !useChangelists.getState().loaded) return;- const next = syncAssignments(useChangelists.getState().state, changedRels(status, root));+ const next = syncAssignments(useChangelists.getState().state, changedRels(status, root), localChangesMayBeAside());if (next) updateChangelists(() => next);};const load = () => {diff --git a/src/features/vcs/conflictsUi.tsx b/src/features/vcs/conflictsUi.tsxindex 9a3d364fb..69d803381 100644--- a/src/features/vcs/conflictsUi.tsx+++ b/src/features/vcs/conflictsUi.tsx@@ -1,5 +1,5 @@/** "Resolve Conflicts" dialog and in-editor conflict resolution actions. */-import { useState } from "react";+import { useEffect, useRef, useState } from "react";import type { FileStatus } from "@/bindings";import { activeEditor } from "@/editor/api";import { call, commands } from "@/platform/ipc";@@ -9,13 +9,28 @@ import { blockAt, parseConflicts, resolutionText, type Resolution } from "./confimport { openDialog } from "./dialogs";import { mergeInput } from "./mergeKind";import { baseName, dirName, relTo, stripSlash } from "./model";-import { controlLabel, controlOperation, inProgress, operationTitle } from "./operations";+import { controlLabel, controlOperation, inProgress, operationTitle, type InProgress } from "./operations";import { runOp, writeFileText } from "./ops";import { executeAction } from "@/platform/actions";import { conflictedFiles, useVcs } from "./store";import styles from "./common.module.css";import { tx } from "@/platform/i18n";+/**+ * The stopped rebase / cherry-pick / revert whose conflicts are being resolved from the+ * Conflicts dialog (there or in the merge editor it opened): once the last one is+ * resolved the operation continues by itself, as IDEA does. Closing the dialog+ * without resolving them leaves it stopped.+ */+let continueWhenResolved: InProgress | null = null;++/** The operation to continue now that its conflicts are resolved, if any (only once). */+export function takeContinueWhenResolved(): InProgress | null {+ const op = continueWhenResolved;+ continueWhenResolved = null;+ return op;+}+export function showConflictsDialog() {if (!conflictedFiles().length) {notifications().notify({ group: "vcs", level: "info", title: "No merge conflicts" });@@ -52,6 +67,20 @@ function ConflictsDialog({ onClose }: { onClose: () => void }) {const files = useVcs((s) => s.status).filter((f) => f.unstaged === "conflicted");const root = useVcs((s) => s.root) ?? "";const op = useVcs((s) => inProgress(s.branch?.operation));+ useEffect(() => {+ continueWhenResolved = op && op !== "merge" ? op : null;+ }, [op]);+ // The last conflict resolved here: the operation continues (see onConflictsCleared), the dialog goes.+ const hadConflicts = useRef(files.length > 0);+ useEffect(() => {+ if (hadConflicts.current && !files.length && op && op !== "merge") onClose();+ hadConflicts.current = files.length > 0;+ }, [files.length, op, onClose]);+ // Closed without going on to resolve them: the operation stays stopped.+ const dismiss = () => {+ continueWhenResolved = null;+ onClose();+ };const head = useVcs((s) => s.branch?.head ?? null);const [active, setActive] = useState(0);const current = files[Math.min(active, files.length - 1)];@@ -66,7 +95,7 @@ function ConflictsDialog({ onClose }: { onClose: () => void }) {<Dialogopentitle="Conflicts"- onClose={onClose}+ onClose={dismiss}width={600}footerStart={<span className={styles.hint}>{op ? operationTitle(op, head) : ""}</span>}buttons={[@@ -77,7 +106,7 @@ function ConflictsDialog({ onClose }: { onClose: () => void }) {role: "default" as const,autoFocus: true,onClick: () => {- onClose();+ dismiss();conclude.run();},},diff --git a/src/features/vcs/index.ts b/src/features/vcs/index.tsindex 750bfded2..3d4b7889c 100644--- a/src/features/vcs/index.ts+++ b/src/features/vcs/index.ts@@ -25,7 +25,7 @@ import { controlLabel, controlOperation, inProgress } from "./operations";import { annotationsShown, blameSlot } from "./blame";import { inlineBlame } from "./inlineBlame";import { BranchWidget, useBranchesPopup } from "./BranchWidget";-import { showConflictsDialog } from "./conflictsUi";+import { showConflictsDialog, takeContinueWhenResolved } from "./conflictsUi";import { registerCompareActions } from "./compare";import { DIFF_KIND, diffTitle, type DiffData } from "./diffInput";import { VcsDialogHost } from "./dialogs";@@ -186,8 +186,13 @@ export function activate(): () => void {onConflictsCleared(() => {notifications().expire?.("vcs.conflicts");- // As IDEA does once the last conflict is resolved: offer to continue the stopped operation.const op = inProgress();+ // Resolved from the Conflicts dialog: the stopped rebase / cherry-pick goes on by itself.+ if (op && takeContinueWhenResolved() === op) {+ void controlOperation("continue", op);+ return;+ }+ // Otherwise, as IDEA does once the last conflict is resolved: offer to continue it.if (op)notifications().notify({group: "vcs",diff --git a/src/features/vcs/operations.tsx b/src/features/vcs/operations.tsxindex 76cd02daf..54a2bcab3 100644--- a/src/features/vcs/operations.tsx+++ b/src/features/vcs/operations.tsx@@ -17,6 +17,7 @@ import { KIND_COLOR, fileCount } from "./model";import { runGitOperation, runOp } from "./ops";import { loadLogDetails } from "./logDetails";import { isProtectedBranch } from "./remoteUi";+import { showLocalChanges } from "./commitUi";import { reloadLog, useGitLog } from "./logStore";import { conflictedFiles, currentRepo, currentRepoRoot, refreshNow, repoName, repoOf, useVcs } from "./store";import styles from "./common.module.css";@@ -82,6 +83,38 @@ export function controlLabel(op: InProgress, control: "continue" | "skip" | "aboreturn `${control === "continue" ? "Continue" : "Abort"} ${OP_NOUN[op]}`;}+/** Why `git rebase --continue` refused (see the backend's UNSTAGED_CHANGES_PREVENT_REBASE). */+const UNSTAGED_CHANGES_PREVENT_REBASE = "There are unstaged changes in tracked files preventing rebase from continuing";++/**+ * Links of the balloon of an operation that failed and is still stopped: Abort, and for+ * a rebase held up by unstaged changes, Stage and Retry (stages the tracked files'+ * changes and continues) and Show Files.+ */+export function stoppedActions(op: InProgress, message: string): Array<{ label: string; run: () => void }> {+ if (!inProgress()) return [];+ const abort = { label: "Abort", run: () => void controlOperation("abort", op) };+ if (op !== "rebase" || !message.includes(UNSTAGED_CHANGES_PREVENT_REBASE)) return [abort];+ return [+ {+ label: "Stage and Retry",+ run: () =>+ void runGitOperation(+ { op: "stageAndContinue" },+ {+ progress: "Continuing rebase",+ success: "Rebase continued",+ failure: tx`${controlLabel(op, "continue")} failed`,+ onError: conflictsInstead,+ errorActions: (m) => stoppedActions(op, m),+ },+ ),+ },+ { label: "Show Files", run: () => showLocalChanges() },+ abort,+ ];+}+/** Opens the conflicts dialog instead of an error balloon when the operation stopped on conflicts. */export async function conflictsInstead(): Promise<boolean> {await refreshNow();@@ -170,6 +203,7 @@ export async function controlOperation(control: "continue" | "skip" | "abort", esuccess,failure: tx`${controlLabel(op, control)} failed`,onError: control === "abort" ? undefined : conflictsInstead,+ errorActions: control === "abort" ? undefined : (message) => stoppedActions(op, message),},);// A rebase that continued and stopped again (next conflict) is reported by the conflicts listener.diff --git a/src/features/vcs/ops.ts b/src/features/vcs/ops.tsindex 969fa94d9..a58f61005 100644--- a/src/features/vcs/ops.ts+++ b/src/features/vcs/ops.ts@@ -5,13 +5,14 @@import { Channel } from "@tauri-apps/api/core";import { create } from "zustand";import type { GitOperation, RemoteOp } from "@/bindings";+import { executeAction } from "@/platform/actions";import { tx } from "@/platform/i18n";import { call, commands, isCancelled, nextRequestId } from "@/platform/ipc";import { attachDocument, editorsFor } from "@/editor/api";import { maybeEditorService, notifications } from "@/workbench/contributions";import { cancelTask, upsertTaskSoon, useTasks } from "@/workbench/tasks";import { progressFraction } from "./model";-import { currentRepo, refreshNow, repoName, useVcs } from "./store";+import { beginGitWork, conflictedFiles, currentRepo, refreshNow, repoName, useVcs } from "./store";// ---------------------------------------------------------------------------// Console (Git tool window → Console tab)@@ -73,6 +74,7 @@ export interface OpOptions<T> {/** Runs `fn`, logging to the console and reporting failures. `undefined` on error. */export async function runOp<T>(title: string, fn: () => Promise<T>, opts: OpOptions<T> = {}): Promise<T | undefined> {logConsole("cmd", title);+ const endWork = beginGitWork();try {const value = await fn();const msg = typeof opts.success === "function" ? opts.success(value) : opts.success;@@ -95,6 +97,7 @@ export async function runOp<T>(title: string, fn: () => Promise<T>, opts: OpOpti});return undefined;} finally {+ endWork();if (opts.refresh !== false) void refreshNow();}}@@ -114,11 +117,14 @@ export async function saveAll() {const REMOTE_TITLE: Record<RemoteOp["op"], [string, string]> = {fetch: ["Fetching", "Fetch"],pull: ["Updating project", "Update"],+ resetToUpstream: ["Updating project", "Update"],pullFrom: ["Pulling", "Pull"],push: ["Pushing", "Push"],deleteBranch: ["Deleting remote branch", "Delete remote branch"],pushBranch: ["Pushing", "Push"],updateBranch: ["Updating branch", "Update"],+ pushTag: ["Pushing", "Push"],+ deleteRemoteTag: ["Deleting remote tag", "Delete remote tag"],};let activeRemote: number | null = null;@@ -150,6 +156,8 @@ export async function runRemote(op: RemoteOp,detail?: string,repos: ReadonlyArray<string | null> = [currentRepo()],+ /** Failures the caller reports itself (e.g. a rejected push it goes on to update). */+ handled?: (message: string) => boolean,): Promise<boolean> {if (useVcs.getState().remoteBusy) {notifications().notify({ group: "vcs", level: "warning", title: "Another remote operation is in progress" });@@ -200,7 +208,7 @@ export async function runRemote(}}try {- const before = op.op === "pull" || op.op === "pullFrom" ? await headCommit(repo) : null;+ const before = isUpdate(op) ? await publishedTip(repo, op) : null;// The push summary counts what the push carries: the commits the branch is// ahead of its upstream before the push (pushing does not move the local head).if (op.op === "push" || (op.op === "pushBranch" && !op.target)) {@@ -208,7 +216,7 @@ export async function runRemote(if (info?.upstream && info.ahead > 0) pushed.push({ to: info.upstream, commits: info.ahead });}await call(commands.vcsRemote(repo, request, op, channel));- const after = before ? await headCommit(repo) : null;+ const after = before ? await publishedTip(repo, op) : null;if (before && after && before !== after) updated.push({ repo, from: before, to: after });} catch (e) {if (isCancelled(e) || !name) throw e;@@ -218,7 +226,7 @@ export async function runRemote(}if (failures.length) throw new Error(failures.join("\n"));lastRemoteError = null;- if (op.op === "pull" || op.op === "pullFrom") await notifyUpdated(updated);+ if (isUpdate(op)) await notifyUpdated(updated);else {// One repository's push names what went out; a partial multi-repo push stays generic.const one = pushed.length === 1 ? pushed[0] : null;@@ -226,7 +234,12 @@ export async function runRemote(group: "vcs",level: "info",key: "vcs.remote",- title: one ? pushedTitle(one.commits, one.to) : `${doneTitle} successful`,+ title:+ op.op === "pushTag"+ ? tx`Pushed tag ${op.tag} to ${op.remote}`+ : one+ ? pushedTitle(one.commits, one.to)+ : `${doneTitle} successful`,body: lastLine && !/%/.test(lastLine) ? lastLine : undefined,});}@@ -236,8 +249,12 @@ export async function runRemote(lastRemoteError = cancelled ? null : errorMessage(e);logConsole(cancelled ? "info" : "err", cancelled ? `${doneTitle} cancelled` : errorMessage(e));// The user asked for it: the progress balloon just goes away.- if (cancelled) notifications().expire?.("vcs.remote");- else+ if (cancelled || handled?.(errorMessage(e))) notifications().expire?.("vcs.remote");+ else if (isUpdate(op) && (await stoppedOnConflicts())) {+ // An update that stopped on conflicts opens them for resolving, not an error.+ notifications().expire?.("vcs.remote");+ void executeAction("vcs.resolveConflicts");+ } elsenotifications().notify({group: "vcs",level: "error",@@ -260,12 +277,36 @@ interface UpdatedRange {to: string;}+/** Update Project and the operations that bring the branch up to date like it. */+const isUpdate = (op: RemoteOp) => op.op === "pull" || op.op === "pullFrom" || op.op === "resetToUpstream";++async function stoppedOnConflicts(): Promise<boolean> {+ await refreshNow();+ return conflictedFiles().length > 0;+}+const headCommit = (repo: string | null) =>call(commands.vcsBranchInfo(repo)).then((i) => i.headCommit,() => null,);+/**+ * Where the branch meets the branch it updates from (their merge base), the start and+ * end of what an update brought in: the incoming commits only, not the local ones a+ * rebase rewrites or the merge commit. HEAD when that branch can't be resolved.+ */+async function publishedTip(repo: string | null, op: RemoteOp): Promise<string | null> {+ const tracked =+ op.op === "pull" || op.op === "resetToUpstream" || (op.op === "pullFrom" && !op.branches.length)+ ? "@{u}"+ : op.op === "pullFrom" && op.branches.length === 1+ ? `${op.remote}/${op.branches[0]}`+ : null;+ const base = tracked ? await call(commands.vcsMergeBase(repo, "HEAD", tracked)).catch(() => null) : null;+ return base ?? headCommit(repo);+}+/** Counts for a translated sentence: each variant is its own source text, as "{count} files". */const filesText = (n: number) => (n === 1 ? tx`${n} file` : tx`${n} files`);const commitsText = (n: number) => (n === 1 ? tx`${n} commit` : tx`${n} commits`);@@ -333,6 +374,8 @@ export interface GitOperationOptions {onError?: (message: string) => boolean | Promise<boolean>;/** Links of the success balloon (e.g. Undo), worked out after the status refreshed. */successActions?: () => Promise<{ label: string; run: () => void }[]>;+ /** Links of the error balloon, worked out after the status refreshed. */+ errorActions?: (message: string) => Array<{ label: string; run: () => void }>;}/**@@ -397,6 +440,7 @@ export async function runGitOperation(key: "vcs.operation",title: opts.failure,body: message,+ actions: opts.errorActions?.(message),});return false;} finally {@@ -413,6 +457,8 @@ export function describeOperation(op: GitOperation): string {case "abort":case "skip":return `${useVcs.getState().branch?.operation ?? ""} --${op.op}`.trim();+ case "stageAndContinue":+ return `add -u && ${useVcs.getState().branch?.operation ?? ""} --continue`.trim();case "cherryPick":return `cherry-pick ${op.commits.map((c) => c.slice(0, 8)).join(" ")}`;case "revert":diff --git a/src/features/vcs/remoteUi.tsx b/src/features/vcs/remoteUi.tsxindex 38ce7d707..c5082c34b 100644--- a/src/features/vcs/remoteUi.tsx+++ b/src/features/vcs/remoteUi.tsx@@ -3,9 +3,23 @@ import { useEffect, useMemo, useState } from "react";import type { BranchInfo, Commit, PushTags, RemoteOp } from "@/bindings";import { call, commands } from "@/platform/ipc";import { tx } from "@/platform/i18n";-import { workflowSettings } from "@/platform/workflowSettings";+import { workflowSettings, type UpdateMethod } from "@/platform/workflowSettings";+import { useProject } from "@/platform/project";import { notifications } from "@/workbench/contributions";-import { Checkbox, Dialog, Input, List, Select, Spinner, SplitGroup, SplitHandle, SplitPanel, T, Tree } from "@/ui";+import {+ Button,+ Checkbox,+ Dialog,+ Input,+ List,+ Select,+ Spinner,+ SplitGroup,+ SplitHandle,+ SplitPanel,+ T,+ Tree,+} from "@/ui";import { ask } from "@/workbench/messages";import { openDialog } from "./dialogs";import { formatTime } from "./model";@@ -34,12 +48,45 @@ async function updateProject(rebase: boolean) {await runRemote({ op: "pull", rebase }, detail, repos);}+/** Writes a Version Control setting of the project, as the Settings page would. */+async function saveVcsSetting(key: string, value: unknown) {+ const scope = useProject.getState().project ? "project" : "global";+ const settings = await call(commands.settingsSet(scope, key, JSON.stringify(value))).catch(() => null);+ if (settings) useProject.setState({ settings });+}++/** Reset to the Remote Branch: after confirming, drops local commits and takes the tracked branch. */+async function resetToRemoteBranch() {+ const branch = useVcs.getState().branch;+ if (branch?.head && branch.upstream) {+ const local = branch.head;+ const remote = branch.upstream;+ const r = await ask({+ title: "Reset to the Remote Branch",+ body: tx`Do you want to reset local branch ${local} to ${remote}? Local commits will be dropped`,+ icon: "warning",+ buttons: [+ { id: "ok", label: "OK", primary: true },+ { id: "cancel", label: "Cancel" },+ ],+ });+ if (r.button !== "ok") return;+ }+ await saveAll();+ await runRemote({ op: "resetToUpstream" }, branch?.upstream ? `${branch.head} ← ${branch.upstream}` : undefined);+}+function UpdateDialog({ onClose }: { onClose: () => void }) {const branch = useVcs((s) => s.branch);- // Default from Settings › Version Control › Git › Update method.+ const single = useVcs((s) => s.roots.length <= 1);+ // Default from Settings › Version Control › Git › Update method; the choice is kept there.const [rebase, setRebase] = useState(() => workflowSettings().vcs.git.updateMethod === "rebase");+ const [hide, setHide] = useState(false);const run = async () => {onClose();+ const method = rebase ? "rebase" : "merge";+ if (method !== workflowSettings().vcs.git.updateMethod) await saveVcsSetting("vcs.git.updateMethod", method);+ if (hide) await saveVcsSetting("vcs.confirmation.showUpdateOptions", false);await updateProject(rebase);};return (@@ -47,7 +94,22 @@ function UpdateDialog({ onClose }: { onClose: () => void }) {opentitle="Update Project"onClose={onClose}- width={420}+ width={single ? 540 : 420}+ footerStart={+ <>+ {single && (+ <Button+ onClick={() => {+ onClose();+ void resetToRemoteBranch();+ }}+ >+ <T>Reset to the Remote Branch</T>+ </Button>+ )}+ <Checkbox checked={hide} onChange={setHide} label="Don't show again" />+ </>+ }buttons={[{ label: "OK", role: "default", autoFocus: true, onClick: () => void run() },{ label: "Cancel", role: "cancel" },@@ -122,6 +184,21 @@ export async function showPushDialog(target: PushTarget = {}) {openDialog((close) => (multi ? <MultiPushDialog onClose={close} /> : <PushDialog target={target} onClose={close} />));}+/** Whether any of `roots` has a pre-push hook: the Push dialog then offers Run Git hooks. */+function usePrePushHook(roots: ReadonlyArray<string | null>): boolean {+ const [found, setFound] = useState(false);+ useEffect(() => {+ let alive = true;+ void Promise.all(roots.map((r) => call(commands.vcsHasHook(r, "pre-push")).catch(() => false))).then(+ (has) => alive && setFound(has.some(Boolean)),+ );+ return () => {+ alive = false;+ };+ }, [roots]);+ return found;+}+/** A repository in the multi-repository Push dialog. */export interface RepoPush {root: string;@@ -163,6 +240,8 @@ function MultiPushDialog({ onClose }: { onClose: () => void }) {const [force, setForce] = useState(false);const [pushTags, setPushTags] = useState(false);const [tagsMode, setTagsMode] = useState<PushTags>("all");+ const hasHook = usePrePushHook(roots);+ const [runHooks, setRunHooks] = useState(true);useEffect(() => {let alive = true;@@ -201,6 +280,9 @@ function MultiPushDialog({ onClose }: { onClose: () => void }) {const picked = (repos ?? []).filter((r) => checked.has(r.root));const push = async () => {onClose();+ // Every picked repository is pushed even when another fails; the outcome is summed up.+ const session: PushSession = { method: null };+ const failed: string[] = [];for (const r of picked) {const upstream = r.branch.upstream;const ok = await pushWithAutoUpdate(@@ -209,12 +291,23 @@ function MultiPushDialog({ onClose }: { onClose: () => void }) {force_with_lease: force && !isProtectedBranch(targetOf(r)),set_upstream: !upstream,tags: pushTags ? tagsMode : null,+ no_verify: hasHook && !runHooks,},`${repoName(r.root)}: ${r.branch.head} → ${upstream ?? "new remote branch"}`,r.root,+ session,);- if (!ok) return;+ if (!ok) failed.push(repoName(r.root));}+ const notPushed = failed.join(", ");+ if (failed.length && picked.length > 1)+ notifications().notify({+ group: "vcs",+ level: "error",+ key: "vcs.remote",+ title: failed.length < picked.length ? "Push partially failed" : "Push failed",+ body: tx`Not pushed: ${notPushed}. See the Git console for details.`,+ });};const nodes: PushNode[] = (repos ?? []).map((repo) => ({key: repo.root,@@ -237,6 +330,7 @@ function MultiPushDialog({ onClose }: { onClose: () => void }) {footerStart={<><Checkbox checked={force} onChange={setForce} label="Force (with lease)" />+ {hasHook && <Checkbox checked={runHooks} onChange={setRunHooks} label="Run Git hooks" />}<Checkbox checked={pushTags} onChange={setPushTags} label="Push tags:" /><Select<PushTags>value={tagsMode}@@ -367,6 +461,9 @@ function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onCloconst [setUpstream, setSetUpstream] = useState(!tracked);const [pushTags, setPushTags] = useState(false);const [tagsMode, setTagsMode] = useState<PushTags>("all");+ const hookRoots = useMemo(() => [repo], [repo]);+ const hasHook = usePrePushHook(hookRoots);+ const [runHooks, setRunHooks] = useState(true);const upstream = trackedBranch ? (remote ? `${remote}/${trackedBranch}` : tracked) : tracked;useEffect(() => {@@ -427,6 +524,8 @@ function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onCloforce_with_lease: force && !protectedTarget,target: retarget ? edited : null,remote: remoteChanged ? remote : null,+ set_upstream: setUpstream && !revision,+ no_verify: hasHook && !runHooks,},`${revision ? `${head} up to ${revision.slice(0, 8)}` : head} → ${targetLabel}`,[repo],@@ -439,6 +538,7 @@ function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onCloforce_with_lease: force && !protectedTarget,set_upstream: setUpstream || !upstream,tags: pushTags ? tagsMode : null,+ no_verify: hasHook && !runHooks,},upstream ? `${head} → ${upstream}` : `${head} → new remote branch`,repo,@@ -494,14 +594,17 @@ function PushDialog({ target: pushTarget, onClose }: { target: PushTarget; onClolabel="Force (with lease)"/></span>+ {hasHook && <Checkbox checked={runHooks} onChange={setRunHooks} label="Run Git hooks" />}+ {!revision && (+ <Checkbox+ checked={setUpstream || !tracked}+ disabled={!tracked}+ onChange={setSetUpstream}+ label="Set upstream"+ />+ )}{!explicit && !retarget && !remoteChanged && (<>- <Checkbox- checked={setUpstream || !upstream}- disabled={!upstream}- onChange={setSetUpstream}- label="Set upstream"- /><Checkbox checked={pushTags} onChange={setPushTags} label="Push tags:" /><Select<PushTags>value={tagsMode}@@ -652,40 +755,125 @@ export function isProtectedBranch(branch: string, patterns = workflowSettings().);}-/** Rejected because the remote has commits we don't (non-fast-forward). */+/**+ * Rejected because the remote has commits we don't (non-fast-forward): an update helps.+ * Not a tag that already exists there, nor a hook or the server refusing it.+ */export function isPushRejected(message: string): boolean {- return /\[rejected\]|non-fast-forward|fetch first|updates were rejected/i.test(message);+ return /\((?:non-fast-forward|fetch first)\)|tip of your current branch is behind|remote contains work that you do/i.test(+ message,+ );+}++/** A force-with-lease push refused because the remote moved since the last fetch. */+export function isLeaseRejected(message: string): boolean {+ return /\(stale info\)/i.test(message);}+/** One Push of several repositories: the update method is asked for once. */+interface PushSession {+ method: UpdateMethod | null;+}++/** Pushes and updates again at most this many times while the push keeps being rejected. */+const MAX_PUSH_ATTEMPTS = 10;+/**- * Pushes; when the push is rejected, either updates (pull with the configured- * update method) and pushes again ("Auto-update if push of the current branch- * was rejected") or offers to.+ * Pushes the current branch; when the push is rejected because the remote has new+ * commits, updates every repository with the method chosen in the Push Rejected+ * dialog (or, with "update silently", the configured one) and pushes again, as long+ * as it keeps being rejected. A rejected forced push offers neither.*/export async function pushWithAutoUpdate(op: Extract<RemoteOp, { op: "push" }>,detail: string,repo: string | null = currentRepo(),+ session: PushSession = { method: null },): 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();- 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]);+ // A rejection that leads to an update is reported by the Push Rejected dialog instead.+ const updatable = (message: string) => !op.force && !op.force_with_lease && isPushRejected(message);+ const rejected = (message: string) => {+ notifications().notify({ group: "vcs", level: "error", key: "vcs.remote", title: "Push rejected", body: message });+ return false;};- if (git.autoUpdateOnPushRejected) return updateAndPush();+ for (let attempt = 1; ; attempt++) {+ if (await runRemote(op, detail, [repo], updatable)) return true;+ const error = lastRemoteFailure();+ if (!error) return false;+ if (op.force_with_lease && isLeaseRejected(error)) {+ offerForcePush(op, detail, repo);+ return false;+ }+ if (!updatable(error)) return false;+ if (attempt >= MAX_PUSH_ATTEMPTS) return rejected(error);+ // Only the tracked branch is brought up to date: a new remote branch has nothing to update from.+ const branch = await call(commands.vcsBranchInfo(repo)).catch(() => null);+ if (!branch?.head || !branch.upstream) return rejected(error);+ session.method ??= await chooseUpdateMethod(repo, branch.head);+ if (!session.method) return rejected(error);+ await saveAll();+ const pull = { op: "pull" as const, rebase: session.method === "rebase" };+ if (!(await runRemote(pull, tx("updating after rejected push"), allRepos()))) return false;+ }+}++/** Unpushed merge commits, which a rebase would linearize (and may need resolving again). */+async function hasOutgoingMerges(repo: string | null): Promise<boolean> {+ const commits = await logOf("HEAD", 1000, "@{u}..HEAD", repo).catch(() => []);+ return commits.some((c) => c.parents.length > 1);+}++/** The Push Rejected dialog: Merge or Rebase, optionally remembered as the silent update. */+async function chooseUpdateMethod(repo: string | null, branch: string): Promise<UpdateMethod | null> {+ const git = workflowSettings().vcs.git;+ if (git.autoUpdateOnPushRejected) return git.updateMethod;+ const merges = await hasOutgoingMerges(repo);+ const name = repo && useVcs.getState().roots.length > 1 ? repoName(repo) : null;+ const rejected = name+ ? tx`Push of the current branch "${branch}" in repository "${name}" was rejected.`+ : tx`Push of the current branch "${branch}" was rejected.`;+ const why = merges+ ? tx(+ "Remote changes need to be merged before pushing.\n\nIn this case merge is highly recommended, because there are non-pushed merge commits. Rebasing them can lead to problems.",+ )+ : tx("Remote changes need to be merged before pushing.");+ const rebaseFirst = !merges && git.updateMethod === "rebase";+ const r = await ask({+ title: "Push Rejected",+ body: `${rejected}\n\n${why}`,+ icon: "warning",+ width: 520,+ checkbox:+ "Remember the update method and update silently in the future. Change this later in Settings | Version Control.",+ buttons: [+ { id: "merge", label: "Merge", primary: !rebaseFirst },+ { id: "rebase", label: merges ? "Rebase Anyway" : "Rebase", primary: rebaseFirst },+ { id: "cancel", label: "Cancel" },+ ],+ });+ if (r.button !== "merge" && r.button !== "rebase") return null;+ if (r.checked) await saveVcsSetting("vcs.git.autoUpdateOnPushRejected", true);+ // A merge chosen only because of the merge commits doesn't replace a preferred rebase.+ if (!merges && r.button !== git.updateMethod) await saveVcsSetting("vcs.git.updateMethod", r.button);+ return r.button;+}++/** A rejected force-with-lease push: says why and offers a plain force push. */+function offerForcePush(op: Extract<RemoteOp, { op: "push" }>, detail: string, repo: string | null) {+ const branch = useVcs.getState().branch;+ const source = branch?.head ?? "HEAD";+ const target = branch?.upstream ?? tx("the remote");notifications().notify({+ group: "vcs",level: "error",key: "vcs.remote",title: "Push rejected",- body: "The remote contains commits that are not in your branch. Update the branch, then push again.",+ body: tx`Force-with-lease push ${source} to ${target} was rejected. Force-with-lease push prevents overriding remote changes that haven't been fetched to the local repository. Fetch recent changes to verify that they can be discarded safely and repeat the push operation.`,actions: [- { label: git.updateMethod === "rebase" ? "Rebase and Push" : "Merge and Push", run: () => void updateAndPush() },+ {+ label: "Force push anyway",+ run: () => void runRemote({ ...op, force_with_lease: false, force: true }, detail, [repo]),+ },],});- return false;}diff --git a/src/features/vcs/store.ts b/src/features/vcs/store.tsindex b35476dee..3e64d3baa 100644--- a/src/features/vcs/store.ts+++ b/src/features/vcs/store.ts@@ -110,6 +110,28 @@ export function attentionRepo(return Object.keys(now).find((root) => !before[root]) ?? null;}+let gitWork = 0;++/** Marks a git command as running until the returned function is called. */+export function beginGitWork(): () => void {+ gitWork++;+ let ended = false;+ return () => {+ if (!ended) gitWork--;+ ended = true;+ };+}++/**+ * A git command is running or an operation is stopped in some repository: local+ * changes may be put aside for the time being (merge, rebase, update), so files that+ * look unchanged now may come back.+ */+export function localChangesMayBeAside(): boolean {+ const s = useVcs.getState();+ return gitWork > 0 || !!s.remoteBusy || Object.keys(s.operations).length > 0 || !!s.branch?.operation;+}+/** Selects the repository branch / log / remote operations act on. */export function selectRepo(root: string): Promise<void> {if (useVcs.getState().repo === root) return Promise.resolve();diff --git a/src/platform/locales/text/es.json b/src/platform/locales/text/es.jsonindex 2d5ff1677..37333d489 100644--- a/src/platform/locales/text/es.json+++ b/src/platform/locales/text/es.json@@ -1231,7 +1231,6 @@"Memory Indicator": "Indicador de memoria","Memory and diagnostics": "Memoria y diagnósticos","Merge": "Fusionar",- "Merge and Push": "Fusionar y hacer push","Merge conflicts": "Conflictos de fusión","Merge incoming changes into the current branch": "Fusionar los cambios entrantes en la rama actual","Merge…": "Fusionar…",@@ -1644,7 +1643,6 @@"Read-only Attribute": "Atributo de solo lectura","Rebase": "Rebase","Rebase Current Branch onto Selected Commit": "Hacer rebase de la rama actual sobre la confirmación seleccionada",- "Rebase and Push": "Hacer rebase y push","Rebase the current branch on top of incoming changes": "Hacer rebase de la rama actual sobre los cambios entrantes","Rebuild Last": "Recompilar último","Rebuild Project": "Recompilar proyecto",@@ -2267,7 +2265,6 @@"Builds, sync and Maven run configurations run through mvnd for speed. It embeds its own Maven (the home and mvnw are bypassed), needs Java 17+ and builds in parallel by default. Falls back to mvn when mvnd is missing or the JDK is too old.": "Las compilaciones, la sincronización y las configuraciones de ejecución de Maven se ejecutan a través de mvnd para mayor velocidad. Incluye su propio Maven (se omiten el directorio raíz y mvnw), necesita Java 17+ y compila en paralelo de forma predeterminada. Recurre a mvn cuando falta mvnd o el JDK es demasiado antiguo.","The project is not a Git repository.": "El proyecto no es un repositorio de Git.","The project path is always shown in the status bar navigation bar.": "La ruta del proyecto se muestra siempre en la barra de navegación de la barra de estado.",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "El repositorio remoto contiene confirmaciones que no están en tu rama. Actualiza la rama y vuelve a hacer push.","The report covers no files": "El informe no abarca ningún archivo","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "El atajo ya está asignado a otras acciones. ¿Deseas quitar las demás asignaciones?","The tab on the left": "La pestaña de la izquierda",diff --git a/src/platform/locales/text/fr.json b/src/platform/locales/text/fr.jsonindex 95c382ebe..f5ff766d1 100644--- a/src/platform/locales/text/fr.json+++ b/src/platform/locales/text/fr.json@@ -1160,7 +1160,6 @@"Memory Indicator": "Indicateur de mémoire","Memory and diagnostics": "Mémoire et diagnostics","Merge": "Fusionner",- "Merge and Push": "Fusionner et pousser","Merge conflicts": "Conflits de fusion","Merge incoming changes into the current branch": "Fusionner les modifications entrantes dans la branche actuelle","Merge…": "Fusionner…",@@ -1572,7 +1571,6 @@"Read-only Attribute": "Attribut lecture seule","Rebase": "Rebase","Rebase Current Branch onto Selected Commit": "Rebaser la branche actuelle sur le commit sélectionné",- "Rebase and Push": "Rebaser et pousser","Rebase the current branch on top of incoming changes": "Rebaser la branche actuelle sur les modifications entrantes","Rebuild Last": "Recompiler le dernier","Rebuild Project": "Recompiler le projet",@@ -2164,7 +2162,6 @@"The patch file is empty": "Le fichier de patch est vide","The project is not a Git repository.": "Le projet n'est pas un dépôt Git.","The project path is always shown in the status bar navigation bar.": "Le chemin du projet est toujours affiché dans la barre de navigation de la barre d'état.",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "Le dépôt distant contient des commits absents de votre branche. Mettez la branche à jour, puis poussez à nouveau.","The report covers no files": "Le rapport ne couvre aucun fichier","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "Le raccourci est déjà attribué à d'autres actions. Voulez-vous retirer les autres attributions ?","The tab on the left": "L'onglet de gauche",diff --git a/src/platform/locales/text/ko.json b/src/platform/locales/text/ko.jsonindex 1a724815c..062ac14b4 100644--- a/src/platform/locales/text/ko.json+++ b/src/platform/locales/text/ko.json@@ -1219,7 +1219,6 @@"Memory Indicator": "메모리 표시기","Memory and diagnostics": "메모리 및 진단","Merge": "병합",- "Merge and Push": "병합 및 푸시","Merge conflicts": "병합 충돌","Merge incoming changes into the current branch": "수신 변경 사항을 현재 브랜치에 병합","Merge…": "병합…",@@ -1632,7 +1631,6 @@"Read-only Attribute": "읽기 전용 속성","Rebase": "리베이스","Rebase Current Branch onto Selected Commit": "현재 브랜치를 선택한 커밋으로 리베이스",- "Rebase and Push": "리베이스 후 푸시","Rebase the current branch on top of incoming changes": "들어오는 변경 사항 위로 현재 브랜치 리베이스","Rebuild Last": "마지막 항목 다시 빌드","Rebuild Project": "프로젝트 다시 빌드",@@ -2250,7 +2248,6 @@"The patch file is empty": "패치 파일이 비어 있습니다","The project is not a Git repository.": "프로젝트가 Git 저장소가 아닙니다.","The project path is always shown in the status bar navigation bar.": "프로젝트 경로는 항상 상태 표시줄 탐색 표시줄에 표시됩니다.",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "원격에 현재 브랜치에 없는 커밋이 있습니다. 브랜치를 업데이트한 후 다시 푸시하세요.","The report covers no files": "보고서에 포함된 파일이 없습니다","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "이 단축키는 이미 다른 액션에 할당되어 있습니다. 다른 할당을 제거하시겠습니까?","The tab on the left": "왼쪽 탭",diff --git a/src/platform/locales/text/pl.json b/src/platform/locales/text/pl.jsonindex fa53e83c9..3c9c5e5bf 100644--- a/src/platform/locales/text/pl.json+++ b/src/platform/locales/text/pl.json@@ -1221,7 +1221,6 @@"Memory Indicator": "Wskaźnik pamięci","Memory and diagnostics": "Pamięć i diagnostyka","Merge": "Scal (Merge)",- "Merge and Push": "Scal i wyślij (Merge and Push)","Merge conflicts": "Konflikty scalania","Merge incoming changes into the current branch": "Scal przychodzące zmiany z bieżącą gałęzią","Merge…": "Scal…",@@ -1634,7 +1633,6 @@"Read-only Attribute": "Atrybut tylko do odczytu","Rebase": "Zmień bazę (Rebase)","Rebase Current Branch onto Selected Commit": "Zmień bazę bieżącej gałęzi na wybrane zatwierdzenie",- "Rebase and Push": "Zmień bazę i wyślij (Rebase and Push)","Rebase the current branch on top of incoming changes": "Zmień bazę bieżącej gałęzi na wierzch przychodzących zmian","Rebuild Last": "Przebuduj ostatnie","Rebuild Project": "Przebuduj projekt",@@ -2246,7 +2244,6 @@"The patch file is empty": "Plik łatki jest pusty","The project is not a Git repository.": "Projekt nie jest repozytorium Git.","The project path is always shown in the status bar navigation bar.": "Ścieżka projektu jest zawsze wyświetlana na pasku nawigacyjnym paska stanu.",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "Repozytorium zdalne zawiera zatwierdzenia, których nie ma w Twojej gałęzi. Zaktualizuj gałąź, a następnie wyślij ponowne.","The report covers no files": "Raport nie obejmuje żadnych plików","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "Skrót jest już przypisany do innych akcji. Czy chcesz usunąć pozostałe przypisania?","The tab on the left": "Karta po lewej stronie",diff --git a/src/platform/locales/text/pt.json b/src/platform/locales/text/pt.jsonindex a7617da79..a531713b5 100644--- a/src/platform/locales/text/pt.json+++ b/src/platform/locales/text/pt.json@@ -1221,7 +1221,6 @@"Memory Indicator": "Indicador de memória","Memory and diagnostics": "Memória e diagnósticos","Merge": "Mesclar",- "Merge and Push": "Mesclar e fazer push","Merge conflicts": "Conflitos de mesclagem","Merge incoming changes into the current branch": "Mesclar alterações recebidas na branch atual","Merge…": "Mesclar…",@@ -1634,7 +1633,6 @@"Read-only Attribute": "Atributo somente leitura","Rebase": "Rebase","Rebase Current Branch onto Selected Commit": "Fazer rebase da branch atual no commit selecionado",- "Rebase and Push": "Fazer rebase e push","Rebase the current branch on top of incoming changes": "Fazer rebase da branch atual sobre as alterações recebidas","Rebuild Last": "Recompilar último","Rebuild Project": "Recompilar projeto",@@ -2247,7 +2245,6 @@"The patch file is empty": "O arquivo de patch está vazio","The project is not a Git repository.": "O projeto não é um repositório Git.","The project path is always shown in the status bar navigation bar.": "O caminho do projeto é sempre exibido na barra de navegação da barra de status.",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "O repositório remoto contém commits que não estão na sua ramificação. Atualize a ramificação e faça push novamente.","The report covers no files": "O relatório não cobre nenhum arquivo","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "O atalho já está atribuído a outras ações. Deseja remover as outras atribuições?","The tab on the left": "A aba à esquerda",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex 3ed6f978a..ef52b4e21 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -1275,7 +1275,6 @@"Memory Indicator": "内存指示器","Memory and diagnostics": "内存和诊断","Merge": "合并",- "Merge and Push": "合并并推送","Merge conflicts": "合并冲突","Merge incoming changes into the current branch": "将传入的更改合并到当前分支","Merge…": "合并…",@@ -1690,7 +1689,6 @@"Read-only Attribute": "只读属性","Rebase": "变基","Rebase Current Branch onto Selected Commit": "将当前分支变基到所选提交",- "Rebase and Push": "变基并推送","Rebase the current branch on top of incoming changes": "将当前分支变基到传入的更改之上","Rebuild Last": "重新构建上一次","Rebuild Project": "重新构建项目",@@ -2328,7 +2326,6 @@"Builds, sync and Maven run configurations run through mvnd for speed. It embeds its own Maven (the home and mvnw are bypassed), needs Java 17+ and builds in parallel by default. Falls back to mvn when mvnd is missing or the JDK is too old.": "构建、同步和 Maven 运行配置改用 mvnd 执行以提速。它内嵌自己的 Maven(主路径与 mvnw 被绕过),需要 Java 17+,且默认并行构建。mvnd 缺失或 JDK 过旧时自动回退到 mvn。","The project is not a Git repository.": "该项目不是 Git 仓库。","The project path is always shown in the status bar navigation bar.": "项目路径始终显示在状态栏导航栏中。",- "The remote contains commits that are not in your branch. Update the branch, then push again.": "远程包含您的分支中没有的提交。请更新分支,然后再次推送。","The report covers no files": "报告未覆盖任何文件","The shortcut is already assigned to other actions. Do you want to remove other assignments?": "此快捷键已分配给其他操作。要移除其他分配吗?","The tab on the left": "左侧标签页",@@ -6352,5 +6349,32 @@"reset to the commit before the merge": "重置到合并前的提交","reset to the commit before the rebase": "重置到变基前的提交","restore branch {name}": "恢复分支 {name}",- "Rebased": "已变基"+ "Rebased": "已变基",+ "Push to {remote}": "推送到 {remote}",+ "Delete tag {name}": "删除标签 {name}",+ "Deleted tag {name}": "已删除标签 {name}",+ "Restore tag {name}": "恢复标签 {name}",+ "Restored tag {name}": "已恢复标签 {name}",+ "Delete on Remote": "在远程删除",+ "Delete on Remotes": "在各远程删除",+ "Pushed tag {tag} to {remote}": "已将标签 {tag} 推送到 {remote}",+ "Reset to the Remote Branch": "重置为远程分支",+ "Do you want to reset local branch {local} to {remote}? Local commits will be dropped": "是否将本地分支 {local} 重置为 {remote}?本地提交将被丢弃",+ "Don't show again": "不再显示",+ "Push partially failed": "推送部分失败",+ "Push failed": "推送失败",+ "Not pushed: {notPushed}. See the Git console for details.": "未推送:{notPushed}。详情请查看 Git 控制台。",+ "updating after rejected push": "推送被拒后更新",+ "Push of the current branch \"{branch}\" in repository \"{name}\" was rejected.": "仓库“{name}”中当前分支“{branch}”的推送被拒绝。",+ "Push of the current branch \"{branch}\" was rejected.": "当前分支“{branch}”的推送被拒绝。",+ "Remote changes need to be merged before pushing.\n\nIn this case merge is highly recommended, because there are non-pushed merge commits. Rebasing them can lead to problems.": "推送前需要先合并远程更改。\n\n此时强烈建议使用合并,因为存在尚未推送的合并提交,对它们变基可能会出问题。",+ "Remote changes need to be merged before pushing.": "推送前需要先合并远程更改。",+ "Push Rejected": "推送被拒绝",+ "Remember the update method and update silently in the future. Change this later in Settings | Version Control.": "记住更新方式,以后静默更新。之后可在“设置 | 版本控制”中更改。",+ "Rebase Anyway": "仍然变基",+ "the remote": "远程",+ "Force-with-lease push {source} to {target} was rejected. Force-with-lease push prevents overriding remote changes that haven't been fetched to the local repository. Fetch recent changes to verify that they can be discarded safely and repeat the push operation.": "将 {source} 以 force-with-lease 方式推送到 {target} 被拒绝。force-with-lease 推送可防止覆盖尚未获取到本地仓库的远程更改。请先获取最新更改,确认可以安全丢弃后再重新推送。",+ "Force push anyway": "仍然强制推送",+ "Stage and Retry": "暂存并重试",+ "Show Files": "显示文件"}