feat(rebase): Add RebaseCommand::FixUp

Author: claytonrcarter

git-branchless-lib/src/core/rewrite/execute.rs

@@ -354,7 +354,8 @@ mod in_memory {
     use crate::core::rewrite::move_branches;
     use crate::core::rewrite::plan::{OidOrLabel, RebaseCommand, RebasePlan};
     use crate::git::{
-        CherryPickFastError, CherryPickFastOptions, GitRunInfo, MaybeZeroOid, NonZeroOid, Repo,
+        AmendFastOptions, CherryPickFastError, CherryPickFastOptions, GitRunInfo, MaybeZeroOid,
+        NonZeroOid, Repo,
     };
     use crate::util::ExitCode;
 
@@ -404,6 +405,7 @@ mod in_memory {
                     | RebaseCommand::CreateLabel { .. }
                     | RebaseCommand::Reset { .. }
                     | RebaseCommand::Pick { .. }
+                    | RebaseCommand::FixUp { .. }
                     | RebaseCommand::RegisterExtraPostRewriteHook
                     | RebaseCommand::DetectEmptyCommit { .. }
                     | RebaseCommand::SkipUpstreamAppliedCommit { .. } => None,
@@ -453,6 +455,7 @@ mod in_memory {
                 | RebaseCommand::RegisterExtraPostRewriteHook
                 | RebaseCommand::DetectEmptyCommit { .. } => false,
                 RebaseCommand::Pick { .. }
+                | RebaseCommand::FixUp { .. }
                 | RebaseCommand::Merge { .. }
                 | RebaseCommand::SkipUpstreamAppliedCommit { .. } => true,
             })
@@ -572,9 +575,8 @@ mod in_memory {
 
                         writeln!(
                             effects.get_output_stream(),
-                            "[{}/{}] Skipped now-empty commit: {}",
-                            i,
-                            num_picks,
+                            "{} Skipped now-empty commit: {}",
+                            commit_num,
                             commit_description
                         )?;
                     } else {
@@ -593,6 +595,131 @@ mod in_memory {
                     }
                 }
 
+                RebaseCommand::FixUp {
+                    commit_to_fixup_oid,
+                    fixup_commit_oid,
+                } => {
+                    // FIXME this was mostly copied from RebaseCommand::Pick;
+                    // review before push to make sure it really makes sense or
+                    // can be simplified
+                    let current_commit = repo
+                        .find_commit_or_fail(current_oid)
+                        .wrap_err("Finding current commit")?;
+                    let commit_to_fixup = match rewritten_oids.get(commit_to_fixup_oid) {
+                        Some(MaybeZeroOid::NonZero(rewritten_oid)) => repo
+                            .find_commit_or_fail(*rewritten_oid)
+                            .wrap_err("Finding commit to apply")?,
+                        Some(MaybeZeroOid::Zero) => todo!("FIXME fixing up deleted commit"),
+                        None => repo
+                            .find_commit_or_fail(*commit_to_fixup_oid)
+                            .wrap_err("Finding commit to apply")?,
+                    };
+                    let fixup_commit = repo
+                        .find_commit_or_fail(*fixup_commit_oid)
+                        .wrap_err("Finding commit to apply")?;
+                    i += 1;
+
+                    let commit_description = printable_styled_string(
+                        effects.get_glyphs(),
+                        commit_to_fixup.friendly_describe(effects.get_glyphs())?,
+                    )?;
+                    let commit_num = format!("[{}/{}]", i, num_picks);
+                    progress.notify_progress(i, num_picks);
+
+                    if fixup_commit.get_parent_count() > 1 {
+                        warn!(
+                            ?fixup_commit_oid,
+                            "BUG: Merge commit should have been detected during planning phase"
+                        );
+                        return Ok(RebaseInMemoryResult::CannotRebaseMergeCommit {
+                            commit_oid: *fixup_commit_oid,
+                        });
+                    };
+
+                    progress.notify_status(format!(
+                        "Applying patch for commit: {}",
+                        commit_description
+                    ));
+
+                    let commit_tree = repo.amend_fast(
+                        &commit_to_fixup,
+                        &AmendFastOptions::FromCommit {
+                            commit: fixup_commit,
+                        },
+                    )?;
+
+                    let commit_message = commit_to_fixup.get_message_raw()?;
+                    let commit_message = commit_message.to_str().with_context(|| {
+                        eyre::eyre!(
+                            "Could not decode commit message for commit: {:?}",
+                            fixup_commit_oid
+                        )
+                    })?;
+
+                    progress
+                        .notify_status(format!("Committing to repository: {}", commit_description));
+                    let committer_signature = if *preserve_timestamps {
+                        commit_to_fixup.get_committer()
+                    } else {
+                        commit_to_fixup.get_committer().update_timestamp(*now)?
+                    };
+                    let parent_commit = current_commit.get_parents()[0].clone();
+                    let rebased_commit_oid = repo
+                        .create_commit(
+                            None,
+                            &commit_to_fixup.get_author(),
+                            &committer_signature,
+                            commit_message,
+                            &commit_tree,
+                            vec![&parent_commit],
+                        )
+                        .wrap_err("Applying rebased commit")?;
+
+                    let rebased_commit = repo
+                        .find_commit_or_fail(rebased_commit_oid)
+                        .wrap_err("Looking up just-rebased commit")?;
+                    let commit_description = printable_styled_string(
+                        effects.get_glyphs(),
+                        repo.friendly_describe_commit_from_oid(
+                            effects.get_glyphs(),
+                            rebased_commit_oid,
+                        )?,
+                    )?;
+                    if rebased_commit.is_empty() {
+                        rewritten_oids.insert(*commit_to_fixup_oid, MaybeZeroOid::Zero);
+                        maybe_set_skipped_head_new_oid(*commit_to_fixup_oid, current_oid);
+
+                        writeln!(
+                            effects.get_output_stream(),
+                            "{} Skipped now-empty commit: {}",
+                            commit_num,
+                            commit_description
+                        )?;
+                    } else {
+                        rewritten_oids.insert(
+                            *commit_to_fixup_oid,
+                            MaybeZeroOid::NonZero(rebased_commit_oid),
+                        );
+                        rewritten_oids.insert(
+                            *fixup_commit_oid,
+                            match head_oid {
+                                Some(head_oid) if head_oid == *fixup_commit_oid => {
+                                    MaybeZeroOid::NonZero(rebased_commit_oid)
+                                }
+                                None | Some(_) => MaybeZeroOid::Zero,
+                            },
+                        );
+                        current_oid = rebased_commit_oid;
+
+                        writeln!(
+                            effects.get_output_stream(),
+                            "{} Amended as: {}",
+                            commit_num,
+                            commit_description
+                        )?;
+                    }
+                }
+
                 RebaseCommand::Merge {
                     replacement_commit_oid: None,
                     commit_oid,