amethystate 0.25.0

A state manager for Rust applications
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

use amethystate::store::StorePath;
use amethystate::store::builder::{Backend, StoreBuilder};
use amethystate::{StateScope, amethystate};
use amethystate_test_macros::backends;
#[cfg(target_arch = "wasm32")]
use wasm_bindgen_test::wasm_bindgen_test as test;

#[amethystate(prefix = "ui.window")]
pub struct WindowState {
    #[amestate(default = 1280)]
    pub width: u32,
}

#[amethystate(prefix = "net")]
pub struct NetState {
    #[amestate(path = "listen_port", default = 8080u16)]
    pub port: u16,
}

#[amethystate(as_root)]
pub struct RootState {
    #[amestate(default = 1280)]
    pub width: u32,
}

/// What the compile-time check in `StorePath::from_static` protects, pinned from
/// outside it: the path the attribute writes is the path its levels build, key
/// and all. The two are written by different code - one at expansion time out of
/// string literals, the other at runtime out of the same levels - and a store
/// addresses a value by the second while the macro hands it the first.
#[test]
fn a_prefix_builds_the_path_its_levels_build() {
    let cases = [
        (
            <WindowState as StateScope>::PATH,
            <WindowState as StateScope>::KEY,
            vec!["ui", "window"],
        ),
        (
            <NetState as StateScope>::PATH,
            <NetState as StateScope>::KEY,
            vec!["net"],
        ),
        (
            <RootState as StateScope>::PATH,
            <RootState as StateScope>::KEY,
            vec![],
        ),
    ];

    for (path, key, levels) in cases {
        let built = StorePath::from_segments(&levels);

        assert_eq!(path, built, "levels: {levels:?}");
        assert_eq!(path.to_string(), built.to_string(), "levels: {levels:?}");
        assert_eq!(key, built.to_string(), "levels: {levels:?}");
        assert_eq!(
            path.segments()
                .map(|l| l.as_str().to_string())
                .collect::<Vec<_>>(),
            levels,
            "levels: {levels:?}"
        );
    }
}

/// The separator is what makes a level, so the attribute never grows one out of
/// a name: `ui.window` is two levels and stays two.
#[test]
fn a_written_prefix_keeps_the_levels_it_names() {
    assert_eq!(<WindowState as StateScope>::PATH.len(), 2);
    assert_eq!(<WindowState as StateScope>::KEY, "ui.window");
    assert_ne!(
        <WindowState as StateScope>::KEY,
        StorePath::from_segments(["ui.window"]).to_string(),
        "one level called `ui.window` is a different path"
    );
}

/// A field key names a level under the prefix, and it is checked the same way -
/// which is why a store written by the macro reads back through `StorePath`.
#[backends(all)]
fn a_field_key_names_a_level_under_the_prefix(backend: Backend) {
    let at = amethystate_core::test_utils::TempPath::new("prefix_path_key");
    let store = StoreBuilder::new(&at).backend(backend).build().unwrap();

    let net = NetState::new_with(&store);
    net.port().set(9090);

    assert_eq!(
        store.get::<u16>(["net", "listen_port"]).unwrap(),
        Some(9090),
        "the key names the level, and the field's own name does not"
    );
    assert_eq!(store.get::<u16>(["net", "port"]).unwrap(), None);
}