feat: add first 'debug' version of gix log

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

Author: cruessler

gitoxide-core/src/repository/log.rs

@@ -0,0 +1,152 @@
+use gix::bstr::{BStr, BString, ByteSlice};
+use gix::prelude::FindExt;
+use gix::ObjectId;
+
+pub fn log(mut repo: gix::Repository, out: &mut dyn std::io::Write, pathspec: BString) -> anyhow::Result<()> {
+    repo.object_cache_size_if_unset(repo.compute_object_cache_size_for_tree_diffs(&**repo.index_or_empty()?));
+
+    let head = repo.head()?.peel_to_commit_in_place()?;
+    let infos: Vec<_> =
+        gix::traverse::commit::topo::Builder::from_iters(&repo.objects, [head.id], None::<Vec<gix::ObjectId>>)
+            .build()?
+            .collect();
+
+    let infos: Vec<_> = infos
+        .into_iter()
+        .filter(|info| {
+            let commit = repo.find_commit(info.as_ref().unwrap().id).unwrap();
+
+            let mut buffer = Vec::new();
+            let tree = repo.objects.find_tree(&commit.tree_id().unwrap(), &mut buffer).unwrap();
+
+            let Some(entry) = tree.bisect_entry(pathspec.as_ref(), false) else {
+                return false;
+            };
+
+            let parent_ids: Vec<_> = commit.parent_ids().collect();
+
+            if parent_ids.is_empty() {
+                // We confirmed above that the file is in `commit`'s tree. If `parent_ids` is
+                // empty, the file was added in `commit`.
+
+                return true;
+            }
+
+            let parent_ids_with_changes: Vec<_> = parent_ids
+                .clone()
+                .into_iter()
+                .filter(|parent_id| {
+                    let mut buffer = Vec::new();
+                    let parent_commit = repo.find_commit(*parent_id).unwrap();
+                    let parent_tree = repo
+                        .objects
+                        .find_tree(&parent_commit.tree_id().unwrap(), &mut buffer)
+                        .unwrap();
+
+                    if let Some(parent_entry) = parent_tree.bisect_entry(pathspec.as_ref(), false) {
+                        if entry.oid == parent_entry.oid {
+                            // The blobs storing the file in `entry` and `parent_entry` are
+                            // identical which means the file was not changed in `commit`.
+
+                            return false;
+                        }
+                    }
+
+                    true
+                })
+                .collect();
+
+            if parent_ids.len() != parent_ids_with_changes.len() {
+                // At least one parent had an identical version of the file which means it was not
+                // changed in `commit`.
+
+                return false;
+            }
+
+            for parent_id in parent_ids_with_changes {
+                let modifications =
+                    get_modifications_for_file_path(&repo.objects, pathspec.as_ref(), commit.id, parent_id.into());
+
+                return !modifications.is_empty();
+            }
+
+            return false;
+        })
+        .collect();
+
+    write_infos(&repo, out, infos)?;
+
+    Ok(())
+}
+
+fn write_infos(
+    repo: &gix::Repository,
+    mut out: impl std::io::Write,
+    infos: Vec<Result<gix::traverse::commit::Info, gix::traverse::commit::topo::Error>>,
+) -> Result<(), std::io::Error> {
+    for info in infos {
+        let info = info.unwrap();
+        let commit = repo.find_commit(info.id).unwrap();
+
+        let message = commit.message_raw_sloppy();
+        let title = message.lines().next();
+
+        writeln!(
+            out,
+            "{} {}",
+            info.id.to_hex_with_len(8),
+            title.map(BString::from).unwrap_or_else(|| "<no message>".into())
+        )?;
+    }
+
+    Ok(())
+}
+
+fn get_modifications_for_file_path(
+    odb: impl gix::objs::Find + gix::objs::FindHeader,
+    file_path: &BStr,
+    id: ObjectId,
+    parent_id: ObjectId,
+) -> Vec<gix::diff::tree::recorder::Change> {
+    let mut buffer = Vec::new();
+
+    let parent = odb.find_commit(&parent_id, &mut buffer).unwrap();
+
+    let mut buffer = Vec::new();
+    let parent_tree_iter = odb
+        .find(&parent.tree(), &mut buffer)
+        .unwrap()
+        .try_into_tree_iter()
+        .unwrap();
+
+    let mut buffer = Vec::new();
+    let commit = odb.find_commit(&id, &mut buffer).unwrap();
+
+    let mut buffer = Vec::new();
+    let tree_iter = odb
+        .find(&commit.tree(), &mut buffer)
+        .unwrap()
+        .try_into_tree_iter()
+        .unwrap();
+
+    let mut recorder = gix::diff::tree::Recorder::default();
+    gix::diff::tree(
+        parent_tree_iter,
+        tree_iter,
+        gix::diff::tree::State::default(),
+        &odb,
+        &mut recorder,
+    )
+    .unwrap();
+
+    recorder
+        .records
+        .iter()
+        .filter(|change| match change {
+            gix::diff::tree::recorder::Change::Modification { path, .. } => path == file_path,
+            gix::diff::tree::recorder::Change::Addition { path, .. } => path == file_path,
+            _ => false,
+        })
+        .cloned()
+        .collect()
+}

gitoxide-core/src/repository/mod.rs

@@ -46,6 +46,7 @@ pub mod commitgraph;
 mod fsck;
 pub use fsck::function as fsck;
 pub mod index;
+pub mod log;
 pub mod mailmap;
 mod merge_base;
 pub use merge_base::merge_base;

src/plumbing/main.rs

@@ -209,6 +209,15 @@ pub fn main() -> Result<()> {
                 },
             ),
         },
+        Subcommands::Log(crate::plumbing::options::log::Platform { pathspec }) => prepare_and_run(
+            "log",
+            trace,
+            verbose,
+            progress,
+            progress_keep_open,
+            None,
+            move |_progress, out, _err| core::repository::log::log(repository(Mode::Lenient)?, out, pathspec),
+        ),
         Subcommands::Worktree(crate::plumbing::options::worktree::Platform { cmd }) => match cmd {
             crate::plumbing::options::worktree::SubCommands::List => prepare_and_run(
                 "worktree-list",

src/plumbing/options/mod.rs

@@ -146,6 +146,7 @@ pub enum Subcommands {
     MergeBase(merge_base::Command),
     Merge(merge::Platform),
     Diff(diff::Platform),
+    Log(log::Platform),
     Worktree(worktree::Platform),
     /// Subcommands that need no git repository to run.
     #[clap(subcommand)]
@@ -409,6 +410,18 @@ pub mod diff {
     }
 }
 
+pub mod log {
+    use gix::bstr::BString;
+
+    /// Print the history of a given file
+    #[derive(Debug, clap::Parser)]
+    pub struct Platform {
+        /// The git path specification to show a log for.
+        #[clap(value_parser = crate::shared::AsBString)]
+        pub pathspec: BString,
+    }
+}
+
 pub mod config {
     use gix::bstr::BString;