xmppftw/xmpp-rs
Watch
1
0
Fork
You've already forked xmpp-rs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Convert all of the parsers/serialisers into consuming their parameter.

Browse source
This commit is contained in:
Emmanuel Gil Peyrot 2017-05-23 23:31:33 +01:00
commit 16e43c0b01
26 changed files with 378 additions and 382 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/attention.rs
View file

@ -15,10 +15,10 @@ use ns;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Attention; pub struct Attention;
impl<'a> TryFrom<&'a Element> for Attention { impl TryFrom<Element> for Attention {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Attention, Error> { fn try_from(elem: Element) -> Result<Attention, Error> {
if !elem.is("attention", ns::ATTENTION) { if !elem.is("attention", ns::ATTENTION) {
return Err(Error::ParseError("This is not an attention element.")); return Err(Error::ParseError("This is not an attention element."));
} }
@ -29,7 +29,7 @@ impl<'a> TryFrom<&'a Element> for Attention {
} }
} }
impl<'a> Into<Element> for &'a Attention { impl Into<Element> for Attention {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("attention") Element::builder("attention")
.ns(ns::ATTENTION) .ns(ns::ATTENTION)
@ -47,13 +47,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap(); let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap();
Attention::try_from(&elem).unwrap(); Attention::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<attention xmlns='urn:xmpp:attention:0'><coucou/></attention>".parse().unwrap(); let elem: Element = "<attention xmlns='urn:xmpp:attention:0'><coucou/></attention>".parse().unwrap();
let error = Attention::try_from(&elem).unwrap_err(); let error = Attention::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -65,9 +65,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap(); let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap();
let attention = Attention; let attention = Attention;
let elem2: Element = (&attention).into(); let elem2: Element = attention.into();
let elem3: Element = (&attention).into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
assert_eq!(elem2, elem3);
} }
} }

18
src/chatstates.rs
View file

