Merge pull request #13689 from gitbutlerapp/behind-count

Count 'behind' using octopus merge-base of workspace stack tips

Author: mtsgrd

crates/but/tests/but/command/snapshots/status/two-worktrees/status-with-worktrees-verbose.stdout.term.svg

@@ -374,16 +374,44 @@ pub(crate) fn target_to_base_branch(ctx: &Context, target: &Target) -> Result<Ba
     // if there are commits ahead of the base branch consider it diverged
     let diverged = !diverged_ahead.is_empty();
 
-    // gather a list of commits between oid and target.sha
-    let upstream_commits = first_parent_commit_ids_until(repo, target_commit_id, target.sha)
+    // Compute the lowest merge base across all workspace stacks and the target.
+    // Read the workspace ref directly rather than HEAD, since HEAD may not point
+    // at the workspace commit in all code paths.
+    let lowest_merge_base = {
+        let heads: Vec<_> = repo
+            .find_reference(WORKSPACE_REF_NAME)?
+            .peel_to_commit()?
+            .parent_ids()
+            .map(|id| id.detach())
+            .collect();
+        if heads.is_empty() {
+            // No workspace commit parents — fall back to stored target SHA.
+            Some(target.sha)
+        } else {
+            let base = repo
+                .merge_base_octopus([heads.as_slice(), &[target_commit_id]].concat())
+                .context("failed to compute octopus merge-base for workspace stacks")?;
+            Some(base.object()?.id().detach())
+        }
+    };
+
+    // Commits on the target branch between its tip and the lowest merge base.
+    let upstream_commit_ids = lowest_merge_base
+        .map(|lb| first_parent_commit_ids_until(repo, target_commit_id, lb))
+        .transpose()
         .context("failed to get upstream commits")?
+        .unwrap_or_default();
+
+    let upstream_commits = upstream_commit_ids
         .iter()
         .map(|id| {
             let commit = repo.find_commit(*id)?;
             commit_to_remote_commit(&commit)
         })
         .collect::<Result<Vec<_>>>()?;
 
+    let behind = upstream_commits.len();
+
     // get some recent commits
     let recent_commits = first_parent_commit_ids_with_limit(repo, target.sha, 20)
         .context("failed to get recent commits")?
@@ -429,7 +457,7 @@ pub(crate) fn target_to_base_branch(ctx: &Context, target: &Target) -> Result<Ba
         push_remote_url,
         base_sha: target.sha,
         current_sha: target_commit_id,
-        behind: upstream_commits.len(),
+        behind,
         upstream_commits,
         recent_commits,
         last_fetched_ms: ctx

crates/but/tests/but/command/snapshots/status/two-worktrees/status-with-worktrees.stdout.term.svg

@@ -243,3 +243,42 @@ mod go_back_to_workspace {
         assert_eq!(base_two, base);
     }
 }
+
+mod behind_count {
+    use super::*;
+
+    #[test]
+    fn behind_reflects_farthest_behind_stack() {
+        let Test { ctx, .. } = &mut Test::from_fixture("scenario/stacks-with-different-bases.sh");
+
+        // HEAD is on branch A (forks from base, 3 behind origin/master).
+        // set_base_branch picks up A as a workspace stack automatically.
+        let mut guard = ctx.exclusive_worktree_access();
+        gitbutler_branch_actions::set_base_branch(
+            ctx,
+            &"refs/remotes/origin/master".parse().unwrap(),
+            guard.write_permission(),
+        )
+        .unwrap();
+        drop(guard);
+
+        // Apply C (forks from M2, 1 behind).
+        let mut guard = ctx.exclusive_worktree_access();
+        gitbutler_branch_actions::create_virtual_branch_from_branch_with_perm(
+            ctx,
+            &"refs/heads/C".parse().unwrap(),
+            None,
+            guard.write_permission(),
+        )
+        .unwrap();
+        drop(guard);
+
+        // Stack A is farthest behind (3 commits behind origin/master).
+        // Stack C is 1 commit behind. The behind count should reflect the max.
+        let base = gitbutler_branch_actions::base::get_base_branch_data(ctx).unwrap();
+        assert_eq!(
+            base.behind, 3,
+            "behind count should match the farthest-behind stack (A, which is 3 commits behind)"
+        );
+    }
+}

crates/but/tests/but/command/snapshots/status/upstream/status-upstream-summary.stdout.term.svg

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+set -eu -o pipefail
+
+# Two stacks that fork from different points on master, with origin/master
+# advanced past both. This creates a scenario where each stack has
+# a different number of "behind" commits relative to the target.
+#
+# History (after setup):
+#   origin/master = M3 -> M2 -> M1 -> base
+#   Stack A forks from base   (3 commits behind)
+#   Stack C forks from M2     (1 commit behind)
+#
+# HEAD is on branch A so set_base_branch picks it up as a workspace stack.
+# Branch C can then be applied separately.
+
+git init -b master local
+(cd local
+  git config commit.gpgsign false
+  git config user.name gitbutler-test
+  git config user.email gitbutler-test@example.com
+  git config gitbutler.storagePath gitbutler
+
+  echo "base" >file && git add . && git commit -m "base"
+
+  # Stack A forks from base
+  git checkout -b A
+  echo "A-work" >a-file && git add . && git commit -m "A: work"
+
+  # Advance master to M1, M2, M3
+  git checkout master
+  echo "M1" >>file && git add . && git commit -m "M1"
+  echo "M2" >>file && git add . && git commit -m "M2"
+
+  # Stack C forks from M2
+  git checkout -b C
+  echo "C-work" >c-file && git add . && git commit -m "C: work"
+
+  git checkout master
+  echo "M3" >>file && git add . && git commit -m "M3"
+
+  # Leave HEAD on A so set_base_branch picks it up
+  git checkout A
+)
+
+git init --bare remote
+(cd local
+  remote_path="$(cd ../remote && pwd)"
+  git remote add origin "$remote_path"
+  git push origin master
+  git fetch origin '+refs/heads/*:refs/remotes/origin/*'
+)