testsupport: drop test-only git2 repo extension methods

Co-authored-by: Sebastian Thiel <sebastian.thiel@icloud.com>

Author: codex

crates/but-testsupport/src/legacy/mod.rs

@@ -1,8 +1,10 @@
+use but_core::commit::Headers;
 use but_ctx::Context;
-use but_oxidize::OidExt;
+use but_oxidize::{ObjectIdExt as _, OidExt, git2_signature_to_gix_signature};
 use but_workspace::{legacy::StacksFilter, ui::StackDetails};
+use gitbutler_reference::Refname;
 use gitbutler_stack::StackId;
-use gix::prelude::ObjectIdExt;
+use gix::prelude::ObjectIdExt as _;
 
 pub const VAR_NO_CLEANUP: &str = "GITBUTLER_TESTS_NO_CLEANUP";
 
@@ -72,6 +74,52 @@ pub fn init_opts_bare() -> git2::RepositoryInitOptions {
     opts
 }
 
+#[expect(clippy::too_many_arguments)]
+pub(crate) fn commit_with_signature(
+    repo: &git2::Repository,
+    update_ref: Option<&Refname>,
+    author: &git2::Signature<'_>,
+    committer: &git2::Signature<'_>,
+    message: &str,
+    tree: &git2::Tree<'_>,
+    parents: &[&git2::Commit<'_>],
+    commit_headers: Option<Headers>,
+) -> anyhow::Result<git2::Oid> {
+    let repo_gix = crate::open_repo(repo.path())?;
+    gitbutler_repo::commit_with_signature_gix(
+        &repo_gix,
+        update_ref,
+        git2_signature_to_gix_signature(author),
+        git2_signature_to_gix_signature(committer),
+        message.as_bytes().into(),
+        tree.id().to_gix(),
+        &parents
+            .iter()
+            .map(|commit| commit.id().to_gix())
+            .collect::<Vec<_>>(),
+        commit_headers,
+    )
+    .map(|oid| oid.to_git2())
+}
+
+pub(crate) fn maybe_find_branch_by_refname<'repo>(
+    repo: &'repo git2::Repository,
+    name: &Refname,
+) -> anyhow::Result<Option<git2::Branch<'repo>>> {
+    let branch = repo.find_branch(
+        &name.simple_name(),
+        match name {
+            Refname::Virtual(_) | Refname::Local(_) | Refname::Other(_) => git2::BranchType::Local,
+            Refname::Remote(_) => git2::BranchType::Remote,
+        },
+    );
+    match branch {
+        Ok(branch) => Ok(Some(branch)),
+        Err(err) if err.code() == git2::ErrorCode::NotFound => Ok(None),
+        Err(err) => Err(err.into()),
+    }
+}
+
 pub fn visualize_git2_tree(tree_id: git2::Oid, repo: &git2::Repository) -> termtree::Tree<String> {
     let repo = gix::open_opts(repo.path(), gix::open::Options::isolated()).unwrap();
     crate::visualize_tree(tree_id.to_gix().attach(&repo))

crates/but-testsupport/src/legacy/suite.rs

@@ -6,10 +6,11 @@ use std::{
 
 use but_ctx::{Context, RepoOpenMode};
 use but_settings::AppSettings;
-use gitbutler_repo::RepositoryExt;
 use tempfile::{TempDir, tempdir};
 
-use super::{VAR_NO_CLEANUP, init_opts, init_opts_bare, test_project::setup_config};
+use super::{
+    VAR_NO_CLEANUP, commit_with_signature, init_opts, init_opts_bare, test_project::setup_config,
+};
 
 pub struct Suite {
     pub local_app_data: Option<TempDir>,
@@ -153,17 +154,17 @@ pub fn test_repository() -> (git2::Repository, TempDir) {
     let mut index = git2_repo.index().expect("failed to get index");
     let oid = index.write_tree().expect("failed to write tree");
     let signature = git2::Signature::now("test", "test@email.com").unwrap();
-    git2_repo
-        .commit_with_signature(
-            Some(&"refs/heads/master".parse().unwrap()),
-            &signature,
-            &signature,
-            "Initial commit",
-            &git2_repo.find_tree(oid).expect("failed to find tree"),
-            &[],
-            None,
-        )
-        .expect("failed to commit");
+    commit_with_signature(
+        &git2_repo,
+        Some(&"refs/heads/master".parse().unwrap()),
+        &signature,
+        &signature,
+        "Initial commit",
+        &git2_repo.find_tree(oid).expect("failed to find tree"),
+        &[],
+        None,
+    )
+    .expect("failed to commit");
     (git2_repo, tmp)
 }
 
@@ -176,9 +177,8 @@ pub fn commit_all(repository: &git2::Repository) -> git2::Oid {
     let oid = index.write_tree().expect("failed to write tree");
     let signature = git2::Signature::now("test", "test@email.com").unwrap();
     let head = repository.head().expect("failed to get head");
-    let repo: &git2::Repository = repository;
-
-    repo.commit_with_signature(
+    commit_with_signature(
+        repository,
         Some(&head.name().map(|name| name.parse().unwrap()).unwrap()),
         &signature,
         &signature,

crates/but-testsupport/src/legacy/test_project.rs

@@ -5,7 +5,7 @@ use gitbutler_reference::{LocalRefname, Refname};
 use gitbutler_repo::RepositoryExt;
 use tempfile::TempDir;
 
-use super::{VAR_NO_CLEANUP, init_opts};
+use super::{VAR_NO_CLEANUP, commit_with_signature, init_opts, maybe_find_branch_by_refname};
 
 pub fn temp_dir() -> TempDir {
     tempfile::tempdir().unwrap()
@@ -36,8 +36,8 @@ impl Default for TestProject {
         let mut index = local_repository.index().expect("failed to get index");
         let oid = index.write_tree().expect("failed to write tree");
         let signature = git2::Signature::now("test", "test@email.com").unwrap();
-        let repo: &git2::Repository = &local_repository;
-        repo.commit_with_signature(
+        commit_with_signature(
+            &local_repository,
             Some(&"refs/heads/master".parse().unwrap()),
             &signature,
             &signature,
@@ -137,17 +137,12 @@ impl TestProject {
             Refname::Remote(remote) => format!("refs/heads/{}", remote.branch()).parse().unwrap(),
             _ => "INVALID".parse().unwrap(),
         };
-        let branch = self
-            .remote_repo
-            .maybe_find_branch_by_refname(&branch_name)
-            .unwrap();
+        let branch = maybe_find_branch_by_refname(&self.remote_repo, &branch_name).unwrap();
         let branch_commit = branch.unwrap().get().peel_to_commit().unwrap();
 
         let master_branch = {
             let name: Refname = "refs/heads/master".parse().unwrap();
-            self.remote_repo
-                .maybe_find_branch_by_refname(&name)
-                .unwrap()
+            maybe_find_branch_by_refname(&self.remote_repo, &name).unwrap()
         };
         let master_branch_commit = master_branch.unwrap().get().peel_to_commit().unwrap();
 
@@ -213,15 +208,13 @@ impl TestProject {
             Refname::Remote(remote) => format!("refs/heads/{}", remote.branch()).parse()?,
             _ => "INVALID".parse()?,
         };
-        let branch = self
-            .remote_repo
-            .maybe_find_branch_by_refname(&branch_name)?
-            .expect("branch exists");
+        let branch =
+            maybe_find_branch_by_refname(&self.remote_repo, &branch_name)?.expect("branch exists");
         let branch_commit = branch.get().peel_to_commit()?;
 
         let master_branch = {
             let name: Refname = "refs/heads/master".parse()?;
-            self.remote_repo.maybe_find_branch_by_refname(&name)?
+            maybe_find_branch_by_refname(&self.remote_repo, &name)?
         };
         let master_branch_commit = master_branch
             .as_ref()
@@ -248,8 +241,8 @@ impl TestProject {
             self.remote_repo.find_tree(tree_id.to_git2())?
         };
 
-        let repo: &git2::Repository = &self.remote_repo;
-        repo.commit_with_signature(
+        commit_with_signature(
+            &self.remote_repo,
             Some(&"refs/heads/master".parse()?),
             &branch_commit.author(),
             &branch_commit.committer(),
@@ -280,7 +273,7 @@ impl TestProject {
     pub fn checkout(&self, branch: &LocalRefname) {
         let refname: Refname = branch.into();
         let head_commit = self.local_repo.head().unwrap().peel_to_commit().unwrap();
-        let tree = match self.local_repo.maybe_find_branch_by_refname(&refname) {
+        let tree = match maybe_find_branch_by_refname(&self.local_repo, &refname) {
             Ok(branch) => match branch {
                 Some(branch) => branch.get().peel_to_tree().unwrap(),
                 None => {
@@ -310,8 +303,8 @@ impl TestProject {
         let oid = index.write_tree().expect("failed to write tree");
         let signature = git2::Signature::now("test", "test@email.com").unwrap();
         let refname: Refname = head.name().unwrap().parse().unwrap();
-        let repo: &git2::Repository = &self.local_repo;
-        repo.commit_with_signature(
+        commit_with_signature(
+            &self.local_repo,
             Some(&refname),
             &signature,
             &signature,

crates/but-testsupport/src/legacy/testing_repository.rs

@@ -2,12 +2,11 @@ use std::fs;
 
 use but_core::{ChangeId, commit::Headers};
 use but_oxidize::OidExt;
-use gitbutler_repo::RepositoryExt;
 use gix_testtools::bstr::ByteSlice as _;
 use tempfile::{TempDir, tempdir};
 use uuid::Uuid;
 
-use super::init_opts;
+use super::{commit_with_signature, init_opts};
 
 pub struct TestingRepository {
     pub repository: git2::Repository,
@@ -148,21 +147,20 @@ impl TestingRepository {
                 conflicted: None,
             });
 
-        let commit = self
-            .repository
-            .commit_with_signature(
-                None,
-                &signature,
-                &signature,
-                message,
-                &self
-                    .repository
-                    .find_tree(index.write_tree().unwrap())
-                    .unwrap(),
-                parent.map(|c| vec![c]).unwrap_or_default().as_slice(),
-                Some(commit_headers),
-            )
-            .unwrap();
+        let commit = commit_with_signature(
+            &self.repository,
+            None,
+            &signature,
+            &signature,
+            message,
+            &self
+                .repository
+                .find_tree(index.write_tree().unwrap())
+                .unwrap(),
+            parent.map(|c| vec![c]).unwrap_or_default().as_slice(),
+            Some(commit_headers),
+        )
+        .unwrap();
 
         self.repository.find_commit(commit).unwrap()
     }

crates/gitbutler-repo/src/repository_ext.rs

@@ -1,12 +1,9 @@
-use std::str;
-
 use anyhow::{Context as _, Result, bail};
 use bstr::BStr;
 use but_core::{
     RepositoryExt as RepositoryExtGix,
     commit::{Headers, SignCommit},
 };
-use but_oxidize::{ObjectIdExt as _, OidExt, git2_signature_to_gix_signature};
 use gitbutler_reference::Refname;
 
 /// Extension trait for `git2::Repository`.
@@ -22,19 +19,6 @@ pub trait RepositoryExt {
     /// gets merged.
     fn merge_base_octopussy(&self, ids: &[git2::Oid]) -> Result<git2::Oid>;
     fn checkout_tree_builder<'a>(&'a self, tree: &'a git2::Tree<'a>) -> CheckoutTreeBuidler<'a>;
-    fn maybe_find_branch_by_refname(&self, name: &Refname) -> Result<Option<git2::Branch<'_>>>;
-
-    #[expect(clippy::too_many_arguments)]
-    fn commit_with_signature(
-        &self,
-        update_ref: Option<&Refname>,
-        author: &git2::Signature<'_>,
-        committer: &git2::Signature<'_>,
-        message: &str,
-        tree: &git2::Tree<'_>,
-        parents: &[&git2::Commit<'_>],
-        commit_headers: Option<Headers>,
-    ) -> Result<git2::Oid>;
 }
 
 /// Create a commit with GitButler signing and trailer behavior using `gix`-native inputs.
@@ -134,50 +118,6 @@ impl RepositoryExt for git2::Repository {
         }
     }
 
-    fn maybe_find_branch_by_refname(&self, name: &Refname) -> Result<Option<git2::Branch<'_>>> {
-        let branch = self.find_branch(
-            &name.simple_name(),
-            match name {
-                Refname::Virtual(_) | Refname::Local(_) | Refname::Other(_) => {
-                    git2::BranchType::Local
-                }
-                Refname::Remote(_) => git2::BranchType::Remote,
-            },
-        );
-        match branch {
-            Ok(branch) => Ok(Some(branch)),
-            Err(e) if e.code() == git2::ErrorCode::NotFound => Ok(None),
-            Err(e) => Err(e.into()),
-        }
-    }
-
-    fn commit_with_signature(
-        &self,
-        update_ref: Option<&Refname>,
-        author: &git2::Signature<'_>,
-        committer: &git2::Signature<'_>,
-        message: &str,
-        tree: &git2::Tree<'_>,
-        parents: &[&git2::Commit<'_>],
-        commit_headers: Option<Headers>,
-    ) -> Result<git2::Oid> {
-        let repo = gix::open(self.path())?;
-        commit_with_signature_gix(
-            &repo,
-            update_ref,
-            git2_signature_to_gix_signature(author),
-            git2_signature_to_gix_signature(committer),
-            message.into(),
-            tree.id().to_gix(),
-            &parents
-                .iter()
-                .map(|commit| commit.id().to_gix())
-                .collect::<Vec<_>>(),
-            commit_headers,
-        )
-        .map(|oid| oid.to_git2())
-    }
-
     fn merge_base_octopussy(&self, ids: &[git2::Oid]) -> Result<git2::Oid> {
         if ids.len() < 2 {
             bail!("Merge base octopussy requires at least two commit ids to operate on");