made-core 0.8.0

Domain core of MADE: entities, value objects, events, ports. No IO.
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

use std::collections::{BTreeMap, BTreeSet};

use crate::value_objects::{CeremonyState, CeremonyTransition, StateId};

/// Cyclic strongly connected components in deterministic state-id order.
pub(super) fn cyclic_components(
    states: &BTreeMap<StateId, CeremonyState>,
    transitions: &[CeremonyTransition],
) -> Vec<BTreeSet<StateId>> {
    let mut assigned = BTreeSet::new();
    let mut components = Vec::new();
    for state_id in states.keys() {
        if assigned.contains(state_id) {
            continue;
        }
        let forward = reachable_from(state_id, transitions);
        let component = forward
            .into_iter()
            .filter(|candidate| reachable_from(candidate, transitions).contains(state_id))
            .collect::<BTreeSet<_>>();
        assigned.extend(component.iter().cloned());
        let self_loop = component.len() == 1
            && transitions
                .iter()
                .any(|transition| transition.from() == state_id && transition.to() == state_id);
        if component.len() > 1 || self_loop {
            components.push(component);
        }
    }
    components
}

fn reachable_from(initial: &StateId, transitions: &[CeremonyTransition]) -> BTreeSet<StateId> {
    let mut reached = BTreeSet::new();
    let mut pending = vec![initial.clone()];
    while let Some(current) = pending.pop() {
        if !reached.insert(current.clone()) {
            continue;
        }
        pending.extend(
            transitions
                .iter()
                .filter(|transition| transition.from() == &current)
                .map(|transition| transition.to().clone()),
        );
    }
    reached
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::value_objects::{CeremonyState, TransitionTrigger};

    fn state(raw: &str) -> StateId {
        StateId::new(raw).unwrap()
    }

    fn edge(from: &str, to: &str) -> CeremonyTransition {
        CeremonyTransition::new(
            state(from),
            state(to),
            TransitionTrigger::new(format!("{from}_{to}")).unwrap(),
            Vec::new(),
        )
        .unwrap()
    }

    #[test]
    fn finds_self_loops_and_multi_state_components_but_not_diamonds() {
        let states = ["a", "b", "c", "d", "e", "f"]
            .into_iter()
            .map(|id| (state(id), CeremonyState::intermediate(state(id))))
            .collect();
        let transitions = vec![
            edge("a", "b"),
            edge("a", "c"),
            edge("b", "d"),
            edge("c", "d"),
            edge("d", "e"),
            edge("e", "d"),
            edge("f", "f"),
        ];

        assert_eq!(
            cyclic_components(&states, &transitions),
            [
                BTreeSet::from([state("d"), state("e")]),
                BTreeSet::from([state("f")])
            ]
        );
    }
}