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;
11
12use error::Error;
13use ns;
14
15use media_element::MediaElement;
16
17#[derive(Debug, Clone)]
18pub struct Field {
19 pub var: String,
20 pub type_: String, // TODO: use an enum here.
21 pub label: Option<String>,
22 pub values: Vec<String>,
23 pub media: Vec<MediaElement>,
24}
25
26#[derive(Debug, Clone, PartialEq)]
27pub enum DataFormType {
28 Cancel,
29 Form,
30 Result_,
31 Submit,
32}
33
34impl FromStr for DataFormType {
35 type Err = Error;
36
37 fn from_str(s: &str) -> Result<DataFormType, Error> {
38 Ok(match s {
39 "cancel" => DataFormType::Cancel,
40 "form" => DataFormType::Form,
41 "result" => DataFormType::Result_,
42 "submit" => DataFormType::Submit,
43
44 _ => return Err(Error::ParseError("Unknown data form type.")),
45 })
46 }
47}
48
49#[derive(Debug, Clone)]
50pub struct DataForm {
51 pub type_: DataFormType,
52 pub form_type: Option<String>,
53 pub fields: Vec<Field>,
54}
55
56pub fn parse_data_form(root: &Element) -> Result<DataForm, Error> {
57 if !root.is("x", ns::DATA_FORMS) {
58 return Err(Error::ParseError("This is not a data form element."));
59 }
60
61 let type_: DataFormType = match root.attr("type") {
62 Some(type_) => type_.parse()?,
63 None => return Err(Error::ParseError("Type attribute on data form is mandatory.")),
64 };
65 let mut fields = vec!();
66 let mut form_type = None;
67 for field in root.children() {
68 if field.is("field", ns::DATA_FORMS) {
69 let var = field.attr("var").ok_or(Error::ParseError("Field must have a 'var' attribute."))?;
70 let field_type = field.attr("type").unwrap_or("text-single");
71 let label = field.attr("label").and_then(|label| label.parse().ok());
72 let mut values = vec!();
73 let mut media = vec!();
74 for element in field.children() {
75 if element.is("value", ns::DATA_FORMS) {
76 values.push(element.text());
77 } else if element.is("media", ns::MEDIA_ELEMENT) {
78 match MediaElement::try_from(element) {
79 Ok(media_element) => media.push(media_element),
80 Err(_) => (), // TODO: is it really nice to swallow this error?
81 }
82 } else {
83 return Err(Error::ParseError("Field child isn’t a value or media element."));
84 }
85 }
86 if var == "FORM_TYPE" && field_type == "hidden" {
87 if form_type != None {
88 return Err(Error::ParseError("More than one FORM_TYPE in a data form."));
89 }
90 if values.len() != 1 {
91 return Err(Error::ParseError("Wrong number of values in FORM_TYPE."));
92 }
93 form_type = Some(values[0].clone());
94 }
95 fields.push(Field {
96 var: var.to_owned(),
97 type_: field_type.to_owned(),
98 label: label,
99 values: values,
100 media: media,
101 });
102 } else {
103 return Err(Error::ParseError("Unknown field type in data form."));
104 }
105 }
106 Ok(DataForm { type_: type_, form_type: form_type, fields: fields })
107}
108
109#[cfg(test)]
110mod tests {
111 use minidom::Element;
112 use error::Error;
113 use data_forms;
114
115 #[test]
116 fn test_simple() {
117 let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
118 let form = data_forms::parse_data_form(&elem).unwrap();
119 assert_eq!(form.type_, data_forms::DataFormType::Result_);
120 assert!(form.form_type.is_none());
121 assert!(form.fields.is_empty());
122 }
123
124 #[test]
125 fn test_invalid() {
126 let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
127 let error = data_forms::parse_data_form(&elem).unwrap_err();
128 let message = match error {
129 Error::ParseError(string) => string,
130 _ => panic!(),
131 };
132 assert_eq!(message, "Type attribute on data form is mandatory.");
133
134 let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
135 let error = data_forms::parse_data_form(&elem).unwrap_err();
136 let message = match error {
137 Error::ParseError(string) => string,
138 _ => panic!(),
139 };
140 assert_eq!(message, "Unknown data form type.");
141 }
142
143 #[test]
144 fn test_wrong_child() {
145 let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap();
146 let error = data_forms::parse_data_form(&elem).unwrap_err();
147 let message = match error {
148 Error::ParseError(string) => string,
149 _ => panic!(),
150 };
151 assert_eq!(message, "Unknown field type in data form.");
152 }
153}