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 std::convert::TryFrom;
8use std::str::FromStr;
9
10use minidom::{Element, IntoElements, IntoAttributeValue, ElementEmitter};
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
49impl IntoElements for Option_ {
50 fn into_elements(self, emitter: &mut ElementEmitter) {
51 emitter.append_child(self.into());
52 }
53}
54
55#[derive(Debug, Clone)]
56pub struct Field {
57 pub var: String,
58 pub type_: FieldType,
59 pub label: Option<String>,
60 pub required: bool,
61 pub options: Vec<Option_>,
62 pub values: Vec<String>,
63 pub media: Vec<MediaElement>,
64}
65
66impl From<Field> for Element {
67 fn from(field: Field) -> Element {
68 Element::builder("field")
69 .ns(ns::DATA_FORMS)
70 .attr("var", field.var)
71 .attr("type", field.type_)
72 .attr("label", field.label)
73 .append(if field.required { Some(Element::builder("required").ns(ns::DATA_FORMS).build()) } else { None })
74 .append(field.options)
75 .append(field.values.iter().map(|value| {
76 Element::builder("value").ns(ns::DATA_FORMS).append(value).build()
77 }).collect::<Vec<_>>())
78 .append(field.media)
79 .build()
80 }
81}
82
83impl IntoElements for Field {
84 fn into_elements(self, emitter: &mut ElementEmitter) {
85 emitter.append_child(self.into());
86 }
87}
88
89generate_attribute!(DataFormType, "type", {
90 Cancel => "cancel",
91 Form => "form",
92 Result_ => "result",
93 Submit => "submit",
94});
95
96#[derive(Debug, Clone)]
97pub struct DataForm {
98 pub type_: DataFormType,
99 pub form_type: Option<String>,
100 pub title: Option<String>,
101 pub instructions: Option<String>,
102 pub fields: Vec<Field>,
103}
104
105impl TryFrom<Element> for DataForm {
106 type Error = Error;
107
108 fn try_from(elem: Element) -> Result<DataForm, Error> {
109 if !elem.is("x", ns::DATA_FORMS) {
110 return Err(Error::ParseError("This is not a data form element."));
111 }
112 let type_ = get_attr!(elem, "type", required);
113 let mut form = DataForm {
114 type_: type_,
115 form_type: None,
116 title: None,
117 instructions: None,
118 fields: vec!(),
119 };
120 for child in elem.children() {
121 if child.is("title", ns::DATA_FORMS) {
122 if form.title.is_some() {
123 return Err(Error::ParseError("More than one title in form element."));
124 }
125 for _ in child.children() {
126 return Err(Error::ParseError("Title element must not have any child."));
127 }
128 for _ in child.attrs() {
129 return Err(Error::ParseError("Title element must not have any attribute."));
130 }
131 form.title = Some(child.text());
132 } else if child.is("instructions", ns::DATA_FORMS) {
133 if form.instructions.is_some() {
134 return Err(Error::ParseError("More than one instructions in form element."));
135 }
136 for _ in child.children() {
137 return Err(Error::ParseError("instructions element must not have any child."));
138 }
139 for _ in child.attrs() {
140 return Err(Error::ParseError("instructions element must not have any attribute."));
141 }
142 form.instructions = Some(child.text());
143 } else if child.is("field", ns::DATA_FORMS) {
144 let var: String = get_attr!(child, "var", required);
145 let field_type = get_attr!(child, "type", default);
146 let label = get_attr!(child, "label", optional);
147
148 let is_form_type = var == "FORM_TYPE" && field_type == FieldType::Hidden;
149 let is_list = field_type == FieldType::ListSingle || field_type == FieldType::ListMulti;
150 let mut field = Field {
151 var: var,
152 type_: field_type,
153 label: label,
154 required: false,
155 options: vec!(),
156 values: vec!(),
157 media: vec!(),
158 };
159 for element in child.children() {
160 if element.is("value", ns::DATA_FORMS) {
161 for _ in element.children() {
162 return Err(Error::ParseError("Value element must not have any child."));
163 }
164 for _ in element.attrs() {
165 return Err(Error::ParseError("Value element must not have any attribute."));
166 }
167 field.values.push(element.text());
168 } else if element.is("required", ns::DATA_FORMS) {
169 if field.required {
170 return Err(Error::ParseError("More than one required element."));
171 }
172 for _ in element.children() {
173 return Err(Error::ParseError("Required element must not have any child."));
174 }
175 for _ in element.attrs() {
176 return Err(Error::ParseError("Required element must not have any attribute."));
177 }
178 field.required = true;
179 } else if element.is("option", ns::DATA_FORMS) {
180 if !is_list {
181 return Err(Error::ParseError("Option element found in non-list field."));
182 }
183 let label = get_attr!(element, "label", optional);
184 let mut value = None;
185 for child2 in element.children() {
186 if child2.is("value", ns::DATA_FORMS) {
187 if value.is_some() {
188 return Err(Error::ParseError("More than one value element in option element"));
189 }
190 value = Some(child2.text());
191 } else {
192 return Err(Error::ParseError("Non-value element in option element"));
193 }
194 }
195 let value = value.ok_or(Error::ParseError("No value element in option element"))?;
196 field.options.push(Option_ {
197 label: label,
198 value: value,
199 });
200 } else if element.is("media", ns::MEDIA_ELEMENT) {
201 match MediaElement::try_from(element.clone()) {
202 Ok(media_element) => field.media.push(media_element),
203 Err(_) => (), // TODO: is it really nice to swallow this error?
204 }
205 } else {
206 return Err(Error::ParseError("Field child isn’t a value or media element."));
207 }
208 }
209 if is_form_type {
210 if form.form_type.is_some() {
211 return Err(Error::ParseError("More than one FORM_TYPE in a data form."));
212 }
213 if field.values.len() != 1 {
214 return Err(Error::ParseError("Wrong number of values in FORM_TYPE."));
215 }
216 form.form_type = Some(field.values[0].clone());
217 }
218 form.fields.push(field);
219 } else {
220 return Err(Error::ParseError("Unknown child in data form element."));
221 }
222 }
223 Ok(form)
224 }
225}
226
227impl From<DataForm> for Element {
228 fn from(form: DataForm) -> Element {
229 Element::builder("x")
230 .ns(ns::DATA_FORMS)
231 .attr("type", form.type_)
232 .append(if form.title.is_some() { Some(Element::builder("title").ns(ns::DATA_FORMS).append(form.title)) } else { None })
233 .append(if form.instructions.is_some() { Some(Element::builder("instructions").ns(ns::DATA_FORMS).append(form.instructions)) } else { None })
234 .append(form.fields)
235 .build()
236 }
237}
238
239impl IntoElements for DataForm {
240 fn into_elements(self, emitter: &mut ElementEmitter) {
241 emitter.append_child(self.into());
242 }
243}
244
245#[cfg(test)]
246mod tests {
247 use super::*;
248
249 #[test]
250 fn test_simple() {
251 let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
252 let form = DataForm::try_from(elem).unwrap();
253 assert_eq!(form.type_, DataFormType::Result_);
254 assert!(form.form_type.is_none());
255 assert!(form.fields.is_empty());
256 }
257
258 #[test]
259 fn test_invalid() {
260 let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
261 let error = DataForm::try_from(elem).unwrap_err();
262 let message = match error {
263 Error::ParseError(string) => string,
264 _ => panic!(),
265 };
266 assert_eq!(message, "Required attribute 'type' missing.");
267
268 let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
269 let error = DataForm::try_from(elem).unwrap_err();
270 let message = match error {
271 Error::ParseError(string) => string,
272 _ => panic!(),
273 };
274 assert_eq!(message, "Unknown value for 'type' attribute.");
275 }
276
277 #[test]
278 fn test_wrong_child() {
279 let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap();
280 let error = DataForm::try_from(elem).unwrap_err();
281 let message = match error {
282 Error::ParseError(string) => string,
283 _ => panic!(),
284 };
285 assert_eq!(message, "Unknown child in data form element.");
286 }
287}