Support reword in log tab & refactor external editor calls

Cargo.toml

@@ -42,6 +42,7 @@ serde = "1.0"
 anyhow = "1.0"
 unicode-width = "0.1"
 textwrap = "0.13"
+tempfile = "3.2"
 unicode-truncate = "0.2"
 unicode-segmentation = "1.7"
 easy-cast = "0.4"

asyncgit/src/error.rs

@@ -18,6 +18,12 @@ pub enum Error {
     #[error("git: work dir error")]
     NoWorkDir,
 
+    #[error("git: no parent of commit found")]
+    NoParent,
+
+    #[error("git: not on a branch")]
+    NoBranch,
+
     #[error("git: uncommitted changes")]
     UncommittedChanges,
 

asyncgit/src/sync/branch/mod.rs

@@ -44,6 +44,32 @@ pub(crate) fn get_branch_name_repo(
     Err(Error::NoHead)
 }
 
+/// Gets the current branch the user is on.
+/// Returns none if they are not on a branch
+/// and Err if there was a problem finding the branch
+pub(crate) fn get_cur_branch(
+    repo: &Repository,
+) -> Result<Option<git2::Branch>> {
+    for b in repo.branches(None)? {
+        let branch = b?.0;
+        if branch.is_head() {
+            return Ok(Some(branch));
+        }
+    }
+    Ok(None)
+}
+
+/// Convenience function to get the current branch reference
+pub fn get_head_refname(repo_path: &str) -> Result<Option<String>> {
+    let repo = utils::repo(repo_path)?;
+    if let Ok(Some(b)) = get_cur_branch(&repo) {
+        return Ok(Some(String::from_utf8(
+            b.get().name_bytes().to_vec(),
+        )?));
+    }
+    Ok(None)
+}
+
 ///
 #[derive(Debug)]
 pub struct LocalBranch {

asyncgit/src/sync/mod.rs

@@ -17,6 +17,7 @@ mod ignore;
 mod logwalker;
 mod merge;
 mod patches;
+mod rebase;
 pub mod remotes;
 mod reset;
 mod staging;
@@ -54,6 +55,7 @@ pub use logwalker::LogWalker;
 pub use merge::{
     abort_merge, merge_branch, merge_commit, merge_msg, mergehead_ids,
 };
+pub use rebase::reword;
 pub use remotes::{
     get_default_remote, get_remotes, push::AsyncProgress,
     tags::PushTagsProgress,

asyncgit/src/sync/rebase.rs

@@ -0,0 +1,163 @@
+//!
+
+use super::branch::get_head_refname;
+use super::commit::signature_allow_undefined_name;
+use crate::{
+    error::Error,
+    error::Result,
+    sync::{
+        branch::get_cur_branch,
+        utils::{self, bytes2string},
+    },
+};
+use git2::{Oid, RebaseOptions};
+
+/// This is the same as reword, but will abort and fix the repo if something goes wrong
+pub fn reword(
+    repo_path: &str,
+    commit_oid: Oid,
+    message: &str,
+) -> Result<()> {
+    let repo = utils::repo(repo_path)?;
+    let cur_branch_ref = get_head_refname(repo_path)?;
+
+    match reword_internal(repo_path, commit_oid, message) {
+        Ok(()) => Ok(()),
+        // Something went wrong, checkout the previous branch then error
+        Err(e) => {
+            if let Ok(mut rebase) = repo.open_rebase(None) {
+                match cur_branch_ref {
+                    Some(cur_branch) => {
+                        rebase.abort()?;
+                        repo.set_head(&cur_branch)?;
+                        repo.checkout_head(None)?;
+                    }
+                    None => return Err(Error::NoBranch),
+                }
+            }
+            Err(e)
+        }
+    }
+}
+
+/// Changes the commit message of a commit with a specified oid
+///
+/// While this function is most commonly associated with doing a
+/// reword opperation in an interactive rebase, that is not how it
+/// is implemented in git2rs
+///
+/// This is dangerous if it errors, as the head will be detached so this should
+/// always be wrapped by another function which aborts the rebase if something goes wrong
+fn reword_internal(
+    repo_path: &str,
+    commit_oid: Oid,
+    message: &str,
+) -> Result<()> {
+    let repo = utils::repo(repo_path)?;
+    let sig = signature_allow_undefined_name(&repo)?;
+
+    let parent_commit_oid = if let Ok(parent_commit) =
+        repo.find_commit(commit_oid)?.parent(0)
+    {
+        Some(parent_commit.id())
+    } else {
+        None
+    };
+
+    let commit_to_change = if let Some(pc_oid) = parent_commit_oid {
+        // Need to start at one previous to the commit, so
+        // first rebase.next() points to the actual commit we want to change
+        repo.find_annotated_commit(pc_oid)?
+    } else {
+        return Err(Error::NoParent);
+    };
+
+    // If we are on a branch
+    if let Ok(Some(branch)) = get_cur_branch(&repo) {
+        let cur_branch_ref = bytes2string(branch.get().name_bytes())?;
+        let cur_branch_name = bytes2string(branch.name_bytes()?)?;
+        let top_branch_commit = repo.find_annotated_commit(
+            branch.get().peel_to_commit()?.id(),
+        )?;
+
+        let mut rebase = repo.rebase(
+            Some(&top_branch_commit),
+            Some(&commit_to_change),
+            None,
+            Some(&mut RebaseOptions::default()),
+        )?;
+
+        let mut target;
+
+        rebase.next();
+        if parent_commit_oid.is_none() {
+            return Err(Error::NoParent);
+        }
+        target = rebase.commit(None, &sig, Some(message))?;
+
+        // Set target to top commit, don't know when the rebase will end
+        // so have to loop till end
+        while rebase.next().is_some() {
+            target = rebase.commit(None, &sig, None)?;
+        }
+        rebase.finish(None)?;
+
+        // Now override the previous branch
+        repo.branch(
+            &cur_branch_name,
+            &repo.find_commit(target)?,
+            true,
+        )?;
+
+        // Reset the head back to the branch then checkout head
+        repo.set_head(&cur_branch_ref)?;
+        repo.checkout_head(None)?;
+        return Ok(());
+    }
+    // Repo is not on a branch, possibly detached head
+    Err(Error::NoBranch)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::sync::{
+        commit, stage_add_file, tests::repo_init_empty,
+    };
+    use std::{fs::File, io::Write, path::Path};
+
+    #[test]
+    fn test_reword() -> Result<()> {
+        let file_path = Path::new("foo");
+        let (_td, repo) = repo_init_empty().unwrap();
+        let root = repo.path().parent().unwrap();
+        let repo_path = root.as_os_str().to_str().unwrap();
+
+        File::create(&root.join(file_path))?.write_all(b"a")?;
+        stage_add_file(repo_path, file_path).unwrap();
+        commit(repo_path, "commit1").unwrap();
+        File::create(&root.join(file_path))?.write_all(b"ab")?;
+        stage_add_file(repo_path, file_path).unwrap();
+        let oid2 = commit(repo_path, "commit2").unwrap();
+
+        let branch =
+            repo.branches(None).unwrap().next().unwrap().unwrap().0;
+        let branch_ref = branch.get();
+        let commit_ref = branch_ref.peel_to_commit().unwrap();
+        let message = commit_ref.message().unwrap();
+
+        assert_eq!(message, "commit2");
+
+        reword(repo_path, oid2.into(), "NewCommitMessage").unwrap();
+
+        // Need to get the branch again as top oid has changed
+        let branch =
+            repo.branches(None).unwrap().next().unwrap().unwrap().0;
+        let branch_ref = branch.get();
+        let commit_ref_new = branch_ref.peel_to_commit().unwrap();
+        let message_new = commit_ref_new.message().unwrap();
+        assert_eq!(message_new, "NewCommitMessage");
+
+        Ok(())
+    }
+}