trellis-core 0.1.0

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

use std::collections::BTreeMap;

use trellis_core::{DependencyList, Graph, GraphError, NodeKind};

#[test]
fn dependencies_are_inspectable_and_ordered() {
    let mut graph = Graph::new();

    let mut tx = graph.begin_transaction().unwrap();
    let input = tx.input::<String>("input").unwrap();
    let derived = tx
        .derived::<usize>(
            "derived",
            DependencyList::new([input.id()]).unwrap(),
            |_| Ok(0),
        )
        .unwrap();
    let collection = tx
        .collection::<String, usize>(
            "collection",
            DependencyList::new([input.id(), derived.id()]).unwrap(),
            |_| Ok(BTreeMap::new()),
        )
        .unwrap();
    tx.commit().unwrap();
    drop(tx);

    assert_eq!(
        graph.dependencies(derived).unwrap().as_slice(),
        &[input.id()]
    );
    assert_eq!(
        graph.dependencies(collection).unwrap().as_slice(),
        &[input.id(), derived.id()]
    );
    assert_eq!(graph.node_meta(derived).unwrap().kind(), NodeKind::Derived);
    assert_eq!(
        graph.node_meta(collection).unwrap().kind(),
        NodeKind::Collection
    );
}

#[test]
fn dependency_list_rejects_duplicate_nodes() {
    let mut graph = Graph::new();
    let mut tx = graph.begin_transaction().unwrap();
    let input = tx.input::<String>("input").unwrap();

    let error = DependencyList::new([input.id(), input.id()]).unwrap_err();
    tx.commit().unwrap();

    assert_eq!(error, GraphError::DuplicateDependency(input.id()));
}

#[test]
fn graph_rejects_unknown_dependency() {
    let mut other_graph = Graph::new();
    let mut other_tx = other_graph.begin_transaction().unwrap();
    let unknown = other_tx.input::<String>("foreign").unwrap();
    other_tx.commit().unwrap();
    drop(other_tx);

    let mut graph = Graph::new();
    let mut tx = graph.begin_transaction().unwrap();
    let error = tx
        .derived::<usize>(
            "derived",
            DependencyList::new([unknown.id()]).expect("foreign id is still typed"),
            |_| Ok(0),
        )
        .unwrap_err();

    assert_eq!(error, GraphError::SelfDependency(unknown.id()));

    let known = tx.input::<String>("known").unwrap();
    let mut other_tx = other_graph.begin_transaction().unwrap();
    let _foreign_two = other_tx.input::<String>("foreign_two").unwrap();
    let _foreign_three = other_tx.input::<String>("foreign_three").unwrap();
    let unknown = other_tx.input::<String>("foreign_four").unwrap();
    other_tx.commit().unwrap();
    drop(other_tx);
    let error = tx
        .derived::<usize>(
            "derived",
            DependencyList::new([known.id(), unknown.id()]).unwrap(),
            |_| Ok(0),
        )
        .unwrap_err();

    assert_eq!(error, GraphError::UnknownNode(unknown.id()));
}