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