update quick_xml and migrate from error-chain to failure

Cargo.toml

@@ -20,5 +20,6 @@ license = "MIT"
 gitlab = { repository = "lumi/minidom-rs" }
 
 [dependencies]
-quick-xml = "0.10.0"
-error-chain = "0.11.0"
+quick-xml = "0.11.0"
+failure = "0.1.1"
+failure_derive = "0.1.1"

src/element.rs

@@ -7,7 +7,7 @@ use std::str;
 use std::rc::Rc;
 use std::borrow::Cow;
 
-use error::{Error, ErrorKind, Result};
+use error::{Error, Result};
 
 use quick_xml::reader::Reader as EventReader;
 use quick_xml::events::{Event, BytesStart};
@@ -309,7 +309,7 @@ impl Element {
                     break build_element(reader, e)?;
                 },
                 Event::Eof => {
-                    bail!(ErrorKind::EndOfDocument);
+                    return Err(Error::EndOfDocument);
                 },
                 Event::Text { .. } |
                 Event::End { .. } |
@@ -349,23 +349,23 @@ impl Element {
                                 match elem.prefix() {
                                     Some(prefix) => {
                                         if possible_prefix != prefix.as_bytes() {
-                                            bail!(ErrorKind::InvalidElementClosed);
+                                            return Err(Error::InvalidElementClosed);
                                         }
                                     },
                                     None => {
-                                        bail!(ErrorKind::InvalidElementClosed);
+                                        return Err(Error::InvalidElementClosed);
                                     },
                                 }
                                 if name != elem.name().as_bytes() {
-                                    bail!(ErrorKind::InvalidElementClosed);
+                                    return Err(Error::InvalidElementClosed);
                                 }
                             },
                             None => {
                                 if elem.prefix().is_some() {
-                                    bail!(ErrorKind::InvalidElementClosed);
+                                    return Err(Error::InvalidElementClosed);
                                 }
                                 if possible_prefix != elem.name().as_bytes() {
-                                    bail!(ErrorKind::InvalidElementClosed);
+                                    return Err(Error::InvalidElementClosed);
                                 }
                             },
                         }
@@ -676,7 +676,7 @@ fn split_element_name<S: AsRef<str>>(s: S) -> Result<(Option<String>, String)> {
     match name_parts.len() {
         2 => Ok((Some(name_parts[0].to_owned()), name_parts[1].to_owned())),
         1 => Ok((None, name_parts[0].to_owned())),
-        _ => bail!(ErrorKind::InvalidElement),
+        _ => Err(Error::InvalidElement),
     }
 }
 

src/error.rs

@@ -2,34 +2,51 @@
 
 use std::convert::From;
 
-error_chain! {
-    foreign_links {
-        XmlError(::quick_xml::errors::Error)
+/// Our main error type.
+#[derive(Debug, Fail)]
+pub enum Error {
     /// An error from quick_xml.
-        ;
-        Utf8Error(::std::str::Utf8Error)
-            /// An UTF-8 conversion error.
-        ;
-        IoError(::std::io::Error)
-            /// An I/O error, from std::io.
-        ;
-    }
+    #[fail(display = "XML error: {}", _0)]
+    XmlError(#[cause] ::quick_xml::errors::Error),
+
+    /// An UTF-8 conversion error.
+    #[fail(display = "UTF-8 error: {}", _0)]
+    Utf8Error(#[cause] ::std::str::Utf8Error),
+
+    /// An I/O error, from std::io.
+    #[fail(display = "IO error: {}", _0)]
+    IoError(#[cause] ::std::io::Error),
 
-    errors {
     /// An error which is returned when the end of the document was reached prematurely.
-        EndOfDocument {
-            description("the end of the document has been reached prematurely")
-            display("the end of the document has been reached prematurely")
-        }
+    #[fail(display = "the end of the document has been reached prematurely")]
+    EndOfDocument,
+
     /// An error which is returned when an element is closed when it shouldn't be
-        InvalidElementClosed {
-            description("The XML is invalid, an element was wrongly closed")
-            display("the XML is invalid, an element was wrongly closed")
-        }
+    #[fail(display = "the XML is invalid, an element was wrongly closed")]
+    InvalidElementClosed,
+
     /// An error which is returned when an elemet's name contains more than one colon
-        InvalidElement {
-            description("The XML element is invalid")
-            display("the XML element is invalid")
-        }
+    #[fail(display = "the XML element is invalid")]
+    InvalidElement,
+}
+
+impl From<::quick_xml::errors::Error> for Error {
+    fn from(err: ::quick_xml::errors::Error) -> Error {
+        Error::XmlError(err)
     }
 }
+
+impl From<::std::str::Utf8Error> for Error {
+    fn from(err: ::std::str::Utf8Error) -> Error {
+        Error::Utf8Error(err)
+    }
+}
+
+impl From<::std::io::Error> for Error {
+    fn from(err: ::std::io::Error) -> Error {
+        Error::IoError(err)
+    }
+}
+
+/// Our simplified Result type.
+pub type Result<T> = ::std::result::Result<T, Error>;

src/lib.rs

@@ -65,7 +65,8 @@
 //! ```
 
 extern crate quick_xml;
-#[macro_use] extern crate error_chain;
+extern crate failure;
+#[macro_use] extern crate failure_derive;
 
 pub mod error;
 pub mod element;
@@ -74,6 +75,6 @@ mod namespace_set;
 
 #[cfg(test)] mod tests;
 
-pub use error::{Error, ErrorKind, Result, ResultExt};
+pub use error::{Error, Result};
 pub use element::{Element, Node, Children, ChildrenMut, ElementBuilder};
 pub use convert::{IntoElements, IntoAttributeValue, ElementEmitter};

src/tests.rs

@@ -201,12 +201,12 @@ fn namespace_inherited_prefixed2() {
 #[test]
 fn xml_error() {
     match "<a></b>".parse::<Element>() {
-        Err(::error::Error(::error::ErrorKind::XmlError(_), _)) => (),
+        Err(::error::Error::XmlError(_)) => (),
         err => panic!("No or wrong error: {:?}", err)
     }
 
     match "<a></".parse::<Element>() {
-        Err(::error::Error(::error::ErrorKind::XmlError(_), _)) => (),
+        Err(::error::Error::XmlError(_)) => (),
         err => panic!("No or wrong error: {:?}", err)
     }
 }
@@ -214,7 +214,7 @@ fn xml_error() {
 #[test]
 fn invalid_element_error() {
     match "<a:b:c>".parse::<Element>() {
-        Err(::error::Error(::error::ErrorKind::InvalidElement, _)) => (),
+        Err(::error::Error::InvalidElement) => (),
         err => panic!("No or wrong error: {:?}", err)
     }
 }