Use new versions of ref_info and head_info everywhere so UI can be using it.

Author: Byron

crates/but-graph/src/init/post.rs

@@ -27,14 +27,13 @@ impl Graph {
                 .and_then(|s| s.commit_index_of(tip));
         }
 
-        // TODO: swap these expressions and tests validation will fail.
+        self.workspace_upgrades(meta)?;
+        self.fill_flags_at_border_segments()?;
         self.non_workspace_adjustments(
             repo,
             symbolic_remote_names,
             configured_remote_tracking_branches,
         )?;
-        self.workspace_upgrades(meta)?;
-        self.fill_flags_at_border_segments()?;
 
         Ok(self)
     }

crates/but-graph/tests/fixtures/scenarios.sh

@@ -99,7 +99,7 @@ git init detached
 (cd detached
   commit init && git branch other
   commit first && git tag release/v1 && git tag -am "tag object" annotated
-  git checkout -f @
+  git checkout -f "$(git rev-parse HEAD)"
 )
 
 # A top-down split that is highly unusual, but good to assure we can handle it.
@@ -568,5 +568,21 @@ EOF
       git checkout gitbutler/workspace
       setup_remote_tracking soon-remote-main main "move"
     )
+
+   git init three-branches-one-advanced-ws-commit-advanced-fully-pushed-empty-dependant
+   (cd three-branches-one-advanced-ws-commit-advanced-fully-pushed-empty-dependant
+     git commit -m "init" --allow-empty
+     setup_target_to_match_main
+     git checkout -b lane main
+
+     git checkout -b advanced-lane
+     git commit -m "change" --allow-empty
+     # This works without an official remote setup as we go by name as fallback.
+     remote_tracking_caught_up advanced-lane
+     git branch dependant
+     git branch on-top-of-dependant
+
+     create_workspace_commit_once advanced-lane
+   )
 )
 

crates/but-graph/tests/graph/init/with_workspace.rs

