Replace libgit2 with gitoxide

.github/dependabot.yml

@@ -6,10 +6,6 @@ updates:
     interval: monthly
     time: "04:00"
     timezone: Europe/Berlin
-  ignore:
-  - dependency-name: git2
-    versions:
-    - 0.13.17
 - package-ecosystem: gitsubmodule
   directory: "/"
   schedule:

Cargo.toml

@@ -31,7 +31,7 @@ minimal-application = [
     "regex-onig",
     "wild",
 ]
-git = ["git2"] # Support indicating git modifications
+git = ["gix"] # Support indicating git modifications
 paging = ["shell-words", "grep-cli"] # Support applying a pager on the output
 lessopen = ["execute"] # Support $LESSOPEN preprocessor
 build-assets = ["syntect/yaml-load", "syntect/plist-load", "regex", "walkdir"]
@@ -69,10 +69,11 @@ encoding_rs = "0.8.35"
 execute = { version = "0.2.13", optional = true }
 terminal-colorsaurus = "0.4"
 
-[dependencies.git2]
-version = "0.20"
+[dependencies.gix]
+version = "0.70"
 optional = true
 default-features = false
+features = ["blob-diff"]
 
 [dependencies.syntect]
 version = "5.2.0"

src/diff.rs

@@ -1,11 +1,15 @@
 #![cfg(feature = "git")]
 
+use gix::diff::blob::pipeline::{Mode, WorktreeRoots};
+use gix::diff::blob::{Algorithm, ResourceKind, Sink};
+use gix::index::hash::Kind;
+use gix::object::tree::EntryKind;
+use gix::{self, ObjectId};
+use path_abs::PathInfo;
 use std::collections::HashMap;
-use std::fs;
+use std::ops::Range;
 use std::path::Path;
 
