reactive-signals 0.1.0-alpha.4

reactive-signals is a dx-first scope-based fine-grained reactive system.
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

use std::{cell::Cell, rc::Rc};

use crate::{runtimes::ServerRuntime, signal, tests::StringStore};

#[test]
fn test_signal_dep() {
    let sc = ServerRuntime::new_root_scope();

    let num_sig = signal!(sc, 5);
    assert_eq!(num_sig.get(), 5);

    let output = Rc::new(StringStore::new());
    let out = output.clone();

    let _str_sig = signal!(sc, move || out.push(format!("val: {}", num_sig.get())));

    assert_eq!(output.values(), "val: 5");
    num_sig.set(4);

    assert_eq!(output.values(), "val: 5, val: 4");
}

#[test]
fn test_signal_update() {
    use std::cell::RefCell;

    let sc = ServerRuntime::new_root_scope();

    let history = Rc::new(RefCell::new(Vec::<String>::new()));

    let string_sig = signal!(sc, "Hi 1".to_string());
    assert_eq!(string_sig.cloned(), "Hi 1".to_string());

    signal!(sc, clone: history, move || history
        .borrow_mut()
        .push(string_sig.cloned()));

    assert_eq!(history.borrow().join(", "), "Hi 1");

    // no change
    string_sig.set("Hi 1".to_string());
    assert_eq!(history.borrow().join(", "), "Hi 1");

    // change
    string_sig.set("Hi 2".to_string());
    assert_eq!(history.borrow().join(", "), "Hi 1, Hi 2");
}

#[test]
fn test_signal_func_val() {
    let sc = ServerRuntime::new_root_scope();

    let num_sig = signal!(sc, 5);

    let output = Rc::new(StringStore::new());

    let a_sig = signal!(sc, move || format!("a{}", num_sig.get()));
    let b_sig = signal!(sc, move || format!("b{}", num_sig.get()));

    let _str_sig = signal!(sc, clone: output, move || {
        output.push(format!("{}-{}", a_sig.cloned(), b_sig.cloned()))
    });

    num_sig.set(4);

    assert_eq!(output.values(), "a5-b5, a4-b5, a4-b4");
}

#[test]
fn test_signal_func_skip_equal() {
    let sc = ServerRuntime::new_root_scope();

    let num_sig = signal!(sc, 10);

    let a_call = Rc::new(Cell::new(0usize));
    let a_sig = signal!(sc, clone: a_call, move || {
        a_call.inc();
        num_sig.get() + 1
    });

    let b_call = Rc::new(Cell::new(0usize));
    let b_sig = signal!(sc, clone: b_call, move || {
        b_call.inc();
        100
    });

    let c_call = Rc::new(Cell::new(0usize));
    let c_sig = signal!(sc, clone: c_call, move || {
        c_call.inc();
        b_sig.get() + 1
    });

    assert_eq!(a_sig.get(), 11);
    assert_eq!(b_sig.get(), 100);
    assert_eq!(c_sig.get(), 101);

    assert_eq!(a_call.get(), 1);
    assert_eq!(b_call.get(), 1);
    assert_eq!(c_call.get(), 1);

    num_sig.set(20);

    assert_eq!(a_sig.get(), 21);
    assert_eq!(b_sig.get(), 100);
    assert_eq!(c_sig.get(), 101);

    assert_eq!(a_call.get(), 2);
    assert_eq!(b_call.get(), 1);
    assert_eq!(c_call.get(), 1);
}

trait CellIncr {
    fn inc(&self);
}

impl CellIncr for Cell<usize> {
    fn inc(&self) {
        let val = self.get();
        self.set(val + 1)
    }
}