Port cherry-rebasing from git2 to gitoxide

Also make use of the `gix` version of cherry-rebase everywhere
in `but-rebase`.

Author: Byron

Cargo.lock

@@ -8,16 +8,40 @@ pub fn project_from_path(path: &Path) -> anyhow::Result<Project> {
 
 pub fn project_repo(path: &Path) -> anyhow::Result<gix::Repository> {
     let project = project_from_path(path)?;
-    Ok(gix::open(project.worktree_path())?)
+    configured_repo(
+        gix::open(project.worktree_path())?,
+        RepositoryOpenMode::General,
+    )
+}
+
+pub enum RepositoryOpenMode {
+    Merge,
+    General,
+}
+
+fn configured_repo(
+    mut repo: gix::Repository,
+    mode: RepositoryOpenMode,
+) -> anyhow::Result<gix::Repository> {
+    match mode {
+        RepositoryOpenMode::Merge => {
+            let bytes = repo.compute_object_cache_size_for_tree_diffs(&***repo.index_or_empty()?);
+            repo.object_cache_size_if_unset(bytes);
+        }
+        RepositoryOpenMode::General => {
+            repo.object_cache_size_if_unset(512 * 1024);
+        }
+    }
+    Ok(repo)
 }
 
 /// Operate like GitButler would in the future, on a Git repository and optionally with additional metadata as obtained
 /// from the previously added project.
 pub fn repo_and_maybe_project(
     args: &super::Args,
+    mode: RepositoryOpenMode,
 ) -> anyhow::Result<(gix::Repository, Option<Project>)> {
-    let mut repo = gix::discover(&args.current_dir)?;
-    repo.object_cache_size_if_unset(512 * 1024);
+    let repo = configured_repo(gix::discover(&args.current_dir)?, mode)?;
     let res = if let Some((projects, work_dir)) =
         project_controller(args.app_suffix.as_deref(), args.app_data_dir.as_deref())
             .ok()

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

@@ -2,7 +2,7 @@
 use anyhow::Result;
 
 mod args;
-use crate::command::repo_and_maybe_project;
+use crate::command::{repo_and_maybe_project, RepositoryOpenMode};
 use args::Args;
 
 mod command;
@@ -21,7 +21,7 @@ fn main() -> Result<()> {
             amend,
             parent,
         } => {
-            let (repo, project) = repo_and_maybe_project(&args)?;
+            let (repo, project) = repo_and_maybe_project(&args, RepositoryOpenMode::Merge)?;
             command::commit(repo, project, message.as_deref(), *amend, parent.as_deref())
         }
         args::Subcommands::HunkDependency => command::diff::locks(&args.current_dir),

crates/but-cli/src/main.rs

@@ -59,12 +59,17 @@ impl From<HeadersV1> for HeadersV2 {
 
 const HEADERS_VERSION_FIELD: &str = "gitbutler-headers-version";
 const HEADERS_CHANGE_ID_FIELD: &str = "gitbutler-change-id";
-const HEADERS_CONFLICTED_FIELD: &str = "gitbutler-conflicted";
+/// The name of the header field that stores the amount of conflicted files.
+pub const HEADERS_CONFLICTED_FIELD: &str = "gitbutler-conflicted";
+const HEADERS_VERSION: &str = "2";
 
-impl From<HeadersV2> for Vec<(BString, BString)> {
-    fn from(hdr: HeadersV2) -> Self {
+impl From<&HeadersV2> for Vec<(BString, BString)> {
+    fn from(hdr: &HeadersV2) -> Self {
         let mut out = vec![
-            (BString::from(HEADERS_VERSION_FIELD), BString::from("2")),
+            (
+                BString::from(HEADERS_VERSION_FIELD),
+                BString::from(HEADERS_VERSION),
+            ),
             (HEADERS_CHANGE_ID_FIELD.into(), hdr.change_id.clone().into()),
         ];
 
@@ -91,6 +96,18 @@ pub enum TreeKind {
     AutoResolution,
 }
 
+impl TreeKind {
+    /// Return then name of the entry this tree would take in the 'meta' tree that captures cherry-pick conflicts.
+    pub fn as_tree_entry_name(&self) -> &'static str {
+        match self {
+            TreeKind::Ours => ".conflict-side-0",
+            TreeKind::Theirs => ".conflict-side-1",
+            TreeKind::Base => ".conflict-base-0",
+            TreeKind::AutoResolution => ".auto-resolution",
+        }
+    }
+}
+
 /// Instantiation
 impl<'repo> Commit<'repo> {
     /// Decode the object at `commit_id` and keep its data for later query.
@@ -103,11 +120,50 @@ impl<'repo> Commit<'repo> {
     }
 }
 
+impl Commit<'_> {
+    /// Set this commit to use the given `headers`, completely replacing the ones it might currently have.
+    pub fn set_headers(&mut self, header: &HeadersV2) {
+        for field in [
+            HEADERS_VERSION_FIELD,
+            HEADERS_CHANGE_ID_FIELD,
+            HEADERS_CONFLICTED_FIELD,
+        ] {
+            if let Some(pos) = self.extra_headers().find_pos(field) {
+                self.extra_headers.remove(pos);
+            }
+        }
+
+        self.extra_headers
+            .extend(Vec::<(BString, BString)>::from(header));
+    }
+}
+
+impl std::ops::Deref for Commit<'_> {
+    type Target = gix::objs::Commit;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl std::ops::DerefMut for Commit<'_> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+impl HeadersV2 {
+    /// Return `true` if this commit contains a tree that is conflicted.
+    pub fn is_conflicted(&self) -> bool {
+        self.conflicted.is_some()
+    }
+}
+
 /// Access
 impl<'repo> Commit<'repo> {
     /// Return `true` if this commit contains a tree that is conflicted.
     pub fn is_conflicted(&self) -> bool {
-        self.headers().is_some_and(|hdr| hdr.conflicted.is_some())
+        self.headers().is_some_and(|hdr| hdr.is_conflicted())
     }
 
     /// Return the hash of *our* tree, even if this commit is conflicted.
@@ -127,12 +183,7 @@ impl<'repo> Commit<'repo> {
                 .attach(self.id.repo)
                 .object()?
                 .into_tree()
-                .find_entry(match kind {
-                    TreeKind::Ours => ".conflict-side-0",
-                    TreeKind::Theirs => ".conflict-side-1",
-                    TreeKind::Base => ".conflict-base-0",
-                    TreeKind::AutoResolution => ".auto-resolution",
-                })
+                .find_entry(kind.as_tree_entry_name())
                 .with_context(|| format!("Unexpected tree in conflicting commit {}", self.id))?
                 .id();
             Some(our_tree)
@@ -156,7 +207,7 @@ impl<'repo> Commit<'repo> {
         if let Some(header) = decoded.extra_headers().find(HEADERS_VERSION_FIELD) {
             let version = header.to_owned();
 
-            if version == "2" {
+            if version == HEADERS_VERSION {
                 let change_id = decoded.extra_headers().find(HEADERS_CHANGE_ID_FIELD)?;
                 let change_id = change_id.to_str().ok()?.to_string();
 

crates/but-core/src/commit.rs

@@ -44,6 +44,7 @@
 use bstr::{BStr, BString};
 use gix::object::tree::EntryKind;
 use serde::Serialize;
+use std::path::Path;
 
 /// Functions to obtain changes between various items.
 pub mod diff;
@@ -104,6 +105,16 @@ pub enum Reference {
     Virtual(String),
 }
 
+/// Open a repository in such a way that the object cache is set to accelerate merge operations.
+///
+/// As it depends on the size of the tree, the index will be loaded for that.
+pub fn open_repo_for_merging(path: &Path) -> anyhow::Result<gix::Repository> {
+    let mut repo = gix::open(path)?;
+    let bytes = repo.compute_object_cache_size_for_tree_diffs(&***repo.index_or_empty()?);
+    repo.object_cache_size_if_unset(bytes);
+    Ok(repo)
+}
+
 /// An entry in the worktree that changed and thus is eligible to being committed.
 ///
 /// It either lives (or lived) in the in `.git/index`, or in the `worktree`.

crates/but-core/src/lib.rs

@@ -19,6 +19,8 @@ gitbutler-error.workspace = true
 bstr.workspace = true
 git2.workspace = true
 tempfile.workspace = true
+serde = { version = "1.0.217", features = ["derive"] }
+toml.workspace = true
 
 [dev-dependencies]
 but-testsupport.workspace = true