perf(cli): Split off highly divergent branches

In #216, a user is backporting changes on Linux and hadn't marked
protected branches which would serve as bases, causing git-stack to
topologically sort commits that are very distant from each other,
causing a simple showing of the commit graph to take 20-30s.

This change infers that these branches are do not belong to their base
and split them off.  Now showing the commit graph takes about 6s as it
tries each base.

Author: epage

docs/reference.md

@@ -129,6 +129,7 @@ Configuration is read from the following (in precedence order):
 | stack.protected-branch | \-       | multivar of globs          | Branch names that match these globs (`.gitignore` syntax) are considered protected branches |
 | stack.protect-commit-count | \-   | integer                    | Protect commits that are on a branch with `count`+ commits |
 | stack.protect-commit-age | \-     | time delta (e.g. 10days)   | Protect commits that older than the specified time |
+| stack.auto-base-commit-count | \-     | integer                | Split off branches that are more than `count` commits away from the implied base |
 | stack.stack            | --stack  | "current", "dependents", "descendants", "all" | Which development branch-stacks to operate on |
 | stack.push-remote      | \-       | string                     | Development remote for pushing local branches |
 | stack.pull-remote      | \-       | string                     | Upstream remote for pulling protected branches |

src/bin/git-stack/args.rs

@@ -89,6 +89,7 @@ impl Args {
             protected_branches: None,
             protect_commit_count: None,
             protect_commit_age: None,
+            auto_base_commit_count: None,
             stack: self.stack,
             push_remote: None,
             pull_remote: None,

src/bin/git-stack/stack.rs

@@ -135,8 +135,13 @@ impl State {
             (None, None, git_stack::config::Stack::All) => {
                 let mut stack_branches = std::collections::BTreeMap::new();
                 for (branch_id, branch) in branches.iter() {
-                    let base_branch =
-                        resolve_implicit_base(&repo, branch_id, &branches, &protected_branches);
+                    let base_branch = resolve_implicit_base(
+                        &repo,
+                        branch_id,
+                        &branches,
+                        &protected_branches,
+                        repo_config.auto_base_commit_count(),
+                    );
                     stack_branches
                         .entry(base_branch)
                         .or_insert_with(git_stack::git::Branches::default)
@@ -163,6 +168,7 @@ impl State {
                             head_commit.id,
                             &branches,
                             &protected_branches,
+                            repo_config.auto_base_commit_count(),
                         );
                         // HACK: Since `base` might have come back with a remote branch, treat it as an
                         // "onto" to find the local version.
@@ -175,6 +181,7 @@ impl State {
                             head_commit.id,
                             &branches,
                             &protected_branches,
+                            repo_config.auto_base_commit_count(),
                         );
                         let base = resolve_base_from_onto(&repo, &onto);
                         (base, onto)
@@ -787,9 +794,45 @@ fn resolve_implicit_base(
     head_oid: git2::Oid,
     branches: &git_stack::git::Branches,
     protected_branches: &git_stack::git::Branches,
+    auto_base_commit_count: Option<usize>,
 ) -> AnnotatedOid {
-    let branch = match git_stack::git::find_protected_base(repo, protected_branches, head_oid) {
+    match git_stack::git::find_protected_base(repo, protected_branches, head_oid) {
         Some(branch) => {
+            let merge_base_id = repo
+                .merge_base(branch.id, head_oid)
+                .expect("to be a base, there must be a merge base");
+            if let Some(max_commit_count) = auto_base_commit_count {
+                let ahead_count = repo
+                    .commit_count(merge_base_id, head_oid)
+                    .expect("merge_base should ensure a count exists ");
+                let behind_count = repo
+                    .commit_count(merge_base_id, branch.id)
+                    .expect("merge_base should ensure a count exists ");
+                if max_commit_count <= ahead_count + behind_count {
+                    let assumed_base_oid =
+                        git_stack::git::infer_base(repo, head_oid).unwrap_or(head_oid);
+                    log::warn!(
+                        "{} is {} ahead and {} behind {}, using {} as --base instead",
+                        branches
+                            .get(head_oid)
+                            .map(|b| b[0].to_string())
+                            .or_else(|| {
+                                repo.find_commit(head_oid)?
+                                    .summary
+                                    .to_str()
+                                    .ok()
+                                    .map(ToOwned::to_owned)
+                            })
+                            .unwrap_or_else(|| "target".to_owned()),
+                        ahead_count,
+                        behind_count,
+                        branch,
+                        assumed_base_oid
+                    );
+                    return AnnotatedOid::new(assumed_base_oid);
+                }
+            }
+
             log::debug!(
                 "Chose branch {} as the base for {}",
                 branch,
@@ -816,8 +859,7 @@ fn resolve_implicit_base(
             );
             AnnotatedOid::new(assumed_base_oid)
         }
-    };
-    branch
+    }
 }
 
 fn resolve_base_from_onto(repo: &git_stack::git::GitRepo, onto: &AnnotatedOid) -> AnnotatedOid {

src/config.rs

@@ -5,6 +5,7 @@ pub struct RepoConfig {
     pub protected_branches: Option<Vec<String>>,
     pub protect_commit_count: Option<usize>,
     pub protect_commit_age: Option<std::time::Duration>,
+    pub auto_base_commit_count: Option<usize>,
     pub stack: Option<Stack>,
     pub push_remote: Option<String>,
     pub pull_remote: Option<String>,
@@ -20,6 +21,7 @@ pub struct RepoConfig {
 static PROTECTED_STACK_FIELD: &str = "stack.protected-branch";
 static PROTECT_COMMIT_COUNT: &str = "stack.protect-commit-count";
 static PROTECT_COMMIT_AGE: &str = "stack.protect-commit-age";
+static AUTO_BASE_COMMIT_COUNT: &str = "stack.auto-base-commit-count";
 static STACK_FIELD: &str = "stack.stack";
 static PUSH_REMOTE_FIELD: &str = "stack.push-remote";
 static PULL_REMOTE_FIELD: &str = "stack.pull-remote";
@@ -34,6 +36,7 @@ static DEFAULT_PROTECTED_BRANCHES: [&str; 4] = ["main", "master", "dev", "stable
 static DEFAULT_PROTECT_COMMIT_COUNT: usize = 50;
 static DEFAULT_PROTECT_COMMIT_AGE: std::time::Duration =
     std::time::Duration::from_secs(60 * 60 * 24 * 14);
+static DEFAULT_AUTO_BASE_COMMIT_COUNT: usize = 500;
 const DEFAULT_CAPACITY: usize = 30;
 
 impl RepoConfig {
@@ -132,6 +135,10 @@ impl RepoConfig {
                 {
                     config.protect_commit_age = Some(value);
                 }
+            } else if key == AUTO_BASE_COMMIT_COUNT {
+                if let Some(value) = value.as_ref().and_then(|v| FromStr::from_str(v).ok()) {
+                    config.auto_base_commit_count = Some(value);
+                }
             } else if key == STACK_FIELD {
                 if let Some(value) = value.as_ref().and_then(|v| FromStr::from_str(v).ok()) {
                     config.stack = Some(value);
@@ -190,6 +197,7 @@ impl RepoConfig {
         let mut conf = Self::default();
         conf.protect_commit_count = Some(conf.protect_commit_count().unwrap_or(0));
         conf.protect_commit_age = Some(conf.protect_commit_age());
+        conf.auto_base_commit_count = Some(conf.auto_base_commit_count().unwrap_or(0));
         conf.stack = Some(conf.stack());
         conf.push_remote = Some(conf.push_remote().to_owned());
         conf.pull_remote = Some(conf.pull_remote().to_owned());
@@ -240,6 +248,11 @@ impl RepoConfig {
             .ok()
             .and_then(|s| humantime::parse_duration(&s).ok());
 
+        let auto_base_commit_count = config
+            .get_i64(AUTO_BASE_COMMIT_COUNT)
+            .ok()
+            .map(|i| i.max(0) as usize);
+
         let push_remote = config
             .get_string(PUSH_REMOTE_FIELD)
             .ok()
@@ -279,6 +292,7 @@ impl RepoConfig {
             protected_branches,
             protect_commit_count,
             protect_commit_age,
+            auto_base_commit_count,
             push_remote,
             pull_remote,
             stack,
@@ -320,6 +334,7 @@ impl RepoConfig {
         }
         self.protect_commit_count = other.protect_commit_count.or(self.protect_commit_count);
         self.protect_commit_age = other.protect_commit_age.or(self.protect_commit_age);
+        self.auto_base_commit_count = other.auto_base_commit_count.or(self.auto_base_commit_count);
         self.push_remote = other.push_remote.or(self.push_remote);
         self.pull_remote = other.pull_remote.or(self.pull_remote);
         self.stack = other.stack.or(self.stack);
@@ -349,6 +364,13 @@ impl RepoConfig {
             .unwrap_or(DEFAULT_PROTECT_COMMIT_AGE)
     }
 
+    pub fn auto_base_commit_count(&self) -> Option<usize> {
+        let auto_base_commit_count = self
+            .auto_base_commit_count
+            .unwrap_or(DEFAULT_AUTO_BASE_COMMIT_COUNT);
+        (auto_base_commit_count != 0).then(|| auto_base_commit_count)
+    }
+
     pub fn push_remote(&self) -> &str {
         self.push_remote.as_deref().unwrap_or("origin")
     }
@@ -412,6 +434,12 @@ impl std::fmt::Display for RepoConfig {
             PROTECT_COMMIT_AGE.split_once('.').unwrap().1,
             humantime::format_duration(self.protect_commit_age())
         )?;
+        writeln!(
+            f,
+            "\t{}={}",
+            AUTO_BASE_COMMIT_COUNT.split_once('.').unwrap().1,
+            self.auto_base_commit_count().unwrap_or(0)
+        )?;
         writeln!(
             f,
             "\t{}={}",