parsers: use Error type from xso

This is a large change and as such, it needs good motivation. Let me
remind you of the ultimate goal: we want a derive macro which allows us
to FromXml/IntoXml, and that derive macro should be usable from
`xmpp_parsers` and other crates.

For that, any code generated by the derive macro mustn't depend on any
code in the `xmpp_parsers` crate, because you cannot name the crate you
are in portably (`xmpp_parsers::..` wouldn't resolve within
`xmpp_parsers`, and `crate::..` would point at other crates if the macro
was used in other crates).

We also want to interoperate with code already implementing
`TryFrom<Element>` and `Into<Element>` on structs. This ultimately
requires that we have an error type which is shared by the two
implementations and that error type must be declared in the `xso` crate
to be usable by the macros.

Thus, we port the error type over to use the type declared in `xso`.

This changes the structure of the error type greatly; I do not think
that `xso` should have to know about all the different types we are
parsing there and they don't deserve special treatment. Wrapping them in
a `Box<dyn ..>` seems more appropriate.

xso/src/error.rs

@@ -23,7 +23,7 @@ pub enum Error {
     TextParseError(Box<dyn std::error::Error + Send + Sync + 'static>),
 
     /// Generic, unspecified other error.
-    Other(Box<str>),
+    Other(&'static str),
 
     /// An element header did not match an expected element.
     ///
@@ -33,6 +33,16 @@ pub enum Error {
     TypeMismatch,
 }
 
+impl Error {
+    /// Convenience function to create a [`Self::TextParseError`] variant.
+    ///
+    /// This includes the `Box::new(.)` call, making it directly usable as
+    /// argument to [`Result::map_err`].
+    pub fn text_parse_error<T: std::error::Error + Send + Sync + 'static>(e: T) -> Self {
+        Self::TextParseError(Box::new(e))
+    }
+}
+
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -121,3 +131,75 @@ impl std::error::Error for FromEventsError {
         }
     }
 }
+
+impl From<Error> for Result<minidom::Element, Error> {
+    fn from(other: Error) -> Self {
+        Self::Err(other)
+    }
+}
+
+/// Error returned by the `TryFrom<Element>` implementations.
+#[derive(Debug)]
+pub enum FromElementError {
+    /// The XML element header did not match the expectations of the type
+    /// implementing `TryFrom`.
+    ///
+    /// Contains the original `Element` unmodified.
+    Mismatch(minidom::Element),
+
+    /// During processing of the element, an (unrecoverable) error occured.
+    Invalid(Error),
+}
+
+impl fmt::Display for FromElementError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Mismatch(ref el) => write!(
+                f,
+                "expected different XML element (got {} in namespace {})",
+                el.name(),
+                el.ns()
+            ),
+            Self::Invalid(ref e) => fmt::Display::fmt(e, f),
+        }
+    }
+}
+
+impl std::error::Error for FromElementError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match self {
+            Self::Mismatch(_) => None,
+            Self::Invalid(ref e) => Some(e),
+        }
+    }
+}
+
+impl From<Result<minidom::Element, Error>> for FromElementError {
+    fn from(other: Result<minidom::Element, Error>) -> Self {
+        match other {
+            Ok(v) => Self::Mismatch(v),
+            Err(e) => Self::Invalid(e),
+        }
+    }
+}
+
+impl From<Error> for FromElementError {
+    fn from(other: Error) -> Self {
+        Self::Invalid(other)
+    }
+}
+
+impl From<FromElementError> for Error {
+    fn from(other: FromElementError) -> Self {
+        match other {
+            FromElementError::Invalid(e) => e,
+            FromElementError::Mismatch(..) => Self::TypeMismatch,
+        }
+    }
+}
+
+impl From<core::convert::Infallible> for FromElementError {
+    fn from(other: core::convert::Infallible) -> Self {
+        match other {}
+    }
+}

xso/src/lib.rs

@@ -138,3 +138,38 @@ pub fn transform<T: FromXml, F: IntoXml>(from: F) -> Result<T, self::error::Erro
         rxml::error::XmlError::InvalidEof("during transform"),
     ))
 }
+
+/// Attempt to convert a [`minidom::Element`] into a type implementing
+/// [`FromXml`], fallably.
+///
+/// Unlike [`transform`] (which can also be used with an element), this
+/// function will return the element unharmed if its element header does not
+/// match the expectations of `T`.
+pub fn try_from_element<T: FromXml>(
+    from: minidom::Element,
+) -> Result<T, self::error::FromElementError> {
+    let (qname, attrs) = minidom_compat::make_start_ev_parts(&from)?;
+    let mut sink = match T::from_events(qname, attrs) {
+        Ok(v) => v,
+        Err(self::error::FromEventsError::Mismatch { .. }) => {
+            return Err(self::error::FromElementError::Mismatch(from))
+        }
+        Err(self::error::FromEventsError::Invalid(e)) => {
+            return Err(self::error::FromElementError::Invalid(e))
+        }
+    };
+
+    let mut iter = from.into_event_iter()?;
+    iter.next().expect("first event from minidom::Element")?;
+    for event in iter {
+        let event = event?;
+        match sink.feed(event)? {
+            Some(v) => return Ok(v),
+            None => (),
+        }
+    }
+    // unreachable! instead of error here, because minidom::Element always
+    // produces the complete event sequence of a single element, and FromXml
+    // implementations must be constructible from that.
+    unreachable!("minidom::Element did not produce enough events to complete element")
+}

xso/src/minidom_compat.rs

@@ -55,7 +55,7 @@ enum IntoEventsInner {
 // NOTE to developers: The limitations are not fully trivial to overcome:
 // the attributes use a BTreeMap internally, which does not offer a `drain`
 // iterator.
-fn make_start_ev_parts(el: &Element) -> Result<(rxml::QName, AttrMap), Error> {
+pub fn make_start_ev_parts(el: &Element) -> Result<(rxml::QName, AttrMap), Error> {
     let name = NcName::try_from(el.name())?;
     let namespace = Namespace::from(el.ns());