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)
             }
         };