ara-core 0.1.2

Shared parsing, normalization, and DAG layout for the ARA viewer runtime.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Diagnostics produced by parsing/validation.
//!
//! A [`Diagnostic`] carries a **logical** path (e.g. `nodes[N07].evidence[0]`),
//! not a source `line:column` — `serde-saphyr` does not expose reliable spans
//! through serde, so line numbers are intentionally not promised.

use serde::Serialize;

/// Severity of a diagnostic.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum Severity {
    Error,
    Warning,
}

impl std::fmt::Display for Severity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Severity::Error => f.write_str("error"),
            Severity::Warning => f.write_str("warning"),
        }
    }
}

/// A single diagnostic: severity, logical path, and message.
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct Diagnostic {
    pub severity: Severity,
    pub path: String,
    pub message: String,
}

impl std::fmt::Display for Diagnostic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}: {}", self.severity, self.path, self.message)
    }
}

/// The outcome of a parse: separated errors and warnings.
///
/// A parse "succeeds" (`is_ok`) when there are no errors — warnings do not
/// block success but **must** still be surfaced by callers.
#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct ParseReport {
    errors: Vec<Diagnostic>,
    warnings: Vec<Diagnostic>,
}

impl ParseReport {
    /// Records an error.
    pub(crate) fn error(&mut self, path: impl Into<String>, message: impl Into<String>) {
        self.errors.push(Diagnostic {
            severity: Severity::Error,
            path: path.into(),
            message: message.into(),
        });
    }

    /// Records a warning.
    pub(crate) fn warn(&mut self, path: impl Into<String>, message: impl Into<String>) {
        self.warnings.push(Diagnostic {
            severity: Severity::Warning,
            path: path.into(),
            message: message.into(),
        });
    }

    /// All errors, in the order they were recorded.
    pub fn errors(&self) -> &[Diagnostic] {
        &self.errors
    }

    /// All warnings, in the order they were recorded.
    pub fn warnings(&self) -> &[Diagnostic] {
        &self.warnings
    }

    /// True when there are no errors (warnings are allowed).
    pub fn is_ok(&self) -> bool {
        self.errors.is_empty()
    }
}

impl std::fmt::Display for ParseReport {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        for d in &self.errors {
            writeln!(f, "{d}")?;
        }
        for d in &self.warnings {
            writeln!(f, "{d}")?;
        }
        write!(
            f,
            "{} error(s), {} warning(s)",
            self.errors.len(),
            self.warnings.len()
        )
    }
}

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

    #[test]
    fn ok_and_accessors() {
        let mut r = ParseReport::default();
        assert!(r.is_ok());
        r.warn("document", "empty");
        assert!(r.is_ok()); // warnings don't block
        assert_eq!(r.warnings().len(), 1);
        r.error("nodes[N01]", "duplicate node id");
        assert!(!r.is_ok());
        assert_eq!(r.errors().len(), 1);
    }

    #[test]
    fn diagnostic_display() {
        let d = Diagnostic {
            severity: Severity::Error,
            path: "nodes[N07].evidence[0]".into(),
            message: "unknown claim".into(),
        };
        assert_eq!(
            d.to_string(),
            "error: nodes[N07].evidence[0]: unknown claim"
        );
    }
}