Function convert_word_diff_to_hunks

atomic-core/src/diff/inline.rs:647–753

Convert a word diff result to inline hunks.

(
    old_line: &'a [u8],
    new_line: &'a [u8],
    word_result: &WordDiffResult<'_>,
)

/// Convert a word diff result to inline hunks.
fn convert_word_diff_to_hunks<'a>(
    old_line: &'a [u8],
    new_line: &'a [u8],
    word_result: &WordDiffResult<'_>,
) -> InlineDiff<'a> {
    let mut old_hunks: Vec<ChangeHunk> = Vec::new();
    let mut new_hunks: Vec<ChangeHunk> = Vec::new();
    let mut has_changes = false;

    let old_tokens = word_result.old_tokens();
    let new_tokens = word_result.new_tokens();

    for op in word_result.ops() {
        match op {
            WordDiffOp::Equal {
                old_range,
                new_range,
            } => {
                // Add unchanged hunks
                if let (Some(first_old), Some(last_old)) = (
                    old_tokens.get(old_range.start),
                    old_tokens.get(old_range.end.saturating_sub(1)),
                ) {
                    let start = first_old.offset();
                    let end = last_old.end_offset();
                    old_hunks.push(ChangeHunk::unchanged(start, end));
                }

                if let (Some(first_new), Some(last_new)) = (
                    new_tokens.get(new_range.start),
                    new_tokens.get(new_range.end.saturating_sub(1)),
                ) {
                    let start = first_new.offset();
                    let end = last_new.end_offset();
                    new_hunks.push(ChangeHunk::unchanged(start, end));
                }
            }

            WordDiffOp::Insert { new_range, .. } => {
                has_changes = true;

                if let (Some(first), Some(last)) = (
                    new_tokens.get(new_range.start),
                    new_tokens.get(new_range.end.saturating_sub(1)),
                ) {
                    let start = first.offset();
                    let end = last.end_offset();
                    new_hunks.push(ChangeHunk::inserted(start, end));
                }
            }

            WordDiffOp::Delete { old_range, .. } => {
                has_changes = true;

                if let (Some(first), Some(last)) = (
                    old_tokens.get(old_range.start),
                    old_tokens.get(old_range.end.saturating_sub(1)),
                ) {