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

use texform::{Document, ParseConfig, ParseDiagnostic, ParseResult, Parser, Span};

fn parser() -> Parser {
    Parser::builder()
        .packages(&["base"])
        .build()
        .expect("parser should build")
}

#[test]
fn parse_success_has_document_without_diagnostics() {
    let output = parser().parse_with(r"\frac{a}{b}", &ParseConfig::STRICT);

    assert!(output.document().is_some());
    assert!(output.diagnostics().is_empty());
    assert!(!output.has_errors());
    let (document, diagnostics) = output
        .try_into_document()
        .expect("document should be editable");
    assert!(!document.has_errors());
    assert!(diagnostics.is_empty());
}

#[test]
fn hard_failure_has_no_document_but_is_not_an_error_tree() {
    let output = parser().parse_with(r"\unknowncmd", &ParseConfig::STRICT);

    assert!(output.document().is_none());
    assert!(!output.diagnostics().is_empty());
    assert!(!output.has_errors());

    let error = output
        .try_into_document()
        .expect_err("strict failure should not produce a document");
    assert!(error.document().is_none());
    assert!(!error.diagnostics().is_empty());
}

#[test]
fn editable_tree_with_diagnostics_is_returned_with_diagnostics() {
    // The parser currently routes recoverable diagnostics through Error nodes.
    // Build this state directly to lock the public result contract: diagnostics
    // alone must not make an otherwise editable document read-only.
    let output = ParseResult::__from_parts_for_tests(
        Some(Document::new()),
        vec![ParseDiagnostic::new(
            "diagnostic-only warning",
            Span { start: 0, end: 0 },
            Vec::new(),
            None,
            Vec::new(),
        )],
    );

    assert!(output.document().is_some());
    assert!(!output.diagnostics().is_empty());
    assert!(!output.has_errors());

    let (document, diagnostics) = output
        .try_into_document()
        .expect("diagnostics alone should not block an editable tree");
    assert!(!document.has_errors());
    assert!(!diagnostics.is_empty());
}

#[test]
fn recovered_error_tree_is_read_only_and_returned_in_error() {
    let output = parser().parse_with("{", &ParseConfig::LENIENT);

    assert!(output.document().is_some());
    assert!(!output.diagnostics().is_empty());
    assert!(output.has_errors());

    let error = output
        .try_into_document()
        .expect_err("read-only error tree should not become editable");
    assert!(error.document().is_some());
    assert!(
        error
            .document()
            .expect("document should be retained")
            .has_errors()
    );
    assert!(!error.diagnostics().is_empty());
}