Basic apply and unapply (heavily WIP)

The idea is to develop both at the same time so it's easier to test
that 'unapply' truly goes back to the (mostly) original state.

Author: Byron

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

@@ -21,10 +21,13 @@ mod remotes;
 mod overlay;
 mod post;
 
+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)]
 pub struct Overlay {
+    entrypoint: Entrypoint,
     nonoverriding_references: Vec<gix::refs::Reference>,
     meta_branches: Vec<(gix::refs::FullName, ref_metadata::Branch)>,
     workspace: Option<(gix::refs::FullName, ref_metadata::Workspace)>,
@@ -141,7 +144,7 @@ impl Graph {
                 let mut graph = Graph::default();
                 // It's OK to default-initialise this here as overlays are only used when redoing
                 // the traversal.
-                let (_repo, meta) = Overlay::default().into_parts(repo, meta);
+                let (_repo, meta, _entrypoint) = Overlay::default().into_parts(repo, meta);
                 graph.insert_root(branch_segment_from_name_and_meta(
                     Some((ref_name, None)),
                     &meta,
@@ -228,7 +231,7 @@ impl Graph {
         meta: &impl RefMetadata,
         options: Options,
     ) -> anyhow::Result<Self> {
-        let (repo, meta) = Overlay::default().into_parts(tip.repo, meta);
+        let (repo, meta, _entrypoint) = Overlay::default().into_parts(tip.repo, meta);
         Graph::from_commit_traversal_inner(tip.detach(), &repo, ref_name, &meta, options)
     }
 
@@ -654,16 +657,22 @@ impl Graph {
         meta: &impl RefMetadata,
         overlay: Overlay,
     ) -> anyhow::Result<Self> {
-        let (repo, meta) = overlay.into_parts(repo, meta);
-        let tip_sidx = self
-            .entrypoint
-            .context("BUG: entrypoint must always be set")?
-            .0;
-        let tip = self
-            .tip_skip_empty(tip_sidx)
-            .context("BUG: entrypoint must eventually point to a commit")?
-            .id;
-        let ref_name = self[tip_sidx].ref_name.clone();
+        let (repo, meta, entrypoint) = overlay.into_parts(repo, meta);
+        let (tip, ref_name) = match entrypoint {
+            Some(t) => t,
+            None => {
+                let tip_sidx = self
+                    .entrypoint
+                    .context("BUG: entrypoint must always be set")?
+                    .0;
+                let tip = self
+                    .tip_skip_empty(tip_sidx)
+                    .context("BUG: entrypoint must eventually point to a commit")?
+                    .id;
+                let ref_name = self[tip_sidx].ref_name.clone();
+                (tip, ref_name)
+            }
+        };
         Graph::from_commit_traversal_inner(tip, &repo, ref_name, &meta, self.options.clone())
     }
 

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

@@ -1,5 +1,5 @@
-use crate::init::Overlay;
 use crate::init::walk::RefsById;
+use crate::init::{Entrypoint, Overlay};
 use crate::is_workspace_ref_name;
 use but_core::{RefMetadata, ref_metadata};
 use gix::prelude::ReferenceExt;
@@ -17,6 +17,17 @@ impl Overlay {
         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 {
+        self.entrypoint = Some((id, ref_name));
+        self
+    }
+
     /// 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_override(
@@ -43,14 +54,15 @@ impl Overlay {
         self,
         repo: &'repo gix::Repository,
         meta: &'meta T,
-    ) -> (OverlayRepo<'repo>, OverlayMetadata<'meta, T>)
+    ) -> (OverlayRepo<'repo>, OverlayMetadata<'meta, T>, Entrypoint)
     where
         T: RefMetadata,
     {
         let Overlay {
             nonoverriding_references,
             meta_branches,
             workspace,
+            entrypoint,
         } = self;
         (
             OverlayRepo {
@@ -62,6 +74,7 @@ impl Overlay {
                 meta_branches,
                 workspace,
             },
+            entrypoint,
         )
     }
 }

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

@@ -61,6 +61,13 @@ pub type CommitOwnerIndexes = (usize, usize, CommitIndex);
 
 /// Utilities
 impl Workspace<'_> {
+    /// Return `true` if the workspace itself is where `HEAD` is pointing to.
+    /// If `false`, one of the stack-segments is checked out instead.
+    pub fn is_entrypoint(&self) -> bool {
+        self.stacks
+            .iter()
+            .all(|s| s.segments.iter().all(|s| !s.is_entrypoint))
+    }
     /// Lookup a triple obtained by [`Self::find_owner_indexes_by_commit_id()`] or panic.
     pub fn lookup_commit(&self, (stack_idx, seg_idx, cidx): CommitOwnerIndexes) -> &StackCommit {
         &self.stacks[stack_idx].segments[seg_idx].commits[cidx]
@@ -149,6 +156,37 @@ impl Workspace<'_> {
             })
     }
 
+    /// Return `true` if `name` is contained in the workspace as segment.
+    pub fn refname_is_segment(&self, name: &gix::refs::FullNameRef) -> bool {
+        self.find_segment_and_stack_by_refname(name).is_some()
+    }
+
+    /// Return `true` if the entrypoint.
+    pub fn is_reachable_from_entrypoint(&self, name: &gix::refs::FullNameRef) -> bool {
+        if self.is_entrypoint() {
+            self.refname_is_segment(name)
+        } else {
+            let Some((stack, segment_idx)) = self.stacks.iter().find_map(|stack| {
+                stack
+                    .segments
+                    .iter()
+                    .enumerate()
+                    .find_map(|(idx, segment)| segment.is_entrypoint.then_some((stack, idx)))
+            }) else {
+                return false;
+            };
+            stack
+                .segments
+                .get(segment_idx..)
+                .into_iter()
+                .any(|segments| {
+                    segments
+                        .iter()
+                        .any(|s| s.ref_name.as_ref().is_some_and(|rn| rn.as_ref() == name))
+                })
+        }
+    }
+
     /// Try to find `name` in any named [`StackSegment`] and return it along with the stack containing it.
     pub fn find_segment_and_stack_by_refname(
         &self,
@@ -189,9 +227,9 @@ pub enum WorkspaceKind {
         /// The name of the reference pointing to the workspace commit. Useful for deriving the workspace name.
         ref_name: gix::refs::FullName,
     },
-    /// Information for when a workspace reference was advanced by hand and does not point to a
-    /// managed workspace commit anymore.
-    /// That commit, however, is reachable by following the first parent from the workspace reference.
+    /// Information for when a workspace reference was *possibly* advanced by hand and does not point to a
+    /// managed workspace commit (anymore).
+    /// That workspace commit, may be reachable by following the first parent from the workspace reference.
     ///
     /// Note that the stacks that follow *will* be in unusable if the workspace commit is in a segment below,
     /// but typically is usable if there is just a single real stack, or any amount of virtual stacks below

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

@@ -699,7 +699,7 @@ fn stack_configuration_is_respected_if_one_of_them_is_an_entrypoint() -> anyhow:
     └── 👉📕►►►:0[0]:gitbutler/workspace
         ├── 📙►:2[1]:A
         │   └── ►:1[2]:anon:
-        │       └── ·fafd9d0 (⌂|🏘️|1) ►main
+        │       └── ·fafd9d0 (⌂|🏘|1) ►main
         └── 📙►:3[1]:B
             └── →:1:
     ");
@@ -720,7 +720,7 @@ fn stack_configuration_is_respected_if_one_of_them_is_an_entrypoint() -> anyhow:
     └── 📕►►►:1[0]:gitbutler/workspace
         └── 👉📙►:0[1]:B
             └── 📙►:2[2]:A
-                └── ·fafd9d0 (⌂|🏘️|1) ►main
+                └── ·fafd9d0 (⌂|🏘|1) ►main
     ");
     insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
     📕🏘️⚠️:1:gitbutler/workspace <> ✓!