railroad 0.3.7

A library to create syntax-diagrams as Scalable Vector Graphics
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

use railroad::{
    Debug, Diagram, Empty, End, Node, NodeCollection, NodeGeometry, SimpleEnd, SimpleStart, Start,
    Stylesheet, svg,
};

use crate::common::boxed;

mod common;

#[test]
fn stylesheet_helpers_preserve_theme_and_render_safety() {
    assert_eq!(Stylesheet::Light.to_dark(), Stylesheet::Dark);
    assert_eq!(
        Stylesheet::LightRendersafe.to_dark(),
        Stylesheet::DarkRendersafe
    );
    assert_eq!(Stylesheet::Dark.to_light(), Stylesheet::Light);
    assert_eq!(
        Stylesheet::DarkRendersafe.to_light(),
        Stylesheet::LightRendersafe
    );
    assert!(Stylesheet::Light.is_light());
    assert!(Stylesheet::LightRendersafe.is_light());
    assert!(!Stylesheet::Dark.is_light());
    assert_eq!(Stylesheet::Light.stylesheet(), railroad::DEFAULT_CSS);
}

#[test]
fn node_defaults_and_collection_helpers_follow_the_public_contract() {
    struct LeafNode;

    impl Node for LeafNode {
        fn entry_height(&self) -> i64 {
            3
        }

        fn height(&self) -> i64 {
            9
        }

        fn width(&self) -> i64 {
            15
        }

        fn draw(&self, x: i64, y: i64, h_dir: svg::HDir) -> svg::Element {
            let direction = match h_dir {
                svg::HDir::LTR => "ltr",
                svg::HDir::RTL => "rtl",
            };
            svg::Element::new("leaf")
                .set("data-x", &x)
                .set("data-y", &y)
                .set("data-hdir", direction)
        }
    }

    let geo = LeafNode.compute_geometry();
    assert_eq!(geo.entry_height, 3);
    assert_eq!(geo.height, 9);
    assert_eq!(geo.width, 15);
    assert!(geo.children.is_empty());

    let drawn = LeafNode
        .draw_with_geometry(7, 11, svg::HDir::RTL, &geo)
        .to_string();
    assert!(drawn.contains("<leaf"));
    assert!(drawn.contains("data-hdir=\"rtl\""));

    let mut rendered = String::new();
    let mut renderer = svg::Renderer::new(&mut rendered);
    LeafNode
        .render(&mut renderer, 7, 11, svg::HDir::RTL)
        .unwrap();
    assert!(rendered.contains("data-x=\"7\""));
    assert!(rendered.contains("data-y=\"11\""));
    assert!(rendered.contains("data-hdir=\"rtl\""));

    let nodes: Vec<Box<dyn Node>> = vec![boxed(Start), boxed(SimpleStart), boxed(End)];
    assert_eq!(nodes.iter().max_entry_height(), 10);
    assert_eq!(nodes.iter().max_height_below_entry(), 10);
    assert_eq!(nodes.iter().max_width(), 20);
    assert_eq!(nodes.iter().total_width(), 55);
    assert_eq!(nodes.iter().total_height(), 50);

    let geo = NodeGeometry {
        entry_height: 4,
        height: 9,
        width: 1,
        children: vec![],
    };
    assert_eq!(geo.height_below_entry(), 5);
}

#[test]
fn built_in_primitives_render_distinct_markup() {
    let svg = Diagram::new(railroad::Sequence::new(vec![
        boxed(Start),
        boxed(SimpleStart),
        boxed(Debug::new(4, 10, 12)),
        boxed(SimpleEnd),
        boxed(End),
        boxed(Empty),
    ]))
    .to_string();

    assert!(svg.starts_with("<svg"));
    assert!(svg.contains("class=\"debug\""));
    assert!(svg.contains("stroke: red"));
    assert!(svg.matches("<path").count() >= 4);
    assert_eq!(Empty.entry_height(), 0);
    assert_eq!(Empty.height(), 0);
    assert_eq!(Empty.width(), 0);
}