limu 0.2.1

A diagram layout engine. It reads Mermaid and leaves the drawing to your program.
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

//! Preprocessing checked against what Pele makes of the same cases, in the oracle's parse
//! fixture.

use limu_fixtures::load;
use serde::Deserialize;

use super::{encode_entities, preprocess};
use crate::detect::detect_diagram;
use crate::testing::{Enc, PeleError, same, sorted};

#[derive(Deserialize)]
struct Parse {
    preprocessed: Vec<Case>,
    encoded: Vec<Encoded>,
}

#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Case {
    source: String,
    #[serde(default)]
    text: String,
    with_comments: Option<String>,
    title: Option<String>,
    config: Option<Enc>,
    #[serde(default)]
    line_offset: usize,
    #[serde(rename = "type")]
    diagram: Option<String>,
    mermaid_type: Option<String>,
    error: Option<PeleError>,
}

#[derive(Deserialize)]
struct Encoded {
    text: String,
    encoded: String,
}

#[test]
fn preprocess_matches_pele() {
    let p: Parse = load("parse");
    assert!(
        p.preprocessed.len() >= 1000,
        "only {} cases",
        p.preprocessed.len()
    );
    let mut failed = 0;
    for c in &p.preprocessed {
        let got = preprocess(&c.source, None);
        let ok = match (&got, &c.error) {
            (Err(e), Some(w)) => w.is(e),
            (Ok(got), None) => {
                let found = detect_diagram(&got.text);
                let config = crate::Value::Object(got.config.clone());
                got.text == c.text
                    && got.with_comments == *c.with_comments.as_ref().unwrap_or(&c.text)
                    && got.title == c.title
                    && got.line_offset == c.line_offset
                    && c.config
                        .as_ref()
                        .is_some_and(|w| same(&sorted(&config), &w.0))
                    && found.map(|f| f.diagram.name()) == c.diagram.as_deref()
                    && found.map(|f| f.mermaid_type) == c.mermaid_type.as_deref()
            }
            _ => false,
        };
        if !ok {
            failed += 1;
            if failed <= 10 {
                eprintln!(
                    "preprocess({:?})\n got {got:?}\nPele text {:?}, with comments {:?}, title {:?}, config {:?}, offset {}, type {:?}, error {:?}",
                    c.source,
                    c.text,
                    c.with_comments,
                    c.title,
                    c.config,
                    c.line_offset,
                    c.diagram,
                    c.error
                );
            }
        }
    }
    assert_eq!(failed, 0, "{failed} of {} differ", p.preprocessed.len());
}

#[test]
fn encode_entities_matches_pele() {
    let p: Parse = load("parse");
    assert!(p.encoded.len() >= 1000, "only {} cases", p.encoded.len());
    for c in &p.encoded {
        assert_eq!(
            encode_entities(&c.text, None),
            c.encoded,
            "encode_entities({:?})",
            c.text
        );
    }
}