trellis-core 0.1.2

Deterministic reactive resource graph core types.
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
140
141
142
143
144
145
146
147
148
149
150
151

use std::collections::BTreeSet;

use trellis_core::{
    AuditEvent, CollectionDiffKind, DependencyList, Graph, OutputFrameKindTrace,
    ResourceCommandKind, ResourceKey, ResourcePlan, ResourceTransitionPolicy, StagedInputOutcome,
};

#[derive(Clone, Debug, Eq, PartialEq)]
enum Command {
    Open(String),
}

fn members(values: &[&str]) -> BTreeSet<String> {
    values.iter().map(|value| (*value).to_owned()).collect()
}

fn key(value: &str) -> ResourceKey {
    ResourceKey::new(format!("resource:{value}"))
}

#[test]
fn transaction_trace_records_stable_structural_facts() {
    let mut graph = Graph::<Command, String>::new_with_command_type();
    let mut tx = graph.begin_transaction().unwrap();
    let scope = tx.create_scope("scope").unwrap();
    let source = tx.input::<BTreeSet<String>>("source").unwrap();
    let mode = tx.input::<String>("mode").unwrap();
    tx.set_input(mode, "initial".to_owned()).unwrap();
    tx.set_input(source, members(&["b", "a"])).unwrap();
    let count = tx
        .derived(
            "count",
            DependencyList::new([source.id()]).unwrap(),
            move |ctx| Ok(ctx.input(source)?.len()),
        )
        .unwrap();
    let collection = tx
        .set_collection(
            "demand",
            DependencyList::new([source.id()]).unwrap(),
            move |ctx| Ok(ctx.input(source)?.clone()),
        )
        .unwrap();
    tx.set_resource_planner(collection, scope, move |ctx| {
        let mut plan = ResourcePlan::new();
        for added in &ctx.diff().added {
            plan.open(
                key(&added.value),
                ctx.scope(),
                Command::Open(added.value.clone()),
            );
        }
        Ok(plan)
    })
    .unwrap();
    let first_output = tx
        .materialized_output(
            "first",
            scope,
            DependencyList::new([collection.id(), mode.id()]).unwrap(),
            move |ctx| {
                Ok(format!(
                    "{}:{}",
                    ctx.input(mode)?,
                    ctx.set_collection(collection)?.len()
                ))
            },
        )
        .unwrap();
    let second_output = tx
        .materialized_output(
            "second",
            scope,
            DependencyList::new([count.id()]).unwrap(),
            move |ctx| Ok(format!("count:{}", ctx.derived(count)?)),
        )
        .unwrap();
    let result = tx.commit().unwrap();
    drop(tx);

    let trace = result.trace();
    assert_eq!(
        trace
            .staged_input_changes
            .iter()
            .map(|change| (change.node, change.outcome))
            .collect::<Vec<_>>(),
        vec![
            (source.id(), StagedInputOutcome::Changed),
            (mode.id(), StagedInputOutcome::Changed),
        ]
    );
    assert_eq!(
        trace.dirty_roots,
        vec![source.id(), mode.id(), count.id(), collection.id()]
    );
    assert_eq!(trace.recomputed_derived_nodes, vec![count.id()]);
    assert_eq!(trace.changed_derived_nodes, vec![count.id()]);
    assert_eq!(trace.recomputed_collection_nodes, vec![collection.id()]);
    assert_eq!(trace.changed_collection_nodes, vec![collection.id()]);

    assert_eq!(trace.collection_diffs.len(), 1);
    assert_eq!(trace.collection_diffs[0].node, collection.id());
    assert_eq!(trace.collection_diffs[0].kind, CollectionDiffKind::Set);
    assert_eq!(trace.collection_diffs[0].added, 2);
    assert_eq!(trace.collection_diffs[0].removed, 0);
    assert_eq!(trace.collection_diffs[0].unchanged, 0);

    assert_eq!(
        trace
            .resource_commands
            .iter()
            .map(|command| (&command.key, command.kind, command.transition))
            .collect::<Vec<_>>(),
        vec![
            (
                &key("a"),
                ResourceCommandKind::Open,
                ResourceTransitionPolicy::Open
            ),
            (
                &key("b"),
                ResourceCommandKind::Open,
                ResourceTransitionPolicy::Open
            ),
        ]
    );
    assert_eq!(
        trace
            .output_frames
            .iter()
            .map(|frame| (frame.output_key, frame.kind))
            .collect::<Vec<_>>(),
        vec![
            (first_output.key(), OutputFrameKindTrace::Baseline),
            (second_output.key(), OutputFrameKindTrace::Baseline),
        ]
    );
    assert_eq!(trace.scope_events.len(), 1);
    assert_eq!(
        trace
            .audit_log
            .iter()
            .filter_map(|entry| match entry.event {
                AuditEvent::InputChanged(node) => Some(node),
                _ => None,
            })
            .collect::<Vec<_>>(),
        vec![source.id(), mode.id()]
    );
}