Update dependencies and fix travis

4 files changed, 64 insertions, 82 deletions

diff --git a/src/binary/reader.rs b/src/binary/reader.rs
index 3999d83..ffb0caf 100644
--- a/src/binary/reader.rs
+++ b/src/binary/reader.rs
@@ -1,19 +1,10 @@
-use byteorder::{BigEndian, Error as ByteorderError, ReadBytesExt};
+use byteorder::{BigEndian, ReadBytesExt};
 use chrono::{TimeZone, UTC};
 use std::io::{Cursor, Read, Seek, SeekFrom};
 use std::string::{FromUtf8Error, FromUtf16Error};
 
 use {Error, Result, PlistEvent, u64_to_usize};
 
-impl From<ByteorderError> for Error {
-    fn from(err: ByteorderError) -> Error {
-        match err {
-            ByteorderError::UnexpectedEOF => Error::UnexpectedEof,
-            ByteorderError::Io(err) => Error::Io(err),
-        }
-    }
-}
-
 impl From<FromUtf8Error> for Error {
     fn from(_: FromUtf8Error) -> Error {
         Error::InvalidData
diff --git a/src/de.rs b/src/de.rs
index 06d316d..b796514 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -11,15 +11,15 @@ macro_rules! expect {
     ($next:expr, $pat:pat) => {
         match $next {
             Some(Ok(v@$pat)) => v,
-            None => return Err(DeserializeError::end_of_stream()),
-            _ => return Err(DeserializeError::syntax(""))
+            None => return Err(Error::UnexpectedEof),
+            _ => return return Err(event_mismatch_error())
         }
     };
     ($next:expr, $pat:pat => $save:expr) => {
         match $next {
             Some(Ok($pat)) => $save,
-            None => return Err(DeserializeError::end_of_stream()),
-            _ => return Err(DeserializeError::syntax(""))
+            None => return Err(Error::UnexpectedEof),
+            _ => return Err(event_mismatch_error())
         }
     };
 }
@@ -28,42 +28,23 @@ macro_rules! try_next {
     ($next:expr) => {
         match $next {
             Some(Ok(v)) => v,
-            Some(Err(_)) => return Err(DeserializeError::syntax("")),
-            None => return Err(DeserializeError::end_of_stream())
+            Some(Err(_)) => return Err(event_mismatch_error()),
+            None => return Err(Error::UnexpectedEof)
         }
     }
 }
 
-#[derive(Debug)]
-pub enum DeserializeError {
-    Syntax,
-    EndOfStream,
-    UnknownField,
-    MissingField,
-    Reader(Error),
+fn event_mismatch_error() -> Error {
+    Error::InvalidData
 }
 
-impl From<Error> for DeserializeError {
-    fn from(err: Error) -> DeserializeError {
-        DeserializeError::Reader(err)
-    }
-}
-
-impl SerdeError for DeserializeError {
-    fn syntax(_msg: &str) -> Self {
-        DeserializeError::Syntax
+impl SerdeError for Error {
+    fn custom<T: Into<String>>(msg: T) -> Self {
+        Error::Serde(msg.into())
     }
 
     fn end_of_stream() -> Self {
-        DeserializeError::EndOfStream
-    }
-
-    fn unknown_field(_field: &str) -> Self {
-        DeserializeError::UnknownField
-    }
-
-    fn missing_field(_field: &'static str) -> Self {
-        DeserializeError::MissingField
+        Error::UnexpectedEof
     }
 }
 
@@ -83,9 +64,9 @@ impl<I> Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>>
 impl<I> SerdeDeserializer for Deserializer<I>
     where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
-    type Error = DeserializeError;
+    type Error = Error;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
         match try_next!(self.events.next()) {
@@ -93,13 +74,13 @@ impl<I> SerdeDeserializer for Deserializer<I>
                 let len = try!(u64_option_to_usize(len));
                 visitor.visit_seq(MapSeq::new(self, len))
             }
-            PlistEvent::EndArray => return Err(DeserializeError::syntax("")),
+            PlistEvent::EndArray => return Err(event_mismatch_error()),
 
             PlistEvent::StartDictionary(len) => {
                 let len = try!(u64_option_to_usize(len));
                 visitor.visit_map(MapSeq::new(self, len))
             }
-            PlistEvent::EndDictionary => return Err(DeserializeError::syntax("")),
+            PlistEvent::EndDictionary => return Err(event_mismatch_error()),
 
             PlistEvent::BooleanValue(v) => visitor.visit_bool(v),
             PlistEvent::DataValue(v) => visitor.visit_byte_buf(v),
@@ -111,14 +92,14 @@ impl<I> SerdeDeserializer for Deserializer<I>
         }
     }
 
-    fn visit_unit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_unit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
         expect!(self.events.next(), PlistEvent::StringValue(_));
         visitor.visit_unit()
     }
 
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
         expect!(self.events.next(), PlistEvent::StartDictionary(_));
@@ -136,7 +117,7 @@ impl<I> SerdeDeserializer for Deserializer<I>
                 ret
             }
             PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)),
