feat: upgrade to git-repository v0.24 to simplify diff implementation.

Author: Byron

Cargo.toml

@@ -15,11 +15,11 @@ include = ["src/**/*", "LICENSE.md", "README.md", "CHANGELOG.md"]
 test = false
 
 [dependencies]
-git-repository = { version = "0.23.1", default-features = false, features = ["max-performance-safe"] }
+git-repository = { version = "0.24.0", default-features = false, features = ["max-performance-safe"] }
 similar = { version = "2.2.0", features = ["bytes"] }
 serde = { version = "1", features = ["std", "derive"] }
 serde_json = "1"
-bstr = "0.2.17"
+bstr = "1.0.1"
 thiserror = "1.0.32"
 
 [dependencies.git2]

src/index/diff/delegate.rs

@@ -2,50 +2,41 @@ use crate::index::diff::Error;
 use crate::{Change, CrateVersion};
 use bstr::BStr;
 use git_repository as git;
-use git_repository::diff::tree::visit::Action;
 use similar::ChangeTag;
 use std::collections::BTreeSet;
 
-pub(crate) struct Delegate<'repo> {
+#[derive(Default)]
+pub(crate) struct Delegate {
     changes: Vec<Change>,
     delete_version_ids: BTreeSet<u64>,
-    file_name: git::bstr::BString,
     err: Option<Error>,
-    repo: &'repo git::Repository,
 }
 
