1 files changed, 43 insertions, 42 deletions

diff --git a/src/error.rs b/src/error.rs
index cf01895..65a1503 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -1,71 +1,72 @@
 use std::{
     collections::{HashMap, VecDeque},
     num::ParseIntError,
-    str::{FromStr, Utf8Error},
+    str::Utf8Error,
 };
 
-use crate::{
-    element::{Content, Name, NamespaceDeclaration},
-    Element,
-};
+use thiserror::Error;
+
+use crate::element::{Content, Name, NamespaceDeclaration};
 
-#[derive(Debug)]
+#[derive(Error, Debug)]
 pub enum DeserializeError {
+    #[error("could not parse string {0:?} to requested value")]
     FromStr(String),
+    #[error("unexpected attributes {0:?}")]
     UnexpectedAttributes(HashMap<Name, String>),
+    #[error("unexpected element content: {0:?}")]
     UnexpectedContent(VecDeque<Content>),
-    UnexpectedElement(Element),
+    #[error("attribute `{0:?}` missing")]
     MissingAttribute(Name),
-    IncorrectName(String),
-    IncorrectNamespace(String),
-    Unqualified,
+    #[error("incorrect localname: expected `{expected:?}`, found `{found:?}`")]
+    IncorrectName { expected: String, found: String },
+    #[error("incorrect namespace: expected `{expected:?}`, found `{found:?}`")]
+    IncorrectNamespace { expected: String, found: String },
+    #[error("unqualified namespace: expected `{expected:?}`")]
+    Unqualified { expected: String },
+    #[error("element missing expected child")]
     MissingChild,
+    #[error("element missing expected text value")]
     MissingValue,
 }
 
-#[derive(Debug)]
-// TODO: thiserror
+#[derive(Error, Debug)]
 pub enum Error {
-    ReadError(std::io::Error),
-    Utf8Error(Utf8Error),
+    #[error(transparent)]
+    ReadError(#[from] std::io::Error),
+    #[error(transparent)]
+    Utf8Error(#[from] Utf8Error),
+    #[error("nom parse error: {0}")]
     ParseError(String),
+    #[error("unknown xml entity reference `&{0};`")]
     EntityProcessError(String),
-    // TODO: better choice for failures than string
-    InvalidCharRef(String),
+    #[error(transparent)]
+    InvalidCharRef(CharRefError),
+    #[error("duplicate namespace declaration: {0:?}")]
     DuplicateNameSpaceDeclaration(NamespaceDeclaration),
+    #[error("duplicate attribute: {0}")]
     DuplicateAttribute(String),
-    UnqualifiedNamespace(String),
+    #[error("mismatched end tag: expected `{0:?}`, found `{1:?}`")]
     MismatchedEndTag(Name, Name),
+    #[error("not currently in any element")]
     NotInElement(String),
+    #[error("extra unexpected data included in complete parse: `{0}`")]
     ExtraData(String),
+    #[error("namespace `{0}` has not previously been declared")]
     UndeclaredNamespace(String),
-    IncorrectName(Name),
-    DeserializeError(String),
-    Deserialize(DeserializeError),
+    #[error(transparent)]
+    Deserialize(#[from] DeserializeError),
     /// root element end tag already processed
+    #[error("root element has already been fully processed")]
     RootElementEnded,
 }
 
-impl From<DeserializeError> for Error {
-    fn from(e: DeserializeError) -> Self {
-        Self::Deserialize(e)
-    }
-}
-
-impl From<std::io::Error> for Error {
-    fn from(e: std::io::Error) -> Self {
-        Self::ReadError(e)
-    }
-}
-
-impl From<Utf8Error> for Error {
-    fn from(e: Utf8Error) -> Self {
-        Self::Utf8Error(e)
-    }
-}
-
-impl From<ParseIntError> for Error {
-    fn from(e: ParseIntError) -> Self {
-        Self::InvalidCharRef(e.to_string())
-    }
+#[derive(Error, Debug)]
+pub enum CharRefError {
+    #[error(transparent)]
+    ParseInt(#[from] ParseIntError),
+    #[error("u32 `{0}` does not represent a valid char")]
+    IntegerNotAChar(u32),
+    #[error("`{0}` is not a valid xml char")]
+    InvalidXMLChar(char),
 }