Add new git rebase-with-intermediates command

With this, it's straightforward to have a bunch of intermediate branches, a
future script will allow `git push-all-intermediates` that will make working
with github with multiple PRs that depend on each other more ergonomic.

See the new test for exactly what this does.

Author: quodlibetor

src/bin/git-rebase-with-intermediates.rs

@@ -0,0 +1,21 @@
+use structopt::StructOpt;
+
+#[derive(Debug, StructOpt)]
+#[structopt(
+    about = "Perform a rebase, and pull all the branches that were pointing at commits being rebased",
+    max_term_width = 100,
+    setting = structopt::clap::AppSettings::UnifiedHelpMessage,
+    setting = structopt::clap::AppSettings::ColoredHelp,
+)]
+struct Args {
+    /// The target ref
+    onto: String,
+}
+
+fn main() {
+    let args = Args::from_args();
+    if let Err(e) = git_fixup::rebase_onto(&args.onto) {
+        eprintln!("{:#}", e);
+        std::process::exit(1);
+    }
+}

src/lib.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::process::Command;
 
-use anyhow::{anyhow, bail};
+use anyhow::{anyhow, bail, Context};
 use console::style;
 use dialoguer::{Confirm, Select};
 use git2::{Branch, Commit, Diff, Object, ObjectType, Oid, Rebase, Repository};
@@ -20,21 +20,42 @@ pub fn instafix(
 ) -> Result<(), anyhow::Error> {
     let repo = Repository::open(".")?;
     let diff = create_diff(&repo)?;
-    let head = repo
-        .head()
-        .map_err(|e| anyhow!("HEAD is not pointing at a valid branch: {}", e))?;
+    let head = repo.head().context("finding head commit")?;
     let head_branch = Branch::wrap(head);
-    println!("head_branch: {:?}", head_branch.name().unwrap().unwrap());
     let upstream = get_upstream(&repo, &head_branch, upstream_branch_name)?;
     let commit_to_amend = select_commit_to_amend(&repo, upstream, max_commits, &message_pattern)?;
+    eprintln!("Selected {}", disp(&commit_to_amend));
     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(())
 }
 
