Integrate cache to blame with existing algorithm

Author: holodorum

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

@@ -43,6 +43,7 @@ pub fn blame_file(
         suspect,
         cache,
         &mut resource_cache,
+        None,
         file.as_bstr(),
         range,
     )?;

Diff for: gix-blame/src/file/function.rs

@@ -1,10 +1,11 @@
-use super::{process_changes, Change, UnblamedHunk};
+use super::{process_changes, update_blame_with_changes, Change, UnblamedHunk};
+use crate::types::BlameCacheObject;
 use crate::{BlameEntry, Error, Outcome, Statistics};
 use gix_diff::blob::intern::TokenSource;
 use gix_diff::tree::Visit;
 use gix_hash::ObjectId;
 use gix_object::{
-    bstr::{BStr, BString},
+    bstr::{BStr, BString, ByteSlice},
     FindExt,
 };
 use gix_traverse::commit::find as find_commit;
@@ -66,17 +67,22 @@ pub fn file(
     suspect: ObjectId,
     cache: Option<gix_commitgraph::Graph>,
     resource_cache: &mut gix_diff::blob::Platform,
+    blame_cache: Option<BlameCacheObject>,
     file_path: &BStr,
     range: Option<Range<u32>>,
 ) -> Result<Outcome, Error> {
     let _span = gix_trace::coarse!("gix_blame::file()", ?file_path, ?suspect);
 
     let mut stats = Statistics::default();
     let (mut buf, mut buf2, mut buf3) = (Vec::new(), Vec::new(), Vec::new());
-    let mut file_id = |commit, buf: &mut Vec<u8>, buf2: &mut Vec<u8>| find_path_entry_in_commit(&odb, commit, file_path, cache.as_ref(), buf, buf2, &mut stats)?.ok_or_else(|| Error::FileMissing {
-        file_path: file_path.to_owned(),
-        commit_id: suspect,
-    });
+    let mut file_id = |commit, buf: &mut Vec<u8>, buf2: &mut Vec<u8>| {
+        find_path_entry_in_commit(&odb, commit, file_path, cache.as_ref(), buf, buf2, &mut stats)?.ok_or_else(|| {
+            Error::FileMissing {
+                file_path: file_path.to_owned(),
+                commit_id: suspect,
+            }
+        })
+    };
     let blamed_file_entry_id = file_id(&suspect, &mut buf, &mut buf2)?;
     let blamed_file_blob = odb.find_blob(&blamed_file_entry_id, &mut buf)?.data.to_vec();
     let num_lines_in_blamed = tokens_for_diffing(&blamed_file_blob).tokenize().count() as u32;
@@ -87,17 +93,56 @@ pub fn file(
     }
 
     let range_in_blamed_file = one_based_inclusive_to_zero_based_exclusive_range(range, num_lines_in_blamed)?;
-    let mut hunks_to_blame = vec![UnblamedHunk {
-        range_in_blamed_file: range_in_blamed_file.clone(),
-        suspects: [(suspect, range_in_blamed_file)].into(),
-    }];
+
+    let (blame_entries, mut hunks_to_blame) = match blame_cache {
+        Some(blame_cache) => {
+            // If there is a cache, we first get the diff between the current commit and the commit
+            // we passed as the cache.
+            let old_file_id = file_id(&blame_cache.cache_id, &mut buf, &mut buf2)?;
+            let changes = blob_changes(
+                &odb,
+                resource_cache,
+                blamed_file_entry_id,
+                old_file_id,
+                file_path.as_bstr(),
+                &mut stats,
+            )?;
+
+            // If there are no changes, we can return the cache as is immediately.
+            if changes.iter().all(|change| matches!(change, Change::Unchanged(_))) {
+                return Ok(Outcome {
+                    entries: blame_cache.entries.clone(),
+                    blob: blamed_file_blob,
+                    statistics: stats,
+                });
+            }
+            // Otherwise, we update the cache with the new changes.
+            let (blame_entries, hunks_to_blame) = update_blame_with_changes(blame_cache.entries, changes, suspect);
+            // If there are no more hunks to blame, we can return the result immediately.
+            if hunks_to_blame.is_empty() {
+                return Ok(Outcome {
+                    entries: blame_entries,
+                    blob: blamed_file_blob,
+                    statistics: stats,
+                });
+            }
+            (blame_entries, hunks_to_blame)
+        }
+        None => {
+            let hunks_to_blame = vec![UnblamedHunk {
+                range_in_blamed_file: range_in_blamed_file.clone(),
+                suspects: [(suspect, range_in_blamed_file)].into(),
+            }];
+            (Vec::new(), hunks_to_blame)
+        }
+    };
 
     let (mut buf, mut buf2) = (Vec::new(), Vec::new());
     let commit = find_commit(cache.as_ref(), &odb, &suspect, &mut buf)?;
     let mut queue: gix_revwalk::PriorityQueue<CommitTime, ObjectId> = gix_revwalk::PriorityQueue::new();
     queue.insert(commit_time(commit)?, suspect);
 
-    let mut out = Vec::new();
+    let mut out = blame_entries;
     let mut diff_state = gix_diff::tree::State::default();
     let mut previous_entry: Option<(ObjectId, ObjectId)> = None;
     'outer: while let Some(suspect) = queue.pop_value() {

Diff for: gix-blame/src/file/mod.rs

@@ -357,7 +357,7 @@ fn process_changes(
     new_hunks_to_blame
 }
 
-/// Consume `cached_blames` and `changes`. With the changes we update the cached blames. 
+/// Consume `cached_blames` and `changes`. With the changes we update the cached blames.
 /// This function returns the updated blames and the new hunks to blame.
 fn update_blame_with_changes(
     cached_blames: Vec<BlameEntry>,
@@ -453,7 +453,7 @@ fn update_blame_with_changes(
                         }
                         false => {
                             new_hunks_to_blame.push(new_unblamed_hunk(range, head_id));
-                            
+
                             blame_assigned
                                 .assigned
                                 .add_assigned(change_assigned.get_remaining(&change));

Diff for: gix-blame/src/lib.rs

@@ -17,7 +17,7 @@
 mod error;
 pub use error::Error;
 mod types;
-pub use types::{BlameEntry, Outcome, Statistics};
+pub use types::{BlameCacheObject, BlameEntry, Outcome, Statistics};
 
 mod file;
 pub use file::function::file;

Diff for: gix-blame/src/types.rs

@@ -117,6 +117,15 @@ impl SubAssign<u32> for Offset {
     }
 }
 
+#[derive(Debug, PartialEq)]
+/// A cache of blame entries that can be used to speed up subsequent blames.
+pub struct BlameCacheObject {
+    /// The entries of the cache.
+    pub entries: Vec<BlameEntry>,
+    /// The commit that was blamed to produce these entries.
+    pub cache_id: ObjectId,
+}
+
 /// A mapping of a section of the *Blamed File* to the section in a *Source File* that introduced it.
 ///
 /// Both ranges are of the same size, but may use different [starting points](Range::start). Naturally,

Diff for: gix-blame/tests/blame.rs

@@ -190,6 +190,7 @@ macro_rules! mktest {
                 suspect,
                 None,
                 &mut resource_cache,
+                None,
                 format!("{}.txt", $case).as_str().into(),
                 None,
             )?
@@ -257,6 +258,7 @@ fn diff_disparity() {
             suspect,
             None,
             &mut resource_cache,
+            None,
             format!("{case}.txt").as_str().into(),
             None,
         )
@@ -285,6 +287,7 @@ fn line_range() {
         suspect,
         None,
         &mut resource_cache,
+        None,
         "simple.txt".into(),
         Some(1..2),
     )