@ -21,10 +21,10 @@ pub enum ChatState {
Paused, Paused,
} }
impl<'a> TryFrom<&'a Element> for ChatState { impl TryFrom<Element> for ChatState {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<ChatState, Error> { fn try_from(elem: Element) -> Result<ChatState, Error> {
for _ in elem.children() { for _ in elem.children() {
return Err(Error::ParseError("Unknown child in chatstate element.")); return Err(Error::ParseError("Unknown child in chatstate element."));
} }
@ -47,9 +47,9 @@ impl<'a> TryFrom<&'a Element> for ChatState {
} }
} }
impl<'a> Into<Element> for &'a ChatState { impl Into<Element> for ChatState {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder(match *self { Element::builder(match self {
ChatState::Active => "active", ChatState::Active => "active",
ChatState::Composing => "composing", ChatState::Composing => "composing",
ChatState::Gone => "gone", ChatState::Gone => "gone",
@ -67,13 +67,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<active xmlns='http://jabber.org/protocol/chatstates'/>".parse().unwrap(); let elem: Element = "<active xmlns='http://jabber.org/protocol/chatstates'/>".parse().unwrap();
ChatState::try_from(&elem).unwrap(); ChatState::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<coucou xmlns='http://jabber.org/protocol/chatstates'/>".parse().unwrap(); let elem: Element = "<coucou xmlns='http://jabber.org/protocol/chatstates'/>".parse().unwrap();
let error = ChatState::try_from(&elem).unwrap_err(); let error = ChatState::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -84,7 +84,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<gone xmlns='http://jabber.org/protocol/chatstates'><coucou/></gone>".parse().unwrap(); let elem: Element = "<gone xmlns='http://jabber.org/protocol/chatstates'><coucou/></gone>".parse().unwrap();
let error = ChatState::try_from(&elem).unwrap_err(); let error = ChatState::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -95,7 +95,7 @@ mod tests {
#[test] #[test]
fn test_invalid_attribute() { fn test_invalid_attribute() {
let elem: Element = "<inactive xmlns='http://jabber.org/protocol/chatstates' coucou=''/>".parse().unwrap(); let elem: Element = "<inactive xmlns='http://jabber.org/protocol/chatstates' coucou=''/>".parse().unwrap();
let error = ChatState::try_from(&elem).unwrap_err(); let error = ChatState::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -106,7 +106,7 @@ mod tests {
#[test] #[test]
fn test_serialise() { fn test_serialise() {
let chatstate = ChatState::Active; let chatstate = ChatState::Active;
let elem: Element = (&chatstate).into(); let elem: Element = chatstate.into();
assert!(elem.is("active", ns::CHATSTATES)); assert!(elem.is("active", ns::CHATSTATES));
} }
} }

14
src/data_forms.rs
View file

@ -104,10 +104,10 @@ pub struct DataForm {
pub fields: Vec<Field>, pub fields: Vec<Field>,
} }
impl<'a> TryFrom<&'a Element> for DataForm { impl TryFrom<Element> for DataForm {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<DataForm, Error> { fn try_from(elem: Element) -> Result<DataForm, Error> {
if !elem.is("x", ns::DATA_FORMS) { if !elem.is("x", ns::DATA_FORMS) {
return Err(Error::ParseError("This is not a data form element.")); return Err(Error::ParseError("This is not a data form element."));
} }
@ -200,7 +200,7 @@ impl<'a> TryFrom<&'a Element> for DataForm {
value: value, value: value,
}); });
} else if element.is("media", ns::MEDIA_ELEMENT) { } 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), Ok(media_element) => field.media.push(media_element),
Err(_) => (), // TODO: is it really nice to swallow this error? Err(_) => (), // TODO: is it really nice to swallow this error?
} }
@ -233,7 +233,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap(); let elem: Element = "<x xmlns='jabber:x:data' type='result'/>".parse().unwrap();
let form = DataForm::try_from(&elem).unwrap(); let form = DataForm::try_from(elem).unwrap();
assert_eq!(form.type_, DataFormType::Result_); assert_eq!(form.type_, DataFormType::Result_);
assert!(form.form_type.is_none()); assert!(form.form_type.is_none());
assert!(form.fields.is_empty()); assert!(form.fields.is_empty());
@ -242,7 +242,7 @@ mod tests {
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap(); let elem: Element = "<x xmlns='jabber:x:data'/>".parse().unwrap();
let error = DataForm::try_from(&elem).unwrap_err(); let error = DataForm::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -250,7 +250,7 @@ mod tests {
assert_eq!(message, "Required attribute 'type' missing."); assert_eq!(message, "Required attribute 'type' missing.");
let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap(); let elem: Element = "<x xmlns='jabber:x:data' type='coucou'/>".parse().unwrap();
let error = DataForm::try_from(&elem).unwrap_err(); let error = DataForm::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -261,7 +261,7 @@ mod tests {
#[test] #[test]
fn test_wrong_child() { fn test_wrong_child() {
let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap(); let elem: Element = "<x xmlns='jabber:x:data' type='cancel'><coucou/></x>".parse().unwrap();
let error = DataForm::try_from(&elem).unwrap_err(); let error = DataForm::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

16
src/delay.rs
View file

@ -20,10 +20,10 @@ pub struct Delay {
pub data: Option<String>, pub data: Option<String>,
} }
impl<'a> TryFrom<&'a Element> for Delay { impl TryFrom<Element> for Delay {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Delay, Error> { fn try_from(elem: Element) -> Result<Delay, Error> {
if !elem.is("delay", ns::DELAY) { if !elem.is("delay", ns::DELAY) {
return Err(Error::ParseError("This is not a delay element.")); return Err(Error::ParseError("This is not a delay element."));
} }
@ -44,7 +44,7 @@ impl<'a> TryFrom<&'a Element> for Delay {
} }
} }
impl<'a> Into<Element> for &'a Delay { impl Into<Element> for Delay {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("delay") Element::builder("delay")
.ns(ns::DELAY) .ns(ns::DELAY)
@ -63,7 +63,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<delay xmlns='urn:xmpp:delay' from='capulet.com' stamp='2002-09-10T23:08:25Z'/>".parse().unwrap(); let elem: Element = "<delay xmlns='urn:xmpp:delay' from='capulet.com' stamp='2002-09-10T23:08:25Z'/>".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.from, Some(Jid::from_str("capulet.com").unwrap()));
assert_eq!(delay.stamp, "2002-09-10T23:08:25Z"); assert_eq!(delay.stamp, "2002-09-10T23:08:25Z");
assert_eq!(delay.data, None); assert_eq!(delay.data, None);
@ -72,7 +72,7 @@ mod tests {
#[test] #[test]
fn test_unknown() { fn test_unknown() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
let error = Delay::try_from(&elem).unwrap_err(); let error = Delay::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -83,7 +83,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<delay xmlns='urn:xmpp:delay'><coucou/></delay>".parse().unwrap(); let elem: Element = "<delay xmlns='urn:xmpp:delay'><coucou/></delay>".parse().unwrap();
let error = Delay::try_from(&elem).unwrap_err(); let error = Delay::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -99,7 +99,7 @@ mod tests {
stamp: "2002-09-10T23:08:25Z".to_owned(), stamp: "2002-09-10T23:08:25Z".to_owned(),
data: None, data: None,
}; };
let elem2 = (&delay).into(); let elem2 = delay.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
@ -111,7 +111,7 @@ mod tests {
stamp: "2002-09-10T23:08:25Z".to_owned(), stamp: "2002-09-10T23:08:25Z".to_owned(),
data: Some(String::from("Reason")), data: Some(String::from("Reason")),
}; };
let elem2 = (&delay).into(); let elem2 = delay.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

34
src/disco.rs
View file

@ -34,10 +34,10 @@ pub struct Disco {
pub extensions: Vec<DataForm>, pub extensions: Vec<DataForm>,
} }
impl<'a> TryFrom<&'a Element> for Disco { impl TryFrom<Element> for Disco {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Disco, Error> { fn try_from(elem: Element) -> Result<Disco, Error> {
if !elem.is("query", ns::DISCO_INFO) { if !elem.is("query", ns::DISCO_INFO) {
return Err(Error::ParseError("This is not a disco#info element.")); return Err(Error::ParseError("This is not a disco#info element."));
} }
@ -74,7 +74,7 @@ impl<'a> TryFrom<&'a Element> for Disco {
name: name, name: name,
}); });
} else if child.is("x", ns::DATA_FORMS) { } 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_ { if data_form.type_ != DataFormType::Result_ {
return Err(Error::ParseError("Data form must have a 'result' type in disco#info.")); 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<Element> for &'a Disco { impl Into<Element> for Disco {
fn into(self) -> Element { fn into(self) -> Element {
let mut root = Element::builder("query") let mut root = Element::builder("query")
.ns(ns::DISCO_INFO) .ns(ns::DISCO_INFO)
.attr("node", self.node.clone()) .attr("node", self.node.clone())
.build(); .build();
for identity in &self.identities { for identity in self.identities {
let identity_element = Element::builder("identity") let identity_element = Element::builder("identity")
.ns(ns::DISCO_INFO) .ns(ns::DISCO_INFO)
.attr("category", identity.category.clone()) .attr("category", identity.category.clone())
@ -125,14 +125,14 @@ impl<'a> Into<Element> for &'a Disco {
.build(); .build();
root.append_child(identity_element); root.append_child(identity_element);
} }
for feature in &self.features { for feature in self.features {
let feature_element = Element::builder("feature") let feature_element = Element::builder("feature")
.ns(ns::DISCO_INFO) .ns(ns::DISCO_INFO)
.attr("var", feature.var.clone()) .attr("var", feature.var.clone())
.build(); .build();
root.append_child(feature_element); root.append_child(feature_element);
} }
for _ in &self.extensions { for _ in self.extensions {
panic!("Not yet implemented!"); panic!("Not yet implemented!");
} }
root root
@ -146,7 +146,7 @@ mod tests {
#[test] #[test]
fn test_simple() { 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 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::try_from(&elem).unwrap(); let query = Disco::try_from(elem).unwrap();
assert!(query.node.is_none()); assert!(query.node.is_none());
assert_eq!(query.identities.len(), 1); assert_eq!(query.identities.len(), 1);
assert_eq!(query.features.len(), 1); assert_eq!(query.features.len(), 1);
@ -156,7 +156,7 @@ mod tests {
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><coucou/></query>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><coucou/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -167,7 +167,7 @@ mod tests {
#[test] #[test]
fn test_invalid_identity() { fn test_invalid_identity() {
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity/></query>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -175,7 +175,7 @@ mod tests {
assert_eq!(message, "Required attribute 'category' missing."); assert_eq!(message, "Required attribute 'category' missing.");
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category=''/></query>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category=''/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -183,7 +183,7 @@ mod tests {
assert_eq!(message, "Identity must have a non-empty 'category' attribute."); 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 elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='coucou'/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -191,7 +191,7 @@ mod tests {
assert_eq!(message, "Required attribute 'type' missing."); assert_eq!(message, "Required attribute 'type' missing.");
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='coucou' type=''/></query>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='coucou' type=''/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -202,7 +202,7 @@ mod tests {
#[test] #[test]
fn test_invalid_feature() { fn test_invalid_feature() {
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><feature/></query>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><feature/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -214,7 +214,7 @@ mod tests {
#[ignore] #[ignore]
fn test_invalid_result() { fn test_invalid_result() {
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'/>".parse().unwrap(); let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'/>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -222,7 +222,7 @@ mod tests {
assert_eq!(message, "There must be at least one identity in disco#info."); 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 elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/></query>".parse().unwrap();
let error = Disco::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -230,7 +230,7 @@ mod tests {
assert_eq!(message, "There must be at least one feature in disco#info."); 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 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::try_from(&elem).unwrap_err(); let error = Disco::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

20
src/ecaps2.rs
View file

@ -25,17 +25,17 @@ pub struct ECaps2 {
hashes: Vec<Hash>, hashes: Vec<Hash>,
} }
impl<'a> TryFrom<&'a Element> for ECaps2 { impl TryFrom<Element> for ECaps2 {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<ECaps2, Error> { fn try_from(elem: Element) -> Result<ECaps2, Error> {
if !elem.is("c", ns::ECAPS2) { if !elem.is("c", ns::ECAPS2) {
return Err(Error::ParseError("This is not an ecaps2 element.")); return Err(Error::ParseError("This is not an ecaps2 element."));
} }
let mut hashes = vec!(); let mut hashes = vec!();
for child in elem.children() { for child in elem.children() {
if child.is("hash", ns::HASHES) { if child.is("hash", ns::HASHES) {
let hash = Hash::try_from(child)?; let hash = Hash::try_from(child.clone())?;
hashes.push(hash); hashes.push(hash);
} else { } else {
return Err(Error::ParseError("Unknown child in ecaps2 element.")); return Err(Error::ParseError("Unknown child in ecaps2 element."));
@ -47,12 +47,12 @@ impl<'a> TryFrom<&'a Element> for ECaps2 {
} }
} }
impl<'a> Into<Element> for &'a ECaps2 { impl Into<Element> for ECaps2 {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("c") Element::builder("c")
.ns(ns::ECAPS2) .ns(ns::ECAPS2)
.append(self.hashes.iter() .append(self.hashes.iter()
.map(|hash| hash.into()) .map(|hash| hash.clone().into())
.collect::<Vec<Element>>()) .collect::<Vec<Element>>())
.build() .build()
} }
@ -175,7 +175,7 @@ mod tests {
#[test] #[test]
fn test_parse() { fn test_parse() {
let elem: Element = "<c xmlns='urn:xmpp:caps'><hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=</hash><hash xmlns='urn:xmpp:hashes:2' algo='sha3-256'>+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=</hash></c>".parse().unwrap(); let elem: Element = "<c xmlns='urn:xmpp:caps'><hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=</hash><hash xmlns='urn:xmpp:hashes:2' algo='sha3-256'>+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=</hash></c>".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.len(), 2);
assert_eq!(ecaps2.hashes[0].algo, Algo::Sha_256); assert_eq!(ecaps2.hashes[0].algo, Algo::Sha_256);
assert_eq!(ecaps2.hashes[0].hash, "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4="); assert_eq!(ecaps2.hashes[0].hash, "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=");
@ -186,7 +186,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<c xmlns='urn:xmpp:caps'><hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=</hash><hash xmlns='urn:xmpp:hashes:1' algo='sha3-256'>+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=</hash></c>".parse().unwrap(); let elem: Element = "<c xmlns='urn:xmpp:caps'><hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=</hash><hash xmlns='urn:xmpp:hashes:1' algo='sha3-256'>+sDTQqBmX6iG/X3zjt06fjZMBBqL/723knFIyRf0sg8=</hash></c>".parse().unwrap();
let error = ECaps2::try_from(&elem).unwrap_err(); let error = ECaps2::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -197,7 +197,7 @@ mod tests {
#[test] #[test]
fn test_simple() { 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 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::try_from(&elem).unwrap(); let disco = Disco::try_from(elem).unwrap();
let ecaps2 = ecaps2::compute_disco(&disco); let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 54); 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, 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, 98, 105, 108, 101, 31, 31, 66, 111, 109, 98, 117, 115, 77, 111,
100, 31, 30, 28, 28]; 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); let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 0x1d9); assert_eq!(ecaps2.len(), 0x1d9);
assert_eq!(ecaps2, expected); 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, 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, 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]; 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); let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 0x543); assert_eq!(ecaps2.len(), 0x543);
assert_eq!(ecaps2, expected); assert_eq!(ecaps2, expected);

16
src/eme.rs
View file

@ -18,10 +18,10 @@ pub struct ExplicitMessageEncryption {
pub name: Option<String>, pub name: Option<String>,
} }
impl<'a> TryFrom<&'a Element> for ExplicitMessageEncryption { impl TryFrom<Element> for ExplicitMessageEncryption {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<ExplicitMessageEncryption, Error> { fn try_from(elem: Element) -> Result<ExplicitMessageEncryption, Error> {
if !elem.is("encryption", ns::EME) { if !elem.is("encryption", ns::EME) {
return Err(Error::ParseError("This is not an encryption element.")); return Err(Error::ParseError("This is not an encryption element."));
} }
@ -37,7 +37,7 @@ impl<'a> TryFrom<&'a Element> for ExplicitMessageEncryption {
} }
} }
impl<'a> Into<Element> for &'a ExplicitMessageEncryption { impl Into<Element> for ExplicitMessageEncryption {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("encryption") Element::builder("encryption")
.ns(ns::EME) .ns(ns::EME)
@ -54,12 +54,12 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='urn:xmpp:otr:0'/>".parse().unwrap(); let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='urn:xmpp:otr:0'/>".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.namespace, "urn:xmpp:otr:0");
assert_eq!(encryption.name, None); assert_eq!(encryption.name, None);
let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='some.unknown.mechanism' name='SuperMechanism'/>".parse().unwrap(); let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='some.unknown.mechanism' name='SuperMechanism'/>".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.namespace, "some.unknown.mechanism");
assert_eq!(encryption.name, Some(String::from("SuperMechanism"))); assert_eq!(encryption.name, Some(String::from("SuperMechanism")));
} }
@ -67,7 +67,7 @@ mod tests {
#[test] #[test]
fn test_unknown() { fn test_unknown() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
let error = ExplicitMessageEncryption::try_from(&elem).unwrap_err(); let error = ExplicitMessageEncryption::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -78,7 +78,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<encryption xmlns='urn:xmpp:eme:0'><coucou/></encryption>".parse().unwrap(); let elem: Element = "<encryption xmlns='urn:xmpp:eme:0'><coucou/></encryption>".parse().unwrap();
let error = ExplicitMessageEncryption::try_from(&elem).unwrap_err(); let error = ExplicitMessageEncryption::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -90,7 +90,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='coucou'/>".parse().unwrap(); let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='coucou'/>".parse().unwrap();
let eme = ExplicitMessageEncryption { namespace: String::from("coucou"), name: None }; let eme = ExplicitMessageEncryption { namespace: String::from("coucou"), name: None };
let elem2 = (&eme).into(); let elem2 = eme.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

20
src/forwarding.rs
View file

@ -22,10 +22,10 @@ pub struct Forwarded {
pub stanza: Option<Message>, pub stanza: Option<Message>,
} }
impl<'a> TryFrom<&'a Element> for Forwarded { impl TryFrom<Element> for Forwarded {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Forwarded, Error> { fn try_from(elem: Element) -> Result<Forwarded, Error> {
if !elem.is("forwarded", ns::FORWARD) { if !elem.is("forwarded", ns::FORWARD) {
return Err(Error::ParseError("This is not a forwarded element.")); 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; let mut stanza = None;
for child in elem.children() { for child in elem.children() {
if child.is("delay", ns::DELAY) { 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) { } 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. // TODO: also handle the five other possibilities.
} else { } else {
return Err(Error::ParseError("Unknown child in forwarded element.")); return Err(Error::ParseError("Unknown child in forwarded element."));
@ -48,12 +48,12 @@ impl<'a> TryFrom<&'a Element> for Forwarded {
} }
} }
impl<'a> Into<Element> for &'a Forwarded { impl Into<Element> for Forwarded {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("forwarded") Element::builder("forwarded")
.ns(ns::FORWARD) .ns(ns::FORWARD)
.append(match self.delay { Some(ref delay) => { let elem: Element = delay.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(ref stanza) => { let elem: Element = stanza.into(); Some(elem) }, None => None }) .append(match self.stanza { Some(stanza) => { let elem: Element = stanza.into(); Some(elem) }, None => None })
.build() .build()
} }
} }
@ -65,13 +65,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'/>".parse().unwrap(); let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'/>".parse().unwrap();
Forwarded::try_from(&elem).unwrap(); Forwarded::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'><coucou/></forwarded>".parse().unwrap(); let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'><coucou/></forwarded>".parse().unwrap();
let error = Forwarded::try_from(&elem).unwrap_err(); let error = Forwarded::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -83,7 +83,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'/>".parse().unwrap(); let elem: Element = "<forwarded xmlns='urn:xmpp:forward:0'/>".parse().unwrap();
let forwarded = Forwarded { delay: None, stanza: None }; let forwarded = Forwarded { delay: None, stanza: None };
let elem2 = (&forwarded).into(); let elem2 = forwarded.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

14
src/hashes.rs
View file

@ -66,10 +66,10 @@ pub struct Hash {
pub hash: String, pub hash: String,
} }
impl<'a> TryFrom<&'a Element> for Hash { impl TryFrom<Element> for Hash {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Hash, Error> { fn try_from(elem: Element) -> Result<Hash, Error> {
if !elem.is("hash", ns::HASHES) { if !elem.is("hash", ns::HASHES) {
return Err(Error::ParseError("This is not a hash element.")); return Err(Error::ParseError("This is not a hash element."));
} }
@ -88,11 +88,11 @@ impl<'a> TryFrom<&'a Element> for Hash {
} }
} }
impl<'a> Into<Element> for &'a Hash { impl Into<Element> for Hash {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("hash") Element::builder("hash")
.ns(ns::HASHES) .ns(ns::HASHES)
.attr("algo", self.algo.clone()) .attr("algo", self.algo)
.append(self.hash.clone()) .append(self.hash.clone())
.build() .build()
} }
@ -105,7 +105,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=</hash>".parse().unwrap(); let elem: Element = "<hash xmlns='urn:xmpp:hashes:2' algo='sha-256'>2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=</hash>".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.algo, Algo::Sha_256);
assert_eq!(hash.hash, "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU="); assert_eq!(hash.hash, "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=");
} }
@ -113,7 +113,7 @@ mod tests {
#[test] #[test]
fn test_unknown() { fn test_unknown() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
let error = Hash::try_from(&elem).unwrap_err(); let error = Hash::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -124,7 +124,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<hash xmlns='urn:xmpp:hashes:2'><coucou/></hash>".parse().unwrap(); let elem: Element = "<hash xmlns='urn:xmpp:hashes:2'><coucou/></hash>".parse().unwrap();
let error = Hash::try_from(&elem).unwrap_err(); let error = Hash::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

36
src/ibb.rs
View file

@ -65,10 +65,10 @@ pub enum IBB {
}, },
} }
impl<'a> TryFrom<&'a Element> for IBB { impl TryFrom<Element> for IBB {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<IBB, Error> { fn try_from(elem: Element) -> Result<IBB, Error> {
if elem.is("open", ns::IBB) { if elem.is("open", ns::IBB) {
for _ in elem.children() { for _ in elem.children() {
return Err(Error::ParseError("Unknown child in open element.")); return Err(Error::ParseError("Unknown child in open element."));
@ -107,29 +107,29 @@ impl<'a> TryFrom<&'a Element> for IBB {
} }
} }
impl<'a> Into<Element> for &'a IBB { impl Into<Element> for IBB {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
IBB::Open { ref block_size, ref sid, ref stanza } => { IBB::Open { block_size, sid, stanza } => {
Element::builder("open") Element::builder("open")
.ns(ns::IBB) .ns(ns::IBB)
.attr("block-size", format!("{}", block_size)) .attr("block-size", format!("{}", block_size))
.attr("sid", sid.to_owned()) .attr("sid", sid)
.attr("stanza", stanza.to_owned()) .attr("stanza", stanza)
.build() .build()
}, },
IBB::Data { ref seq, ref sid, ref data } => { IBB::Data { seq, sid, data } => {
Element::builder("data") Element::builder("data")
.ns(ns::IBB) .ns(ns::IBB)
.attr("seq", format!("{}", seq)) .attr("seq", format!("{}", seq))
.attr("sid", sid.to_owned()) .attr("sid", sid)
.append(base64::encode(&data)) .append(base64::encode(&data))
.build() .build()
}, },
IBB::Close { ref sid } => { IBB::Close { sid } => {
Element::builder("close") Element::builder("close")
.ns(ns::IBB) .ns(ns::IBB)
.attr("sid", sid.to_owned()) .attr("sid", sid)
.build() .build()
}, },
} }
@ -144,7 +144,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='3' sid='coucou'/>".parse().unwrap(); let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='3' sid='coucou'/>".parse().unwrap();
let open = IBB::try_from(&elem).unwrap(); let open = IBB::try_from(elem).unwrap();
match open { match open {
IBB::Open { block_size, sid, stanza } => { IBB::Open { block_size, sid, stanza } => {
assert_eq!(block_size, 3); assert_eq!(block_size, 3);
@ -155,7 +155,7 @@ mod tests {
} }
let elem: Element = "<data xmlns='http://jabber.org/protocol/ibb' seq='0' sid='coucou'>AAAA</data>".parse().unwrap(); let elem: Element = "<data xmlns='http://jabber.org/protocol/ibb' seq='0' sid='coucou'>AAAA</data>".parse().unwrap();
let data = IBB::try_from(&elem).unwrap(); let data = IBB::try_from(elem).unwrap();
match data { match data {
IBB::Data { seq, sid, data } => { IBB::Data { seq, sid, data } => {
assert_eq!(seq, 0); assert_eq!(seq, 0);
@ -166,7 +166,7 @@ mod tests {
} }
let elem: Element = "<close xmlns='http://jabber.org/protocol/ibb' sid='coucou'/>".parse().unwrap(); let elem: Element = "<close xmlns='http://jabber.org/protocol/ibb' sid='coucou'/>".parse().unwrap();
let close = IBB::try_from(&elem).unwrap(); let close = IBB::try_from(elem).unwrap();
match close { match close {
IBB::Close { sid } => { IBB::Close { sid } => {
assert_eq!(sid, "coucou"); assert_eq!(sid, "coucou");
@ -178,7 +178,7 @@ mod tests {
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb'/>".parse().unwrap(); let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb'/>".parse().unwrap();
let error = IBB::try_from(&elem).unwrap_err(); let error = IBB::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -186,7 +186,7 @@ mod tests {
assert_eq!(message, "Required attribute 'block-size' missing."); assert_eq!(message, "Required attribute 'block-size' missing.");
let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='-5'/>".parse().unwrap(); let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='-5'/>".parse().unwrap();
let error = IBB::try_from(&elem).unwrap_err(); let error = IBB::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseIntError(error) => error, Error::ParseIntError(error) => error,
_ => panic!(), _ => panic!(),
@ -194,7 +194,7 @@ mod tests {
assert_eq!(message.description(), "invalid digit found in string"); assert_eq!(message.description(), "invalid digit found in string");
let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='128'/>".parse().unwrap(); let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='128'/>".parse().unwrap();
let error = IBB::try_from(&elem).unwrap_err(); let error = IBB::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(error) => error, Error::ParseError(error) => error,
_ => panic!(), _ => panic!(),
@ -205,7 +205,7 @@ mod tests {
#[test] #[test]
fn test_invalid_stanza() { fn test_invalid_stanza() {
let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='128' sid='coucou' stanza='fdsq'/>".parse().unwrap(); let elem: Element = "<open xmlns='http://jabber.org/protocol/ibb' block-size='128' sid='coucou' stanza='fdsq'/>".parse().unwrap();
let error = IBB::try_from(&elem).unwrap_err(); let error = IBB::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

14
src/idle.rs
View file

@ -19,10 +19,10 @@ pub struct Idle {
pub since: Date, pub since: Date,
} }
impl<'a> TryFrom<&'a Element> for Idle { impl TryFrom<Element> for Idle {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Idle, Error> { fn try_from(elem: Element) -> Result<Idle, Error> {
if !elem.is("idle", ns::IDLE) { if !elem.is("idle", ns::IDLE) {
return Err(Error::ParseError("This is not an idle element.")); return Err(Error::ParseError("This is not an idle element."));
} }
@ -34,7 +34,7 @@ impl<'a> TryFrom<&'a Element> for Idle {
} }
} }
impl<'a> Into<Element> for &'a Idle { impl Into<Element> for Idle {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("idle") Element::builder("idle")
.ns(ns::IDLE) .ns(ns::IDLE)
@ -50,13 +50,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<idle xmlns='urn:xmpp:idle:1' since='2017-05-21T20:19:55+01:00'/>".parse().unwrap(); let elem: Element = "<idle xmlns='urn:xmpp:idle:1' since='2017-05-21T20:19:55+01:00'/>".parse().unwrap();
Idle::try_from(&elem).unwrap(); Idle::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<idle xmlns='urn:xmpp:idle:1'><coucou/></idle>".parse().unwrap(); let elem: Element = "<idle xmlns='urn:xmpp:idle:1'><coucou/></idle>".parse().unwrap();
let error = Idle::try_from(&elem).unwrap_err(); let error = Idle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -67,7 +67,7 @@ mod tests {
#[test] #[test]
fn test_invalid_id() { fn test_invalid_id() {
let elem: Element = "<idle xmlns='urn:xmpp:idle:1'/>".parse().unwrap(); let elem: Element = "<idle xmlns='urn:xmpp:idle:1'/>".parse().unwrap();
let error = Idle::try_from(&elem).unwrap_err(); let error = Idle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -79,7 +79,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<idle xmlns='urn:xmpp:idle:1' since='2017-05-21T20:19:55+01:00'/>".parse().unwrap(); let elem: Element = "<idle xmlns='urn:xmpp:idle:1' since='2017-05-21T20:19:55+01:00'/>".parse().unwrap();
let idle = Idle { since: Date::from("2017-05-21T20:19:55+01:00") }; 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); assert_eq!(elem, elem2);
} }
} }

56
src/iq.rs
View file

@ -37,13 +37,13 @@ pub enum IqPayload {
Unknown(Element), Unknown(Element),
} }
impl<'a> TryFrom<&'a Element> for IqPayload { impl TryFrom<Element> for IqPayload {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<IqPayload, Error> { fn try_from(elem: Element) -> Result<IqPayload, Error> {
Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) {
// XEP-0030 // 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 // XEP-0047
("open", ns::IBB) ("open", ns::IBB)
@ -93,10 +93,10 @@ pub struct Iq {
pub payload: IqType, pub payload: IqType,
} }
impl<'a> TryFrom<&'a Element> for Iq { impl TryFrom<Element> for Iq {
type Error = Error; type Error = Error;
fn try_from(root: &'a Element) -> Result<Iq, Error> { fn try_from(root: Element) -> Result<Iq, Error> {
if !root.is("iq", ns::JABBER_CLIENT) { if !root.is("iq", ns::JABBER_CLIENT) {
return Err(Error::ParseError("This is not an iq element.")); 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() { if error_payload.is_some() {
return Err(Error::ParseError("Wrong number of children in iq element.")); 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::<Vec<_>>().len() != 2 { } else if root.children().collect::<Vec<_>>().len() != 2 {
return Err(Error::ParseError("Wrong number of children in iq element.")); 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<Element> for &'a IqPayload { impl Into<Element> for IqPayload {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
IqPayload::Disco(ref disco) => disco.into(), IqPayload::Disco(disco) => disco.into(),
IqPayload::IBB(ref ibb) => ibb.into(), IqPayload::IBB(ibb) => ibb.into(),
IqPayload::Jingle(ref jingle) => jingle.into(), IqPayload::Jingle(jingle) => jingle.into(),
IqPayload::Ping(ref ping) => ping.into(), IqPayload::Ping(ping) => ping.into(),
IqPayload::MamQuery(ref query) => query.into(), IqPayload::MamQuery(query) => query.into(),
IqPayload::MamFin(ref fin) => fin.into(), IqPayload::MamFin(fin) => fin.into(),
IqPayload::MamPrefs(ref prefs) => prefs.into(), IqPayload::MamPrefs(prefs) => prefs.into(),
IqPayload::Unknown(ref elem) => elem.clone(), IqPayload::Unknown(elem) => elem.clone(),
} }
} }
} }
impl<'a> Into<Element> for &'a Iq { impl Into<Element> for Iq {
fn into(self) -> Element { fn into(self) -> Element {
let mut stanza = Element::builder("iq") let mut stanza = Element::builder("iq")
.ns(ns::JABBER_CLIENT) .ns(ns::JABBER_CLIENT)
@ -191,7 +191,7 @@ impl<'a> Into<Element> for &'a Iq {
IqType::Get(elem) IqType::Get(elem)
| IqType::Set(elem) | IqType::Set(elem)
| IqType::Result(Some(elem)) => elem, | IqType::Result(Some(elem)) => elem,
IqType::Error(error) => (&error).into(), IqType::Error(error) => error.into(),
IqType::Result(None) => return stanza, IqType::Result(None) => return stanza,
}; };
stanza.append_child(elem); stanza.append_child(elem);
@ -207,7 +207,7 @@ mod tests {
#[test] #[test]
fn test_require_type() { fn test_require_type() {
let elem: Element = "<iq xmlns='jabber:client'/>".parse().unwrap(); let elem: Element = "<iq xmlns='jabber:client'/>".parse().unwrap();
let error = Iq::try_from(&elem).unwrap_err(); let error = Iq::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -220,7 +220,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='get'> let elem: Element = "<iq xmlns='jabber:client' type='get'>
<foo/> <foo/>
</iq>".parse().unwrap(); </iq>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
let query: Element = "<foo xmlns='jabber:client'/>".parse().unwrap(); let query: Element = "<foo xmlns='jabber:client'/>".parse().unwrap();
assert_eq!(iq.from, None); assert_eq!(iq.from, None);
assert_eq!(iq.to, None); assert_eq!(iq.to, None);
@ -236,7 +236,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='set'> let elem: Element = "<iq xmlns='jabber:client' type='set'>
<vCard xmlns='vcard-temp'/> <vCard xmlns='vcard-temp'/>
</iq>".parse().unwrap(); </iq>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
let vcard: Element = "<vCard xmlns='vcard-temp'/>".parse().unwrap(); let vcard: Element = "<vCard xmlns='vcard-temp'/>".parse().unwrap();
assert_eq!(iq.from, None); assert_eq!(iq.from, None);
assert_eq!(iq.to, None); assert_eq!(iq.to, None);
@ -250,7 +250,7 @@ mod tests {
#[test] #[test]
fn test_result_empty() { fn test_result_empty() {
let elem: Element = "<iq xmlns='jabber:client' type='result'/>".parse().unwrap(); let elem: Element = "<iq xmlns='jabber:client' type='result'/>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
assert_eq!(iq.from, None); assert_eq!(iq.from, None);
assert_eq!(iq.to, None); assert_eq!(iq.to, None);
assert_eq!(iq.id, None); assert_eq!(iq.id, None);
@ -265,7 +265,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='result'> let elem: Element = "<iq xmlns='jabber:client' type='result'>
<query xmlns='http://jabber.org/protocol/disco#items'/> <query xmlns='http://jabber.org/protocol/disco#items'/>
</iq>".parse().unwrap(); </iq>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
let query: Element = "<query xmlns='http://jabber.org/protocol/disco#items'/>".parse().unwrap(); let query: Element = "<query xmlns='http://jabber.org/protocol/disco#items'/>".parse().unwrap();
assert_eq!(iq.from, None); assert_eq!(iq.from, None);
assert_eq!(iq.to, None); assert_eq!(iq.to, None);
@ -284,7 +284,7 @@ mod tests {
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/> <service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error> </error>
</iq>".parse().unwrap(); </iq>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
assert_eq!(iq.from, None); assert_eq!(iq.from, None);
assert_eq!(iq.to, None); assert_eq!(iq.to, None);
assert_eq!(iq.id, None); assert_eq!(iq.id, None);
@ -303,7 +303,7 @@ mod tests {
#[test] #[test]
fn test_children_invalid() { fn test_children_invalid() {
let elem: Element = "<iq xmlns='jabber:client' type='error'></iq>".parse().unwrap(); let elem: Element = "<iq xmlns='jabber:client' type='error'></iq>".parse().unwrap();
let error = Iq::try_from(&elem).unwrap_err(); let error = Iq::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -320,16 +320,16 @@ mod tests {
id: None, id: None,
payload: IqType::Result(None), payload: IqType::Result(None),
}; };
let elem2 = (&iq2).into(); let elem2 = iq2.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
#[test] #[test]
fn test_disco() { fn test_disco() {
let elem: Element = "<iq xmlns='jabber:client' type='get'><query xmlns='http://jabber.org/protocol/disco#info'/></iq>".parse().unwrap(); let elem: Element = "<iq xmlns='jabber:client' type='get'><query xmlns='http://jabber.org/protocol/disco#info'/></iq>".parse().unwrap();
let iq = Iq::try_from(&elem).unwrap(); let iq = Iq::try_from(elem).unwrap();
let payload = match iq.payload { let payload = match iq.payload {
IqType::Get(ref payload) => IqPayload::try_from(payload).unwrap(), IqType::Get(payload) => IqPayload::try_from(payload).unwrap(),
_ => panic!(), _ => panic!(),
}; };
assert!(match payload { assert!(match payload {

66
src/jingle.rs
View file

@ -204,9 +204,9 @@ impl FromStr for Reason {
} }
} }
impl<'a> Into<Element> for &'a Reason { impl Into<Element> for Reason {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder(match *self { Element::builder(match self {
Reason::AlternativeSession => "alternative-session", Reason::AlternativeSession => "alternative-session",
Reason::Busy => "busy", Reason::Busy => "busy",
Reason::Cancel => "cancel", Reason::Cancel => "cancel",
@ -245,10 +245,10 @@ pub struct Jingle {
pub other: Vec<Element>, pub other: Vec<Element>,
} }
impl<'a> TryFrom<&'a Element> for Jingle { impl TryFrom<Element> for Jingle {
type Error = Error; type Error = Error;
fn try_from(root: &'a Element) -> Result<Jingle, Error> { fn try_from(root: Element) -> Result<Jingle, Error> {
if !root.is("jingle", ns::JINGLE) { if !root.is("jingle", ns::JINGLE) {
return Err(Error::ParseError("This is not a Jingle element.")); return Err(Error::ParseError("This is not a Jingle element."));
} }
@ -353,7 +353,7 @@ impl<'a> TryFrom<&'a Element> for Jingle {
} }
} }
impl<'a> Into<Element> for &'a Content { impl Into<Element> for Content {
fn into(self) -> Element { fn into(self) -> Element {
let mut root = Element::builder("content") let mut root = Element::builder("content")
.ns(ns::JINGLE) .ns(ns::JINGLE)
@ -375,7 +375,7 @@ impl<'a> Into<Element> for &'a Content {
} }
} }
impl<'a> Into<Element> for &'a Jingle { impl Into<Element> for Jingle {
fn into(self) -> Element { fn into(self) -> Element {
let mut root = Element::builder("jingle") let mut root = Element::builder("jingle")
.ns(ns::JINGLE) .ns(ns::JINGLE)
@ -384,15 +384,15 @@ impl<'a> Into<Element> for &'a Jingle {
.attr("responder", self.responder.clone()) .attr("responder", self.responder.clone())
.attr("sid", self.sid.clone()) .attr("sid", self.sid.clone())
.build(); .build();
for content in self.contents.clone() { for content in self.contents {
let content_elem = (&content).into(); let content_elem = content.into();
root.append_child(content_elem); root.append_child(content_elem);
} }
if let Some(ref reason) = self.reason { if let Some(reason) = self.reason {
let reason2: Element = (&reason.reason).into(); let reason2: Element = reason.reason.into();
let reason_elem = Element::builder("reason") let reason_elem = Element::builder("reason")
.append(reason2) .append(reason2)
.append(reason.text.clone()) .append(reason.text)
.build(); .build();
root.append_child(reason_elem); root.append_child(reason_elem);
} }
@ -400,12 +400,6 @@ impl<'a> Into<Element> for &'a Jingle {
} }
} }
impl Into<Element> for Jingle {
fn into(self) -> Element {
(&self).into()
}
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use super::*; use super::*;
@ -413,7 +407,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'/>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'/>".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.action, Action::SessionInitiate);
assert_eq!(jingle.sid, "coucou"); assert_eq!(jingle.sid, "coucou");
} }
@ -421,7 +415,7 @@ mod tests {
#[test] #[test]
fn test_invalid_jingle() { fn test_invalid_jingle() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1'/>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1'/>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -429,7 +423,7 @@ mod tests {
assert_eq!(message, "Jingle must have an 'action' attribute."); assert_eq!(message, "Jingle must have an 'action' attribute.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-info'/>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-info'/>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -437,7 +431,7 @@ mod tests {
assert_eq!(message, "Jingle must have a 'sid' attribute."); assert_eq!(message, "Jingle must have a 'sid' attribute.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='coucou' sid='coucou'/>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='coucou' sid='coucou'/>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -448,25 +442,25 @@ mod tests {
#[test] #[test]
fn test_content() { fn test_content() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou'><description/><transport/></content></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou'><description/><transport/></content></jingle>".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].creator, Creator::Initiator);
assert_eq!(jingle.contents[0].name, "coucou"); assert_eq!(jingle.contents[0].name, "coucou");
assert_eq!(jingle.contents[0].senders, Senders::Both); assert_eq!(jingle.contents[0].senders, Senders::Both);
assert_eq!(jingle.contents[0].disposition, "session"); assert_eq!(jingle.contents[0].disposition, "session");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders='both'><description/><transport/></content></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders='both'><description/><transport/></content></jingle>".parse().unwrap();
let jingle = Jingle::try_from(&elem).unwrap(); let jingle = Jingle::try_from(elem).unwrap();
assert_eq!(jingle.contents[0].senders, Senders::Both); assert_eq!(jingle.contents[0].senders, Senders::Both);
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' disposition='early-session'><description/><transport/></content></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' disposition='early-session'><description/><transport/></content></jingle>".parse().unwrap();
let jingle = Jingle::try_from(&elem).unwrap(); let jingle = Jingle::try_from(elem).unwrap();
assert_eq!(jingle.contents[0].disposition, "early-session"); assert_eq!(jingle.contents[0].disposition, "early-session");
} }
#[test] #[test]
fn test_invalid_content() { fn test_invalid_content() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -474,7 +468,7 @@ mod tests {
assert_eq!(message, "Content must have a 'creator' attribute."); assert_eq!(message, "Content must have a 'creator' attribute.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator'/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator'/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -482,7 +476,7 @@ mod tests {
assert_eq!(message, "Content must have a 'name' attribute."); assert_eq!(message, "Content must have a 'name' attribute.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='coucou' name='coucou'/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='coucou' name='coucou'/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -490,7 +484,7 @@ mod tests {
assert_eq!(message, "Unknown creator."); assert_eq!(message, "Unknown creator.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders='coucou'/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders='coucou'/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -498,7 +492,7 @@ mod tests {
assert_eq!(message, "Unknown senders."); assert_eq!(message, "Unknown senders.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders=''/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><content creator='initiator' name='coucou' senders=''/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -509,13 +503,13 @@ mod tests {
#[test] #[test]
fn test_reason() { fn test_reason() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><success/></reason></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><success/></reason></jingle>".parse().unwrap();
let jingle = Jingle::try_from(&elem).unwrap(); let jingle = Jingle::try_from(elem).unwrap();
let reason = jingle.reason.unwrap(); let reason = jingle.reason.unwrap();
assert_eq!(reason.reason, Reason::Success); assert_eq!(reason.reason, Reason::Success);
assert_eq!(reason.text, None); assert_eq!(reason.text, None);
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><success/><text>coucou</text></reason></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><success/><text>coucou</text></reason></jingle>".parse().unwrap();
let jingle = Jingle::try_from(&elem).unwrap(); let jingle = Jingle::try_from(elem).unwrap();
let reason = jingle.reason.unwrap(); let reason = jingle.reason.unwrap();
assert_eq!(reason.reason, Reason::Success); assert_eq!(reason.reason, Reason::Success);
assert_eq!(reason.text, Some(String::from("coucou"))); assert_eq!(reason.text, Some(String::from("coucou")));
@ -524,7 +518,7 @@ mod tests {
#[test] #[test]
fn test_invalid_reason() { fn test_invalid_reason() {
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -532,7 +526,7 @@ mod tests {
assert_eq!(message, "Reason doesn’t contain a valid reason."); assert_eq!(message, "Reason doesn’t contain a valid reason.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><a/></reason></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><a/></reason></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -540,7 +534,7 @@ mod tests {
assert_eq!(message, "Unknown reason."); assert_eq!(message, "Unknown reason.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><a xmlns='http://www.w3.org/1999/xhtml'/></reason></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><a xmlns='http://www.w3.org/1999/xhtml'/></reason></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -548,7 +542,7 @@ mod tests {
assert_eq!(message, "Reason contains a foreign element."); assert_eq!(message, "Reason contains a foreign element.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><decline/></reason><reason/></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><decline/></reason><reason/></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -556,7 +550,7 @@ mod tests {
assert_eq!(message, "Jingle must not have more than one reason."); assert_eq!(message, "Jingle must not have more than one reason.");
let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><decline/><text/><text/></reason></jingle>".parse().unwrap(); let elem: Element = "<jingle xmlns='urn:xmpp:jingle:1' action='session-initiate' sid='coucou'><reason><decline/><text/><text/></reason></jingle>".parse().unwrap();
let error = Jingle::try_from(&elem).unwrap_err(); let error = Jingle::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

46
src/jingle_ft.rs
View file

@ -31,7 +31,7 @@ impl IntoElements for Range {
}) })
.build(); .build();
for hash in self.hashes { for hash in self.hashes {
elem.append_child((&hash).into()); elem.append_child(hash.into());
} }
emitter.append_child(elem); emitter.append_child(elem);
} }
@ -86,10 +86,10 @@ impl IntoElements for Received {
} }
} }
impl<'a> TryFrom<&'a Element> for Description { impl TryFrom<Element> for Description {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Description, Error> { fn try_from(elem: Element) -> Result<Description, Error> {
if !elem.is("description", ns::JINGLE_FT) { if !elem.is("description", ns::JINGLE_FT) {
return Err(Error::ParseError("This is not a JingleFT description element.")); 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) { if !hash_element.is("hash", ns::HASHES) {
return Err(Error::ParseError("Unknown element in JingleFT range.")); 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 { range = Some(Range {
offset: offset, offset: offset,
@ -153,7 +153,7 @@ impl<'a> TryFrom<&'a Element> for Description {
hashes: range_hashes, hashes: range_hashes,
}); });
} else if file_payload.is("hash", ns::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 { } else {
return Err(Error::ParseError("Unknown element in JingleFT file.")); return Err(Error::ParseError("Unknown element in JingleFT file."));
} }
@ -174,57 +174,57 @@ impl<'a> TryFrom<&'a Element> for Description {
} }
} }
impl<'a> Into<Element> for &'a File { impl Into<Element> for File {
fn into(self) -> Element { fn into(self) -> Element {
let mut root = Element::builder("file") let mut root = Element::builder("file")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.build(); .build();
if let Some(ref date) = self.date { if let Some(date) = self.date {
root.append_child(Element::builder("date") root.append_child(Element::builder("date")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(date.clone()) .append(date)
.build()); .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") root.append_child(Element::builder("media-type")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(media_type.clone()) .append(media_type)
.build()); .build());
} }
if let Some(ref name) = self.name { if let Some(name) = self.name {
root.append_child(Element::builder("name") root.append_child(Element::builder("name")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(name.clone()) .append(name)
.build()); .build());
} }
if let Some(ref desc) = self.desc { if let Some(desc) = self.desc {
root.append_child(Element::builder("desc") root.append_child(Element::builder("desc")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(desc.clone()) .append(desc)
.build()); .build());
} }
if let Some(ref size) = self.size { if let Some(size) = self.size {
root.append_child(Element::builder("size") root.append_child(Element::builder("size")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(format!("{}", size)) .append(format!("{}", size))
.build()); .build());
} }
if let Some(ref range) = self.range { if let Some(range) = self.range {
root.append_child(Element::builder("range") root.append_child(Element::builder("range")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(range.clone()) .append(range)
.build()); .build());
} }
for hash in self.hashes.clone() { for hash in self.hashes {
root.append_child((&hash).into()); root.append_child(hash.into());
} }
root root
} }
} }
impl<'a> Into<Element> for &'a Description { impl Into<Element> for Description {
fn into(self) -> Element { fn into(self) -> Element {
let file: Element = (&self.file).into(); let file: Element = self.file.into();
Element::builder("description") Element::builder("description")
.ns(ns::JINGLE_FT) .ns(ns::JINGLE_FT)
.append(file) .append(file)
@ -252,7 +252,7 @@ mod tests {
</description> </description>
"#.parse().unwrap(); "#.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.media_type, Some(String::from("text/plain")));
assert_eq!(desc.file.name, Some(String::from("test.txt"))); assert_eq!(desc.file.name, Some(String::from("test.txt")));
assert_eq!(desc.file.desc, None); assert_eq!(desc.file.desc, None);
@ -274,7 +274,7 @@ mod tests {
</description> </description>
"#.parse().unwrap(); "#.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.media_type, None);
assert_eq!(desc.file.name, None); assert_eq!(desc.file.name, None);
assert_eq!(desc.file.desc, None); assert_eq!(desc.file.desc, None);

18
src/jingle_ibb.rs
View file

@ -21,10 +21,10 @@ pub struct Transport {
pub stanza: Stanza, pub stanza: Stanza,
} }
impl<'a> TryFrom<&'a Element> for Transport { impl TryFrom<Element> for Transport {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Transport, Error> { fn try_from(elem: Element) -> Result<Transport, Error> {
if elem.is("transport", ns::JINGLE_IBB) { if elem.is("transport", ns::JINGLE_IBB) {
for _ in elem.children() { for _ in elem.children() {
return Err(Error::ParseError("Unknown child in JingleIBB element.")); return Err(Error::ParseError("Unknown child in JingleIBB element."));
@ -43,7 +43,7 @@ impl<'a> TryFrom<&'a Element> for Transport {
} }
} }
impl<'a> Into<Element> for &'a Transport { impl Into<Element> for Transport {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("transport") Element::builder("transport")
.ns(ns::JINGLE_IBB) .ns(ns::JINGLE_IBB)
@ -62,7 +62,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='3' sid='coucou'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='3' sid='coucou'/>".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.block_size, 3);
assert_eq!(transport.sid, "coucou"); assert_eq!(transport.sid, "coucou");
assert_eq!(transport.stanza, Stanza::Iq); assert_eq!(transport.stanza, Stanza::Iq);
@ -71,7 +71,7 @@ mod tests {
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1'/>".parse().unwrap();
let error = Transport::try_from(&elem).unwrap_err(); let error = Transport::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -79,7 +79,7 @@ mod tests {
assert_eq!(message, "Required attribute 'block-size' missing."); assert_eq!(message, "Required attribute 'block-size' missing.");
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='65536'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='65536'/>".parse().unwrap();
let error = Transport::try_from(&elem).unwrap_err(); let error = Transport::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseIntError(error) => error, Error::ParseIntError(error) => error,
_ => panic!(), _ => panic!(),
@ -87,7 +87,7 @@ mod tests {
assert_eq!(message.description(), "number too large to fit in target type"); assert_eq!(message.description(), "number too large to fit in target type");
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='-5'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='-5'/>".parse().unwrap();
let error = Transport::try_from(&elem).unwrap_err(); let error = Transport::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseIntError(error) => error, Error::ParseIntError(error) => error,
_ => panic!(), _ => panic!(),
@ -95,7 +95,7 @@ mod tests {
assert_eq!(message.description(), "invalid digit found in string"); assert_eq!(message.description(), "invalid digit found in string");
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='128'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='128'/>".parse().unwrap();
let error = Transport::try_from(&elem).unwrap_err(); let error = Transport::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -106,7 +106,7 @@ mod tests {
#[test] #[test]
fn test_invalid_stanza() { fn test_invalid_stanza() {
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='128' sid='coucou' stanza='fdsq'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:ibb:1' block-size='128' sid='coucou' stanza='fdsq'/>".parse().unwrap();
let error = Transport::try_from(&elem).unwrap_err(); let error = Transport::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

22
src/jingle_s5b.rs
View file

@ -63,7 +63,7 @@ pub struct Candidate {
pub type_: Type, pub type_: Type,
} }
impl<'a> Into<Element> for &'a Candidate { impl Into<Element> for Candidate {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("candidate") Element::builder("candidate")
.ns(ns::JINGLE_S5B) .ns(ns::JINGLE_S5B)
@ -129,10 +129,10 @@ pub struct Transport {
pub payload: TransportPayload, pub payload: TransportPayload,
} }
impl<'a> TryFrom<&'a Element> for Transport { impl TryFrom<Element> for Transport {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Transport, Error> { fn try_from(elem: Element) -> Result<Transport, Error> {
if elem.is("transport", ns::JINGLE_S5B) { if elem.is("transport", ns::JINGLE_S5B) {
let sid = get_attr!(elem, "sid", required); let sid = get_attr!(elem, "sid", required);
let dstaddr = get_attr!(elem, "dstaddr", optional); let dstaddr = get_attr!(elem, "dstaddr", optional);
@ -200,7 +200,7 @@ impl<'a> TryFrom<&'a Element> for Transport {
} }
} }
impl<'a> Into<Element> for &'a Transport { impl Into<Element> for Transport {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("transport") Element::builder("transport")
.ns(ns::JINGLE_S5B) .ns(ns::JINGLE_S5B)
@ -208,15 +208,15 @@ impl<'a> Into<Element> for &'a Transport {
.attr("dstaddr", self.dstaddr.clone()) .attr("dstaddr", self.dstaddr.clone())
.attr("mode", self.mode.clone()) .attr("mode", self.mode.clone())
.append(match self.payload { .append(match self.payload {
TransportPayload::Candidates(ref candidates) => { TransportPayload::Candidates(candidates) => {
candidates.iter() candidates.iter()
.map(|candidate| -> Element { candidate.into() }) .map(|candidate| -> Element { candidate.clone().into() })
.collect::<Vec<Element>>() .collect::<Vec<Element>>()
}, },
TransportPayload::Activated(ref cid) => { TransportPayload::Activated(cid) => {
vec!(Element::builder("activated") vec!(Element::builder("activated")
.ns(ns::JINGLE_S5B) .ns(ns::JINGLE_S5B)
.attr("cid", cid.to_owned()) .attr("cid", cid)
.build()) .build())
}, },
TransportPayload::CandidateError => { TransportPayload::CandidateError => {
@ -248,7 +248,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:s5b:1' sid='coucou'/>".parse().unwrap(); let elem: Element = "<transport xmlns='urn:xmpp:jingle:transports:s5b:1' sid='coucou'/>".parse().unwrap();
let transport = Transport::try_from(&elem).unwrap(); let transport = Transport::try_from(elem).unwrap();
assert_eq!(transport.sid, "coucou"); assert_eq!(transport.sid, "coucou");
assert_eq!(transport.dstaddr, None); assert_eq!(transport.dstaddr, None);
assert_eq!(transport.mode, Mode::Tcp); assert_eq!(transport.mode, Mode::Tcp);
@ -267,7 +267,7 @@ mod tests {
mode: Mode::Tcp, mode: Mode::Tcp,
payload: TransportPayload::Activated(String::from("coucou")), payload: TransportPayload::Activated(String::from("coucou")),
}; };
let elem2: Element = (&transport).into(); let elem2: Element = transport.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
@ -287,7 +287,7 @@ mod tests {
type_: Type::Direct, type_: Type::Direct,
})), })),
}; };
let elem2: Element = (&transport).into(); let elem2: Element = transport.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

70
src/mam.rs
View file

@ -60,9 +60,9 @@ impl FromStr for DefaultPrefs {
} }
} }
impl<'a> IntoAttributeValue for &'a DefaultPrefs { impl IntoAttributeValue for DefaultPrefs {
fn into_attribute_value(self) -> Option<String> { fn into_attribute_value(self) -> Option<String> {
Some(String::from(match *self { Some(String::from(match self {
DefaultPrefs::Always => "always", DefaultPrefs::Always => "always",
DefaultPrefs::Never => "never", DefaultPrefs::Never => "never",
DefaultPrefs::Roster => "roster", DefaultPrefs::Roster => "roster",
@ -77,10 +77,10 @@ pub struct Prefs {
pub never: Vec<Jid>, pub never: Vec<Jid>,
} }
impl<'a> TryFrom<&'a Element> for Query { impl TryFrom<Element> for Query {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Query, Error> { fn try_from(elem: Element) -> Result<Query, Error> {
if !elem.is("query", ns::MAM) { if !elem.is("query", ns::MAM) {
return Err(Error::ParseError("This is not a query element.")); 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; let mut set = None;
for child in elem.children() { for child in elem.children() {
if child.is("x", ns::DATA_FORMS) { 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) { } else if child.is("set", ns::RSM) {
set = Some(Set::try_from(child)?); set = Some(Set::try_from(child.clone())?);
} else { } else {
return Err(Error::ParseError("Unknown child in query element.")); 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<Element> for Result_ {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Result_, Error> { fn try_from(elem: Element) -> Result<Result_, Error> {
if !elem.is("result", ns::MAM) { if !elem.is("result", ns::MAM) {
return Err(Error::ParseError("This is not a result element.")); return Err(Error::ParseError("This is not a result element."));
} }
let mut forwarded = None; let mut forwarded = None;
for child in elem.children() { for child in elem.children() {
if child.is("forwarded", ns::FORWARD) { if child.is("forwarded", ns::FORWARD) {
forwarded = Some(Forwarded::try_from(child)?); forwarded = Some(Forwarded::try_from(child.clone())?);
} else { } else {
return Err(Error::ParseError("Unknown child in result element.")); 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<Element> for Fin {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Fin, Error> { fn try_from(elem: Element) -> Result<Fin, Error> {
if !elem.is("fin", ns::MAM) { if !elem.is("fin", ns::MAM) {
return Err(Error::ParseError("This is not a fin element.")); return Err(Error::ParseError("This is not a fin element."));
} }
let mut set = None; let mut set = None;
for child in elem.children() { for child in elem.children() {
if child.is("set", ns::RSM) { if child.is("set", ns::RSM) {
set = Some(Set::try_from(child)?); set = Some(Set::try_from(child.clone())?);
} else { } else {
return Err(Error::ParseError("Unknown child in fin element.")); 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<Element> for Prefs {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Prefs, Error> { fn try_from(elem: Element) -> Result<Prefs, Error> {
if !elem.is("prefs", ns::MAM) { if !elem.is("prefs", ns::MAM) {
return Err(Error::ParseError("This is not a prefs element.")); return Err(Error::ParseError("This is not a prefs element."));
} }
@ -186,7 +186,7 @@ impl<'a> TryFrom<&'a Element> for Prefs {
} }
} }
impl<'a> Into<Element> for &'a Query { impl Into<Element> for Query {
fn into(self) -> Element { fn into(self) -> Element {
let mut elem = Element::builder("query") let mut elem = Element::builder("query")
.ns(ns::MAM) .ns(ns::MAM)
@ -194,43 +194,43 @@ impl<'a> Into<Element> for &'a Query {
.attr("node", self.node.clone()) .attr("node", self.node.clone())
.build(); .build();
//if let Some(form) = self.form { //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.append_child(set.into());
} }
elem elem
} }
} }
impl<'a> Into<Element> for &'a Result_ { impl Into<Element> for Result_ {
fn into(self) -> Element { fn into(self) -> Element {
let mut elem = Element::builder("result") let mut elem = Element::builder("result")
.ns(ns::MAM) .ns(ns::MAM)
.attr("queryid", self.queryid.clone()) .attr("queryid", self.queryid)
.attr("id", self.id.clone()) .attr("id", self.id)
.build(); .build();
elem.append_child((&self.forwarded).into()); elem.append_child(self.forwarded.into());
elem elem
} }
} }
impl<'a> Into<Element> for &'a Fin { impl Into<Element> for Fin {
fn into(self) -> Element { fn into(self) -> Element {
let mut elem = Element::builder("fin") let mut elem = Element::builder("fin")
.ns(ns::MAM) .ns(ns::MAM)
.attr("complete", if self.complete { Some("true") } else { None }) .attr("complete", if self.complete { Some("true") } else { None })
.build(); .build();
elem.append_child((&self.set).into()); elem.append_child(self.set.into());
elem elem
} }
} }
impl<'a> Into<Element> for &'a Prefs { impl Into<Element> for Prefs {
fn into(self) -> Element { fn into(self) -> Element {
let mut elem = Element::builder("prefs") let mut elem = Element::builder("prefs")
.ns(ns::MAM) .ns(ns::MAM)
.attr("default", &self.default_) .attr("default", self.default_)
.build(); .build();
if !self.always.is_empty() { if !self.always.is_empty() {
let mut always = Element::builder("always") let mut always = Element::builder("always")
@ -267,7 +267,7 @@ mod tests {
#[test] #[test]
fn test_query() { fn test_query() {
let elem: Element = "<query xmlns='urn:xmpp:mam:2'/>".parse().unwrap(); let elem: Element = "<query xmlns='urn:xmpp:mam:2'/>".parse().unwrap();
Query::try_from(&elem).unwrap(); Query::try_from(elem).unwrap();
} }
#[test] #[test]
@ -282,7 +282,7 @@ mod tests {
</forwarded> </forwarded>
</result> </result>
"#.parse().unwrap(); "#.parse().unwrap();
Result_::try_from(&elem).unwrap(); Result_::try_from(elem).unwrap();
} }
#[test] #[test]
@ -295,7 +295,7 @@ mod tests {
</set> </set>
</fin> </fin>
"#.parse().unwrap(); "#.parse().unwrap();
Fin::try_from(&elem).unwrap(); Fin::try_from(elem).unwrap();
} }
#[test] #[test]
@ -312,7 +312,7 @@ mod tests {
</x> </x>
</query> </query>
"#.parse().unwrap(); "#.parse().unwrap();
Query::try_from(&elem).unwrap(); Query::try_from(elem).unwrap();
} }
#[test] #[test]
@ -332,13 +332,13 @@ mod tests {
</set> </set>
</query> </query>
"#.parse().unwrap(); "#.parse().unwrap();
Query::try_from(&elem).unwrap(); Query::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_prefs_get() { fn test_prefs_get() {
let elem: Element = "<prefs xmlns='urn:xmpp:mam:2' default='always'/>".parse().unwrap(); let elem: Element = "<prefs xmlns='urn:xmpp:mam:2' default='always'/>".parse().unwrap();
Prefs::try_from(&elem).unwrap(); Prefs::try_from(elem).unwrap();
let elem: Element = r#" let elem: Element = r#"
<prefs xmlns='urn:xmpp:mam:2' default='roster'> <prefs xmlns='urn:xmpp:mam:2' default='roster'>
@ -346,7 +346,7 @@ mod tests {
<never/> <never/>
</prefs> </prefs>
"#.parse().unwrap(); "#.parse().unwrap();
Prefs::try_from(&elem).unwrap(); Prefs::try_from(elem).unwrap();
} }
#[test] #[test]
@ -361,13 +361,13 @@ mod tests {
</never> </never>
</prefs> </prefs>
"#.parse().unwrap(); "#.parse().unwrap();
Prefs::try_from(&elem).unwrap(); Prefs::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<query xmlns='urn:xmpp:mam:2'><coucou/></query>".parse().unwrap(); let elem: Element = "<query xmlns='urn:xmpp:mam:2'><coucou/></query>".parse().unwrap();
let error = Query::try_from(&elem).unwrap_err(); let error = Query::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -379,7 +379,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<query xmlns='urn:xmpp:mam:2'/>".parse().unwrap(); let elem: Element = "<query xmlns='urn:xmpp:mam:2'/>".parse().unwrap();
let replace = Query { queryid: None, node: None, form: None, set: None }; let replace = Query { queryid: None, node: None, form: None, set: None };
let elem2 = (&replace).into(); let elem2 = replace.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

28
src/media_element.rs
View file

@ -25,10 +25,10 @@ pub struct MediaElement {
pub uris: Vec<URI>, pub uris: Vec<URI>,
} }
impl<'a> TryFrom<&'a Element> for MediaElement { impl TryFrom<Element> for MediaElement {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<MediaElement, Error> { fn try_from(elem: Element) -> Result<MediaElement, Error> {
if !elem.is("media", ns::MEDIA_ELEMENT) { if !elem.is("media", ns::MEDIA_ELEMENT) {
return Err(Error::ParseError("This is not a media element.")); return Err(Error::ParseError("This is not a media element."));
} }
@ -60,7 +60,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<media xmlns='urn:xmpp:media-element'/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element'/>".parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.width.is_none()); assert!(media.width.is_none());
assert!(media.height.is_none()); assert!(media.height.is_none());
assert!(media.uris.is_empty()); assert!(media.uris.is_empty());
@ -69,7 +69,7 @@ mod tests {
#[test] #[test]
fn test_width_height() { fn test_width_height() {
let elem: Element = "<media xmlns='urn:xmpp:media-element' width='32' height='32'/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element' width='32' height='32'/>".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.width.unwrap(), 32);
assert_eq!(media.height.unwrap(), 32); assert_eq!(media.height.unwrap(), 32);
} }
@ -77,7 +77,7 @@ mod tests {
#[test] #[test]
fn test_uri() { fn test_uri() {
let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri type='text/html'>https://example.org/</uri></media>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri type='text/html'>https://example.org/</uri></media>".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.len(), 1);
assert_eq!(media.uris[0].type_, "text/html"); assert_eq!(media.uris[0].type_, "text/html");
assert_eq!(media.uris[0].uri, "https://example.org/"); assert_eq!(media.uris[0].uri, "https://example.org/");
@ -86,26 +86,26 @@ mod tests {
#[test] #[test]
fn test_invalid_width_height() { fn test_invalid_width_height() {
let elem: Element = "<media xmlns='urn:xmpp:media-element' width=''/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element' width=''/>".parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.width.is_none()); assert!(media.width.is_none());
let elem: Element = "<media xmlns='urn:xmpp:media-element' width='coucou'/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element' width='coucou'/>".parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.width.is_none()); assert!(media.width.is_none());
let elem: Element = "<media xmlns='urn:xmpp:media-element' height=''/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element' height=''/>".parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.height.is_none()); assert!(media.height.is_none());
let elem: Element = "<media xmlns='urn:xmpp:media-element' height='-10'/>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element' height='-10'/>".parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.height.is_none()); assert!(media.height.is_none());
} }
#[test] #[test]
fn test_unknown_child() { fn test_unknown_child() {
let elem: Element = "<media xmlns='urn:xmpp:media-element'><coucou/></media>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element'><coucou/></media>".parse().unwrap();
let error = MediaElement::try_from(&elem).unwrap_err(); let error = MediaElement::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -116,7 +116,7 @@ mod tests {
#[test] #[test]
fn test_bad_uri() { fn test_bad_uri() {
let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri>https://example.org/</uri></media>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri>https://example.org/</uri></media>".parse().unwrap();
let error = MediaElement::try_from(&elem).unwrap_err(); let error = MediaElement::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -124,7 +124,7 @@ mod tests {
assert_eq!(message, "Attribute type on uri is mandatory."); assert_eq!(message, "Attribute type on uri is mandatory.");
let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri type='text/html'/></media>".parse().unwrap(); let elem: Element = "<media xmlns='urn:xmpp:media-element'><uri type='text/html'/></media>".parse().unwrap();
let error = MediaElement::try_from(&elem).unwrap_err(); let error = MediaElement::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -146,7 +146,7 @@ mod tests {
http://victim.example.com/challenges/speech.mp3?F3A6292C http://victim.example.com/challenges/speech.mp3?F3A6292C
</uri> </uri>
</media>"#.parse().unwrap(); </media>"#.parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap(); let media = MediaElement::try_from(elem).unwrap();
assert!(media.width.is_none()); assert!(media.width.is_none());
assert!(media.height.is_none()); assert!(media.height.is_none());
assert_eq!(media.uris.len(), 3); assert_eq!(media.uris.len(), 3);
@ -177,7 +177,7 @@ mod tests {
</field> </field>
[ ... ] [ ... ]
</x>"#.parse().unwrap(); </x>"#.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.len(), 1);
assert_eq!(form.fields[0].var, "ocr"); assert_eq!(form.fields[0].var, "ocr");
assert_eq!(form.fields[0].media[0].width, Some(290)); assert_eq!(form.fields[0].media[0].width, Some(290));

61
src/message.rs
View file

@ -42,10 +42,10 @@ pub enum MessagePayload {
Unknown(Element), Unknown(Element),
} }
impl<'a> TryFrom<&'a Element> for MessagePayload { impl TryFrom<Element> for MessagePayload {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<MessagePayload, Error> { fn try_from(elem: Element) -> Result<MessagePayload, Error> {
Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) {
("error", ns::JABBER_CLIENT) => MessagePayload::StanzaError(StanzaError::try_from(elem)?), ("error", ns::JABBER_CLIENT) => MessagePayload::StanzaError(StanzaError::try_from(elem)?),
@ -84,20 +84,20 @@ impl<'a> TryFrom<&'a Element> for MessagePayload {
} }
} }
impl<'a> Into<Element> for &'a MessagePayload { impl Into<Element> for MessagePayload {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
MessagePayload::StanzaError(ref stanza_error) => stanza_error.into(), MessagePayload::StanzaError(stanza_error) => stanza_error.into(),
MessagePayload::Attention(ref attention) => attention.into(), MessagePayload::Attention(attention) => attention.into(),
MessagePayload::ChatState(ref chatstate) => chatstate.into(), MessagePayload::ChatState(chatstate) => chatstate.into(),
MessagePayload::Receipt(ref receipt) => receipt.into(), MessagePayload::Receipt(receipt) => receipt.into(),
MessagePayload::Delay(ref delay) => delay.into(), MessagePayload::Delay(delay) => delay.into(),
MessagePayload::MessageCorrect(ref replace) => replace.into(), MessagePayload::MessageCorrect(replace) => replace.into(),
MessagePayload::ExplicitMessageEncryption(ref eme) => eme.into(), MessagePayload::ExplicitMessageEncryption(eme) => eme.into(),
MessagePayload::StanzaId(ref stanza_id) => stanza_id.into(), MessagePayload::StanzaId(stanza_id) => stanza_id.into(),
MessagePayload::MamResult(ref result) => result.into(), MessagePayload::MamResult(result) => result.into(),
MessagePayload::Unknown(ref elem) => elem.clone(), MessagePayload::Unknown(elem) => elem.clone(),
} }
} }
} }
@ -162,10 +162,10 @@ pub struct Message {
pub payloads: Vec<Element>, pub payloads: Vec<Element>,
} }
impl<'a> TryFrom<&'a Element> for Message { impl TryFrom<Element> for Message {
type Error = Error; type Error = Error;
fn try_from(root: &'a Element) -> Result<Message, Error> { fn try_from(root: Element) -> Result<Message, Error> {
if !root.is("message", ns::JABBER_CLIENT) { if !root.is("message", ns::JABBER_CLIENT) {
return Err(Error::ParseError("This is not a message element.")); return Err(Error::ParseError("This is not a message element."));
} }
@ -219,7 +219,7 @@ impl<'a> TryFrom<&'a Element> for Message {
} }
} }
impl<'a> Into<Element> for &'a Message { impl Into<Element> for Message {
fn into(self) -> Element { fn into(self) -> Element {
let mut stanza = Element::builder("message") let mut stanza = Element::builder("message")
.ns(ns::JABBER_CLIENT) .ns(ns::JABBER_CLIENT)
@ -264,7 +264,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap(); let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap();
let message = Message::try_from(&elem).unwrap(); let message = Message::try_from(elem).unwrap();
assert_eq!(message.from, None); assert_eq!(message.from, None);
assert_eq!(message.to, None); assert_eq!(message.to, None);
assert_eq!(message.id, None); assert_eq!(message.id, None);
@ -285,18 +285,19 @@ mod tests {
thread: None, thread: None,
payloads: vec!(), payloads: vec!(),
}; };
let elem2 = (&message).into(); let elem2 = message.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
#[test] #[test]
fn test_body() { fn test_body() {
let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><body>Hello world!</body></message>".parse().unwrap(); let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><body>Hello world!</body></message>".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!"); assert_eq!(message.bodies[""], "Hello world!");
let elem2 = (&message).into(); let elem2 = message.into();
assert_eq!(elem, elem2); assert_eq!(elem1, elem2);
} }
#[test] #[test]
@ -314,25 +315,27 @@ mod tests {
thread: None, thread: None,
payloads: vec!(), payloads: vec!(),
}; };
let elem2 = (&message).into(); let elem2 = message.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
#[test] #[test]
fn test_subject() { fn test_subject() {
let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><subject>Hello world!</subject></message>".parse().unwrap(); let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><subject>Hello world!</subject></message>".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!"); assert_eq!(message.subjects[""], "Hello world!");
let elem2 = (&message).into(); let elem2 = message.into();
assert_eq!(elem, elem2); assert_eq!(elem1, elem2);
} }
#[test] #[test]
fn test_attention() { fn test_attention() {
let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><attention xmlns='urn:xmpp:attention:0'/></message>".parse().unwrap(); let elem: Element = "<message xmlns='jabber:client' to='coucou@example.org' type='chat'><attention xmlns='urn:xmpp:attention:0'/></message>".parse().unwrap();
let message = Message::try_from(&elem).unwrap(); let elem1 = elem.clone();
let elem2 = (&message).into(); let message = Message::try_from(elem).unwrap();
assert_eq!(elem, elem2); let elem2 = message.into();
assert_eq!(elem1, elem2);
} }
} }

14
src/message_correct.rs
View file

@ -17,10 +17,10 @@ pub struct Replace {
pub id: String, pub id: String,
} }
impl<'a> TryFrom<&'a Element> for Replace { impl TryFrom<Element> for Replace {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Replace, Error> { fn try_from(elem: Element) -> Result<Replace, Error> {
if !elem.is("replace", ns::MESSAGE_CORRECT) { if !elem.is("replace", ns::MESSAGE_CORRECT) {
return Err(Error::ParseError("This is not a replace element.")); return Err(Error::ParseError("This is not a replace element."));
} }
@ -32,7 +32,7 @@ impl<'a> TryFrom<&'a Element> for Replace {
} }
} }
impl<'a> Into<Element> for &'a Replace { impl Into<Element> for Replace {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("replace") Element::builder("replace")
.ns(ns::MESSAGE_CORRECT) .ns(ns::MESSAGE_CORRECT)
@ -48,13 +48,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap();
Replace::try_from(&elem).unwrap(); Replace::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'><coucou/></replace>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'><coucou/></replace>".parse().unwrap();
let error = Replace::try_from(&elem).unwrap_err(); let error = Replace::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -65,7 +65,7 @@ mod tests {
#[test] #[test]
fn test_invalid_id() { fn test_invalid_id() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
let error = Replace::try_from(&elem).unwrap_err(); let error = Replace::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -77,7 +77,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap();
let replace = Replace { id: String::from("coucou") }; let replace = Replace { id: String::from("coucou") };
let elem2 = (&replace).into(); let elem2 = replace.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
} }

12
src/ping.rs
View file

@ -16,10 +16,10 @@ use ns;
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct Ping; pub struct Ping;
impl<'a> TryFrom<&'a Element> for Ping { impl TryFrom<Element> for Ping {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Ping, Error> { fn try_from(elem: Element) -> Result<Ping, Error> {
if !elem.is("ping", ns::PING) { if !elem.is("ping", ns::PING) {
return Err(Error::ParseError("This is not a ping element.")); return Err(Error::ParseError("This is not a ping element."));
} }
@ -33,7 +33,7 @@ impl<'a> TryFrom<&'a Element> for Ping {
} }
} }
impl<'a> Into<Element> for &'a Ping { impl Into<Element> for Ping {
fn into(self) -> Element { fn into(self) -> Element {
Element::builder("ping") Element::builder("ping")
.ns(ns::PING) .ns(ns::PING)
@ -48,13 +48,13 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<ping xmlns='urn:xmpp:ping'/>".parse().unwrap(); let elem: Element = "<ping xmlns='urn:xmpp:ping'/>".parse().unwrap();
Ping::try_from(&elem).unwrap(); Ping::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_invalid() { fn test_invalid() {
let elem: Element = "<ping xmlns='urn:xmpp:ping'><coucou/></ping>".parse().unwrap(); let elem: Element = "<ping xmlns='urn:xmpp:ping'><coucou/></ping>".parse().unwrap();
let error = Ping::try_from(&elem).unwrap_err(); let error = Ping::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -65,7 +65,7 @@ mod tests {
#[test] #[test]
fn test_invalid_attribute() { fn test_invalid_attribute() {
let elem: Element = "<ping xmlns='urn:xmpp:ping' coucou=''/>".parse().unwrap(); let elem: Element = "<ping xmlns='urn:xmpp:ping' coucou=''/>".parse().unwrap();
let error = Ping::try_from(&elem).unwrap_err(); let error = Ping::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

56
src/presence.rs
View file

@ -57,10 +57,10 @@ pub enum PresencePayload {
Unknown(Element), Unknown(Element),
} }
impl<'a> TryFrom<&'a Element> for PresencePayload { impl TryFrom<Element> for PresencePayload {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<PresencePayload, Error> { fn try_from(elem: Element) -> Result<PresencePayload, Error> {
Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) { Ok(match (elem.name().as_ref(), elem.ns().unwrap().as_ref()) {
("error", ns::JABBER_CLIENT) => PresencePayload::StanzaError(StanzaError::try_from(elem)?), ("error", ns::JABBER_CLIENT) => PresencePayload::StanzaError(StanzaError::try_from(elem)?),
@ -73,20 +73,20 @@ impl<'a> TryFrom<&'a Element> for PresencePayload {
// XEP-0390 // XEP-0390
("c", ns::ECAPS2) => PresencePayload::ECaps2(ECaps2::try_from(elem)?), ("c", ns::ECAPS2) => PresencePayload::ECaps2(ECaps2::try_from(elem)?),
_ => PresencePayload::Unknown(elem.clone()), _ => PresencePayload::Unknown(elem),
}) })
} }
} }
impl<'a> Into<Element> for &'a PresencePayload { impl Into<Element> for PresencePayload {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
PresencePayload::StanzaError(ref stanza_error) => stanza_error.into(), PresencePayload::StanzaError(stanza_error) => stanza_error.into(),
PresencePayload::Delay(ref delay) => delay.into(), PresencePayload::Delay(delay) => delay.into(),
PresencePayload::Idle(ref idle) => idle.into(), PresencePayload::Idle(idle) => idle.into(),
PresencePayload::ECaps2(ref ecaps2) => ecaps2.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<Element>, pub payloads: Vec<Element>,
} }
impl<'a> TryFrom<&'a Element> for Presence { impl TryFrom<Element> for Presence {
type Error = Error; type Error = Error;
fn try_from(root: &'a Element) -> Result<Presence, Error> { fn try_from(root: Element) -> Result<Presence, Error> {
if !root.is("presence", ns::JABBER_CLIENT) { if !root.is("presence", ns::JABBER_CLIENT) {
return Err(Error::ParseError("This is not a presence element.")); return Err(Error::ParseError("This is not a presence element."));
} }
@ -232,7 +232,7 @@ impl<'a> TryFrom<&'a Element> for Presence {
} }
} }
impl<'a> Into<Element> for &'a Presence { impl Into<Element> for Presence {
fn into(self) -> Element { fn into(self) -> Element {
let mut stanza = Element::builder("presence") let mut stanza = Element::builder("presence")
.ns(ns::JABBER_CLIENT) .ns(ns::JABBER_CLIENT)
@ -267,7 +267,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<presence xmlns='jabber:client'/>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'/>".parse().unwrap();
let presence = Presence::try_from(&elem).unwrap(); let presence = Presence::try_from(elem).unwrap();
assert_eq!(presence.from, None); assert_eq!(presence.from, None);
assert_eq!(presence.to, None); assert_eq!(presence.to, None);
assert_eq!(presence.id, None); assert_eq!(presence.id, None);
@ -288,14 +288,14 @@ mod tests {
priority: 0i8, priority: 0i8,
payloads: vec!(), payloads: vec!(),
}; };
let elem2 = (&presence).into(); let elem2 = presence.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
#[test] #[test]
fn test_show() { fn test_show() {
let elem: Element = "<presence xmlns='jabber:client'><show>chat</show></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><show>chat</show></presence>".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.payloads.len(), 0);
assert_eq!(presence.show, Some(Show::Chat)); assert_eq!(presence.show, Some(Show::Chat));
} }
@ -304,7 +304,7 @@ mod tests {
fn test_missing_show_value() { fn test_missing_show_value() {
// "online" used to be a pretty common mistake. // "online" used to be a pretty common mistake.
let elem: Element = "<presence xmlns='jabber:client'><show/></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><show/></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -316,7 +316,7 @@ mod tests {
fn test_invalid_show() { fn test_invalid_show() {
// "online" used to be a pretty common mistake. // "online" used to be a pretty common mistake.
let elem: Element = "<presence xmlns='jabber:client'><show>online</show></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><show>online</show></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -327,7 +327,7 @@ mod tests {
#[test] #[test]
fn test_empty_status() { fn test_empty_status() {
let elem: Element = "<presence xmlns='jabber:client'><status/></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status/></presence>".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.payloads.len(), 0);
assert_eq!(presence.statuses.len(), 1); assert_eq!(presence.statuses.len(), 1);
assert_eq!(presence.statuses[""], ""); assert_eq!(presence.statuses[""], "");
@ -336,7 +336,7 @@ mod tests {
#[test] #[test]
fn test_status() { fn test_status() {
let elem: Element = "<presence xmlns='jabber:client'><status>Here!</status></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status>Here!</status></presence>".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.payloads.len(), 0);
assert_eq!(presence.statuses.len(), 1); assert_eq!(presence.statuses.len(), 1);
assert_eq!(presence.statuses[""], "Here!"); assert_eq!(presence.statuses[""], "Here!");
@ -345,7 +345,7 @@ mod tests {
#[test] #[test]
fn test_multiple_statuses() { fn test_multiple_statuses() {
let elem: Element = "<presence xmlns='jabber:client'><status>Here!</status><status xml:lang='fr'>Là!</status></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status>Here!</status><status xml:lang='fr'>Là!</status></presence>".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.payloads.len(), 0);
assert_eq!(presence.statuses.len(), 2); assert_eq!(presence.statuses.len(), 2);
assert_eq!(presence.statuses[""], "Here!"); assert_eq!(presence.statuses[""], "Here!");
@ -355,7 +355,7 @@ mod tests {
#[test] #[test]
fn test_invalid_multiple_statuses() { fn test_invalid_multiple_statuses() {
let elem: Element = "<presence xmlns='jabber:client'><status xml:lang='fr'>Here!</status><status xml:lang='fr'>Là!</status></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status xml:lang='fr'>Here!</status><status xml:lang='fr'>Là!</status></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -366,7 +366,7 @@ mod tests {
#[test] #[test]
fn test_priority() { fn test_priority() {
let elem: Element = "<presence xmlns='jabber:client'><priority>-1</priority></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><priority>-1</priority></presence>".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.payloads.len(), 0);
assert_eq!(presence.priority, -1i8); assert_eq!(presence.priority, -1i8);
} }
@ -374,7 +374,7 @@ mod tests {
#[test] #[test]
fn test_invalid_priority() { fn test_invalid_priority() {
let elem: Element = "<presence xmlns='jabber:client'><priority>128</priority></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><priority>128</priority></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
match error { match error {
Error::ParseIntError(_) => (), Error::ParseIntError(_) => (),
_ => panic!(), _ => panic!(),
@ -384,7 +384,7 @@ mod tests {
#[test] #[test]
fn test_unknown_child() { fn test_unknown_child() {
let elem: Element = "<presence xmlns='jabber:client'><test xmlns='invalid'/></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><test xmlns='invalid'/></presence>".parse().unwrap();
let presence = Presence::try_from(&elem).unwrap(); let presence = Presence::try_from(elem).unwrap();
let payload = &presence.payloads[0]; let payload = &presence.payloads[0];
assert!(payload.is("test", "invalid")); assert!(payload.is("test", "invalid"));
} }
@ -392,7 +392,7 @@ mod tests {
#[test] #[test]
fn test_invalid_status_child() { fn test_invalid_status_child() {
let elem: Element = "<presence xmlns='jabber:client'><status><coucou/></status></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status><coucou/></status></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -403,7 +403,7 @@ mod tests {
#[test] #[test]
fn test_invalid_attribute() { fn test_invalid_attribute() {
let elem: Element = "<presence xmlns='jabber:client'><status coucou=''/></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status coucou=''/></presence>".parse().unwrap();
let error = Presence::try_from(&elem).unwrap_err(); let error = Presence::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -426,7 +426,7 @@ mod tests {
priority: 0i8, priority: 0i8,
payloads: vec!(), payloads: vec!(),
}; };
let elem: Element = (&presence).into(); let elem: Element = presence.into();
assert!(elem.is("presence", ns::JABBER_CLIENT)); assert!(elem.is("presence", ns::JABBER_CLIENT));
assert!(elem.children().collect::<Vec<_>>()[0].is("status", ns::JABBER_CLIENT)); assert!(elem.children().collect::<Vec<_>>()[0].is("status", ns::JABBER_CLIENT));
} }

26
src/receipts.rs
View file

@ -18,10 +18,10 @@ pub enum Receipt {
Received(String), Received(String),
} }
impl<'a> TryFrom<&'a Element> for Receipt { impl TryFrom<Element> for Receipt {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Receipt, Error> { fn try_from(elem: Element) -> Result<Receipt, Error> {
for _ in elem.children() { for _ in elem.children() {
return Err(Error::ParseError("Unknown child in receipt element.")); return Err(Error::ParseError("Unknown child in receipt element."));
} }
@ -36,16 +36,16 @@ impl<'a> TryFrom<&'a Element> for Receipt {
} }
} }
impl<'a> Into<Element> for &'a Receipt { impl Into<Element> for Receipt {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
Receipt::Request => Element::builder("request") Receipt::Request => Element::builder("request")
.ns(ns::RECEIPTS) .ns(ns::RECEIPTS)
.build(), .build(),
Receipt::Received(ref id) => Element::builder("received") Receipt::Received(id) => Element::builder("received")
.ns(ns::RECEIPTS) .ns(ns::RECEIPTS)
.attr("id", id.clone()) .attr("id", id)
.build(), .build(),
} }
} }
} }
@ -57,23 +57,23 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<request xmlns='urn:xmpp:receipts'/>".parse().unwrap(); let elem: Element = "<request xmlns='urn:xmpp:receipts'/>".parse().unwrap();
Receipt::try_from(&elem).unwrap(); Receipt::try_from(elem).unwrap();
let elem: Element = "<received xmlns='urn:xmpp:receipts'/>".parse().unwrap(); let elem: Element = "<received xmlns='urn:xmpp:receipts'/>".parse().unwrap();
Receipt::try_from(&elem).unwrap(); Receipt::try_from(elem).unwrap();
let elem: Element = "<received xmlns='urn:xmpp:receipts' id='coucou'/>".parse().unwrap(); let elem: Element = "<received xmlns='urn:xmpp:receipts' id='coucou'/>".parse().unwrap();
Receipt::try_from(&elem).unwrap(); Receipt::try_from(elem).unwrap();
} }
#[test] #[test]
fn test_serialise() { fn test_serialise() {
let receipt = Receipt::Request; let receipt = Receipt::Request;
let elem: Element = (&receipt).into(); let elem: Element = receipt.into();
assert!(elem.is("request", ns::RECEIPTS)); assert!(elem.is("request", ns::RECEIPTS));
let receipt = Receipt::Received("coucou".to_owned()); let receipt = Receipt::Received("coucou".to_owned());
let elem: Element = (&receipt).into(); let elem: Element = receipt.into();
assert!(elem.is("received", ns::RECEIPTS)); assert!(elem.is("received", ns::RECEIPTS));
assert_eq!(elem.attr("id"), Some("coucou")); assert_eq!(elem.attr("id"), Some("coucou"));
} }

21
src/rsm.rs
View file

@ -24,10 +24,10 @@ pub struct Set {
pub max: Option<usize>, pub max: Option<usize>,
} }
impl<'a> TryFrom<&'a Element> for Set { impl TryFrom<Element> for Set {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<Set, Error> { fn try_from(elem: Element) -> Result<Set, Error> {
if !elem.is("set", ns::RSM) { if !elem.is("set", ns::RSM) {
return Err(Error::ParseError("This is not a RSM element.")); return Err(Error::ParseError("This is not a RSM element."));
} }
@ -86,7 +86,7 @@ impl<'a> TryFrom<&'a Element> for Set {
} }
} }
impl<'a> Into<Element> for &'a Set { impl Into<Element> for Set {
fn into(self) -> Element { fn into(self) -> Element {
let mut elem = Element::builder("set") let mut elem = Element::builder("set")
.ns(ns::RSM) .ns(ns::RSM)
@ -126,7 +126,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>".parse().unwrap(); let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'/>".parse().unwrap();
let set = Set::try_from(&elem).unwrap(); let set = Set::try_from(elem).unwrap();
assert_eq!(set.after, None); assert_eq!(set.after, None);
assert_eq!(set.before, None); assert_eq!(set.before, None);
assert_eq!(set.count, None); assert_eq!(set.count, None);
@ -142,7 +142,7 @@ mod tests {
#[test] #[test]
fn test_unknown() { fn test_unknown() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap(); let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0'/>".parse().unwrap();
let error = Set::try_from(&elem).unwrap_err(); let error = Set::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -153,7 +153,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><coucou/></set>".parse().unwrap(); let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><coucou/></set>".parse().unwrap();
let error = Set::try_from(&elem).unwrap_err(); let error = Set::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -174,14 +174,15 @@ mod tests {
last: None, last: None,
max: None, max: None,
}; };
let elem2 = (&rsm).into(); let elem2 = rsm.into();
assert_eq!(elem, elem2); assert_eq!(elem, elem2);
} }
#[test] #[test]
fn test_first_index() { fn test_first_index() {
let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><first index='4'>coucou</first></set>".parse().unwrap(); let elem: Element = "<set xmlns='http://jabber.org/protocol/rsm'><first index='4'>coucou</first></set>".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, Some(String::from("coucou")));
assert_eq!(set.first_index, Some(4)); assert_eq!(set.first_index, Some(4));
@ -195,7 +196,7 @@ mod tests {
last: None, last: None,
max: None, max: None,
}; };
let elem2 = (&set2).into(); let elem2 = set2.into();
assert_eq!(elem, elem2); assert_eq!(elem1, elem2);
} }
} }

14
src/stanza_error.rs
View file

@ -150,10 +150,10 @@ pub struct StanzaError {
pub other: Option<Element>, pub other: Option<Element>,
} }
impl<'a> TryFrom<&'a Element> for StanzaError { impl TryFrom<Element> for StanzaError {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<StanzaError, Error> { fn try_from(elem: Element) -> Result<StanzaError, Error> {
if !elem.is("error", ns::JABBER_CLIENT) { if !elem.is("error", ns::JABBER_CLIENT) {
return Err(Error::ParseError("This is not an error element.")); return Err(Error::ParseError("This is not an error element."));
} }
@ -205,7 +205,7 @@ impl<'a> TryFrom<&'a Element> for StanzaError {
} }
} }
impl<'a> Into<Element> for &'a StanzaError { impl Into<Element> for StanzaError {
fn into(self) -> Element { fn into(self) -> Element {
let mut root = Element::builder("error") let mut root = Element::builder("error")
.ns(ns::JABBER_CLIENT) .ns(ns::JABBER_CLIENT)
@ -240,7 +240,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<error xmlns='jabber:client' type='cancel'><undefined-condition xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error>".parse().unwrap(); let elem: Element = "<error xmlns='jabber:client' type='cancel'><undefined-condition xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error>".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.type_, ErrorType::Cancel);
assert_eq!(error.defined_condition, DefinedCondition::UndefinedCondition); assert_eq!(error.defined_condition, DefinedCondition::UndefinedCondition);
} }
@ -248,7 +248,7 @@ mod tests {
#[test] #[test]
fn test_invalid_type() { fn test_invalid_type() {
let elem: Element = "<error xmlns='jabber:client'/>".parse().unwrap(); let elem: Element = "<error xmlns='jabber:client'/>".parse().unwrap();
let error = StanzaError::try_from(&elem).unwrap_err(); let error = StanzaError::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -256,7 +256,7 @@ mod tests {
assert_eq!(message, "Required attribute 'type' missing."); assert_eq!(message, "Required attribute 'type' missing.");
let elem: Element = "<error xmlns='jabber:client' type='coucou'/>".parse().unwrap(); let elem: Element = "<error xmlns='jabber:client' type='coucou'/>".parse().unwrap();
let error = StanzaError::try_from(&elem).unwrap_err(); let error = StanzaError::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -267,7 +267,7 @@ mod tests {
#[test] #[test]
fn test_invalid_condition() { fn test_invalid_condition() {
let elem: Element = "<error xmlns='jabber:client' type='cancel'/>".parse().unwrap(); let elem: Element = "<error xmlns='jabber:client' type='cancel'/>".parse().unwrap();
let error = StanzaError::try_from(&elem).unwrap_err(); let error = StanzaError::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),

30
src/stanza_id.rs
View file

@ -24,10 +24,10 @@ pub enum StanzaId {
}, },
} }
impl<'a> TryFrom<&'a Element> for StanzaId { impl TryFrom<Element> for StanzaId {
type Error = Error; type Error = Error;
fn try_from(elem: &'a Element) -> Result<StanzaId, Error> { fn try_from(elem: Element) -> Result<StanzaId, Error> {
let is_stanza_id = elem.is("stanza-id", ns::SID); let is_stanza_id = elem.is("stanza-id", ns::SID);
if !is_stanza_id && !elem.is("origin-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.")); 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<Element> for &'a StanzaId { impl Into<Element> for StanzaId {
fn into(self) -> Element { fn into(self) -> Element {
match *self { match self {
StanzaId::StanzaId { ref id, ref by } => { StanzaId::StanzaId { id, by } => {
Element::builder("stanza-id") Element::builder("stanza-id")
.ns(ns::SID) .ns(ns::SID)
.attr("id", id.clone()) .attr("id", id)
.attr("by", String::from(by.clone())) .attr("by", String::from(by))
.build() .build()
}, },
StanzaId::OriginId { ref id } => { StanzaId::OriginId { id } => {
Element::builder("origin-id") Element::builder("origin-id")
.ns(ns::SID) .ns(ns::SID)
.attr("id", id.clone()) .attr("id", id)
.build() .build()
}, },
} }
@ -73,7 +73,7 @@ mod tests {
#[test] #[test]
fn test_simple() { fn test_simple() {
let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou' by='coucou@coucou'/>".parse().unwrap(); let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou' by='coucou@coucou'/>".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 { if let StanzaId::StanzaId { id, by } = stanza_id {
assert_eq!(id, String::from("coucou")); assert_eq!(id, String::from("coucou"));
assert_eq!(by, Jid::from_str("coucou@coucou").unwrap()); assert_eq!(by, Jid::from_str("coucou@coucou").unwrap());
@ -82,7 +82,7 @@ mod tests {
} }
let elem: Element = "<origin-id xmlns='urn:xmpp:sid:0' id='coucou'/>".parse().unwrap(); let elem: Element = "<origin-id xmlns='urn:xmpp:sid:0' id='coucou'/>".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 { if let StanzaId::OriginId { id } = stanza_id {
assert_eq!(id, String::from("coucou")); assert_eq!(id, String::from("coucou"));
} else { } else {
@ -93,7 +93,7 @@ mod tests {
#[test] #[test]
fn test_invalid_child() { fn test_invalid_child() {
let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0'><coucou/></stanza-id>".parse().unwrap(); let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0'><coucou/></stanza-id>".parse().unwrap();
let error = StanzaId::try_from(&elem).unwrap_err(); let error = StanzaId::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -104,7 +104,7 @@ mod tests {
#[test] #[test]
fn test_invalid_id() { fn test_invalid_id() {
let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0'/>".parse().unwrap(); let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0'/>".parse().unwrap();
let error = StanzaId::try_from(&elem).unwrap_err(); let error = StanzaId::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -115,7 +115,7 @@ mod tests {
#[test] #[test]
fn test_invalid_by() { fn test_invalid_by() {
let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou'/>".parse().unwrap(); let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou'/>".parse().unwrap();
let error = StanzaId::try_from(&elem).unwrap_err(); let error = StanzaId::try_from(elem).unwrap_err();
let message = match error { let message = match error {
Error::ParseError(string) => string, Error::ParseError(string) => string,
_ => panic!(), _ => panic!(),
@ -127,7 +127,7 @@ mod tests {
fn test_serialise() { fn test_serialise() {
let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou' by='coucou@coucou'/>".parse().unwrap(); let elem: Element = "<stanza-id xmlns='urn:xmpp:sid:0' id='coucou' by='coucou@coucou'/>".parse().unwrap();
let stanza_id = StanzaId::StanzaId { id: String::from("coucou"), by: Jid::from_str("coucou@coucou").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); assert_eq!(elem, elem2);
} }
} }