aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/dav/caldecoder.rs8
-rw-r--r--src/dav/calencoder.rs4
-rw-r--r--src/dav/caltypes.rs3
-rw-r--r--src/dav/decoder.rs748
-rw-r--r--src/dav/encoder.rs2
-rw-r--r--src/dav/error.rs1
-rw-r--r--src/dav/realization.rs4
-rw-r--r--src/dav/types.rs19
-rw-r--r--src/dav/xml.rs87
9 files changed, 406 insertions, 470 deletions
diff --git a/src/dav/caldecoder.rs b/src/dav/caldecoder.rs
index b45d649..5f40c4b 100644
--- a/src/dav/caldecoder.rs
+++ b/src/dav/caldecoder.rs
@@ -7,25 +7,25 @@ use super::error;
// ---- EXTENSIONS ---
impl xml::QRead<Violation> for Violation {
- async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Option<Self>, error::ParsingError> {
+ async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Self, error::ParsingError> {
unreachable!();
}
}
impl xml::QRead<Property> for Property {
- async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Option<Self>, error::ParsingError> {
+ async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Self, error::ParsingError> {
unreachable!();
}
}
impl xml::QRead<PropertyRequest> for PropertyRequest {
- async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Option<Self>, error::ParsingError> {
+ async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Self, error::ParsingError> {
unreachable!();
}
}
impl xml::QRead<ResourceType> for ResourceType {
- async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Option<Self>, error::ParsingError> {
+ async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Self, error::ParsingError> {
unreachable!();
}
}
diff --git a/src/dav/calencoder.rs b/src/dav/calencoder.rs
index cadfc78..58b88c7 100644
--- a/src/dav/calencoder.rs
+++ b/src/dav/calencoder.rs
@@ -4,8 +4,8 @@ use quick_xml::name::PrefixDeclaration;
use tokio::io::AsyncWrite;
use super::caltypes::*;
-use super::xml::{QWrite, IWrite, Writer};
-use super::types::{Extension, Node};
+use super::xml::{Node, QWrite, IWrite, Writer};
+use super::types::Extension;
const ICAL_DATETIME_FMT: &str = "%Y%m%dT%H%M%SZ";
diff --git a/src/dav/caltypes.rs b/src/dav/caltypes.rs
index d9cbb12..befecef 100644
--- a/src/dav/caltypes.rs
+++ b/src/dav/caltypes.rs
@@ -2,6 +2,7 @@
use chrono::{DateTime,Utc};
use super::types as dav;
+use super::xml;
//@FIXME ACL (rfc3744) is missing, required
//@FIXME Versioning (rfc3253) is missing, required
@@ -44,7 +45,7 @@ pub struct MkCalendar<E: dav::Extension>(pub dav::Set<E>);
///
/// <!ELEMENT mkcol-response (propstat+)>
#[derive(Debug, PartialEq)]
-pub struct MkCalendarResponse<E: dav::Extension, N: dav::Node<N>>(pub Vec<dav::PropStat<E,N>>);
+pub struct MkCalendarResponse<E: dav::Extension, N: xml::Node<N>>(pub Vec<dav::PropStat<E,N>>);
// --- (REPORT PART) ---
diff --git a/src/dav/decoder.rs b/src/dav/decoder.rs
index 41eca36..144cc4e 100644
--- a/src/dav/decoder.rs
+++ b/src/dav/decoder.rs
@@ -9,7 +9,7 @@ use tokio::io::AsyncBufRead;
use super::types::*;
use super::error::ParsingError;
-use super::xml::{QRead, Reader, IRead, DAV_URN, CAL_URN};
+use super::xml::{Node, QRead, Reader, IRead, DAV_URN, CAL_URN};
//@TODO (1) Rewrite all objects as Href,
// where we return Ok(None) instead of trying to find the object at any cost.
@@ -24,21 +24,22 @@ use super::xml::{QRead, Reader, IRead, DAV_URN, CAL_URN};
/// Propfind request
impl<E: Extension> QRead<PropFind<E>> for PropFind<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
// Find propfind
- xml.tag_start(DAV_URN, "propfind").await?;
+ xml.open(DAV_URN, "propfind").await?;
+
// Find any tag
let propfind: PropFind<E> = loop {
match xml.peek() {
Event::Start(_) if xml.is_tag(DAV_URN, "allprop") => {
- xml.tag_start(DAV_URN, "allprop").await?;
- let r = PropFind::AllProp(Include::qread(xml).await?);
+ xml.open(DAV_URN, "allprop").await?;
+ let includ = xml.maybe_find::<Include<E>>().await?;
+ let r = PropFind::AllProp(includ);
xml.tag_stop(DAV_URN, "allprop").await?;
break r
},
Event::Start(_) if xml.is_tag(DAV_URN, "prop") => {
- let propname = PropName::qread(xml).await?.ok_or(ParsingError::MissingChild)?;
- break PropFind::Prop(propname);
+ break PropFind::Prop(xml.find::<PropName<E>>().await?);
},
Event::Empty(_) if xml.is_tag(DAV_URN, "allprop") => {
xml.next().await?;
@@ -55,47 +56,32 @@ impl<E: Extension> QRead<PropFind<E>> for PropFind<E> {
// Close tag
xml.tag_stop(DAV_URN, "propfind").await?;
- Ok(Some(propfind))
+ Ok(propfind)
}
}
/// PROPPATCH request
impl<E: Extension> QRead<PropertyUpdate<E>> for PropertyUpdate<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "propertyupdate").await?;
- let mut collected_items = Vec::new();
- loop {
- // Try to collect a property item
- if let Some(item) = PropertyUpdateItem::qread(xml).await? {
- collected_items.push(item);
- continue
- }
-
- // Skip or stop otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
-
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "propertyupdate").await?;
+ let collected_items = xml.collect::<PropertyUpdateItem<E>>().await?;
xml.tag_stop(DAV_URN, "propertyupdate").await?;
- Ok(Some(PropertyUpdate(collected_items)))
+ Ok(PropertyUpdate(collected_items))
}
}
/// Generic response
impl<E: Extension, N: Node<N>> QRead<Multistatus<E,N>> for Multistatus<E,N> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "multistatus").await?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "multistatus").await?;
let mut responses = Vec::new();
let mut responsedescription = None;
loop {
- if let Some(v) = Response::qread(xml).await? {
- responses.push(v);
- } else if let Some(v) = ResponseDescription::qread(xml).await? {
- responsedescription = Some(v);
- } else {
+ let mut dirty = false;
+ xml.maybe_push(&mut responses, &mut dirty).await?;
+ xml.maybe_read(&mut responsedescription, &mut dirty).await?;
+ if !dirty {
match xml.peek() {
Event::End(_) => break,
_ => xml.skip().await?,
@@ -104,23 +90,22 @@ impl<E: Extension, N: Node<N>> QRead<Multistatus<E,N>> for Multistatus<E,N> {
}
xml.tag_stop(DAV_URN, "multistatus").await?;
- Ok(Some(Multistatus { responses, responsedescription }))
+ Ok(Multistatus { responses, responsedescription })
}
}
// LOCK REQUEST
impl QRead<LockInfo> for LockInfo {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "lockinfo").await?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "lockinfo").await?;
let (mut m_scope, mut m_type, mut owner) = (None, None, None);
loop {
- if let Some(v) = LockScope::qread(xml).await? {
- m_scope = Some(v);
- } else if let Some(v) = LockType::qread(xml).await? {
- m_type = Some(v);
- } else if let Some(v) = Owner::qread(xml).await? {
- owner = Some(v);
- } else {
+ let mut dirty = false;
+ xml.maybe_read::<LockScope>(&mut m_scope, &mut dirty).await?;
+ xml.maybe_read::<LockType>(&mut m_type, &mut dirty).await?;
+ xml.maybe_read::<Owner>(&mut owner, &mut dirty).await?;
+
+ if !dirty {
match xml.peek() {
Event::End(_) => break,
_ => xml.skip().await?,
@@ -129,7 +114,7 @@ impl QRead<LockInfo> for LockInfo {
}
xml.tag_stop(DAV_URN, "lockinfo").await?;
match (m_scope, m_type) {
- (Some(lockscope), Some(locktype)) => Ok(Some(LockInfo { lockscope, locktype, owner })),
+ (Some(lockscope), Some(locktype)) => Ok(LockInfo { lockscope, locktype, owner }),
_ => Err(ParsingError::MissingChild),
}
}
@@ -137,44 +122,22 @@ impl QRead<LockInfo> for LockInfo {
// LOCK RESPONSE
impl<E: Extension> QRead<PropValue<E>> for PropValue<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "prop").await?;
- let mut acc = Vec::new();
- loop {
- // Found a property
- if let Some(prop) = Property::qread(xml).await? {
- acc.push(prop);
- continue;
- }
-
- // Otherwise skip or escape
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "prop").await?;
+ let mut acc = xml.collect::<Property<E>>().await?;
xml.tag_stop(DAV_URN, "prop").await?;
- Ok(Some(PropValue(acc)))
+ Ok(PropValue(acc))
}
}
/// Error response
impl<E: Extension> QRead<Error<E>> for Error<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "error").await?;
- let mut violations = Vec::new();
- loop {
- match xml.peek() {
- Event::Start(_) | Event::Empty(_) => {
- Violation::qread(xml).await?.map(|v| violations.push(v));
- },
- Event::End(_) if xml.is_tag(DAV_URN, "error") => break,
- _ => { xml.skip().await?; },
- }
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "error").await?;
+ let violations = xml.collect::<Violation<E>>().await?;
xml.tag_stop(DAV_URN, "error").await?;
- Ok(Some(Error(violations)))
+ Ok(Error(violations))
}
}
@@ -182,28 +145,22 @@ impl<E: Extension> QRead<Error<E>> for Error<E> {
// ---- INNER XML
impl<E: Extension, N: Node<N>> QRead<Response<E,N>> for Response<E,N> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "response").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "response").await?;
let (mut status, mut error, mut responsedescription, mut location) = (None, None, None, None);
let mut href = Vec::new();
let mut propstat = Vec::new();
loop {
- if let Some(v) = Status::qread(xml).await? {
- status = Some(v);
- } else if let Some(v) = Href::qread(xml).await? {
- href.push(v);
- } else if let Some(v) = PropStat::qread(xml).await? {
- propstat.push(v);
- } else if let Some(v) = Error::qread(xml).await? {
- error = Some(v);
- } else if let Some(v) = ResponseDescription::qread(xml).await? {
- responsedescription = Some(v);
- } else if let Some(v) = Location::qread(xml).await? {
- location = Some(v);
- } else {
+ let mut dirty = false;
+ xml.maybe_read::<Status>(&mut status, &mut dirty).await?;
+ xml.maybe_push::<Href>(&mut href, &mut dirty).await?;
+ xml.maybe_push::<PropStat<E,N>>(&mut propstat, &mut dirty).await?;
+ xml.maybe_read::<Error<E>>(&mut error, &mut dirty).await?;
+ xml.maybe_read::<ResponseDescription>(&mut responsedescription, &mut dirty).await?;
+ xml.maybe_read::<Location>(&mut location, &mut dirty).await?;
+
+ if !dirty {
match xml.peek() {
Event::End(_) => break,
_ => { xml.skip().await? },
@@ -213,14 +170,14 @@ impl<E: Extension, N: Node<N>> QRead<Response<E,N>> for Response<E,N> {
xml.tag_stop(DAV_URN, "response").await?;
match (status, &propstat[..], &href[..]) {
- (Some(status), &[], &[_, ..]) => Ok(Some(Response {
+ (Some(status), &[], &[_, ..]) => Ok(Response {
status_or_propstat: StatusOrPropstat::Status(href, status),
error, responsedescription, location,
- })),
- (None, &[_, ..], &[_, ..]) => Ok(Some(Response {
+ }),
+ (None, &[_, ..], &[_, ..]) => Ok(Response {
status_or_propstat: StatusOrPropstat::PropStat(href.into_iter().next().unwrap(), propstat),
error, responsedescription, location,
- })),
+ }),
(Some(_), &[_, ..], _) => Err(ParsingError::InvalidValue),
_ => Err(ParsingError::MissingChild),
}
@@ -228,255 +185,173 @@ impl<E: Extension, N: Node<N>> QRead<Response<E,N>> for Response<E,N> {
}
impl<E: Extension, N: Node<N>> QRead<PropStat<E,N>> for PropStat<E,N> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "propstat").await?.is_none() {
- return Ok(None)
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "propstat").await?;
+
+ let (mut m_prop, mut m_status, mut error, mut responsedescription) = (None, None, None, None);
+
+ loop {
+ let mut dirty = false;
+ xml.maybe_read::<N>(&mut m_prop, &mut dirty).await?;
+ xml.maybe_read::<Status>(&mut m_status, &mut dirty).await?;
+ xml.maybe_read::<Error<E>>(&mut error, &mut dirty).await?;
+ xml.maybe_read::<ResponseDescription>(&mut responsedescription, &mut dirty).await?;
+
+ if !dirty {
+ match xml.peek() {
+ Event::End(_) => break,
+ _ => xml.skip().await?,
+ };
+ }
+ }
+
+ xml.tag_stop(DAV_URN, "propstat").await?;
+ match (m_prop, m_status) {
+ (Some(prop), Some(status)) => Ok(PropStat { prop, status, error, responsedescription }),
+ _ => Err(ParsingError::MissingChild),
}
- unimplemented!();
}
}
impl QRead<Status> for Status {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "status").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "status").await?;
let fullcode = xml.tag_string().await?;
let txtcode = fullcode.splitn(3, ' ').nth(1).ok_or(ParsingError::InvalidValue)?;
let code = http::status::StatusCode::from_bytes(txtcode.as_bytes()).or(Err(ParsingError::InvalidValue))?;
xml.tag_stop(DAV_URN, "status").await?;
- Ok(Some(Status(code)))
+ Ok(Status(code))
}
}
impl QRead<ResponseDescription> for ResponseDescription {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "responsedescription").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "responsedescription").await?;
let cnt = xml.tag_string().await?;
xml.tag_stop(DAV_URN, "responsedescription").await?;
- Ok(Some(ResponseDescription(cnt)))
+ Ok(ResponseDescription(cnt))
}
}
impl QRead<Location> for Location {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "location").await?.is_none() {
- return Ok(None)
- }
- let href = loop {
- if let Some(v) = Href::qread(xml).await? {
- break v
- }
-
- match xml.peek() {
- Event::End(_) => return Err(ParsingError::MissingChild),
- _ => xml.skip().await?,
- };
- };
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "location").await?;
+ let href = xml.find::<Href>().await?;
xml.tag_stop(DAV_URN, "location").await?;
- Ok(Some(Location(href)))
+ Ok(Location(href))
}
}
impl<E: Extension> QRead<PropertyUpdateItem<E>> for PropertyUpdateItem<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if let Some(rm) = Remove::qread(xml).await? {
- return Ok(Some(PropertyUpdateItem::Remove(rm)))
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ match Remove::qread(xml).await {
+ Err(ParsingError::Recoverable) => (),
+ otherwise => return otherwise.map(PropertyUpdateItem::Remove),
}
- Ok(Set::qread(xml).await?.map(PropertyUpdateItem::Set))
+ Set::qread(xml).await.map(PropertyUpdateItem::Set)
}
}
impl<E: Extension> QRead<Remove<E>> for Remove<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- match xml.peek() {
- Event::Start(b) if xml.is_tag(DAV_URN, "remove") => xml.next().await?,
- _ => return Ok(None),
- };
-
- let propname = loop {
- match xml.peek() {
- Event::Start(b) | Event::Empty(b) if xml.is_tag(DAV_URN, "prop") => break PropName::qread(xml).await?,
- _ => xml.skip().await?,
- };
- };
-
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "remove").await?;
+ let propname = xml.find::<PropName<E>>().await?;
xml.tag_stop(DAV_URN, "remove").await?;
- Ok(propname.map(Remove))
+ Ok(Remove(propname))
}
}
impl<E: Extension> QRead<Set<E>> for Set<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- match xml.peek() {
- Event::Start(b) if xml.is_tag(DAV_URN, "set") => xml.next().await?,
- _ => return Ok(None),
- };
- let propvalue = loop {
- match xml.peek() {
- Event::Start(b) | Event::Empty(b) if xml.is_tag(DAV_URN, "prop") => break PropValue::qread(xml).await?,
- _ => xml.skip().await?,
- };
- };
-
-
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "set").await?;
+ let propvalue = xml.find::<PropValue<E>>().await?;
xml.tag_stop(DAV_URN, "set").await?;
- Ok(propvalue.map(Set))
+ Ok(Set(propvalue))
}
}
impl<E: Extension> QRead<Violation<E>> for Violation<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- loop {
- let bs = match xml.peek() {
- Event::Start(b) | Event::Empty(b) => b,
- _ => {
- xml.skip().await?;
- continue
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ let bs = match xml.peek() {
+ Event::Start(b) | Event::Empty(b) => b,
+ _ => return Err(ParsingError::Recoverable),
+ };
+
+ // Option 1: a pure DAV property
+ let (ns, loc) = xml.rdr.resolve_element(bs.name());
+ if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) {
+ match loc.into_inner() {
+ b"lock-token-matches-request-uri" => {
+ xml.next().await?;
+ return Ok(Violation::LockTokenMatchesRequestUri)
+ },
+ b"lock-token-submitted" => {
+ xml.next().await?;
+ let links = xml.collect::<Href>().await?;
+ xml.tag_stop(DAV_URN, "lock-token-submitted").await?;
+ return Ok(Violation::LockTokenSubmitted(links))
+ },
+ b"no-conflicting-lock" => {
+ // start tag
+ xml.next().await?;
+ let links = xml.collect::<Href>().await?;
+ xml.tag_stop(DAV_URN, "no-conflicting-lock").await?;
+ return Ok(Violation::NoConflictingLock(links))
+ },
+ b"no-external-entities" => {
+ xml.next().await?;
+ return Ok(Violation::NoExternalEntities)
+ },
+ b"preserved-live-properties" => {
+ xml.next().await?;
+ return Ok(Violation::PreservedLiveProperties)
},
+ b"propfind-finite-depth" => {
+ xml.next().await?;
+ return Ok(Violation::PropfindFiniteDepth)
+ },
+ b"cannot-modify-protected-property" => {
+ xml.next().await?;
+ return Ok(Violation::CannotModifyProtectedProperty)
+ },
+ _ => (),
};
-
- let mut maybe_res = None;
-
- // Option 1: a pure DAV property
- let (ns, loc) = xml.rdr.resolve_element(bs.name());
- if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) {
- maybe_res = match loc.into_inner() {
- b"lock-token-matches-request-uri" => {
- xml.next().await?;
- Some(Violation::LockTokenMatchesRequestUri)
- },
- b"lock-token-submitted" => {
- // start tag
- xml.next().await?;
-
- let mut links = Vec::new();
- loop {
- // If we find a Href
- if let Some(href) = Href::qread(xml).await? {
- links.push(href);
- continue
- }
-
- // Otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
- xml.tag_stop(DAV_URN, "lock-token-submitted").await?;
- Some(Violation::LockTokenSubmitted(links))
- },
- b"no-conflicting-lock" => {
- // start tag
- xml.next().await?;
-
- let mut links = Vec::new();
- loop {
- // If we find a Href
- if let Some(href) = Href::qread(xml).await? {
- links.push(href);
- continue
- }
-
- // Otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
- xml.tag_stop(DAV_URN, "no-conflicting-lock").await?;
- Some(Violation::NoConflictingLock(links))
- },
- b"no-external-entities" => {
- xml.next().await?;
- Some(Violation::NoExternalEntities)
- },
- b"preserved-live-properties" => {
- xml.next().await?;
- Some(Violation::PreservedLiveProperties)
- },
- b"propfind-finite-depth" => {
- xml.next().await?;
- Some(Violation::PropfindFiniteDepth)
- },
- b"cannot-modify-protected-property" => {
- xml.next().await?;
- Some(Violation::CannotModifyProtectedProperty)
- },
- _ => None,
- };
- }
-
- // Option 2: an extension property, delegating
- if maybe_res.is_none() {
- maybe_res = E::Error::qread(xml).await?.map(Violation::Extension);
- }
-
- return Ok(maybe_res)
}
+
+ // Option 2: an extension property, delegating
+ E::Error::qread(xml).await.map(Violation::Extension)
}
}
impl<E: Extension> QRead<Include<E>> for Include<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "include").await?;
- let mut acc = Vec::new();
- loop {
- // Found a property
- if let Some(prop) = PropertyRequest::qread(xml).await? {
- acc.push(prop);
- continue;
- }
-
- // Otherwise skip or escape
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "include").await?;
+ let acc = xml.collect::<PropertyRequest<E>>().await?;
xml.tag_stop(DAV_URN, "include").await?;
- Ok(Some(Include(acc)))
+ Ok(Include(acc))
}
}
impl<E: Extension> QRead<PropName<E>> for PropName<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "prop").await?;
- let mut acc = Vec::new();
- loop {
- // Found a property
- if let Some(prop) = PropertyRequest::qread(xml).await? {
- acc.push(prop);
- continue;
- }
-
- // Otherwise skip or escape
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "prop").await?;
+ let acc = xml.collect::<PropertyRequest<E>>().await?;
xml.tag_stop(DAV_URN, "prop").await?;
- Ok(Some(PropName(acc)))
+ Ok(PropName(acc))
}
}
impl<E: Extension> QRead<PropertyRequest<E>> for PropertyRequest<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
let bs = match xml.peek() {
Event::Start(b) | Event::Empty(b) => b,
- _ => return Ok(None),
+ _ => return Err(ParsingError::Recoverable),
};
- let mut maybe_res = None;
-
// Option 1: a pure core DAV property
let (ns, loc) = xml.rdr.resolve_element(bs.name());
if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) {
- maybe_res = match loc.into_inner() {
+ let maybe_res = match loc.into_inner() {
b"creationdate" => Some(PropertyRequest::CreationDate),
b"displayname" => Some(PropertyRequest::DisplayName),
b"getcontentlanguage" => Some(PropertyRequest::GetContentLanguage),
@@ -490,163 +365,105 @@ impl<E: Extension> QRead<PropertyRequest<E>> for PropertyRequest<E> {
_ => None,
};
// Close the current tag if we read something
- if maybe_res.is_some() {
+ if let Some(res) = maybe_res {
xml.skip().await?;
+ return Ok(res)
}
}
// Option 2: an extension property, delegating
- if maybe_res.is_none() {
- maybe_res = E::PropertyRequest::qread(xml).await?.map(PropertyRequest::Extension);
- }
-
- Ok(maybe_res)
+ E::PropertyRequest::qread(xml).await.map(PropertyRequest::Extension)
}
}
impl<E: Extension> QRead<Property<E>> for Property<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
use chrono::{DateTime, FixedOffset, TimeZone};
let bs = match xml.peek() {
Event::Start(b) | Event::Empty(b) => b,
- _ => return Ok(None),
+ _ => return Err(ParsingError::Recoverable),
};
- let mut maybe_res = None;
-
// Option 1: a pure core DAV property
let (ns, loc) = xml.rdr.resolve_element(bs.name());
if matches!(ns, Bound(Namespace(ns)) if ns == DAV_URN) {
- maybe_res = match loc.into_inner() {
+ match loc.into_inner() {
b"creationdate" => {
xml.next().await?;
let datestr = xml.tag_string().await?;
- Some(Property::CreationDate(DateTime::parse_from_rfc3339(datestr.as_str())?))
+ return Ok(Property::CreationDate(DateTime::parse_from_rfc3339(datestr.as_str())?))
},
b"displayname" => {
xml.next().await?;
- Some(Property::DisplayName(xml.tag_string().await?))
+ return Ok(Property::DisplayName(xml.tag_string().await?))
},
b"getcontentlanguage" => {
xml.next().await?;
- Some(Property::GetContentLanguage(xml.tag_string().await?))
+ return Ok(Property::GetContentLanguage(xml.tag_string().await?))
},
b"getcontentlength" => {
xml.next().await?;
let cl = xml.tag_string().await?.parse::<u64>()?;
- Some(Property::GetContentLength(cl))
+ return Ok(Property::GetContentLength(cl))
},
b"getcontenttype" => {
xml.next().await?;
- Some(Property::GetContentType(xml.tag_string().await?))
+ return Ok(Property::GetContentType(xml.tag_string().await?))
},
b"getetag" => {
xml.next().await?;
- Some(Property::GetEtag(xml.tag_string().await?))
+ return Ok(Property::GetEtag(xml.tag_string().await?))
},
b"getlastmodified" => {
xml.next().await?;
- xml.next().await?;
let datestr = xml.tag_string().await?;
- Some(Property::CreationDate(DateTime::parse_from_rfc2822(datestr.as_str())?))
+ return Ok(Property::CreationDate(DateTime::parse_from_rfc2822(datestr.as_str())?))
},
b"lockdiscovery" => {
- // start tag
xml.next().await?;
-
- let mut acc = Vec::new();
- loop {
- // If we find a lock
- if let Some(lock) = ActiveLock::qread(xml).await? {
- acc.push(lock);
- continue
- }
-
- // Otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ let acc = xml.collect::<ActiveLock>().await?;
xml.tag_stop(DAV_URN, "lockdiscovery").await?;
- Some(Property::LockDiscovery(acc))
+ return Ok(Property::LockDiscovery(acc))
},
b"resourcetype" => {
xml.next().await?;
-
- let mut acc = Vec::new();
- loop {
- // If we find a resource type...
- if let Some(restype) = ResourceType::qread(xml).await? {
- acc.push(restype);
- continue
- }
-
- // Otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ let acc = xml.collect::<ResourceType<E>>().await?;
xml.tag_stop(DAV_URN, "resourcetype").await?;
- Some(Property::ResourceType(acc))
+ return Ok(Property::ResourceType(acc))
},
b"supportedlock" => {
xml.next().await?;
-
- let mut acc = Vec::new();
- loop {
- // If we find a resource type...
- if let Some(restype) = LockEntry::qread(xml).await? {
- acc.push(restype);
- continue
- }
-
- // Otherwise
- match xml.peek() {
- Event::End(_) => break,
- _ => { xml.skip().await?; },
- }
- }
+ let acc = xml.collect::<LockEntry>().await?;
xml.tag_stop(DAV_URN, "supportedlock").await?;
- Some(Property::SupportedLock(acc))
+ return Ok(Property::SupportedLock(acc))
},
- _ => None,
+ _ => (),
};
}
// Option 2: an extension property, delegating
- if maybe_res.is_none() {
- maybe_res = E::Property::qread(xml).await?.map(Property::Extension);
- }
-
- Ok(maybe_res)
+ E::Property::qread(xml).await.map(Property::Extension)
}
}
impl QRead<ActiveLock> for ActiveLock {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "activelock").await?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "activelock").await?;
let (mut m_scope, mut m_type, mut m_depth, mut owner, mut timeout, mut locktoken, mut m_root) =
(None, None, None, None, None, None, None);
loop {
- if let Some(v) = LockScope::qread(xml).await? {
- m_scope = Some(v);
- } else if let Some(v) = LockType::qread(xml).await? {
- m_type = Some(v);
- } else if let Some(v) = Depth::qread(xml).await? {
- m_depth = Some(v);
- } else if let Some(v) = Owner::qread(xml).await? {
- owner = Some(v);
- } else if let Some(v) = Timeout::qread(xml).await? {
- timeout = Some(v);
- } else if let Some(v) = LockToken::qread(xml).await? {
- locktoken = Some(v);
- } else if let Some(v) = LockRoot::qread(xml).await? {
- m_root = Some(v);
- } else {
+ let mut dirty = false;
+ xml.maybe_read::<LockScope>(&mut m_scope, &mut dirty).await?;
+ xml.maybe_read::<LockType>(&mut m_type, &mut dirty).await?;
+ xml.maybe_read::<Depth>(&mut m_depth, &mut dirty).await?;
+ xml.maybe_read::<Owner>(&mut owner, &mut dirty).await?;
+ xml.maybe_read::<Timeout>(&mut timeout, &mut dirty).await?;
+ xml.maybe_read::<LockToken>(&mut locktoken, &mut dirty).await?;
+ xml.maybe_read::<LockRoot>(&mut m_root, &mut dirty).await?;
+
+ if !dirty {
match xml.peek() {
Event::End(_) => break,
_ => { xml.skip().await?; },
@@ -657,31 +474,29 @@ impl QRead<ActiveLock> for ActiveLock {
xml.tag_stop(DAV_URN, "activelock").await?;
match (m_scope, m_type, m_depth, m_root) {
(Some(lockscope), Some(locktype), Some(depth), Some(lockroot)) =>
- Ok(Some(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot })),
+ Ok(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot }),
_ => Err(ParsingError::MissingChild),
}
}
}
impl QRead<Depth> for Depth {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "depth").await?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "depth").await?;
let depth_str = xml.tag_string().await?;
xml.tag_stop(DAV_URN, "depth").await?;
match depth_str.as_str() {
- "0" => Ok(Some(Depth::Zero)),
- "1" => Ok(Some(Depth::One)),
- "infinity" => Ok(Some(Depth::Infinity)),
+ "0" => Ok(Depth::Zero),
+ "1" => Ok(Depth::One),
+ "infinity" => Ok(Depth::Infinity),
_ => Err(ParsingError::WrongToken),
}
}
}
impl QRead<Owner> for Owner {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "owner").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "owner").await?;
let mut owner = Owner::Unknown;
loop {
@@ -693,28 +508,25 @@ impl QRead<Owner> for Owner {
}
}
Event::Start(_) | Event::Empty(_) => {
- if let Some(href) = Href::qread(xml).await? {
- owner = Owner::Href(href)
+ match Href::qread(xml).await {
+ Ok(href) => { owner = Owner::Href(href); },
+ Err(ParsingError::Recoverable) => { xml.skip().await?; },
+ Err(e) => return Err(e),
}
- xml.skip().await?;
}
Event::End(_) => break,
_ => { xml.skip().await?; },
}
};
xml.tag_stop(DAV_URN, "owner").await?;
- Ok(Some(owner))
+ Ok(owner)
}
}
impl QRead<Timeout> for Timeout {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
const SEC_PFX: &str = "SEC_PFX";
-
- match xml.peek() {
- Event::Start(b) if xml.is_tag(DAV_URN, "timeout") => xml.next().await?,
- _ => return Ok(None),
- };
+ xml.open(DAV_URN, "timeout").await?;
let timeout = match xml.tag_string().await?.as_str() {
"Infinite" => Timeout::Infinite,
@@ -725,79 +537,70 @@ impl QRead<Timeout> for Timeout {
};
xml.tag_stop(DAV_URN, "timeout").await?;
- Ok(Some(timeout))
+ Ok(timeout)
}
}
impl QRead<LockToken> for LockToken {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- match xml.peek() {
- Event::Start(b) if xml.is_tag(DAV_URN, "locktoken") => xml.next().await?,
- _ => return Ok(None),
- };
- let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "locktoken").await?;
+ let href = Href::qread(xml).await?;
xml.tag_stop(DAV_URN, "locktoken").await?;
- Ok(Some(LockToken(href)))
+ Ok(LockToken(href))
}
}
impl QRead<LockRoot> for LockRoot {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "lockroot").await?;
- let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "lockroot").await?;
+ let href = Href::qread(xml).await?;
xml.tag_stop(DAV_URN, "lockroot").await?;
- Ok(Some(LockRoot(href)))
+ Ok(LockRoot(href))
}
}
impl<E: Extension> QRead<ResourceType<E>> for ResourceType<E> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
match xml.peek() {
Event::Empty(b) if xml.is_tag(DAV_URN, "collection") => {
xml.next().await?;
- Ok(Some(ResourceType::Collection))
+ Ok(ResourceType::Collection)
},
- _ => Ok(E::ResourceType::qread(xml).await?.map(ResourceType::Extension)),
+ _ => E::ResourceType::qread(xml).await.map(ResourceType::Extension),
}
}
}
impl QRead<LockEntry> for LockEntry {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- xml.tag_start(DAV_URN, "lockentry").await?;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "lockentry").await?;
let (mut maybe_scope, mut maybe_type) = (None, None);
loop {
- match xml.peek() {
- Event::Start(_) if xml.is_tag(DAV_URN, "lockscope") => {
- maybe_scope = LockScope::qread(xml).await?;
- },
- Event::Start(_) if xml.is_tag(DAV_URN, "lockentry") => {
- maybe_type = LockType::qread(xml).await?;
- }
- Event::End(_) => break,
- _ => { xml.skip().await?; },
+ let mut dirty = false;
+ xml.maybe_read::<LockScope>(&mut maybe_scope, &mut dirty).await?;
+ xml.maybe_read::<LockType>(&mut maybe_type, &mut dirty).await?;
+ if !dirty {
+ match xml.peek() {
+ Event::End(_) => break,
+ _ => xml.skip().await?,
+ };
}
}
- let lockentry = match (maybe_scope, maybe_type) {
- (Some(lockscope), Some(locktype)) => LockEntry { lockscope, locktype },
- _ => return Err(ParsingError::MissingChild),
- };
-
xml.tag_stop(DAV_URN, "lockentry").await?;
- Ok(Some(lockentry))
+ match (maybe_scope, maybe_type) {
+ (Some(lockscope), Some(locktype)) => Ok(LockEntry { lockscope, locktype }),
+ _ => Err(ParsingError::MissingChild),
+ }
}
}
impl QRead<LockScope> for LockScope {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "lockscope").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "lockscope").await?;
let lockscope = loop {
- println!("lockscope tag: {:?}", xml.peek());
match xml.peek() {
Event::Empty(_) if xml.is_tag(DAV_URN, "exclusive") => {
xml.next().await?;
@@ -812,15 +615,13 @@ impl QRead<LockScope> for LockScope {
};
xml.tag_stop(DAV_URN, "lockscope").await?;
- Ok(Some(lockscope))
+ Ok(lockscope)
}
}
impl QRead<LockType> for LockType {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- if xml.maybe_tag_start(DAV_URN, "locktype").await?.is_none() {
- return Ok(None)
- }
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "locktype").await?;
let locktype = loop {
match xml.peek() {
@@ -832,20 +633,16 @@ impl QRead<LockType> for LockType {
};
};
xml.tag_stop(DAV_URN, "locktype").await?;
- Ok(Some(locktype))
+ Ok(locktype)
}
}
impl QRead<Href> for Href {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
- match xml.peek() {
- Event::Start(b) if xml.is_tag(DAV_URN, "href") => xml.next().await?,
- _ => return Ok(None),
- };
-
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<Self, ParsingError> {
+ xml.open(DAV_URN, "href").await?;
let mut url = xml.tag_string().await?;
xml.tag_stop(DAV_URN, "href").await?;
- Ok(Some(Href(url)))
+ Ok(Href(url))
}
}
@@ -865,7 +662,7 @@ mod tests {
"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
- let got = PropFind::<Core>::qread(&mut rdr).await.unwrap().unwrap();
+ let got = rdr.find::<PropFind::<Core>>().await.unwrap();
assert_eq!(got, PropFind::<Core>::PropName);
}
@@ -889,7 +686,7 @@ mod tests {
"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
- let got = PropFind::<Core>::qread(&mut rdr).await.unwrap().unwrap();
+ let got = rdr.find::<PropFind::<Core>>().await.unwrap();
assert_eq!(got, PropFind::Prop(PropName(vec![
PropertyRequest::DisplayName,
@@ -912,7 +709,7 @@ mod tests {
</D:error>"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
- let got = Error::<Core>::qread(&mut rdr).await.unwrap().unwrap();
+ let got = rdr.find::<Error::<Core>>().await.unwrap();
assert_eq!(got, Error(vec![
Violation::LockTokenSubmitted(vec![
@@ -941,7 +738,7 @@ mod tests {
</D:propertyupdate>"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
- let got = PropertyUpdate::<Core>::qread(&mut rdr).await.unwrap().unwrap();
+ let got = rdr.find::<PropertyUpdate::<Core>>().await.unwrap();
assert_eq!(got, PropertyUpdate(vec![
PropertyUpdateItem::Set(Set(PropValue(vec![]))),
@@ -950,7 +747,7 @@ mod tests {
}
#[tokio::test]
- async fn rfc_lockinfo1() {
+ async fn rfc_lockinfo() {
let src = r#"
<?xml version="1.0" encoding="utf-8" ?>
<D:lockinfo xmlns:D='DAV:'>
@@ -963,7 +760,8 @@ mod tests {
"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
- let got = LockInfo::qread(&mut rdr).await.unwrap().unwrap();
+ let got = rdr.find::<LockInfo>().await.unwrap();
+
assert_eq!(got, LockInfo {
lockscope: LockScope::Exclusive,
locktype: LockType::Write,
@@ -971,4 +769,58 @@ mod tests {
});
}
+ #[tokio::test]
+ async fn rfc_multistatus_name() {
+ let src = r#"
+<?xml version="1.0" encoding="utf-8" ?>
+ <multistatus xmlns="DAV:">
+ <response>
+ <href>http://www.example.com/container/</href>
+ <propstat>
+ <prop xmlns:R="http://ns.example.com/boxschema/">
+ <R:bigbox/>
+ <R:author/>
+ <creationdate/>
+ <displayname/>
+ <resourcetype/>
+ <supportedlock/>
+ </prop>
+ <status>HTTP/1.1 200 OK</status>
+ </propstat>
+ </response>
+ <response>
+ <href>http://www.example.com/container/front.html</href>
+ <propstat>
+ <prop xmlns:R="http://ns.example.com/boxschema/">
+ <R:bigbox/>
+ <creationdate/>
+ <displayname/>
+ <getcontentlength/>
+ <getcontenttype/>
+ <getetag/>
+ <getlastmodified/>
+ <resourcetype/>
+ <supportedlock/>
+ </prop>
+ <status>HTTP/1.1 200 OK</status>
+ </propstat>
+ </response>
+ </multistatus>
+"#;
+
+ let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
+ let got = rdr.find::<Multistatus::<Core, PropName<Core>>>().await.unwrap();
+
+ /*assert_eq!(got, Multistatus {
+ responses: vec![
+ Response {
+ status_or_propstat:
+ },
+ Response {},
+ ],
+ responsedescription: None,
+ });*/
+
+ }
+
}
diff --git a/src/dav/encoder.rs b/src/dav/encoder.rs
index 9e60f29..4de5440 100644
--- a/src/dav/encoder.rs
+++ b/src/dav/encoder.rs
@@ -6,7 +6,7 @@ use quick_xml::writer::ElementWriter;
use quick_xml::name::PrefixDeclaration;
use tokio::io::AsyncWrite;
use super::types::*;
-use super::xml::{Writer,QWrite,IWrite};
+use super::xml::{Node, Writer,QWrite,IWrite};
// --- XML ROOTS
diff --git a/src/dav/error.rs b/src/dav/error.rs
index 88a5e60..78c6d6b 100644
--- a/src/dav/error.rs
+++ b/src/dav/error.rs
@@ -2,6 +2,7 @@ use quick_xml::events::attributes::AttrError;
#[derive(Debug)]
pub enum ParsingError {
+ Recoverable,
MissingChild,
NamespacePrefixAlreadyUsed,
WrongToken,
diff --git a/src/dav/realization.rs b/src/dav/realization.rs
index 1898173..33a556e 100644
--- a/src/dav/realization.rs
+++ b/src/dav/realization.rs
@@ -6,8 +6,8 @@ use super::error;
#[derive(Debug, PartialEq)]
pub struct Disabled(());
impl xml::QRead<Disabled> for Disabled {
- async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Option<Self>, error::ParsingError> {
- Ok(None)
+ async fn qread(xml: &mut xml::Reader<impl xml::IRead>) -> Result<Self, error::ParsingError> {
+ Err(error::ParsingError::Recoverable)
}
}
impl xml::QWrite for Disabled {
diff --git a/src/dav/types.rs b/src/dav/types.rs
index 246a4bd..5ea38d1 100644
--- a/src/dav/types.rs
+++ b/src/dav/types.rs
@@ -7,12 +7,11 @@ use super::error;
/// It's how we implement a DAV extension
/// (That's the dark magic part...)
-pub trait Node<T> = xml::QRead<T> + xml::QWrite + Debug + PartialEq;
-pub trait Extension {
- type Error: Node<Self::Error>;
- type Property: Node<Self::Property>;
- type PropertyRequest: Node<Self::PropertyRequest>;
- type ResourceType: Node<Self::ResourceType>;
+pub trait Extension: std::fmt::Debug + PartialEq {
+ type Error: xml::Node<Self::Error>;
+ type Property: xml::Node<Self::Property>;
+ type PropertyRequest: xml::Node<Self::PropertyRequest>;
+ type ResourceType: xml::Node<Self::ResourceType>;
}
/// 14.1. activelock XML Element
@@ -333,7 +332,7 @@ pub enum LockType {
///
/// <!ELEMENT multistatus (response*, responsedescription?) >
#[derive(Debug, PartialEq)]
-pub struct Multistatus<E: Extension, N: Node<N>> {
+pub struct Multistatus<E: Extension, N: xml::Node<N>> {
pub responses: Vec<Response<E, N>>,
pub responsedescription: Option<ResponseDescription>,
}
@@ -465,7 +464,7 @@ pub enum PropFind<E: Extension> {
///
/// <!ELEMENT propstat (prop, status, error?, responsedescription?) >
#[derive(Debug, PartialEq)]
-pub struct PropStat<E: Extension, N: Node<N>> {
+pub struct PropStat<E: Extension, N: xml::Node<N>> {
pub prop: N,
pub status: Status,
pub error: Option<Error<E>>,
@@ -514,7 +513,7 @@ pub struct Remove<E: Extension>(pub PropName<E>);
/// --- rewritten as ---
/// <!ELEMENT response ((href+, status)|(href, propstat+), error?, responsedescription?, location?>
#[derive(Debug, PartialEq)]
-pub enum StatusOrPropstat<E: Extension, N: Node<N>> {
+pub enum StatusOrPropstat<E: Extension, N: xml::Node<N>> {
// One status, multiple hrefs...
Status(Vec<Href>, Status),
// A single href, multiple properties...
@@ -522,7 +521,7 @@ pub enum StatusOrPropstat<E: Extension, N: Node<N>> {
}
#[derive(Debug, PartialEq)]
-pub struct Response<E: Extension, N: Node<N>> {
+pub struct Response<E: Extension, N: xml::Node<N>> {
pub status_or_propstat: StatusOrPropstat<E, N>,
pub error: Option<Error<E>>,
pub responsedescription: Option<ResponseDescription>,
diff --git a/src/dav/xml.rs b/src/dav/xml.rs
index ff121f4..d465d60 100644
--- a/src/dav/xml.rs
+++ b/src/dav/xml.rs
@@ -19,9 +19,14 @@ pub trait QWrite {
async fn qwrite(&self, xml: &mut Writer<impl IWrite>) -> Result<(), quick_xml::Error>;
}
pub trait QRead<T> {
- async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<T>, ParsingError>;
+ async fn qread(xml: &mut Reader<impl IRead>) -> Result<T, ParsingError>;
}
+// The representation of an XML node in Rust
+pub trait Node<T> = QRead<T> + QWrite + std::fmt::Debug + PartialEq;
+
+// ---------------
+
/// Transform a Rust object into an XML stream of characters
pub struct Writer<T: IWrite> {
pub q: quick_xml::writer::Writer<T>,
@@ -106,6 +111,8 @@ impl<T: IRead> Reader<T> {
}
}
+ /*
+ * Disabled
/// maybe find start tag
pub async fn maybe_tag_start(&mut self, ns: &[u8], key: &str) -> Result<Option<Event<'static>>, ParsingError> {
println!("maybe start tag {}", key);
@@ -118,7 +125,6 @@ impl<T: IRead> Reader<T> {
/// find start tag
pub async fn tag_start(&mut self, ns: &[u8], key: &str) -> Result<Event<'static>, ParsingError> {
- println!("search start tag {}", key);
loop {
match self.peek() {
Event::Start(b) if self.is_tag(ns, key) => break,
@@ -127,6 +133,7 @@ impl<T: IRead> Reader<T> {
}
self.next().await
}
+ */
// find stop tag
pub async fn tag_stop(&mut self, ns: &[u8], key: &str) -> Result<Event<'static>, ParsingError> {
@@ -157,5 +164,81 @@ impl<T: IRead> Reader<T> {
};
}
}
+
+ // NEW API
+ pub async fn maybe_read<N: Node<N>>(&mut self, t: &mut Option<N>, dirty: &mut bool) -> Result<(), ParsingError> {
+ match N::qread(self).await {
+ Ok(v) => {
+ *t = Some(v);
+ *dirty = true;
+ Ok(())
+ },
+ Err(ParsingError::Recoverable) => Ok(()),
+ Err(e) => Err(e),
+ }
+ }
+
+ pub async fn maybe_push<N: Node<N>>(&mut self, t: &mut Vec<N>, dirty: &mut bool) -> Result<(), ParsingError> {
+ match N::qread(self).await {
+ Ok(v) => {
+ t.push(v);
+ *dirty = true;
+ Ok(())
+ },
+ Err(ParsingError::Recoverable) => Ok(()),
+ Err(e) => Err(e),
+ }
+ }
+
+ pub async fn find<N: Node<N>>(&mut self) -> Result<N, ParsingError> {
+ loop {
+ // Try parse
+ match N::qread(self).await {
+ Err(ParsingError::Recoverable) => (),
+ otherwise => return otherwise,
+ }
+
+ // If recovered, skip the element
+ self.skip().await?;
+ }
+ }
+
+ pub async fn maybe_find<N: Node<N>>(&mut self) -> Result<Option<N>, ParsingError> {
+ loop {
+ // Try parse
+ match N::qread(self).await {
+ Err(ParsingError::Recoverable) => (),
+ otherwise => return otherwise.map(Some),
+ }
+
+ match self.peek() {
+ Event::End(_) => return Ok(None),
+ _ => self.skip().await?,
+ };
+ }
+ }
+
+ pub async fn collect<N: Node<N>>(&mut self) -> Result<Vec<N>, ParsingError> {
+ let mut acc = Vec::new();
+ loop {
+ match N::qread(self).await {
+ Err(ParsingError::Recoverable) => match self.peek() {
+ Event::End(_) => return Ok(acc),
+ _ => {
+ self.skip().await?;
+ },
+ },
+ Ok(v) => acc.push(v),
+ Err(e) => return Err(e),
+ }
+ }
+ }
+
+ pub async fn open(&mut self, ns: &[u8], key: &str) -> Result<Event<'static>, ParsingError> {
+ if self.is_tag(ns, key) {
+ return self.next().await
+ }
+ return Err(ParsingError::Recoverable);
+ }
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-19 16:04:22 +0000