Add --one-reflog-entry option

README.md

@@ -83,7 +83,7 @@ Note: `cargo install` does not currently know how to install manpages ([cargo#27
 1. `git add` any changes that you want to absorb. By design, `git absorb` will only consider content in the git index (staging area).
 2. `git absorb`. This will create a sequence of commits on `HEAD`. Each commit will have a `fixup!` message indicating the message (if unique) or SHA of the commit it should be squashed into.
 3. If you are satisfied with the output, `git rebase -i --autosquash` to squash the `fixup!` commits into their predecessors. You can set the [`GIT_SEQUENCE_EDITOR`](https://stackoverflow.com/a/29094904) environment variable if you don't need to edit the rebase TODO file.
-4. If you are not satisfied (or if something bad happened), `git reset --soft` to the pre-absorption commit to recover your old state. (You can find the commit in question with `git reflog`.) And if you think `git absorb` is at fault, please [file an issue](https://github.com/tummychow/git-absorb/issues/new).
+4. If you are not satisfied (or if something bad happened), `git reset --soft` to the pre-absorption commit to recover your old state. (You can find the commit in question with `git reflog`. Alternatively, you can run `git absorb` with `--one-reflog-entry`, in which case the pre-absorption commit will be `HEAD@{1}`.) And if you think `git absorb` is at fault, please [file an issue](https://github.com/tummychow/git-absorb/issues/new).
 
 ## How it works (roughly)
 

src/lib.rs

@@ -7,6 +7,7 @@ mod config;
 mod owned;
 mod stack;
 
+use git2::ResetType;
 use std::io::Write;
 use std::path::Path;
 
@@ -19,6 +20,7 @@ pub struct Config<'a> {
     pub rebase_options: &'a Vec<&'a str>,
     pub whole_file: bool,
     pub one_fixup_per_commit: bool,
+    pub one_reflog_entry: bool,
 }
 
 pub fn run(logger: &slog::Logger, config: &Config) -> Result<()> {
@@ -316,7 +318,7 @@ fn run_with_repo(logger: &slog::Logger, config: &Config, repo: &git2::Repository
             if !config.dry_run {
                 head_tree = new_head_tree;
                 head_commit = repo.find_commit(repo.commit(
-                    Some("HEAD"),
+                    (!config.one_reflog_entry).then_some("HEAD"),
                     &signature,
                     &signature,
                     &format!("fixup! {}\n", dest_commit_locator),
@@ -339,6 +341,14 @@ fn run_with_repo(logger: &slog::Logger, config: &Config, repo: &git2::Repository
         }
     }
 
+    if config.one_reflog_entry && !config.dry_run {
+        let mut head_ref = repo.head()?;
+        head_ref.set_target(head_commit.id(), "absorb: adding fixup commits")?;
+        // If you don't like the fancy custom reflog message above and want to stick to Git's own
+        // messages, this would also work:
+        // repo.reset(head_commit.as_object(), ResetType::Soft, None)?;
+    }
+
     if autostage_enabled && we_added_everything_to_index {
         // now that the fixup commits have been created,
         // we should unstage the remaining changes from the index.
@@ -557,6 +567,39 @@ mod tests {
         assert!(nothing_left_in_index(&ctx.repo).unwrap());
     }
 
+    #[test]
+    fn one_reflog_entry() {
+        let ctx = repo_utils::prepare_and_stage();
+
+        // get initial reflog length to compare
+        let initial_reflog_len = ctx.repo.reflog("HEAD").unwrap().len();
+
+        // run 'git-absorb'
+        let drain = slog::Discard;
+        let logger = slog::Logger::root(drain, o!());
+        let config = Config {
+            one_reflog_entry: true,
+            ..DEFAULT_CONFIG
+        };
+        run_with_repo(&logger, &config, &ctx.repo).unwrap();
+
+        // sanity checks: all is as usual when it comes to commits and index:
+        let mut revwalk = ctx.repo.revwalk().unwrap();
+        revwalk.push_head().unwrap();
+        assert_eq!(revwalk.count(), 3);
+        assert!(nothing_left_in_index(&ctx.repo).unwrap());
+
+        // check that only one reflog entry was created:
+        let reflog = ctx.repo.reflog("HEAD").unwrap();
+        let final_reflog_len = reflog.len();
+        assert_eq!(final_reflog_len, initial_reflog_len + 1);
+
+        // check reflog entry message:
+        let reflog_entry = reflog.get(0).unwrap();
+        let reflog_message = reflog_entry.message().unwrap();
+        assert_eq!(reflog_message, "absorb: adding fixup commits");
+    }
+
     #[test]
     fn foreign_author() {
         let ctx = repo_utils::prepare_and_stage();
@@ -973,5 +1016,6 @@ mod tests {
         rebase_options: &Vec::new(),
         whole_file: false,
         one_fixup_per_commit: false,
+        one_reflog_entry: false,
     };
 }

src/main.rs

@@ -44,6 +44,9 @@ struct Cli {
     /// Only generate one fixup per commit
     #[clap(long, short = 'F')]
     one_fixup_per_commit: bool,
+    /// Only generate one reflog entry, no matter how many commits were made
+    #[clap(long, short = 'F')]
+    one_reflog_entry: bool,
 }
 
 fn main() {
@@ -59,6 +62,7 @@ fn main() {
         gen_completions,
         whole_file,
         one_fixup_per_commit,
+        one_reflog_entry,
     } = Cli::parse();
 
     if let Some(shell) = gen_completions {
@@ -109,6 +113,7 @@ fn main() {
             rebase_options: &rebase_options,
             whole_file,
             one_fixup_per_commit,
+            one_reflog_entry,
         },
     ) {
         crit!(logger, "absorb failed"; "err" => e.to_string());