kobold_csv/

diff.rs

//! `KOBOLD.CSV.DIFF.1` -- a row/field-wise diff between two parsed delimited tables.
//!
//! Where kobold-json diffs two JSON trees by path, the CSV analogue compares two TABLES: a source extract
//! against a target extract, cell by cell. Each table is a header row of column names plus data rows. The
//! diff aligns columns by NAME (not position, so a reordered target still compares correctly), walks rows in
//! order, and emits a [`DiffEntry`] per differing cell -- the exact `(row, field, source, target)` an analyst
//! needs to chase a reconciliation break.
//!
//! Rows present in only one table, and columns present in only one table, are reported as findings rather
//! than silently ignored. This module is independent of GnuCOBOL/libcob.

use crate::dialect::{parse_row, Dialect};
use crate::model::Finding;

/// A parsed delimited table: a header (column names) and the data rows.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Table {
    /// The column names from the header row.
    pub header: Vec<String>,
    /// The data rows (each a vector of cell values aligned to `header`).
    pub rows: Vec<Vec<String>>,
}

/// Parse delimited `text` into a [`Table`] under dialect `d`, fail-closed on a malformed line or a data row
/// whose column count differs from the header.
pub fn parse_table(text: &[u8], d: &Dialect) -> Result<Table, Vec<Finding>> {
    let lines = split_lines(text);
    let mut findings = Vec::new();
    if lines.is_empty() {
        return Err(vec![Finding::new("CSV_EMPTY", "no rows (expected a header)".to_string())]);
    }
    let header = match parse_row(lines[0], d) {
        Ok(h) => h,
        Err(f) => return Err(vec![f]),
    };
    let mut rows = Vec::new();
    for (i, line) in lines.iter().enumerate().skip(1) {
        match parse_row(line, d) {
            Ok(r) => {
                if r.len() != header.len() {
                    findings.push(Finding::new(
                        "COLUMN_COUNT",
                        format!("row {}: {} columns, header has {}", i, r.len(), header.len()),
                    ));
                } else {
                    rows.push(r);
                }
            }
            Err(mut f) => {
                f.message = format!("row {}: {}", i, f.message);
                findings.push(f);
            }
        }
    }
    if findings.is_empty() {
        Ok(Table { header, rows })
    } else {
        Err(findings)
    }
}

fn split_lines(text: &[u8]) -> Vec<&[u8]> {
    let mut lines = Vec::new();
    let mut start = 0;
    for i in 0..text.len() {
        if text[i] == 0x0a {
            lines.push(&text[start..i]);
            start = i + 1;
        }
    }
    if start < text.len() {
        lines.push(&text[start..]);
    }
    lines
}

/// One cell-level difference between a source table and a target table.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffEntry {
    /// The zero-based data-row index (excludes the header).
    pub row: usize,
    /// The column (field) name.
    pub field: String,
    /// The source value at this cell (empty string if the row/column is absent in source).
    pub source: String,
    /// The target value at this cell (empty string if the row/column is absent in target).
    pub target: String,
}

/// The result of a [`diff`]: the differing cells plus structural findings (extra/missing rows or columns).
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffReport {
    /// Per-cell differences, in (row, column) order.
    pub entries: Vec<DiffEntry>,
    /// Structural findings: a row or column present in only one table.
    pub findings: Vec<Finding>,
}

impl DiffReport {
    /// True iff the two tables are identical (no cell differences and no structural findings).
    pub fn is_clean(&self) -> bool {
        self.entries.is_empty() && self.findings.is_empty()
    }
}

/// `KOBOLD.CSV.DIFF.1` -- compare two parsed tables `source` and `target` cell by cell, aligning columns by
/// name. Columns present in only one table, and rows present in only one table, become findings.
pub fn diff(source: &Table, target: &Table) -> DiffReport {
    let mut entries = Vec::new();
    let mut findings = Vec::new();

    // Columns only in source.
    for col in &source.header {
        if !target.header.iter().any(|c| c == col) {
            findings.push(Finding::new(
                "COLUMN_ONLY_IN_SOURCE",
                format!("column {} present in source but not target", col),
            ));
        }
    }
    // Columns only in target.
    for col in &target.header {
        if !source.header.iter().any(|c| c == col) {
            findings.push(Finding::new(
                "COLUMN_ONLY_IN_TARGET",
                format!("column {} present in target but not source", col),
            ));
        }
    }

    // Row count mismatch.
    if source.rows.len() != target.rows.len() {
        findings.push(Finding::new(
            "ROW_COUNT",
            format!("source has {} rows, target has {}", source.rows.len(), target.rows.len()),
        ));
    }

    // Common columns, in source header order.
    let common: Vec<&String> =
        source.header.iter().filter(|c| target.header.iter().any(|t| &t == c)).collect();

    let nrows = source.rows.len().max(target.rows.len());
    for r in 0..nrows {
        let srow = source.rows.get(r);
        let trow = target.rows.get(r);
        for col in &common {
            let sval = srow
                .and_then(|row| column_value(&source.header, row, col))
                .unwrap_or_default();
            let tval = trow
                .and_then(|row| column_value(&target.header, row, col))
                .unwrap_or_default();
            if sval != tval {
                entries.push(DiffEntry {
                    row: r,
                    field: (*col).clone(),
                    source: sval,
                    target: tval,
                });
            }
        }
    }

    DiffReport { entries, findings }
}

/// Look up the value of `col` in `row`, given the table `header` (column alignment by name).
fn column_value(header: &[String], row: &[String], col: &str) -> Option<String> {
    let idx = header.iter().position(|h| h == col)?;
    row.get(idx).cloned()
}

#[cfg(test)]
mod tests {
    use super::*;

    fn table(text: &[u8]) -> Table {
        parse_table(text, &Dialect::csv()).expect("parse table")
    }

    #[test]
    fn identical_tables_are_clean() {
        let a = table(b"ACCT,AMT\nA1,12.50\nA2,0.99\n");
        let report = diff(&a, &a);
        assert!(report.is_clean());
    }

    #[test]
    fn changed_cell_is_reported() {
        let s = table(b"ACCT,AMT\nA1,12.50\n");
        let t = table(b"ACCT,AMT\nA1,99.99\n");
        let report = diff(&s, &t);
        assert_eq!(report.entries.len(), 1);
        assert_eq!(report.entries[0].field, "AMT");
        assert_eq!(report.entries[0].source, "12.50");
        assert_eq!(report.entries[0].target, "99.99");
    }

    #[test]
    fn column_alignment_by_name_not_position() {
        // Same data, columns reordered -> no cell differences.
        let s = table(b"ACCT,AMT\nA1,12.50\n");
        let t = table(b"AMT,ACCT\n12.50,A1\n");
        let report = diff(&s, &t);
        assert!(report.entries.is_empty(), "entries: {:?}", report.entries);
        assert!(report.findings.is_empty());
    }

    #[test]
    fn column_only_in_one_table_is_a_finding() {
        let s = table(b"ACCT,AMT,STATUS\nA1,12.50,OK\n");
        let t = table(b"ACCT,AMT\nA1,12.50\n");
        let report = diff(&s, &t);
        assert!(report.findings.iter().any(|f| f.code == "COLUMN_ONLY_IN_SOURCE"));
    }

    #[test]
    fn row_count_mismatch_is_a_finding() {
        let s = table(b"ACCT,AMT\nA1,12.50\nA2,1.00\n");
        let t = table(b"ACCT,AMT\nA1,12.50\n");
        let report = diff(&s, &t);
        assert!(report.findings.iter().any(|f| f.code == "ROW_COUNT"));
    }
}