chartlet 0.22.0

Compile structured data into deterministic, accessible static charts
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

use super::*;

const POLAR: &str = r#"{"schemaVersion": 1, "type": "polar", "title": "Wind", "width": 600, "height": 460,
    "polar": {"valueLabel": "Hours", "points": [
        {"label": "N", "value": 10}, {"label": "E", "value": 40},
        {"label": "S", "value": 25}, {"label": "W", "value": 0}
    ]}}"#;

fn html(spec: &str) -> String {
    render_json(spec, RenderFormat::Html, &RenderOptions::default())
        .unwrap()
        .content
}

#[test]
fn a_polar_chart_draws_rings_and_a_wedge_for_every_nonzero_value() {
    let output = render_ok(POLAR);
    assert!(output.warnings.is_empty(), "{:?}", output.warnings);
    let svg = &output.content;
    assert_eq!(svg.matches("class=\"chartlet-polar-ring\"").count(), 4);
    // Zero has no wedge: it is the center.
    assert_eq!(svg.matches("class=\"chartlet-polar-bar\"").count(), 3);
    assert!(svg.contains("<title>E: 40</title>"));
    // The largest value is 40: four rings of 10.
    for ring in ["10", "20", "30", "40"] {
        assert!(
            svg.contains(&format!("class=\"chartlet-polar-tick\">{ring}</text>")),
            "{ring}"
        );
    }
    for name in ["N", "E", "S", "W"] {
        assert!(svg.contains(&format!(">{name}</text>")), "{name}");
    }
}

#[test]
fn lollipops_draw_a_stem_and_a_dot() {
    let svg = render_ok(&POLAR.replace(
        "\"valueLabel\"",
        "\"display\": \"lollipops\", \"valueLabel\"",
    ))
    .content;
    assert_eq!(svg.matches("class=\"chartlet-polar-stem\"").count(), 4);
    assert_eq!(svg.matches("class=\"chartlet-polar-dot\"").count(), 4);
    assert_eq!(svg.matches("class=\"chartlet-polar-bar\"").count(), 0);
}

#[test]
fn the_description_and_the_table_name_every_category() {
    let html = html(POLAR);
    assert!(html.contains("Polar chart of 4 categories, from the top clockwise: N, E, S, W. Highest: E (40); lowest: W (0). Hours runs from 0 at the center to 40 at the outer ring."));
    assert!(html.contains("<th scope=\"col\">Category</th><th scope=\"col\">Hours</th>"));
    assert!(html.contains("<th scope=\"row\">S</th><td>25</td>"));
}

#[test]
fn a_crowded_cycle_leaves_out_names_that_would_overlap() {
    let points = (0..60)
        .map(|index| {
            format!(
                "{{\"label\": \"Category {index}\", \"value\": {}}}",
                index % 7 + 1
            )
        })
        .collect::<Vec<_>>()
        .join(",");
    let spec = format!(
        "{{\"schemaVersion\": 1, \"type\": \"polar\", \"title\": \"T\", \"width\": 480, \"height\": 420, \"polar\": {{\"points\": [{points}]}}}}"
    );
    let output = render_ok(&spec);
    assert!(
        output.warnings.iter().any(|w| w.code == "labels_omitted"),
        "{:?}",
        output.warnings
    );
    // Every category stays in the table.
    assert_eq!(
        html(&spec).matches("<th scope=\"row\">Category").count(),
        60
    );
}

#[test]
fn polar_charts_are_validated_by_name() {
    for (from, to, code, path) in [
        (
            "\"value\": 40",
            "\"value\": -4",
            "invalid_value",
            "/polar/points/1/value",
        ),
        (
            "\"label\": \"S\"",
            "\"label\": \"N\"",
            "duplicate_label",
            "/polar/points/2/label",
        ),
        (
            "\"valueLabel\"",
            "\"max\": 30, \"valueLabel\"",
            "value_outside_axis",
            "/polar/points/1/value",
        ),
        (
            "\"valueLabel\"",
            "\"max\": 0, \"valueLabel\"",
            "invalid_axis_range",
            "/polar/max",
        ),
    ] {
        let spec = POLAR.replace(from, to);
        assert_eq!(render_err(&spec), (code, path.to_owned()), "{from}");
    }
}

#[test]
fn a_polar_chart_needs_three_points() {
    let two = r#"{"schemaVersion": 1, "type": "polar", "title": "T", "polar": {"points": [{"label": "A", "value": 1}, {"label": "B", "value": 2}]}}"#;
    assert_eq!(render_err(two), ("empty_data", "/polar/points".to_owned()));
}