1// Copyright (c) 2017 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7use try_from::TryFrom;
8use std::str::FromStr;
9
10use minidom::{Element, IntoAttributeValue};
11
12use error::Error;
13use ns;
14
15use media_element::MediaElement;
16
17generate_attribute!(FieldType, "type", {
18 Boolean => "boolean",
19 Fixed => "fixed",
20 Hidden => "hidden",
21 JidMulti => "jid-multi",
22 JidSingle => "jid-single",
23 ListMulti => "list-multi",
24 ListSingle => "list-single",
25 TextMulti => "text-multi",
26 TextPrivate => "text-private",
27 TextSingle => "text-single",
28}, Default = TextSingle);
29
30#[derive(Debug, Clone)]
31pub struct Option_ {
32 pub label: Option<String>,
33 pub value: String,
34}
35
36impl From<Option_> for Element {
37 fn from(option: Option_) -> Element {
38 Element::builder("option")
39 .ns(ns::DATA_FORMS)
40 .attr("label", option.label)
41 .append(Element::builder("value")
42 .ns(ns::DATA_FORMS)
43 .append(option.value)
44 .build())
45 .build()
46 }
47}
48
49#[derive(Debug, Clone)]
50pub struct Field {
51 pub var: String,
52 pub type_: FieldType,
53 pub label: Option<String>,
54 pub required: bool,
55 pub options: Vec<Option_>,
56 pub values: Vec<String>,
57 pub media: Vec<MediaElement>,
58}
59
60impl From<Field> for Element {
61 fn from(field: Field) -> Element {
62 Element::builder("field")
63 .ns(ns::DATA_FORMS)
64 .attr("var", field.var)
65 .attr("type", field.type_)
66 .attr("label", field.label)
67 .append(if field.required { Some(Element::builder("required").ns(ns::DATA_FORMS).build()) } else { None })
68 .append(field.options)
69 .append(field.values.into_iter().map(|value| {
70 Element::builder("value").ns(ns::DATA_FORMS).append(value).build()
71 }).collect::<Vec<_>>())
72 .append(field.media)
73 .build()
74 }
75}
76
77generate_attribute!(DataFormType, "type", {
78 Cancel => "cancel",
79 Form => "form",
80 Result_ => "result",
81 Submit => "submit",
82});
83
84#[derive(Debug, Clone)]
85pub struct DataForm {
86 pub type_: DataFormType,
87 pub form_type: Option<String>,
88 pub title: Option<String>,
89 pub instructions: Option<String>,
90 pub fields: Vec<Field>,
91}
92
93impl TryFrom<Element> for DataForm {
94 type Err = Error;
95
96 fn try_from(elem: Element) -> Result<DataForm, Error> {
97 if !elem.is("x", ns::DATA_FORMS) {
98 return Err(Error::ParseError("This is not a data form element."));
99 }
100 let type_ = get_attr!(elem, "type", required);
101 let mut form = DataForm {
102 type_: type_,
103 form_type: None,
104 title: None,
105 instructions: None,
106 fields: vec!(),
107 };
108 for child in elem.children() {
109 if child.is("title", ns::DATA_FORMS) {
110 if form.title.is_some() {
111 return Err(Error::ParseError("More than one title in form element."));
112 }
113 for _ in child.children() {
114 return Err(Error::ParseError("Title element must not have any child."));
115 }
116 for _ in child.attrs() {
117 return Err(Error::ParseError("Title element must not have any attribute."));
118 }
119 form.title = Some(child.text());
120 } else if child.is("instructions", ns::DATA_FORMS) {
121 if form.instructions.is_some() {
122 return Err(Error::ParseError("More than one instructions in form element."));
123 }
124 for _ in child.children() {
125 return Err(Error::ParseError("instructions element must not have any child."));
126 }
127 for _ in child.attrs() {
128 return Err(Error::ParseError("instructions element must not have any attribute."));
129 }
130 form.instructions = Some(child.text());
131 } else if child.is("field", ns::DATA_FORMS) {
132 let var: String = get_attr!(child, "var", required);
133 let field_type = get_attr!(child, "type", default);
134 let label = get_attr!(child, "label", optional);
135
136 let is_form_type = var == "FORM_TYPE" && field_type == FieldType::Hidden;
137 let is_list = field_type == FieldType::ListSingle || field_type == FieldType::ListMulti;
138 let mut field = Field {
139 var: var,
140 type_: field_type,
141 label: label,
142 required: false,
143 options: vec!(),
144 values: vec!(),
145 media: vec!(),
146 };
147 for element in child.children() {
148 if element.is("value", ns::DATA_FORMS) {
149 for _ in element.children() {
150 return Err(Error::ParseError("Value element must not have any child."));
151 }
152 for _ in element.attrs() {
153 return Err(Error::ParseError("Value element must not have any attribute."));
154 }
155 field.values.push(element.text());
156 } else if element.is("required", ns::DATA_FORMS) {
157 if field.required {
158 return Err(Error::ParseError("More than one required element."));
159 }
160 for _ in element.children() {
161 return Err(Error::ParseError("Required element must not have any child."));
162 }
163 for _ in element.attrs() {
164 return Err(Error::ParseError("Required element must not have any attribute."));
165 }
166 field.required = true;
167 } else if element.is("option", ns::DATA_FORMS) {
168 if !is_list {
169 return Err(Error::ParseError("Option element found in non-list field."));
170 }
171 let label = get_attr!(element, "label", optional);
172 let mut value = None;
173 for child2 in element.children() {
174 if child2.is("value", ns::DATA_FORMS) {
175 if value.is_some() {
176 return Err(Error::ParseError("More than one value element in option element"));
177 }
178 value = Some(child2.text());
179 } else {
180 return Err(Error::ParseError("Non-value element in option element"));
181 }
182 }
183 let value = value.ok_or(Error::ParseError("No value element in option element"))?;
184 field.options.push(Option_ {
185 label: label,
186 value: value,
187 });
188 } else if element.is("media", ns::MEDIA_ELEMENT) {
189 match MediaElement::try_from(element.clone()) {
190 Ok(media_element) => field.media.push(media_element),
191 Err(_) => (), // TODO: is it really nice to swallow this error?
192 }
193 } else {
194 return Err(Error::ParseError("Field child isn’t a value or media element."));
195 }
196 }
197 if is_form_type {
198 if form.form_type.is_some() {
199 return Err(Error::ParseError("More than one FORM_TYPE in a data form."));
200 }
201 if field.values.len() != 1 {
202 return Err(Error::ParseError("Wrong number of values in FORM_TYPE."));
203 }
204 form.form_type = Some(field.values[0].clone());
205 }
206 form.fields.push(field);
207 } else {
208 return Err(Error::ParseError("Unknown child in data form element."));
209 }
210 }
211 Ok(form)
212 }
213}
214
215impl From<DataForm> for Element {
216 fn from(form: DataForm) -> Element {
217 Element::builder("x")
218 .ns(ns::DATA_FORMS)
219 .attr("type", form.type_)
220 .append(if form.title.is_some() { Some(Element::builder("title").ns(ns::DATA_FORMS).append(form.title)) } else { None })
221 .append(if form.instructions.is_some() { Some(Element::builder("instructions").ns(ns::DATA_FORMS).append(form.instructions)) } else { None })
222 .append(form.fields)
223 .build()
224 }
225}
226
227#[cfg(test)]
228mod tests {
229 use super::*;
230
231 #[test]
232 fn test_simple() {
233 let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
234 let form = DataForm::try_from(elem).unwrap();
235 assert_eq!(form.type_, DataFormType::Result_);
236 assert!(form.form_type.is_none());
237 assert!(form.fields.is_empty());
238 }
239
240 #[test]
241 fn test_invalid() {
242 let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
243 let error = DataForm::try_from(elem).unwrap_err();
244 let message = match error {
245 Error::ParseError(string) => string,
246 _ => panic!(),
247 };
248 assert_eq!(message, "Required attribute 'type' missing.");
249
250 let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
251 let error = DataForm::try_from(elem).unwrap_err();
252 let message = match error {
253 Error::ParseError(string) => string,
254 _ => panic!(),
255 };
256 assert_eq!(message, "Unknown value for 'type' attribute.");
257 }
258
259 #[test]
260 fn test_wrong_child() {
261 let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap();
262 let error = DataForm::try_from(elem).unwrap_err();
263 let message = match error {
264 Error::ParseError(string) => string,
265 _ => panic!(),
266 };
267 assert_eq!(message, "Unknown child in data form element.");
268 }
269}