Parsing Unified Diff Hunks and Applying Them to a Text Buffer in Rust

use crate::hunk::{Hunk, Line, PatchError};

fn parse_range(spec: &str) -> Option<(usize, usize)> {
    let spec = spec.trim_start_matches(['-', '+']);
    let mut it = spec.splitn(2, ',');
    let start: usize = it.next()?.parse().ok()?;
    let len: usize = match it.next() {
        Some(n) => n.parse().ok()?,
        None => 1,
    };
    Some((start, len))
}

fn parse_header(line: &str) -> Result<(usize, usize, usize, usize), PatchError> {
    let bad = || PatchError::BadHeader(line.to_string());
    let inner = line.strip_prefix("@@ ").and_then(|s| s.split(" @@").next()).ok_or_else(bad)?;
    let mut parts = inner.split_whitespace();
    let old = parts.next().and_then(parse_range).ok_or_else(bad)?;
    let new = parts.next().and_then(parse_range).ok_or_else(bad)?;
    Ok((old.0, old.1, new.0, new.1))
}

pub fn parse_patch(input: &str) -> Result<Vec<Hunk>, PatchError> {
    let mut hunks: Vec<Hunk> = Vec::new();
    for raw in input.lines() {
        if raw.starts_with("@@") {
            let (os, ol, ns, nl) = parse_header(raw)?;
            hunks.push(Hunk { old_start: os, old_len: ol, new_start: ns, new_len: nl, lines: Vec::new() });
            continue;
        }
        let hunk = match hunks.last_mut() {
            Some(h) => h,
            None => continue, // skip file headers / preamble
        };
        let (tag, rest) = raw.split_at(raw.char_indices().next().map(|(_, c)| c.len_utf8()).unwrap_or(0));
        match tag {
            " " => hunk.lines.push(Line::Context(rest.to_string())),
            "-" => hunk.lines.push(Line::Remove(rest.to_string())),
            "+" => hunk.lines.push(Line::Add(rest.to_string())),
            _ => {}
        }
    }
    Ok(hunks)
}

use crate::hunk::{Hunk, Line, PatchError};

pub fn apply_hunks(buffer: &[String], hunks: &[Hunk]) -> Result<Vec<String>, PatchError> {
    let mut out: Vec<String> = buffer.to_vec();
    let mut offset: isize = 0;

    for (idx, hunk) in hunks.iter().enumerate() {
        let base = (hunk.old_start as isize - 1 + offset) as usize;
        let mut cursor = base;
        let mut spliced: Vec<String> = Vec::new();
        let mut removed = 0usize;

        for line in &hunk.lines {
            match line {
                Line::Context(text) => {
                    check(&out, cursor, text, idx)?;
                    spliced.push(text.clone());
                    cursor += 1;
                    removed += 1;
                }
                Line::Remove(text) => {
                    check(&out, cursor, text, idx)?;
                    cursor += 1;
                    removed += 1;
                }
                Line::Add(text) => spliced.push(text.clone()),
            }
        }

        out.splice(base..base + removed, spliced.clone());
        offset += spliced.len() as isize - removed as isize;
    }
    Ok(out)
}

fn check(buf: &[String], at: usize, expected: &str, hunk: usize) -> Result<(), PatchError> {
    match buf.get(at) {
        Some(actual) if actual == expected => Ok(()),
        _ => Err(PatchError::ContextMismatch { hunk, at }),
    }
}