texform 0.1.0

LaTeX formula parser, editor, and normalizer — the public TeXForm facade
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

use crate::Document;
use crate::ParseDiagnostic;

#[derive(Debug, Clone)]
pub struct ParseResult {
    document: Option<Document>,
    diagnostics: Vec<ParseDiagnostic>,
}

impl ParseResult {
    pub(crate) fn from_core(result: texform_core::parse::ParseResult) -> Self {
        let (document, diagnostics) = result.into_parts();
        Self {
            document: document.map(Document::from_core),
            diagnostics,
        }
    }

    #[doc(hidden)]
    pub fn __from_parts_for_tests(
        document: Option<Document>,
        diagnostics: Vec<ParseDiagnostic>,
    ) -> Self {
        Self {
            document,
            diagnostics,
        }
    }

    pub fn document(&self) -> Option<&Document> {
        self.document.as_ref()
    }

    pub fn diagnostics(&self) -> &[ParseDiagnostic] {
        self.diagnostics.as_slice()
    }

    pub fn into_diagnostics(self) -> Vec<ParseDiagnostic> {
        self.diagnostics
    }

    pub fn has_errors(&self) -> bool {
        self.document.as_ref().is_some_and(Document::has_errors)
    }

    pub fn try_into_document(self) -> Result<(Document, Vec<ParseDiagnostic>), ParseError> {
        match (self.document, self.diagnostics) {
            (Some(document), diagnostics) if !document.has_errors() => Ok((document, diagnostics)),
            (document, diagnostics) => Err(ParseError {
                document: document.map(Box::new),
                diagnostics,
            }),
        }
    }

    pub fn into_parts(self) -> (Option<Document>, Vec<ParseDiagnostic>) {
        (self.document, self.diagnostics)
    }
}

#[derive(Debug, Clone)]
pub struct ParseError {
    pub document: Option<Box<Document>>,
    pub diagnostics: Vec<ParseDiagnostic>,
}

impl ParseError {
    pub fn diagnostics(&self) -> &[ParseDiagnostic] {
        self.diagnostics.as_slice()
    }

    pub fn document(&self) -> Option<&Document> {
        self.document.as_deref()
    }

    pub fn into_diagnostics(self) -> Vec<ParseDiagnostic> {
        self.diagnostics
    }

    pub fn into_parts(self) -> (Option<Document>, Vec<ParseDiagnostic>) {
        (self.document.map(|document| *document), self.diagnostics)
    }
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if self.document.is_some() {
            f.write_str("parse produced an incomplete document")
        } else {
            f.write_str("parse produced no document")
        }
    }
}

impl std::error::Error for ParseError {}

impl From<texform_core::parse::ParseError> for ParseError {
    fn from(error: texform_core::parse::ParseError) -> Self {
        let (document, diagnostics) = error.into_parts();
        Self {
            document: document.map(Document::from_core).map(Box::new),
            diagnostics,
        }
    }
}