refactor: Use gitoxide instead of git2

gitoxide's git_repository crate provides similar capabilities to the git2
crate. The primary advantage of gitoxide is that it is faster than git2;
specifically for startup time where it is about 4x faster, and possibly for
other operations.

gitoxide is also written in pure Rust, which provides a richer set of
interfaces and opens the door to more direct participation in upstream
improvements. Also, gitoxide aims to implement more git behaviors than
libgit2, and thus provides a path to eliminate calls to git which would
further improve runtime performance of StGit.

The potential downside to gitoxide is that it introduces a significant
numbmer (40) of additional Rust crate dependencies.

Author: jpgrayson

Cargo.lock

@@ -31,7 +31,7 @@ clap = { version = "4.0", default-features = false, features = [
 ] }
 ctrlc = "3.2"
 encoding_rs = "0.8"
-git2 = { version = "0.15", default-features = false }
+git-repository = { version = "0.31", default-features = false, features = [] }
 indexmap = "1.8"
 is-terminal = "0.4"
 serde = { version = "1.0", features = ["derive"] }

Cargo.toml

@@ -38,7 +38,6 @@ dynamically links to libc and other non-Rust libraries when they are
 available at build-time. Dynamic link dependencies include these
 libraries along with their transient link dependencies:
 
-- libgit2
 - libcurl (optional)
 - libbz2 (optional)
 

README.md

@@ -88,35 +88,39 @@ pub(crate) fn get_default_aliases() -> Aliases {
 ///
 /// The `exclude` closure is intended to prevent names of builtin StGit subcommands from
 /// being shadowed by aliases.
-pub(crate) fn get_aliases<F>(config: &git2::Config, exclude: F) -> Result<Aliases>
+pub(crate) fn get_aliases<F>(
+    config_file: Option<&git_repository::config::File>,
+    exclude: F,
+) -> Result<Aliases>
 where
     F: Fn(&str) -> bool,
 {
     let mut aliases = get_default_aliases();
-    let mut iter = config.entries(None)?;
-    while let Some(entry) = iter.next() {
-        let entry = entry?;
-        if let Some(name) = entry.name_bytes().strip_prefix(b"stgit.alias.") {
-            let name = name.to_str().map_err(|_| {
-                anyhow!(
-                    "Alias name `{}` in {} is not valid UTF-8",
-                    name.to_str_lossy(),
-                    config_level_to_str(entry.level()),
-                )
-            })?;
-            if entry.has_value() {
-                if !exclude(name) {
-                    let command = entry.value().ok_or_else(|| {
-                        anyhow!(
-                            "Alias value for `{name}` in {} is not valid UTF-8",
-                            config_level_to_str(entry.level()),
-                        )
-                    })?;
-                    let alias = Alias::new(name, command);
-                    aliases.insert(name.to_string(), alias);
+
+    if let Some(config_file) = config_file {
+        if let Ok(section) = config_file.section("stgit", Some("alias".into())) {
+            for key in section.keys() {
+                let name = key.to_str().map_err(|_| {
+                    anyhow!(
+                        "Alias name `{}` in {} is not valid UTF-8",
+                        key.to_str_lossy(),
+                        config_source_str(section.meta().source),
+                    )
+                })?;
+                if let Some(value) = section.value(key) {
+                    if !exclude(name) {
+                        let command = value.to_str().map_err(|_| {
+                            anyhow!(
+                                "Alias value for `{name}` in {} is not valid UTF-8",
+                                config_source_str(section.meta().source)
+                            )
+                        })?;
+                        let alias = Alias::new(name, command);
+                        aliases.insert(name.to_string(), alias);
+                    }
+                } else {
+                    aliases.remove(name);
                 }
-            } else {
-                aliases.remove(name);
             }
         }
     }
@@ -172,16 +176,20 @@ fn split_command_line(line: &str) -> Result<Vec<String>, String> {
     }
 }
 
-/// Map [`git2::ConfigLevel`] to user-facing strings.
-fn config_level_to_str(level: git2::ConfigLevel) -> &'static str {
-    match level {
-        git2::ConfigLevel::ProgramData => "program data config",
-        git2::ConfigLevel::System => "system config",
-        git2::ConfigLevel::XDG => "XDG config",
-        git2::ConfigLevel::Global => "global config",
-        git2::ConfigLevel::Local => "local config",
-        git2::ConfigLevel::App => "app config",
-        git2::ConfigLevel::Highest => "highest config",
+/// Map [`git_repository::config::Source`] to user-facing strings.
+fn config_source_str(source: git_repository::config::Source) -> &'static str {
+    use git_repository::config::Source;
+    match source {
+        Source::GitInstallation => "git installed config",
+        Source::System => "system config",
+        Source::Git => "git config",
+        Source::User => "user global config",
+        Source::Local => "repository local config",
+        Source::Worktree => "worktree config",
+        Source::Env => "environment config",
+        Source::Cli => "cli config",
+        Source::Api => "api config",
+        Source::EnvOverride => "environment override config",
     }
 }
 

src/alias.rs

@@ -2,6 +2,7 @@
 
 //! [`clap::Arg`] definitions common to several StGit commands.
 
+use bstr::ByteSlice;
 use clap::Arg;
 
 /// The `--branch`/`-b` option for selecting an alternative branch.
@@ -97,11 +98,7 @@ pub(crate) fn diff_opts_arg() -> Arg {
 
 /// For use with `clap::Arg::value_parser()` to ensure a branch name is valid.
 pub(crate) fn parse_branch_name(name: &str) -> anyhow::Result<String> {
-    if git2::Branch::name_is_valid(name)? {
-        Ok(name.to_string())
-    } else {
-        Err(anyhow::anyhow!("invalid branch name `{name}`"))
-    }
+    Ok(git_repository::refs::PartialName::try_from(name).map(|_| name.to_string())?)
 }
 
 /// Get a `&str` from a `clap::ArgMatches` instance for the given `id`.
@@ -136,15 +133,17 @@ pub(crate) fn parse_usize(s: &str) -> anyhow::Result<usize> {
 /// line of subordinate `git` commands.
 pub(crate) fn get_diff_opts(
     matches: &clap::ArgMatches,
-    config: &git2::Config,
+    config: &git_repository::config::Snapshot,
     force_full_index: bool,
     force_binary: bool,
 ) -> Vec<String> {
     let mut opts = Vec::new();
 
-    if let Ok(value) = config.get_string("stgit.diff-opts") {
-        for arg in value.split_ascii_whitespace() {
-            opts.push(String::from(arg));
+    if let Some(value) = config.string("stgit.diff-opts") {
+        if let Ok(value) = value.to_str() {
+            for arg in value.split_ascii_whitespace() {
+                opts.push(String::from(arg));
+            }
         }
     }
 
@@ -164,14 +163,10 @@ pub(crate) fn get_diff_opts(
 }
 
 pub(crate) fn resolve_allow_push_conflicts(
-    config: &git2::Config,
+    config: &git_repository::config::Snapshot,
     matches: &clap::ArgMatches,
 ) -> bool {
     get_one_str(matches, "conflicts")
         .map(|s| s == "allow")
-        .unwrap_or_else(|| {
-            config
-                .get_bool("stgit.push.allow-conflicts")
-                .unwrap_or(true)
-        })
+        .unwrap_or_else(|| config.boolean("stgit.push.allow-conflicts").unwrap_or(true))
 }