Convert to using libgit2 for rebase

This will eventually allow me to bring branches over on various commits

Functionality is currently reduced, it can no longer handle `squash` history.

Author: quodlibetor

src/main.rs

@@ -14,13 +14,12 @@
 
 use std::collections::HashMap;
 use std::env;
-use std::error::Error;
 use std::process::Command;
 
-use anyhow::bail;
+use anyhow::{anyhow, bail};
 use console::style;
 use dialoguer::{Confirm, Select};
-use git2::{Branch, Commit, Diff, Object, ObjectType, Oid, Repository};
+use git2::{Branch, Commit, Diff, Object, ObjectType, Oid, Rebase, Repository};
 use structopt::StructOpt;
 
 const UPSTREAM_VAR: &str = "GIT_INSTAFIX_UPSTREAM";
@@ -72,53 +71,138 @@ fn main() {
         // An empty message means don't display any error message
         let msg = e.to_string();
         if !msg.is_empty() {
-            println!("Error: {}", e);
+            println!("Error: {:#}", e);
         }
         std::process::exit(1);
     }
 }
 
 fn run(
-    squash: bool,
+    _squash: bool,
     max_commits: usize,
     message_pattern: Option<String>,
-) -> Result<(), Box<dyn Error>> {
+) -> Result<(), anyhow::Error> {
     let repo = Repository::open(".")?;
+    let diff = create_diff(&repo)?;
     let head = repo
         .head()
-        .map_err(|e| format!("HEAD is not pointing at a valid branch: {}", e))?;
-    let head_tree = head.peel_to_tree()?;
+        .map_err(|e| anyhow!("HEAD is not pointing at a valid branch: {}", e))?;
     let head_branch = Branch::wrap(head);
-    let diff = repo.diff_tree_to_index(Some(&head_tree), None, None)?;
+    println!("head_branch: {:?}", head_branch.name().unwrap().unwrap());
     let upstream = get_upstream(&repo, &head_branch)?;
-    let commit_to_amend = create_fixup_commit(
-        &repo,
-        &head_branch,
-        upstream,
-        &diff,
-        squash,
-        max_commits,
-        &message_pattern,
-    )?;
-    println!(
-        "selected: {} {}",
-        &commit_to_amend.id().to_string()[0..10],
-        commit_to_amend.summary().unwrap_or("")
-    );
-    // do the rebase
-    let target_id = format!("{}~", commit_to_amend.id());
-    Command::new("git")
-        .args(&["rebase", "--interactive", "--autosquash", &target_id])
-        .env("GIT_SEQUENCE_EDITOR", "true")
-        .spawn()?
-        .wait()?;
+    let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits, &message_pattern)?;
+    do_fixup_commit(&repo, &head_branch, &commit_to_amend, false)?;
+    println!("selected: {}", disp(&commit_to_amend));
+    let current_branch = Branch::wrap(repo.head()?);
+    do_rebase(&repo, &current_branch, &commit_to_amend, &diff)?;
+
+    Ok(())
+}
+
+fn do_rebase(
+    repo: &Repository,
+    branch: &Branch,
+    commit_to_amend: &Commit,
+    diff: &Diff,
+) -> Result<(), anyhow::Error> {
+    let first_parent = repo.find_annotated_commit(commit_parent(commit_to_amend)?.id())?;
+    let branch_commit = repo.reference_to_annotated_commit(branch.get())?;
+    let fixup_commit = branch.get().peel_to_commit()?;
+    let fixup_message = fixup_commit.message();
+
+    let rebase = &mut repo
+        .rebase(Some(&branch_commit), Some(&first_parent), None, None)
+        .map_err(|e| anyhow!("Error starting rebase: {}", e))?;
+    match do_rebase_inner(repo, rebase, diff, fixup_message) {
+        Ok(_) => {
+            rebase.finish(None)?;
+            Ok(())
+        }
+        Err(e) => {
+            eprintln!("Aborting rebase, please apply it manualy via");
+            eprintln!(
+                "    git rebase --interactive --autosquash {}~",
+                first_parent.id()
+            );
+            rebase.abort()?;
+            Err(e)
+        }
+    }
+}
+
+fn do_rebase_inner(
+    repo: &Repository,
+    rebase: &mut Rebase,
+    diff: &Diff,
+    fixup_message: Option<&str>,
+) -> Result<(), anyhow::Error> {
+    let sig = repo.signature()?;
+
+    match rebase.next() {
+        Some(ref res) => {
+            let op = res.as_ref().map_err(|e| anyhow!("No commit: {}", e))?;
+            let target_commit = repo.find_commit(op.id())?;
+            repo.apply(diff, git2::ApplyLocation::Both, None)?;
+            let mut idx = repo.index()?;
+            let oid = idx.write_tree()?;
+            let tree = repo.find_tree(oid)?;
+
+            // TODO: Support squash amends
+
+            let rewrit_id = target_commit.amend(None, None, None, None, None, Some(&tree))?;
+            repo.reset(
+                &repo.find_object(rewrit_id, None)?,
+                git2::ResetType::Soft,
+                None,
+            )?;
+
+            rewrit_id
+        }
+        None => bail!("Unable to start rebase: no first step in rebase"),
+    };
+
+    while let Some(ref res) = rebase.next() {
+        use git2::RebaseOperationType::*;
+
+        let op = res.as_ref().map_err(|e| anyhow!("Err: {}", e))?;
+        match op.kind() {
+            Some(Pick) => {
+                let commit = repo.find_commit(op.id())?;
+                if commit.message() != fixup_message {
+                    rebase.commit(None, &sig, None)?;
+                }
+            }
+            Some(Fixup) | Some(Squash) | Some(Exec) | Some(Edit) | Some(Reword) => {
+                // None of this should happen, we'd need to manually create the commits
+                bail!("Unable to handle {:?} rebase operation", op.kind().unwrap())
+            }
+            None => {}
+        }
+    }
+
     Ok(())
 }
 
