Print diff between trees

Author: cruessler

gitoxide-core/src/repository/diff.rs

@@ -1,10 +1,92 @@
-use gix::bstr::BString;
+use gix::bstr::{BString, ByteSlice};
 
 pub fn tree(
-    _repo: gix::Repository,
-    _out: &mut dyn std::io::Write,
-    _treeish1: BString,
-    _treeish2: BString,
+    repo: gix::Repository,
+    out: &mut dyn std::io::Write,
+    old_treeish: BString,
+    new_treeish: BString,
 ) -> anyhow::Result<()> {
+    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()
+        .unwrap()
+        .peel_to_kind(gix::object::Kind::Tree)
+        .unwrap()
+        .into_tree();
+    let new_tree = new_tree_id
+        .object()
+        .unwrap()
+        .peel_to_kind(gix::object::Kind::Tree)
+        .unwrap()
+        .into_tree();
+
+    let changes = repo.diff_tree_to_tree(&old_tree, &new_tree, None)?;
+
+    writeln!(
+        out,
+        "Diffing tree `{old_treeish}` ({old_tree_id}) -> `{new_treeish}` ({new_tree_id})"
+    )?;
+    writeln!(out)?;
+
+    write_changes(out, changes)?;
+
+    Ok(())
+}
+
+fn write_changes(
+    mut out: impl std::io::Write,
+    changes: Vec<gix::diff::tree_with_rewrites::Change>,
+) -> Result<(), std::io::Error> {
+    for change in changes {
+        match change {
+            gix::diff::tree_with_rewrites::Change::Addition {
+                location,
+                id,
+                entry_mode,
+                ..
+            } => {
+                writeln!(out, "A: {location}")?;
+                writeln!(out, "  {id}")?;
+                writeln!(out, "  -> {:o}", entry_mode.0)?;
+            }
+            gix::diff::tree_with_rewrites::Change::Deletion {
+                location,
+                id,
+                entry_mode,
+                ..
+            } => {
+                writeln!(out, "D: {location}")?;
+                writeln!(out, "  {id}")?;
+                writeln!(out, "  {:o} ->", entry_mode.0)?;
+            }
+            gix::diff::tree_with_rewrites::Change::Modification {
+                location,
+                previous_id,
+                id,
+                previous_entry_mode,
+                entry_mode,
+            } => {
+                writeln!(out, "M: {location}")?;
+                writeln!(out, "  {previous_id} -> {id}")?;
+                writeln!(out, "  {:o} -> {:o}", previous_entry_mode.0, entry_mode.0)?;
+            }
+            gix::diff::tree_with_rewrites::Change::Rewrite {
+                source_location,
+                source_id,
+                id,
+                location,
+                source_entry_mode,
+                entry_mode,
+                ..
+            } => {
+                writeln!(out, "R: {source_location} -> {location}")?;
+                writeln!(out, "  {source_id} -> {id}")?;
+                writeln!(out, "  {:o} -> {:o}", source_entry_mode.0, entry_mode.0)?;
+            }
+        };
+    }
+
     Ok(())
 }

src/plumbing/main.rs

@@ -190,15 +190,18 @@ pub fn main() -> Result<()> {
             },
         ),
         Subcommands::Diff(crate::plumbing::options::diff::Platform { cmd }) => match cmd {
-            crate::plumbing::options::diff::SubCommands::Tree { treeish1, treeish2 } => prepare_and_run(
+            crate::plumbing::options::diff::SubCommands::Tree {
+                old_treeish,
+                new_treeish,
+            } => prepare_and_run(
                 "diff-tree",
                 trace,
                 verbose,
                 progress,
                 progress_keep_open,
                 None,
                 move |_progress, out, _err| {
-                    core::repository::diff::tree(repository(Mode::Lenient)?, out, treeish1, treeish2)
+                    core::repository::diff::tree(repository(Mode::Lenient)?, out, old_treeish, new_treeish)
                 },
             ),
         },

src/plumbing/options/mod.rs

@@ -401,10 +401,10 @@ pub mod diff {
         Tree {
             /// TODO
             #[clap( value_parser = crate::shared::AsBString)]
-            treeish1: BString,
+            old_treeish: BString,
             /// TODO
             #[clap( value_parser = crate::shared::AsBString)]
-            treeish2: BString,
+            new_treeish: BString,
         },
     }
 }