Struct Hunk 

pub struct Hunk {
    pub before: Range<u32>,
    pub after: Range<u32>,
}

Available on crate feature blob only.

A single change in a Diff that represents a range of tokens (before) in the first sequence that were replaced by a different range of tokens in the second sequence (after).

Each hunk identifies a contiguous region of change, where tokens from the before range should be replaced with tokens from the after range.

Fields

before: Range<u32>

The range of token indices in the first sequence (before) that were removed.

after: Range<u32>

The range of token indices in the second sequence (after) that were added.

Implementations

impl Hunk

pub const NONE: Hunk

Can be used instead of Option::None for better performance. Because imara-diff does not support more than i32::MAX there is an unused bit pattern that can be used.

It has some nice properties where it usually is not necessary to check for None separately: Empty ranges fail contains checks and also fail smaller than checks.

pub fn invert(&self) -> Hunk

Inverts a hunk so that it represents a change that would undo this hunk.

pub fn is_pure_insertion(&self) -> bool

Returns whether tokens are only inserted and not removed in this hunk.

pub fn is_pure_removal(&self) -> bool

Returns whether tokens are only removed and not inserted in this hunk.

pub fn latin_word_diff<'a>( &self, input: &InternedInput<&'a str>, word_tokens: &mut InternedInput<&'a str>, diff: &mut Diff, )

Performs a word-diff on this hunk.

This requires passing the original input in order to look up the tokens of the current hunk, which typically are lines. Each token is split into words using the built-in words tokenizer. The resulting word tokens are stored in a second diff_input, and a diff is computed on them, with basic post-processing applied.

For performance reasons, this second diff_input as well as the computed diff need to be passed as parameters so that they can be re-used when iterating over hunks. Note that word tokens are always added but never removed from the interner. Consider clearing it if you expect your input to have a large vocabulary.

Examples

// Compute diff normally
let before = "before text";
let after = "after text";
let mut lines = InternedInput::new(before, after);
let mut diff = Diff::compute(Algorithm::Histogram, &lines);
diff.postprocess_lines(&lines);

// Compute word-diff per hunk, reusing allocations across iterations
let mut hunk_diff_input = InternedInput::default();
let mut hunk_diff = Diff::default();
for hunk in diff.hunks() {
  hunk.latin_word_diff(&lines, &mut hunk_diff_input, &mut hunk_diff);
  let added = hunk_diff.count_additions();
  let removed = hunk_diff.count_removals();
  println!("word-diff of this hunk has {added} additions and {removed} removals");
  // optionally, clear the interner:
  hunk_diff_input.clear();
}

Trait Implementations

impl Clone for Hunk

fn clone(&self) -> Hunk

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hunk

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

Formats the value using the given formatter.

impl Default for Hunk

fn default() -> Hunk

Returns the “default value” for a type.

impl Hash for Hunk

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Hunk

fn eq(&self, other: &Hunk) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Hunk

impl StructuralPartialEq for Hunk