d2-rs 0.1.5

The d2-rs command-line tool, a Rust port of D2's d2cli package.
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
138
139

use super::*;
use d2_rs_core::stable_sort::StableSort;

#[test]
fn requested_target_trace_survives_unused_leaf_hashes() {
    for requested in [false, true] {
        let calls = std::cell::Cell::new(0);
        let own = diagnostic_hash_input(
            || {
                calls.set(calls.get() + 1);
                vec![42]
            },
            requested,
        );
        assert_eq!(calls.get(), usize::from(requested));
        assert_eq!(own(), vec![42]);
        assert_eq!(calls.get(), 1);
    }
    let calls = std::cell::Cell::new(0);
    let _unused_leaf = diagnostic_hash_input(
        || {
            calls.set(calls.get() + 1);
            vec![42]
        },
        true,
    );
    assert_eq!(calls.get(), 1);
}

#[test]
fn planned_svg_preserves_direct_render_bytes_and_target_selection() {
    for source in [
        "a -> b\n",
        "a\nlayers: {empty: {}; one: {b; layers: {two: {c}}}}\nscenarios: {other: {d}}\n",
        "layers: {\"a.b\": {x; steps: {next: {y}}}}\n",
    ] {
        let plan = source_board_plan(source.as_bytes(), "-").unwrap();
        for target in ["", "*"].into_iter().chain(
            plan.all_targets
                .iter()
                .flat_map(|target| [target.clone(), format!("{target}.*")])
                .collect::<Vec<_>>()
                .iter()
                .map(String::as_str),
        ) {
            let args = vec![
                "--engine=dagre".into(),
                "--bundle=false".into(),
                format!("--target={target}"),
            ];
            let expected = render_source_partial(source.as_bytes(), &args);
            let planned = render_source_partial_with_board_targets(
                source.as_bytes(),
                &args,
                Some(&plan.all_targets),
            );
            assert_eq!(planned, expected, "{target}: {source}");
        }
    }
}

// Manual stage profile for the workload named by the performance brief.
// It also compares the complete SVG bytes on every old/new paired render.
#[test]
#[ignore = "set D2_RS_PROFILE_SOURCE to a source file; run with --nocapture"]
fn profile_svg_source_stages() {
    let path = std::env::var("D2_RS_PROFILE_SOURCE").expect("source path");
    let source = std::fs::read(&path).unwrap();
    let args = vec![
        format!("--path={path}"),
        "--engine=dagre".into(),
        "--bundle=false".into(),
    ];
    let source_args = extract_render_options(&args).unwrap().0;
    let plan = source_board_plan(&source, &path).unwrap();
    let mut samples = BTreeMap::<&str, Vec<f64>>::new();
    for iteration in 0..21 {
        macro_rules! measure {
            ($name:literal, $body:expr) => {{
                let started = std::time::Instant::now();
                let value = $body;
                let elapsed = started.elapsed().as_secs_f64() * 1000.0;
                if iteration > 0 {
                    samples.entry($name).or_default().push(elapsed);
                }
                value
            }};
        }
        measure!("source_config", source_config(&source, &path).unwrap());
        measure!("board_plan", source_board_plan(&source, &path).unwrap());
        let SourceRenderLayout {
            layout: (graph, result, labels, styles),
            target_metadata,
        } = measure!(
            "layout",
            source_render_layout_with_theme(&source, &source_args, None, false).unwrap()
        );
        // Metadata is now produced by layout's existing compilation.
        measure!("hash_metadata", target_metadata.unwrap());
        measure!(
            "own_hash_input",
            d2_rs_render::target_hash_input(
                &graph,
                &result,
                &labels,
                &styles,
                &RenderOptions::default(),
                false,
            )
        );
        // Alternate the pair's order to reduce drift bias.
        let fallback = || render_source_partial(&source, &args).unwrap();
        let planned = || {
            render_source_partial_with_board_targets(&source, &args, Some(&plan.all_targets))
                .unwrap()
        };
        let (before, after) = if iteration % 2 == 0 {
            (
                measure!("render_fallback", fallback()),
                measure!("render_planned", planned()),
            )
        } else {
            let after = measure!("render_planned", planned());
            (measure!("render_fallback", fallback()), after)
        };
        assert_eq!(after, before);
    }
    let medians: BTreeMap<_, _> = samples
        .iter_mut()
        .map(|(name, times)| {
            times.stable_sort_by(f64::total_cmp);
            (*name, (times[9] + times[10]) / 2.0)
        })
        .collect();
    println!(
        "SOURCE_PROFILE {}",
        serde_json::json!({"median_ms":medians,"samples":samples})
    );
}