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
56impl<'a> TryFrom<&'a Element> for DataForm {
57 type Error = Error;
58
59 fn try_from(elem: &'a Element) -> Result<DataForm, Error> {
60 if !elem.is("x", ns::DATA_FORMS) {
61 return Err(Error::ParseError("This is not a data form element."));
62 }
63
64 let type_: DataFormType = match elem.attr("type") {
65 Some(type_) => type_.parse()?,
66 None => return Err(Error::ParseError("Type attribute on data form is mandatory.")),
67 };
68 let mut fields = vec!();
69 let mut form_type = None;
70 for field in elem.children() {
71 if field.is("field", ns::DATA_FORMS) {
72 let var = field.attr("var").ok_or(Error::ParseError("Field must have a 'var' attribute."))?;
73 let field_type = field.attr("type").unwrap_or("text-single");
74 let label = field.attr("label").and_then(|label| label.parse().ok());
75 let mut values = vec!();
76 let mut media = vec!();
77 for element in field.children() {
78 if element.is("value", ns::DATA_FORMS) {
79 values.push(element.text());
80 } else if element.is("media", ns::MEDIA_ELEMENT) {
81 match MediaElement::try_from(element) {
82 Ok(media_element) => media.push(media_element),
83 Err(_) => (), // TODO: is it really nice to swallow this error?
84 }
85 } else {
86 return Err(Error::ParseError("Field child isn’t a value or media element."));
87 }
88 }
89 if var == "FORM_TYPE" && field_type == "hidden" {
90 if form_type != None {
91 return Err(Error::ParseError("More than one FORM_TYPE in a data form."));
92 }
93 if values.len() != 1 {
94 return Err(Error::ParseError("Wrong number of values in FORM_TYPE."));
95 }
96 form_type = Some(values[0].clone());
97 }
98 fields.push(Field {
99 var: var.to_owned(),
100 type_: field_type.to_owned(),
101 label: label,
102 values: values,
103 media: media,
104 });
105 } else {
106 return Err(Error::ParseError("Unknown field type in data form."));
107 }
108 }
109 Ok(DataForm { type_: type_, form_type: form_type, fields: fields })
110 }
111}
112
113#[cfg(test)]
114mod tests {
115 use super::*;
116
117 #[test]
118 fn test_simple() {
119 let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
120 let form = DataForm::try_from(&elem).unwrap();
121 assert_eq!(form.type_, DataFormType::Result_);
122 assert!(form.form_type.is_none());
123 assert!(form.fields.is_empty());
124 }
125
126 #[test]
127 fn test_invalid() {
128 let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
129 let error = DataForm::try_from(&elem).unwrap_err();
130 let message = match error {
131 Error::ParseError(string) => string,
132 _ => panic!(),
133 };
134 assert_eq!(message, "Type attribute on data form is mandatory.");
135
136 let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
137 let error = DataForm::try_from(&elem).unwrap_err();
138 let message = match error {
139 Error::ParseError(string) => string,
140 _ => panic!(),
141 };
142 assert_eq!(message, "Unknown data form type.");
143 }
144
145 #[test]
146 fn test_wrong_child() {
147 let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap();
148 let error = DataForm::try_from(&elem).unwrap_err();
149 let message = match error {
150 Error::ParseError(string) => string,
151 _ => panic!(),
152 };
153 assert_eq!(message, "Unknown field type in data form.");
154 }
155}