parlov_output/

lib.rs

//! Output formatters for parlov: terminal table and raw JSON.
//!
//! Two formatters are provided:
//! - [`render_table`]: human-readable terminal table via `comfy-table`.
//! - [`render_json`]: pretty-printed JSON via `serde_json`.

#![deny(clippy::all)]
#![warn(clippy::pedantic)]
#![deny(missing_docs)]

use comfy_table::{Cell, Color, Table};
use parlov_core::{OracleResult, OracleVerdict, Severity};

/// Renders an `OracleResult` as a human-readable terminal table.
///
/// Columns: `Oracle`, `Verdict`, `Severity`, `Evidence`. One row per evidence string.
/// Verdict and severity cells are ANSI-colored by confidence level. When present,
/// label, leaks, and RFC basis are appended as labeled detail rows.
#[must_use]
pub fn render_table(result: &OracleResult) -> String {
    let mut table = Table::new();
    table.set_header(vec!["Oracle", "Verdict", "Severity", "Evidence"]);

    let verdict_cell = verdict_cell(result.verdict);
    let severity_cell = severity_cell(result.severity.as_ref());
    let oracle_label = format!("{:?}", result.class);

    add_evidence_rows(&mut table, &oracle_label, verdict_cell, severity_cell, &result.evidence);
    add_metadata_rows(&mut table, result);

    table.to_string()
}

fn add_evidence_rows(
    table: &mut Table,
    oracle_label: &str,
    verdict_cell: Cell,
    severity_cell: Cell,
    evidence: &[String],
) {
    if evidence.is_empty() {
        table.add_row(vec![
            Cell::new(oracle_label),
            verdict_cell,
            severity_cell,
            Cell::new("—"),
        ]);
        return;
    }

    for (i, ev) in evidence.iter().enumerate() {
        if i == 0 {
            table.add_row(vec![
                Cell::new(oracle_label),
                verdict_cell.clone(),
                severity_cell.clone(),
                Cell::new(ev.as_str()),
            ]);
        } else {
            table.add_row(vec![
                Cell::new(""),
                Cell::new(""),
                Cell::new(""),
                Cell::new(ev.as_str()),
            ]);
        }
    }
}

fn add_metadata_rows(table: &mut Table, result: &OracleResult) {
    if let Some(label) = &result.label {
        add_detail_row(table, "Label", label);
    }
    if let Some(leaks) = &result.leaks {
        add_detail_row(table, "Leaks", leaks);
    }
    if let Some(rfc_basis) = &result.rfc_basis {
        add_detail_row(table, "RFC Basis", rfc_basis);
    }
}

fn add_detail_row(table: &mut Table, key: &str, value: &str) {
    table.add_row(vec![
        Cell::new(""),
        Cell::new(""),
        Cell::new(key),
        Cell::new(value),
    ]);
}

/// Renders an `OracleResult` as a pretty-printed JSON string.
///
/// # Errors
///
/// Returns `Err` if `serde_json` serialization fails, which cannot occur for
/// well-formed `OracleResult` values in practice.
pub fn render_json(result: &OracleResult) -> Result<String, serde_json::Error> {
    serde_json::to_string_pretty(result)
}

fn verdict_cell(verdict: OracleVerdict) -> Cell {
    let (label, color) = match verdict {
        OracleVerdict::Confirmed => ("Confirmed", Color::Red),
        OracleVerdict::Likely => ("Likely", Color::Yellow),
        OracleVerdict::Inconclusive => ("Inconclusive", Color::Blue),
        OracleVerdict::NotPresent => ("NotPresent", Color::Green),
    };
    Cell::new(label).fg(color)
}

fn severity_cell(severity: Option<&Severity>) -> Cell {
    match severity {
        Some(Severity::High) => Cell::new("High").fg(Color::Red),
        Some(Severity::Medium) => Cell::new("Medium").fg(Color::Yellow),
        Some(Severity::Low) => Cell::new("Low").fg(Color::Cyan),
        None => Cell::new("—"),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use parlov_core::{OracleClass, OracleVerdict};

    fn confirmed_with_metadata() -> OracleResult {
        OracleResult {
            class: OracleClass::Existence,
            verdict: OracleVerdict::Confirmed,
            evidence: vec!["403 (baseline) vs 404 (probe)".into()],
            severity: Some(Severity::High),
            label: Some("Authorization-based differential".into()),
            leaks: Some("Resource existence confirmed".into()),
            rfc_basis: Some("RFC 9110 §15.5.4".into()),
        }
    }

    fn not_present_no_metadata() -> OracleResult {
        OracleResult {
            class: OracleClass::Existence,
            verdict: OracleVerdict::NotPresent,
            evidence: vec!["404 (baseline) vs 404 (probe)".into()],
            severity: None,
            label: None,
            leaks: None,
            rfc_basis: None,
        }
    }

    #[test]
    fn table_includes_label_when_present() {
        let table = render_table(&confirmed_with_metadata());
        assert!(table.contains("Authorization-based differential"));
    }

    #[test]
    fn table_includes_leaks_when_present() {
        let table = render_table(&confirmed_with_metadata());
        assert!(table.contains("Resource existence confirmed"));
    }

    #[test]
    fn table_includes_rfc_basis_when_present() {
        let table = render_table(&confirmed_with_metadata());
        assert!(table.contains("RFC 9110 §15.5.4"));
    }

    #[test]
    fn table_omits_label_row_when_none() {
        let table = render_table(&not_present_no_metadata());
        assert!(!table.contains("Label"));
    }

    #[test]
    fn table_omits_leaks_row_when_none() {
        let table = render_table(&not_present_no_metadata());
        assert!(!table.contains("Leaks"));
    }

    #[test]
    fn table_omits_rfc_basis_row_when_none() {
        let table = render_table(&not_present_no_metadata());
        assert!(!table.contains("RFC Basis"));
    }

    #[test]
    fn json_omits_none_metadata_fields() {
        let result = not_present_no_metadata();
        let json = render_json(&result).expect("serialization failed");
        assert!(!json.contains("label"));
        assert!(!json.contains("leaks"));
        assert!(!json.contains("rfc_basis"));
    }

    #[test]
    fn json_includes_some_metadata_fields() {
        let result = confirmed_with_metadata();
        let json = render_json(&result).expect("serialization failed");
        assert!(json.contains("\"label\""));
        assert!(json.contains("\"leaks\""));
        assert!(json.contains("\"rfc_basis\""));
    }
}