Struct Diff 

pub struct Diff { /* private fields */ }

A minimal line-level edit script between two blocks of text.

Construct one with Diff::lines. Iterate the individual changes with changes, ask whether the two inputs matched with is_empty, or format the whole thing as a unified diff through its Display implementation.

Examples

use test_lang::{Change, Diff};

let diff = Diff::lines("a\nb\nc", "a\nB\nc");
assert!(!diff.is_empty());

// The unchanged `a` and `c` frame the one changed line.
let rendered = diff.to_string();
assert!(rendered.contains("-b"));
assert!(rendered.contains("+B"));
assert!(rendered.contains(" a"));

Implementations

impl Diff

pub fn lines(expected: &str, actual: &str) -> Self

Compute the line-level diff between expected and actual.

Both inputs are split on \n into lines (the caller is expected to have already normalized line endings — Snapshot does this for you). Common leading and trailing lines are matched directly; only the differing middle region is run through the LCS engine.

Examples

Two identical strings produce an empty diff:

use test_lang::Diff;

let diff = Diff::lines("same\ntext", "same\ntext");
assert!(diff.is_empty());

An added line shows up as an insertion:

use test_lang::{Change, Diff};

let diff = Diff::lines("one\ntwo", "one\ntwo\nthree");
let inserted: Vec<_> = diff
    .changes()
    .filter(|(c, _)| *c == Change::Insert)
    .map(|(_, line)| line)
    .collect();
assert_eq!(inserted, ["three"]);

pub fn is_empty(&self) -> bool

Returns true when the two inputs were line-for-line identical, i.e. the diff contains no insertions or deletions.

Examples

use test_lang::Diff;

assert!(Diff::lines("x", "x").is_empty());
assert!(!Diff::lines("x", "y").is_empty());

pub fn changes(&self) -> impl Iterator<Item = (Change, &str)>

Iterate over every line in the diff, in order, as (change, text) pairs.

Equal lines are included so the caller can reconstruct the full aligned view; filter on the Change if only edits are of interest.

Examples

use test_lang::{Change, Diff};

let diff = Diff::lines("keep\ndrop", "keep");
let deleted = diff
    .changes()
    .filter(|(c, _)| *c == Change::Delete)
    .count();
assert_eq!(deleted, 1);

Trait Implementations

impl Clone for Diff

fn clone(&self) -> Diff

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Diff

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

Formats the value using the given formatter.

impl Display for Diff

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

Render the diff in unified style: one line per change, each prefixed with its marker and a space.

impl Eq for Diff

impl PartialEq for Diff

fn eq(&self, other: &Diff) -> 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 StructuralPartialEq for Diff