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