feat: add first 'debug' version of gix diff file

Author: cruessler

gitoxide-core/src/repository/diff.rs

@@ -1,4 +1,6 @@
-use gix::bstr::{BString, ByteSlice};
+use gix::bstr::{BStr, BString, ByteSlice};
+use gix::diff::blob::intern::TokenSource;
+use gix::diff::blob::UnifiedDiffBuilder;
 use gix::objs::tree::EntryMode;
 use gix::odb::store::RefreshMode;
 use gix::prelude::ObjectIdExt;
@@ -111,3 +113,181 @@ fn typed_location(mut location: BString, mode: EntryMode) -> BString {
     }
     location
 }
+
+pub fn file(
+    mut repo: gix::Repository,
+    out: &mut dyn std::io::Write,
+    old_treeish: BString,
+    new_treeish: BString,
+    path: BString,
+) -> Result<(), anyhow::Error> {
+    repo.object_cache_size_if_unset(repo.compute_object_cache_size_for_tree_diffs(&**repo.index_or_empty()?));
+    repo.objects.refresh = RefreshMode::Never;
+
+    let old_tree_id = repo.rev_parse_single(old_treeish.as_bstr())?;
+    let new_tree_id = repo.rev_parse_single(new_treeish.as_bstr())?;
+
+    let old_tree = old_tree_id.object()?.peel_to_tree()?;
+    let new_tree = new_tree_id.object()?.peel_to_tree()?;
+
+    let mut old_tree_buf = Vec::new();
+    let mut new_tree_buf = Vec::new();
+
+    use gix::diff::object::FindExt;
+
+    let old_tree_iter = repo.objects.find_tree_iter(&old_tree.id(), &mut old_tree_buf)?;
+    let new_tree_iter = repo.objects.find_tree_iter(&new_tree.id(), &mut new_tree_buf)?;
+
+    use gix::diff::tree::{
+        recorder::{self, Location},
+        Recorder,
+    };
+
+    struct FindChangeToPath {
+        inner: Recorder,
+        interesting_path: BString,
+        change: Option<recorder::Change>,
+    }
+
+    impl FindChangeToPath {
+        fn new(interesting_path: BString) -> Self {
+            let inner = Recorder::default().track_location(Some(Location::Path));
+
+            FindChangeToPath {
+                inner,
+                interesting_path,
+                change: None,
+            }
+        }
+    }
+
+    use gix::diff::tree::{visit, Visit};
+
+    impl Visit for FindChangeToPath {
+        fn pop_front_tracked_path_and_set_current(&mut self) {
+            self.inner.pop_front_tracked_path_and_set_current();
+        }
+
+        fn push_back_tracked_path_component(&mut self, component: &BStr) {
+            self.inner.push_back_tracked_path_component(component);
+        }
+
+        fn push_path_component(&mut self, component: &BStr) {
+            self.inner.push_path_component(component);
+        }
+
+        fn pop_path_component(&mut self) {
+            self.inner.pop_path_component();
+        }
+
+        fn visit(&mut self, change: visit::Change) -> visit::Action {
+            if self.inner.path() == self.interesting_path {
+                self.change = Some(match change {
+                    visit::Change::Deletion {
+                        entry_mode,
+                        oid,
+                        relation,
+                    } => recorder::Change::Deletion {
+                        entry_mode,
+                        oid,
+                        path: self.inner.path_clone(),
+                        relation,
+                    },
+                    visit::Change::Addition {
+                        entry_mode,
+                        oid,
+                        relation,
+                    } => recorder::Change::Addition {
+                        entry_mode,
+                        oid,
+                        path: self.inner.path_clone(),
+                        relation,
+                    },
+                    visit::Change::Modification {
+                        previous_entry_mode,
+                        previous_oid,
+                        entry_mode,
+                        oid,
+                    } => recorder::Change::Modification {
+                        previous_entry_mode,
+                        previous_oid,
+                        entry_mode,
+                        oid,
+                        path: self.inner.path_clone(),
+                    },
+                });
+
+                visit::Action::Cancel
+            } else {
+                visit::Action::Continue
+            }
+        }
+    }
+
+    let mut recorder = FindChangeToPath::new(path);
+    let state = gix::diff::tree::State::default();
+    let result = gix::diff::tree(old_tree_iter, new_tree_iter, state, &repo.objects, &mut recorder);
+
+    let Some(change) = (match result {
+        Ok(_) | Err(gix::diff::tree::Error::Cancelled) => recorder.change,
+        Err(_) => todo!(),
+    }) else {
+        todo!()
+    };
+
+    match change {
+        recorder::Change::Addition { .. } => todo!(),
+        recorder::Change::Deletion { .. } => todo!(),
+        recorder::Change::Modification {
+            previous_oid,
+            oid,
+            path,
+            ..
+        } => {
+            let mut resource_cache =
+                repo.diff_resource_cache(gix::diff::blob::pipeline::Mode::ToGit, Default::default())?;
+
+            resource_cache.set_resource(
+                previous_oid,
+                gix::object::tree::EntryKind::Blob,
+                path.as_slice().into(),
+                gix::diff::blob::ResourceKind::OldOrSource,
+                &repo.objects,
+            )?;
+            resource_cache.set_resource(
+                oid,
+                gix::object::tree::EntryKind::Blob,
+                path.as_slice().into(),
+                gix::diff::blob::ResourceKind::NewOrDestination,
+                &repo.objects,
+            )?;
+
+            let outcome = resource_cache.prepare_diff()?;
+
+            let old_data = String::from_utf8_lossy(outcome.old.data.as_slice().unwrap_or_default());
+            let new_data = String::from_utf8_lossy(outcome.new.data.as_slice().unwrap_or_default());
+
+            let input = gix::diff::blob::intern::InternedInput::new(
+                tokens_for_diffing(&old_data),
+                tokens_for_diffing(&new_data),
+            );
+
+            let unified_diff_builder = UnifiedDiffBuilder::new(&input);
+
+            // TODO
+            // The algorithm should come from `diff.algorithm`.
+            //
+            // See https://docs.rs/gix/latest/gix/object/blob/diff/struct.Platform.html#method.lines
+            let unified_diff =
+                gix::diff::blob::diff(gix::diff::blob::Algorithm::Histogram, &input, unified_diff_builder);
+
+            out.write_all(unified_diff.as_bytes())?;
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn tokens_for_diffing(data: &str) -> impl TokenSource<Token = &str> {
+    gix::diff::blob::sources::lines(data)
+}

src/plumbing/main.rs

@@ -277,6 +277,21 @@ pub fn main() -> Result<()> {
                     core::repository::diff::tree(repository(Mode::Lenient)?, out, old_treeish, new_treeish)
                 },
             ),
+            crate::plumbing::options::diff::SubCommands::File {
+                old_treeish,
+                new_treeish,
+                path,
+            } => prepare_and_run(
+                "diff-file",
+                trace,
+                verbose,
+                progress,
+                progress_keep_open,
+                None,
+                move |_progress, out, _err| {
+                    core::repository::diff::file(repository(Mode::Lenient)?, out, old_treeish, new_treeish, path)
+                },
+            ),
         },
         Subcommands::Log(crate::plumbing::options::log::Platform { pathspec }) => prepare_and_run(
             "log",

src/plumbing/options/mod.rs

@@ -514,6 +514,18 @@ pub mod diff {
             #[clap(value_parser = crate::shared::AsBString)]
             new_treeish: BString,
         },
+        /// Diff two versions of a file.
+        File {
+            /// A rev-spec representing the 'before' or old tree.
+            #[clap(value_parser = crate::shared::AsBString)]
+            old_treeish: BString,
+            /// A rev-spec representing the 'after' or new tree.
+            #[clap(value_parser = crate::shared::AsBString)]
+            new_treeish: BString,
+            /// The path to the file to run diff for.
+            #[clap(value_parser = crate::shared::AsBString)]
+            path: BString,
+        },
     }
 }