disco: Switch to Into/TryFrom.

src/disco.rs

@@ -34,121 +34,125 @@ pub struct Disco {
     pub extensions: Vec<DataForm>,
 }
 
-pub fn parse_disco(root: &Element) -> Result<Disco, Error> {
+impl<'a> TryFrom<&'a Element> for Disco {
-    if !root.is("query", ns::DISCO_INFO) {
+    type Error = Error;
-        return Err(Error::ParseError("This is not a disco#info element."));
-    }
 
-    let mut identities: Vec<Identity> = vec!();
+    fn try_from(elem: &'a Element) -> Result<Disco, Error> {
-    let mut features: Vec<Feature> = vec!();
+        if !elem.is("query", ns::DISCO_INFO) {
-    let mut extensions: Vec<DataForm> = vec!();
+            return Err(Error::ParseError("This is not a disco#info element."));
-
-    let node = root.attr("node")
-                   .and_then(|node| node.parse().ok());
-
-    for child in root.children() {
-        if child.is("feature", ns::DISCO_INFO) {
-            let feature = child.attr("var")
-                               .ok_or(Error::ParseError("Feature must have a 'var' attribute."))?;
-            features.push(Feature {
-                var: feature.to_owned(),
-            });
-        } else if child.is("identity", ns::DISCO_INFO) {
-            let category = child.attr("category")
-                                .ok_or(Error::ParseError("Identity must have a 'category' attribute."))?;
-            if category == "" {
-                return Err(Error::ParseError("Identity must have a non-empty 'category' attribute."))
-            }
-
-            let type_ = child.attr("type")
-                             .ok_or(Error::ParseError("Identity must have a 'type' attribute."))?;
-            if type_ == "" {
-                return Err(Error::ParseError("Identity must have a non-empty 'type' attribute."))
-            }
-
-            let xml_lang = child.attr("xml:lang").unwrap_or("");
-            let name = child.attr("name")
-                            .and_then(|name| name.parse().ok());
-            identities.push(Identity {
-                category: category.to_owned(),
-                type_: type_.to_owned(),
-                xml_lang: xml_lang.to_owned(),
-                name: name,
-            });
-        } else if child.is("x", ns::DATA_FORMS) {
-            let data_form = DataForm::try_from(child)?;
-            match data_form.type_ {
-                DataFormType::Result_ => (),
-                _ => return Err(Error::ParseError("Data form must have a 'result' type in disco#info.")),
-            }
-            match data_form.form_type {
-                Some(_) => extensions.push(data_form),
-                None => return Err(Error::ParseError("Data form found without a FORM_TYPE.")),
-            }
-        } else {
-            return Err(Error::ParseError("Unknown element in disco#info."));
         }
-    }
 
-    /*
+        let mut identities: Vec<Identity> = vec!();
-    // TODO: encode these restrictions only for result disco#info, not get ones.
+        let mut features: Vec<Feature> = vec!();
-    if identities.is_empty() {
+        let mut extensions: Vec<DataForm> = vec!();
-        return Err(Error::ParseError("There must be at least one identity in disco#info."));
-    }
-    if features.is_empty() {
-        return Err(Error::ParseError("There must be at least one feature in disco#info."));
-    }
-    if !features.contains(&Feature { var: ns::DISCO_INFO.to_owned() }) {
-        return Err(Error::ParseError("disco#info feature not present in disco#info."));
-    }
-    */
 
-    Ok(Disco {
+        let node = elem.attr("node")
-        node: node,
+                       .and_then(|node| node.parse().ok());
-        identities: identities,
+
-        features: features,
+        for child in elem.children() {
-        extensions: extensions
+            if child.is("feature", ns::DISCO_INFO) {
-    })
+                let feature = child.attr("var")
+                                   .ok_or(Error::ParseError("Feature must have a 'var' attribute."))?;
+                features.push(Feature {
+                    var: feature.to_owned(),
+                });
+            } else if child.is("identity", ns::DISCO_INFO) {
+                let category = child.attr("category")
+                                    .ok_or(Error::ParseError("Identity must have a 'category' attribute."))?;
+                if category == "" {
+                    return Err(Error::ParseError("Identity must have a non-empty 'category' attribute."))
+                }
+
+                let type_ = child.attr("type")
+                                 .ok_or(Error::ParseError("Identity must have a 'type' attribute."))?;
+                if type_ == "" {
+                    return Err(Error::ParseError("Identity must have a non-empty 'type' attribute."))
+                }
+
+                let xml_lang = child.attr("xml:lang").unwrap_or("");
+                let name = child.attr("name")
+                                .and_then(|name| name.parse().ok());
+                identities.push(Identity {
+                    category: category.to_owned(),
+                    type_: type_.to_owned(),
+                    xml_lang: xml_lang.to_owned(),
+                    name: name,
+                });
+            } else if child.is("x", ns::DATA_FORMS) {
+                let data_form = DataForm::try_from(child)?;
+                match data_form.type_ {
+                    DataFormType::Result_ => (),
+                    _ => return Err(Error::ParseError("Data form must have a 'result' type in disco#info.")),
+                }
+                match data_form.form_type {
+                    Some(_) => extensions.push(data_form),
+                    None => return Err(Error::ParseError("Data form found without a FORM_TYPE.")),
+                }
+            } else {
+                return Err(Error::ParseError("Unknown element in disco#info."));
+            }
+        }
+
+        /*
+        // TODO: encode these restrictions only for result disco#info, not get ones.
+        if identities.is_empty() {
+            return Err(Error::ParseError("There must be at least one identity in disco#info."));
+        }
+        if features.is_empty() {
+            return Err(Error::ParseError("There must be at least one feature in disco#info."));
+        }
+        if !features.contains(&Feature { var: ns::DISCO_INFO.to_owned() }) {
+            return Err(Error::ParseError("disco#info feature not present in disco#info."));
+        }
+        */
+
+        Ok(Disco {
+            node: node,
+            identities: identities,
+            features: features,
+            extensions: extensions
+        })
+    }
 }
 
-pub fn serialise_disco(disco: &Disco) -> Element {
+impl<'a> Into<Element> for &'a Disco {
-    let mut root = Element::builder("query")
+    fn into(self) -> Element {
-                           .ns(ns::DISCO_INFO)
+        let mut root = Element::builder("query")
-                           .attr("node", disco.node.clone())
+                               .ns(ns::DISCO_INFO)
-                           .build();
+                               .attr("node", self.node.clone())
-    for identity in &disco.identities {
+                               .build();
-        let identity_element = Element::builder("identity")
+        for identity in &self.identities {
-                                       .ns(ns::DISCO_INFO)
+            let identity_element = Element::builder("identity")
-                                       .attr("category", identity.category.clone())
+                                           .ns(ns::DISCO_INFO)
-                                       .attr("type", identity.type_.clone())
+                                           .attr("category", identity.category.clone())
-                                       .attr("xml:lang", identity.xml_lang.clone())
+                                           .attr("type", identity.type_.clone())
-                                       .attr("name", identity.name.clone())
+                                           .attr("xml:lang", identity.xml_lang.clone())
-                                       .build();
+                                           .attr("name", identity.name.clone())
-        root.append_child(identity_element);
+                                           .build();
+            root.append_child(identity_element);
+        }
+        for feature in &self.features {
+            let feature_element = Element::builder("feature")
+                                          .ns(ns::DISCO_INFO)
+                                          .attr("var", feature.var.clone())
+                                          .build();
+            root.append_child(feature_element);
+        }
+        for _ in &self.extensions {
+            panic!("Not yet implemented!");
+        }
+        root
     }
-    for feature in &disco.features {
-        let feature_element = Element::builder("feature")
-                                      .ns(ns::DISCO_INFO)
-                                      .attr("var", feature.var.clone())
-                                      .build();
-        root.append_child(feature_element);
-    }
-    for _ in &disco.extensions {
-        panic!("Not yet implemented!");
-    }
-    root
 }
 
 #[cfg(test)]
 mod tests {
-    use minidom::Element;
+    use super::*;
-    use error::Error;
-    use disco;
 
     #[test]
     fn test_simple() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/><feature var='http://jabber.org/protocol/disco#info'/></query>".parse().unwrap();
-        let query = disco::parse_disco(&elem).unwrap();
+        let query = Disco::try_from(&elem).unwrap();
         assert!(query.node.is_none());
         assert_eq!(query.identities.len(), 1);
         assert_eq!(query.features.len(), 1);
@@ -158,7 +162,7 @@ mod tests {
     #[test]
     fn test_invalid() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><coucou/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -169,7 +173,7 @@ mod tests {
     #[test]
     fn test_invalid_identity() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -177,7 +181,7 @@ mod tests {
         assert_eq!(message, "Identity must have a 'category' attribute.");
 
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category=''/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -185,7 +189,7 @@ mod tests {
         assert_eq!(message, "Identity must have a non-empty 'category' attribute.");
 
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='coucou'/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -193,7 +197,7 @@ mod tests {
         assert_eq!(message, "Identity must have a 'type' attribute.");
 
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='coucou' type=''/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -204,7 +208,7 @@ mod tests {
     #[test]
     fn test_invalid_feature() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><feature/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -216,7 +220,7 @@ mod tests {
     #[ignore]
     fn test_invalid_result() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'/>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -224,7 +228,7 @@ mod tests {
         assert_eq!(message, "There must be at least one identity in disco#info.");
 
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),
@@ -232,7 +236,7 @@ mod tests {
         assert_eq!(message, "There must be at least one feature in disco#info.");
 
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/><feature var='http://jabber.org/protocol/disco#items'/></query>".parse().unwrap();
-        let error = disco::parse_disco(&elem).unwrap_err();
+        let error = Disco::try_from(&elem).unwrap_err();
         let message = match error {
             Error::ParseError(string) => string,
             _ => panic!(),

src/ecaps2.rs

@@ -166,7 +166,6 @@ pub fn hash_ecaps2(data: &[u8], algo: &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use disco;
     use ecaps2;
     use base64;
 
@@ -195,7 +194,7 @@ mod tests {
     #[test]
     fn test_simple() {
         let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/><feature var='http://jabber.org/protocol/disco#info'/></query>".parse().unwrap();
-        let disco = disco::parse_disco(&elem).unwrap();
+        let disco = Disco::try_from(&elem).unwrap();
         let ecaps2 = ecaps2::compute_disco(&disco);
         assert_eq!(ecaps2.len(), 54);
     }
@@ -258,7 +257,7 @@ mod tests {
             105, 109, 101, 31, 28, 99, 108, 105, 101, 110, 116, 31, 109, 111,
             98, 105, 108, 101, 31, 31, 66, 111, 109, 98, 117, 115, 77, 111,
             100, 31, 30, 28, 28];
-        let disco = disco::parse_disco(&elem).unwrap();
+        let disco = Disco::try_from(&elem).unwrap();
         let ecaps2 = ecaps2::compute_disco(&disco);
         assert_eq!(ecaps2.len(), 0x1d9);
         assert_eq!(ecaps2, expected);
@@ -430,7 +429,7 @@ mod tests {
             111, 110, 31, 48, 46, 49, 49, 46, 49, 45, 115, 118, 110, 45, 50,
             48, 49, 49, 49, 50, 49, 54, 45, 109, 111, 100, 32, 40, 84, 99, 108,
             47, 84, 107, 32, 56, 46,54, 98, 50, 41, 31, 30, 29, 28];
-        let disco = disco::parse_disco(&elem).unwrap();
+        let disco = Disco::try_from(&elem).unwrap();
         let ecaps2 = ecaps2::compute_disco(&disco);
         assert_eq!(ecaps2.len(), 0x543);
         assert_eq!(ecaps2, expected);

src/iq.rs

@@ -17,7 +17,7 @@ use error::Error;
 use ns;
 
 use stanza_error;
-use disco;
+use disco::Disco;
 use ibb::IBB;
 use jingle::Jingle;
 use ping::Ping;
@@ -25,7 +25,7 @@ use ping::Ping;
 /// Lists every known payload of a `<iq/>`.
 #[derive(Debug, Clone)]
 pub enum IqPayload {
-    Disco(disco::Disco),
+    Disco(Disco),
     IBB(IBB),
     Jingle(Jingle),
     Ping(Ping),
@@ -95,7 +95,7 @@ pub fn parse_iq(root: &Element) -> Result<Iq, Error> {
                 return Err(Error::ParseError("Wrong number of children in iq element."));
             }
         } else {
-            let parsed_payload = if let Ok(disco) = disco::parse_disco(elem) {
+            let parsed_payload = if let Ok(disco) = Disco::try_from(elem) {
                 Some(IqPayload::Disco(disco))
             } else if let Ok(ibb) = IBB::try_from(elem) {
                 Some(IqPayload::IBB(ibb))
@@ -152,7 +152,7 @@ pub fn parse_iq(root: &Element) -> Result<Iq, Error> {
 
 pub fn serialise_payload(payload: &IqPayload) -> Element {
     match *payload {
-        IqPayload::Disco(ref disco) => disco::serialise_disco(disco),
+        IqPayload::Disco(ref disco) => disco.into(),
         IqPayload::IBB(ref ibb) => ibb.into(),
         IqPayload::Jingle(ref jingle) => jingle.into(),
         IqPayload::Ping(ref ping) => ping.into(),