Add tests for head_info() for common managed workspace scenarios.

Author: Byron

Cargo.lock

@@ -46,3 +46,4 @@ but-core = { workspace = true, features = ["testing"] }
 # TODO: remove once `gitbutler-repo` isn't needed anymore.
 gitbutler-commit = { workspace = true, features = ["testing"] }
 regex = "1.11.1"
+gitbutler-reference.workspace = true

crates/but-workspace/Cargo.toml

@@ -508,6 +508,7 @@ pub struct Stack {
     /// If there is an integration branch, we know a base commit shared with the integration branch from
     /// which we branched off.
     /// Otherwise, it's the merge-base of all stacks in the current workspace.
+    /// It is `None` if this is a stack derived from a branch without relation to any other branch.
     pub base: Option<gix::ObjectId>,
     /// The branch-name denoted segments of the stack from its tip to the point of reference, typically a merge-base.
     /// This array is never empty.
@@ -518,6 +519,7 @@ pub struct Stack {
     /// using Git commands.
     ///
     /// The backend auto-applies floating stashes, but if that didn't happen, the frontend may guide the user.
+    // TODO: refactor/remove this in favor of special stash commits.
     pub stash_status: Option<StashStatus>,
 }
 
@@ -737,14 +739,17 @@ pub enum RefLocation {
 }
 
 /// A list of all commits in a stack segment of a [`Stack`].
-#[derive(Default, Debug, Clone)]
+#[derive(Default, Clone)]
 pub struct StackSegment {
     /// The name of the branch at the tip of it, and the starting point of the walk.
     ///
     /// It is `None` if this branch is the top-most stack segment and the `ref_name` wasn't pointing to
     /// a commit anymore that was reached by our rev-walk.
     /// This can happen if the ref is deleted, or if it was advanced by other means.
     pub ref_name: Option<gix::refs::FullName>,
+    /// The name of the remote tracking branch of this segment, if present, i.e. `refs/remotes/origin/main`.
+    /// Its presence means that a remote is configured and that the stack content
+    pub remote_tracking_ref_name: Option<gix::refs::FullName>,
     /// Specify where the `ref_name` is specifically, or `None` if there is no ref-name.
     pub ref_location: Option<RefLocation>,
     /// The portion of commits that can be reached from the tip of the *branch* downwards, so that they are unique
@@ -760,15 +765,56 @@ pub struct StackSegment {
     /// no derived value to make this visible explicitly.
     // TODO: review this - should branch divergence be a thing? Rare, but not impossible.
     pub commits_unique_in_remote_tracking_branch: Vec<RemoteCommit>,
-    /// The name of the remote tracking branch of this segment, if present, i.e. `refs/remotes/origin/main`.
-    /// Its presence means that a remote is configured and that the stack content
-    pub remote_tracking_ref_name: Option<gix::refs::FullName>,
     /// Metadata with additional information, or `None` if nothing was present.
     ///
     /// Primary use for this is the consumer, as edits are forced to be made on 'connected' data, so refetching is necessary.
     pub metadata: Option<but_core::ref_metadata::Branch>,
 }
 
+impl std::fmt::Debug for StackSegment {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let StackSegment {
+            ref_name,
+            ref_location,
+            commits_unique_from_tip,
+            commits_unique_in_remote_tracking_branch,
+            remote_tracking_ref_name,
+            metadata,
+        } = self;
+        f.debug_struct("StackSegment")
+            .field(
+                "ref_name",
+                &match ref_name.as_ref() {
+                    None => "None".to_string(),
+                    Some(name) => name.to_string(),
+                },
+            )
+            .field(
+                "remote_tracking_ref_name",
+                &match remote_tracking_ref_name.as_ref() {
+                    None => "None".to_string(),
+                    Some(name) => name.to_string(),
+                },
+            )
+            .field(
+                "ref_location",
+                &match ref_location {
+                    None => "None".to_string(),
+                    Some(location) => {
+                        format!("{:?}", location)
+                    }
+                },
+            )
+            .field("commits_unique_from_tip", &commits_unique_from_tip)
+            .field(
+                "commits_unique_in_remote_tracking_branch",
+                &commits_unique_in_remote_tracking_branch,
+            )
+            .field("metadata", &metadata)
+            .finish()
+    }
+}
+
 /// Return all stack segments within the given `stack`.
 pub fn stack_segments(stack: Stack) -> anyhow::Result<Vec<StackSegment>> {
     todo!()

crates/but-workspace/src/branch.rs

@@ -93,8 +93,9 @@ impl WorkspaceCommit<'_> {
     /// once another branch is added to the workspace.
     pub fn is_managed(&self) -> bool {
         let message = gix::objs::commit::MessageRef::from_bytes(&self.message);
-        message.title == Self::GITBUTLER_INTEGRATION_COMMIT_TITLE
-            || message.title == Self::GITBUTLER_WORKSPACE_COMMIT_TITLE
+        let title = message.title.trim().as_bstr();
+        title == Self::GITBUTLER_INTEGRATION_COMMIT_TITLE
+            || title == Self::GITBUTLER_WORKSPACE_COMMIT_TITLE
     }
 }
 

crates/but-workspace/src/commit.rs

@@ -1,5 +1,5 @@
 /// Options for the [`head_info()`](crate::head_info) call.
-#[derive(Debug, Copy, Clone)]
+#[derive(Default, Debug, Copy, Clone)]
 pub struct Options {
     /// The maximum amount of commits to list *per stack*. Note that a [`StackSegment`](crate::branch::StackSegment) will always have a single commit, if available,
     ///  even if this exhausts the commit limit in that stack.
@@ -17,7 +17,7 @@ pub(crate) mod function {
     use crate::HeadInfo;
     use crate::branch::{LocalCommit, RefLocation, Stack, StackSegment};
     use but_core::ref_metadata::ValueInfo;
-    use gix::prelude::ReferenceExt;
+    use gix::prelude::{ObjectIdExt, ReferenceExt};
     use gix::revision::walk::Sorting;
     use tracing::instrument;
 
@@ -66,10 +66,10 @@ pub(crate) mod function {
         };
 
         let ws_data = workspace_data_of_workspace_branch(meta, existing_ref.name())?;
-        let target_ref = if let Some(_data) = ws_data {
-            todo!(
-                "figure out what to do with workspace information, consolidate it with what's there as well"
-            );
+        let target_ref = if let Some(data) = ws_data {
+            // TODO: figure out what to do with workspace information, consolidate it with what's there as well
+            //       to know which branch is where.
+            data.target_ref
         } else {
             None
         };
@@ -79,33 +79,104 @@ pub(crate) mod function {
             id: head_commit.id(),
             inner: head_commit.decode()?.to_owned(),
         };
-        if head_commit.is_managed() {
-            todo!("deal with managed commits");
+        let refs_by_id = collect_refs_by_commit_id(repo)?;
+        let target_ref_id = target_ref
+            .as_ref()
+            .and_then(|r| repo.try_find_reference(r).transpose())
+            .transpose()?
+            .map(|mut r| r.peel_to_id_in_place())
+            .transpose()?;
+        let cache = repo.commit_graph_if_enabled()?;
+        let mut graph = repo.revision_graph(cache.as_ref());
+        let base =
+            if target_ref_id.is_none() {
+                Some(repo.merge_base_octopus_with_graph(
+                    head_commit.parents.iter().cloned(),
+                    &mut graph,
+                )?)
+            } else {
+                None
+            };
+        let stacks = if head_commit.is_managed() {
+            // The commits we have already associated with a stack segment.
+            let mut associated_commits = gix::hashtable::HashSet::default();
+            let mut stacks = Vec::new();
+            for (index, commit_id) in head_commit.parents.iter().enumerate() {
+                let tip = *commit_id;
+                let base = base
+                    .map(Ok)
+                    .or_else(|| {
+                        target_ref_id
+                            .map(|target_id| repo.merge_base_with_graph(target_id, tip, &mut graph))
+                    })
+                    .transpose()?
+                    .map(|base| base.detach());
+                associated_commits.extend(base);
+                let segments = collect_stack_segments(
+                    tip.attach(repo),
+                    refs_by_id
+                        .get(&tip)
+                        .and_then(|refs| refs.first().map(|r| r.as_ref())),
+                    Some(RefLocation::ReachableFromWorkspaceCommit),
+                    &associated_commits, /* boundary commits */
+                    // TODO: get from workspace information maybe?
+                    &[], /* preferred refs */
+                    options.stack_commit_limit,
+                    &refs_by_id,
+                )?;
+
+                associated_commits.extend(segments.iter().flat_map(|segment| {
+                    segment.commits_unique_from_tip.iter().map(|c| c.id).chain(
+                        segment
+                            .commits_unique_in_remote_tracking_branch
+                            .iter()
+                            .map(|c| c.id),
+                    )
+                }));
+
+                stacks.push(Stack {
+                    index,
+                    tip: Some(tip),
+                    segments,
+                    base,
+                    // TODO: but as part of the commits.
+                    stash_status: None,
+                })
+            }
+            stacks
         } else {
             // Discover all references that actually point to the reachable graph.
-            let refs_by_id = collect_refs_by_commit_id(repo)?;
+            let boundary = {
+                let mut hs = gix::hashtable::HashSet::default();
+                hs.extend(target_ref_id.map(|id| id.detach()));
+                hs
+            };
+            let tip = head_commit.id;
             let segments = collect_stack_segments(
-                head_commit.id,
+                tip,
                 Some(existing_ref.name()),
                 Some(RefLocation::AtHead),
-                &[],                               /* boundary commits */
+                &boundary,                         /* boundary commits */
                 &[existing_ref.name().to_owned()], /* preferred refs */
                 options.stack_commit_limit,
                 &refs_by_id,
             )?;
-            Ok(HeadInfo {
-                stacks: vec![Stack {
-                    index: 0,
-                    tip: segments
-                        .first()
-                        .and_then(|stack| Some(stack.commits_unique_from_tip.first()?.id)),
-                    base: None,
-                    segments,
-                    stash_status: None,
-                }],
-                target_ref,
-            })
-        }
+
+            let base = target_ref_id
+                .map(|target_id| repo.merge_base_with_graph(target_id, tip, &mut graph))
+                .transpose()?
+                .map(|base| base.detach());
+            vec![Stack {
+                index: 0,
+                tip: Some(tip.detach()),
+                // TODO: compute base if target-ref is available, but only if this isn't the target ref!
+                base,
+                segments,
+                stash_status: None,
+            }]
+        };
+
+        Ok(HeadInfo { stacks, target_ref })
     }
 
     /// Walk down the commit-graph from `tip` until a `boundary_commits` is encountered, excluding it, or to the graph root if there is no boundary.
@@ -116,11 +187,12 @@ pub(crate) mod function {
     /// *and* there are more than one ref pointing to it.
     ///
     /// Note that `boundary_commits` are sorted so binary-search can be used to quickly check membership.
+    /// TODO: also add `hidden` commits, for a list of special commits like the merge-base where all parents should be hidden as well.
     fn collect_stack_segments(
         tip: gix::Id<'_>,
         tip_ref: Option<&gix::refs::FullNameRef>,
         ref_location: Option<RefLocation>,
-        boundary_commits: &[gix::ObjectId],
+        boundary_commits: &gix::hashtable::HashSet,
         preferred_refs: &[gix::refs::FullName],
         mut limit: usize,
         refs_by_id: &RefsById,
@@ -148,7 +220,7 @@ pub(crate) mod function {
                 }
             }
             let info = info?;
-            if boundary_commits.binary_search(&info.id).is_ok() {
+            if boundary_commits.contains(&info.id) {
                 out.extend(segment.take());
                 break;
             }

crates/but-workspace/src/head_info.rs

@@ -86,6 +86,14 @@ impl VirtualBranchesTomlMetadata {
     }
 }
 
+/// Mostly used in testing, and it's fine as it's intermediate, and we are very practical here.
+impl VirtualBranchesTomlMetadata {
+    /// Return a mutable snapshot of the underlying data. Useful for testing mainly.
+    pub fn data_mut(&mut self) -> &mut VirtualBranchesState {
+        &mut self.snapshot.content
+    }
+}
+
 // Emergency-behaviour in case the application winds down, we don't want data-loss (at least a chance).
 impl Drop for VirtualBranchesTomlMetadata {
     fn drop(&mut self) {

crates/but-workspace/src/virtual_branches_metadata.rs

@@ -25,4 +25,5 @@
 /mixed-hunk-modifications.tar
 /plain-modifications.tar
 /three-commits-with-line-offset-and-workspace-commit.tar
-/with_remotes_no_workspace.tar
+/with-remotes-no-workspace.tar
+/with-remotes-and-workspace.tar

crates/but-workspace/tests/fixtures/generated-archives/.gitignore

@@ -0,0 +1,59 @@
+#!/usr/bin/env bash
+
+### General Description
+
+# Various directories with different scenarios for testing stack information *with* a workspace commit,
+# and of course with a remote and a branch to integrate with.
+set -eu -o pipefail
+
+function set_author() {
+  local author=${1:?Author}
+
+  unset GIT_AUTHOR_NAME
+  unset GIT_AUTHOR_EMAIL
+
+  git config user.name $author
+  git config user.email $author@example.com
+}
+
+
+# can only be called once per test setup
+function create_workspace_commit_once() {
+  local workspace_commit_subject="GitButler Workspace Commit"
+
+  if [ $# == 1 ]; then
+    local current_branch=$(git rev-parse --abbrev-ref HEAD)
+    if [[ "$current_branch" != "$1" ]]; then
+      echo "BUG: Must assure the current branch is the branch passed as argument: $current_branch != $1"
+      return 42
+    fi
+  fi
+
+  git checkout -b gitbutler/workspace
+  if [ $# == 1 ] || [ $# == 0 ]; then
+    git commit --allow-empty -m "$workspace_commit_subject"
+  else
+    git merge -m "$workspace_commit_subject" "${@}"
+  fi
+}
+
+git init remote
+(cd remote
+  touch file
+  git add . && git commit -m init-integration
+
+  git checkout -b A
+  touch file-in-A && git add . && git commit -m "new file in A"
+  echo change >file-in-A && git commit -am "change in A"
+
+  git checkout main
+)
+
+# The remote has a new commit, but is fast-forwardable
+git clone remote remote-advanced-ff
+(cd remote-advanced-ff
+  git checkout -b A origin/A
+  git reset --hard @~1
+
+  create_workspace_commit_once A
+)

crates/but-workspace/tests/fixtures/scenario/with-remotes-and-workspace.sh

@@ -27,14 +27,14 @@ git init remote
   git checkout main
 )
 
-# The remote has a new commit, but is fast-forwardable
+# The remote has a new commit, but is fast-forwardable.
 git clone remote remote-tracking-advanced-ff
 (cd remote-tracking-advanced-ff
   git checkout -b A origin/A
   git reset --hard @~1
 )
 
-# The remote has a new commit, but is fast-forwardable
+# The remote has a new commit, and local has a new commit in an unreconcilable way.
 cp -R remote-tracking-advanced-ff remote-diverged
 (cd remote-diverged
   set_author local-user