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