merman-core 0.7.0

Mermaid parser + semantic model (headless; parity-focused).
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
131
132
133
134
135
136
137

use crate::baseline::BaselineRegistryProfile;
use crate::{DetectorRegistry, DiagramRegistry, MermaidConfig, RenderDiagramRegistry};
use std::collections::BTreeSet;

#[test]
fn detector_registries_follow_family_fact_order() {
    let full = DetectorRegistry::pinned_mermaid_baseline_full();
    let full_actual: Vec<_> = full.detector_ids().collect();
    let full_expected: Vec<_> = crate::family::detector_facts(BaselineRegistryProfile::Full)
        .iter()
        .map(|fact| fact.id)
        .collect();
    assert_eq!(full_actual, full_expected);

    let tiny = DetectorRegistry::pinned_mermaid_baseline_tiny();
    let tiny_actual: Vec<_> = tiny.detector_ids().collect();
    let tiny_expected: Vec<_> = crate::family::detector_facts(BaselineRegistryProfile::Tiny)
        .iter()
        .map(|fact| fact.id)
        .collect();
    assert_eq!(tiny_actual, tiny_expected);
}

#[test]
fn fast_detector_respects_family_feature_profile() {
    let mut config = MermaidConfig::empty_object();
    let full = DetectorRegistry::pinned_mermaid_baseline_full();
    assert_eq!(
        full.detect_type_precleaned("mindmap\n  root", &mut config)
            .unwrap(),
        "mindmap"
    );

    let tiny = DetectorRegistry::pinned_mermaid_baseline_tiny();
    let err = tiny
        .detect_type_precleaned("mindmap\n  root", &mut config)
        .unwrap_err();
    assert!(
        err.to_string()
            .contains("No diagram type detected matching given configuration")
    );
}

#[test]
fn parser_registries_follow_family_fact_projection() {
    let semantic = DiagramRegistry::for_pinned_mermaid_baseline();
    let semantic_actual = sorted_set(semantic.parser_ids());
    let semantic_expected = sorted_set(
        crate::family::semantic_parser_facts()
            .iter()
            .map(|fact| fact.id),
    );
    assert_eq!(semantic_actual, semantic_expected);

    let render = RenderDiagramRegistry::for_pinned_mermaid_baseline();
    let render_actual = sorted_set(render.parser_ids());
    let render_expected = sorted_set(
        crate::family::render_parser_facts()
            .iter()
            .map(|fact| fact.id),
    );
    assert_eq!(render_actual, render_expected);
}

#[test]
fn supported_diagram_metadata_is_backed_by_typed_render_projection() {
    assert_eq!(
        crate::supported_diagrams(),
        &[
            "architecture",
            "block",
            "c4",
            "class",
            "er",
            "flowchart",
            "gantt",
            "gitgraph",
            "info",
            "journey",
            "kanban",
            "mindmap",
            "packet",
            "pie",
            "quadrantchart",
            "radar",
            "requirement",
            "sankey",
            "sequence",
            "state",
            "timeline",
            "treemap",
            "venn",
            "xychart",
            "zenuml",
        ]
    );

    let render_ids = sorted_set(
        crate::family::render_parser_facts()
            .iter()
            .map(|fact| fact.id),
    );
    for fact in crate::family::supported_diagram_facts() {
        for parser_id in &fact.render_parser_ids {
            assert!(
                render_ids.contains(parser_id),
                "{} metadata points to missing render parser {parser_id}",
                fact.metadata_id
            );
        }
    }
}

#[test]
fn pinned_non_error_semantic_parsers_are_backed_by_typed_render_parsers() {
    let render_ids = sorted_set(
        crate::family::render_parser_facts()
            .iter()
            .map(|fact| fact.id),
    );

    for fact in crate::family::semantic_parser_facts() {
        if fact.id == "error" {
            continue;
        }

        assert!(
            render_ids.contains(fact.id),
            "built-in semantic parser {} must not rely on JSON render fallback",
            fact.id
        );
    }
}

fn sorted_set(ids: impl IntoIterator<Item = &'static str>) -> BTreeSet<&'static str> {
    ids.into_iter().collect()
}