xml_schema_generator 0.6.23

Create Rust struct for given XML file, that allows to deserliaze the given XML using serde or vice versa
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! defines a helper macro to write shorter tests
use super::Element;

/// usage: element!(name: T, text: Option<T>, attributes: Vec<T>, children: Vec<Element<T>>) for a standalone element
/// or   : element!(name: T, text: Option<T>, attributes: Vec<T>, children: Vec<Element<T>>, multiple) if the element appears multiple times within it' parent
/// where T is String or &str usually (T: std::cmp::PartialEq + std::fmt::Display + std::fmt::Debug)
/// all parameters but name are optional
macro_rules! element {
    ($name:expr, $text:expr, $attributes:expr, $children:expr, multiple) => {{
        let mut temp = element!($name, $text, $attributes, $children);
        temp.set_multiple();
        temp
    }};
    ($name:expr, $text:expr, $attributes:expr, $children:expr) => {{
        let mut temp = Element::new($name, $attributes);
        temp.text = $text;
        for c in $children.into_iter() {
            temp.add_unique_child(c)
        }
        temp
    }};
    ($name:expr, $text:expr, $attributes:expr) => {{
        element!($name, $text, $attributes, vec![])
    }};
    ($name:expr, $text:expr) => {{
        element!($name, $text, vec![], vec![])
    }};
    ($name:expr) => {{
        element!($name, None, vec![], vec![])
    }};
}

pub(crate) use element;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn create_element() {
        let a = element!("a", Some("text"), vec!["attribute"], vec![]);

        assert_eq!("a", a.name);
        assert_eq!(Some("text"), a.text);
        assert_eq!(1, a.attributes().len());
        assert_eq!(0, a.children.len());
        assert!(a.standalone());
    }

    #[test]
    fn create_element_without_children() {
        let a = element!("a", Some("text"), vec!["attribute"]);

        assert_eq!("a", a.name);
        assert_eq!(Some("text"), a.text);
        assert_eq!(1, a.attributes().len());
        assert_eq!(0, a.children.len());
        assert!(a.standalone());
    }

    #[test]
    fn create_element_without_children_or_attributes() {
        let a = element!("a", Some("text"));

        assert_eq!("a", a.name);
        assert_eq!(Some("text"), a.text);
        assert_eq!(0, a.attributes().len());
        assert_eq!(0, a.children.len());
        assert!(a.standalone());
    }

    #[test]
    fn create_element_with_name_only() {
        let a = element!("a");

        assert_eq!("a", a.name);
        assert_eq!(None, a.text);
        assert_eq!(0, a.attributes().len());
        assert_eq!(0, a.children.len());
        assert!(a.standalone());
    }

    #[test]
    fn create_element_without_text() {
        let a = element!("a", None, vec![], vec![]);

        assert_eq!("a", a.name);
        assert_eq!(None, a.text);
    }

    #[test]
    fn create_element_as_multiple() {
        let a = element!("a", None, vec![], vec![], multiple);

        assert!(!a.standalone());
    }

    #[test]
    fn create_element_with_multiple_attributes() {
        let a = element!("a", None, vec!["a1", "a2"], vec![]);

        assert_eq!(2, a.attributes().len());
        assert_eq!(
            &"a1",
            a.attributes()
                .first()
                .expect("expected to get first attribute")
                .inner_t()
        );
        assert_eq!(
            &"a2",
            a.attributes()
                .get(1)
                .expect("expected to get second attribute")
                .inner_t()
        );
    }

    #[test]
    fn create_element_with_children() {
        let c = element!("c", None, vec![], vec![]);
        let b = element!("b", None, vec![], vec![]);
        let a = element!("a", None, vec![], vec![b, c]);

        assert_eq!(2, a.children.len());
        assert_eq!(
            "b",
            a.children()
                .first()
                .expect("expected to get child b")
                .inner_t()
                .name
        );
        assert_eq!(
            "c",
            a.children()
                .get(1)
                .expect("expected to get child c")
                .inner_t()
                .name
        );
    }
}