dotparser 0.3.0

diagram file parser for Bevy visualization of diagrams
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

use dotparser::{EdgeType, GraphEvent, plantuml};

fn main() {
    let sequence_diagram = r#"
@startuml
actor User
participant "Web Server" as Web
database "Database" as DB

User -> Web: HTTP Request
activate Web
Web -> DB: Query
activate DB
DB --> Web: Results
deactivate DB
Web --> User: HTTP Response
deactivate Web
@enduml
"#;

    match plantuml::parse(sequence_diagram) {
        Ok(events) => {
            println!("Parsed PlantUML sequence diagram as events:");

            // Count participants and messages
            let mut participants = Vec::new();
            let mut messages = Vec::new();

            for event in &events {
                match event {
                    GraphEvent::AddNode {
                        id,
                        label,
                        node_type,
                        ..
                    } => {
                        participants.push((id.clone(), label.clone(), node_type.clone()));
                    }
                    GraphEvent::AddEdge {
                        edge_type: EdgeType::Message { .. },
                        from,
                        to,
                        label,
                        ..
                    } => {
                        messages.push((from.clone(), to.clone(), label.clone()));
                    }
                    _ => {}
                }
            }

            println!("Participants: {}", participants.len());
            for (id, label, node_type) in &participants {
                println!(
                    "  - {} ({:?}): {}",
                    id,
                    node_type,
                    label.as_deref().unwrap_or("no label")
                );
            }

            println!("\nMessages: {}", messages.len());
            for (i, (from, to, label)) in messages.iter().enumerate() {
                println!(
                    "  {}. {} -> {}: {}",
                    i + 1,
                    from,
                    to,
                    label.as_deref().unwrap_or("no label")
                );
            }
        }
        Err(e) => {
            eprintln!("Error parsing PlantUML: {e}");
        }
    }
}