diff --git a/src/attention.rs b/src/attention.rs index 21f8e0b5d29c3411bb3a1c6cc47df8b184308088..b28b5cc300967f03c455814f1008cd06c93c264b 100644 --- a/src/attention.rs +++ b/src/attention.rs @@ -15,10 +15,10 @@ use ns; #[derive(Debug, Clone)] pub struct Attention; -impl<'a> TryFrom<&'a Element> for Attention { +impl TryFrom for Attention { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("attention", ns::ATTENTION) { return Err(Error::ParseError("This is not an attention element.")); } @@ -29,7 +29,7 @@ impl<'a> TryFrom<&'a Element> for Attention { } } -impl<'a> Into for &'a Attention { +impl Into for Attention { fn into(self) -> Element { Element::builder("attention") .ns(ns::ATTENTION) @@ -47,13 +47,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Attention::try_from(&elem).unwrap(); + Attention::try_from(elem).unwrap(); } #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Attention::try_from(&elem).unwrap_err(); + let error = Attention::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -65,9 +65,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let attention = Attention; - let elem2: Element = (&attention).into(); - let elem3: Element = (&attention).into(); + let elem2: Element = attention.into(); assert_eq!(elem, elem2); - assert_eq!(elem2, elem3); } } diff --git a/src/chatstates.rs b/src/chatstates.rs index f9fdb4f3d26e47dfd853a18ff4f22a1fd9b22e59..54f0aefe7e93d343be9c46e8df6fc2d83e4f7f2e 100644 --- a/src/chatstates.rs +++ b/src/chatstates.rs @@ -21,10 +21,10 @@ pub enum ChatState { Paused, } -impl<'a> TryFrom<&'a Element> for ChatState { +impl TryFrom for ChatState { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { for _ in elem.children() { return Err(Error::ParseError("Unknown child in chatstate element.")); } @@ -47,9 +47,9 @@ impl<'a> TryFrom<&'a Element> for ChatState { } } -impl<'a> Into for &'a ChatState { +impl Into for ChatState { fn into(self) -> Element { - Element::builder(match *self { + Element::builder(match self { ChatState::Active => "active", ChatState::Composing => "composing", ChatState::Gone => "gone", @@ -67,13 +67,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - ChatState::try_from(&elem).unwrap(); + ChatState::try_from(elem).unwrap(); } #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = ChatState::try_from(&elem).unwrap_err(); + let error = ChatState::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -84,7 +84,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = ChatState::try_from(&elem).unwrap_err(); + let error = ChatState::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -95,7 +95,7 @@ mod tests { #[test] fn test_invalid_attribute() { let elem: Element = "".parse().unwrap(); - let error = ChatState::try_from(&elem).unwrap_err(); + let error = ChatState::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -106,7 +106,7 @@ mod tests { #[test] fn test_serialise() { let chatstate = ChatState::Active; - let elem: Element = (&chatstate).into(); + let elem: Element = chatstate.into(); assert!(elem.is("active", ns::CHATSTATES)); } } diff --git a/src/data_forms.rs b/src/data_forms.rs index 6d4e3bc41fa450cf1c833af52e6345dc79bfc18f..21d2ab11db6276b488936edaf54dc4fb4501d054 100644 --- a/src/data_forms.rs +++ b/src/data_forms.rs @@ -104,10 +104,10 @@ pub struct DataForm { pub fields: Vec, } -impl<'a> TryFrom<&'a Element> for DataForm { +impl TryFrom for DataForm { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("x", ns::DATA_FORMS) { return Err(Error::ParseError("This is not a data form element.")); } @@ -200,7 +200,7 @@ impl<'a> TryFrom<&'a Element> for DataForm { value: value, }); } else if element.is("media", ns::MEDIA_ELEMENT) { - match MediaElement::try_from(element) { + match MediaElement::try_from(element.clone()) { Ok(media_element) => field.media.push(media_element), Err(_) => (), // TODO: is it really nice to swallow this error? } @@ -233,7 +233,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let form = DataForm::try_from(&elem).unwrap(); + let form = DataForm::try_from(elem).unwrap(); assert_eq!(form.type_, DataFormType::Result_); assert!(form.form_type.is_none()); assert!(form.fields.is_empty()); @@ -242,7 +242,7 @@ mod tests { #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = DataForm::try_from(&elem).unwrap_err(); + let error = DataForm::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -250,7 +250,7 @@ mod tests { assert_eq!(message, "Required attribute 'type' missing."); let elem: Element = "".parse().unwrap(); - let error = DataForm::try_from(&elem).unwrap_err(); + let error = DataForm::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -261,7 +261,7 @@ mod tests { #[test] fn test_wrong_child() { let elem: Element = "".parse().unwrap(); - let error = DataForm::try_from(&elem).unwrap_err(); + let error = DataForm::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/delay.rs b/src/delay.rs index 79424dcb5e4a01e3129e00c4c80555d1718c7046..08b406c5c7d04b58bf53eeeb73c1cd63a48b4875 100644 --- a/src/delay.rs +++ b/src/delay.rs @@ -20,10 +20,10 @@ pub struct Delay { pub data: Option, } -impl<'a> TryFrom<&'a Element> for Delay { +impl TryFrom for Delay { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("delay", ns::DELAY) { return Err(Error::ParseError("This is not a delay element.")); } @@ -44,7 +44,7 @@ impl<'a> TryFrom<&'a Element> for Delay { } } -impl<'a> Into for &'a Delay { +impl Into for Delay { fn into(self) -> Element { Element::builder("delay") .ns(ns::DELAY) @@ -63,7 +63,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let delay = Delay::try_from(&elem).unwrap(); + let delay = Delay::try_from(elem).unwrap(); assert_eq!(delay.from, Some(Jid::from_str("capulet.com").unwrap())); assert_eq!(delay.stamp, "2002-09-10T23:08:25Z"); assert_eq!(delay.data, None); @@ -72,7 +72,7 @@ mod tests { #[test] fn test_unknown() { let elem: Element = "".parse().unwrap(); - let error = Delay::try_from(&elem).unwrap_err(); + let error = Delay::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -83,7 +83,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Delay::try_from(&elem).unwrap_err(); + let error = Delay::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -99,7 +99,7 @@ mod tests { stamp: "2002-09-10T23:08:25Z".to_owned(), data: None, }; - let elem2 = (&delay).into(); + let elem2 = delay.into(); assert_eq!(elem, elem2); } @@ -111,7 +111,7 @@ mod tests { stamp: "2002-09-10T23:08:25Z".to_owned(), data: Some(String::from("Reason")), }; - let elem2 = (&delay).into(); + let elem2 = delay.into(); assert_eq!(elem, elem2); } } diff --git a/src/disco.rs b/src/disco.rs index 9610ad7e7daa58aa8f0e4f5262936ac0aac12f43..acd2d4872f78411fe40f86b22d18cab1ec7144a9 100644 --- a/src/disco.rs +++ b/src/disco.rs @@ -34,10 +34,10 @@ pub struct Disco { pub extensions: Vec, } -impl<'a> TryFrom<&'a Element> for Disco { +impl TryFrom for Disco { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("query", ns::DISCO_INFO) { return Err(Error::ParseError("This is not a disco#info element.")); } @@ -74,7 +74,7 @@ impl<'a> TryFrom<&'a Element> for Disco { name: name, }); } else if child.is("x", ns::DATA_FORMS) { - let data_form = DataForm::try_from(child)?; + let data_form = DataForm::try_from(child.clone())?; if data_form.type_ != DataFormType::Result_ { return Err(Error::ParseError("Data form must have a 'result' type in disco#info.")); } @@ -109,13 +109,13 @@ impl<'a> TryFrom<&'a Element> for Disco { } } -impl<'a> Into for &'a Disco { +impl Into for Disco { fn into(self) -> Element { let mut root = Element::builder("query") .ns(ns::DISCO_INFO) .attr("node", self.node.clone()) .build(); - for identity in &self.identities { + for identity in self.identities { let identity_element = Element::builder("identity") .ns(ns::DISCO_INFO) .attr("category", identity.category.clone()) @@ -125,14 +125,14 @@ impl<'a> Into for &'a Disco { .build(); root.append_child(identity_element); } - for feature in &self.features { + 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 { + for _ in self.extensions { panic!("Not yet implemented!"); } root @@ -146,7 +146,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let query = Disco::try_from(&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); @@ -156,7 +156,7 @@ mod tests { #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -167,7 +167,7 @@ mod tests { #[test] fn test_invalid_identity() { let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -175,7 +175,7 @@ mod tests { assert_eq!(message, "Required attribute 'category' missing."); let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -183,7 +183,7 @@ mod tests { assert_eq!(message, "Identity must have a non-empty 'category' attribute."); let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -191,7 +191,7 @@ mod tests { assert_eq!(message, "Required attribute 'type' missing."); let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -202,7 +202,7 @@ mod tests { #[test] fn test_invalid_feature() { let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -214,7 +214,7 @@ mod tests { #[ignore] fn test_invalid_result() { let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -222,7 +222,7 @@ mod tests { assert_eq!(message, "There must be at least one identity in disco#info."); let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -230,7 +230,7 @@ mod tests { assert_eq!(message, "There must be at least one feature in disco#info."); let elem: Element = "".parse().unwrap(); - let error = Disco::try_from(&elem).unwrap_err(); + let error = Disco::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/ecaps2.rs b/src/ecaps2.rs index b69a6449d5efb0eab126dfd5d1e6bcd567a6df42..ac9df22edc6f3e3478963578b41b689037d4dcaa 100644 --- a/src/ecaps2.rs +++ b/src/ecaps2.rs @@ -25,17 +25,17 @@ pub struct ECaps2 { hashes: Vec, } -impl<'a> TryFrom<&'a Element> for ECaps2 { +impl TryFrom for ECaps2 { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("c", ns::ECAPS2) { return Err(Error::ParseError("This is not an ecaps2 element.")); } let mut hashes = vec!(); for child in elem.children() { if child.is("hash", ns::HASHES) { - let hash = Hash::try_from(child)?; + let hash = Hash::try_from(child.clone())?; hashes.push(hash); } else { return Err(Error::ParseError("Unknown child in ecaps2 element.")); @@ -47,12 +47,12 @@ impl<'a> TryFrom<&'a Element> for ECaps2 { } } -impl<'a> Into for &'a ECaps2 { +impl Into for ECaps2 { fn into(self) -> Element { Element::builder("c") .ns(ns::ECAPS2) .append(self.hashes.iter() - .map(|hash| hash.into()) + .map(|hash| hash.clone().into()) .collect::>()) .build() } @@ -175,7 +175,7 @@ mod tests { #[test] fn test_parse() { let elem: Element = "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=".parse().unwrap(); - let ecaps2 = ECaps2::try_from(&elem).unwrap(); + let ecaps2 = ECaps2::try_from(elem).unwrap(); assert_eq!(ecaps2.hashes.len(), 2); assert_eq!(ecaps2.hashes[0].algo, Algo::Sha_256); assert_eq!(ecaps2.hashes[0].hash, "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4="); @@ -186,7 +186,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=".parse().unwrap(); - let error = ECaps2::try_from(&elem).unwrap_err(); + let error = ECaps2::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -197,7 +197,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let disco = Disco::try_from(&elem).unwrap(); + let disco = Disco::try_from(elem).unwrap(); let ecaps2 = ecaps2::compute_disco(&disco); assert_eq!(ecaps2.len(), 54); } @@ -260,7 +260,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::try_from(&elem).unwrap(); + let disco = Disco::try_from(elem).unwrap(); let ecaps2 = ecaps2::compute_disco(&disco); assert_eq!(ecaps2.len(), 0x1d9); assert_eq!(ecaps2, expected); @@ -432,7 +432,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::try_from(&elem).unwrap(); + let disco = Disco::try_from(elem).unwrap(); let ecaps2 = ecaps2::compute_disco(&disco); assert_eq!(ecaps2.len(), 0x543); assert_eq!(ecaps2, expected); diff --git a/src/eme.rs b/src/eme.rs index 217517cef0710c13e89920d15205ba5afe40d4ae..edf6cd359ba443022f60d9227ed0e032728116a9 100644 --- a/src/eme.rs +++ b/src/eme.rs @@ -18,10 +18,10 @@ pub struct ExplicitMessageEncryption { pub name: Option, } -impl<'a> TryFrom<&'a Element> for ExplicitMessageEncryption { +impl TryFrom for ExplicitMessageEncryption { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("encryption", ns::EME) { return Err(Error::ParseError("This is not an encryption element.")); } @@ -37,7 +37,7 @@ impl<'a> TryFrom<&'a Element> for ExplicitMessageEncryption { } } -impl<'a> Into for &'a ExplicitMessageEncryption { +impl Into for ExplicitMessageEncryption { fn into(self) -> Element { Element::builder("encryption") .ns(ns::EME) @@ -54,12 +54,12 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let encryption = ExplicitMessageEncryption::try_from(&elem).unwrap(); + let encryption = ExplicitMessageEncryption::try_from(elem).unwrap(); assert_eq!(encryption.namespace, "urn:xmpp:otr:0"); assert_eq!(encryption.name, None); let elem: Element = "".parse().unwrap(); - let encryption = ExplicitMessageEncryption::try_from(&elem).unwrap(); + let encryption = ExplicitMessageEncryption::try_from(elem).unwrap(); assert_eq!(encryption.namespace, "some.unknown.mechanism"); assert_eq!(encryption.name, Some(String::from("SuperMechanism"))); } @@ -67,7 +67,7 @@ mod tests { #[test] fn test_unknown() { let elem: Element = "".parse().unwrap(); - let error = ExplicitMessageEncryption::try_from(&elem).unwrap_err(); + let error = ExplicitMessageEncryption::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -78,7 +78,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = ExplicitMessageEncryption::try_from(&elem).unwrap_err(); + let error = ExplicitMessageEncryption::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -90,7 +90,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let eme = ExplicitMessageEncryption { namespace: String::from("coucou"), name: None }; - let elem2 = (&eme).into(); + let elem2 = eme.into(); assert_eq!(elem, elem2); } } diff --git a/src/forwarding.rs b/src/forwarding.rs index a2162e06b110209c8b9e8001d0da0518c90255ad..9ad416b8fcf5ea23775bcac763b37235763c46c6 100644 --- a/src/forwarding.rs +++ b/src/forwarding.rs @@ -22,10 +22,10 @@ pub struct Forwarded { pub stanza: Option, } -impl<'a> TryFrom<&'a Element> for Forwarded { +impl TryFrom for Forwarded { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("forwarded", ns::FORWARD) { return Err(Error::ParseError("This is not a forwarded element.")); } @@ -33,9 +33,9 @@ impl<'a> TryFrom<&'a Element> for Forwarded { let mut stanza = None; for child in elem.children() { if child.is("delay", ns::DELAY) { - delay = Some(Delay::try_from(child)?); + delay = Some(Delay::try_from(child.clone())?); } else if child.is("message", ns::JABBER_CLIENT) { - stanza = Some(Message::try_from(child)?); + stanza = Some(Message::try_from(child.clone())?); // TODO: also handle the five other possibilities. } else { return Err(Error::ParseError("Unknown child in forwarded element.")); @@ -48,12 +48,12 @@ impl<'a> TryFrom<&'a Element> for Forwarded { } } -impl<'a> Into for &'a Forwarded { +impl Into for Forwarded { fn into(self) -> Element { Element::builder("forwarded") .ns(ns::FORWARD) - .append(match self.delay { Some(ref delay) => { let elem: Element = delay.into(); Some(elem) }, None => None }) - .append(match self.stanza { Some(ref stanza) => { let elem: Element = stanza.into(); Some(elem) }, None => None }) + .append(match self.delay { Some(delay) => { let elem: Element = delay.into(); Some(elem) }, None => None }) + .append(match self.stanza { Some(stanza) => { let elem: Element = stanza.into(); Some(elem) }, None => None }) .build() } } @@ -65,13 +65,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Forwarded::try_from(&elem).unwrap(); + Forwarded::try_from(elem).unwrap(); } #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Forwarded::try_from(&elem).unwrap_err(); + let error = Forwarded::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -83,7 +83,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let forwarded = Forwarded { delay: None, stanza: None }; - let elem2 = (&forwarded).into(); + let elem2 = forwarded.into(); assert_eq!(elem, elem2); } } diff --git a/src/hashes.rs b/src/hashes.rs index da16788b9578af631dde3f584f8e38bdc6b97cf5..af9c3a053c81626161b09b2fe0b011249b9899b4 100644 --- a/src/hashes.rs +++ b/src/hashes.rs @@ -66,10 +66,10 @@ pub struct Hash { pub hash: String, } -impl<'a> TryFrom<&'a Element> for Hash { +impl TryFrom for Hash { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("hash", ns::HASHES) { return Err(Error::ParseError("This is not a hash element.")); } @@ -88,11 +88,11 @@ impl<'a> TryFrom<&'a Element> for Hash { } } -impl<'a> Into for &'a Hash { +impl Into for Hash { fn into(self) -> Element { Element::builder("hash") .ns(ns::HASHES) - .attr("algo", self.algo.clone()) + .attr("algo", self.algo) .append(self.hash.clone()) .build() } @@ -105,7 +105,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=".parse().unwrap(); - let hash = Hash::try_from(&elem).unwrap(); + let hash = Hash::try_from(elem).unwrap(); assert_eq!(hash.algo, Algo::Sha_256); assert_eq!(hash.hash, "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU="); } @@ -113,7 +113,7 @@ mod tests { #[test] fn test_unknown() { let elem: Element = "".parse().unwrap(); - let error = Hash::try_from(&elem).unwrap_err(); + let error = Hash::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -124,7 +124,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Hash::try_from(&elem).unwrap_err(); + let error = Hash::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/ibb.rs b/src/ibb.rs index ffdb907e15fcabdd4ffba3410c270d217c4c5db6..71bf69511aa1bcd4143340dd53b6bff328fad5c9 100644 --- a/src/ibb.rs +++ b/src/ibb.rs @@ -65,10 +65,10 @@ pub enum IBB { }, } -impl<'a> TryFrom<&'a Element> for IBB { +impl TryFrom for IBB { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if elem.is("open", ns::IBB) { for _ in elem.children() { return Err(Error::ParseError("Unknown child in open element.")); @@ -107,29 +107,29 @@ impl<'a> TryFrom<&'a Element> for IBB { } } -impl<'a> Into for &'a IBB { +impl Into for IBB { fn into(self) -> Element { - match *self { - IBB::Open { ref block_size, ref sid, ref stanza } => { + match self { + IBB::Open { block_size, sid, stanza } => { Element::builder("open") .ns(ns::IBB) .attr("block-size", format!("{}", block_size)) - .attr("sid", sid.to_owned()) - .attr("stanza", stanza.to_owned()) + .attr("sid", sid) + .attr("stanza", stanza) .build() }, - IBB::Data { ref seq, ref sid, ref data } => { + IBB::Data { seq, sid, data } => { Element::builder("data") .ns(ns::IBB) .attr("seq", format!("{}", seq)) - .attr("sid", sid.to_owned()) + .attr("sid", sid) .append(base64::encode(&data)) .build() }, - IBB::Close { ref sid } => { + IBB::Close { sid } => { Element::builder("close") .ns(ns::IBB) - .attr("sid", sid.to_owned()) + .attr("sid", sid) .build() }, } @@ -144,7 +144,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let open = IBB::try_from(&elem).unwrap(); + let open = IBB::try_from(elem).unwrap(); match open { IBB::Open { block_size, sid, stanza } => { assert_eq!(block_size, 3); @@ -155,7 +155,7 @@ mod tests { } let elem: Element = "AAAA".parse().unwrap(); - let data = IBB::try_from(&elem).unwrap(); + let data = IBB::try_from(elem).unwrap(); match data { IBB::Data { seq, sid, data } => { assert_eq!(seq, 0); @@ -166,7 +166,7 @@ mod tests { } let elem: Element = "".parse().unwrap(); - let close = IBB::try_from(&elem).unwrap(); + let close = IBB::try_from(elem).unwrap(); match close { IBB::Close { sid } => { assert_eq!(sid, "coucou"); @@ -178,7 +178,7 @@ mod tests { #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = IBB::try_from(&elem).unwrap_err(); + let error = IBB::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -186,7 +186,7 @@ mod tests { assert_eq!(message, "Required attribute 'block-size' missing."); let elem: Element = "".parse().unwrap(); - let error = IBB::try_from(&elem).unwrap_err(); + let error = IBB::try_from(elem).unwrap_err(); let message = match error { Error::ParseIntError(error) => error, _ => panic!(), @@ -194,7 +194,7 @@ mod tests { assert_eq!(message.description(), "invalid digit found in string"); let elem: Element = "".parse().unwrap(); - let error = IBB::try_from(&elem).unwrap_err(); + let error = IBB::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(error) => error, _ => panic!(), @@ -205,7 +205,7 @@ mod tests { #[test] fn test_invalid_stanza() { let elem: Element = "".parse().unwrap(); - let error = IBB::try_from(&elem).unwrap_err(); + let error = IBB::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/idle.rs b/src/idle.rs index 5261788e1c10abcee5417873753d87471a82184c..2800a0e1854b05c1db54970a8ca982eb21f81da2 100644 --- a/src/idle.rs +++ b/src/idle.rs @@ -19,10 +19,10 @@ pub struct Idle { pub since: Date, } -impl<'a> TryFrom<&'a Element> for Idle { +impl TryFrom for Idle { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("idle", ns::IDLE) { return Err(Error::ParseError("This is not an idle element.")); } @@ -34,7 +34,7 @@ impl<'a> TryFrom<&'a Element> for Idle { } } -impl<'a> Into for &'a Idle { +impl Into for Idle { fn into(self) -> Element { Element::builder("idle") .ns(ns::IDLE) @@ -50,13 +50,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Idle::try_from(&elem).unwrap(); + Idle::try_from(elem).unwrap(); } #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Idle::try_from(&elem).unwrap_err(); + let error = Idle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -67,7 +67,7 @@ mod tests { #[test] fn test_invalid_id() { let elem: Element = "".parse().unwrap(); - let error = Idle::try_from(&elem).unwrap_err(); + let error = Idle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -79,7 +79,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let idle = Idle { since: Date::from("2017-05-21T20:19:55+01:00") }; - let elem2 = (&idle).into(); + let elem2 = idle.into(); assert_eq!(elem, elem2); } } diff --git a/src/iq.rs b/src/iq.rs index b1767735662b6ef4245166c4557fd925c4d3290d..aaf7b027998ce5bf2818645892a9a06c79023b00 100644 --- a/src/iq.rs +++ b/src/iq.rs @@ -37,13 +37,13 @@ pub enum IqPayload { Unknown(Element), } -impl<'a> TryFrom<&'a Element> for IqPayload { +impl TryFrom for IqPayload { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { // XEP-0030 - ("query", ns::DISCO_INFO) => IqPayload::Disco(Disco::try_from(elem)?), + ("query", ns::DISCO_INFO) => IqPayload::Disco(Disco::try_from(elem.clone())?), // XEP-0047 ("open", ns::IBB) @@ -93,10 +93,10 @@ pub struct Iq { pub payload: IqType, } -impl<'a> TryFrom<&'a Element> for Iq { +impl TryFrom for Iq { type Error = Error; - fn try_from(root: &'a Element) -> Result { + fn try_from(root: Element) -> Result { if !root.is("iq", ns::JABBER_CLIENT) { return Err(Error::ParseError("This is not an iq element.")); } @@ -116,7 +116,7 @@ impl<'a> TryFrom<&'a Element> for Iq { if error_payload.is_some() { return Err(Error::ParseError("Wrong number of children in iq element.")); } - error_payload = Some(StanzaError::try_from(elem)?); + error_payload = Some(StanzaError::try_from(elem.clone())?); } else if root.children().collect::>().len() != 2 { return Err(Error::ParseError("Wrong number of children in iq element.")); } @@ -162,23 +162,23 @@ impl<'a> TryFrom<&'a Element> for Iq { } } -impl<'a> Into for &'a IqPayload { +impl Into for IqPayload { fn into(self) -> Element { - match *self { - IqPayload::Disco(ref disco) => disco.into(), - IqPayload::IBB(ref ibb) => ibb.into(), - IqPayload::Jingle(ref jingle) => jingle.into(), - IqPayload::Ping(ref ping) => ping.into(), - IqPayload::MamQuery(ref query) => query.into(), - IqPayload::MamFin(ref fin) => fin.into(), - IqPayload::MamPrefs(ref prefs) => prefs.into(), - - IqPayload::Unknown(ref elem) => elem.clone(), + match self { + IqPayload::Disco(disco) => disco.into(), + IqPayload::IBB(ibb) => ibb.into(), + IqPayload::Jingle(jingle) => jingle.into(), + IqPayload::Ping(ping) => ping.into(), + IqPayload::MamQuery(query) => query.into(), + IqPayload::MamFin(fin) => fin.into(), + IqPayload::MamPrefs(prefs) => prefs.into(), + + IqPayload::Unknown(elem) => elem.clone(), } } } -impl<'a> Into for &'a Iq { +impl Into for Iq { fn into(self) -> Element { let mut stanza = Element::builder("iq") .ns(ns::JABBER_CLIENT) @@ -191,7 +191,7 @@ impl<'a> Into for &'a Iq { IqType::Get(elem) | IqType::Set(elem) | IqType::Result(Some(elem)) => elem, - IqType::Error(error) => (&error).into(), + IqType::Error(error) => error.into(), IqType::Result(None) => return stanza, }; stanza.append_child(elem); @@ -207,7 +207,7 @@ mod tests { #[test] fn test_require_type() { let elem: Element = "".parse().unwrap(); - let error = Iq::try_from(&elem).unwrap_err(); + let error = Iq::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -220,7 +220,7 @@ mod tests { let elem: Element = " ".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); let query: Element = "".parse().unwrap(); assert_eq!(iq.from, None); assert_eq!(iq.to, None); @@ -236,7 +236,7 @@ mod tests { let elem: Element = " ".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); let vcard: Element = "".parse().unwrap(); assert_eq!(iq.from, None); assert_eq!(iq.to, None); @@ -250,7 +250,7 @@ mod tests { #[test] fn test_result_empty() { let elem: Element = "".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); assert_eq!(iq.from, None); assert_eq!(iq.to, None); assert_eq!(iq.id, None); @@ -265,7 +265,7 @@ mod tests { let elem: Element = " ".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); let query: Element = "".parse().unwrap(); assert_eq!(iq.from, None); assert_eq!(iq.to, None); @@ -284,7 +284,7 @@ mod tests { ".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); assert_eq!(iq.from, None); assert_eq!(iq.to, None); assert_eq!(iq.id, None); @@ -303,7 +303,7 @@ mod tests { #[test] fn test_children_invalid() { let elem: Element = "".parse().unwrap(); - let error = Iq::try_from(&elem).unwrap_err(); + let error = Iq::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -320,16 +320,16 @@ mod tests { id: None, payload: IqType::Result(None), }; - let elem2 = (&iq2).into(); + let elem2 = iq2.into(); assert_eq!(elem, elem2); } #[test] fn test_disco() { let elem: Element = "".parse().unwrap(); - let iq = Iq::try_from(&elem).unwrap(); + let iq = Iq::try_from(elem).unwrap(); let payload = match iq.payload { - IqType::Get(ref payload) => IqPayload::try_from(payload).unwrap(), + IqType::Get(payload) => IqPayload::try_from(payload).unwrap(), _ => panic!(), }; assert!(match payload { diff --git a/src/jingle.rs b/src/jingle.rs index fb928aee94f0a113f05027a6e8abee5105cd154d..4796ae41bcfa926d4f2b859926677fe9c7bfa420 100644 --- a/src/jingle.rs +++ b/src/jingle.rs @@ -204,9 +204,9 @@ impl FromStr for Reason { } } -impl<'a> Into for &'a Reason { +impl Into for Reason { fn into(self) -> Element { - Element::builder(match *self { + Element::builder(match self { Reason::AlternativeSession => "alternative-session", Reason::Busy => "busy", Reason::Cancel => "cancel", @@ -245,10 +245,10 @@ pub struct Jingle { pub other: Vec, } -impl<'a> TryFrom<&'a Element> for Jingle { +impl TryFrom for Jingle { type Error = Error; - fn try_from(root: &'a Element) -> Result { + fn try_from(root: Element) -> Result { if !root.is("jingle", ns::JINGLE) { return Err(Error::ParseError("This is not a Jingle element.")); } @@ -353,7 +353,7 @@ impl<'a> TryFrom<&'a Element> for Jingle { } } -impl<'a> Into for &'a Content { +impl Into for Content { fn into(self) -> Element { let mut root = Element::builder("content") .ns(ns::JINGLE) @@ -375,7 +375,7 @@ impl<'a> Into for &'a Content { } } -impl<'a> Into for &'a Jingle { +impl Into for Jingle { fn into(self) -> Element { let mut root = Element::builder("jingle") .ns(ns::JINGLE) @@ -384,15 +384,15 @@ impl<'a> Into for &'a Jingle { .attr("responder", self.responder.clone()) .attr("sid", self.sid.clone()) .build(); - for content in self.contents.clone() { - let content_elem = (&content).into(); + for content in self.contents { + let content_elem = content.into(); root.append_child(content_elem); } - if let Some(ref reason) = self.reason { - let reason2: Element = (&reason.reason).into(); + if let Some(reason) = self.reason { + let reason2: Element = reason.reason.into(); let reason_elem = Element::builder("reason") .append(reason2) - .append(reason.text.clone()) + .append(reason.text) .build(); root.append_child(reason_elem); } @@ -400,12 +400,6 @@ impl<'a> Into for &'a Jingle { } } -impl Into for Jingle { - fn into(self) -> Element { - (&self).into() - } -} - #[cfg(test)] mod tests { use super::*; @@ -413,7 +407,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); assert_eq!(jingle.action, Action::SessionInitiate); assert_eq!(jingle.sid, "coucou"); } @@ -421,7 +415,7 @@ mod tests { #[test] fn test_invalid_jingle() { let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -429,7 +423,7 @@ mod tests { assert_eq!(message, "Jingle must have an 'action' attribute."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -437,7 +431,7 @@ mod tests { assert_eq!(message, "Jingle must have a 'sid' attribute."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -448,25 +442,25 @@ mod tests { #[test] fn test_content() { let elem: Element = "".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); assert_eq!(jingle.contents[0].creator, Creator::Initiator); assert_eq!(jingle.contents[0].name, "coucou"); assert_eq!(jingle.contents[0].senders, Senders::Both); assert_eq!(jingle.contents[0].disposition, "session"); let elem: Element = "".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); assert_eq!(jingle.contents[0].senders, Senders::Both); let elem: Element = "".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); assert_eq!(jingle.contents[0].disposition, "early-session"); } #[test] fn test_invalid_content() { let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -474,7 +468,7 @@ mod tests { assert_eq!(message, "Content must have a 'creator' attribute."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -482,7 +476,7 @@ mod tests { assert_eq!(message, "Content must have a 'name' attribute."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -490,7 +484,7 @@ mod tests { assert_eq!(message, "Unknown creator."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -498,7 +492,7 @@ mod tests { assert_eq!(message, "Unknown senders."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -509,13 +503,13 @@ mod tests { #[test] fn test_reason() { let elem: Element = "".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); let reason = jingle.reason.unwrap(); assert_eq!(reason.reason, Reason::Success); assert_eq!(reason.text, None); let elem: Element = "coucou".parse().unwrap(); - let jingle = Jingle::try_from(&elem).unwrap(); + let jingle = Jingle::try_from(elem).unwrap(); let reason = jingle.reason.unwrap(); assert_eq!(reason.reason, Reason::Success); assert_eq!(reason.text, Some(String::from("coucou"))); @@ -524,7 +518,7 @@ mod tests { #[test] fn test_invalid_reason() { let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -532,7 +526,7 @@ mod tests { assert_eq!(message, "Reason doesn’t contain a valid reason."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -540,7 +534,7 @@ mod tests { assert_eq!(message, "Unknown reason."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -548,7 +542,7 @@ mod tests { assert_eq!(message, "Reason contains a foreign element."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -556,7 +550,7 @@ mod tests { assert_eq!(message, "Jingle must not have more than one reason."); let elem: Element = "".parse().unwrap(); - let error = Jingle::try_from(&elem).unwrap_err(); + let error = Jingle::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/jingle_ft.rs b/src/jingle_ft.rs index 454ce8d4a54d1c026e1fcb356515624638d522fc..57cf626cf6ce235ea06be2b761dd0e5ca8677ae3 100644 --- a/src/jingle_ft.rs +++ b/src/jingle_ft.rs @@ -31,7 +31,7 @@ impl IntoElements for Range { }) .build(); for hash in self.hashes { - elem.append_child((&hash).into()); + elem.append_child(hash.into()); } emitter.append_child(elem); } @@ -86,10 +86,10 @@ impl IntoElements for Received { } } -impl<'a> TryFrom<&'a Element> for Description { +impl TryFrom for Description { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("description", ns::JINGLE_FT) { return Err(Error::ParseError("This is not a JingleFT description element.")); } @@ -145,7 +145,7 @@ impl<'a> TryFrom<&'a Element> for Description { if !hash_element.is("hash", ns::HASHES) { return Err(Error::ParseError("Unknown element in JingleFT range.")); } - range_hashes.push(Hash::try_from(hash_element)?); + range_hashes.push(Hash::try_from(hash_element.clone())?); } range = Some(Range { offset: offset, @@ -153,7 +153,7 @@ impl<'a> TryFrom<&'a Element> for Description { hashes: range_hashes, }); } else if file_payload.is("hash", ns::HASHES) { - hashes.push(Hash::try_from(file_payload)?); + hashes.push(Hash::try_from(file_payload.clone())?); } else { return Err(Error::ParseError("Unknown element in JingleFT file.")); } @@ -174,57 +174,57 @@ impl<'a> TryFrom<&'a Element> for Description { } } -impl<'a> Into for &'a File { +impl Into for File { fn into(self) -> Element { let mut root = Element::builder("file") .ns(ns::JINGLE_FT) .build(); - if let Some(ref date) = self.date { + if let Some(date) = self.date { root.append_child(Element::builder("date") .ns(ns::JINGLE_FT) - .append(date.clone()) + .append(date) .build()); } - if let Some(ref media_type) = self.media_type { + if let Some(media_type) = self.media_type { root.append_child(Element::builder("media-type") .ns(ns::JINGLE_FT) - .append(media_type.clone()) + .append(media_type) .build()); } - if let Some(ref name) = self.name { + if let Some(name) = self.name { root.append_child(Element::builder("name") .ns(ns::JINGLE_FT) - .append(name.clone()) + .append(name) .build()); } - if let Some(ref desc) = self.desc { + if let Some(desc) = self.desc { root.append_child(Element::builder("desc") .ns(ns::JINGLE_FT) - .append(desc.clone()) + .append(desc) .build()); } - if let Some(ref size) = self.size { + if let Some(size) = self.size { root.append_child(Element::builder("size") .ns(ns::JINGLE_FT) .append(format!("{}", size)) .build()); } - if let Some(ref range) = self.range { + if let Some(range) = self.range { root.append_child(Element::builder("range") .ns(ns::JINGLE_FT) - .append(range.clone()) + .append(range) .build()); } - for hash in self.hashes.clone() { - root.append_child((&hash).into()); + for hash in self.hashes { + root.append_child(hash.into()); } root } } -impl<'a> Into for &'a Description { +impl Into for Description { fn into(self) -> Element { - let file: Element = (&self.file).into(); + let file: Element = self.file.into(); Element::builder("description") .ns(ns::JINGLE_FT) .append(file) @@ -252,7 +252,7 @@ mod tests { "#.parse().unwrap(); - let desc = Description::try_from(&elem).unwrap(); + let desc = Description::try_from(elem).unwrap(); assert_eq!(desc.file.media_type, Some(String::from("text/plain"))); assert_eq!(desc.file.name, Some(String::from("test.txt"))); assert_eq!(desc.file.desc, None); @@ -274,7 +274,7 @@ mod tests { "#.parse().unwrap(); - let desc = Description::try_from(&elem).unwrap(); + let desc = Description::try_from(elem).unwrap(); assert_eq!(desc.file.media_type, None); assert_eq!(desc.file.name, None); assert_eq!(desc.file.desc, None); diff --git a/src/jingle_ibb.rs b/src/jingle_ibb.rs index 73544c26666b6eb2efbff481b42c24a741ca0411..d89df221f80ce5a79d810d0ae334c03b999e053e 100644 --- a/src/jingle_ibb.rs +++ b/src/jingle_ibb.rs @@ -21,10 +21,10 @@ pub struct Transport { pub stanza: Stanza, } -impl<'a> TryFrom<&'a Element> for Transport { +impl TryFrom for Transport { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if elem.is("transport", ns::JINGLE_IBB) { for _ in elem.children() { return Err(Error::ParseError("Unknown child in JingleIBB element.")); @@ -43,7 +43,7 @@ impl<'a> TryFrom<&'a Element> for Transport { } } -impl<'a> Into for &'a Transport { +impl Into for Transport { fn into(self) -> Element { Element::builder("transport") .ns(ns::JINGLE_IBB) @@ -62,7 +62,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let transport = Transport::try_from(&elem).unwrap(); + let transport = Transport::try_from(elem).unwrap(); assert_eq!(transport.block_size, 3); assert_eq!(transport.sid, "coucou"); assert_eq!(transport.stanza, Stanza::Iq); @@ -71,7 +71,7 @@ mod tests { #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = Transport::try_from(&elem).unwrap_err(); + let error = Transport::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -79,7 +79,7 @@ mod tests { assert_eq!(message, "Required attribute 'block-size' missing."); let elem: Element = "".parse().unwrap(); - let error = Transport::try_from(&elem).unwrap_err(); + let error = Transport::try_from(elem).unwrap_err(); let message = match error { Error::ParseIntError(error) => error, _ => panic!(), @@ -87,7 +87,7 @@ mod tests { assert_eq!(message.description(), "number too large to fit in target type"); let elem: Element = "".parse().unwrap(); - let error = Transport::try_from(&elem).unwrap_err(); + let error = Transport::try_from(elem).unwrap_err(); let message = match error { Error::ParseIntError(error) => error, _ => panic!(), @@ -95,7 +95,7 @@ mod tests { assert_eq!(message.description(), "invalid digit found in string"); let elem: Element = "".parse().unwrap(); - let error = Transport::try_from(&elem).unwrap_err(); + let error = Transport::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -106,7 +106,7 @@ mod tests { #[test] fn test_invalid_stanza() { let elem: Element = "".parse().unwrap(); - let error = Transport::try_from(&elem).unwrap_err(); + let error = Transport::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/jingle_s5b.rs b/src/jingle_s5b.rs index cb43e743c9fc0d60a37870fe5d2e4d747208ccff..fa5ee667e6bb3b1b7c1d939c944808ac2f2f0167 100644 --- a/src/jingle_s5b.rs +++ b/src/jingle_s5b.rs @@ -63,7 +63,7 @@ pub struct Candidate { pub type_: Type, } -impl<'a> Into for &'a Candidate { +impl Into for Candidate { fn into(self) -> Element { Element::builder("candidate") .ns(ns::JINGLE_S5B) @@ -129,10 +129,10 @@ pub struct Transport { pub payload: TransportPayload, } -impl<'a> TryFrom<&'a Element> for Transport { +impl TryFrom for Transport { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if elem.is("transport", ns::JINGLE_S5B) { let sid = get_attr!(elem, "sid", required); let dstaddr = get_attr!(elem, "dstaddr", optional); @@ -200,7 +200,7 @@ impl<'a> TryFrom<&'a Element> for Transport { } } -impl<'a> Into for &'a Transport { +impl Into for Transport { fn into(self) -> Element { Element::builder("transport") .ns(ns::JINGLE_S5B) @@ -208,15 +208,15 @@ impl<'a> Into for &'a Transport { .attr("dstaddr", self.dstaddr.clone()) .attr("mode", self.mode.clone()) .append(match self.payload { - TransportPayload::Candidates(ref candidates) => { + TransportPayload::Candidates(candidates) => { candidates.iter() - .map(|candidate| -> Element { candidate.into() }) + .map(|candidate| -> Element { candidate.clone().into() }) .collect::>() }, - TransportPayload::Activated(ref cid) => { + TransportPayload::Activated(cid) => { vec!(Element::builder("activated") .ns(ns::JINGLE_S5B) - .attr("cid", cid.to_owned()) + .attr("cid", cid) .build()) }, TransportPayload::CandidateError => { @@ -248,7 +248,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let transport = Transport::try_from(&elem).unwrap(); + let transport = Transport::try_from(elem).unwrap(); assert_eq!(transport.sid, "coucou"); assert_eq!(transport.dstaddr, None); assert_eq!(transport.mode, Mode::Tcp); @@ -267,7 +267,7 @@ mod tests { mode: Mode::Tcp, payload: TransportPayload::Activated(String::from("coucou")), }; - let elem2: Element = (&transport).into(); + let elem2: Element = transport.into(); assert_eq!(elem, elem2); } @@ -287,7 +287,7 @@ mod tests { type_: Type::Direct, })), }; - let elem2: Element = (&transport).into(); + let elem2: Element = transport.into(); assert_eq!(elem, elem2); } } diff --git a/src/mam.rs b/src/mam.rs index b673154bd20685a25c160669ce026546ac8c5074..22ec0576fa4f1d45da3eb2fcf1858269a9c8b83a 100644 --- a/src/mam.rs +++ b/src/mam.rs @@ -60,9 +60,9 @@ impl FromStr for DefaultPrefs { } } -impl<'a> IntoAttributeValue for &'a DefaultPrefs { +impl IntoAttributeValue for DefaultPrefs { fn into_attribute_value(self) -> Option { - Some(String::from(match *self { + Some(String::from(match self { DefaultPrefs::Always => "always", DefaultPrefs::Never => "never", DefaultPrefs::Roster => "roster", @@ -77,10 +77,10 @@ pub struct Prefs { pub never: Vec, } -impl<'a> TryFrom<&'a Element> for Query { +impl TryFrom for Query { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("query", ns::MAM) { return Err(Error::ParseError("This is not a query element.")); } @@ -88,9 +88,9 @@ impl<'a> TryFrom<&'a Element> for Query { let mut set = None; for child in elem.children() { if child.is("x", ns::DATA_FORMS) { - form = Some(DataForm::try_from(child)?); + form = Some(DataForm::try_from(child.clone())?); } else if child.is("set", ns::RSM) { - set = Some(Set::try_from(child)?); + set = Some(Set::try_from(child.clone())?); } else { return Err(Error::ParseError("Unknown child in query element.")); } @@ -101,17 +101,17 @@ impl<'a> TryFrom<&'a Element> for Query { } } -impl<'a> TryFrom<&'a Element> for Result_ { +impl TryFrom for Result_ { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("result", ns::MAM) { return Err(Error::ParseError("This is not a result element.")); } let mut forwarded = None; for child in elem.children() { if child.is("forwarded", ns::FORWARD) { - forwarded = Some(Forwarded::try_from(child)?); + forwarded = Some(Forwarded::try_from(child.clone())?); } else { return Err(Error::ParseError("Unknown child in result element.")); } @@ -127,17 +127,17 @@ impl<'a> TryFrom<&'a Element> for Result_ { } } -impl<'a> TryFrom<&'a Element> for Fin { +impl TryFrom for Fin { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("fin", ns::MAM) { return Err(Error::ParseError("This is not a fin element.")); } let mut set = None; for child in elem.children() { if child.is("set", ns::RSM) { - set = Some(Set::try_from(child)?); + set = Some(Set::try_from(child.clone())?); } else { return Err(Error::ParseError("Unknown child in fin element.")); } @@ -153,10 +153,10 @@ impl<'a> TryFrom<&'a Element> for Fin { } } -impl<'a> TryFrom<&'a Element> for Prefs { +impl TryFrom for Prefs { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("prefs", ns::MAM) { return Err(Error::ParseError("This is not a prefs element.")); } @@ -186,7 +186,7 @@ impl<'a> TryFrom<&'a Element> for Prefs { } } -impl<'a> Into for &'a Query { +impl Into for Query { fn into(self) -> Element { let mut elem = Element::builder("query") .ns(ns::MAM) @@ -194,43 +194,43 @@ impl<'a> Into for &'a Query { .attr("node", self.node.clone()) .build(); //if let Some(form) = self.form { - // elem.append_child((&form).into()); + // elem.append_child(form.into()); //} - if let Some(ref set) = self.set { + if let Some(set) = self.set { elem.append_child(set.into()); } elem } } -impl<'a> Into for &'a Result_ { +impl Into for Result_ { fn into(self) -> Element { let mut elem = Element::builder("result") .ns(ns::MAM) - .attr("queryid", self.queryid.clone()) - .attr("id", self.id.clone()) + .attr("queryid", self.queryid) + .attr("id", self.id) .build(); - elem.append_child((&self.forwarded).into()); + elem.append_child(self.forwarded.into()); elem } } -impl<'a> Into for &'a Fin { +impl Into for Fin { fn into(self) -> Element { let mut elem = Element::builder("fin") .ns(ns::MAM) .attr("complete", if self.complete { Some("true") } else { None }) .build(); - elem.append_child((&self.set).into()); + elem.append_child(self.set.into()); elem } } -impl<'a> Into for &'a Prefs { +impl Into for Prefs { fn into(self) -> Element { let mut elem = Element::builder("prefs") .ns(ns::MAM) - .attr("default", &self.default_) + .attr("default", self.default_) .build(); if !self.always.is_empty() { let mut always = Element::builder("always") @@ -267,7 +267,7 @@ mod tests { #[test] fn test_query() { let elem: Element = "".parse().unwrap(); - Query::try_from(&elem).unwrap(); + Query::try_from(elem).unwrap(); } #[test] @@ -282,7 +282,7 @@ mod tests { "#.parse().unwrap(); - Result_::try_from(&elem).unwrap(); + Result_::try_from(elem).unwrap(); } #[test] @@ -295,7 +295,7 @@ mod tests { "#.parse().unwrap(); - Fin::try_from(&elem).unwrap(); + Fin::try_from(elem).unwrap(); } #[test] @@ -312,7 +312,7 @@ mod tests { "#.parse().unwrap(); - Query::try_from(&elem).unwrap(); + Query::try_from(elem).unwrap(); } #[test] @@ -332,13 +332,13 @@ mod tests { "#.parse().unwrap(); - Query::try_from(&elem).unwrap(); + Query::try_from(elem).unwrap(); } #[test] fn test_prefs_get() { let elem: Element = "".parse().unwrap(); - Prefs::try_from(&elem).unwrap(); + Prefs::try_from(elem).unwrap(); let elem: Element = r#" @@ -346,7 +346,7 @@ mod tests { "#.parse().unwrap(); - Prefs::try_from(&elem).unwrap(); + Prefs::try_from(elem).unwrap(); } #[test] @@ -361,13 +361,13 @@ mod tests { "#.parse().unwrap(); - Prefs::try_from(&elem).unwrap(); + Prefs::try_from(elem).unwrap(); } #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Query::try_from(&elem).unwrap_err(); + let error = Query::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -379,7 +379,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let replace = Query { queryid: None, node: None, form: None, set: None }; - let elem2 = (&replace).into(); + let elem2 = replace.into(); assert_eq!(elem, elem2); } } diff --git a/src/media_element.rs b/src/media_element.rs index d4d31985caad71b54afa050ddd0594a30a9650f3..54ffee132eb5a6ee7b20bbd4012e166b6d7d8cb4 100644 --- a/src/media_element.rs +++ b/src/media_element.rs @@ -25,10 +25,10 @@ pub struct MediaElement { pub uris: Vec, } -impl<'a> TryFrom<&'a Element> for MediaElement { +impl TryFrom for MediaElement { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("media", ns::MEDIA_ELEMENT) { return Err(Error::ParseError("This is not a media element.")); } @@ -60,7 +60,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.width.is_none()); assert!(media.height.is_none()); assert!(media.uris.is_empty()); @@ -69,7 +69,7 @@ mod tests { #[test] fn test_width_height() { let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert_eq!(media.width.unwrap(), 32); assert_eq!(media.height.unwrap(), 32); } @@ -77,7 +77,7 @@ mod tests { #[test] fn test_uri() { let elem: Element = "https://example.org/".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert_eq!(media.uris.len(), 1); assert_eq!(media.uris[0].type_, "text/html"); assert_eq!(media.uris[0].uri, "https://example.org/"); @@ -86,26 +86,26 @@ mod tests { #[test] fn test_invalid_width_height() { let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.width.is_none()); let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.width.is_none()); let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.height.is_none()); let elem: Element = "".parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.height.is_none()); } #[test] fn test_unknown_child() { let elem: Element = "".parse().unwrap(); - let error = MediaElement::try_from(&elem).unwrap_err(); + let error = MediaElement::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -116,7 +116,7 @@ mod tests { #[test] fn test_bad_uri() { let elem: Element = "https://example.org/".parse().unwrap(); - let error = MediaElement::try_from(&elem).unwrap_err(); + let error = MediaElement::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -124,7 +124,7 @@ mod tests { assert_eq!(message, "Attribute type on uri is mandatory."); let elem: Element = "".parse().unwrap(); - let error = MediaElement::try_from(&elem).unwrap_err(); + let error = MediaElement::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -146,7 +146,7 @@ mod tests { http://victim.example.com/challenges/speech.mp3?F3A6292C "#.parse().unwrap(); - let media = MediaElement::try_from(&elem).unwrap(); + let media = MediaElement::try_from(elem).unwrap(); assert!(media.width.is_none()); assert!(media.height.is_none()); assert_eq!(media.uris.len(), 3); @@ -177,7 +177,7 @@ mod tests { [ ... ] "#.parse().unwrap(); - let form = DataForm::try_from(&elem).unwrap(); + let form = DataForm::try_from(elem).unwrap(); assert_eq!(form.fields.len(), 1); assert_eq!(form.fields[0].var, "ocr"); assert_eq!(form.fields[0].media[0].width, Some(290)); diff --git a/src/message.rs b/src/message.rs index a309fa015ff4a4490148efd8c4218b85685861c5..be47756a5c2d622dafc77936184c9e13e6621d7f 100644 --- a/src/message.rs +++ b/src/message.rs @@ -42,10 +42,10 @@ pub enum MessagePayload { Unknown(Element), } -impl<'a> TryFrom<&'a Element> for MessagePayload { +impl TryFrom for MessagePayload { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { ("error", ns::JABBER_CLIENT) => MessagePayload::StanzaError(StanzaError::try_from(elem)?), @@ -84,20 +84,20 @@ impl<'a> TryFrom<&'a Element> for MessagePayload { } } -impl<'a> Into for &'a MessagePayload { +impl Into for MessagePayload { fn into(self) -> Element { - match *self { - MessagePayload::StanzaError(ref stanza_error) => stanza_error.into(), - MessagePayload::Attention(ref attention) => attention.into(), - MessagePayload::ChatState(ref chatstate) => chatstate.into(), - MessagePayload::Receipt(ref receipt) => receipt.into(), - MessagePayload::Delay(ref delay) => delay.into(), - MessagePayload::MessageCorrect(ref replace) => replace.into(), - MessagePayload::ExplicitMessageEncryption(ref eme) => eme.into(), - MessagePayload::StanzaId(ref stanza_id) => stanza_id.into(), - MessagePayload::MamResult(ref result) => result.into(), - - MessagePayload::Unknown(ref elem) => elem.clone(), + match self { + MessagePayload::StanzaError(stanza_error) => stanza_error.into(), + MessagePayload::Attention(attention) => attention.into(), + MessagePayload::ChatState(chatstate) => chatstate.into(), + MessagePayload::Receipt(receipt) => receipt.into(), + MessagePayload::Delay(delay) => delay.into(), + MessagePayload::MessageCorrect(replace) => replace.into(), + MessagePayload::ExplicitMessageEncryption(eme) => eme.into(), + MessagePayload::StanzaId(stanza_id) => stanza_id.into(), + MessagePayload::MamResult(result) => result.into(), + + MessagePayload::Unknown(elem) => elem.clone(), } } } @@ -162,10 +162,10 @@ pub struct Message { pub payloads: Vec, } -impl<'a> TryFrom<&'a Element> for Message { +impl TryFrom for Message { type Error = Error; - fn try_from(root: &'a Element) -> Result { + fn try_from(root: Element) -> Result { if !root.is("message", ns::JABBER_CLIENT) { return Err(Error::ParseError("This is not a message element.")); } @@ -219,7 +219,7 @@ impl<'a> TryFrom<&'a Element> for Message { } } -impl<'a> Into for &'a Message { +impl Into for Message { fn into(self) -> Element { let mut stanza = Element::builder("message") .ns(ns::JABBER_CLIENT) @@ -264,7 +264,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let message = Message::try_from(&elem).unwrap(); + let message = Message::try_from(elem).unwrap(); assert_eq!(message.from, None); assert_eq!(message.to, None); assert_eq!(message.id, None); @@ -285,18 +285,19 @@ mod tests { thread: None, payloads: vec!(), }; - let elem2 = (&message).into(); + let elem2 = message.into(); assert_eq!(elem, elem2); } #[test] fn test_body() { let elem: Element = "Hello world!".parse().unwrap(); - let message = Message::try_from(&elem).unwrap(); + let elem1 = elem.clone(); + let message = Message::try_from(elem).unwrap(); assert_eq!(message.bodies[""], "Hello world!"); - let elem2 = (&message).into(); - assert_eq!(elem, elem2); + let elem2 = message.into(); + assert_eq!(elem1, elem2); } #[test] @@ -314,25 +315,27 @@ mod tests { thread: None, payloads: vec!(), }; - let elem2 = (&message).into(); + let elem2 = message.into(); assert_eq!(elem, elem2); } #[test] fn test_subject() { let elem: Element = "Hello world!".parse().unwrap(); - let message = Message::try_from(&elem).unwrap(); + let elem1 = elem.clone(); + let message = Message::try_from(elem).unwrap(); assert_eq!(message.subjects[""], "Hello world!"); - let elem2 = (&message).into(); - assert_eq!(elem, elem2); + let elem2 = message.into(); + assert_eq!(elem1, elem2); } #[test] fn test_attention() { let elem: Element = "".parse().unwrap(); - let message = Message::try_from(&elem).unwrap(); - let elem2 = (&message).into(); - assert_eq!(elem, elem2); + let elem1 = elem.clone(); + let message = Message::try_from(elem).unwrap(); + let elem2 = message.into(); + assert_eq!(elem1, elem2); } } diff --git a/src/message_correct.rs b/src/message_correct.rs index ab0d3b2b9532a9cecd16bd59bba6e7cb72eb9df9..35494f810b04c59ad3365049a79338655967307c 100644 --- a/src/message_correct.rs +++ b/src/message_correct.rs @@ -17,10 +17,10 @@ pub struct Replace { pub id: String, } -impl<'a> TryFrom<&'a Element> for Replace { +impl TryFrom for Replace { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("replace", ns::MESSAGE_CORRECT) { return Err(Error::ParseError("This is not a replace element.")); } @@ -32,7 +32,7 @@ impl<'a> TryFrom<&'a Element> for Replace { } } -impl<'a> Into for &'a Replace { +impl Into for Replace { fn into(self) -> Element { Element::builder("replace") .ns(ns::MESSAGE_CORRECT) @@ -48,13 +48,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Replace::try_from(&elem).unwrap(); + Replace::try_from(elem).unwrap(); } #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Replace::try_from(&elem).unwrap_err(); + let error = Replace::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -65,7 +65,7 @@ mod tests { #[test] fn test_invalid_id() { let elem: Element = "".parse().unwrap(); - let error = Replace::try_from(&elem).unwrap_err(); + let error = Replace::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -77,7 +77,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let replace = Replace { id: String::from("coucou") }; - let elem2 = (&replace).into(); + let elem2 = replace.into(); assert_eq!(elem, elem2); } } diff --git a/src/ping.rs b/src/ping.rs index baebf68b133a9f4ebc07bdf769ece76cd1f360d8..84a7cebf0d9796abc09046bb29346a617c84b99c 100644 --- a/src/ping.rs +++ b/src/ping.rs @@ -16,10 +16,10 @@ use ns; #[derive(Debug, Clone)] pub struct Ping; -impl<'a> TryFrom<&'a Element> for Ping { +impl TryFrom for Ping { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("ping", ns::PING) { return Err(Error::ParseError("This is not a ping element.")); } @@ -33,7 +33,7 @@ impl<'a> TryFrom<&'a Element> for Ping { } } -impl<'a> Into for &'a Ping { +impl Into for Ping { fn into(self) -> Element { Element::builder("ping") .ns(ns::PING) @@ -48,13 +48,13 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Ping::try_from(&elem).unwrap(); + Ping::try_from(elem).unwrap(); } #[test] fn test_invalid() { let elem: Element = "".parse().unwrap(); - let error = Ping::try_from(&elem).unwrap_err(); + let error = Ping::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -65,7 +65,7 @@ mod tests { #[test] fn test_invalid_attribute() { let elem: Element = "".parse().unwrap(); - let error = Ping::try_from(&elem).unwrap_err(); + let error = Ping::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/presence.rs b/src/presence.rs index c15950a90082e339e91bfbb56ce03e1d5904cfbb..9dd1c62ca20708e25ce8bedc72412f064b983be2 100644 --- a/src/presence.rs +++ b/src/presence.rs @@ -57,10 +57,10 @@ pub enum PresencePayload { Unknown(Element), } -impl<'a> TryFrom<&'a Element> for PresencePayload { +impl TryFrom for PresencePayload { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { ("error", ns::JABBER_CLIENT) => PresencePayload::StanzaError(StanzaError::try_from(elem)?), @@ -73,20 +73,20 @@ impl<'a> TryFrom<&'a Element> for PresencePayload { // XEP-0390 ("c", ns::ECAPS2) => PresencePayload::ECaps2(ECaps2::try_from(elem)?), - _ => PresencePayload::Unknown(elem.clone()), + _ => PresencePayload::Unknown(elem), }) } } -impl<'a> Into for &'a PresencePayload { +impl Into for PresencePayload { fn into(self) -> Element { - match *self { - PresencePayload::StanzaError(ref stanza_error) => stanza_error.into(), - PresencePayload::Delay(ref delay) => delay.into(), - PresencePayload::Idle(ref idle) => idle.into(), - PresencePayload::ECaps2(ref ecaps2) => ecaps2.into(), + match self { + PresencePayload::StanzaError(stanza_error) => stanza_error.into(), + PresencePayload::Delay(delay) => delay.into(), + PresencePayload::Idle(idle) => idle.into(), + PresencePayload::ECaps2(ecaps2) => ecaps2.into(), - PresencePayload::Unknown(ref elem) => elem.clone(), + PresencePayload::Unknown(elem) => elem.clone(), } } } @@ -157,10 +157,10 @@ pub struct Presence { pub payloads: Vec, } -impl<'a> TryFrom<&'a Element> for Presence { +impl TryFrom for Presence { type Error = Error; - fn try_from(root: &'a Element) -> Result { + fn try_from(root: Element) -> Result { if !root.is("presence", ns::JABBER_CLIENT) { return Err(Error::ParseError("This is not a presence element.")); } @@ -232,7 +232,7 @@ impl<'a> TryFrom<&'a Element> for Presence { } } -impl<'a> Into for &'a Presence { +impl Into for Presence { fn into(self) -> Element { let mut stanza = Element::builder("presence") .ns(ns::JABBER_CLIENT) @@ -267,7 +267,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.from, None); assert_eq!(presence.to, None); assert_eq!(presence.id, None); @@ -288,14 +288,14 @@ mod tests { priority: 0i8, payloads: vec!(), }; - let elem2 = (&presence).into(); + let elem2 = presence.into(); assert_eq!(elem, elem2); } #[test] fn test_show() { let elem: Element = "chat".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.payloads.len(), 0); assert_eq!(presence.show, Some(Show::Chat)); } @@ -304,7 +304,7 @@ mod tests { fn test_missing_show_value() { // "online" used to be a pretty common mistake. let elem: Element = "".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -316,7 +316,7 @@ mod tests { fn test_invalid_show() { // "online" used to be a pretty common mistake. let elem: Element = "online".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -327,7 +327,7 @@ mod tests { #[test] fn test_empty_status() { let elem: Element = "".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.payloads.len(), 0); assert_eq!(presence.statuses.len(), 1); assert_eq!(presence.statuses[""], ""); @@ -336,7 +336,7 @@ mod tests { #[test] fn test_status() { let elem: Element = "Here!".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.payloads.len(), 0); assert_eq!(presence.statuses.len(), 1); assert_eq!(presence.statuses[""], "Here!"); @@ -345,7 +345,7 @@ mod tests { #[test] fn test_multiple_statuses() { let elem: Element = "Here!Là!".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.payloads.len(), 0); assert_eq!(presence.statuses.len(), 2); assert_eq!(presence.statuses[""], "Here!"); @@ -355,7 +355,7 @@ mod tests { #[test] fn test_invalid_multiple_statuses() { let elem: Element = "Here!Là!".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -366,7 +366,7 @@ mod tests { #[test] fn test_priority() { let elem: Element = "-1".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); assert_eq!(presence.payloads.len(), 0); assert_eq!(presence.priority, -1i8); } @@ -374,7 +374,7 @@ mod tests { #[test] fn test_invalid_priority() { let elem: Element = "128".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); match error { Error::ParseIntError(_) => (), _ => panic!(), @@ -384,7 +384,7 @@ mod tests { #[test] fn test_unknown_child() { let elem: Element = "".parse().unwrap(); - let presence = Presence::try_from(&elem).unwrap(); + let presence = Presence::try_from(elem).unwrap(); let payload = &presence.payloads[0]; assert!(payload.is("test", "invalid")); } @@ -392,7 +392,7 @@ mod tests { #[test] fn test_invalid_status_child() { let elem: Element = "".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -403,7 +403,7 @@ mod tests { #[test] fn test_invalid_attribute() { let elem: Element = "".parse().unwrap(); - let error = Presence::try_from(&elem).unwrap_err(); + let error = Presence::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -426,7 +426,7 @@ mod tests { priority: 0i8, payloads: vec!(), }; - let elem: Element = (&presence).into(); + let elem: Element = presence.into(); assert!(elem.is("presence", ns::JABBER_CLIENT)); assert!(elem.children().collect::>()[0].is("status", ns::JABBER_CLIENT)); } diff --git a/src/receipts.rs b/src/receipts.rs index 27392fb8cb161c2f1cea195907754b35d06d876b..f7c1d50d2af1352210c98d6c3317742ef04b7e47 100644 --- a/src/receipts.rs +++ b/src/receipts.rs @@ -18,10 +18,10 @@ pub enum Receipt { Received(String), } -impl<'a> TryFrom<&'a Element> for Receipt { +impl TryFrom for Receipt { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { for _ in elem.children() { return Err(Error::ParseError("Unknown child in receipt element.")); } @@ -36,16 +36,16 @@ impl<'a> TryFrom<&'a Element> for Receipt { } } -impl<'a> Into for &'a Receipt { +impl Into for Receipt { fn into(self) -> Element { - match *self { + match self { Receipt::Request => Element::builder("request") .ns(ns::RECEIPTS) .build(), - Receipt::Received(ref id) => Element::builder("received") - .ns(ns::RECEIPTS) - .attr("id", id.clone()) - .build(), + Receipt::Received(id) => Element::builder("received") + .ns(ns::RECEIPTS) + .attr("id", id) + .build(), } } } @@ -57,23 +57,23 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - Receipt::try_from(&elem).unwrap(); + Receipt::try_from(elem).unwrap(); let elem: Element = "".parse().unwrap(); - Receipt::try_from(&elem).unwrap(); + Receipt::try_from(elem).unwrap(); let elem: Element = "".parse().unwrap(); - Receipt::try_from(&elem).unwrap(); + Receipt::try_from(elem).unwrap(); } #[test] fn test_serialise() { let receipt = Receipt::Request; - let elem: Element = (&receipt).into(); + let elem: Element = receipt.into(); assert!(elem.is("request", ns::RECEIPTS)); let receipt = Receipt::Received("coucou".to_owned()); - let elem: Element = (&receipt).into(); + let elem: Element = receipt.into(); assert!(elem.is("received", ns::RECEIPTS)); assert_eq!(elem.attr("id"), Some("coucou")); } diff --git a/src/rsm.rs b/src/rsm.rs index a697b3705f3fe6a19fa345b4acfc0101a6bb6ae1..7ac80b192b711f1f1828b7aa632a7446423d2ef2 100644 --- a/src/rsm.rs +++ b/src/rsm.rs @@ -24,10 +24,10 @@ pub struct Set { pub max: Option, } -impl<'a> TryFrom<&'a Element> for Set { +impl TryFrom for Set { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("set", ns::RSM) { return Err(Error::ParseError("This is not a RSM element.")); } @@ -86,7 +86,7 @@ impl<'a> TryFrom<&'a Element> for Set { } } -impl<'a> Into for &'a Set { +impl Into for Set { fn into(self) -> Element { let mut elem = Element::builder("set") .ns(ns::RSM) @@ -126,7 +126,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let set = Set::try_from(&elem).unwrap(); + let set = Set::try_from(elem).unwrap(); assert_eq!(set.after, None); assert_eq!(set.before, None); assert_eq!(set.count, None); @@ -142,7 +142,7 @@ mod tests { #[test] fn test_unknown() { let elem: Element = "".parse().unwrap(); - let error = Set::try_from(&elem).unwrap_err(); + let error = Set::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -153,7 +153,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = Set::try_from(&elem).unwrap_err(); + let error = Set::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -174,14 +174,15 @@ mod tests { last: None, max: None, }; - let elem2 = (&rsm).into(); + let elem2 = rsm.into(); assert_eq!(elem, elem2); } #[test] fn test_first_index() { let elem: Element = "coucou".parse().unwrap(); - let set = Set::try_from(&elem).unwrap(); + let elem1 = elem.clone(); + let set = Set::try_from(elem).unwrap(); assert_eq!(set.first, Some(String::from("coucou"))); assert_eq!(set.first_index, Some(4)); @@ -195,7 +196,7 @@ mod tests { last: None, max: None, }; - let elem2 = (&set2).into(); - assert_eq!(elem, elem2); + let elem2 = set2.into(); + assert_eq!(elem1, elem2); } } diff --git a/src/stanza_error.rs b/src/stanza_error.rs index 85f21298635c99dbae616a859b423e3b4c4c0e9f..4f30f3a44171529b4066c3c931d942ae710de766 100644 --- a/src/stanza_error.rs +++ b/src/stanza_error.rs @@ -150,10 +150,10 @@ pub struct StanzaError { pub other: Option, } -impl<'a> TryFrom<&'a Element> for StanzaError { +impl TryFrom for StanzaError { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { if !elem.is("error", ns::JABBER_CLIENT) { return Err(Error::ParseError("This is not an error element.")); } @@ -205,7 +205,7 @@ impl<'a> TryFrom<&'a Element> for StanzaError { } } -impl<'a> Into for &'a StanzaError { +impl Into for StanzaError { fn into(self) -> Element { let mut root = Element::builder("error") .ns(ns::JABBER_CLIENT) @@ -240,7 +240,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let error = StanzaError::try_from(&elem).unwrap(); + let error = StanzaError::try_from(elem).unwrap(); assert_eq!(error.type_, ErrorType::Cancel); assert_eq!(error.defined_condition, DefinedCondition::UndefinedCondition); } @@ -248,7 +248,7 @@ mod tests { #[test] fn test_invalid_type() { let elem: Element = "".parse().unwrap(); - let error = StanzaError::try_from(&elem).unwrap_err(); + let error = StanzaError::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -256,7 +256,7 @@ mod tests { assert_eq!(message, "Required attribute 'type' missing."); let elem: Element = "".parse().unwrap(); - let error = StanzaError::try_from(&elem).unwrap_err(); + let error = StanzaError::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -267,7 +267,7 @@ mod tests { #[test] fn test_invalid_condition() { let elem: Element = "".parse().unwrap(); - let error = StanzaError::try_from(&elem).unwrap_err(); + let error = StanzaError::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), diff --git a/src/stanza_id.rs b/src/stanza_id.rs index 2b87890bf338daf2f1f1595614b4d5a6981b6be7..38008d0c5c8230050c7a12c8f200e9dccebe88fc 100644 --- a/src/stanza_id.rs +++ b/src/stanza_id.rs @@ -24,10 +24,10 @@ pub enum StanzaId { }, } -impl<'a> TryFrom<&'a Element> for StanzaId { +impl TryFrom for StanzaId { type Error = Error; - fn try_from(elem: &'a Element) -> Result { + fn try_from(elem: Element) -> Result { let is_stanza_id = elem.is("stanza-id", ns::SID); if !is_stanza_id && !elem.is("origin-id", ns::SID) { return Err(Error::ParseError("This is not a stanza-id or origin-id element.")); @@ -45,20 +45,20 @@ impl<'a> TryFrom<&'a Element> for StanzaId { } } -impl<'a> Into for &'a StanzaId { +impl Into for StanzaId { fn into(self) -> Element { - match *self { - StanzaId::StanzaId { ref id, ref by } => { + match self { + StanzaId::StanzaId { id, by } => { Element::builder("stanza-id") .ns(ns::SID) - .attr("id", id.clone()) - .attr("by", String::from(by.clone())) + .attr("id", id) + .attr("by", String::from(by)) .build() }, - StanzaId::OriginId { ref id } => { + StanzaId::OriginId { id } => { Element::builder("origin-id") .ns(ns::SID) - .attr("id", id.clone()) + .attr("id", id) .build() }, } @@ -73,7 +73,7 @@ mod tests { #[test] fn test_simple() { let elem: Element = "".parse().unwrap(); - let stanza_id = StanzaId::try_from(&elem).unwrap(); + let stanza_id = StanzaId::try_from(elem).unwrap(); if let StanzaId::StanzaId { id, by } = stanza_id { assert_eq!(id, String::from("coucou")); assert_eq!(by, Jid::from_str("coucou@coucou").unwrap()); @@ -82,7 +82,7 @@ mod tests { } let elem: Element = "".parse().unwrap(); - let stanza_id = StanzaId::try_from(&elem).unwrap(); + let stanza_id = StanzaId::try_from(elem).unwrap(); if let StanzaId::OriginId { id } = stanza_id { assert_eq!(id, String::from("coucou")); } else { @@ -93,7 +93,7 @@ mod tests { #[test] fn test_invalid_child() { let elem: Element = "".parse().unwrap(); - let error = StanzaId::try_from(&elem).unwrap_err(); + let error = StanzaId::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -104,7 +104,7 @@ mod tests { #[test] fn test_invalid_id() { let elem: Element = "".parse().unwrap(); - let error = StanzaId::try_from(&elem).unwrap_err(); + let error = StanzaId::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -115,7 +115,7 @@ mod tests { #[test] fn test_invalid_by() { let elem: Element = "".parse().unwrap(); - let error = StanzaId::try_from(&elem).unwrap_err(); + let error = StanzaId::try_from(elem).unwrap_err(); let message = match error { Error::ParseError(string) => string, _ => panic!(), @@ -127,7 +127,7 @@ mod tests { fn test_serialise() { let elem: Element = "".parse().unwrap(); let stanza_id = StanzaId::StanzaId { id: String::from("coucou"), by: Jid::from_str("coucou@coucou").unwrap() }; - let elem2 = (&stanza_id).into(); + let elem2 = stanza_id.into(); assert_eq!(elem, elem2); } }