+pub fn rebase_onto(onto: &str) -> Result<(), anyhow::Error> {
+    let repo = Repository::open(".")?;
+    let onto = repo
+        .reference_to_annotated_commit(
+            &repo
+                .find_branch(onto, git2::BranchType::Local)
+                .context("Chosing parent")?
+                .get(),
+        )
+        .context("creating onto annotated commit")?;
+    let head = repo
+        .reference_to_annotated_commit(&repo.head().context("finding head")?)
+        .context("choosing branch")?;
+    let rebase = &mut repo
+        .rebase(Some(&head), None, Some(&onto), None)
+        .context("creating rebase")?;
+
+    if let Ok(_) = do_rebase_inner(&repo, rebase, None) {
+        rebase.finish(None).context("finishing")?;
+    }
+
+    Ok(())
+}
+
 fn do_rebase(
     repo: &Repository,
     branch: &Branch,
@@ -48,8 +69,11 @@ fn do_rebase(
 
     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) {
+        .context("starting rebase")?;
+
+    apply_diff_in_rebase(repo, rebase, diff)?;
+
+    match do_rebase_inner(repo, rebase, fixup_message) {
         Ok(_) => {
             rebase.finish(None)?;
             Ok(())
@@ -66,21 +90,11 @@ fn do_rebase(
     }
 }
 
-fn do_rebase_inner(
+fn apply_diff_in_rebase(
     repo: &Repository,
     rebase: &mut Rebase,
     diff: &Diff,
-    fixup_message: Option<&str>,
 ) -> Result<(), anyhow::Error> {
-    let sig = repo.signature()?;
-
-    let mut branches: HashMap<Oid, Branch> = HashMap::new();
-    for (branch, _type) in repo.branches(Some(git2::BranchType::Local))?.flatten() {
-        let oid = branch.get().peel_to_commit()?.id();
-        // TODO: handle multiple branches pointing to the same commit
-        branches.insert(oid, branch);
-    }
-
     match rebase.next() {
         Some(ref res) => {
             let op = res.as_ref().map_err(|e| anyhow!("No commit: {}", e))?;
@@ -98,11 +112,26 @@ fn do_rebase_inner(
                 git2::ResetType::Soft,
                 None,
             )?;
-
-            rewrit_id
         }
         None => bail!("Unable to start rebase: no first step in rebase"),
     };
+    Ok(())
+}
+
+/// Do a rebase, pulling all intermediate branches along the way
+fn do_rebase_inner(
+    repo: &Repository,
+    rebase: &mut Rebase,
+    fixup_message: Option<&str>,
+) -> Result<(), anyhow::Error> {
+    let sig = repo.signature()?;
+
+    let mut branches: HashMap<Oid, Branch> = HashMap::new();
+    for (branch, _type) in repo.branches(Some(git2::BranchType::Local))?.flatten() {
+        let oid = branch.get().peel_to_commit()?.id();
+        // TODO: handle multiple branches pointing to the same commit
+        branches.insert(oid, branch);
+    }
 
     while let Some(ref res) = rebase.next() {
         use git2::RebaseOperationType::*;
@@ -111,12 +140,17 @@ fn do_rebase_inner(
         match op.kind() {
             Some(Pick) => {
                 let commit = repo.find_commit(op.id())?;
-                if commit.message() != fixup_message {
+                let message = commit.message();
+                if message.is_some() && message != fixup_message {
                     let new_id = rebase.commit(None, &sig, None)?;
                     if let Some(branch) = branches.get_mut(&commit.id()) {
-                        branch
-                            .get_mut()
-                            .set_target(new_id, "git-fixup retarget historical branch")?;
+                        // Don't retarget the last branch, rebase.finish does that for us
+                        // TODO: handle multiple branches
+                        if rebase.operation_current() != Some(rebase.len() - 1) {
+                            branch
+                                .get_mut()
+                                .set_target(new_id, "git-fixup retarget historical branch")?;
+                        }
                     }
                 }
             }

tests/basic.rs

@@ -210,6 +210,63 @@ new
     assert_eq!(out, expected, "\nactual:\n{}\nexpected:\n{}", out, expected);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// rebase-with-intermediates tests
+
+#[test]
+fn test_rebase_with_intermediates() {
+    let td = assert_fs::TempDir::new().unwrap();
+    git_init(&td);
+
+    git_commits(&["a", "b", "c"], &td);
+    git(&["checkout", "-b", "int_1", ":/b"], &td);
+    git_commits(&["d", "e"], &td);
+    git(&["checkout", "-b", "int_2"], &td);
+
+    git_commits(&["f", "g"], &td);
+
+    git(&["checkout", "-b", "changes"], &td);
+
+    git_commits(&["h", "i"], &td);
+
+    let out = git_log(&td);
+    let expected = "\
+* i HEAD -> changes
+* h
+* g int_2
+* f
+* e int_1
+* d
+| * c main
+|/
+* b
+* a
+";
+    assert_eq!(
+        out, expected,
+        "pre rebase\nactual:\n{}\nexpected:\n{}",
+        out, expected
+    );
+
+    if let Err(e) = rebase("main", &td).ok() {
+        panic!("ERROR: {}", e);
+    }
+
+    let out = git_log(&td);
+    let expected = "\
+* i HEAD -> changes
+* h
+* g int_2
+* f
+* e int_1
+* d
+* c main
+* b
+* a
+";
+    assert_eq!(out, expected, "\nactual:\n{}\nexpected:\n{}", out, expected);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Helpers
 
@@ -287,3 +344,10 @@ fn fixup(dir: &assert_fs::TempDir) -> Command {
     c.current_dir(&dir.path());
     c
 }
+
+fn rebase(onto: &str, dir: &assert_fs::TempDir) -> Command {
+    let mut c = Command::cargo_bin("git-rebase-with-intermediates").unwrap();
+    c.current_dir(&dir.path());
+    c.arg(onto);
+    c
+}