Perform an actual workspace commit merge

Author: Byron

crates/but-core/src/ref_metadata.rs

@@ -38,22 +38,46 @@ pub struct Workspace {
 
 /// 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 {
+    /// Insert `branch` as new stack if it's not yet contained in the workspace and if `order` is not `None` or push
+    /// it to the end of the stack list.
+    /// Note that `order` is only relevant at insertion time.
+    /// Returns `true` if the ref was newly added, or `false` if it already existed.
+    pub fn add_or_insert_new_stack_if_not_present(
+        &mut self,
+        branch: &FullNameRef,
+        order: Option<usize>,
+    ) -> bool {
         if self.contains_ref(branch) {
             return false;
         };
 
-        self.stacks.push(WorkspaceStack {
+        let stack = WorkspaceStack {
             id: StackId::generate(),
             branches: vec![WorkspaceStackBranch {
                 ref_name: branch.to_owned(),
                 archived: false,
             }],
-        });
+        };
+        match order.map(|idx| idx.min(self.stacks.len())) {
+            None => {
+                self.stacks.push(stack);
+            }
+            Some(existing_index) => {
+                self.stacks.insert(existing_index, stack);
+            }
+        }
         true
     }
+}
+
+/// Access
+impl Workspace {
+    /// Return the names of the tips of all stacks in the workspace.
+    pub fn stack_names(&self) -> impl Iterator<Item = &gix::refs::FullNameRef> {
+        self.stacks
+            .iter()
+            .filter_map(|s| s.ref_name().map(|rn| rn.as_ref()))
+    }
 
     /// 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.
@@ -77,10 +101,7 @@ impl Workspace {
             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 {
         self.stacks

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

@@ -7,13 +7,17 @@ mod workspace {
         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!(ws.add_or_insert_new_stack_if_not_present(a_ref, Some(100)));
+        assert!(!ws.add_or_insert_new_stack_if_not_present(a_ref, Some(200)));
         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);
+        assert!(ws.add_or_insert_new_stack_if_not_present(b_ref, Some(0)));
+        assert_eq!(ws.stack_names().collect::<Vec<_>>(), [b_ref, a_ref]);
+
+        let c_ref = r("refs/heads/C");
+        assert!(ws.add_or_insert_new_stack_if_not_present(c_ref, None));
+        assert_eq!(ws.stack_names().collect::<Vec<_>>(), [b_ref, a_ref, c_ref]);
     }
 
     fn r(name: &str) -> &gix::refs::FullNameRef {

crates/but-graph/src/api.rs

@@ -63,6 +63,53 @@ impl Graph {
     }
 }
 
+/// Merge-base computation
+impl Graph {
+    /// Compute the lowest merge-base between two segments.
+    /// Such a merge-base is reachable from all possible paths from `a` and `b`.
+    ///
+    /// The segment representing the merge-base is expected to not be empty, as its first commit
+    /// is usually what one is interested in.
+    // TODO: should be multi, with extra segments as third parameter
+    // TODO: actually find the lowest merge-base, right now it just finds the first merge-base, but that's not
+    //       the lowest.
+    pub fn first_merge_base(&self, a: SegmentIndex, b: SegmentIndex) -> Option<SegmentIndex> {
+        // TODO(perf): improve this by allowing to set bitflags on the segments themselves, to allow
+        //       marking them accordingly, just like Git does.
+        //       Right now we 'emulate' bitflags on pre-allocated data with two data sets, expensive
+        //       in comparison.
+        //       And yes, let's avoid `gix::Repository::merge_base` as we have free
+        //       generation numbers here and can avoid work duplication.
+        let mut segments_reachable_by_b = BTreeSet::new();
+        self.visit_all_segments_including_start_until(b, Direction::Outgoing, |s| {
+            segments_reachable_by_b.insert(s.id);
+            // Collect everything, keep it simple.
+            // This is fast* as completely in memory.
+            // *means slow compared to an array traversal with memory locality.
+            false
+        });
+
+        let mut candidate = None;
+        self.visit_all_segments_including_start_until(a, Direction::Outgoing, |s| {
+            if candidate.is_some() {
+                return true;
+            }
+            let prune = segments_reachable_by_b.contains(&s.id);
+            if prune {
+                candidate = Some(s.id);
+            }
+            prune
+        });
+        if candidate.is_none() {
+            // TODO: improve this - workspaces shouldn't be like this but if they are, do we deal with it well?
+            tracing::warn!(
+                "Couldn't find merge-base between segments {a:?} and {b:?} - this might lead to unexpected results"
+            )
+        }
+        candidate
+    }
+}
+
 /// Query
 /// ‼️Useful only if one knows the graph traversal was started where one expects, or else the graph may be partial.
 impl Graph {
@@ -130,6 +177,11 @@ impl Graph {
         sidx_with_commits.and_then(|sidx| self[sidx].commits.first())
     }
 
+    /// The first commit reachable by skipping over empty segments starting at the entrypoint segment.
+    pub fn entrypoint_commit(&self) -> Option<&Commit> {
+        self.tip_skip_empty(self.entrypoint?.0)
+    }
+
     /// Visit the ancestry of `start` along the first parents, itself excluded, until `stop` returns `true`.
     /// Also return the segment that we stopped at.
     /// **Important**: `stop` is not called with `start`, this is a feature.

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

@@ -29,6 +29,7 @@ pub(crate) type Entrypoint = Option<(gix::ObjectId, Option<gix::refs::FullName>)
 pub struct Overlay {
     entrypoint: Entrypoint,
     nonoverriding_references: Vec<gix::refs::Reference>,
+    overriding_references: Vec<gix::refs::Reference>,
     meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
     workspace: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
 }

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

@@ -2,6 +2,7 @@ use crate::init::walk::RefsById;
 use crate::init::{Entrypoint, Overlay};
 use but_core::{RefMetadata, ref_metadata};
 use gix::prelude::ReferenceExt;
+use gix::refs::Target;
 use std::borrow::Cow;
 use std::collections::BTreeSet;
 
@@ -16,13 +17,27 @@ impl Overlay {
         self
     }
 
+    /// Serve the given `refs` from memory, which is like creating the reference or as if its value was set,
+    /// completely overriding the value in the repository.
+    pub fn with_references(mut self, refs: impl IntoIterator<Item = gix::refs::Reference>) -> Self {
+        self.overriding_references.extend(refs);
+        self
+    }
+
     /// Override the starting position of the traversal by setting it to `id`,
     /// and optionally, by providing the `ref_name` that points to `id`.
     pub fn with_entrypoint(
         mut self,
         id: gix::ObjectId,
         ref_name: Option<gix::refs::FullName>,
     ) -> Self {
+        if let Some(ref_name) = &ref_name {
+            self.overriding_references.push(gix::refs::Reference {
+                name: ref_name.to_owned(),
+                target: Target::Object(id),
+                peeled: Some(id),
+            })
+        }
         self.entrypoint = Some((id, ref_name));
         self
     }
@@ -58,14 +73,19 @@ impl Overlay {
         T: RefMetadata,
     {
         let Overlay {
-            nonoverriding_references,
+            mut nonoverriding_references,
+            mut overriding_references,
             meta_branches,
             workspace,
             entrypoint,
         } = self;
+        // Make sure that duplicates from later determine the value.
+        nonoverriding_references.reverse();
+        overriding_references.reverse();
         (
             OverlayRepo {
-                nonoverriding_references,
+                nonoverriding_references: nonoverriding_references.into_iter().collect(),
+                overriding_references: overriding_references.into_iter().collect(),
                 inner: repo,
             },
             OverlayMetadata {
@@ -80,7 +100,8 @@ impl Overlay {
 
 pub(crate) struct OverlayRepo<'repo> {
     inner: &'repo gix::Repository,
-    nonoverriding_references: Vec<gix::refs::Reference>,
+    nonoverriding_references: BTreeSet<gix::refs::Reference>,
+    overriding_references: BTreeSet<gix::refs::Reference>,
 }
 
 /// Note that functions with `'repo` in their return value technically leak the bare repo, and it's
@@ -94,7 +115,13 @@ impl<'repo> OverlayRepo<'repo> {
         &self,
         ref_name: &gix::refs::FullNameRef,
     ) -> anyhow::Result<Option<gix::Reference<'repo>>> {
-        if let Some(rn) = self.inner.try_find_reference(ref_name)? {
+        if let Some(r) = self
+            .overriding_references
+            .iter()
+            .find(|r| r.name.as_ref() == ref_name)
+        {
+            Ok(Some(r.clone().attach(self.inner)))
+        } else if let Some(rn) = self.inner.try_find_reference(ref_name)? {
             Ok(Some(rn))
         } else if let Some(r) = self
             .nonoverriding_references
@@ -111,6 +138,13 @@ impl<'repo> OverlayRepo<'repo> {
         &self,
         ref_name: &gix::refs::FullNameRef,
     ) -> anyhow::Result<gix::Reference<'repo>> {
+        if let Some(r) = self
+            .overriding_references
+            .iter()
+            .find(|r| r.name.as_ref() == ref_name)
+        {
+            return Ok(r.clone().attach(self.inner));
+        }
         Ok(self
             .inner
             .find_reference(ref_name)
@@ -202,6 +236,18 @@ impl<'repo> OverlayRepo<'repo> {
             };
         let mut all_refs_by_id = gix::hashtable::HashMap::<_, Vec<_>>::default();
         for prefix in prefixes {
+            // apply overrides - they are seen first and take the spot of everything.
+            for (commit_id, git_reference) in self
+                .overriding_references
+                .iter()
+                .filter(|rn| rn.name.as_bstr().starts_with(prefix.as_bytes()))
+                .filter_map(|rn| ref_filter(rn.clone().attach(self.inner)))
+            {
+                all_refs_by_id
+                    .entry(commit_id)
+                    .or_default()
+                    .push(git_reference);
+            }
             for (commit_id, git_reference) in self
                 .inner
                 .references()?
@@ -214,7 +260,7 @@ impl<'repo> OverlayRepo<'repo> {
                     .or_default()
                     .push(git_reference);
             }
-            // apply overrides
+            // apply overrides (new only)
             for (commit_id, git_reference) in self
                 .nonoverriding_references
                 .iter()

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

@@ -93,7 +93,6 @@ impl Graph {
         // Finally, once all segments were added, it's good to generations
         // have to figure out early abort conditions, or to know what's ahead of another.
         self.compute_generation_numbers();
-
         Ok(self)
     }
 

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

@@ -696,50 +696,6 @@ impl Graph {
                 .map(|(c, sidx)| (c.id, sidx))
         }
     }
-
-    /// Compute the loweset merge-base between two segments.
-    /// Such a merge-base is reachable from all possible paths from `a` and `b`.
-    ///
-    /// We know this works as all branching and merging is represented by a segment.
-    /// Thus, the merge-base is always the first commit of the returned segment
-    // TODO: should be multi, with extra segments as third parameter
-    // TODO: actually find the lowest merge-base, right now it just finds the first merge-base, but that's not
-    //       the lowest.
-    fn first_merge_base(&self, a: SegmentIndex, b: SegmentIndex) -> Option<SegmentIndex> {
-        // TODO(perf): improve this by allowing to set bitflags on the segments themselves, to allow
-        //       marking them accordingly, just like Git does.
-        //       Right now we 'emulate' bitflags on pre-allocated data with two data sets, expensive
-        //       in comparison.
-        //       And yes, let's avoid `gix::Repository::merge_base` as we have free
-        //       generation numbers here and can avoid work duplication.
-        let mut segments_reachable_by_b = BTreeSet::new();
-        self.visit_all_segments_including_start_until(b, Direction::Outgoing, |s| {
-            segments_reachable_by_b.insert(s.id);
-            // Collect everything, keep it simple.
-            // This is fast* as completely in memory.
-            // *means slow compared to an array traversal with memory locality.
-            false
-        });
-
-        let mut candidate = None;
-        self.visit_all_segments_including_start_until(a, Direction::Outgoing, |s| {
-            if candidate.is_some() {
-                return true;
-            }
-            let prune = segments_reachable_by_b.contains(&s.id);
-            if prune {
-                candidate = Some(s.id);
-            }
-            prune
-        });
-        if candidate.is_none() {
-            // TODO: improve this - workspaces shouldn't be like this but if they are, do we deal with it well?
-            tracing::warn!(
-                "Couldn't find merge-base between segments {a:?} and {b:?} - this might lead to unexpected results"
-            )
-        }
-        candidate
-    }
 }
 
 /// This works as named segments have been created in a prior step. Thus, we are able to find best matches by