attr 0.1.0

`attr` is a library to provide external access to a datastructure through a typed path object, using all type information known about the data structure at hand.
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

extern crate serde_json;
extern crate attr;

mod serde;

use serde::*;

use serde_json as json;
use serde_json::value::Value;

use attr::Attr;
use attr::InsecureAttr;
use attr::InsecureIndexableAttr;

use attr::retrieve_insecure;
use attr::Traverse;

#[test]
fn test_attr() {
    let obj: Value = json::from_str(r#"{"x": 1, "y": [1,2,3] }"#).unwrap();

    let attr_x = SerdeAttribute::new("x");
    let attr_y = SerdeAttribute::new("y");

    assert_eq!(attr_x.get(&obj).unwrap(), &Value::U64(1));
    assert_eq!(attr_y.at(&obj, 1).unwrap(), &Value::U64(2));
}

#[test]
fn test_multiple_attr() {
    let obj: Value = json::from_str(r#"{"x": 1, "y": { "z": 1 } }"#).unwrap();

    let attr_z = SerdeAttribute::new("z");
    let attr_y = SerdeAttribute::new("y");

    let path = retrieve_insecure(attr_z).try(attr_y);

    assert_eq!(path.traverse(&obj), Ok(&Value::U64(1)));
}

struct Foo {
    inner: Value
}

#[test]
fn test_combine() {
    use serde_json::value::Value;

    #[derive(Default)]
    struct Inner;

    impl<'a> Attr<&'a Foo> for Inner {
        type Output = &'a Value;

        fn get(&self, i: &'a Foo) -> &'a Value {
            &i.inner
        }

        fn name(&self) -> &'static str {
            "inner"
        }
    }

    let val: Value = json::from_str(r#"{"x": 1}"#).unwrap();
    let obj = Foo { inner: val };
    let attr = SerdeAttribute::new("x");

    let path = retrieve_insecure(attr).from(Inner);

    assert_eq!(path.traverse(&obj), Ok(&Value::U64(1)));
}