From d7e30166bc55f81b8c3391915c201af7dca0ce44 Mon Sep 17 00:00:00 2001 From: Edward Barnard Date: Sun, 3 Apr 2016 14:59:17 +0100 Subject: Update dependencies and fix travis --- src/binary/reader.rs | 11 +------- src/de.rs | 71 +++++++++++++++++++--------------------------------- src/lib.rs | 8 +++--- src/ser.rs | 56 ++++++++++++++++++++++++----------------- 4 files changed, 64 insertions(+), 82 deletions(-) (limited to 'src') 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 for Error { - fn from(err: ByteorderError) -> Error { - match err { - ByteorderError::UnexpectedEOF => Error::UnexpectedEof, - ByteorderError::Io(err) => Error::Io(err), - } - } -} - impl From 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 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>(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 Deserializer where I: IntoIterator> impl SerdeDeserializer for Deserializer where I: IntoIterator> { - type Error = DeserializeError; + type Error = Error; - fn visit(&mut self, mut visitor: V) -> Result + fn deserialize(&mut self, mut visitor: V) -> Result where V: Visitor { match try_next!(self.events.next()) { @@ -93,13 +74,13 @@ impl SerdeDeserializer for Deserializer 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 SerdeDeserializer for Deserializer } } - fn visit_unit(&mut self, mut visitor: V) -> Result + fn deserialize_unit(&mut self, mut visitor: V) -> Result where V: Visitor { expect!(self.events.next(), PlistEvent::StringValue(_)); visitor.visit_unit() } - fn visit_option(&mut self, mut visitor: V) -> Result + fn deserialize_option(&mut self, mut visitor: V) -> Result where V: Visitor { expect!(self.events.next(), PlistEvent::StartDictionary(_)); @@ -136,7 +117,7 @@ impl SerdeDeserializer for Deserializer 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 SerdeDeserializer for Deserializer Ok(ret) } - fn visit_newtype_struct(&mut self, + fn deserialize_newtype_struct(&mut self, _name: &'static str, mut visitor: V) -> Result @@ -153,7 +134,7 @@ impl SerdeDeserializer for Deserializer visitor.visit_newtype_struct(self) } - fn visit_enum(&mut self, + fn deserialize_enum(&mut self, _enum: &'static str, _variants: &'static [&'static str], mut visitor: V) @@ -169,7 +150,7 @@ impl SerdeDeserializer for Deserializer impl VariantVisitor for Deserializer where I: IntoIterator> { - type Error = DeserializeError; + type Error = Error; fn visit_variant(&mut self) -> Result where V: Deserialize @@ -190,7 +171,7 @@ impl VariantVisitor for Deserializer where I: IntoIterator(&mut self, len: usize, visitor: V) -> Result where V: Visitor { - ::visit_tuple(self, len, visitor) + ::deserialize_tuple(self, len, visitor) } fn visit_struct(&mut self, @@ -200,7 +181,7 @@ impl VariantVisitor for Deserializer where I: IntoIterator::visit_struct(self, name, fields, visitor) + ::deserialize_struct(self, name, fields, visitor) } } @@ -226,7 +207,7 @@ impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator SeqVisitor for MapSeq<'a, I> where I: 'a + IntoIterator> { - type Error = DeserializeError; + type Error = Error; fn visit(&mut self) -> Result, 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> { - type Error = DeserializeError; + type Error = Error; fn visit_key(&mut self) -> Result, 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 - (reader: R) - -> ::std::result::Result { +pub fn deserialize(reader: R) -> Result { 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>(msg: T) -> Self { + Error::Serde(msg.into()) + } + + fn invalid_value(_: &str) -> Self { + Error::InvalidData + } +} + pub struct Serializer { writer: W, } @@ -41,46 +51,46 @@ impl Serializer { impl SerdeSerializer for Serializer { 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(&mut self, value: V) -> Result<(), Self::Error> + fn serialize_some(&mut self, value: V) -> Result<(), Self::Error> where V: Serialize { self.single_key_dict("Some".to_owned(), |this| value.serialize(this)) } - fn visit_seq(&mut self, mut visitor: V) -> Result<(), Self::Error> + fn serialize_seq(&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 SerdeSerializer for Serializer { Ok(()) } - fn visit_seq_elt(&mut self, value: T) -> Result<(), Self::Error> + fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> where T: Serialize { value.serialize(self) } - fn visit_map(&mut self, mut visitor: V) -> Result<(), Self::Error> + fn serialize_map(&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 SerdeSerializer for Serializer { Ok(()) } - fn visit_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> + fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize { @@ -125,21 +135,21 @@ impl SerdeSerializer for Serializer { 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(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error> + fn serialize_newtype_struct(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error> where T: Serialize { value.serialize(self) } - fn visit_newtype_variant(&mut self, + fn serialize_newtype_variant(&mut self, _name: &'static str, _variant_index: usize, variant: &'static str, @@ -150,7 +160,7 @@ impl SerdeSerializer for Serializer { self.single_key_dict(variant.to_owned(), |this| value.serialize(this)) } - fn visit_tuple_variant(&mut self, + fn serialize_tuple_variant(&mut self, _name: &'static str, _variant_index: usize, variant: &'static str, @@ -159,10 +169,10 @@ impl SerdeSerializer for Serializer { 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(&mut self, + fn serialize_struct_variant(&mut self, _name: &'static str, _variant_index: usize, variant: &'static str, @@ -171,6 +181,6 @@ impl SerdeSerializer for Serializer { where V: MapVisitor { self.single_key_dict(variant.to_owned(), - |this| this.visit_struct(variant, visitor)) + |this| this.serialize_struct(variant, visitor)) } } -- cgit v1.2.3