Use the projected workspace to drive ref-info

That way it will be possible for the graph to first show up in the UI.

Author: Byron

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

@@ -1,6 +1,6 @@
 use crate::{CommitFlags, CommitIndex, Edge};
 use crate::{Graph, Segment, SegmentIndex, SegmentMetadata};
-use anyhow::bail;
+use anyhow::{Context, bail};
 use but_core::RefMetadata;
 use gix::hashtable::hash_map::Entry;
 use gix::prelude::{ObjectIdExt, ReferenceExt};
@@ -98,6 +98,7 @@ impl Graph {
         options: Options,
     ) -> anyhow::Result<Self> {
         let head = repo.head()?;
+        let mut is_detached = false;
         let (tip, maybe_name) = match head.kind {
             gix::head::Kind::Unborn(ref_name) => {
                 let mut graph = Graph::default();
@@ -109,6 +110,7 @@ impl Graph {
                 return Ok(graph);
             }
             gix::head::Kind::Detached { target, peeled } => {
+                is_detached = true;
                 (peeled.unwrap_or(target).attach(repo), None)
             }
             gix::head::Kind::Symbolic(existing_reference) => {
@@ -117,7 +119,23 @@ impl Graph {
                 (tip, Some(existing_reference.inner.name))
             }
         };
-        Self::from_commit_traversal(tip, maybe_name, meta, options)
+        let mut graph = Self::from_commit_traversal(tip, maybe_name, meta, options)?;
+        if is_detached {
+            // graph is eagerly naming segments, which we undo to show it's detached.
+            let sidx = graph
+                .entrypoint
+                .context("BUG: entrypoint is set after first traversal")?
+                .0;
+            let s = &mut graph[sidx];
+            if let Some((rn, first_commit)) = s
+                .commits
+                .first_mut()
+                .and_then(|first_commit| s.ref_name.take().map(|rn| (rn, first_commit)))
+            {
+                first_commit.refs.push(rn);
+            }
+        };
+        Ok(graph)
     }
     /// Produce a minimal-effort representation of the commit-graph reachable from the commit at `tip` such the returned instance
     /// can represent everything that's observed, without loosing information.

crates/but-graph/src/projection/stack.rs

@@ -2,6 +2,7 @@ use crate::{CommitFlags, Graph, SegmentIndex, SegmentMetadata};
 use anyhow::{Context, bail};
 use bitflags::bitflags;
 use but_core::ref_metadata;
+use gix::reference::Category;
 use petgraph::Direction;
 use std::fmt::Formatter;
 
@@ -80,9 +81,12 @@ pub struct StackSegment {
     ///
     /// The list could be empty for when this is a dedicated empty segment as insertion position of commits.
     pub commits: Vec<StackCommit>,
-    /// Commits that are *only* reachable from the remote-tracking branch that is associated with this branch.
+    /// Commits that are *only* reachable from the tip of the remote-tracking branch that is associated with this branch,
+    /// down to the first (and possibly unrelated) non-remote commit.
     /// Note that these commits may not have an actual commit-graph connection to the local
     /// `commits` available above.
+    /// Further, despite being in a simple list, their order is based on a simple topological walk, so
+    /// this form doesn't imply a linear history.
     pub commits_on_remote: Vec<StackCommit>,
     /// Read-only branch metadata with additional information, or `None` if nothing was present.
     pub metadata: Option<ref_metadata::Branch>,
@@ -127,6 +131,7 @@ impl StackSegment {
 
         // TODO: copy the ReachableByMatchingRemote down to all segments from the first commit that has them,
         //       as they are only detected (and set) on named commits, not their anonymous 'splits'.
+        //       Is this not sufficiently done below? I think so - needs test.
         let mut commits_by_segment = Vec::new();
         for s in segments {
             let mut stack_commits = Vec::new();
@@ -153,7 +158,12 @@ impl StackSegment {
 
             let mut v = Vec::new();
             graph.visit_all_segments_until(remote_sidx, Direction::Outgoing, |s| {
-                let prune = !s.commits.iter().all(|c| c.flags.is_remote());
+                let prune = !s.commits.iter().all(|c| c.flags.is_remote())
+                    // Do not 'steal' commits from other known remote segments while they are officially connected.
+                    || (s.id != remote_sidx
+                        && s.ref_name
+                            .as_ref()
+                            .is_some_and(|orn| orn.category() == Some(Category::RemoteBranch)));
                 if prune {
                     // See if this segment links to a commit we know as local, and mark it accordingly.
                     // `s` may be in `segments`, let's find it and mark all its commits (and all that follow).

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

@@ -99,6 +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 @
 )
 
 # A top-down split that is highly unusual, but good to assure we can handle it.

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

@@ -49,22 +49,24 @@ fn unborn() -> anyhow::Result<()> {
 fn detached() -> anyhow::Result<()> {
     let (repo, meta) = read_only_in_memory_scenario("detached")?;
     insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @r"
-    * 541396b (HEAD -> main, tag: release/v1, tag: annotated) first
+    * 541396b (HEAD, tag: release/v1, tag: annotated, main) first
     * fafd9d0 (other) init
     ");
 
+    // Detached branches are forcefully made anonymous, and it's something
+    // we only know by examining `HEAD`.
     let graph = Graph::from_head(&repo, &*meta, standard_options())?;
     insta::assert_snapshot!(graph_tree(&graph), @r"
-    └── 👉►:0:main
-        └── ·541396b (⌂|1) ►tags/annotated, ►tags/release/v1
+    └── ►:0:anon:
+        └── 👉·541396b (⌂|1) ►tags/annotated, ►tags/release/v1, ►main
             └── ►:1:other
                 └── ·fafd9d0 (⌂|1)
     ");
     insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
-    ⌂:0:main <> ✓!
-    └── ≡:0:main
-        ├── :0:main
-        │   └── ·541396b ►tags/annotated, ►tags/release/v1
+    ⌂:0:DETACHED <> ✓!
+    └── ≡:0:<anon>
+        ├── :0:<anon>
+        │   └── ·541396b ►tags/annotated, ►tags/release/v1, ►main
         └── :1:other
             └── ·fafd9d0
     ");
@@ -78,7 +80,7 @@ fn detached() -> anyhow::Result<()> {
             node weights: {
                 0: StackSegment {
                     id: NodeIndex(0),
-                    ref_name: "refs/heads/main",
+                    ref_name: "None",
                     remote_tracking_ref_name: "None",
                     commits: [
                         Commit(541396b, ⌂|1),
@@ -283,10 +285,9 @@ fn stacked_rebased_remotes() -> anyhow::Result<()> {
     // 'main' is frozen because it connects to a 'foreign' remote, the commit was pushed.
     insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
     ⌂:0:B <> ✓!
-    └── ≡:0:B <> origin/B⇡1⇣2
-        ├── :0:B <> origin/B⇡1⇣2
+    └── ≡:0:B <> origin/B⇡1⇣1
+        ├── :0:B <> origin/B⇡1⇣1
         │   ├── 🟣682be32
-        │   ├── 🟣e29c23d
         │   └── ·312f819
         ├── :2:A <> origin/A⇡1⇣1
         │   ├── 🟣e29c23d

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

@@ -839,14 +839,14 @@ fn stacked_rebased_remotes() -> anyhow::Result<()> {
                 └── 🟣e29c23d
                     └── →:1: (origin/main)
     ");
-    // It's worth noting that we can list remote commits multiple times, and this is because
+    // It's worth noting that we avoid double-listing remote commits that are also
+    // directly owned by another remote segment.
     // they have to be considered as something relevant to the branch history.
     insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
     📕🏘️:0:gitbutler/workspace <> ✓refs/remotes/origin/main
-    └── ≡:2:B <> origin/B⇡1⇣2
-        ├── :2:B <> origin/B⇡1⇣2
+    └── ≡:2:B <> origin/B⇡1⇣1
+        ├── :2:B <> origin/B⇡1⇣1
         │   ├── 🟣682be32
-        │   ├── 🟣e29c23d
         │   └── ·312f819 (🏘️)
         └── :4:A <> origin/A⇡1⇣1
             ├── 🟣e29c23d
@@ -873,10 +873,9 @@ fn stacked_rebased_remotes() -> anyhow::Result<()> {
     ");
     insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
     📕🏘️:1:gitbutler/workspace <> ✓refs/remotes/origin/main
-    └── ≡:4:B <> origin/B⇡1⇣2
-        ├── :4:B <> origin/B⇡1⇣2
+    └── ≡:4:B <> origin/B⇡1⇣1
+        ├── :4:B <> origin/B⇡1⇣1
         │   ├── 🟣682be32
-        │   ├── 🟣e29c23d
         │   └── ·312f819 (🏘️)
         └── 👉:0:A <> origin/A⇡1⇣1
             ├── 🟣e29c23d

crates/but-testing/src/command/mod.rs

@@ -483,6 +483,7 @@ pub fn ref_info(args: &super::Args, ref_name: Option<&str>, expensive: bool) ->
     let opts = but_workspace::ref_info::Options {
         stack_commit_limit: 0,
         expensive_commit_info: expensive,
+        traversal: Default::default(),
     };
 
     let project = project.with_context(|| {

crates/but-workspace/src/lib.rs

@@ -73,7 +73,7 @@ mod commit;
 ///
 /// Note that many of these types should eventually end up in the crate root.
 pub mod ref_info;
-pub use ref_info::function::{head_info, ref_info};
+pub use ref_info::function::{head_info, head_info2, ref_info, ref_info2};
 
 /// High level Stack funtions that use primitives from this crate (`but-workspace`)
 pub mod stack_ext;
@@ -162,19 +162,25 @@ impl HunkHeader {
 ///
 /// We always try to deduce a set of stacks that are currently applied to a workspace,
 /// even though it's possible to look at refs that are outside a workspace as well.
+/// TODO: this should become the UI version of [`but_graph::projection::Workspace`].
+///       This should also include base-branch data, see `get_base_branch_data()`.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct RefInfo {
-    /// The name of the ref that points to a workspace commit.
-    ///
-    /// Such a commit always combines one or more branches and stacks.
+    /// The name of the ref that points to a workspace commit,
+    /// *or* the name of the first stack segment.
     pub workspace_ref_name: Option<gix::refs::FullName>,
     /// The stacks visible in the current workspace.
     ///
     /// This is an empty array if the `HEAD` is detached.
     /// Otherwise, there is one or more stacks.
     pub stacks: Vec<branch::Stack>,
     /// The full name to the target reference that we should integrate with, if present.
+    /// 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,
+    /// The workspace represents what `HEAD` is pointing to.
+    pub is_entrypoint: bool,
 }
 
 /// A representation of the commit that is the tip of the workspace i.e., usually what `HEAD` points to,