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