Struct DiffIndex 

pub struct DiffIndex { /* private fields */ }

Parsed, command-neutral index of files and added lines in a unified diff.

Keys are exactly the paths the diff names in its +++ b/<path> headers, so they live in whatever namespace produced the diff — for git diff, relative to the repository toplevel. DiffIndex::base records the directory those keys are relative to, so a finding’s absolute path can be mapped into the same namespace before lookup. Without it, an analysis root below the toplevel silently misses every key.

Implementations

impl DiffIndex

pub fn from_unified_diff(diff: &str) -> Self

Parse a unified diff into an index of changed files and added lines.

Indexes at most MAX_ADDED_LINES added lines; totals used by DiffIndex::net_lines keep counting past the cap.

pub fn old_path_for(&self, head_path: &str) -> Option<&str>

Pre-rename path for head_path, in the diff’s key namespace, when the diff renamed it.

pub fn added_line_count(&self) -> usize

Number of indexed added lines, capped at MAX_ADDED_LINES.

pub fn hunk_count(&self) -> usize

Number of parsed unified-diff hunk headers.

pub fn net_lines(&self) -> i64

Total added lines minus total removed lines, independent of the added line indexing cap.

pub fn changes_path(&self, path: &str) -> bool

Whether this diff changes the path, including when the path is deleted.

pub fn changed_paths(&self) -> impl Iterator<Item = &str>

Paths changed by the diff, using the old path for deleted files.

pub fn touches_file(&self, path: &str) -> bool

Whether this diff touches an analyzable path in the head tree.

pub fn range_overlaps_added(&self, path: &str, start: u64, end: u64) -> bool

Whether any added line in path falls inside the inclusive 1-based start..=end range.

pub fn line_is_added(&self, path: &str, line: u64) -> bool

Whether the 1-based line in path was added by this diff.

pub fn line_within_added_context( &self, path: &str, line: u64, radius: u64, ) -> bool

Whether line sits within radius lines of any added line in path.

pub fn added_lines_in(&self, path: &str) -> Option<&FxHashSet<u64>>

Set of 1-based added line numbers for path, when the diff added any.

pub fn with_base(self, base: impl Into<PathBuf>) -> Self

Declare the directory this diff’s paths are relative to (the git toplevel for git diff output).

pub fn with_root_offset(self, offset: impl Into<String>) -> Self

Declare where the analysis root sits below DiffIndex::base, as a forward-slashed relative path (empty when they are the same directory).

Findings are addressed relative to the analysis root; this diff’s keys are relative to its base. Everything that looks a finding up in this index has to cross that gap, so the index carries the offset rather than making each caller rediscover it.

pub fn root_offset(&self) -> &str

Relative path of the analysis root below DiffIndex::base; empty when they coincide.

pub fn key_for_root_relative<'a>(&self, rel: &'a str) -> Cow<'a, str>

Lift an analysis-root-relative path into this diff’s key namespace.

pub fn root_relative_from_key<'a>(&self, key: &'a str) -> Option<Cow<'a, str>>

Lower one of this diff’s keys back to an analysis-root-relative path. None when the key names a file outside the analysis root.

pub fn old_path_for_root_relative<'a>( &'a self, rel: &str, ) -> Option<Cow<'a, str>>

The pre-rename path of an analysis-root-relative path, itself analysis-root-relative. Crosses into the diff’s key namespace and back, so a monorepo package below the diff’s base resolves its renames.

pub fn base(&self) -> Option<&Path>

Directory this diff’s keys are relative to, when declared via DiffIndex::with_base.

pub fn touched_files(&self) -> impl Iterator<Item = &str>

Analyzable head-tree paths this diff touches, in the diff’s key namespace.

pub fn key_for(&self, path: &Path, fallback_root: &Path) -> Option<String>

Map a finding’s path into this diff’s key namespace.

Relativizes against DiffIndex::base when one was declared, else against fallback_root. When base == fallback_root (the analysis root is the repository toplevel) both agree, so behavior is unchanged.

Trait Implementations

impl Clone for DiffIndex

fn clone(&self) -> DiffIndex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DiffIndex

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

Formats the value using the given formatter.

impl Default for DiffIndex

fn default() -> DiffIndex

Returns the “default value” for a type.