feat: add first 'debug' version of gix diff tree.

It's primarily meant to better understand `gix blame`.

Author: cruessler

Diff for: gitoxide-core/src/repository/diff.rs

@@ -0,0 +1,82 @@
+use gix::bstr::{BString, ByteSlice};
+
+pub fn tree(
+    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()?.peel_to_kind(gix::object::Kind::Tree)?.into_tree();
+    let new_tree = new_tree_id.object()?.peel_to_kind(gix::object::Kind::Tree)?.into_tree();
+
+    let changes = repo.diff_tree_to_tree(&old_tree, &new_tree, None)?;
+
+    writeln!(
+        out,
+        "Diffing trees `{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(())
+}

Diff for: gitoxide-core/src/repository/mod.rs

@@ -28,6 +28,7 @@ pub use credential::function as credential;
 pub mod attributes;
 #[cfg(feature = "clean")]
 pub mod clean;
+pub mod diff;
 pub mod dirty;
 #[cfg(feature = "clean")]
 pub use clean::function::clean;

Diff for: src/plumbing/main.rs

@@ -189,6 +189,22 @@ pub fn main() -> Result<()> {
                 core::repository::merge_base(repository(Mode::Lenient)?, first, others, out, format)
             },
         ),
+        Subcommands::Diff(crate::plumbing::options::diff::Platform { cmd }) => match cmd {
+            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, old_treeish, new_treeish)
+                },
+            ),
+        },
         Subcommands::Worktree(crate::plumbing::options::worktree::Platform { cmd }) => match cmd {
             crate::plumbing::options::worktree::SubCommands::List => prepare_and_run(
                 "worktree-list",

Diff for: src/plumbing/options/mod.rs

@@ -145,6 +145,7 @@ pub enum Subcommands {
     Corpus(corpus::Platform),
     MergeBase(merge_base::Command),
     Merge(merge::Platform),
+    Diff(diff::Platform),
     Worktree(worktree::Platform),
     /// Subcommands that need no git repository to run.
     #[clap(subcommand)]
@@ -384,6 +385,30 @@ pub mod merge {
     }
 }
 
+pub mod diff {
+    use gix::bstr::BString;
+
+    /// Print all changes between two objects
+    #[derive(Debug, clap::Parser)]
+    pub struct Platform {
+        #[clap(subcommand)]
+        pub cmd: SubCommands,
+    }
+
+    #[derive(Debug, clap::Subcommand)]
+    pub enum SubCommands {
+        /// Diff two trees by specifying their revspecs.
+        Tree {
+            /// A revspec representing the before or old tree
+            #[clap(value_parser = crate::shared::AsBString)]
+            old_treeish: BString,
+            /// A revspec representing the after or new tree
+            #[clap(value_parser = crate::shared::AsBString)]
+            new_treeish: BString,
+        },
+    }
+}
+
 pub mod config {
     use gix::bstr::BString;