dyn_path 1.0.7

A JavaScript-like nested object-like structure non-fallible path access interface. Access your data without serializing it just like you do in your JavaScript projects.
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

use serde_json::{json, Value};

use crate::dyn_access;
#[cfg(feature = "alloc")]
use crate::dyn_path;

const ERROR: &str = "nested value to exist.";

fn map() -> Value {
    json!({
        "very": {
            "nested": [
                "bunch",
                "of",
                "values"
            ],
            "or": {
                "numbers": 50
            }
        }
    })
}

#[test]
pub fn access_types() {
    let map = map();

    let _1 = dyn_access!(map.very);
    let _2 = dyn_access!(map["very"]);

    assert!(_1.is_some());
    assert!(_2.is_some());
}

#[test]
pub fn nested_access() {
    let map = map();

    let _1 = dyn_access!(map.very.nested[0])
        .expect(ERROR);
    let _2 = dyn_access!(map.very.or.numbers)
        .expect(ERROR);

    assert_eq!(_1, "bunch");
    assert_eq!(_2, 50);
}

#[test]
pub fn direct_expression() {
    let vector = (map(), ());
    let _1 = dyn_access!((vector.0).very.nested[1])
        .expect(ERROR);

    assert_eq!(_1, "of");
}

#[cfg(feature = "alloc")]
#[test]
pub fn path_descriptor() {
    let _1 = dyn_path!(very.nested["value"].on.index[1 + 1]);
    let _2 = dyn_path!(very.nested["value"].on.index[1 + 1]);

    assert_eq!(_1, r#"very.nested["value"].on.index[2]"#)
}