+fn commit_parent<'a>(commit: &'a Commit) -> Result<Commit<'a>, anyhow::Error> {
+    match commit.parents().next() {
+        Some(c) => Ok(c),
+        None => bail!("Commit '{}' has no parents", disp(&commit)),
+    }
+}
+
+/// Display a commit as "short_hash summary"
+fn disp(commit: &Commit) -> String {
+    format!(
+        "{} {}",
+        &commit.id().to_string()[0..10],
+        commit.summary().unwrap_or("<no summary>"),
+    )
+}
+
 fn get_upstream<'a>(
     repo: &'a Repository,
     head_branch: &'a Branch,
-) -> Result<Option<Object<'a>>, Box<dyn Error>> {
+) -> Result<Option<Object<'a>>, anyhow::Error> {
     let upstream = if let Ok(upstream_name) = env::var(UPSTREAM_VAR) {
         let branch = repo
             .branches(None)?
@@ -128,7 +212,7 @@ fn get_upstream<'a>(
                     .map(|n| n.expect("valid utf8 branchname") == &upstream_name)
                     .unwrap_or(false)
             })
-            .ok_or_else(|| format!("cannot find branch with name {:?}", upstream_name))?;
+            .ok_or_else(|| anyhow!("cannot find branch with name {:?}", upstream_name))?;
         branch.into_reference().peel(ObjectType::Commit)?
     } else {
         if let Ok(upstream) = head_branch.upstream() {
@@ -150,48 +234,44 @@ fn get_upstream<'a>(
     Ok(Some(commit))
 }
 
-fn create_fixup_commit<'a>(
-    repo: &'a Repository,
-    head_branch: &'a Branch,
-    upstream: Option<Object<'a>>,
-    diff: &'a Diff,
-    squash: bool,
-    max_commits: usize,
-    message_pattern: &Option<String>,
-) -> Result<Commit<'a>, Box<dyn Error>> {
-    let diffstat = diff.stats()?;
-    if diffstat.files_changed() == 0 {
-        let dirty_workdir_stats = repo.diff_index_to_workdir(None, None)?.stats()?;
+/// Get a diff either from the index or the diff from the index to the working tree
+fn create_diff(repo: &Repository) -> Result<Diff, anyhow::Error> {
+    let head = repo.head()?;
+    let head_tree = head.peel_to_tree()?;
+    let staged_diff = repo.diff_tree_to_index(Some(&head_tree), None, None)?;
+    let diffstat = staged_diff.stats()?;
+    let diff = if diffstat.files_changed() == 0 {
+        let diff = repo.diff_index_to_workdir(None, None)?;
+        let dirty_workdir_stats = diff.stats()?;
         if dirty_workdir_stats.files_changed() > 0 {
             print_diff(Changes::Unstaged)?;
             if !Confirm::new()
                 .with_prompt("Nothing staged, stage and commit everything?")
                 .interact()?
             {
-                return Err("".into());
+                bail!("");
             }
         } else {
-            return Err("Nothing staged and no tracked files have any changes".into());
+            bail!("Nothing staged and no tracked files have any changes");
         }
-        let pathspecs: Vec<&str> = vec![];
-        let mut idx = repo.index()?;
-        idx.update_all(&pathspecs, None)?;
-        idx.write()?;
+        repo.apply(&diff, git2::ApplyLocation::Index, None)?;
+        diff
     } else {
         println!("Staged changes:");
         print_diff(Changes::Staged)?;
-    }
-    let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits, message_pattern)?;
-    do_fixup_commit(&repo, &head_branch, &commit_to_amend, squash)?;
-    Ok(commit_to_amend)
+        staged_diff
+    };
+
+    Ok(diff)
 }
 
+/// Commit the current index as a fixup or squash commit
 fn do_fixup_commit<'a>(
     repo: &'a Repository,
     head_branch: &'a Branch,
     commit_to_amend: &'a Commit,
     squash: bool,
-) -> Result<(), Box<dyn Error>> {
+) -> Result<(), anyhow::Error> {
     let msg = if squash {
         format!("squash! {}", commit_to_amend.id())
     } else {
@@ -278,9 +358,9 @@ fn select_commit_to_amend<'a>(
             })
             .collect::<Vec<_>>();
         if upstream.is_none() {
-            eprintln!("Select a commit to amend (no upstream for HEAD):");
+            println!("Select a commit to amend (no upstream for HEAD):");
         } else {
-            eprintln!("Select a commit to amend:");
+            println!("Select a commit to amend:");
         }
         let selected = Select::new().items(&rev_aliases).default(0).interact();
         Ok(repo.find_commit(commits[selected?].id())?)
@@ -293,7 +373,7 @@ fn format_ref(rf: &git2::Reference<'_>) -> Result<String, anyhow::Error> {
     Ok(format!("{} ({})", shorthand, &sha[..10]))
 }
 
-fn print_diff(kind: Changes) -> Result<(), Box<dyn Error>> {
+fn print_diff(kind: Changes) -> Result<(), anyhow::Error> {
     let mut args = vec!["diff", "--stat"];
     if kind == Changes::Staged {
         args.push("--cached");
@@ -302,6 +382,6 @@ fn print_diff(kind: Changes) -> Result<(), Box<dyn Error>> {
     if status.success() {
         Ok(())
     } else {
-        Err("git diff failed".into())
+        bail!("git diff failed")
     }
 }