-impl<'repo> Delegate<'repo> {
-    pub fn from_repo(repo: &'repo git::Repository) -> Self {
-        Delegate {
-            changes: Vec::new(),
-            delete_version_ids: BTreeSet::new(),
-            err: None,
-            file_name: Default::default(),
-            repo,
-        }
-    }
-    fn handle(&mut self, change: git::diff::tree::visit::Change) -> Result<(), Error> {
+impl Delegate {
+    pub fn handle(
+        &mut self,
+        change: git::object::tree::diff::Change<'_, '_, '_>,
+    ) -> Result<git::object::tree::diff::Action, Error> {
         use git::bstr::ByteSlice;
-        use git::diff::tree::visit::Change::*;
+        use git::object::tree::diff::change::Event::*;
         use git::objs::tree::EntryMode::*;
         fn entry_data(
-            repo: &git::Repository,
             entry: git::objs::tree::EntryMode,
-            oid: git::hash::ObjectId,
+            id: git::Id<'_>,
         ) -> Result<Option<git::Object<'_>>, Error> {
             matches!(entry, Blob | BlobExecutable)
-                .then(|| repo.find_object(oid))
+                .then(|| id.object())
                 .transpose()
                 .map_err(Into::into)
         }
-        if self.file_name.contains(&b'.') {
-            return Ok(());
+        if change.location.contains(&b'.') {
+            return Ok(Default::default());
         }
-        match change {
-            Addition { entry_mode, oid } => {
-                if let Some(obj) = entry_data(self.repo, entry_mode, oid)? {
+        match change.event {
+            Addition { entry_mode, id } => {
+                if let Some(obj) = entry_data(entry_mode, id)? {
                     for line in (&obj.data).lines() {
-                        let version = version_from_json_line(line, self.file_name.as_ref())?;
+                        let version = version_from_json_line(line, change.location)?;
                         self.changes.push(if version.yanked {
                             Change::Yanked(version)
                         } else {
@@ -57,29 +48,27 @@ impl<'repo> Delegate<'repo> {
             Deletion { entry_mode, .. } => {
                 if entry_mode.is_no_tree() {
                     self.changes.push(Change::Deleted {
-                        name: self.file_name.to_string(),
+                        name: change.location.to_string(),
                     });
                 }
             }
             Modification {
                 previous_entry_mode,
-                previous_oid,
+                previous_id,
                 entry_mode,
-                oid,
+                id,
             } => {
-                let pair = entry_data(self.repo, previous_entry_mode, previous_oid)?
-                    .zip(entry_data(self.repo, entry_mode, oid)?);
+                let pair =
+                    entry_data(previous_entry_mode, previous_id)?.zip(entry_data(entry_mode, id)?);
                 if let Some((old, new)) = pair {
                     let diff = similar::TextDiffConfig::default()
                         .algorithm(similar::Algorithm::Myers)
                         .diff_lines(old.data.as_slice(), new.data.as_slice());
+                    let location = change.location;
                     for change in diff.iter_all_changes() {
                         match change.tag() {
                             ChangeTag::Delete | ChangeTag::Insert => {
-                                let version = version_from_json_line(
-                                    change.value(),
-                                    self.file_name.as_ref(),
-                                )?;
+                                let version = version_from_json_line(change.value(), location)?;
                                 if change.tag() == ChangeTag::Insert {
                                     self.changes.push(if version.yanked {
                                         Change::Yanked(version)
@@ -96,8 +85,9 @@ impl<'repo> Delegate<'repo> {
                 }
             }
         }
-        Ok(())
+        Ok(Default::default())
     }
+
     pub fn into_result(mut self) -> Result<Vec<Change>, Error> {
         match self.err {
             Some(err) => Err(err),
@@ -117,27 +107,6 @@ impl<'repo> Delegate<'repo> {
     }
 }
 
-impl git::diff::tree::Visit for Delegate<'_> {
-    fn pop_front_tracked_path_and_set_current(&mut self) {}
-    fn push_back_tracked_path_component(&mut self, _component: &git::bstr::BStr) {}
-    fn push_path_component(&mut self, component: &git::bstr::BStr) {
-        use git::bstr::ByteVec;
-        self.file_name.clear();
-        self.file_name.push_str(component);
-    }
-    fn pop_path_component(&mut self) {}
-
-    fn visit(&mut self, change: git::diff::tree::visit::Change) -> Action {
-        match self.handle(change) {
-            Ok(()) => Action::Continue,
-            Err(err) => {
-                self.err = err.into();
-                Action::Cancel
-            }
-        }
-    }
-}
-
 fn version_from_json_line(line: &[u8], file_name: &BStr) -> Result<CrateVersion, Error> {
     serde_json::from_slice(line).map_err(|err| Error::VersionDecode {
         source: err,

src/index/diff/mod.rs

@@ -1,6 +1,6 @@
 use crate::{Change, Index};
 use git_repository as git;
-use git_repository::prelude::{FindExt, ObjectIdExt};
+use git_repository::prelude::ObjectIdExt;
 use git_repository::refs::transaction::PreviousValue;
 use std::convert::TryFrom;
 
@@ -22,7 +22,7 @@ pub enum Error {
     #[error("Couldn't get the tree of a commit for diffing purposes")]
     PeelToTree(#[from] git::object::peel::to_kind::Error),
     #[error("Failed to diff two trees to find changed crates")]
-    Diff(#[from] git::diff::tree::changes::Error),
+    Diff(#[from] git::object::tree::diff::Error),
     #[error("Failed to decode {line:?} in file {file_name:?} as crate version")]
     VersionDecode {
         source: serde_json::Error,
@@ -105,18 +105,10 @@ impl Index {
         };
         let from = into_tree(from.into())?;
         let to = into_tree(to.into())?;
-        let mut delegate = Delegate::from_repo(&self.repo);
-        let res = git::diff::tree::Changes::from(git::objs::TreeRefIter::from_bytes(&from.data))
-            .needed_to_obtain(
-                git::objs::TreeRefIter::from_bytes(&to.data),
-                git::diff::tree::State::default(),
-                |id, buf| self.repo.objects.find_tree_iter(id, buf),
-                &mut delegate,
-            );
-        match res.err() {
-            None | Some(git::diff::tree::changes::Error::Cancelled) => { /*error in delegate*/ }
-            Some(err) => return Err(err.into()),
-        }
+        let mut delegate = Delegate::default();
+        from.changes()
+            .track_filename()
+            .for_each_to_obtain_tree(&to, |change| delegate.handle(change))?;
         delegate.into_result()
     }
 }