Struct BlameOptions 

pub struct BlameOptions {
    pub ignore_whitespace: bool,
    pub moves: MoveDetection,
    pub copies: CopyDetection,
    pub ignore_revs: Arc<HashSet<Hash>>,
    pub ignore_rev_precise: bool,
    pub first_parent: bool,
}

Knobs controlling how blame_file_with attributes lines. The default (no -w, detection off, empty ignore set) reproduces blame_file’s exact-match behavior; this struct is the extension point for the blame parity work (-w, -M, -C, ignore-revs today; --reverse to follow).

Not Copy: Self::ignore_revs owns an Arc. It is passed by reference (&BlameOptions) on the hot path; the Arc lets copy-source blames share the same set without re-cloning it.

Fields

ignore_whitespace: bool

Ignore whitespace when matching a line against its parent revision, so a whitespace-only edit (reindent, tab↔space, spacing tweak) does not reattribute the line. Mirrors git blame -w, which ignores all whitespace, not just runs of it.

moves: MoveDetection

Within-file move detection (git -M).

copies: CopyDetection

Cross-file copy detection (git -C). On implies move detection even when Self::moves is MoveDetection::Off — git’s -C implies -M.

ignore_revs: Arc<HashSet<Hash>>

Commits to skip during attribution, like git blame --ignore-rev / --ignore-revs-file. When a line would be credited to a commit in this set (a mass-reformat / license-header / rename “noise” commit), blame falls through to the previous commit that actually changed the line. A commit whose lines have no counterpart in its parent (a genuine insertion) stays on the ignored commit, matching git’s default (no blame.markUnblamableLines marker).

Behind an Arc so a -C copy-source blame can share the same set (it inherits the active ignore-revs) with an O(1) refcount bump rather than deep-cloning the whole set per source.

ignore_rev_precise: bool

Refine --ignore-rev fall-through with content matching instead of git’s positional per-hunk guess (mkit-only, opt-in; no-op unless Self::ignore_revs is non-empty). git pairs a fallen-through line with whatever line sits at the same offset in the hunk, because a textual diff is all it has; mkit hashes line content, so it can often identify the line’s true surviving origin even when a reformat/reorder moved it to a different offset — e.g. a moved-and-reindented line matched to its real origin rather than to whatever happens to sit at the same position.

The refinement is never worse than git’s positional --ignore-rev, by construction: a line whose positional guess is already a real parent line (Some) is only re-pointed when the content evidence is a genuine moved block — a run of ≥ 2 file-adjacent lines matching contiguously — never for an isolated single-line key coincidence (which could otherwise land an edited line on an unrelated duplicate, strictly worse than positional). A line the positional pass left unattributed (None — a genuine insertion) may additionally be filled from a single exact-content match anywhere in the parent, since that only ever improves on “credited to the ignored commit”. Trivial keys (blank lines, }-only lines, sub-3-byte tokens) are never reattributed. When no qualifying evidence exists the result is identical to the positional default, so every line is attributed at least as well as plain --ignore-rev.

The default (false) keeps --ignore-rev byte-identical to git — this is a documented divergence, not a change to the default.

first_parent: bool

Follow only each commit’s first parent, like git blame --first-parent. The default (false) is git’s merge-aware walk: at a merge, a line is credited to whichever parent’s side actually wrote it (the first parent that still contains it), so a line merged in from a side branch is attributed to its authoring commit rather than the merge. With --first-parent, the walk follows the first-parent chain only, so such a line is credited to the merge commit — the older linear-history behavior.

Trait Implementations

impl Clone for BlameOptions

fn clone(&self) -> BlameOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BlameOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for BlameOptions

fn default() -> BlameOptions

Returns the “default value” for a type.