Add support for creating dependent branches in workspaces

With and without workspace commits

Author: Byron

crates/but-core/src/ref_metadata.rs

@@ -58,6 +58,22 @@ impl Workspace {
             .iter()
             .find_map(|stack| stack.branches.iter().find(|b| b.ref_name.as_ref() == name))
     }
+
+    /// Find the `(stack_idx, branch_idx)` of `name` within our stack branches and return it,
+    /// for direct access like `ws.stacks[stack_idx].branches[branch_idx]`.
+    pub fn find_owner_indexes_by_name(
+        &self,
+        name: &gix::refs::FullNameRef,
+    ) -> Option<(usize, usize)> {
+        self.stacks
+            .iter()
+            .enumerate()
+            .find_map(|(stack_idx, stack)| {
+                stack.branches.iter().enumerate().find_map(|(seg_idx, b)| {
+                    (b.ref_name.as_ref() == name).then_some((stack_idx, seg_idx))
+                })
+            })
+    }
 }
 
 /// Metadata about branches, associated with any Git branch.

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

@@ -27,6 +27,7 @@ mod post;
 pub struct Overlay {
     nonoverriding_references: Vec<gix::refs::Reference>,
     meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
+    workspace: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
 }
 
 pub(super) type PetGraph = petgraph::stable_graph::StableGraph<Segment, Edge>;

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

@@ -9,7 +9,7 @@ use std::collections::BTreeSet;
 impl Overlay {
     /// Serve the given `refs` from memory, as if they would exist.
     /// This is true only, however, if a real reference doesn't exist.
-    pub fn with_references_non_overriding(
+    pub fn with_references_if_new(
         mut self,
         refs: impl IntoIterator<Item = gix::refs::Reference>,
     ) -> Self {
@@ -19,13 +19,23 @@ impl Overlay {
 
     /// Serve the given `branches` metadata from memory, as if they would exist,
     /// possibly overriding metadata of a ref that already exists.
-    pub fn with_branch_metadata_overriding(
+    pub fn with_branch_metadata_override(
         mut self,
         refs: impl IntoIterator<Item = (gix::refs::FullName, ref_metadata::Branch)>,
     ) -> Self {
         self.meta_branches = refs.into_iter().collect();
         self
     }
+
+    /// Serve the given workspace `metadata` from memory, as if they would exist,
+    /// possibly overriding metadata of a workspace at that place
+    pub fn with_workspace_metadata_override(
+        mut self,
+        metadata: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
+    ) -> Self {
+        self.workspace = metadata;
+        self
+    }
 }
 
 impl Overlay {
@@ -40,6 +50,7 @@ impl Overlay {
         let Overlay {
             nonoverriding_references,
             meta_branches,
+            workspace,
         } = self;
         (
             OverlayRepo {
@@ -49,6 +60,7 @@ impl Overlay {
             OverlayMetadata {
                 inner: meta,
                 meta_branches,
+                workspace,
             },
         )
     }
@@ -209,6 +221,7 @@ impl<'repo> OverlayRepo<'repo> {
 pub(crate) struct OverlayMetadata<'meta, T> {
     inner: &'meta T,
     meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
+    workspace: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
 }
 
 impl<T> OverlayMetadata<'_, T>
@@ -226,13 +239,30 @@ where
                     .ok()
                     .map(|ws| (ref_name, ws))
             })
-            .map(|(ref_name, ws)| (ref_name, (*ws).clone()))
+            .map(|(ref_name, ws)| {
+                if let Some((_ws_ref, ws_override)) = self
+                    .workspace
+                    .as_ref()
+                    .filter(|(ws_ref, _ws_data)| *ws_ref == ref_name)
+                {
+                    (ref_name, ws_override.clone())
+                } else {
+                    (ref_name, (*ws).clone())
+                }
+            })
     }
 
     pub fn workspace_opt(
         &self,
         ref_name: &gix::refs::FullNameRef,
     ) -> anyhow::Result<Option<ref_metadata::Workspace>> {
+        if let Some((_ws_ref, ws_meta)) = self
+            .workspace
+            .as_ref()
+            .filter(|(ws_ref, _ws_meta)| ws_ref.as_ref() == ref_name)
+        {
+            return Ok(Some(ws_meta.clone()));
+        }
         let opt = self.inner.workspace_opt(ref_name)?;
         Ok(opt.map(|ws_data| ws_data.clone()))
     }

crates/but-graph/src/lib.rs

@@ -224,7 +224,7 @@ mod debug;
 pub type CommitIndex = usize;
 
 /// A graph of connected segments that represent a section of the actual commit-graph.
-#[derive(Default, Debug)]
+#[derive(Default, Debug, Clone)]
 pub struct Graph {
     inner: init::PetGraph,
     /// From where the graph was created. This is useful if one wants to focus on a subset of the graph.

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

@@ -130,7 +130,7 @@ impl Workspace<'_> {
             .with_context(|| {
                 format!(
                     "Couldn't find any stack that contained the branch named '{}'",
-                    name.as_bstr()
+                    name.shorten()
                 )
             })
     }
@@ -159,7 +159,7 @@ impl Workspace<'_> {
             .with_context(|| {
                 format!(
                     "Couldn't find any stack that contained the branch named '{}'",
-                    name.as_bstr()
+                    name.shorten()
                 )
             })
     }
@@ -959,7 +959,7 @@ impl Workspace<'_> {
 }
 
 /// Query
-impl Workspace<'_> {
+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 {
@@ -978,8 +978,8 @@ impl Workspace<'_> {
     /// Return the name of the workspace reference by looking our segment up in `graph`.
     /// Note that for managed workspaces, this can be retrieved via [`WorkspaceKind::Managed`].
     /// Note that it can be expected to be set on any workspace, but the data would allow it to not be set.
-    pub fn ref_name<'a>(&self, graph: &'a Graph) -> Option<&'a gix::refs::FullNameRef> {
-        graph[self.id].ref_name.as_ref().map(|rn| rn.as_ref())
+    pub fn ref_name(&self) -> Option<&'graph gix::refs::FullNameRef> {
+        self.graph[self.id].ref_name.as_ref().map(|rn| rn.as_ref())
     }
 }
 

crates/but-graph/src/ref_metadata_legacy.rs

@@ -240,7 +240,8 @@ impl RefMetadata for VirtualBranchesTomlMetadata {
                     stack_id = *branch.stack_id.borrow();
                 } else if stack_id != *branch.stack_id.borrow() {
                     bail!(
-                        "Inconsistent stack detected, wanted {:?}, but got {:?}",
+                        "{}:Inconsistent stack detected, wanted {:?}, but got {:?}",
+                        branch.ref_name.as_bstr(),
                         stack_id,
                         branch.stack_id.borrow()
                     )