-use git2::{DiffOptions, IntoCString, Repository};
-
 #[derive(Copy, Clone, Debug)]
 pub enum LineChange {
     Added,
@@ -16,68 +20,73 @@ pub enum LineChange {
 
 pub type LineChanges = HashMap<u32, LineChange>;
 
-pub fn get_git_diff(filename: &Path) -> Option<LineChanges> {
-    let repo = Repository::discover(filename).ok()?;
+struct DiffStepper(LineChanges);
 
-    let repo_path_absolute = fs::canonicalize(repo.workdir()?).ok()?;
+impl Sink for DiffStepper {
+    type Out = LineChanges;
 
-    let filepath_absolute = fs::canonicalize(filename).ok()?;
-    let filepath_relative_to_repo = filepath_absolute.strip_prefix(&repo_path_absolute).ok()?;
-
-    let mut diff_options = DiffOptions::new();
-    let pathspec = filepath_relative_to_repo.into_c_string().ok()?;
-    diff_options.pathspec(pathspec);
-    diff_options.context_lines(0);
-
-    let diff = repo
-        .diff_index_to_workdir(None, Some(&mut diff_options))
-        .ok()?;
-
-    let mut line_changes: LineChanges = HashMap::new();
-
-    let mark_section =
-        |line_changes: &mut LineChanges, start: u32, end: i32, change: LineChange| {
-            for line in start..=end as u32 {
-                line_changes.insert(line, change);
+    fn process_change(&mut self, before: Range<u32>, after: Range<u32>) {
+        if before.is_empty() && !after.is_empty() {
+            for line in after {
+                self.0.insert(line + 1, LineChange::Added);
+            }
+        } else if after.is_empty() && !before.is_empty() {
+            if after.start == 0 {
+                self.0.insert(1, LineChange::RemovedAbove);
+            } else {
+                self.0.insert(after.start, LineChange::RemovedBelow);
+            }
+        } else {
+            for line in after {
+                self.0.insert(line + 1, LineChange::Modified);
             }
         };
+    }
 
-    let _ = diff.foreach(
-        &mut |_, _| true,
-        None,
-        Some(&mut |delta, hunk| {
-            let path = delta.new_file().path().unwrap_or_else(|| Path::new(""));
-
-            if filepath_relative_to_repo != path {
-                return false;
-            }
-
-            let old_lines = hunk.old_lines();
-            let new_start = hunk.new_start();
-            let new_lines = hunk.new_lines();
-            let new_end = (new_start + new_lines) as i32 - 1;
-
-            if old_lines == 0 && new_lines > 0 {
-                mark_section(&mut line_changes, new_start, new_end, LineChange::Added);
-            } else if new_lines == 0 && old_lines > 0 {
-                if new_start == 0 {
-                    mark_section(&mut line_changes, 1, 1, LineChange::RemovedAbove);
-                } else {
-                    mark_section(
-                        &mut line_changes,
-                        new_start,
-                        new_start as i32,
-                        LineChange::RemovedBelow,
-                    );
-                }
-            } else {
-                mark_section(&mut line_changes, new_start, new_end, LineChange::Modified);
-            }
-
-            true
-        }),
-        None,
-    );
-
-    Some(line_changes)
+    fn finish(self) -> Self::Out {
+        self.0
+    }
+}
+
+pub fn get_git_diff(filename: &Path) -> Option<LineChanges> {
+    let filepath_absolute = filename.canonicalize().ok()?;
+    let repository = gix::discover(filepath_absolute.parent().ok()?).unwrap();
+    let repo_path_absolute = repository.work_dir()?.canonicalize().ok()?;
+    let filepath_relative_to_repo = filepath_absolute.strip_prefix(&repo_path_absolute).ok()?;
+    let mut cache = repository
+        .diff_resource_cache(
+            Mode::ToGit,
+            WorktreeRoots {
+                old_root: None,
+                new_root: repository.work_dir().map(Path::to_path_buf),
+            },
+        )
+        .ok()?;
+    cache
+        .set_resource(
+            repository
+                .head_tree()
+                .ok()?
+                .lookup_entry_by_path(filepath_relative_to_repo.to_str()?).ok()??
+                .object_id(),
+            EntryKind::Blob,
+            filepath_relative_to_repo.to_str()?.into(),
+            ResourceKind::OldOrSource,
+            &repository,
+        )
+        .ok()?;
+    cache
+        .set_resource(
+            ObjectId::null(Kind::Sha1),
+            EntryKind::Blob,
+            filepath_relative_to_repo.to_str()?.into(),
+            ResourceKind::NewOrDestination,
+            &repository,
+        )
+        .ok()?;
+    return Some(gix::diff::blob::diff(
+        Algorithm::Myers,
+        &cache.prepare_diff().ok()?.interned_input(),
+        DiffStepper(HashMap::new()),
+    ));
 }

tests/tester/mod.rs

@@ -1,15 +1,13 @@
 use std::env;
 use std::fs::{self, File};
 use std::io::Read;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::process::Command;
 
+use gix::bstr::BString;
+use gix::objs::tree;
 use tempfile::TempDir;
 
-use git2::build::CheckoutBuilder;
-use git2::Repository;
-use git2::Signature;
-
 pub struct BatTester {
     /// Temporary working directory
     temp_dir: TempDir,
@@ -33,7 +31,6 @@ impl BatTester {
             ])
             .output()
             .expect("bat failed");
-
         // have to do the replace because the filename in the header changes based on the current working directory
         let actual = String::from_utf8_lossy(&output.stdout)
             .as_ref()
@@ -68,35 +65,31 @@ impl Default for BatTester {
     }
 }
 
-fn create_sample_directory() -> Result<TempDir, git2::Error> {
+fn create_sample_directory() -> Result<TempDir, Box<dyn std::error::Error>> {
     // Create temp directory and initialize repository
     let temp_dir = TempDir::new().expect("Temp directory");
-    let repo = Repository::init(&temp_dir)?;
+    let repo = gix::init(&temp_dir)?;
+    let mut tree = gix::objs::Tree::empty();
 
-    // Copy over `sample.rs`
-    let sample_path = temp_dir.path().join("sample.rs");
-    println!("{:?}", &sample_path);
-    fs::copy("tests/snapshots/sample.rs", &sample_path).expect("successful copy");
+    // Create sample.rs from snapshot file
+    let blob_id = repo.write_blob_stream(File::open("tests/snapshots/sample.rs")?)?;
+    let entry = tree::Entry {
+        mode: tree::EntryMode::from(tree::EntryKind::Blob),
+        oid: blob_id.object()?.id,
+        filename: BString::from("sample.rs"),
+    };
+    tree.entries.push(entry);
+    let tree_id = repo.write_object(tree)?;
 
-    // Commit
-    let mut index = repo.index()?;
-    index.add_path(Path::new("sample.rs"))?;
-
-    let oid = index.write_tree()?;
-    let signature = Signature::now("bat test runner", "bat@test.runner")?;
-    let tree = repo.find_tree(oid)?;
-    let _ = repo.commit(
-        Some("HEAD"), //  point HEAD to our new commit
-        &signature,   // author
-        &signature,   // committer
+    let commit_id = repo.commit(
+        "HEAD",
         "initial commit",
-        &tree,
-        &[],
-    );
-    let mut opts = CheckoutBuilder::new();
-    repo.checkout_head(Some(opts.force()))?;
+        tree_id,
+        gix::commit::NO_PARENT_IDS
+    )?;
+    assert_eq!(commit_id, repo.head_id()?);
 
-    fs::copy("tests/snapshots/sample.modified.rs", &sample_path).expect("successful copy");
+    fs::copy("tests/snapshots/sample.modified.rs", temp_dir.path().join("sample.rs")).expect("successful copy");
 
     Ok(temp_dir)
 }