miniconf 0.20.1

Serialize/deserialize/access reflection for trees
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

use miniconf::{Indices, KeyError, Path, Shape, Short, Track, Tree, TreeSchema};
mod common;

#[test]
fn borrowed() {
    let mut a = "";
    miniconf::json_core::set(&mut a, "", "\"foo\"".as_bytes()).unwrap();
    assert_eq!(a, "foo");
}

#[cfg(feature = "postcard")]
#[test]
fn borrowed_u8() {
    use postcard::{de_flavors::Slice, to_slice};

    let mut a = &[0u8; 0][..];
    let mut buf = [0u8; 32];
    let data = to_slice(&[1u8, 2, 3][..], &mut buf).unwrap();
    miniconf::postcard::set_by_key(&mut a, [0; 0], Slice::new(data)).unwrap();
    assert_eq!(a, &[1, 2, 3]);
}

#[derive(Tree, Default)]
struct Inner {
    inner: f32,
}

#[derive(Tree, Default)]
struct Settings {
    a: f32,
    b: i32,
    c: Inner,
}

#[test]
fn meta() {
    const SHAPE: Shape = Settings::SCHEMA.shape();
    assert_eq!(SHAPE.max_depth, 2);
    assert_eq!(SHAPE.max_length("/"), "/c/inner".len());
    assert_eq!(SHAPE.count.get(), 3);
}

#[test]
fn path() {
    for (keys, path, depth, leaf) in [
        (&[1usize][..], "/b", 1, true),
        (&[2, 0], "/c/inner", 2, true),
        (&[2], "/c", 1, false),
        (&[], "", 0, false),
    ] {
        let s = Settings::SCHEMA
            .transcode::<Short<Track<Path<String, '/'>>>>(keys)
            .unwrap();
        assert_eq!(depth, s.inner().depth());
        assert_eq!(leaf, s.leaf());
        assert_eq!(s.inner().inner().as_ref(), path);
    }
}

#[test]
fn indices() {
    for (keys, idx, leaf) in [
        ("", &[][..], false),
        ("/b", &[1], true),
        ("/c/inner", &[2, 0], true),
        ("/c", &[2], false),
    ] {
        let indices = Settings::SCHEMA
            .transcode::<Short<Indices<[usize; 2]>>>(Path::<_, '/'>(keys))
            .unwrap();
        println!("{keys} {indices:?}");
        assert_eq!(indices.leaf(), leaf);
        assert_eq!(indices.inner().as_ref(), idx);
    }
    let indices = Option::<i8>::SCHEMA
        .transcode::<Short<Indices<[usize; 1]>>>([0usize; 0])
        .unwrap();
    assert_eq!(indices.inner().as_ref(), [0usize; 0]);
    assert_eq!(indices.leaf(), true);
    assert_eq!(indices.inner().len(), 0);

    let mut it = [0usize; 4].into_iter();
    assert_eq!(
        Settings::SCHEMA.transcode::<Indices<[usize; 2]>>(&mut it),
        Err(KeyError::TooLong.into())
    );
    assert_eq!(it.count(), 2);
}

#[test]
fn tuple() {
    type T = (u32, (i32, u8), [u16; 3]);
    let paths = common::paths::<T, 3>();
    assert_eq!(paths.len(), 6);
    let mut s: T = Default::default();
    for p in paths {
        common::set_get(&mut s, p.as_str(), b"9");
    }
    assert_eq!(s, (9, (9, 9), [9; 3]));
}

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

    let c: RefCell<i32> = Default::default();
    let mut r = &c;
    common::set_get(&mut r, "", b"9");
}