ron 0.10.0

Rusty Object Notation
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
122
123
124
125
126
127
128
129

use ron::ser::{path_meta::Field, PrettyConfig};

#[test]
fn serialize_field() {
    #[derive(serde::Serialize)]
    enum PetKind {
        Isopod,
    }

    #[derive(serde::Serialize)]
    struct Pet {
        name: &'static str,
        age: u8,
        kind: PetKind,
    }

    #[derive(serde::Serialize)]
    struct Person {
        name: &'static str,
        age: u8,
        knows: Vec<usize>,
        pet: Option<Pet>,
    }

    let value = (
        Person {
            name: "Walter",
            age: 43,
            knows: vec![0, 1],
            pet: None,
        },
        vec![
            Person {
                name: "Alice",
                age: 29,
                knows: vec![1],
                pet: Some(Pet {
                    name: "Herbert",
                    age: 7,
                    kind: PetKind::Isopod,
                }),
            },
            Person {
                name: "Bob",
                age: 29,
                knows: vec![0],
                pet: None,
            },
        ],
    );

    let mut config = PrettyConfig::default();

    config
        .path_meta
        .get_or_insert_with(Field::empty)
        .build_fields(|fields| {
            fields
                .field("age")
                .with_doc("0@age (person)\nmust be within range 0..256");
            fields
                .field("knows")
                .with_doc("0@knows (person)\nmust be list of valid person indices");
            fields.field("pet").build_fields(|fields| {
                fields
                    .field("age")
                    .with_doc("1@age (pet)\nmust be valid range 0..256");
                fields
                    .field("kind")
                    .with_doc("1@kind (pet)\nmust be `Isopod`");
            });

            // provide meta for a field that doesn't exist;
            // this should not end up anywhere in the final string
            fields.field("0").with_doc("unreachable");
        });

    let s = ron::ser::to_string_pretty(&value, config).unwrap();

    assert_eq!(
        s,
        r#"((
    name: "Walter",
    /// 0@age (person)
    /// must be within range 0..256
    age: 43,
    /// 0@knows (person)
    /// must be list of valid person indices
    knows: [
        0,
        1,
    ],
    pet: None,
), [
    (
        name: "Alice",
        /// 0@age (person)
        /// must be within range 0..256
        age: 29,
        /// 0@knows (person)
        /// must be list of valid person indices
        knows: [
            1,
        ],
        pet: Some((
            name: "Herbert",
            /// 1@age (pet)
            /// must be valid range 0..256
            age: 7,
            /// 1@kind (pet)
            /// must be `Isopod`
            kind: Isopod,
        )),
    ),
    (
        name: "Bob",
        /// 0@age (person)
        /// must be within range 0..256
        age: 29,
        /// 0@knows (person)
        /// must be list of valid person indices
        knows: [
            0,
        ],
        pet: None,
    ),
])"#
    );
}