-            _ => return Err(DeserializeError::syntax("")),
+            _ => return Err(event_mismatch_error()),
         };
 
         expect!(self.events.next(), PlistEvent::EndDictionary);
@@ -144,7 +125,7 @@ impl<I> SerdeDeserializer for Deserializer<I>
         Ok(ret)
     }
 
-    fn visit_newtype_struct<V>(&mut self,
+    fn deserialize_newtype_struct<V>(&mut self,
                                _name: &'static str,
                                mut visitor: V)
                                -> Result<V::Value, Self::Error>
@@ -153,7 +134,7 @@ impl<I> SerdeDeserializer for Deserializer<I>
         visitor.visit_newtype_struct(self)
     }
 
-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                      _enum: &'static str,
                      _variants: &'static [&'static str],
                      mut visitor: V)
@@ -169,7 +150,7 @@ impl<I> SerdeDeserializer for Deserializer<I>
 
 impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>>
 {
-    type Error = DeserializeError;
+    type Error = Error;
 
     fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
         where V: Deserialize
@@ -190,7 +171,7 @@ impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<P
     fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
         where V: Visitor
     {
-        <Self as SerdeDeserializer>::visit_tuple(self, len, visitor)
+        <Self as SerdeDeserializer>::deserialize_tuple(self, len, visitor)
     }
 
     fn visit_struct<V>(&mut self,
@@ -200,7 +181,7 @@ impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<P
         where V: Visitor
     {
         let name = "";
-        <Self as SerdeDeserializer>::visit_struct(self, name, fields, visitor)
+        <Self as SerdeDeserializer>::deserialize_struct(self, name, fields, visitor)
     }
 }
 
@@ -226,7 +207,7 @@ impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, E
 impl<'a, I> SeqVisitor for MapSeq<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
-    type Error = DeserializeError;
+    type Error = Error;
 
     fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
         where T: Deserialize
@@ -257,7 +238,7 @@ impl<'a, I> SeqVisitor for MapSeq<'a, I>
 impl<'a, I> MapVisitor for MapSeq<'a, I>
     where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
 {
-    type Error = DeserializeError;
+    type Error = Error;
 
     fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
         where K: Deserialize
diff --git a/src/lib.rs b/src/lib.rs
index 4d6ccab..d036d52 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -48,7 +48,7 @@ mod builder;
 mod de;
 mod ser;
 
-pub use de::{Deserializer, DeserializeError};
+pub use de::Deserializer;
 pub use ser::Serializer;
 
 use chrono::{DateTime, UTC};
@@ -58,9 +58,7 @@ use std::fmt;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::io::Error as IoError;
 
-pub fn deserialize<R: Read + Seek, T: Deserialize>
-    (reader: R)
-     -> ::std::result::Result<T, DeserializeError> {
+pub fn deserialize<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> {
     let reader = EventReader::new(reader);
     let mut de = Deserializer::new(reader);
     Deserialize::deserialize(&mut de)
@@ -308,6 +306,7 @@ pub enum Error {
     InvalidData,
     UnexpectedEof,
     Io(IoError),
+    Serde(String)
 }
 
 impl ::std::error::Error for Error {
@@ -316,6 +315,7 @@ impl ::std::error::Error for Error {
             Error::InvalidData => "invalid data",
             Error::UnexpectedEof => "unexpected eof",
             Error::Io(ref err) => err.description(),
+            Error::Serde(ref err) => &err
         }
     }
 
diff --git a/src/ser.rs b/src/ser.rs
index 450aec7..54294b5 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -1,10 +1,20 @@
 // Tests for the serializer and deserializer are located in tests/serde_/mod.rs.
 // They can be run with `cargo test --features serde_tests`.
 
-use serde::ser::{MapVisitor, Serialize, Serializer as SerdeSerializer, SeqVisitor};
+use serde::ser::{Error as SerdeError, MapVisitor, Serialize, Serializer as SerdeSerializer, SeqVisitor};
 
 use {Error, EventWriter, PlistEvent};
 
+impl SerdeError for Error {
+    fn custom<T: Into<String>>(msg: T) -> Self {
+        Error::Serde(msg.into())
+    }
+
+    fn invalid_value(_: &str) -> Self {
+        Error::InvalidData
+    }
+}
+
 pub struct Serializer<W: EventWriter> {
     writer: W,
 }
@@ -41,46 +51,46 @@ impl<W: EventWriter> Serializer<W> {
 impl<W: EventWriter> SerdeSerializer for Serializer<W> {
     type Error = Error;
 
-    fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error> {
+    fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error> {
         self.emit(PlistEvent::BooleanValue(v))
     }
 
-    fn visit_i64(&mut self, v: i64) -> Result<(), Self::Error> {
+    fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> {
         self.emit(PlistEvent::IntegerValue(v))
     }
 
-    fn visit_u64(&mut self, v: u64) -> Result<(), Self::Error> {
+    fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> {
         self.emit(PlistEvent::IntegerValue(v as i64))
     }
 
-    fn visit_f64(&mut self, v: f64) -> Result<(), Self::Error> {
+    fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> {
         self.emit(PlistEvent::RealValue(v))
     }
 
-    fn visit_str(&mut self, value: &str) -> Result<(), Self::Error> {
+    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> {
         self.emit(PlistEvent::StringValue(value.to_owned()))
     }
 
-    fn visit_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
         self.emit(PlistEvent::DataValue(value.to_owned()))
     }
 
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+    fn serialize_unit(&mut self) -> Result<(), Self::Error> {
         // Emit empty string
         self.emit(PlistEvent::StringValue(String::new()))
     }
 
-    fn visit_none(&mut self) -> Result<(), Self::Error> {
-        self.single_key_dict("None".to_owned(), |this| this.visit_unit())
+    fn serialize_none(&mut self) -> Result<(), Self::Error> {
+        self.single_key_dict("None".to_owned(), |this| this.serialize_unit())
     }
 
-    fn visit_some<V>(&mut self, value: V) -> Result<(), Self::Error>
+    fn serialize_some<V>(&mut self, value: V) -> Result<(), Self::Error>
         where V: Serialize
     {
         self.single_key_dict("Some".to_owned(), |this| value.serialize(this))
     }
 
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
+    fn serialize_seq<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
         where V: SeqVisitor
     {
         let len = visitor.len().map(|len| len as u64);
@@ -95,13 +105,13 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         Ok(())
     }
 
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
         where T: Serialize
     {
         value.serialize(self)
     }
 
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
+    fn serialize_map<V>(&mut self, mut visitor: V) -> Result<(), Self::Error>
         where V: MapVisitor
     {
         let len = visitor.len().map(|len| len as u64);
@@ -116,7 +126,7 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         Ok(())
     }
 
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
         where K: Serialize,
               V: Serialize
     {
@@ -125,21 +135,21 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         Ok(())
     }
 
-    fn visit_unit_variant(&mut self,
+    fn serialize_unit_variant(&mut self,
                           _name: &'static str,
                           _variant_index: usize,
                           variant: &'static str)
                           -> Result<(), Self::Error> {
-        self.single_key_dict(variant.to_owned(), |this| this.visit_unit())
+        self.single_key_dict(variant.to_owned(), |this| this.serialize_unit())
     }
 
-    fn visit_newtype_struct<T>(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error>
+    fn serialize_newtype_struct<T>(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error>
         where T: Serialize
     {
         value.serialize(self)
     }
 
-    fn visit_newtype_variant<T>(&mut self,
+    fn serialize_newtype_variant<T>(&mut self,
                                 _name: &'static str,
                                 _variant_index: usize,
                                 variant: &'static str,
@@ -150,7 +160,7 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         self.single_key_dict(variant.to_owned(), |this| value.serialize(this))
     }
 
-    fn visit_tuple_variant<V>(&mut self,
+    fn serialize_tuple_variant<V>(&mut self,
                               _name: &'static str,
                               _variant_index: usize,
                               variant: &'static str,
@@ -159,10 +169,10 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         where V: SeqVisitor
     {
         self.single_key_dict(variant.to_owned(),
-                             |this| this.visit_tuple_struct(variant, visitor))
+                             |this| this.serialize_tuple_struct(variant, visitor))
     }
 
-    fn visit_struct_variant<V>(&mut self,
+    fn serialize_struct_variant<V>(&mut self,
                                _name: &'static str,
                                _variant_index: usize,
                                variant: &'static str,
@@ -171,6 +181,6 @@ impl<W: EventWriter> SerdeSerializer for Serializer<W> {
         where V: MapVisitor
     {
         self.single_key_dict(variant.to_owned(),
-                             |this| this.visit_struct(variant, visitor))
+                             |this| this.serialize_struct(variant, visitor))
     }
 }