Merge pull request #9878 from Byron/next

V3 apply/unapply

Author: Byron

crates/but-api/src/commands/stack.rs

@@ -1,9 +1,7 @@
-use crate::commands::stack::create_reference::Anchor;
 use crate::error::Error;
 use anyhow::{Context, anyhow};
 use but_api_macros::api_cmd;
 use but_settings::AppSettings;
-use but_workspace::branch::{ReferenceAnchor, ReferencePosition};
 use gitbutler_branch_actions::internal::PushResult;
 use gitbutler_branch_actions::stack::CreateSeriesRequest;
 use gitbutler_command_context::CommandContext;
@@ -33,11 +31,11 @@ pub mod create_reference {
     pub enum Anchor {
         AtCommit {
             commit_id: HexHash,
-            position: but_workspace::branch::ReferencePosition,
+            position: but_workspace::branch::create_reference::Position,
         },
         AtReference {
             short_name: String,
-            position: but_workspace::branch::ReferencePosition,
+            position: but_workspace::branch::create_reference::Position,
         },
     }
 }
@@ -58,17 +56,17 @@ pub fn create_reference(
     let anchor = anchor
         .map(|anchor| -> Result<_, Error> {
             Ok(match anchor {
-                Anchor::AtCommit {
+                create_reference::Anchor::AtCommit {
                     commit_id,
                     position,
-                } => but_workspace::branch::ReferenceAnchor::AtCommit {
+                } => but_workspace::branch::create_reference::Anchor::AtCommit {
                     commit_id: commit_id.into(),
                     position,
                 },
-                Anchor::AtReference {
+                create_reference::Anchor::AtReference {
                     short_name,
                     position,
-                } => but_workspace::branch::ReferenceAnchor::AtSegment {
+                } => but_workspace::branch::create_reference::Anchor::AtSegment {
                     ref_name: Cow::Owned(
                         Category::LocalBranch
                             .to_full_name(short_name.as_str())
@@ -103,7 +101,7 @@ pub fn create_branch(
     let project = gitbutler_project::get(project_id)?;
     let ctx = CommandContext::open(&project, AppSettings::load_from_default_path_creating()?)?;
     if ctx.app_settings().feature_flags.ws3 {
-        use ReferencePosition::Above;
+        use but_workspace::branch::create_reference::Position::Above;
         let mut guard = project.exclusive_worktree_access();
         let (repo, mut meta, graph) = ctx.graph_and_meta_mut_and_repo(guard.write_permission())?;
         let ws = graph.to_workspace()?;
@@ -120,19 +118,20 @@ pub fn create_branch(
 
         ctx.snapshot_create_dependent_branch(&request.name, guard.write_permission())
             .ok();
-        _ = but_workspace::branch::create_reference(
-            new_ref.as_ref(),
-            {
-                let segment = stack.segments.first().context("BUG: no empty stacks")?;
-                segment
+        _ =
+            but_workspace::branch::create_reference(
+                new_ref.as_ref(),
+                {
+                    let segment = stack.segments.first().context("BUG: no empty stacks")?;
+                    segment
                     .ref_name
                     .as_ref()
-                    .map(|rn| ReferenceAnchor::AtSegment {
+                    .map(|rn| but_workspace::branch::create_reference::Anchor::AtSegment {
                         ref_name: Cow::Borrowed(rn.as_ref()),
                         position: Above,
                     })
                     .or_else(|| {
-                        Some(ReferenceAnchor::AtCommit {
+                        Some(but_workspace::branch::create_reference::Anchor::AtCommit {
                             commit_id: graph.tip_skip_empty(segment.id)?.id,
                             position: Above,
                         })
@@ -143,11 +142,11 @@ pub fn create_branch(
                             couldn't handle stack_id={stack_id:?}, request={request:?}"
                         )
                     })?
-            },
-            &repo,
-            &ws,
-            &mut *meta,
-        )?;
+                },
+                &repo,
+                &ws,
+                &mut *meta,
+            )?;
     } else {
         // NOTE: locking is built-in here.
         gitbutler_branch_actions::stack::create_branch(&ctx, stack_id, request)?;

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/fixtures/scenarios.sh

@@ -298,6 +298,14 @@ mkdir ws
      create_workspace_commit_once main
   )
 
+  git init just-init-with-two-branches
+  (cd just-init-with-two-branches
+    commit init
+    git branch A
+    git branch B
+    git checkout -b gitbutler/workspace
+  )
+
   git init just-init-with-branches
   (cd just-init-with-branches
     commit init && setup_target_to_match_main

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

@@ -681,6 +681,58 @@ fn minimal_merge() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+fn stack_configuration_is_respected_if_one_of_them_is_an_entrypoint() -> anyhow::Result<()> {
+    let (repo, mut meta) = read_only_in_memory_scenario("ws/just-init-with-two-branches")?;
+    insta::assert_snapshot!(visualize_commit_graph_all(&repo)?, @"* fafd9d0 (HEAD -> gitbutler/workspace, main, B, A) init");
+
+    add_stack_with_segments(&mut meta, 1, "A", StackState::InWorkspace, &[]);
+    add_stack_with_segments(&mut meta, 2, "B", StackState::InWorkspace, &[]);
+
+    let graph = Graph::from_head(
+        &repo,
+        &*meta,
+        standard_options_with_extra_target(&repo, "main"),
+    )?
+    .validated()?;
+    insta::assert_snapshot!(graph_tree(&graph), @r"
+    └── 👉📕►►►:0[0]:gitbutler/workspace
+        ├── 📙►:2[1]:A
+        │   └── ►:1[2]:anon:
+        │       └── ·fafd9d0 (⌂|🏘|1) ►main
+        └── 📙►:3[1]:B
+            └── →:1:
+    ");
+    insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
+    📕🏘️⚠️:0:gitbutler/workspace <> ✓! on fafd9d0
+    ├── ≡📙:3:B on fafd9d0
+    │   └── 📙:3:B
+    └── ≡📙:2:A on fafd9d0
+        └── 📙:2:A
+    ");
+
+    let (id, ref_name) = id_at(&repo, "B");
+    let graph = Graph::from_commit_traversal(id, ref_name.clone(), &*meta, standard_options())?
+        .validated()?;
+    // TODO: it shouldn't create a dependent branch here, but instead see A as a stack.
+    //       problem is that for stack creation, there is no candidate.
+    insta::assert_snapshot!(graph_tree(&graph), @r"
+    └── 📕►►►:1[0]:gitbutler/workspace
+        └── 👉📙►:0[1]:B
+            └── 📙►:2[2]:A
+                └── ·fafd9d0 (⌂|🏘|1) ►main
+    ");
+    insta::assert_snapshot!(graph_workspace(&graph.to_workspace()?), @r"
+    📕🏘️⚠️:1:gitbutler/workspace <> ✓!
+    └── ≡👉📙:0:B
+        ├── 👉📙:0:B
+        └── 📙:2:A
+            └── ·fafd9d0 (🏘️) ►main
+    ");
+
+    Ok(())
+}
+
 #[test]
 fn just_init_with_branches() -> anyhow::Result<()> {
     let (repo, mut meta) = read_only_in_memory_scenario("ws/just-init-with-branches")?;

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

@@ -3,7 +3,7 @@ use but_core::UnifiedDiff;
 use but_db::poll::ItemKind;
 use but_graph::VirtualBranchesTomlMetadata;
 use but_settings::AppSettings;
-use but_workspace::branch::{ReferenceAnchor, ReferencePosition};
+use but_workspace::branch::create_reference::{Anchor, Position};
 use but_workspace::{DiffSpec, HunkHeader};
 use gitbutler_project::{Project, ProjectId};
 use gix::bstr::{BString, ByteSlice};
@@ -601,22 +601,21 @@ pub fn create_reference(
 ) -> anyhow::Result<()> {
     let (repo, project, graph, mut meta) =
         repo_and_maybe_project_and_graph(args, RepositoryOpenMode::General)?;
-    let resolve =
-        |spec: &str, position: ReferencePosition| -> anyhow::Result<ReferenceAnchor<'_>> {
-            Ok(match repo.try_find_reference(spec)? {
-                None => ReferenceAnchor::AtCommit {
-                    commit_id: repo.rev_parse_single(spec)?.detach(),
-                    position,
-                },
-                Some(rn) => ReferenceAnchor::AtSegment {
-                    ref_name: Cow::Owned(rn.inner.name),
-                    position,
-                },
-            })
-        };
+    let resolve = |spec: &str, position: Position| -> anyhow::Result<Anchor<'_>> {
+        Ok(match repo.try_find_reference(spec)? {
+            None => Anchor::AtCommit {
+                commit_id: repo.rev_parse_single(spec)?.detach(),
+                position,
+            },
+            Some(rn) => Anchor::AtSegment {
+                ref_name: Cow::Owned(rn.inner.name),
+                position,
+            },
+        })
+    };
     let anchor = above
-        .map(|spec| resolve(spec, ReferencePosition::Above))
-        .or_else(|| below.map(|spec| resolve(spec, ReferencePosition::Below)))
+        .map(|spec| resolve(spec, Position::Above))
+        .or_else(|| below.map(|spec| resolve(spec, Position::Below)))
         .transpose()?;
 
     let new_ref = Category::LocalBranch.to_full_name(short_name)?;