Method hunks_from_changed_lines

atomic-cli/src/commands/diff/helpers.rs:128–281

Group numbered changed lines into diff hunks with true file offsets. `changed` must be in file order. Changes separated by more than `2 * context` unchanged lines become separate hunks; closer changes merge with the gap emitted as context. Context line content is taken from `before_lines` (the file's recorded before-content); when it is `None`, hunks are emitted with zero context but still carry

(
        changed: &[NumberedLine],
        before_lines: Option<&[Vec<u8>]>,
        context: usize,
    )

    /// at boundary `p` is `@@ -p,0 +n,k @@`, a pure deletion is
    /// `@@ -l,k +p,0 @@`, and context lines count toward both sides.
    pub(super) fn hunks_from_changed_lines(
        changed: &[NumberedLine],
        before_lines: Option<&[Vec<u8>]>,
        context: usize,
    ) -> Vec<DiffHunk> {
        let mut hunks = Vec::new();
        if changed.is_empty() {
            return hunks;
        }

        let old_len = before_lines.map(|l| l.len()).unwrap_or(0);
        let ctx = if before_lines.is_some() { context } else { 0 };
        let merge_gap = 2 * ctx as isize;

        // 1. Group into runs of nearby changes, measured in old-file
        //    coordinates.
        let mut runs: Vec<(usize, usize)> = Vec::new();
        let mut run_start = 0usize;
        let mut run_hi = changed[0].old_pos();
        for (i, nl) in changed.iter().enumerate().skip(1) {
            let lo = nl.old_pos();
            // Unchanged lines between the run and this change. An addition
            // sits at a boundary, so the gap is measured from the boundary
            // itself; a removal occupies a line, hence the extra -1.
            let gap = match nl.line.status {
                LineStatus::Removed => lo as isize - run_hi as isize - 1,
                _ => lo as isize - run_hi as isize,
            };
            if gap > merge_gap {
                runs.push((run_start, i));
                run_start = i;
            }
            run_hi = run_hi.max(nl.old_pos());
        }
        runs.push((run_start, changed.len()));

        // 2. Emit one hunk per run.
        for (start, end) in runs {
            let lines = &changed[start..end];

            let removed_count = lines.iter().filter(|l| l.line.is_removed()).count();
            let added_count = lines.len() - removed_count;

            let old_lo = lines.iter().map(|l| l.old_pos()).min().unwrap_or(0);
            let old_hi = lines.iter().map(|l| l.old_pos()).max().unwrap_or(0);
            let new_lo = lines.iter().map(|l| l.new_pos()).min().unwrap_or(0);

            // Old-file range covered by the hunk, including context.
            let (old_start, old_end, old_count) = if removed_count > 0 {
                let s = old_lo.saturating_sub(ctx).max(1);
                let e = if ctx > 0 {
                    old_hi.saturating_add(ctx).min(old_len)
                } else {
                    old_hi
                };
                let e = e.max(s);
                (s, e, e - s + 1)
            } else {