Support force push

assets/vim_style_key_config.ron

@@ -68,6 +68,7 @@
  select_branch: ( code: Char('b'), modifiers: ( bits: 0,),),
  delete_branch: ( code: Char('D'), modifiers: ( bits: 1,),),
  push: ( code: Char('p'), modifiers: ( bits: 0,),),
+ force_push: ( code: Char('P'), modifiers: ( bits: 1,),),
  fetch: ( code: Char('f'), modifiers: ( bits: 0,),),
 
  //removed in 0.11

asyncgit/src/push.rs

@@ -90,6 +90,8 @@ pub struct PushRequest {
  ///
  pub branch: String,
  ///
+ pub force: bool,
+ ///
  pub basic_credential: Option<BasicAuthCredential>,
 }
 
@@ -164,8 +166,9 @@ impl AsyncPush {
  CWD,
  params.remote.as_str(),
  params.branch.as_str(),
+ params.force,
  params.basic_credential,
- progress_sender.clone(),
+ Some(progress_sender.clone()),
  );
 
  progress_sender

asyncgit/src/sync/mod.rs

@@ -98,6 +98,13 @@ mod tests {
  Ok((td, repo))
  }
 
+ /// Same as repo_init, but the repo is a bare repo (--bare)
+ pub fn repo_init_bare() -> Result<(TempDir, Repository)> {
+ let tmp_repo_dir = TempDir::new()?;
+ let bare_repo = Repository::init_bare(tmp_repo_dir.path())?;
+ Ok((tmp_repo_dir, bare_repo))
+ }
+
  /// helper returning amount of files with changes in the (wd,stage)
  pub fn get_statuses(repo_path: &str) -> (usize, usize) {
  (

asyncgit/src/sync/remotes.rs

@@ -111,8 +111,9 @@ pub fn push(
  repo_path: &str,
  remote: &str,
  branch: &str,
+ force: bool,
  basic_credential: Option<BasicAuthCredential>,
- progress_sender: Sender<ProgressNotification>,
+ progress_sender: Option<Sender<ProgressNotification>>,
 ) -> Result<()> {
  scope_time!("push");
 
@@ -122,15 +123,20 @@ pub fn push(
  let mut options = PushOptions::new();
 
  options.remote_callbacks(remote_callbacks(
- Some(progress_sender),
+ progress_sender,
  basic_credential,
  ));
  options.packbuilder_parallelism(0);
 
  let branch_name = format!("refs/heads/{}", branch);
-
- remote.push(&[branch_name.as_str()], Some(&mut options))?;
-
+ if force {
+ remote.push(
+ &[String::from("+") + &branch_name],
+ Some(&mut options),
+ )?;
+ } else {
+ remote.push(&[branch_name.as_str()], Some(&mut options))?;
+ }
  branch_set_upstream(&repo, branch)?;
 
  Ok(())
@@ -306,4 +312,237 @@ mod tests {
  .unwrap();
  assert_eq!(first, String::from("origin"));
  }
+
+ #[test]
+ fn test_force_push() {
+ use super::push;
+ use std::fs::File;
+ use std::io::Write;
+
+ use crate::sync::commit::commit;
+ use crate::sync::tests::{repo_init, repo_init_bare};
+
+ // This test mimics the scenario of 2 people having 2
+ // local branches and both modifying the same file then
+ // both pushing, sequentially
+
+ let (tmp_repo_dir, repo) = repo_init().unwrap();
+ let (tmp_other_repo_dir, other_repo) = repo_init().unwrap();
+ let (tmp_upstream_dir, _) = repo_init_bare().unwrap();
+
+ repo.remote(
+ "origin",
+ tmp_upstream_dir.path().to_str().unwrap(),
+ )
+ .unwrap();
+
+ other_repo
+ .remote(
+ "origin",
+ tmp_upstream_dir.path().to_str().unwrap(),
+ )
+ .unwrap();
+
+ let tmp_repo_file_path =
+ tmp_repo_dir.path().join("temp_file.txt");
+ let mut tmp_repo_file =
+ File::create(tmp_repo_file_path).unwrap();
+ writeln!(tmp_repo_file, "TempSomething").unwrap();
+
+ commit(
+ tmp_repo_dir.path().to_str().unwrap(),
+ "repo_1_commit",
+ )
+ .unwrap();
+
+ push(
+ tmp_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ false,
+ None,
+ None,
+ )
+ .unwrap();
+
+ let tmp_other_repo_file_path =
+ tmp_other_repo_dir.path().join("temp_file.txt");
+ let mut tmp_other_repo_file =
+ File::create(tmp_other_repo_file_path).unwrap();
+ writeln!(tmp_other_repo_file, "TempElse").unwrap();
+
+ commit(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "repo_2_commit",
+ )
+ .unwrap();
+
+ // Attempt a normal push,
+ // should fail as branches diverged
+ assert_eq!(
+ push(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ false,
+ None,
+ None,
+ )
+ .is_err(),
+ true
+ );
+
+ // Attempt force push,
+ // should work as it forces the push through
+ assert_eq!(
+ push(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ true,
+ None,
+ None,
+ )
+ .is_err(),
+ false
+ );
+ }
+
+ #[test]
+ fn test_force_push_rewrites_history() {
+ use super::push;
+ use std::fs::File;
+ use std::io::Write;
+
+ use crate::sync::commit::commit;
+ use crate::sync::tests::{repo_init, repo_init_bare};
+ use crate::sync::LogWalker;
+
+ // This test mimics the scenario of 2 people having 2
+ // local branches and both modifying the same file then
+ // both pushing, sequentially
+
+ let (tmp_repo_dir, repo) = repo_init().unwrap();
+ let (tmp_other_repo_dir, other_repo) = repo_init().unwrap();
+ let (tmp_upstream_dir, upstream) = repo_init_bare().unwrap();
+
+ repo.remote(
+ "origin",
+ tmp_upstream_dir.path().to_str().unwrap(),
+ )
+ .unwrap();
+
+ other_repo
+ .remote(
+ "origin",
+ tmp_upstream_dir.path().to_str().unwrap(),
+ )
+ .unwrap();
+
+ let tmp_repo_file_path =
+ tmp_repo_dir.path().join("temp_file.txt");
+ let mut tmp_repo_file =
+ File::create(tmp_repo_file_path).unwrap();
+ writeln!(tmp_repo_file, "TempSomething").unwrap();
+
+ commit(
+ tmp_repo_dir.path().to_str().unwrap(),
+ "repo_1_commit",
+ )
+ .unwrap();
+
+ let mut repo_commit_ids = Vec::<CommitId>::new();
+ LogWalker::new(&repo).read(&mut repo_commit_ids, 1).unwrap();
+
+ push(
+ tmp_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ false,
+ None,
+ None,
+ )
+ .unwrap();
+
+ let upstream_parent = upstream
+ .find_commit((repo_commit_ids[0]).into())
+ .unwrap()
+ .parents()
+ .next()
+ .unwrap()
+ .id();
+
+ let tmp_other_repo_file_path =
+ tmp_other_repo_dir.path().join("temp_file.txt");
+ let mut tmp_other_repo_file =
+ File::create(tmp_other_repo_file_path).unwrap();
+ writeln!(tmp_other_repo_file, "TempElse").unwrap();
+
+ commit(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "repo_2_commit",
+ )
+ .unwrap();
+ let mut other_repo_commit_ids = Vec::<CommitId>::new();
+ LogWalker::new(&other_repo)
+ .read(&mut other_repo_commit_ids, 1)
+ .unwrap();
+
+ // Attempt a normal push,
+ // should fail as branches diverged
+ assert_eq!(
+ push(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ false,
+ None,
+ None,
+ )
+ .is_err(),
+ true
+ );
+
+ // Check that the other commit is not in upstream,
+ // a normal push would not rewrite history
+ let mut commit_ids = Vec::<CommitId>::new();
+ LogWalker::new(&upstream).read(&mut commit_ids, 1).unwrap();
+ assert_eq!(commit_ids.contains(&repo_commit_ids[0]), true);
+
+ // Attempt force push,
+ // should work as it forces the push through
+ assert_eq!(
+ push(
+ tmp_other_repo_dir.path().to_str().unwrap(),
+ "origin",
+ "master",
+ true,
+ None,
+ None,
+ )
+ .is_err(),
+ false
+ );
+
+ commit_ids.clear();
+ LogWalker::new(&upstream).read(&mut commit_ids, 1).unwrap();
+
+ // Check that only the other repo commit is now in upstream
+ assert_eq!(
+ commit_ids.contains(&other_repo_commit_ids[0]),
+ true
+ );
+
+ assert_eq!(
+ upstream
+ .find_commit((commit_ids[0]).into())
+ .unwrap()
+ .parents()
+ .next()
+ .unwrap()
+ .id()
+ == upstream_parent,
+ true
+ );
+ }
 }

src/app.rs

@@ -493,6 +493,10 @@ impl App {
  self.select_branch_popup.hide();
  }
  }
+ Action::ForcePush(branch, force) => self
+ .queue
+ .borrow_mut()
+ .push_back(InternalEvent::Push(branch, force)),
  },
  InternalEvent::ConfirmAction(action) => {
  self.reset.open(action)?;
@@ -533,8 +537,8 @@ impl App {
  self.file_to_open = path;
  flags.insert(NeedsUpdate::COMMANDS)
  }
- InternalEvent::Push(branch) => {
- self.push_popup.push(branch)?;
+ InternalEvent::Push(branch, force) => {
+ self.push_popup.push(branch, force)?;
  flags.insert(NeedsUpdate::ALL)
  }
  };