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