@@ -10,7 +10,7 @@ use gix_traverse::commit::find as find_commit;

use smallvec::SmallVec;

use super::{process_changes, Change, UnblamedHunk};

use crate::{BlameEntry, Error, Options, Outcome, Statistics};

use crate::{types::BlamePathEntry, BlameEntry, Error, Options, Outcome, Statistics};

/// Produce a list of consecutive [`BlameEntry`] instances to indicate in which commits the ranges of the file

/// at `suspect:<file_path>` originated in.

@@ -115,6 +115,12 @@ pub fn file(

let mut out = Vec::new();

let mut diff_state = gix_diff::tree::State::default();

let mut previous_entry: Option<(ObjectId, ObjectId)> = None;

let mut blame_path = if options.debug_track_path {

Some(Vec::new())

} else {

None

};

'outer: while let Some(suspect) = queue.pop_value() {

stats.commits_traversed += 1;

if hunks_to_blame.is_empty() {

@@ -156,6 +162,23 @@ pub fn file(

// true here. We could perhaps use diff-tree-to-tree to compare `suspect` against

// an empty tree to validate this assumption.

if unblamed_to_out_is_done(&mut hunks_to_blame, &mut out, suspect) {

if let Some(ref mut blame_path) = blame_path {

let entry = previous_entry

.take()

.filter(|(id, _)| *id == suspect)

.map(|(_, entry)| entry);

let blame_path_entry = BlamePathEntry {

source_file_path: current_file_path.clone(),

previous_source_file_path: None,

commit_id: suspect,

blob_id: entry.unwrap_or(ObjectId::null(gix_hash::Kind::Sha1)),

previous_blob_id: ObjectId::null(gix_hash::Kind::Sha1),

parent_index: 0,

};

blame_path.push(blame_path_entry);

}

break 'outer;

}

}

@@ -241,13 +264,13 @@ pub fn file(

}

let more_than_one_parent = parent_ids.len() > 1;

for (parent_id, parent_commit_time) in parent_ids {

queue.insert(parent_commit_time, parent_id);

for (index, (parent_id, parent_commit_time)) in parent_ids.iter().enumerate() {

queue.insert(*parent_commit_time, *parent_id);

let changes_for_file_path = tree_diff_at_file_path(

&odb,

current_file_path.as_ref(),

suspect,

parent_id,

*parent_id,

cache.as_ref(),

&mut stats,

&mut diff_state,

@@ -262,21 +285,33 @@ pub fn file(

// None of the changes affected the file we’re currently blaming.

// Copy blame to parent.

for unblamed_hunk in &mut hunks_to_blame {

unblamed_hunk.clone_blame(suspect, parent_id);

unblamed_hunk.clone_blame(suspect, *parent_id);

}

} else {

pass_blame_from_to(suspect, parent_id, &mut hunks_to_blame);

pass_blame_from_to(suspect, *parent_id, &mut hunks_to_blame);

}

continue;

};

match modification {

TreeDiffChange::Addition => {

TreeDiffChange::Addition { id } => {

if more_than_one_parent {

// Do nothing under the assumption that this always (or almost always)

// implies that the file comes from a different parent, compared to which

// it was modified, not added.

} else if unblamed_to_out_is_done(&mut hunks_to_blame, &mut out, suspect) {

if let Some(ref mut blame_path) = blame_path {

let blame_path_entry = BlamePathEntry {

source_file_path: current_file_path.clone(),

previous_source_file_path: None,

commit_id: suspect,

blob_id: id,

previous_blob_id: ObjectId::null(gix_hash::Kind::Sha1),

parent_index: index,

};

blame_path.push(blame_path_entry);

}

break 'outer;

}

}

@@ -294,7 +329,22 @@ pub fn file(

options.diff_algorithm,

&mut stats,

)?;

hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent_id);

hunks_to_blame = process_changes(hunks_to_blame, changes.clone(), suspect, *parent_id);

if let Some(ref mut blame_path) = blame_path {

let has_blame_been_passed = hunks_to_blame.iter().any(|hunk| hunk.has_suspect(parent_id));

if has_blame_been_passed {

let blame_path_entry = BlamePathEntry {

source_file_path: current_file_path.clone(),

previous_source_file_path: Some(current_file_path.clone()),

commit_id: suspect,

blob_id: id,

previous_blob_id: previous_id,

parent_index: index,

};

blame_path.push(blame_path_entry);

}

}

}

TreeDiffChange::Rewrite {

source_location,

@@ -311,11 +361,29 @@ pub fn file(

options.diff_algorithm,

&mut stats,

)?;

hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, parent_id);

hunks_to_blame = process_changes(hunks_to_blame, changes, suspect, *parent_id);

let mut has_blame_been_passed = false;

for hunk in hunks_to_blame.iter_mut() {

if hunk.has_suspect(&parent_id) {

if hunk.has_suspect(parent_id) {

hunk.source_file_name = Some(source_location.clone());

has_blame_been_passed = true;

}

}

if has_blame_been_passed {

if let Some(ref mut blame_path) = blame_path {

let blame_path_entry = BlamePathEntry {

source_file_path: current_file_path.clone(),

previous_source_file_path: Some(source_location.clone()),

commit_id: suspect,

blob_id: id,

previous_blob_id: source_id,

parent_index: index,

};

blame_path.push(blame_path_entry);

}

}

}

@@ -351,6 +419,7 @@ pub fn file(

entries: coalesce_blame_entries(out),

blob: blamed_file_blob,

statistics: stats,

blame_path,

})

}

@@ -435,7 +504,9 @@ fn coalesce_blame_entries(lines_blamed: Vec<BlameEntry>) -> Vec<BlameEntry> {

/// The union of [`gix_diff::tree::recorder::Change`] and [`gix_diff::tree_with_rewrites::Change`],

/// keeping only the blame-relevant information.

enum TreeDiffChange {

Addition,

Addition {

id: ObjectId,

},

Deletion,

Modification {

previous_id: ObjectId,

@@ -453,7 +524,7 @@ impl From<gix_diff::tree::recorder::Change> for TreeDiffChange {

use gix_diff::tree::recorder::Change;

match value {

Change::Addition { .. } => Self::Addition,

Change::Addition { oid, .. } => Self::Addition { id: oid },

Change::Deletion { .. } => Self::Deletion,

Change::Modification { previous_oid, oid, .. } => Self::Modification {

previous_id: previous_oid,

@@ -468,7 +539,7 @@ impl From<gix_diff::tree_with_rewrites::Change> for TreeDiffChange {

use gix_diff::tree_with_rewrites::Change;

match value {

Change::Addition { .. } => Self::Addition,

Change::Addition { id, .. } => Self::Addition { id },

Change::Deletion { .. } => Self::Deletion,

Change::Modification { previous_id, id, .. } => Self::Modification { previous_id, id },

Change::Rewrite {