@@ -1357,6 +1357,72 @@ fn workspace_obeys_limit_when_target_branch_is_missing() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn three_branches_one_advanced_ws_commit_advanced_fully_pushed_empty_dependant()
+-> anyhow::Result<()> {
+    let (repo, mut meta) = read_only_in_memory_scenario(
+        "ws/three-branches-one-advanced-ws-commit-advanced-fully-pushed-empty-dependant",
+    )?;
+    insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
+    * f8f33a7 (HEAD -> gitbutler/workspace) GitButler Workspace Commit
+    * cbc6713 (origin/advanced-lane, on-top-of-dependant, dependant, advanced-lane) change
+    * fafd9d0 (origin/main, main, lane) init
+    ");
+
+    add_workspace(&mut meta);
+    let graph = Graph::from_head(&repo, &*meta, standard_options())?.validated()?;
+    insta::assert_snapshot!(graph_tree(&graph), @r"
+    ├── 👉📕►►►:0:gitbutler/workspace
+    │   └── ·f8f33a7 (⌂|🏘️|1)
+    │       └── ►:3:advanced-lane <> origin/advanced-lane
+    │           └── ·cbc6713 (⌂|🏘️|11) ►dependant, ►on-top-of-dependant
+    │               └── ►:1:origin/main
+    │                   └── ·fafd9d0 (⌂|🏘️|✓|11) ►lane, ►main
+    └── ►:2:origin/advanced-lane
+        └── →:3: (advanced-lane)
+    ");
+
+    // By default, the advanced lane is simply frozen as its remote contains the commit.
+    insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
+    📕🏘️:0:gitbutler/workspace <> ✓refs/remotes/origin/main
+    └── ≡:3:advanced-lane <> origin/advanced-lane
+        └── :3:advanced-lane <> origin/advanced-lane
+            └── ❄️cbc6713 (🏘️) ►dependant, ►on-top-of-dependant
+    ");
+
+    add_stack_with_segments(
+        &mut meta,
+        StackId::from_number_for_testing(1),
+        "dependant",
+        StackState::InWorkspace,
+        &["advanced-lane"],
+    );
+
+    // Lanes are properly ordered
+    let graph = Graph::from_head(&repo, &*meta, standard_options())?.validated()?;
+    insta::assert_snapshot!(graph_tree(&graph), @r"
+    ├── 👉📕►►►:0:gitbutler/workspace
+    │   └── ·f8f33a7 (⌂|🏘️|1)
+    │       └── 📙►:4:dependant
+    │           └── 📙►:5:advanced-lane <> origin/advanced-lane
+    │               └── ·cbc6713 (⌂|🏘️|11) ►on-top-of-dependant
+    │                   └── ►:1:origin/main
+    │                       └── ·fafd9d0 (⌂|🏘️|✓|11) ►lane, ►main
+    └── ►:2:origin/advanced-lane
+        └── →:4: (dependant)
+    ");
+
+    // When putting the dependent branch on top as empty segment, the frozen state is retained.
+    insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
+    📕🏘️:0:gitbutler/workspace <> ✓refs/remotes/origin/main
+    └── ≡📙:4:dependant
+        ├── 📙:4:dependant
+        └── 📙:5:advanced-lane <> origin/advanced-lane
+            └── ❄️cbc6713 (🏘️) ►on-top-of-dependant
+    ");
+    Ok(())
+}
+
 #[test]
 fn on_top_of_target_with_history() -> anyhow::Result<()> {
     let (repo, mut meta) = read_only_in_memory_scenario("ws/on-top-of-target-with-history")?;

crates/but-workspace/src/branch_details.rs

@@ -120,6 +120,8 @@ pub fn branch_details(
 ///
 /// - `push_status` - `Integrated` variant is not computed for now (but it's conceivably doable later).
 /// - `is_conflicted` - only local commits contribute.
+// TODO: make use of `but-graph` here: traverse with `name` as entrypoint, maybe even try to cache the
+//       graph and find its segment in there first before traversing unnecessarily.
 pub fn branch_details_v3(
     repo: &gix::Repository,
     name: &gix::refs::FullNameRef,

crates/but-workspace/src/lib.rs

@@ -178,7 +178,10 @@ pub struct RefInfo {
     /// It's never present in single-branch mode.
     pub target_ref: Option<gix::refs::FullName>,
     /// The `workspace_ref_name` is `Some(_)` and belongs to GitButler, because it had metadata attached.
-    pub is_managed: bool,
+    pub is_managed_ref: bool,
+    /// The `workspace_ref_name` points to a commit that was specifically created by us.
+    /// If the user advanced the workspace head by hand, this would be `false`.
+    pub is_managed_commit: bool,
     /// The workspace represents what `HEAD` is pointing to.
     pub is_entrypoint: bool,
 }

crates/but-workspace/src/ref_info.rs

@@ -246,9 +246,11 @@ pub mod ui {
         /// Read-only metadata with additional information about the branch naming the segment,
         /// or `None` if nothing was present.
         pub metadata: Option<ref_metadata::Branch>,
-        /// This is `true` for exactly one segment in a workspace if the entrypoint of [the traversal](Graph::from_commit_traversal())
+        /// This is `true` a segment in a workspace if the entrypoint of [the traversal](Graph::from_commit_traversal())
         /// is this segment, and the surrounding workspace is provided for context.
+        ///
         /// This means one will see the entire workspace, while knowing the focus is on one specific segment.
+        /// *Note* that this segment can be listed in *multiple stacks* as it's reachable from multiple 'ahead' segments.
         pub is_entrypoint: bool,
     }
 
@@ -272,7 +274,7 @@ pub mod ui {
                 is_entrypoint,
             } = self;
             f.debug_struct(&format!(
-                "{ep}StackSegment",
+                "{ep}ref_info::ui::Segment",
                 ep = if *is_entrypoint { "👉" } else { "" }
             ))
             .field("id", &id)
@@ -365,7 +367,8 @@ pub(crate) mod function {
                         stash_status: None,
                     }],
                     is_entrypoint: true,
-                    is_managed,
+                    is_managed_ref: is_managed,
+                    is_managed_commit: false,
                 });
             }
             gix::head::Kind::Detached { .. } => {
@@ -374,7 +377,8 @@ pub(crate) mod function {
                     stacks: vec![],
                     target_ref: None,
                     is_entrypoint: true,
-                    is_managed: false,
+                    is_managed_ref: false,
+                    is_managed_commit: false,
                 });
             }
             gix::head::Kind::Symbolic(name) => name.attach(repo),
