refactor!: Use the new tree_with_rewrites plumbing implementation.

This merges `object::tree::diff::change::Event` into `object::tree::diff::Change`
as well.

Author: Byron

gitoxide-core/src/hours/core.rs

@@ -128,19 +128,19 @@ pub fn spawn_tree_delta_threads<'scope>(
                                 .track_filename()
                                 .track_rewrites(None)
                                 .for_each_to_obtain_tree(&to, |change| {
-                                    use gix::object::tree::diff::change::Event::*;
+                                    use gix::object::tree::diff::Change::*;
                                     changes.fetch_add(1, Ordering::Relaxed);
-                                    match change.event {
+                                    match change {
                                         Rewrite { .. } => {
                                             unreachable!("we turned that off")
                                         }
-                                        Addition { entry_mode, id } => {
+                                        Addition { entry_mode, id, .. } => {
                                             if entry_mode.is_no_tree() {
                                                 files.added += 1;
                                                 add_lines(line_stats, &lines_count, &mut lines, id);
                                             }
                                         }
-                                        Deletion { entry_mode, id } => {
+                                        Deletion { entry_mode, id, .. } => {
                                             if entry_mode.is_no_tree() {
                                                 files.removed += 1;
                                                 remove_lines(line_stats, &lines_count, &mut lines, id);
@@ -151,6 +151,7 @@ pub fn spawn_tree_delta_threads<'scope>(
                                             previous_entry_mode,
                                             id,
                                             previous_id,
+                                            ..
                                         } => match (previous_entry_mode.is_blob(), entry_mode.is_blob()) {
                                             (false, false) => {}
                                             (false, true) => {

gitoxide-core/src/query/engine/update.rs

@@ -210,31 +210,32 @@ pub fn update(
                                             .track_path()
                                             .track_rewrites(Some(rewrites))
                                             .for_each_to_obtain_tree_with_cache(&to, &mut rewrite_cache, |change| {
-                                                use gix::object::tree::diff::change::Event::*;
+                                                use gix::object::tree::diff::Change::*;
                                                 change_counter.fetch_add(1, Ordering::SeqCst);
-                                                match change.event {
-                                                    Addition { entry_mode, id } => {
+                                                match change {
+                                                    Addition {
+                                                        entry_mode,
+                                                        id,
+                                                        location,
+                                                        ..
+                                                    } => {
                                                         if entry_mode.is_blob_or_symlink() {
-                                                            add_lines(&mut out, change.location, &lines_counter, id);
+                                                            add_lines(&mut out, location, &lines_counter, id);
                                                         }
                                                     }
                                                     Modification {
                                                         entry_mode,
                                                         previous_entry_mode,
                                                         id,
                                                         previous_id,
+                                                        location,
                                                     } => match (previous_entry_mode.is_blob(), entry_mode.is_blob()) {
                                                         (false, false) => {}
                                                         (false, true) => {
-                                                            add_lines(&mut out, change.location, &lines_counter, id);
+                                                            add_lines(&mut out, location, &lines_counter, id);
                                                         }
                                                         (true, false) => {
-                                                            add_lines(
-                                                                &mut out,
-                                                                change.location,
-                                                                &lines_counter,
-                                                                previous_id,
-                                                            );
+                                                            add_lines(&mut out, location, &lines_counter, previous_id);
                                                         }
                                                         (true, true) => {
                                                             if let Ok(cache) =
@@ -266,7 +267,7 @@ pub fn update(
                                                                             lines_counter
                                                                                 .fetch_add(nl, Ordering::SeqCst);
                                                                             out.push(FileChange {
-                                                                                relpath: change.location.to_owned(),
+                                                                                relpath: location.to_owned(),
                                                                                 mode: FileMode::Modified,
                                                                                 source_relpath: None,
                                                                                 lines: Some(lines),
@@ -281,19 +282,25 @@ pub fn update(
                                                             }
                                                         }
                                                     },
-                                                    Deletion { entry_mode, id } => {
+                                                    Deletion {
+                                                        entry_mode,
+                                                        id,
+                                                        location,
+                                                        ..
+                                                    } => {
                                                         if entry_mode.is_blob_or_symlink() {
-                                                            remove_lines(&mut out, change.location, &lines_counter, id);
+                                                            remove_lines(&mut out, location, &lines_counter, id);
                                                         }
                                                     }
                                                     Rewrite {
                                                         source_location,
                                                         diff,
                                                         copy,
+                                                        location,
                                                         ..
                                                     } => {
                                                         out.push(FileChange {
-                                                            relpath: change.location.to_owned(),
+                                                            relpath: location.to_owned(),
                                                             source_relpath: Some(source_location.to_owned()),
                                                             mode: if copy { FileMode::Copy } else { FileMode::Rename },
                                                             lines: diff.map(|d| LineStats {

gix/src/ext/mod.rs

@@ -2,6 +2,8 @@ pub use object_id::ObjectIdExt;
 pub use reference::ReferenceExt;
 #[cfg(feature = "revision")]
 pub use rev_spec::RevSpecExt;
+#[cfg(feature = "blob-diff")]
+pub use tree::TreeDiffChangeExt;
 pub use tree::{TreeEntryExt, TreeEntryRefExt, TreeIterExt};
 
 mod object_id;

gix/src/ext/tree.rs

@@ -42,9 +42,9 @@ impl TreeIterExt for TreeRefIter<'_> {
     }
 }
 
-/// Extensions for [EntryRef][gix_object::tree::EntryRef].
+/// Extensions for [EntryRef](gix_object::tree::EntryRef).
 pub trait TreeEntryRefExt<'a>: 'a {
-    /// Attach [`Repository`][crate::Repository] to the given tree entry. It can be detached later with `detach()`.
+    /// Attach [`repo`](crate::Repository) to the given tree entry. It can be detached later with `detach()`.
     fn attach<'repo>(self, repo: &'repo crate::Repository) -> crate::object::tree::EntryRef<'repo, 'a>;
 }
 
@@ -54,9 +54,9 @@ impl<'a> TreeEntryRefExt<'a> for gix_object::tree::EntryRef<'a> {
     }
 }
 
-/// Extensions for [Entry][gix_object::tree::Entry].
+/// Extensions for [Entry](gix_object::tree::Entry).
 pub trait TreeEntryExt {
-    /// Attach [`Repository`][crate::Repository] to the given tree entry. It can be detached later with `detach()`.
+    /// Attach [`repo`](crate::Repository) to the given tree entry. It can be detached later with `detach()`.
     fn attach(self, repo: &crate::Repository) -> crate::object::tree::Entry<'_>;
 }
 
@@ -65,3 +65,15 @@ impl TreeEntryExt for gix_object::tree::Entry {
         crate::object::tree::Entry { inner: self, repo }
     }
 }
+
+/// Extensions for [Change](gix_diff::tree_with_rewrites::Change).
+#[cfg(feature = "blob-diff")]
+pub trait TreeDiffChangeExt {
+    /// Attach [`old_repo`](crate::Repository) and `new_repo` to current instance. It can be detached later with `detach()`.
+    /// Note that both repositories are usually the same.
+    fn attach<'old, 'new>(
+        &self,
+        old_repo: &'old crate::Repository,
+        new_repo: &'new crate::Repository,
+    ) -> crate::object::tree::diff::Change<'_, 'old, 'new>;
+}

gix/src/object/blob.rs

@@ -5,12 +5,9 @@ use crate::{Blob, ObjectDetached};
 pub mod diff {
     use std::ops::Range;
 
-    use gix_diff::blob::{platform::prepare_diff::Operation, ResourceKind};
+    use gix_diff::blob::platform::prepare_diff::Operation;
 
-    use crate::{
-        bstr::ByteSlice,
-        object::{blob::diff::lines::Change, tree::diff::change::Event},
-    };
+    use crate::bstr::ByteSlice;
 
     /// A platform to keep temporary information to perform line diffs on modified blobs.
     ///
@@ -21,99 +18,10 @@ pub mod diff {
 
     ///
     pub mod init {
-        /// The error returned by [`Platform::from_tree_change()`][super::Platform::from_tree_change()].
+        /// The error returned by [`object::tree::diff::Change::diff`](crate::object::tree::diff::Change::diff()).
         pub type Error = gix_diff::blob::platform::set_resource::Error;
     }
 
-    impl<'a> Platform<'a> {
-        /// Produce a platform for performing various diffs after obtaining the data from a single `tree_change`.
-        pub fn from_tree_change(
-            tree_change: &crate::object::tree::diff::Change<'_, '_, '_>,
-            resource_cache: &'a mut gix_diff::blob::Platform,
-        ) -> Result<Platform<'a>, init::Error> {
-            match tree_change.event {
-                Event::Addition { entry_mode, id } => {
-                    resource_cache.set_resource(
-                        id.repo.object_hash().null(),
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::OldOrSource,
-                        &id.repo.objects,
-                    )?;
-                    resource_cache.set_resource(
-                        id.inner,
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::NewOrDestination,
-                        &id.repo.objects,
-                    )?;
-                }
-                Event::Deletion { entry_mode, id } => {
-                    resource_cache.set_resource(
-                        id.inner,
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::OldOrSource,
-                        &id.repo.objects,
-                    )?;
-                    resource_cache.set_resource(
-                        id.repo.object_hash().null(),
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::NewOrDestination,
-                        &id.repo.objects,
-                    )?;
-                }
-                Event::Modification {
-                    previous_entry_mode,
-                    previous_id,
-                    entry_mode,
-                    id,
-                } => {
-                    resource_cache.set_resource(
-                        previous_id.inner,
-                        previous_entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::OldOrSource,
-                        &previous_id.repo.objects,
-                    )?;
-                    resource_cache.set_resource(
-                        id.inner,
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::NewOrDestination,
-                        &id.repo.objects,
-                    )?;
-                }
-                Event::Rewrite {
-                    source_location,
-                    source_entry_mode,
-                    source_id,
-                    entry_mode,
-                    id,
-                    diff: _,
-                    copy: _,
-                } => {
-                    resource_cache.set_resource(
-                        source_id.inner,
-                        source_entry_mode.kind(),
-                        source_location,
-                        ResourceKind::OldOrSource,
-                        &source_id.repo.objects,
-                    )?;
-                    resource_cache.set_resource(
-                        id.inner,
-                        entry_mode.kind(),
-                        tree_change.location,
-                        ResourceKind::NewOrDestination,
-                        &id.repo.objects,
-                    )?;
-                }
-            }
-            Ok(Self { resource_cache })
-        }
-    }
-
     ///
     pub mod lines {
         use crate::bstr::BStr;
@@ -195,11 +103,11 @@ pub mod diff {
                         let hunk_before = &lines[..end_of_before];
                         let hunk_after = &lines[end_of_before..];
                         if hunk_after.is_empty() {
-                            err = process_hunk(Change::Deletion { lines: hunk_before }).err();
+                            err = process_hunk(lines::Change::Deletion { lines: hunk_before }).err();
                         } else if hunk_before.is_empty() {
-                            err = process_hunk(Change::Addition { lines: hunk_after }).err();
+                            err = process_hunk(lines::Change::Addition { lines: hunk_after }).err();
                         } else {
-                            err = process_hunk(Change::Modification {
+                            err = process_hunk(lines::Change::Modification {
                                 lines_before: hunk_before,
                                 lines_after: hunk_after,
                             })

gix/src/object/tree/diff/change.rs

@@ -1,20 +1,14 @@
 use gix_object::TreeRefIter;
 
-use super::{change, Action, Change, Platform};
-use crate::{
-    bstr::BStr,
-    diff::{rewrites, rewrites::tracker},
-    ext::ObjectIdExt,
-    object::tree::diff,
-    Repository, Tree,
-};
+use super::{Action, Change, Platform};
+use crate::{diff::rewrites::tracker, Tree};
 
 /// The error return by methods on the [diff platform][Platform].
 #[derive(Debug, thiserror::Error)]
 #[allow(missing_docs)]
 pub enum Error {
     #[error(transparent)]
-    Diff(#[from] gix_diff::tree::Error),
+    Diff(#[from] gix_diff::tree_with_rewrites::Error),
     #[error("The user-provided callback failed")]
     ForEach(#[source] Box<dyn std::error::Error + Send + Sync + 'static>),
     #[error(transparent)]
@@ -23,13 +17,6 @@ pub enum Error {
     RenameTracking(#[from] tracker::emit::Error),
 }
 
-///
-#[derive(Clone, Debug, Copy, PartialEq)]
-pub struct Outcome {
-    /// Available only if [rewrite-tracking was enabled][Platform::track_rewrites()].
-    pub rewrites: Option<rewrites::Outcome>,
-}
-
 /// Add the item to compare to.
 impl<'old> Platform<'_, 'old> {
     /// Call `for_each` repeatedly with all changes that are needed to convert the source of the diff to the tree to `other`.
@@ -40,7 +27,7 @@ impl<'old> Platform<'_, 'old> {
         &mut self,
         other: &Tree<'new>,
         for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
-    ) -> Result<Outcome, Error>
+    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
     where
         E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
     {
@@ -62,7 +49,7 @@ impl<'old> Platform<'_, 'old> {
         other: &Tree<'new>,
         resource_cache: &mut gix_diff::blob::Platform,
         for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
-    ) -> Result<Outcome, Error>
+    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
     where
         E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
     {
@@ -72,289 +59,37 @@ impl<'old> Platform<'_, 'old> {
     fn for_each_to_obtain_tree_inner<'new, E>(
         &mut self,
         other: &Tree<'new>,
-        for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
+        mut for_each: impl FnMut(Change<'_, 'old, 'new>) -> Result<Action, E>,
         resource_cache: Option<&mut gix_diff::blob::Platform>,
-    ) -> Result<Outcome, Error>
+    ) -> Result<Option<gix_diff::rewrites::Outcome>, Error>
     where
         E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
     {
         let repo = self.lhs.repo;
-        let mut delegate = Delegate {
-            src_tree: self.lhs,
-            other_repo: other.repo,
-            recorder: gix_diff::tree::Recorder::default().track_location(self.tracking),
-            visit: for_each,
-            location: self.tracking,
-            tracked: self.rewrites.map(rewrites::Tracker::new),
-            err: None,
-        };
-        match gix_diff::tree(
-            TreeRefIter::from_bytes(&self.lhs.data),
-            TreeRefIter::from_bytes(&other.data),
-            &mut self.state,
-            &repo.objects,
-            &mut delegate,
-        ) {
-            Ok(()) => {
-                let outcome = Outcome {
-                    rewrites: delegate.process_tracked_changes(resource_cache)?,
-                };
-                match delegate.err {
-                    Some(err) => Err(Error::ForEach(err.into())),
-                    None => Ok(outcome),
-                }
-            }
-            Err(gix_diff::tree::Error::Cancelled) => delegate
-                .err
-                .map_or(Err(Error::Diff(gix_diff::tree::Error::Cancelled)), |err| {
-                    Err(Error::ForEach(err.into()))
-                }),
-            Err(err) => Err(err.into()),
-        }
-    }
-}
-
-struct Delegate<'a, 'old, 'new, VisitFn, E> {
-    src_tree: &'a Tree<'old>,
-    other_repo: &'new Repository,
-    recorder: gix_diff::tree::Recorder,
-    visit: VisitFn,
-    tracked: Option<rewrites::Tracker<gix_diff::tree::visit::Change>>,
-    location: Option<gix_diff::tree::recorder::Location>,
-    err: Option<E>,
-}
-
-impl<'old, 'new, VisitFn, E> Delegate<'_, 'old, 'new, VisitFn, E>
-where
-    VisitFn: for<'delegate> FnMut(Change<'delegate, 'old, 'new>) -> Result<Action, E>,
-    E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-{
-    /// Call `visit` on an attached version of `change`.
-    fn emit_change(
-        change: gix_diff::tree::visit::Change,
-        location: &BStr,
-        visit: &mut VisitFn,
-        repo: &'old Repository,
-        other_repo: &'new Repository,
-        stored_err: &mut Option<E>,
-    ) -> gix_diff::tree::visit::Action {
-        use gix_diff::tree::visit::Change::*;
-        let event = match change {
-            Addition {
-                entry_mode,
-                oid,
-                relation: _,
-            } => change::Event::Addition {
-                entry_mode,
-                id: oid.attach(other_repo),
-            },
-            Deletion {
-                entry_mode,
-                oid,
-                relation: _,
-            } => change::Event::Deletion {
-                entry_mode,
-                id: oid.attach(repo),
-            },
-            Modification {
-                previous_entry_mode,
-                previous_oid,
-                entry_mode,
-                oid,
-            } => change::Event::Modification {
-                previous_entry_mode,
-                entry_mode,
-                previous_id: previous_oid.attach(repo),
-                id: oid.attach(other_repo),
-            },
-        };
-        match visit(Change { event, location }) {
-            Ok(Action::Cancel) => gix_diff::tree::visit::Action::Cancel,
-            Ok(Action::Continue) => gix_diff::tree::visit::Action::Continue,
-            Err(err) => {
-                *stored_err = Some(err);
-                gix_diff::tree::visit::Action::Cancel
-            }
-        }
-    }
-
-    fn process_tracked_changes(
-        &mut self,
-        diff_cache: Option<&mut gix_diff::blob::Platform>,
-    ) -> Result<Option<rewrites::Outcome>, Error> {
-        let tracked = match self.tracked.as_mut() {
-            Some(t) => t,
-            None => return Ok(None),
-        };
-
-        let repo = self.src_tree.repo;
         let mut storage;
-        let diff_cache = match diff_cache {
-            Some(cache) => cache,
+        let cache = match resource_cache {
             None => {
                 storage = repo.diff_resource_cache(gix_diff::blob::pipeline::Mode::ToGit, Default::default())?;
                 &mut storage
             }
+            Some(cache) => cache,
         };
-
-        let outcome = tracked.emit(
-            |dest, source| match source {
-                Some(source) => {
-                    let (oid, mode) = dest.change.oid_and_entry_mode();
-                    let change = diff::Change {
-                        location: dest.location,
-                        event: diff::change::Event::Rewrite {
-                            source_location: source.location,
-                            source_entry_mode: source.entry_mode,
-                            source_id: source.id.attach(self.src_tree.repo),
-                            entry_mode: mode,
-                            id: oid.to_owned().attach(self.other_repo),
-                            diff: source.diff,
-                            copy: match source.kind {
-                                tracker::visit::SourceKind::Rename => false,
-                                tracker::visit::SourceKind::Copy => true,
-                            },
-                        },
-                    };
-                    match (self.visit)(change) {
-                        Ok(Action::Cancel) => gix_diff::tree::visit::Action::Cancel,
-                        Ok(Action::Continue) => gix_diff::tree::visit::Action::Continue,
-                        Err(err) => {
-                            self.err = Some(err);
-                            gix_diff::tree::visit::Action::Cancel
-                        }
-                    }
-                }
-                None => Self::emit_change(
-                    dest.change,
-                    dest.location,
-                    &mut self.visit,
-                    self.src_tree.repo,
-                    self.other_repo,
-                    &mut self.err,
-                ),
+        Ok(gix_diff::tree_with_rewrites(
+            TreeRefIter::from_bytes(&self.lhs.data),
+            TreeRefIter::from_bytes(&other.data),
+            cache,
+            &mut self.state,
+            &repo.objects,
+            |change| {
+                for_each(Change::from_change_ref(change, repo, other.repo)).map(|action| match action {
+                    Action::Continue => gix_diff::tree_with_rewrites::Action::Continue,
+                    Action::Cancel => gix_diff::tree_with_rewrites::Action::Cancel,
+                })
             },
-            diff_cache,
-            &self.src_tree.repo.objects,
-            |push| {
-                self.src_tree
-                    .traverse()
-                    .breadthfirst(&mut tree_to_changes::Delegate::new(push, self.location))
+            gix_diff::tree_with_rewrites::Options {
+                location: self.location,
+                rewrites: self.rewrites,
             },
-        )?;
-        Ok(Some(outcome))
-    }
-}
-
-impl<'old, 'new, VisitFn, E> gix_diff::tree::Visit for Delegate<'_, 'old, 'new, VisitFn, E>
-where
-    VisitFn: for<'delegate> FnMut(Change<'delegate, 'old, 'new>) -> Result<Action, E>,
-    E: Into<Box<dyn std::error::Error + Sync + Send + 'static>>,
-{
-    fn pop_front_tracked_path_and_set_current(&mut self) {
-        self.recorder.pop_front_tracked_path_and_set_current();
-    }
-
-    fn push_back_tracked_path_component(&mut self, component: &BStr) {
-        self.recorder.push_back_tracked_path_component(component);
-    }
-
-    fn push_path_component(&mut self, component: &BStr) {
-        self.recorder.push_path_component(component);
-    }
-
-    fn pop_path_component(&mut self) {
-        self.recorder.pop_path_component();
-    }
-
-    fn visit(&mut self, change: gix_diff::tree::visit::Change) -> gix_diff::tree::visit::Action {
-        match self.tracked.as_mut() {
-            Some(tracked) => tracked.try_push_change(change, self.recorder.path()).map_or(
-                gix_diff::tree::visit::Action::Continue,
-                |change| {
-                    Self::emit_change(
-                        change,
-                        self.recorder.path(),
-                        &mut self.visit,
-                        self.src_tree.repo,
-                        self.other_repo,
-                        &mut self.err,
-                    )
-                },
-            ),
-            None => Self::emit_change(
-                change,
-                self.recorder.path(),
-                &mut self.visit,
-                self.src_tree.repo,
-                self.other_repo,
-                &mut self.err,
-            ),
-        }
-    }
-}
-
-mod tree_to_changes {
-    use gix_diff::tree::visit::Change;
-    use gix_object::tree::EntryRef;
-
-    use crate::bstr::BStr;
-
-    pub struct Delegate<'a> {
-        push: &'a mut dyn FnMut(Change, &BStr),
-        recorder: gix_traverse::tree::Recorder,
-    }
-
-    impl<'a> Delegate<'a> {
-        pub fn new(
-            push: &'a mut dyn FnMut(Change, &BStr),
-            location: Option<gix_diff::tree::recorder::Location>,
-        ) -> Self {
-            let location = location.map(|t| match t {
-                gix_diff::tree::recorder::Location::FileName => gix_traverse::tree::recorder::Location::FileName,
-                gix_diff::tree::recorder::Location::Path => gix_traverse::tree::recorder::Location::Path,
-            });
-            Self {
-                push,
-                recorder: gix_traverse::tree::Recorder::default().track_location(location),
-            }
-        }
-    }
-
-    impl gix_traverse::tree::Visit for Delegate<'_> {
-        fn pop_front_tracked_path_and_set_current(&mut self) {
-            self.recorder.pop_front_tracked_path_and_set_current();
-        }
-
-        fn push_back_tracked_path_component(&mut self, component: &BStr) {
-            self.recorder.push_back_tracked_path_component(component);
-        }
-
-        fn push_path_component(&mut self, component: &BStr) {
-            self.recorder.push_path_component(component);
-        }
-
-        fn pop_path_component(&mut self) {
-            self.recorder.pop_path_component();
-        }
-
-        fn visit_tree(&mut self, _entry: &EntryRef<'_>) -> gix_traverse::tree::visit::Action {
-            gix_traverse::tree::visit::Action::Continue
-        }
-
-        fn visit_nontree(&mut self, entry: &EntryRef<'_>) -> gix_traverse::tree::visit::Action {
-            if entry.mode.is_blob() {
-                (self.push)(
-                    Change::Modification {
-                        previous_entry_mode: entry.mode,
-                        previous_oid: gix_hash::ObjectId::null(entry.oid.kind()),
-                        entry_mode: entry.mode,
-                        oid: entry.oid.to_owned(),
-                    },
-                    self.recorder.path(),
-                );
-            }
-            gix_traverse::tree::visit::Action::Continue
-        }
+        )?)
     }
 }

gix/src/object/tree/diff/for_each.rs

@@ -1,7 +1,7 @@
+use gix_diff::tree;
 use gix_diff::tree::recorder::Location;
 
-use crate::bstr::BString;
-use crate::{bstr::BStr, diff::Rewrites, Tree};
+use crate::{bstr::BStr, diff::Rewrites, Id, Tree};
 
 /// Returned by the `for_each` function to control flow.
 #[derive(Default, Clone, Copy, PartialOrd, PartialEq, Ord, Eq, Hash)]
@@ -15,25 +15,100 @@ pub enum Action {
 
 /// Represents any possible change in order to turn one tree into another.
 #[derive(Debug, Clone, Copy)]
-pub struct Change<'a, 'old, 'new> {
-    /// The location of the file or directory described by `event`, if tracking was enabled.
+pub enum Change<'a, 'old, 'new> {
+    /// An entry was added, like the addition of a file or directory.
+    Addition {
+        /// The location of the file or directory, if [tracking](Platform::track_path) was enabled.
+        ///
+        /// It may be empty if neither [file names](Platform::track_filename()) nor [file paths](Platform::track_path())
+        /// are tracked.
+        location: &'a BStr,
+        /// The mode of the added entry.
+        entry_mode: gix_object::tree::EntryMode,
+        /// Identifies a relationship between this instance and another one,
+        /// making it easy to reconstruct the top-level of directory changes.
+        relation: Option<tree::visit::Relation>,
+        /// The object id of the added entry.
+        id: Id<'new>,
+    },
+    /// An entry was deleted, like the deletion of a file or directory.
+    Deletion {
+        /// The location of the file or directory, if [tracking](Platform::track_path) was enabled.
+        ///
+        /// Otherwise, this value is always an empty path.
+        location: &'a BStr,
+        /// The mode of the deleted entry.
+        entry_mode: gix_object::tree::EntryMode,
+        /// Identifies a relationship between this instance and another one,
+        /// making it easy to reconstruct the top-level of directory changes.
+        relation: Option<tree::visit::Relation>,
+        /// The object id of the deleted entry.
+        id: Id<'old>,
+    },
+    /// An entry was modified, e.g. changing the contents of a file adjusts its object id and turning
+    /// a file into a symbolic link adjusts its mode.
+    Modification {
+        /// The location of the file or directory, if [tracking](Platform::track_path) was enabled.
+        ///
+        /// It may be empty if neither [file names](Platform::track_filename()) nor [file paths](Platform::track_path())
+        /// are tracked.
+        location: &'a BStr,
+        /// The mode of the entry before the modification.
+        previous_entry_mode: gix_object::tree::EntryMode,
+        /// The object id of the entry before the modification.
+        previous_id: Id<'old>,
+
+        /// The mode of the entry after the modification.
+        entry_mode: gix_object::tree::EntryMode,
+        /// The object id after the modification.
+        id: Id<'new>,
+    },
+    /// Entries are considered rewritten if they are not trees and they, according to some understanding of identity, were renamed
+    /// or copied.
+    /// In case of renames, this means they originally appeared as [`Deletion`](Change::Deletion) signalling their source as well as an
+    /// [`Addition`](Change::Addition) acting as destination.
     ///
-    /// Otherwise, this value is always an empty path.
-    pub location: &'a BStr,
-    /// The diff event itself to provide information about what would need to change.
-    pub event: change::Event<'a, 'old, 'new>,
-}
-
-/// Represents any possible change in order to turn one tree into another, the fully owned version
-/// of [`Change`].
-#[derive(Debug, Clone)]
-pub struct ChangeDetached {
-    /// The location of the file or directory described by `event`, if tracking was enabled.
+    /// In case of copies, the `copy` flag is true and typically represents a perfect copy of a source was made.
+    ///
+    /// This variant can only be encountered if [rewrite tracking](Platform::track_rewrites()) is enabled.
     ///
-    /// Otherwise, this value is always an empty path.
-    pub location: BString,
-    /// The diff event itself to provide information about what would need to change.
-    pub event: change::EventDetached,
+    /// Note that mode changes may have occurred as well, i.e. changes from executable to non-executable or vice-versa.
+    Rewrite {
+        /// The location of the source of the rename operation.
+        ///
+        /// It may be empty if neither [file names](Platform::track_filename()) nor [file paths](Platform::track_path())
+        /// are tracked.
+        source_location: &'a BStr,
+        /// Identifies a relationship between the source and another source,
+        /// making it easy to reconstruct the top-level of directory changes.
+        source_relation: Option<tree::visit::Relation>,
+        /// The mode of the entry before the rename.
+        source_entry_mode: gix_object::tree::EntryMode,
+        /// The object id of the entry before the rename.
+        ///
+        /// Note that this is the same as `id` if we require the [similarity to be 100%](Rewrites::percentage), but may
+        /// be different otherwise.
+        source_id: Id<'old>,
+        /// Information about the diff we performed to detect similarity and match the `source_id` with the current state at `id`.
+        /// It's `None` if `source_id` is equal to `id`, as identity made an actual diff computation unnecessary.
+        diff: Option<gix_diff::blob::DiffLineStats>,
+        /// The mode of the entry after the rename.
+        /// It could differ but still be considered a rename as we are concerned only about content.
+        entry_mode: gix_object::tree::EntryMode,
+        /// The location of the destination file or directory, if [tracking](Platform::track_path) was enabled.
+        ///
+        /// It may be empty if neither [file names](Platform::track_filename()) nor [file paths](Platform::track_path())
+        /// are tracked.
+        location: &'a BStr,
+        /// The object id after the rename.
+        id: Id<'new>,
+        /// Identifies a relationship between this destination and another destination,
+        /// making it easy to reconstruct the top-level of directory changes.
+        relation: Option<tree::visit::Relation>,
+        /// If true, this rewrite is created by copy, and `source_id` is pointing to its source. Otherwise, it's a rename, and `source_id`
+        /// points to a deleted object, as renames are tracked as deletions and additions of the same or similar content.
+        copy: bool,
+    },
 }
 
 ///
@@ -58,7 +133,7 @@ impl<'repo> Tree<'repo> {
         Ok(Platform {
             state: Default::default(),
             lhs: self,
-            tracking: None,
+            location: None,
             rewrites: self.repo.config.diff_renames()?.unwrap_or_default().into(),
         })
     }
@@ -69,23 +144,23 @@ impl<'repo> Tree<'repo> {
 pub struct Platform<'a, 'repo> {
     state: gix_diff::tree::State,
     lhs: &'a Tree<'repo>,
-    tracking: Option<Location>,
+    location: Option<Location>,
     rewrites: Option<Rewrites>,
 }
 
 /// Configuration
 impl Platform<'_, '_> {
     /// Keep track of file-names, which makes the [`location`][Change::location] field usable with the filename of the changed item.
     pub fn track_filename(&mut self) -> &mut Self {
-        self.tracking = Some(Location::FileName);
+        self.location = Some(Location::FileName);
         self
     }
 
     /// Keep track of the entire path of a change, relative to the repository.
     ///
     /// This makes the [`location`][Change::location] field usable.
     pub fn track_path(&mut self) -> &mut Self {
-        self.tracking = Some(Location::Path);
+        self.location = Some(Location::Path);
         self
     }