stateforward-sml-macros 1.0.0

Procedural macros for the sml.rs transition-table DSL
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

use crate::parser::event::EventKind;
use crate::parser::*;

/// Generates DOT syntax for a state-machine diagram with Graphviz.
pub fn generate_diagram(sm: &ParsedStateMachine) -> String {
    let transitions = &sm.states_events_mapping;

    let mut diagram_states = sm.states.iter().map(|s| s.0).collect::<Vec<&String>>();
    diagram_states.sort();
    let diagram_states = diagram_states.into_iter();
    let mut diagram_events = vec![];
    let mut diagram_transitions = vec![];
    for (state, event) in transitions {
        for eventmapping in event.values() {
            for transition in &eventmapping.transitions {
                let (event_id, event_label) = match eventmapping.event_kind {
                    EventKind::Normal => {
                        let event = eventmapping.event.to_string();
                        (event.clone(), event)
                    }
                    EventKind::Unexpected if eventmapping.event_wildcard => {
                        ("unexpected_any".to_string(), "unexpected<_>".to_string())
                    }
                    EventKind::Unexpected => (
                        format!("unexpected_{}", eventmapping.event),
                        format!("unexpected<{}>", eventmapping.event),
                    ),
                    EventKind::Completion => (
                        format!("completion_{}", eventmapping.event),
                        format!("completion<{}>", eventmapping.event),
                    ),
                    EventKind::Entry => ("on_entry".to_string(), "on_entry<_>".to_string()),
                    EventKind::Exit => ("on_exit".to_string(), "on_exit<_>".to_string()),
                    EventKind::Exception => ("exception".to_string(), "exception<_>".to_string()),
                };
                diagram_events.push((
                    event_id.clone(),
                    event_label,
                    transition
                        .guard
                        .as_ref()
                        .map(|i| i.to_string())
                        .unwrap_or_else(|| "_".to_string()),
                    transition
                        .action
                        .iter()
                        .chain(transition.additional_actions.iter())
                        .map(|action| action.ident.to_string())
                        .collect::<Vec<_>>()
                        .join(","),
                ));
                diagram_transitions.push((state, transition.out_state.to_string(), event_id));
            }
        }
    }
    // Sorting is needed to ensure stable (ie not changing between runs of
    // the same sm code) dot file contents. This is needed to ensure stable
    // hash sum, which is used to name unnamed diagrams. If done without sorting,
    // the output is polluted with lots of similar svg files with different names.
    // This ensures that new files will only occur upon changing the structure of the code.
    diagram_events.sort();
    diagram_transitions.sort();

    let state_string = diagram_states
        .map(|s| {
            format!(
                "\t{} [shape=box color=\"red\" fillcolor=\"#ffbb33\" style=filled]",
                s
            )
        })
        .collect::<Vec<String>>();
    let event_string = diagram_events
        .iter()
        .map(|s| {
            format!(
                "\t{0} [shape=box label=\"{1}\\n[{2}] / {3}\"]",
                s.0, s.1, s.2, s.3
            )
        })
        .collect::<Vec<String>>();
    let transition_string = diagram_transitions
        .iter()
        .map(|t| format!("\t{0} -> {1} [color=blue label={2}];", t.0, t.1, t.2))
        .collect::<Vec<String>>();

    format!(
        "digraph G {{
    rankdir=\"LR\";
    node [fontname=Arial];
    edge [fontname=Arial];
    s [shape=circle size=2 color=\"black\" style=filled]
    
    s -> {}
{}

{}

{}
}}",
        sm.starting_state,
        state_string.join("\n"),
        event_string.join("\n"),
        transition_string.join("\n")
    )
}

#[cfg(test)]
mod tests {
    use super::generate_diagram;
    use crate::parser::{state_machine::StateMachine, ParsedStateMachine};
    use syn::parse_str;

    #[test]
    fn diagram_distinguishes_completion_and_unexpected_triggers() {
        let parsed: StateMachine = parse_str(
            "transitions: {
                *Idle + Start = Step,
                Step + completion<Start> = Done,
                Done + unexpected<Reset> = Error,
                Done + unexpected<_> = Error
            }",
        )
        .unwrap();
        let machine = ParsedStateMachine::new(parsed).unwrap();
        let diagram = generate_diagram(&machine);

        assert!(diagram.contains("completion<Start>"));
        assert!(diagram.contains("unexpected<Reset>"));
        assert!(diagram.contains("unexpected<_>"));
    }
}