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

presence: Switch to Into/TryFrom.

Browse source
This commit is contained in:
Emmanuel Gil Peyrot 2017-05-06 21:24:17 +01:00
commit 69cfb14c77
1 changed files with 144 additions and 138 deletions
Download patch file Download diff file Expand all files Collapse all files

286
src/presence.rs
View file

@ -128,177 +128,183 @@ pub struct Presence {
pub payloads: Vec<PresencePayloadType>, pub payloads: Vec<PresencePayloadType>,
} }
pub fn parse_presence(root: &Element) -> Result<Presence, Error> { impl<'a> TryFrom<&'a Element> for Presence {
if !root.is("presence", ns::JABBER_CLIENT) { type Error = Error;
return Err(Error::ParseError("This is not a presence element."));
}
let from = root.attr("from")
.and_then(|value| value.parse().ok());
let to = root.attr("to")
.and_then(|value| value.parse().ok());
let id = root.attr("id")
.and_then(|value| value.parse().ok());
let type_ = match root.attr("type") {
Some(type_) => type_.parse()?,
None => Default::default(),
};
let mut show = None;
let mut statuses = BTreeMap::new();
let mut priority = None;
let mut payloads = vec!();
for elem in root.children() {
if elem.is("show", ns::JABBER_CLIENT) {
if show.is_some() {
return Err(Error::ParseError("More than one show element in a presence."));
}
for _ in elem.children() {
return Err(Error::ParseError("Unknown child in show element."));
}
show = Some(match elem.text().as_ref() {
"away" => Show::Away,
"chat" => Show::Chat,
"dnd" => Show::Dnd,
"xa" => Show::Xa,
_ => return Err(Error::ParseError("Invalid value for show.")), fn try_from(root: &'a Element) -> Result<Presence, Error> {
}); if !root.is("presence", ns::JABBER_CLIENT) {
} else if elem.is("status", ns::JABBER_CLIENT) { return Err(Error::ParseError("This is not a presence element."));
for _ in elem.children() { }
return Err(Error::ParseError("Unknown child in status element.")); let from = root.attr("from")
} .and_then(|value| value.parse().ok());
let lang = elem.attr("xml:lang").unwrap_or("").to_owned(); let to = root.attr("to")
if let Some(_) = statuses.insert(lang, elem.text()) { .and_then(|value| value.parse().ok());
return Err(Error::ParseError("Status element present twice for the same xml:lang.")); let id = root.attr("id")
} .and_then(|value| value.parse().ok());
} else if elem.is("priority", ns::JABBER_CLIENT) { let type_ = match root.attr("type") {
if priority.is_some() { Some(type_) => type_.parse()?,
return Err(Error::ParseError("More than one priority element in a presence.")); None => Default::default(),
} };
for _ in elem.children() { let mut show = None;
return Err(Error::ParseError("Unknown child in priority element.")); let mut statuses = BTreeMap::new();
} let mut priority = None;
priority = Some(Priority::from_str(elem.text().as_ref())?); let mut payloads = vec!();
} else { for elem in root.children() {
let payload = if let Ok(stanza_error) = StanzaError::try_from(elem) { if elem.is("show", ns::JABBER_CLIENT) {
Some(PresencePayload::StanzaError(stanza_error)) if show.is_some() {
} else if let Ok(delay) = Delay::try_from(elem) { return Err(Error::ParseError("More than one show element in a presence."));
Some(PresencePayload::Delay(delay)) }
} else if let Ok(ecaps2) = ECaps2::try_from(elem) { for _ in elem.children() {
Some(PresencePayload::ECaps2(ecaps2)) return Err(Error::ParseError("Unknown child in show element."));
}
show = Some(match elem.text().as_ref() {
"away" => Show::Away,
"chat" => Show::Chat,
"dnd" => Show::Dnd,
"xa" => Show::Xa,
_ => return Err(Error::ParseError("Invalid value for show.")),
});
} else if elem.is("status", ns::JABBER_CLIENT) {
for _ in elem.children() {
return Err(Error::ParseError("Unknown child in status element."));
}
let lang = elem.attr("xml:lang").unwrap_or("").to_owned();
if let Some(_) = statuses.insert(lang, elem.text()) {
return Err(Error::ParseError("Status element present twice for the same xml:lang."));
}
} else if elem.is("priority", ns::JABBER_CLIENT) {
if priority.is_some() {
return Err(Error::ParseError("More than one priority element in a presence."));
}
for _ in elem.children() {
return Err(Error::ParseError("Unknown child in priority element."));
}
priority = Some(Priority::from_str(elem.text().as_ref())?);
} else { } else {
None let payload = if let Ok(stanza_error) = StanzaError::try_from(elem) {
}; Some(PresencePayload::StanzaError(stanza_error))
payloads.push(match payload { } else if let Ok(delay) = Delay::try_from(elem) {
Some(payload) => PresencePayloadType::Parsed(payload), Some(PresencePayload::Delay(delay))
None => PresencePayloadType::XML(elem.clone()), } else if let Ok(ecaps2) = ECaps2::try_from(elem) {
}); Some(PresencePayload::ECaps2(ecaps2))
} else {
None
};
payloads.push(match payload {
Some(payload) => PresencePayloadType::Parsed(payload),
None => PresencePayloadType::XML(elem.clone()),
});
}
}
Ok(Presence {
from: from,
to: to,
id: id,
type_: type_,
show: show,
statuses: statuses,
priority: priority.unwrap_or(0i8),
payloads: payloads,
})
}
}
impl<'a> Into<Element> for &'a PresencePayload {
fn into(self) -> Element {
match *self {
PresencePayload::Show(ref show) => {
Element::builder("status")
.ns(ns::JABBER_CLIENT)
.append(show.to_owned())
.build()
},
PresencePayload::Status(ref status) => {
Element::builder("status")
.ns(ns::JABBER_CLIENT)
.append(status.to_owned())
.build()
},
PresencePayload::Priority(ref priority) => {
Element::builder("status")
.ns(ns::JABBER_CLIENT)
.append(format!("{}", priority))
.build()
},
PresencePayload::StanzaError(ref stanza_error) => stanza_error.into(),
PresencePayload::Delay(ref delay) => delay.into(),
PresencePayload::ECaps2(ref ecaps2) => ecaps2.into(),
} }
} }
Ok(Presence {
from: from,
to: to,
id: id,
type_: type_,
show: show,
statuses: statuses,
priority: priority.unwrap_or(0i8),
payloads: payloads,
})
} }
pub fn serialise_payload(payload: &PresencePayload) -> Element { impl<'a> Into<Element> for &'a Presence {
match *payload { fn into(self) -> Element {
PresencePayload::Show(ref show) => { let mut stanza = Element::builder("presence")
Element::builder("status") .ns(ns::JABBER_CLIENT)
.ns(ns::JABBER_CLIENT) .attr("from", self.from.clone().and_then(|value| Some(String::from(value))))
.append(show.to_owned()) .attr("to", self.to.clone().and_then(|value| Some(String::from(value))))
.build() .attr("id", self.id.clone())
}, .attr("type", self.type_.clone())
PresencePayload::Status(ref status) => { .build();
Element::builder("status") for child in self.payloads.clone() {
.ns(ns::JABBER_CLIENT) let elem = match child {
.append(status.to_owned()) PresencePayloadType::XML(elem) => elem,
.build() PresencePayloadType::Parsed(payload) => (&payload).into(),
}, };
PresencePayload::Priority(ref priority) => { stanza.append_child(elem);
Element::builder("status") }
.ns(ns::JABBER_CLIENT) stanza
.append(format!("{}", priority))
.build()
},
PresencePayload::StanzaError(ref stanza_error) => stanza_error.into(),
PresencePayload::Delay(ref delay) => delay.into(),
PresencePayload::ECaps2(ref ecaps2) => ecaps2.into(),
} }
} }
pub fn serialise(presence: &Presence) -> Element {
let mut stanza = Element::builder("presence")
.ns(ns::JABBER_CLIENT)
.attr("from", presence.from.clone().and_then(|value| Some(String::from(value))))
.attr("to", presence.to.clone().and_then(|value| Some(String::from(value))))
.attr("id", presence.id.clone())
.attr("type", presence.type_.clone())
.build();
for child in presence.payloads.clone() {
let elem = match child {
PresencePayloadType::XML(elem) => elem,
PresencePayloadType::Parsed(payload) => serialise_payload(&payload),
};
stanza.append_child(elem);
}
stanza
}
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::collections::BTreeMap; use std::collections::BTreeMap;
use minidom::Element; use super::*;
use error::Error;
use presence;
use ns; use ns;
#[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::parse_presence(&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);
assert_eq!(presence.type_, presence::PresenceType::Available); assert_eq!(presence.type_, PresenceType::Available);
assert!(presence.payloads.is_empty()); assert!(presence.payloads.is_empty());
} }
#[test] #[test]
fn test_serialise() { fn test_serialise() {
let elem: Element = "<presence xmlns='jabber:client' type='unavailable'/>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client' type='unavailable'/>".parse().unwrap();
let presence = presence::Presence { let presence = Presence {
from: None, from: None,
to: None, to: None,
id: None, id: None,
type_: presence::PresenceType::Unavailable, type_: PresenceType::Unavailable,
show: None, show: None,
statuses: BTreeMap::new(), statuses: BTreeMap::new(),
priority: 0i8, priority: 0i8,
payloads: vec!(), payloads: vec!(),
}; };
let elem2 = presence::serialise(&presence); 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::parse_presence(&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(presence::Show::Chat)); assert_eq!(presence.show, Some(Show::Chat));
} }
#[test] #[test]
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::parse_presence(&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!(),
@ -310,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::parse_presence(&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!(),
@ -321,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::parse_presence(&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[""], "");
@ -330,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::parse_presence(&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!");
@ -339,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::parse_presence(&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!");
@ -349,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::parse_presence(&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!(),
@ -360,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::parse_presence(&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);
} }
@ -368,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::parse_presence(&elem).unwrap_err(); let error = Presence::try_from(&elem).unwrap_err();
match error { match error {
Error::ParseIntError(_) => (), Error::ParseIntError(_) => (),
_ => panic!(), _ => panic!(),
@ -378,8 +384,8 @@ 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::parse_presence(&elem).unwrap(); let presence = Presence::try_from(&elem).unwrap();
if let presence::PresencePayloadType::XML(ref payload) = presence.payloads[0] { if let PresencePayloadType::XML(ref payload) = presence.payloads[0] {
assert!(payload.is("test", "invalid")); assert!(payload.is("test", "invalid"));
} else { } else {
panic!("Did successfully parse an invalid element."); panic!("Did successfully parse an invalid element.");
@ -390,7 +396,7 @@ mod tests {
#[ignore] #[ignore]
fn test_invalid_status_child() { fn test_invalid_status_child() {
let elem: Element = "<presence xmlns='jabber:client'><status xmlns='jabber:client'><coucou/></status></presence>".parse().unwrap(); let elem: Element = "<presence xmlns='jabber:client'><status xmlns='jabber:client'><coucou/></status></presence>".parse().unwrap();
let error = presence::parse_presence(&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!(),
@ -402,7 +408,7 @@ mod tests {
#[ignore] #[ignore]
fn test_invalid_attribute() { fn test_invalid_attribute() {
let elem: Element = "<status xmlns='jabber:client' coucou=''/>".parse().unwrap(); let elem: Element = "<status xmlns='jabber:client' coucou=''/>".parse().unwrap();
let error = presence::parse_presence(&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!(),
@ -412,19 +418,19 @@ mod tests {
#[test] #[test]
fn test_serialise_status() { fn test_serialise_status() {
let status = presence::Status::from("Hello world!"); let status = Status::from("Hello world!");
let payloads = vec!(presence::PresencePayloadType::Parsed(presence::PresencePayload::Status(status))); let payloads = vec!(PresencePayloadType::Parsed(PresencePayload::Status(status)));
let presence = presence::Presence { let presence = Presence {
from: None, from: None,
to: None, to: None,
id: None, id: None,
type_: presence::PresenceType::Unavailable, type_: PresenceType::Unavailable,
show: None, show: None,
statuses: BTreeMap::new(), statuses: BTreeMap::new(),
priority: 0i8, priority: 0i8,
payloads: payloads, payloads: payloads,
}; };
let elem = presence::serialise(&presence); 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));
} }