Function diff_with_anchors

atomic-core/src/diff/patience.rs:278–340

Build the diff result using LIS anchors. Process regions between consecutive anchors recursively.

(
    old: &[Line<'a>],
    new: &[Line<'a>],
    old_offset: usize,
    new_offset: usize,
    anchors: &[UniqueMatch],
)

///
/// Process regions between consecutive anchors recursively.
fn diff_with_anchors<'a>(
    old: &[Line<'a>],
    new: &[Line<'a>],
    old_offset: usize,
    new_offset: usize,
    anchors: &[UniqueMatch],
) -> DiffResult {
    let mut result = DiffResult::new();

    let mut old_pos = 0;
    let mut new_pos = 0;

    for anchor in anchors {
        // Diff the region before this anchor
        if old_pos < anchor.old_idx || new_pos < anchor.new_idx {
            let old_region = &old[old_pos..anchor.old_idx];
            let new_region = &new[new_pos..anchor.new_idx];

            let region_result = patience_diff_recursive(
                old_region,
                new_region,
                old_offset + old_pos,
                new_offset + new_pos,
            );

            for op in region_result {
                result.push(op);
            }
        }

        // The anchor itself is an equal line
        result.push(DiffOp::equal(
            old_offset + anchor.old_idx,
            new_offset + anchor.new_idx,
            1,
        ));

        old_pos = anchor.old_idx + 1;
        new_pos = anchor.new_idx + 1;
    }

    // Diff the region after the last anchor
    if old_pos < old.len() || new_pos < new.len() {
        let old_region = &old[old_pos..];
        let new_region = &new[new_pos..];

        let region_result = patience_diff_recursive(
            old_region,
            new_region,
            old_offset + old_pos,
            new_offset + new_pos,
        );

        for op in region_result {
            result.push(op);
        }
    }