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)]
pub struct Attention;
impl<'a> TryFrom<&'a Element> for Attention {
impl TryFrom<Element> for Attention {
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) {
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 {
Element::builder("attention")
.ns(ns::ATTENTION)
@ -47,13 +47,13 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap();
Attention::try_from(&elem).unwrap();
Attention::try_from(elem).unwrap();
}
#[test]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -65,9 +65,7 @@ mod tests {
fn test_serialise() {
let elem: Element = "<attention xmlns='urn:xmpp:attention:0'/>".parse().unwrap();
let attention = Attention;
let elem2: Element = (&attention).into();
let elem3: Element = (&attention).into();
let elem2: Element = attention.into();
assert_eq!(elem, elem2);
assert_eq!(elem2, elem3);
}
}

18
src/chatstates.rs
View file

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

14
src/data_forms.rs
View file

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

16
src/delay.rs
View file

@ -20,10 +20,10 @@ pub struct Delay {
pub data: Option<String>,
}
impl<'a> TryFrom<&'a Element> for Delay {
impl TryFrom<Element> for Delay {
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) {
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 {
Element::builder("delay")
.ns(ns::DELAY)
@ -63,7 +63,7 @@ mod tests {
#[test]
fn test_simple() {
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.stamp, "2002-09-10T23:08:25Z");
assert_eq!(delay.data, None);
@ -72,7 +72,7 @@ mod tests {
#[test]
fn test_unknown() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -83,7 +83,7 @@ mod tests {
#[test]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -99,7 +99,7 @@ mod tests {
stamp: "2002-09-10T23:08:25Z".to_owned(),
data: None,
};
let elem2 = (&delay).into();
let elem2 = delay.into();
assert_eq!(elem, elem2);
}
@ -111,7 +111,7 @@ mod tests {
stamp: "2002-09-10T23:08:25Z".to_owned(),
data: Some(String::from("Reason")),
};
let elem2 = (&delay).into();
let elem2 = delay.into();
assert_eq!(elem, elem2);
}
}

34
src/disco.rs
View file

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

20
src/ecaps2.rs
View file

@ -25,17 +25,17 @@ pub struct ECaps2 {
hashes: Vec<Hash>,
}
impl<'a> TryFrom<&'a Element> for ECaps2 {
impl TryFrom<Element> for ECaps2 {
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) {
return Err(Error::ParseError("This is not an ecaps2 element."));
}
let mut hashes = vec!();
for child in elem.children() {
if child.is("hash", ns::HASHES) {
let hash = Hash::try_from(child)?;
let hash = Hash::try_from(child.clone())?;
hashes.push(hash);
} else {
return Err(Error::ParseError("Unknown child in ecaps2 element."));
@ -47,12 +47,12 @@ impl<'a> TryFrom<&'a Element> for ECaps2 {
}
}
impl<'a> Into<Element> for &'a ECaps2 {
impl Into<Element> for ECaps2 {
fn into(self) -> Element {
Element::builder("c")
.ns(ns::ECAPS2)
.append(self.hashes.iter()
.map(|hash| hash.into())
.map(|hash| hash.clone().into())
.collect::<Vec<Element>>())
.build()
}
@ -175,7 +175,7 @@ mod tests {
#[test]
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 ecaps2 = ECaps2::try_from(&elem).unwrap();
let ecaps2 = ECaps2::try_from(elem).unwrap();
assert_eq!(ecaps2.hashes.len(), 2);
assert_eq!(ecaps2.hashes[0].algo, Algo::Sha_256);
assert_eq!(ecaps2.hashes[0].hash, "K1Njy3HZBThlo4moOD5gBGhn0U0oK7/CbfLlIUDi6o4=");
@ -186,7 +186,7 @@ mod tests {
#[test]
fn test_invalid_child() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -197,7 +197,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<query xmlns='http://jabber.org/protocol/disco#info'><identity category='client' type='pc'/><feature var='http://jabber.org/protocol/disco#info'/></query>".parse().unwrap();
let disco = Disco::try_from(&elem).unwrap();
let disco = Disco::try_from(elem).unwrap();
let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 54);
}
@ -260,7 +260,7 @@ mod tests {
105, 109, 101, 31, 28, 99, 108, 105, 101, 110, 116, 31, 109, 111,
98, 105, 108, 101, 31, 31, 66, 111, 109, 98, 117, 115, 77, 111,
100, 31, 30, 28, 28];
let disco = Disco::try_from(&elem).unwrap();
let disco = Disco::try_from(elem).unwrap();
let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 0x1d9);
assert_eq!(ecaps2, expected);
@ -432,7 +432,7 @@ mod tests {
111, 110, 31, 48, 46, 49, 49, 46, 49, 45, 115, 118, 110, 45, 50,
48, 49, 49, 49, 50, 49, 54, 45, 109, 111, 100, 32, 40, 84, 99, 108,
47, 84, 107, 32, 56, 46,54, 98, 50, 41, 31, 30, 29, 28];
let disco = Disco::try_from(&elem).unwrap();
let disco = Disco::try_from(elem).unwrap();
let ecaps2 = ecaps2::compute_disco(&disco);
assert_eq!(ecaps2.len(), 0x543);
assert_eq!(ecaps2, expected);

16
src/eme.rs
View file

@ -18,10 +18,10 @@ pub struct ExplicitMessageEncryption {
pub name: Option<String>,
}
impl<'a> TryFrom<&'a Element> for ExplicitMessageEncryption {
impl TryFrom<Element> for ExplicitMessageEncryption {
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) {
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 {
Element::builder("encryption")
.ns(ns::EME)
@ -54,12 +54,12 @@ mod tests {
#[test]
fn test_simple() {
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.name, None);
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.name, Some(String::from("SuperMechanism")));
}
@ -67,7 +67,7 @@ mod tests {
#[test]
fn test_unknown() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -78,7 +78,7 @@ mod tests {
#[test]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -90,7 +90,7 @@ mod tests {
fn test_serialise() {
let elem: Element = "<encryption xmlns='urn:xmpp:eme:0' namespace='coucou'/>".parse().unwrap();
let eme = ExplicitMessageEncryption { namespace: String::from("coucou"), name: None };
let elem2 = (&eme).into();
let elem2 = eme.into();
assert_eq!(elem, elem2);
}
}

20
src/forwarding.rs
View file

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

14
src/hashes.rs
View file

@ -66,10 +66,10 @@ pub struct Hash {
pub hash: String,
}
impl<'a> TryFrom<&'a Element> for Hash {
impl TryFrom<Element> for Hash {
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) {
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 {
Element::builder("hash")
.ns(ns::HASHES)
.attr("algo", self.algo.clone())
.attr("algo", self.algo)
.append(self.hash.clone())
.build()
}
@ -105,7 +105,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<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.hash, "2XarmwTlNxDAMkvymloX3S5+VbylNrJt/l5QyPa+YoU=");
}
@ -113,7 +113,7 @@ mod tests {
#[test]
fn test_unknown() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -124,7 +124,7 @@ mod tests {
#[test]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => 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;
fn try_from(elem: &'a Element) -> Result<IBB, Error> {
fn try_from(elem: Element) -> Result<IBB, Error> {
if elem.is("open", ns::IBB) {
for _ in elem.children() {
return Err(Error::ParseError("Unknown child in open element."));
@ -107,29 +107,29 @@ impl<'a> TryFrom<&'a Element> for IBB {
}
}
impl<'a> Into<Element> for &'a IBB {
impl Into<Element> for IBB {
fn into(self) -> Element {
match *self {
IBB::Open { ref block_size, ref sid, ref stanza } => {
match self {
IBB::Open { block_size, sid, stanza } => {
Element::builder("open")
.ns(ns::IBB)
.attr("block-size", format!("{}", block_size))
.attr("sid", sid.to_owned())
.attr("stanza", stanza.to_owned())
.attr("sid", sid)
.attr("stanza", stanza)
.build()
},
IBB::Data { ref seq, ref sid, ref data } => {
IBB::Data { seq, sid, data } => {
Element::builder("data")
.ns(ns::IBB)
.attr("seq", format!("{}", seq))
.attr("sid", sid.to_owned())
.attr("sid", sid)
.append(base64::encode(&data))
.build()
},
IBB::Close { ref sid } => {
IBB::Close { sid } => {
Element::builder("close")
.ns(ns::IBB)
.attr("sid", sid.to_owned())
.attr("sid", sid)
.build()
},
}
@ -144,7 +144,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<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 {
IBB::Open { block_size, sid, stanza } => {
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 data = IBB::try_from(&elem).unwrap();
let data = IBB::try_from(elem).unwrap();
match data {
IBB::Data { seq, sid, data } => {
assert_eq!(seq, 0);
@ -166,7 +166,7 @@ mod tests {
}
let elem: Element = "<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 {
IBB::Close { sid } => {
assert_eq!(sid, "coucou");
@ -178,7 +178,7 @@ mod tests {
#[test]
fn test_invalid() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -186,7 +186,7 @@ mod tests {
assert_eq!(message, "Required attribute 'block-size' missing.");
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 {
Error::ParseIntError(error) => error,
_ => panic!(),
@ -194,7 +194,7 @@ mod tests {
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 error = IBB::try_from(&elem).unwrap_err();
let error = IBB::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(error) => error,
_ => panic!(),
@ -205,7 +205,7 @@ mod tests {
#[test]
fn test_invalid_stanza() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),

14
src/idle.rs
View file

@ -19,10 +19,10 @@ pub struct Idle {
pub since: Date,
}
impl<'a> TryFrom<&'a Element> for Idle {
impl TryFrom<Element> for Idle {
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) {
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 {
Element::builder("idle")
.ns(ns::IDLE)
@ -50,13 +50,13 @@ mod tests {
#[test]
fn test_simple() {
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]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -67,7 +67,7 @@ mod tests {
#[test]
fn test_invalid_id() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -79,7 +79,7 @@ mod tests {
fn test_serialise() {
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 elem2 = (&idle).into();
let elem2 = idle.into();
assert_eq!(elem, elem2);
}
}

56
src/iq.rs
View file

@ -37,13 +37,13 @@ pub enum IqPayload {
Unknown(Element),
}
impl<'a> TryFrom<&'a Element> for IqPayload {
impl TryFrom<Element> for IqPayload {
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()) {
// XEP-0030
("query", ns::DISCO_INFO) => IqPayload::Disco(Disco::try_from(elem)?),
("query", ns::DISCO_INFO) => IqPayload::Disco(Disco::try_from(elem.clone())?),
// XEP-0047
("open", ns::IBB)
@ -93,10 +93,10 @@ pub struct Iq {
pub payload: IqType,
}
impl<'a> TryFrom<&'a Element> for Iq {
impl TryFrom<Element> for Iq {
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) {
return Err(Error::ParseError("This is not an iq element."));
}
@ -116,7 +116,7 @@ impl<'a> TryFrom<&'a Element> for Iq {
if error_payload.is_some() {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
error_payload = Some(StanzaError::try_from(elem)?);
error_payload = Some(StanzaError::try_from(elem.clone())?);
} else if root.children().collect::<Vec<_>>().len() != 2 {
return Err(Error::ParseError("Wrong number of children in iq element."));
}
@ -162,23 +162,23 @@ impl<'a> TryFrom<&'a Element> for Iq {
}
}
impl<'a> Into<Element> for &'a IqPayload {
impl Into<Element> for IqPayload {
fn into(self) -> Element {
match *self {
IqPayload::Disco(ref disco) => disco.into(),
IqPayload::IBB(ref ibb) => ibb.into(),
IqPayload::Jingle(ref jingle) => jingle.into(),
IqPayload::Ping(ref ping) => ping.into(),
IqPayload::MamQuery(ref query) => query.into(),
IqPayload::MamFin(ref fin) => fin.into(),
IqPayload::MamPrefs(ref prefs) => prefs.into(),
match self {
IqPayload::Disco(disco) => disco.into(),
IqPayload::IBB(ibb) => ibb.into(),
IqPayload::Jingle(jingle) => jingle.into(),
IqPayload::Ping(ping) => ping.into(),
IqPayload::MamQuery(query) => query.into(),
IqPayload::MamFin(fin) => fin.into(),
IqPayload::MamPrefs(prefs) => prefs.into(),
IqPayload::Unknown(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 {
let mut stanza = Element::builder("iq")
.ns(ns::JABBER_CLIENT)
@ -191,7 +191,7 @@ impl<'a> Into<Element> for &'a Iq {
IqType::Get(elem)
| IqType::Set(elem)
| IqType::Result(Some(elem)) => elem,
IqType::Error(error) => (&error).into(),
IqType::Error(error) => error.into(),
IqType::Result(None) => return stanza,
};
stanza.append_child(elem);
@ -207,7 +207,7 @@ mod tests {
#[test]
fn test_require_type() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -220,7 +220,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='get'>
<foo/>
</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();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
@ -236,7 +236,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='set'>
<vCard xmlns='vcard-temp'/>
</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();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
@ -250,7 +250,7 @@ mod tests {
#[test]
fn test_result_empty() {
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.to, None);
assert_eq!(iq.id, None);
@ -265,7 +265,7 @@ mod tests {
let elem: Element = "<iq xmlns='jabber:client' type='result'>
<query xmlns='http://jabber.org/protocol/disco#items'/>
</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();
assert_eq!(iq.from, None);
assert_eq!(iq.to, None);
@ -284,7 +284,7 @@ mod tests {
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</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.to, None);
assert_eq!(iq.id, None);
@ -303,7 +303,7 @@ mod tests {
#[test]
fn test_children_invalid() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -320,16 +320,16 @@ mod tests {
id: None,
payload: IqType::Result(None),
};
let elem2 = (&iq2).into();
let elem2 = iq2.into();
assert_eq!(elem, elem2);
}
#[test]
fn test_disco() {
let elem: Element = "<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 {
IqType::Get(ref payload) => IqPayload::try_from(payload).unwrap(),
IqType::Get(payload) => IqPayload::try_from(payload).unwrap(),
_ => panic!(),
};
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 {
Element::builder(match *self {
Element::builder(match self {
Reason::AlternativeSession => "alternative-session",
Reason::Busy => "busy",
Reason::Cancel => "cancel",
@ -245,10 +245,10 @@ pub struct Jingle {
pub other: Vec<Element>,
}
impl<'a> TryFrom<&'a Element> for Jingle {
impl TryFrom<Element> for Jingle {
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) {
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 {
let mut root = Element::builder("content")
.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 {
let mut root = Element::builder("jingle")
.ns(ns::JINGLE)
@ -384,15 +384,15 @@ impl<'a> Into<Element> for &'a Jingle {
.attr("responder", self.responder.clone())
.attr("sid", self.sid.clone())
.build();
for content in self.contents.clone() {
let content_elem = (&content).into();
for content in self.contents {
let content_elem = content.into();
root.append_child(content_elem);
}
if let Some(ref reason) = self.reason {
let reason2: Element = (&reason.reason).into();
if let Some(reason) = self.reason {
let reason2: Element = reason.reason.into();
let reason_elem = Element::builder("reason")
.append(reason2)
.append(reason.text.clone())
.append(reason.text)
.build();
root.append_child(reason_elem);
}
@ -400,12 +400,6 @@ impl<'a> Into<Element> for &'a Jingle {
}
}
impl Into<Element> for Jingle {
fn into(self) -> Element {
(&self).into()
}
}
#[cfg(test)]
mod tests {
use super::*;
@ -413,7 +407,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<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.sid, "coucou");
}
@ -421,7 +415,7 @@ mod tests {
#[test]
fn test_invalid_jingle() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -429,7 +423,7 @@ mod tests {
assert_eq!(message, "Jingle must have an 'action' attribute.");
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -437,7 +431,7 @@ mod tests {
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 error = Jingle::try_from(&elem).unwrap_err();
let error = Jingle::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -448,25 +442,25 @@ mod tests {
#[test]
fn test_content() {
let elem: Element = "<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].name, "coucou");
assert_eq!(jingle.contents[0].senders, Senders::Both);
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 jingle = Jingle::try_from(&elem).unwrap();
let jingle = Jingle::try_from(elem).unwrap();
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 jingle = Jingle::try_from(&elem).unwrap();
let jingle = Jingle::try_from(elem).unwrap();
assert_eq!(jingle.contents[0].disposition, "early-session");
}
#[test]
fn test_invalid_content() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -474,7 +468,7 @@ mod tests {
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 error = Jingle::try_from(&elem).unwrap_err();
let error = Jingle::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -482,7 +476,7 @@ mod tests {
assert_eq!(message, "Content must have a 'name' attribute.");
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -490,7 +484,7 @@ mod tests {
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 error = Jingle::try_from(&elem).unwrap_err();
let error = Jingle::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -498,7 +492,7 @@ mod tests {
assert_eq!(message, "Unknown senders.");
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -509,13 +503,13 @@ mod tests {
#[test]
fn test_reason() {
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();
assert_eq!(reason.reason, Reason::Success);
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 jingle = Jingle::try_from(&elem).unwrap();
let jingle = Jingle::try_from(elem).unwrap();
let reason = jingle.reason.unwrap();
assert_eq!(reason.reason, Reason::Success);
assert_eq!(reason.text, Some(String::from("coucou")));
@ -524,7 +518,7 @@ mod tests {
#[test]
fn test_invalid_reason() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -532,7 +526,7 @@ mod tests {
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 error = Jingle::try_from(&elem).unwrap_err();
let error = Jingle::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -540,7 +534,7 @@ mod tests {
assert_eq!(message, "Unknown reason.");
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -548,7 +542,7 @@ mod tests {
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 error = Jingle::try_from(&elem).unwrap_err();
let error = Jingle::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -556,7 +550,7 @@ mod tests {
assert_eq!(message, "Jingle must not have more than one reason.");
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),

46
src/jingle_ft.rs
View file

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

18
src/jingle_ibb.rs
View file

@ -21,10 +21,10 @@ pub struct Transport {
pub stanza: Stanza,
}
impl<'a> TryFrom<&'a Element> for Transport {
impl TryFrom<Element> for Transport {
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) {
for _ in elem.children() {
return Err(Error::ParseError("Unknown child in JingleIBB element."));
@ -43,7 +43,7 @@ impl<'a> TryFrom<&'a Element> for Transport {
}
}
impl<'a> Into<Element> for &'a Transport {
impl Into<Element> for Transport {
fn into(self) -> Element {
Element::builder("transport")
.ns(ns::JINGLE_IBB)
@ -62,7 +62,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<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.sid, "coucou");
assert_eq!(transport.stanza, Stanza::Iq);
@ -71,7 +71,7 @@ mod tests {
#[test]
fn test_invalid() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -79,7 +79,7 @@ mod tests {
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 error = Transport::try_from(&elem).unwrap_err();
let error = Transport::try_from(elem).unwrap_err();
let message = match error {
Error::ParseIntError(error) => error,
_ => panic!(),
@ -87,7 +87,7 @@ mod tests {
assert_eq!(message.description(), "number too large to fit in target type");
let elem: Element = "<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 {
Error::ParseIntError(error) => error,
_ => panic!(),
@ -95,7 +95,7 @@ mod tests {
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 error = Transport::try_from(&elem).unwrap_err();
let error = Transport::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -106,7 +106,7 @@ mod tests {
#[test]
fn test_invalid_stanza() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),

22
src/jingle_s5b.rs
View file

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

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

28
src/media_element.rs
View file

@ -25,10 +25,10 @@ pub struct MediaElement {
pub uris: Vec<URI>,
}
impl<'a> TryFrom<&'a Element> for MediaElement {
impl TryFrom<Element> for MediaElement {
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) {
return Err(Error::ParseError("This is not a media element."));
}
@ -60,7 +60,7 @@ mod tests {
#[test]
fn test_simple() {
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.height.is_none());
assert!(media.uris.is_empty());
@ -69,7 +69,7 @@ mod tests {
#[test]
fn test_width_height() {
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.height.unwrap(), 32);
}
@ -77,7 +77,7 @@ mod tests {
#[test]
fn test_uri() {
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[0].type_, "text/html");
assert_eq!(media.uris[0].uri, "https://example.org/");
@ -86,26 +86,26 @@ mod tests {
#[test]
fn test_invalid_width_height() {
let elem: Element = "<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());
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());
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());
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());
}
#[test]
fn test_unknown_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -116,7 +116,7 @@ mod tests {
#[test]
fn test_bad_uri() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -124,7 +124,7 @@ mod tests {
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 error = MediaElement::try_from(&elem).unwrap_err();
let error = MediaElement::try_from(elem).unwrap_err();
let message = match error {
Error::ParseError(string) => string,
_ => panic!(),
@ -146,7 +146,7 @@ mod tests {
http://victim.example.com/challenges/speech.mp3?F3A6292C
</uri>
</media>"#.parse().unwrap();
let media = MediaElement::try_from(&elem).unwrap();
let media = MediaElement::try_from(elem).unwrap();
assert!(media.width.is_none());
assert!(media.height.is_none());
assert_eq!(media.uris.len(), 3);
@ -177,7 +177,7 @@ mod tests {
</field>
[ ... ]
</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[0].var, "ocr");
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),
}
impl<'a> TryFrom<&'a Element> for MessagePayload {
impl TryFrom<Element> for MessagePayload {
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()) {
("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 {
match *self {
MessagePayload::StanzaError(ref stanza_error) => stanza_error.into(),
MessagePayload::Attention(ref attention) => attention.into(),
MessagePayload::ChatState(ref chatstate) => chatstate.into(),
MessagePayload::Receipt(ref receipt) => receipt.into(),
MessagePayload::Delay(ref delay) => delay.into(),
MessagePayload::MessageCorrect(ref replace) => replace.into(),
MessagePayload::ExplicitMessageEncryption(ref eme) => eme.into(),
MessagePayload::StanzaId(ref stanza_id) => stanza_id.into(),
MessagePayload::MamResult(ref result) => result.into(),
match self {
MessagePayload::StanzaError(stanza_error) => stanza_error.into(),
MessagePayload::Attention(attention) => attention.into(),
MessagePayload::ChatState(chatstate) => chatstate.into(),
MessagePayload::Receipt(receipt) => receipt.into(),
MessagePayload::Delay(delay) => delay.into(),
MessagePayload::MessageCorrect(replace) => replace.into(),
MessagePayload::ExplicitMessageEncryption(eme) => eme.into(),
MessagePayload::StanzaId(stanza_id) => stanza_id.into(),
MessagePayload::MamResult(result) => result.into(),
MessagePayload::Unknown(ref elem) => elem.clone(),
MessagePayload::Unknown(elem) => elem.clone(),
}
}
}
@ -162,10 +162,10 @@ pub struct Message {
pub payloads: Vec<Element>,
}
impl<'a> TryFrom<&'a Element> for Message {
impl TryFrom<Element> for Message {
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) {
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 {
let mut stanza = Element::builder("message")
.ns(ns::JABBER_CLIENT)
@ -264,7 +264,7 @@ mod tests {
#[test]
fn test_simple() {
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.to, None);
assert_eq!(message.id, None);
@ -285,18 +285,19 @@ mod tests {
thread: None,
payloads: vec!(),
};
let elem2 = (&message).into();
let elem2 = message.into();
assert_eq!(elem, elem2);
}
#[test]
fn test_body() {
let elem: Element = "<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!");
let elem2 = (&message).into();
assert_eq!(elem, elem2);
let elem2 = message.into();
assert_eq!(elem1, elem2);
}
#[test]
@ -314,25 +315,27 @@ mod tests {
thread: None,
payloads: vec!(),
};
let elem2 = (&message).into();
let elem2 = message.into();
assert_eq!(elem, elem2);
}
#[test]
fn test_subject() {
let elem: Element = "<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!");
let elem2 = (&message).into();
assert_eq!(elem, elem2);
let elem2 = message.into();
assert_eq!(elem1, elem2);
}
#[test]
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 message = Message::try_from(&elem).unwrap();
let elem2 = (&message).into();
assert_eq!(elem, elem2);
let elem1 = elem.clone();
let message = Message::try_from(elem).unwrap();
let elem2 = message.into();
assert_eq!(elem1, elem2);
}
}

14
src/message_correct.rs
View file

@ -17,10 +17,10 @@ pub struct Replace {
pub id: String,
}
impl<'a> TryFrom<&'a Element> for Replace {
impl TryFrom<Element> for Replace {
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) {
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 {
Element::builder("replace")
.ns(ns::MESSAGE_CORRECT)
@ -48,13 +48,13 @@ mod tests {
#[test]
fn test_simple() {
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]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -65,7 +65,7 @@ mod tests {
#[test]
fn test_invalid_id() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -77,7 +77,7 @@ mod tests {
fn test_serialise() {
let elem: Element = "<replace xmlns='urn:xmpp:message-correct:0' id='coucou'/>".parse().unwrap();
let replace = Replace { id: String::from("coucou") };
let elem2 = (&replace).into();
let elem2 = replace.into();
assert_eq!(elem, elem2);
}
}

12
src/ping.rs
View file

@ -16,10 +16,10 @@ use ns;
#[derive(Debug, Clone)]
pub struct Ping;
impl<'a> TryFrom<&'a Element> for Ping {
impl TryFrom<Element> for Ping {
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) {
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 {
Element::builder("ping")
.ns(ns::PING)
@ -48,13 +48,13 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<ping xmlns='urn:xmpp:ping'/>".parse().unwrap();
Ping::try_from(&elem).unwrap();
Ping::try_from(elem).unwrap();
}
#[test]
fn test_invalid() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -65,7 +65,7 @@ mod tests {
#[test]
fn test_invalid_attribute() {
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 {
Error::ParseError(string) => string,
_ => panic!(),

56
src/presence.rs
View file

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

26
src/receipts.rs
View file

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

21
src/rsm.rs
View file

@ -24,10 +24,10 @@ pub struct Set {
pub max: Option<usize>,
}
impl<'a> TryFrom<&'a Element> for Set {
impl TryFrom<Element> for Set {
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) {
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 {
let mut elem = Element::builder("set")
.ns(ns::RSM)
@ -126,7 +126,7 @@ mod tests {
#[test]
fn test_simple() {
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.before, None);
assert_eq!(set.count, None);
@ -142,7 +142,7 @@ mod tests {
#[test]
fn test_unknown() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -153,7 +153,7 @@ mod tests {
#[test]
fn test_invalid_child() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -174,14 +174,15 @@ mod tests {
last: None,
max: None,
};
let elem2 = (&rsm).into();
let elem2 = rsm.into();
assert_eq!(elem, elem2);
}
#[test]
fn test_first_index() {
let elem: Element = "<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_index, Some(4));
@ -195,7 +196,7 @@ mod tests {
last: None,
max: None,
};
let elem2 = (&set2).into();
assert_eq!(elem, elem2);
let elem2 = set2.into();
assert_eq!(elem1, elem2);
}
}

14
src/stanza_error.rs
View file

@ -150,10 +150,10 @@ pub struct StanzaError {
pub other: Option<Element>,
}
impl<'a> TryFrom<&'a Element> for StanzaError {
impl TryFrom<Element> for StanzaError {
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) {
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 {
let mut root = Element::builder("error")
.ns(ns::JABBER_CLIENT)
@ -240,7 +240,7 @@ mod tests {
#[test]
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 error = StanzaError::try_from(&elem).unwrap();
let error = StanzaError::try_from(elem).unwrap();
assert_eq!(error.type_, ErrorType::Cancel);
assert_eq!(error.defined_condition, DefinedCondition::UndefinedCondition);
}
@ -248,7 +248,7 @@ mod tests {
#[test]
fn test_invalid_type() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -256,7 +256,7 @@ mod tests {
assert_eq!(message, "Required attribute 'type' missing.");
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -267,7 +267,7 @@ mod tests {
#[test]
fn test_invalid_condition() {
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 {
Error::ParseError(string) => string,
_ => 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;
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);
if !is_stanza_id && !elem.is("origin-id", ns::SID) {
return Err(Error::ParseError("This is not a stanza-id or origin-id element."));
@ -45,20 +45,20 @@ impl<'a> TryFrom<&'a Element> for StanzaId {
}
}
impl<'a> Into<Element> for &'a StanzaId {
impl Into<Element> for StanzaId {
fn into(self) -> Element {
match *self {
StanzaId::StanzaId { ref id, ref by } => {
match self {
StanzaId::StanzaId { id, by } => {
Element::builder("stanza-id")
.ns(ns::SID)
.attr("id", id.clone())
.attr("by", String::from(by.clone()))
.attr("id", id)
.attr("by", String::from(by))
.build()
},
StanzaId::OriginId { ref id } => {
StanzaId::OriginId { id } => {
Element::builder("origin-id")
.ns(ns::SID)
.attr("id", id.clone())
.attr("id", id)
.build()
},
}
@ -73,7 +73,7 @@ mod tests {
#[test]
fn test_simple() {
let elem: Element = "<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 {
assert_eq!(id, String::from("coucou"));
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 stanza_id = StanzaId::try_from(&elem).unwrap();
let stanza_id = StanzaId::try_from(elem).unwrap();
if let StanzaId::OriginId { id } = stanza_id {
assert_eq!(id, String::from("coucou"));
} else {
@ -93,7 +93,7 @@ mod tests {
#[test]
fn test_invalid_child() {
let elem: Element = "<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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -104,7 +104,7 @@ mod tests {
#[test]
fn test_invalid_id() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -115,7 +115,7 @@ mod tests {
#[test]
fn test_invalid_by() {
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 {
Error::ParseError(string) => string,
_ => panic!(),
@ -127,7 +127,7 @@ mod tests {
fn test_serialise() {
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 elem2 = (&stanza_id).into();
let elem2 = stanza_id.into();
assert_eq!(elem, elem2);
}
}