Merge pull request #10233 from Byron/next

V3 apply/unapply: workspace checkout

Author: Byron

Cargo.lock

@@ -39,7 +39,6 @@ gitbutler-git = { path = "crates/gitbutler-git" }
 gitbutler-watcher = { path = "crates/gitbutler-watcher" }
 gitbutler-filemonitor = { path = "crates/gitbutler-filemonitor" }
 gitbutler-testsupport = { path = "crates/gitbutler-testsupport" }
-gitbutler-cli = { path = "crates/gitbutler-cli" }
 gitbutler-branch-actions = { path = "crates/gitbutler-branch-actions" }
 gitbutler-sync = { path = "crates/gitbutler-sync" }
 gitbutler-oplog = { path = "crates/gitbutler-oplog" }
@@ -71,7 +70,6 @@ gitbutler-hunk-dependency = { path = "crates/gitbutler-hunk-dependency" }
 but-settings = { path = "crates/but-settings" }
 gitbutler-workspace = { path = "crates/gitbutler-workspace" }
 but = { path = "crates/but" }
-but-server = { path = "crates/but-server" }
 but-testsupport = { path = "crates/but-testsupport" }
 but-rebase = { path = "crates/but-rebase" }
 but-core = { path = "crates/but-core" }
@@ -112,3 +110,18 @@ incremental = false
 
 [profile.test]
 incremental = false
+
+# Assure that `gix` is always fast so debug builds aren't unnecessarily slow.
+[profile.dev.package]
+gix-object = { opt-level = 3 }
+gix-ref = { opt-level = 3 }
+gix-pack = { opt-level = 3 }
+gix-hash = { opt-level = 3 }
+gix-actor = { opt-level = 3 }
+gix-config = { opt-level = 3 }
+sha1-checked = { opt-level = 3 }
+zlib-rs = { opt-level = 3 }
+# This one is special as we can run into debug assertions otherwise.
+# They have a time, but let's chose the time instead of always being hit by it.
+gix-merge = { opt-level = 3, debug-assertions = false }
+

Cargo.toml

@@ -158,7 +158,7 @@ impl Graph {
             }
             gix::head::Kind::Symbolic(existing_reference) => {
                 let mut existing_reference = existing_reference.attach(repo);
-                let tip = existing_reference.peel_to_id_in_place()?;
+                let tip = existing_reference.peel_to_id()?;
                 (tip, Some(existing_reference.inner.name))
             }
         };
@@ -487,7 +487,7 @@ impl Graph {
             {
                 let Some(segment_tip) = repo
                     .try_find_reference(segment.ref_name.as_ref())?
-                    .map(|mut r| r.peel_to_id_in_place())
+                    .map(|mut r| r.peel_to_id())
                     .transpose()?
                 else {
                     continue;

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

@@ -667,7 +667,7 @@ pub fn try_refname_to_id(
 ) -> anyhow::Result<Option<gix::ObjectId>> {
     Ok(repo
         .try_find_reference(refname)?
-        .map(|mut r| r.peel_to_id_in_place())
+        .map(|mut r| r.peel_to_id())
         .transpose()?
         .map(|id| id.detach()))
 }

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

@@ -8,6 +8,7 @@ use crate::projection::workspace;
 use crate::{
     CommitFlags, CommitIndex, Graph, Segment, SegmentIndex,
     projection::{Stack, StackCommit, StackCommitFlags, StackSegment},
+    segment,
 };
 use anyhow::Context;
 use bstr::{BStr, ByteSlice};
@@ -68,6 +69,17 @@ impl Workspace<'_> {
             .iter()
             .all(|s| s.segments.iter().all(|s| !s.is_entrypoint))
     }
+
+    /// 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
+    /// inside the workspace as well.
+    ///
+    /// Note that this commit could also be the base of the workspace, particularly if there is no commits in the workspace.
+    pub fn tip_commit(&self) -> Option<&segment::Commit> {
+        self.graph.tip_skip_empty(self.id)
+    }
+
     /// 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]
@@ -161,23 +173,28 @@ impl Workspace<'_> {
         self.find_segment_and_stack_by_refname(name).is_some()
     }
 
-    /// Return `true` if the entrypoint.
+    /// Return `true` if `name` is in the ancestry of the workspace entrypoint, and is IN the workspace as well.
     pub fn is_reachable_from_entrypoint(&self, name: &gix::refs::FullNameRef) -> bool {
+        if self.ref_name().filter(|_| self.is_entrypoint()) == Some(name) {
+            return true;
+        }
         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 {
+            let Some((entrypoint_stack, entrypoint_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
+            entrypoint_stack
                 .segments
-                .get(segment_idx..)
+                .get(entrypoint_segment_idx..)
                 .into_iter()
                 .any(|segments| {
                     segments

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

@@ -78,7 +78,7 @@ impl Snapshot {
                         let Ok(mut r) = repo.find_reference(&segment.name) else {
                             continue;
                         };
-                        if let Ok(id) = r.peel_to_id_in_place() {
+                        if let Ok(id) = r.peel_to_id() {
                             segment.head = CommitOrChangeId::CommitId(id.to_string());
                         }
                     }

crates/but-graph/src/ref_metadata_legacy.rs

@@ -1,7 +1,7 @@
 //! An API for an interactive rebases, suitable for interactive, UI driven, and programmatic use.
 //!
 //! It will only affect the commit-graph, and never the alter the worktree in any way.
-#![deny(rust_2018_idioms, missing_docs)]
+#![deny(missing_docs)]
 
 use crate::commit::DateMode;
 use anyhow::{Context, Ok, Result, anyhow, bail};

crates/but-rebase/src/lib.rs

@@ -510,7 +510,7 @@ pub fn graph(
         None => but_graph::Graph::from_head(&repo, &*meta, opts),
         Some(ref_name) => {
             let mut reference = repo.find_reference(ref_name)?;
-            let id = reference.peel_to_id_in_place()?;
+            let id = reference.peel_to_id()?;
             but_graph::Graph::from_commit_traversal(id, reference.name().to_owned(), &*meta, opts)
         }
     }?;

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

@@ -1,5 +1,5 @@
 //! Utilities for testing.
-#![deny(rust_2018_idioms, missing_docs)]
+#![deny(missing_docs)]
 
 use gix::Repository;
 use gix::bstr::{BStr, ByteSlice};
@@ -252,7 +252,7 @@ pub fn id_at<'repo>(repo: &'repo Repository, name: &str) -> (gix::Id<'repo>, gix
     let mut rn = repo
         .find_reference(name)
         .expect("statically known reference exists");
-    let id = rn.peel_to_id_in_place().expect("must be valid reference");
+    let id = rn.peel_to_id().expect("must be valid reference");
     (id, rn.inner.name)
 }
 

crates/but-testsupport/src/lib.rs

@@ -35,7 +35,6 @@ flume = "0.11.1"
 
 [dev-dependencies]
 but-testsupport.workspace = true
-pretty_assertions = "1.4.1"
 insta = "1.43.1"
 but-core = { workspace = true, features = ["testing"] }
 # for stable hashes in `gitbuter-` crates while we use them.