Merge pull request #204 from p1k0chu/118-root-option

Add --no-limit option

Author: tummychow

Documentation/git-absorb.adoc

@@ -51,6 +51,15 @@ FLAGS
 --dry-run::
         Don't make any actual changes
 
+--no-limit::
+        Remove absorb stack limit. Has no effect when used with `--base`
+        +
+        This will consider all commits until
+        either root, merge commit, or a commit by other author
+        (unless `--force-author` is used)
+        +
+        Which is why you should be careful when using this flag.
+
 --force-author::
         Generate fixups to commits not made by you
 
@@ -153,6 +162,8 @@ edit your local or global `.gitconfig` and add the following section:
     maxStack=50 # Or any other reasonable value for your project
 .............................................................................
 
+Stack size can also be disabled temporarily for one command (see `--no-limit`)
+
 ONE FIXUP PER FIXABLE COMMIT
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

src/lib.rs

@@ -13,6 +13,7 @@ use std::path::Path;
 
 pub struct Config<'a> {
     pub dry_run: bool,
+    pub no_limit: bool,
     pub force_author: bool,
     pub force_detach: bool,
     pub base: Option<&'a str>,
@@ -64,6 +65,7 @@ fn run_with_repo(logger: &slog::Logger, config: &Config, repo: &git2::Repository
 
     let (stack, stack_end_reason) = stack::working_stack(
         repo,
+        config.no_limit,
         config.base,
         config.force_author,
         config.force_detach,
@@ -1031,6 +1033,38 @@ lines
         );
     }
 
+    #[test]
+    fn no_stack_limit_exceeds_stack_limit() {
+        let (ctx, initial_fp) = repo_utils::prepare_repo();
+        let parent_commit = ctx.repo.head().unwrap().peel_to_commit().unwrap();
+        repo_utils::empty_commit_chain(&ctx.repo, "HEAD", &[&parent_commit], config::MAX_STACK);
+
+        repo_utils::stage_file_changes(&ctx, &initial_fp);
+
+        let config = Config {
+            no_limit: true,
+            // to have a predictable number of commits for unit test
+            one_fixup_per_commit: true,
+            ..DEFAULT_CONFIG
+        };
+
+        // run 'git-absorb'
+        let capturing_logger = log_utils::CapturingLogger::new();
+        run_with_repo(&capturing_logger.logger, &config, &ctx.repo).unwrap();
+
+        let mut revwalk = ctx.repo.revwalk().unwrap();
+        revwalk.push_head().unwrap();
+
+        assert_eq!(
+            revwalk.count(),
+            // initial + 10 empty + fixup
+            config::MAX_STACK + 2,
+            "Wrong number of commits."
+        );
+
+        assert!(nothing_left_in_index(&ctx.repo).unwrap());
+    }
+
     #[test]
     fn reached_root() {
         let (ctx, _) = repo_utils::prepare_repo();
@@ -2073,6 +2107,7 @@ lines
 
     const DEFAULT_CONFIG: Config = Config {
         dry_run: false,
+        no_limit: false,
         force_author: false,
         force_detach: false,
         base: None,

src/main.rs

@@ -19,6 +19,9 @@ struct Cli {
     /// Don't make any actual changes
     #[clap(long, short = 'n')]
     dry_run: bool,
+    /// Remove absorb stack limit. Be careful with this
+    #[clap(long)]
+    no_limit: bool,
     /// Generate fixups to commits not made by you
     #[clap(long)]
     force_author: bool,
@@ -58,6 +61,7 @@ fn main() {
     let Cli {
         base,
         dry_run,
+        no_limit,
         force_author,
         force_detach,
         force,
@@ -120,6 +124,7 @@ fn main() {
             base: base.as_deref(),
             and_rebase,
             rebase_options: &rebase_options,
+            no_limit,
             whole_file,
             one_fixup_per_commit,
             squash,

src/stack.rs

@@ -16,6 +16,7 @@ pub enum StackEndReason {
 
 pub fn working_stack<'repo>(
     repo: &'repo git2::Repository,
+    no_limit: bool,
     user_provided_base: Option<&str>,
     force_author: bool,
     force_detach: bool,
@@ -88,7 +89,7 @@ pub fn working_stack<'repo>(
             break;
         }
 
-        if ret.len() == config::max_stack(repo) && user_provided_base.is_none() {
+        if !no_limit && ret.len() == config::max_stack(repo) && user_provided_base.is_none() {
             debug!(logger, "Stopping at stack limit.";
                   "limit" => ret.len());
             stack_end_reason = Some(StackEndReason::ReachedLimit);
@@ -203,7 +204,8 @@ mod tests {
         let commits = repo_utils::empty_commit_chain(&repo, "HEAD", &[], 2);
         repo.branch("hide", &commits[0], false).unwrap();
 
-        let (stack, reason) = working_stack(&repo, None, false, false, &empty_slog()).unwrap();
+        let (stack, reason) =
+            working_stack(&repo, false, None, false, false, &empty_slog()).unwrap();
         assert_stack_matches_chain(1, &stack, &commits);
         assert_eq!(reason, StackEndReason::CommitsHiddenByBranches);
     }
@@ -216,6 +218,7 @@ mod tests {
 
         let (stack, reason) = working_stack(
             &repo,
+            false,
             Some(&commits[0].id().to_string()),
             false,
             false,
@@ -238,7 +241,8 @@ mod tests {
             )
             .unwrap();
 
-        let (stack, reason) = working_stack(&repo, None, false, false, &empty_slog()).unwrap();
+        let (stack, reason) =
+            working_stack(&repo, false, None, false, false, &empty_slog()).unwrap();
         assert_stack_matches_chain(config::MAX_STACK + 1, &stack, &commits);
         assert_eq!(reason, StackEndReason::ReachedLimit);
     }
@@ -254,7 +258,8 @@ mod tests {
         let new_commits =
             repo_utils::empty_commit_chain(&repo, "HEAD", &[old_commits.last().unwrap()], 2);
 
-        let (stack, reason) = working_stack(&repo, None, false, false, &empty_slog()).unwrap();
+        let (stack, reason) =
+            working_stack(&repo, false, None, false, false, &empty_slog()).unwrap();
         assert_stack_matches_chain(2, &stack, &new_commits);
         assert_eq!(reason, StackEndReason::ReachedAnotherAuthor);
     }
@@ -265,7 +270,8 @@ mod tests {
         let merge = repo_utils::merge_commit(&repo, &[]);
         let commits = repo_utils::empty_commit_chain(&repo, "HEAD", &[&merge], 2);
 
-        let (stack, reason) = working_stack(&repo, None, false, false, &empty_slog()).unwrap();
+        let (stack, reason) =
+            working_stack(&repo, false, None, false, false, &empty_slog()).unwrap();
         assert_stack_matches_chain(2, &stack, &commits);
         assert_eq!(reason, StackEndReason::ReachedMergeCommit);
     }