Replace merge-trees in oplog to use gitoxide.

Author: Byron

Cargo.lock

@@ -1,5 +1,6 @@
 use anyhow::Result;
 use gitbutler_project::Project;
+use std::path::Path;
 
 pub struct CommandContext {
     /// The git repository of the `project` itself.
@@ -90,10 +91,7 @@ impl CommandContext {
     /// to correctly figure out author and committer names (i.e. with most global configuration loaded),
     /// *and* which will perform diffs quickly thanks to an adequate object cache.
     pub fn gix_repository_for_merging(&self) -> Result<gix::Repository> {
-        let mut repo = gix::open(self.repository().path())?;
-        let bytes = repo.compute_object_cache_size_for_tree_diffs(&***repo.index_or_empty()?);
-        repo.object_cache_size_if_unset(bytes);
-        Ok(repo)
+        gix_repository_for_merging(self.repository().path())
     }
 
     /// Return a newly opened `gitoxide` repository, with all configuration available
@@ -119,5 +117,15 @@ impl CommandContext {
     }
 }
 
+/// Return a newly opened `gitoxide` repository, with all configuration available
+/// to correctly figure out author and committer names (i.e. with most global configuration loaded),
+/// *and* which will perform diffs quickly thanks to an adequate object cache.
+pub fn gix_repository_for_merging(worktree_or_git_dir: &Path) -> Result<gix::Repository> {
+    let mut repo = gix::open(worktree_or_git_dir)?;
+    let bytes = repo.compute_object_cache_size_for_tree_diffs(&***repo.index_or_empty()?);
+    repo.object_cache_size_if_unset(bytes);
+    Ok(repo)
+}
+
 mod repository_ext;
 pub use repository_ext::RepositoryExtLite;

crates/gitbutler-command-context/src/lib.rs

@@ -17,6 +17,7 @@ gix = { workspace = true, features = ["dirwalk", "credentials", "parallel"] }
 toml.workspace = true
 gitbutler-command-context.workspace = true
 gitbutler-project.workspace = true
+gitbutler-oxidize.workspace = true
 gitbutler-branch.workspace = true
 gitbutler-serde.workspace = true
 gitbutler-fs.workspace = true

crates/gitbutler-oplog/Cargo.toml

@@ -6,25 +6,26 @@ use std::{
     time::Duration,
 };
 
+use super::{
+    entry::{OperationKind, Snapshot, SnapshotDetails, Trailer},
+    reflog::set_reference_to_oplog,
+    state::OplogHandle,
+};
 use anyhow::{anyhow, bail, Context, Result};
 use git2::{DiffOptions, FileMode};
 use gitbutler_command_context::RepositoryExtLite;
 use gitbutler_diff::{hunks_by_filepath, FileDiff};
+use gitbutler_oxidize::{git2_to_gix_object_id, gix_to_git2_oid};
 use gitbutler_project::{
     access::{WorktreeReadPermission, WorktreeWritePermission},
     Project,
 };
-use gitbutler_repo::RepositoryExt;
 use gitbutler_repo::SignaturePurpose;
+use gitbutler_repo::{GixRepositoryExt, RepositoryExt};
 use gitbutler_stack::{Stack, VirtualBranchesHandle, VirtualBranchesState};
+use gix::prelude::Write;
 use tracing::instrument;
 
-use super::{
-    entry::{OperationKind, Snapshot, SnapshotDetails, Trailer},
-    reflog::set_reference_to_oplog,
-    state::OplogHandle,
-};
-
 const SNAPSHOT_FILE_LIMIT_BYTES: u64 = 32 * 1024 * 1024;
 
 /// The Oplog allows for crating snapshots of the current state of the project as well as restoring to a previous snapshot.
@@ -165,8 +166,9 @@ impl OplogExt for Project {
         limit: usize,
         oplog_commit_id: Option<git2::Oid>,
     ) -> Result<Vec<Snapshot>> {
-        let repo_path = self.path.as_path();
-        let repo = git2::Repository::open(repo_path)?;
+        let worktree_dir = self.path.as_path();
+        let repo = git2::Repository::open(worktree_dir)?;
+        let gix_repo = gitbutler_command_context::gix_repository_for_merging(worktree_dir)?;
 
         let traversal_root_id = match oplog_commit_id {
             Some(id) => id,
@@ -208,15 +210,16 @@ impl OplogExt for Project {
             }
 
             // Get tree id from cache or calculate it
-            let wd_tree = get_workdir_tree(&mut wd_trees_cache, commit_id, &repo)?;
+            let wd_tree = get_workdir_tree(&mut wd_trees_cache, commit_id, &repo, &gix_repo)?;
 
             let details = commit
                 .message()
                 .and_then(|msg| SnapshotDetails::from_str(msg).ok());
 
             if let Ok(parent) = commit.parent(0) {
                 // Get tree id from cache or calculate it
-                let parent_tree = get_workdir_tree(&mut wd_trees_cache, parent.id(), &repo)?;
+                let parent_tree =
+                    get_workdir_tree(&mut wd_trees_cache, parent.id(), &repo, &gix_repo)?;
 
                 let mut opts = DiffOptions::new();
                 opts.include_untracked(true);
@@ -279,13 +282,14 @@ impl OplogExt for Project {
 
     fn snapshot_diff(&self, sha: git2::Oid) -> Result<HashMap<PathBuf, FileDiff>> {
         let worktree_dir = self.path.as_path();
+        let gix_repo = gitbutler_command_context::gix_repository_for_merging(worktree_dir)?;
         let repo = git2::Repository::init(worktree_dir)?;
 
         let commit = repo.find_commit(sha)?;
 
-        let wd_tree_id = tree_from_applied_vbranches(&repo, commit.id())?;
+        let wd_tree_id = tree_from_applied_vbranches(&gix_repo, commit.id())?;
         let wd_tree = repo.find_tree(wd_tree_id)?;
-        let old_wd_tree_id = tree_from_applied_vbranches(&repo, commit.parent(0)?.id())?;
+        let old_wd_tree_id = tree_from_applied_vbranches(&gix_repo, commit.parent(0)?.id())?;
         let old_wd_tree = repo.find_tree(old_wd_tree_id)?;
 
         repo.ignore_large_files_in_diffs(SNAPSHOT_FILE_LIMIT_BYTES)?;
@@ -317,9 +321,10 @@ fn get_workdir_tree<'a>(
     wd_trees_cache: &mut HashMap<git2::Oid, git2::Oid>,
     commit_id: git2::Oid,
     repo: &'a git2::Repository,
+    gix_repo: &gix::Repository,
 ) -> Result<git2::Tree<'a>, anyhow::Error> {
     if let Entry::Vacant(e) = wd_trees_cache.entry(commit_id) {
-        if let Ok(wd_tree_id) = tree_from_applied_vbranches(repo, commit_id) {
+        if let Ok(wd_tree_id) = tree_from_applied_vbranches(gix_repo, commit_id) {
             e.insert(wd_tree_id);
         }
     }
@@ -574,7 +579,8 @@ fn restore_snapshot(
         "We will not change a worktree which for some reason isn't on the workspace branch",
     )?;
 
-    let workdir_tree_id = tree_from_applied_vbranches(&repo, snapshot_commit_id)?;
+    let gix_repo = gitbutler_command_context::gix_repository_for_merging(worktree_dir)?;
+    let workdir_tree_id = tree_from_applied_vbranches(&gix_repo, snapshot_commit_id)?;
     let workdir_tree = repo.find_tree(workdir_tree_id)?;
 
     repo.ignore_large_files_in_diffs(SNAPSHOT_FILE_LIMIT_BYTES)?;
@@ -794,59 +800,57 @@ fn deserialize_commit(
 }
 
 /// Creates a tree that is the merge of all applied branches from a given snapshot and returns the tree id.
+/// Note that `repo` must have caching setup for merges.
 fn tree_from_applied_vbranches(
-    repo: &git2::Repository,
+    repo: &gix::Repository,
     snapshot_commit_id: git2::Oid,
 ) -> Result<git2::Oid> {
-    let snapshot_commit = repo.find_commit(snapshot_commit_id)?;
+    let snapshot_commit = repo.find_commit(git2_to_gix_object_id(snapshot_commit_id))?;
     let snapshot_tree = snapshot_commit.tree()?;
 
     let target_tree_entry = snapshot_tree
-        .get_name("target_tree")
-        .context("failed to get target tree entry")?;
-    let target_tree = repo
-        .find_tree(target_tree_entry.id())
-        .context("failed to convert target tree entry to tree")?;
+        .lookup_entry_by_path("target_tree")?
+        .context("no entry at 'target_entry'")?;
+    let target_tree_id = target_tree_entry.id().detach();
 
     let vb_toml_entry = snapshot_tree
-        .get_name("virtual_branches.toml")
+        .lookup_entry_by_path("virtual_branches.toml")?
         .context("failed to get virtual_branches.toml blob")?;
-    // virtual_branches.toml blob
     let vb_toml_blob = repo
         .find_blob(vb_toml_entry.id())
         .context("failed to convert virtual_branches tree entry to blob")?;
 
-    let vbs_from_toml: VirtualBranchesState = toml::from_str(from_utf8(vb_toml_blob.content())?)?;
-    let applied_branch_trees: Vec<git2::Oid> = vbs_from_toml
+    let vbs_from_toml: VirtualBranchesState = toml::from_str(from_utf8(&vb_toml_blob.data)?)?;
+    let applied_branch_trees: Vec<_> = vbs_from_toml
         .list_branches_in_workspace()?
         .iter()
-        .map(|b| b.tree)
+        .map(|b| git2_to_gix_object_id(b.tree))
         .collect();
 
-    let mut workdir_tree_id = target_tree.id();
-    let base_tree = target_tree;
-    let mut current_ours = base_tree.clone();
-
-    for branch in applied_branch_trees {
-        let branch_tree = repo.find_tree(branch)?;
-        let mut merge_options: git2::MergeOptions = git2::MergeOptions::new();
-        merge_options.fail_on_conflict(false);
-        let mut workdir_temp_index = repo.merge_trees(
-            &base_tree,
-            &current_ours,
-            &branch_tree,
-            Some(&merge_options),
+    let mut workdir_tree_id = target_tree_id;
+    let base_tree_id = target_tree_id;
+    let mut current_ours_id = target_tree_id;
+
+    let (merge_option_fail_fast, conflict_kind) = repo.merge_options_fail_fast()?;
+    for branch_id in applied_branch_trees {
+        let mut merge = repo.merge_trees(
+            base_tree_id,
+            current_ours_id,
+            branch_id,
+            repo.default_merge_labels(),
+            merge_option_fail_fast.clone(),
         )?;
-        match workdir_temp_index.write_tree_to(repo) {
-            Ok(id) => {
-                workdir_tree_id = id;
-                current_ours = repo.find_tree(workdir_tree_id)?;
-            }
-            Err(_err) => {
-                tracing::warn!("Failed to merge tree {branch} - this branch is probably applied at a time when it should not be");
-            }
+        if merge.has_unresolved_conflicts(conflict_kind) {
+            tracing::warn!("Failed to merge tree {branch_id} - this branch is probably applied at a time when it should not be");
+        } else {
+            let id = merge
+                .tree
+                .write(|tree| repo.write(tree))
+                .map_err(|err| anyhow!("{err}"))?;
+            workdir_tree_id = id;
+            current_ours_id = id;
         }
     }
 
-    Ok(workdir_tree_id)
+    Ok(gix_to_git2_oid(workdir_tree_id))
 }