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