pipecircuit-visualization 0.0.4

Code-derived architectural visualizations for Pipecircuit programs
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 super::*;
use pipecircuit::{BindingDescription, DeclarationLocation, DescribeBindings, Pipe};
struct Protocol;
impl Pipe for Protocol {
    type In<'a> = &'a [u8];
    type Out<'a> = usize;
}
pipecircuit::pipe_roster! { mod roster {
    /// A client sends data & observes results.
    #[doc = concat!(" Additional ", "detail.")]
    client: super::Protocol,
    worker: super::Protocol
} }
struct Board;
impl Switchboard for Board {
    type From<'a> = roster::From<'a>;
    type To<'a> = roster::To<'a>;
    fn route<'a>(&mut self, from: Self::From<'a>) -> Self::To<'a> {
        match from {
            roster::From::Client(_) => roster::To::Worker(&[]),
            roster::From::Worker(_) => roster::To::Client(&[]),
        }
    }
}
struct FixtureBinding;
impl DescribeBindings for FixtureBinding {
    type Roster = roster::Schema;
    fn describe_bindings(&self) -> impl ExactSizeIterator<Item = BindingDescription> {
        let client = BindingDescription {
            name: "client",
            documentation: &[" Queue <script>alert(1)</script> & \"owned\" data."],
            binding: "Carrier<\"bytes\">",
            driver: "Driver",
            declaration: DeclarationLocation {
                package: "fixture",
                file: "src/example.rs",
                line: 3,
                column: 5,
            },
        };
        [
            client,
            BindingDescription {
                name: "worker",
                ..client
            },
        ]
        .into_iter()
    }
}
#[test]
fn compiled_protocol_metadata_is_ordered_and_preserves_lending_families() -> Result<(), &'static str>
{
    let diagram = ProgramDiagram::<roster::Schema>::for_board::<Board>();
    let [client, worker] = diagram.pipes() else {
        return Err("wrong roster");
    };
    assert_eq!(client.name, "client");
    assert_eq!(worker.name, "worker");
    assert_eq!(client.protocol, worker.protocol);
    assert_eq!(client.input, "&[u8]");
    assert_eq!(client.output, "usize");
    assert!(client.declaration.file.ends_with("program/tests.rs"));
    assert!(client.declaration.line > 0);
    assert_ne!(client.declaration.line, worker.declaration.line);
    assert_eq!(
        client.documentation,
        &[
            " A client sends data & observes results.",
            " Additional detail."
        ]
    );
    let before = diagram.render(DiagramTarget::TextTree);
    assert!(before.contains("runtime routes and reachability are not inferred"));
    let physical = diagram.installed(&FixtureBinding);
    assert_eq!(before, diagram.render(DiagramTarget::TextTree));
    assert!(physical.render(DiagramTarget::TextTree).contains(
        "Transport occupancy, health, remote placement and compatibility are not measured here"
    ));
    for target in [DiagramTarget::MermaidFlowchart, DiagramTarget::GraphvizDot] {
        let rendered = physical.render(target);
        assert!(rendered.contains("installed as"));
        assert!(rendered.contains("src/example.rs:3:5"));
    }
    assert!(
        physical
            .render(DiagramTarget::MermaidFlowchart)
            .contains("Carrier&lt;&quot;bytes&quot;&gt;")
    );
    assert!(
        physical
            .render(DiagramTarget::GraphvizDot)
            .contains("Carrier<\\\"bytes\\\">")
    );
    Ok(())
}

#[test]
fn html_preserves_direction_and_escapes_author_content() {
    let diagram = ProgramDiagram::<roster::Schema>::for_board::<Board>();
    let semantic = diagram.render_html();
    assert!(semantic.contains("Emits to switchboard<code>usize</code>"));
    assert!(semantic.contains("Receives from switchboard<code>&amp;[u8]</code>"));
    assert!(semantic.contains("A client sends data &amp; observes results."));
    assert!(!semantic.contains("id=\"placement\""));
    let physical = diagram.installed(&FixtureBinding).render_html();
    assert!(physical.contains("Show physical installation"));
    assert!(physical.contains("&lt;script&gt;alert(1)&lt;/script&gt;"));
    assert!(!physical.contains("<script>"));
    assert!(physical.contains("Carrier&lt;&quot;bytes&quot;&gt;"));
    assert!(physical.contains("src/example.rs:3:5"));
    assert!(physical.contains("static inspection artifact, not a live monitor"));
}