Ability to make an existing branch dependent and visible in the workspace

Ambiguous branches aren't displayed, but they will be once they are listed in the
workspace metadata.

Author: Byron

crates/but-core/src/ref_metadata.rs

@@ -1,4 +1,5 @@
 use crate::Id;
+use gix::refs::FullNameRef;
 
 /// Metadata about workspaces, associated with references that are designated to a workspace,
 /// i.e. `refs/heads/gitbutler/workspaces/<name>`.
@@ -35,6 +36,50 @@ pub struct Workspace {
     pub push_remote: Option<String>,
 }
 
+/// Mutations
+impl Workspace {
+    /// Insert `branch` as new stack if it's not yet contained in the workspace, and return
+    /// Returns `true` if the ref was newly added, or false if it already existed.
+    pub fn add_new_stack_if_not_present(&mut self, branch: &FullNameRef) -> bool {
+        if self.contains_ref(branch) {
+            return false;
+        };
+
+        self.stacks.push(WorkspaceStack {
+            id: StackId::generate(),
+            branches: vec![WorkspaceStackBranch {
+                ref_name: branch.to_owned(),
+                archived: false,
+            }],
+        });
+        true
+    }
+
+    /// Return `true` if the branch with `name` is the workspace target or the targets local tracking branch,
+    /// using `repo` for the lookup of the local tracking branch.
+    pub fn is_branch_the_target_or_its_local_tracking_branch(
+        &self,
+        name: &gix::refs::FullNameRef,
+        repo: &gix::Repository,
+    ) -> anyhow::Result<bool> {
+        let Some(target_ref) = self.target_ref.as_ref() else {
+            return Ok(false);
+        };
+
+        if target_ref.as_ref() == name {
+            Ok(true)
+        } else {
+            let Some((local_tracking_branch, _remote_name)) =
+                repo.upstream_branch_and_remote_for_tracking_branch(target_ref.as_ref())?
+            else {
+                return Ok(false);
+            };
+            Ok(local_tracking_branch.as_ref() == name)
+        }
+    }
+}
+
+/// Access
 impl Workspace {
     /// Return `true` if `name` is a reference mentioned in our [stacks](Workspace::stacks).
     pub fn contains_ref(&self, name: &gix::refs::FullNameRef) -> bool {
@@ -92,6 +137,18 @@ pub struct Branch {
     pub review: Review,
 }
 
+/// Mutations
+impl Branch {
+    /// Claim that we now updated the branch in some way, and possibly also set the created time
+    /// if `is_new_ref` is `true`
+    pub fn update_times(&mut self, is_new_ref: bool) {
+        self.ref_info.set_updated_to_now();
+        if is_new_ref {
+            self.ref_info.set_created_to_now();
+        }
+    }
+}
+
 impl std::fmt::Debug for Branch {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         const DEFAULT_IN_TESTSUITE: gix::date::Time = gix::date::Time {

crates/but-core/tests/core/main.rs

@@ -2,5 +2,6 @@ mod cmd;
 mod commit;
 mod diff;
 mod json_samples;
+mod ref_metadata;
 mod settings;
 mod unified_diff;

crates/but-core/tests/core/ref_metadata.rs

@@ -0,0 +1,22 @@
+mod workspace {
+    use but_core::ref_metadata::Workspace;
+
+    #[test]
+    fn add_new_stack_if_not_present() {
+        let mut ws = Workspace::default();
+        assert_eq!(ws.stacks.len(), 0);
+
+        let a_ref = r("refs/heads/A");
+        assert!(ws.add_new_stack_if_not_present(a_ref));
+        assert!(!ws.add_new_stack_if_not_present(a_ref));
+        assert_eq!(ws.stacks.len(), 1);
+
+        let b_ref = r("refs/heads/B");
+        assert!(ws.add_new_stack_if_not_present(b_ref));
+        assert_eq!(ws.stacks.len(), 2);
+    }
+
+    fn r(name: &str) -> &gix::refs::FullNameRef {
+        name.try_into().expect("statically known ref")
+    }
+}

crates/but-graph/src/api.rs

@@ -171,6 +171,12 @@ impl Graph {
         self.hard_limit_hit = true;
     }
 
+    /// Lookup the segment of `sidx` and then find its sibling segment, if it has one.
+    pub fn lookup_sibling_segment(&self, sidx: SegmentIndex) -> Option<&Segment> {
+        self.inner
+            .node_weight(self.inner.node_weight(sidx)?.sibling_segment_id?)
+    }
+
     /// Return the entry-point of the graph as configured during traversal.
     /// It's useful for when one wants to know which commit was used to discover the entire graph.
     ///

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

@@ -25,7 +25,7 @@ pub(crate) type Entrypoint = Option<(gix::ObjectId, Option<gix::refs::FullName>)
 
 /// A way to define information to be served from memory, instead of from the underlying data source, when
 /// [initializing](Graph::from_commit_traversal()) the graph.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct Overlay {
     entrypoint: Entrypoint,
     nonoverriding_references: Vec<gix::refs::Reference>,

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

@@ -27,6 +27,13 @@ impl Stack {
             .and_then(|s| s.commits.first().map(|c| c.id))
     }
 
+    /// Return the name of the first segment of the stack.
+    pub fn ref_name(&self) -> Option<&gix::refs::FullNameRef> {
+        self.segments
+            .first()
+            .and_then(|s| s.ref_name.as_ref().map(|rn| rn.as_ref()))
+    }
+
     /// Return the first commit of the first non-empty segment, or `None` this stack is completely empty, or has only empty segments.
     pub fn tip_skip_empty(&self) -> Option<gix::ObjectId> {
         self.segments.iter().find_map(|s| {
@@ -36,6 +43,7 @@ impl Stack {
             s.commits.first().map(|c| c.id)
         })
     }
+
     /// The [base](StackSegment::base) of the last of our segments.
     pub fn base(&self) -> Option<gix::ObjectId> {
         self.segments.last().and_then(|s| s.base)

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

@@ -70,6 +70,23 @@ impl Workspace<'_> {
             .all(|s| s.segments.iter().all(|s| !s.is_entrypoint))
     }
 
+    /// Return `true` if the branch with `name` is the workspace target or the targets local tracking branch.
+    pub fn is_branch_the_target_or_its_local_tracking_branch(
+        &self,
+        name: &gix::refs::FullNameRef,
+    ) -> bool {
+        let Some(t) = self.target.as_ref() else {
+            return false;
+        };
+
+        t.ref_name.as_ref() == name
+            || self
+                .graph
+                .lookup_sibling_segment(t.segment_index)
+                .and_then(|local_tracking_segment| local_tracking_segment.ref_name.as_ref())
+                .is_some_and(|local_tracking_ref| local_tracking_ref.as_ref() == name)
+    }
+
     /// Return the `commit` at the tip of the workspace itself, and do so by following empty segments along the
     /// first parent until the first commit is found.
     /// This importantly is different from the [`Graph::lookup_entrypoint()`] `commit`, as the entrypoint could be anywhere
@@ -264,6 +281,24 @@ pub enum WorkspaceKind {
     AdHoc,
 }
 
+impl WorkspaceKind {
+    /// Return `true` if this workspace has a managed reference, meaning we control certain aspects of it
+    /// by means of workspace metadata that is associated with that ref.
+    /// If `false`, we are more conservative and may not support all features.
+    pub fn has_managed_ref(&self) -> bool {
+        matches!(
+            self,
+            WorkspaceKind::Managed { .. } | WorkspaceKind::ManagedMissingWorkspaceCommit { .. }
+        )
+    }
+
+    /// Return `true` if we have a workspace commit, a commit that merges all stacks together.
+    /// Implies `has_managed_ref() == true`.
+    pub fn has_managed_commit(&self) -> bool {
+        matches!(self, WorkspaceKind::Managed { .. })
+    }
+}
+
 impl WorkspaceKind {
     fn managed(ref_name: &Option<gix::refs::FullName>) -> anyhow::Result<Self> {
         Ok(WorkspaceKind::Managed {
@@ -279,7 +314,7 @@ impl WorkspaceKind {
 #[derive(Debug, Clone)]
 pub struct Target {
     /// The name of the target branch, i.e. the branch that all [Stacks](Stack) want to get merged into.
-    /// Typically, this is `origin/main`.
+    /// Typically, this is `refs/remotes/origin/main`.
     pub ref_name: gix::refs::FullName,
     /// The index to the respective segment in the graph.
     pub segment_index: SegmentIndex,
@@ -438,7 +473,7 @@ impl Graph {
             lower_bound: None,
         };
 
-        let ws_lower_bound = if ws.has_managed_ref() {
+        let ws_lower_bound = if ws.kind.has_managed_ref() {
             self.compute_lowest_base(ws.id, ws.target.as_ref(), self.extra_target)
                 .or_else(|| {
                     // target not available? Try the base of the workspace itself
@@ -501,7 +536,7 @@ impl Graph {
             *lower_bound_segment_id = None;
         }
 
-        if ws.has_managed_ref() && self[ws.id].commits.is_empty() {
+        if ws.kind.has_managed_ref() && self[ws.id].commits.is_empty() {
             ws.kind = WorkspaceKind::ManagedMissingWorkspaceCommit {
                 ref_name: ws_tip_segment
                     .ref_name
@@ -516,7 +551,7 @@ impl Graph {
                 .is_some_and(|rn| rn.as_bstr().starts_with_str("refs/heads/gitbutler/"))
         }
 
-        if ws.has_managed_ref() {
+        if ws.kind.has_managed_ref() {
             let (lowest_base, lowest_base_sidx) =
                 ws_lower_bound.map_or((None, None), |(base, sidx)| (Some(base), Some(sidx)));
             for stack_top_sidx in self
@@ -1070,15 +1105,6 @@ impl Workspace<'_> {
 
 /// Query
 impl<'graph> Workspace<'graph> {
-    /// Return `true` if this workspace is managed, meaning we control certain aspects of it.
-    /// If `false`, we are more conservative and may not support all features.
-    pub fn has_managed_ref(&self) -> bool {
-        matches!(
-            self.kind,
-            WorkspaceKind::Managed { .. } | WorkspaceKind::ManagedMissingWorkspaceCommit { .. }
-        )
-    }
-
     /// Return `true` if the workspace has workspace metadata associated with it.
     /// This is relevant when creating references for example.
     pub fn has_metadata(&self) -> bool {