@@ -438,13 +442,28 @@ pub(crate) mod function {
         let cache = repo.commit_graph_if_enabled()?;
         let mut graph_cache = repo.revision_graph(cache.as_ref());
 
+        let (workspace_ref_name, is_managed_commit) = match head {
+            HeadLocation::Workspace { ref_name } => {
+                let is_managed = try_refname_to_id(repo, ref_name.as_ref())?
+                    .map(|id| WorkspaceCommit::from_id(id.attach(repo)))
+                    .transpose()?
+                    .is_some_and(|wsc| wsc.is_managed());
+                (Some(ref_name), is_managed)
+            }
+            HeadLocation::Segment { segment_index } => {
+                (graph[segment_index].ref_name.clone(), false)
+            }
+        };
         Ok(RefInfo {
-            workspace_ref_name: match head {
-                HeadLocation::Workspace { ref_name } => Some(ref_name),
-                HeadLocation::Segment { segment_index } => graph[segment_index].ref_name.clone(),
-            },
+            workspace_ref_name,
             stacks: stacks
                 .into_iter()
+                // `but-graph` produces the order as seen by the merge commit,
+                // but GB traditionally shows it the other way around.
+                // TODO: validate that this is still correct to do here if the workspace
+                //       was generated from 'virtual' stacks only, i.e. stacks not from real
+                //       merges.
+                .rev()
                 .map(|stack| {
                     branch::Stack::try_from_graph_stack(
                         stack,
@@ -458,7 +477,8 @@ pub(crate) mod function {
                 })
                 .collect::<anyhow::Result<_>>()?,
             target_ref: target.map(|t| t.ref_name),
-            is_managed: metadata.is_some(),
+            is_managed_ref: metadata.is_some(),
+            is_managed_commit,
             is_entrypoint: graph.lookup_entrypoint()?.segment_index == id,
         })
     }
@@ -928,7 +948,8 @@ pub(crate) mod function {
             stacks,
             target_ref,
             is_entrypoint: false,
-            is_managed,
+            is_managed_commit: false,
+            is_managed_ref: is_managed,
         })
     }
 

crates/but-workspace/src/stacks.rs

@@ -3,7 +3,8 @@ use crate::ref_info::ui::{Commit, Segment};
 use crate::ref_info::ui::{LocalCommit, LocalCommitRelation};
 use crate::ui::{CommitState, PushStatus, StackDetails};
 use crate::{
-    RefInfo, StacksFilter, branch, head_info, id_from_name_v2_to_v3, ref_info, state_handle, ui,
+    RefInfo, StacksFilter, branch, head_info2, id_from_name_v2_to_v3, ref_info, ref_info2,
+    state_handle, ui,
 };
 use anyhow::Context;
 use bstr::BString;
@@ -173,14 +174,19 @@ pub fn stacks_v3(
         Ok(out)
     }
 
-    let info = head_info(
+    let info = head_info2(
         repo,
         meta,
         ref_info::Options {
             // TODO: set this to a good value for the UI to not slow down, and also a value that forces us to re-investigate this.
             stack_commit_limit: 100,
             expensive_commit_info: false,
-            ..Default::default()
+            traversal: but_graph::init::Options {
+                collect_tags: false,
+                commits_limit_hint: Some(300),
+                commits_limit_recharge_location: vec![],
+                hard_limit: None,
+            },
         },
     )?;
 
@@ -390,7 +396,12 @@ pub fn stack_details_v3(
     let ref_info_options = ref_info::Options {
         stack_commit_limit: 0,
         expensive_commit_info: true,
-        ..Default::default()
+        traversal: but_graph::init::Options {
+            collect_tags: false,
+            commits_limit_hint: Some(300),
+            commits_limit_recharge_location: vec![],
+            hard_limit: None,
+        },
     };
     let stack = meta.data().branches.get(&stack_id).with_context(|| {
         format!("Couldn't find {stack_id} even when looking at virtual_branches.toml directly")
@@ -400,7 +411,7 @@ pub fn stack_details_v3(
         shortname = stack.derived_name()?
     ))?;
     let existing_ref = repo.find_reference(&full_name)?;
-    let stack = stack_by_id(ref_info(existing_ref, meta, ref_info_options)?, stack_id, meta)?
+    let stack = stack_by_id(ref_info2(existing_ref, meta, ref_info_options)?, stack_id, meta)?
         .with_context(|| format!("Really couldn't find {stack_id} in current HEAD or when searching virtual_branches.toml plainly"))?;
 
     let branch_details = stack