From b8787a29a3a8d4bdeedecccbd2ab3a9b386f7683 Mon Sep 17 00:00:00 2001 From: Edward Barnard Date: Sat, 7 Jan 2017 10:53:37 +0000 Subject: Support Serde 0.8. Bump minimum Rust version to 0.15. --- .travis.yml | 2 +- Cargo.toml | 10 +- src/de.rs | 276 --------------------------------------- src/lib.rs | 26 +--- src/ser.rs | 186 --------------------------- src/serde/de.rs | 285 ++++++++++++++++++++++++++++++++++++++++ src/serde/mod.rs | 24 ++++ src/serde/ser.rs | 329 +++++++++++++++++++++++++++++++++++++++++++++++ tests/serde_/mod.rs | 209 ------------------------------ tests/serde_tests.rs.in | 4 - tests/serde_tests/mod.rs | 207 +++++++++++++++++++++++++++++ tests/tests.rs | 12 +- 12 files changed, 869 insertions(+), 701 deletions(-) delete mode 100644 src/de.rs delete mode 100644 src/ser.rs create mode 100644 src/serde/de.rs create mode 100644 src/serde/mod.rs create mode 100644 src/serde/ser.rs delete mode 100644 tests/serde_/mod.rs delete mode 100644 tests/serde_tests.rs.in create mode 100644 tests/serde_tests/mod.rs diff --git a/.travis.yml b/.travis.yml index de2a24c..8d089d5 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,7 +4,7 @@ rust: - nightly - beta - stable -- 1.8.0 +- 1.15.0 before_script: - | pip install 'travis-cargo<0.2' --user && diff --git a/Cargo.toml b/Cargo.toml index 03a63cb..f215f62 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,14 +10,16 @@ keywords = ["plist", "parser"] build = "build.rs" [features] -serde_tests = ["serde_codegen"] +default = ["serde_serialization"] +serde_serialization = ["serde"] [dependencies] rustc-serialize = "0.3.19" xml-rs = "0.3.4" byteorder = "0.5.3" chrono = "0.2.22" -serde = "0.7.10" +serde = { version = "0.8.21", optional = true } -[build-dependencies] -serde_codegen = { version = "0.7.10", optional = true } +[dev-dependencies] +# Should be an optional dependency on serde_serialization +serde_derive = { version = "0.8.21" } diff --git a/src/de.rs b/src/de.rs deleted file mode 100644 index 1d9531c..0000000 --- a/src/de.rs +++ /dev/null @@ -1,276 +0,0 @@ -// 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::de::{Deserializer as SerdeDeserializer, Error as SerdeError, Visitor, SeqVisitor, - MapVisitor, VariantVisitor, Deserialize, EnumVisitor}; -use std::iter::Peekable; - -use {Error, PlistEvent, u64_option_to_usize}; - -macro_rules! expect { - ($next:expr, $pat:pat) => { - match $next { - Some(Ok(v@$pat)) => v, - None => return Err(Error::UnexpectedEof), - _ => return Err(event_mismatch_error()) - } - }; - ($next:expr, $pat:pat => $save:expr) => { - match $next { - Some(Ok($pat)) => $save, - None => return Err(Error::UnexpectedEof), - _ => return Err(event_mismatch_error()) - } - }; -} - -macro_rules! try_next { - ($next:expr) => { - match $next { - Some(Ok(v)) => v, - Some(Err(_)) => return Err(event_mismatch_error()), - None => return Err(Error::UnexpectedEof) - } - } -} - -fn event_mismatch_error() -> Error { - Error::InvalidData -} - -impl SerdeError for Error { - fn custom>(msg: T) -> Self { - Error::Serde(msg.into()) - } - - fn end_of_stream() -> Self { - Error::UnexpectedEof - } -} - -pub struct Deserializer - where I: IntoIterator> -{ - events: Peekable<::IntoIter>, -} - -impl Deserializer where I: IntoIterator> -{ - pub fn new(iter: I) -> Deserializer { - Deserializer { events: iter.into_iter().peekable() } - } -} - -impl SerdeDeserializer for Deserializer - where I: IntoIterator> -{ - type Error = Error; - - fn deserialize(&mut self, mut visitor: V) -> Result - where V: Visitor - { - match try_next!(self.events.next()) { - PlistEvent::StartArray(len) => { - let len = try!(u64_option_to_usize(len)); - visitor.visit_seq(MapSeq::new(self, len)) - } - 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(event_mismatch_error()), - - PlistEvent::BooleanValue(v) => visitor.visit_bool(v), - PlistEvent::DataValue(v) => visitor.visit_byte_buf(v), - PlistEvent::DateValue(v) => visitor.visit_string(v.to_rfc3339()), - PlistEvent::IntegerValue(v) if v.is_positive() => visitor.visit_u64(v as u64), - PlistEvent::IntegerValue(v) => visitor.visit_i64(v as i64), - PlistEvent::RealValue(v) => visitor.visit_f64(v), - PlistEvent::StringValue(v) => visitor.visit_string(v), - } - } - - fn deserialize_unit(&mut self, mut visitor: V) -> Result - where V: Visitor - { - expect!(self.events.next(), PlistEvent::StringValue(_)); - visitor.visit_unit() - } - - fn deserialize_option(&mut self, mut visitor: V) -> Result - where V: Visitor - { - expect!(self.events.next(), PlistEvent::StartDictionary(_)); - - let ret = match try_next!(self.events.next()) { - PlistEvent::StringValue(ref s) if &s[..] == "None" => { - let ret = match visitor.visit_none() { - Ok(ret) => ret, - Err(e) => return Err(e), - }; - // For some reason the try! below doesn't work - probably a macro hygene issue - // with Error and ::Error - // let ret = try!(visitor.visit_none()); - expect!(self.events.next(), PlistEvent::StringValue(_)); - ret - } - PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)), - _ => return Err(event_mismatch_error()), - }; - - expect!(self.events.next(), PlistEvent::EndDictionary); - - Ok(ret) - } - - fn deserialize_newtype_struct(&mut self, - _name: &'static str, - mut visitor: V) - -> Result - where V: Visitor - { - visitor.visit_newtype_struct(self) - } - - fn deserialize_enum(&mut self, - _enum: &'static str, - _variants: &'static [&'static str], - mut visitor: V) - -> Result - where V: EnumVisitor - { - expect!(self.events.next(), PlistEvent::StartDictionary(_)); - let ret = try!(visitor.visit(&mut *self)); - expect!(self.events.next(), PlistEvent::EndDictionary); - Ok(ret) - } -} - -impl VariantVisitor for Deserializer where I: IntoIterator> -{ - type Error = Error; - - fn visit_variant(&mut self) -> Result - where V: Deserialize - { - ::deserialize(self) - } - - fn visit_unit(&mut self) -> Result<(), Self::Error> { - <() as Deserialize>::deserialize(self) - } - - fn visit_newtype(&mut self) -> Result - where T: Deserialize - { - ::deserialize(self) - } - - fn visit_tuple(&mut self, len: usize, visitor: V) -> Result - where V: Visitor - { - ::deserialize_tuple(self, len, visitor) - } - - fn visit_struct(&mut self, - fields: &'static [&'static str], - visitor: V) - -> Result - where V: Visitor - { - let name = ""; - ::deserialize_struct(self, name, fields, visitor) - } -} - -struct MapSeq<'a, I> - where I: 'a + IntoIterator> -{ - de: &'a mut Deserializer, - remaining: Option, - finished: bool, -} - -impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator> -{ - fn new(de: &'a mut Deserializer, len: Option) -> MapSeq<'a, I> { - MapSeq { - de: de, - remaining: len, - finished: false, - } - } -} - -impl<'a, I> SeqVisitor for MapSeq<'a, I> - where I: 'a + IntoIterator> -{ - type Error = Error; - - fn visit(&mut self) -> Result, Self::Error> - where T: Deserialize - { - match self.de.events.peek() { - Some(&Ok(PlistEvent::EndArray)) => { - self.de.events.next(); - self.finished = true; - return Ok(None); - } - _ => ::deserialize(self.de).map(|k| Some(k)), - } - } - - fn end(&mut self) -> Result<(), Self::Error> { - if !self.finished { - self.finished = true; - expect!(self.de.events.next(), PlistEvent::EndArray); - } - Ok(()) - } - - fn size_hint(&self) -> (usize, Option) { - ::size_hint(self) - } -} - -impl<'a, I> MapVisitor for MapSeq<'a, I> - where I: 'a + IntoIterator> -{ - type Error = Error; - - fn visit_key(&mut self) -> Result, Self::Error> - where K: Deserialize - { - match self.de.events.peek() { - Some(&Ok(PlistEvent::EndDictionary)) => { - self.de.events.next(); - self.finished = true; - return Ok(None); - } - _ => ::deserialize(self.de).map(|k| Some(k)), - } - } - - fn visit_value(&mut self) -> Result - where V: Deserialize - { - ::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Self::Error> { - if !self.finished { - self.finished = true; - expect!(self.de.events.next(), PlistEvent::EndDictionary); - } - Ok(()) - } - - fn size_hint(&self) -> (usize, Option) { - match self.remaining { - Some(len) => (len, Some(len)), - None => (0, None), - } - } -} diff --git a/src/lib.rs b/src/lib.rs index e63e18e..c3ef24b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -38,38 +38,26 @@ extern crate byteorder; extern crate chrono; extern crate rustc_serialize; -extern crate serde; extern crate xml as xml_rs; pub mod binary; pub mod xml; mod builder; -mod de; -mod ser; -pub use de::Deserializer; -pub use ser::Serializer; +// Optional serde module +#[cfg(feature = "serde")] +#[macro_use] +extern crate serde as serde_base; +#[cfg(feature = "serde")] +pub mod serde; use chrono::{DateTime, UTC}; -use serde::{Deserialize, Serialize}; use std::collections::BTreeMap; use std::fmt; -use std::io::{Read, Seek, SeekFrom, Write}; +use std::io::{Read, Seek, SeekFrom}; use std::io::Error as IoError; -pub fn deserialize(reader: R) -> Result { - let reader = EventReader::new(reader); - let mut de = Deserializer::new(reader); - Deserialize::deserialize(&mut de) -} - -pub fn serialize_to_xml(writer: W, value: &T) -> Result<()> { - let writer = xml::EventWriter::new(writer); - let mut ser = Serializer::new(writer); - value.serialize(&mut ser) -} - #[derive(Clone, Debug, PartialEq)] pub enum Plist { Array(Vec), diff --git a/src/ser.rs b/src/ser.rs deleted file mode 100644 index 54294b5..0000000 --- a/src/ser.rs +++ /dev/null @@ -1,186 +0,0 @@ -// 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::{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, -} - -impl Serializer { - pub fn new(writer: W) -> Serializer { - Serializer { writer: writer } - } - - #[inline] - fn emit(&mut self, event: PlistEvent) -> Result<(), Error> { - self.writer.write(&event) - } - - pub fn into_inner(self) -> W { - self.writer - } - - fn single_key_dict(&mut self, - key: String, - value_fn: F) - -> Result<(), ::Error> - where F: FnOnce(&mut Serializer) -> Result<(), ::Error> - { - // Emit {key: value} - try!(self.emit(PlistEvent::StartDictionary(Some(1)))); - try!(self.emit(PlistEvent::StringValue(key))); - try!(value_fn(self)); - try!(self.emit(PlistEvent::EndDictionary)); - Ok(()) - } -} - -impl SerdeSerializer for Serializer { - type Error = Error; - - fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error> { - self.emit(PlistEvent::BooleanValue(v)) - } - - fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> { - self.emit(PlistEvent::IntegerValue(v)) - } - - fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> { - self.emit(PlistEvent::IntegerValue(v as i64)) - } - - fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> { - self.emit(PlistEvent::RealValue(v)) - } - - fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> { - self.emit(PlistEvent::StringValue(value.to_owned())) - } - - fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { - self.emit(PlistEvent::DataValue(value.to_owned())) - } - - fn serialize_unit(&mut self) -> Result<(), Self::Error> { - // Emit empty string - self.emit(PlistEvent::StringValue(String::new())) - } - - fn serialize_none(&mut self) -> Result<(), Self::Error> { - self.single_key_dict("None".to_owned(), |this| this.serialize_unit()) - } - - 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 serialize_seq(&mut self, mut visitor: V) -> Result<(), Self::Error> - where V: SeqVisitor - { - let len = visitor.len().map(|len| len as u64); - try!(self.emit(PlistEvent::StartArray(len))); - loop { - match try!(visitor.visit(self)) { - Some(()) => (), - None => break, - } - } - try!(self.emit(PlistEvent::EndArray)); - Ok(()) - } - - fn serialize_seq_elt(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize - { - value.serialize(self) - } - - fn serialize_map(&mut self, mut visitor: V) -> Result<(), Self::Error> - where V: MapVisitor - { - let len = visitor.len().map(|len| len as u64); - try!(self.emit(PlistEvent::StartDictionary(len))); - loop { - match try!(visitor.visit(self)) { - Some(()) => (), - None => break, - } - } - try!(self.emit(PlistEvent::EndDictionary)); - Ok(()) - } - - fn serialize_map_elt(&mut self, key: K, value: V) -> Result<(), Self::Error> - where K: Serialize, - V: Serialize - { - try!(key.serialize(self)); - try!(value.serialize(self)); - Ok(()) - } - - 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.serialize_unit()) - } - - fn serialize_newtype_struct(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error> - where T: Serialize - { - value.serialize(self) - } - - fn serialize_newtype_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - value: T) - -> Result<(), Self::Error> - where T: Serialize - { - self.single_key_dict(variant.to_owned(), |this| value.serialize(this)) - } - - fn serialize_tuple_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - visitor: V) - -> Result<(), Self::Error> - where V: SeqVisitor - { - self.single_key_dict(variant.to_owned(), - |this| this.serialize_tuple_struct(variant, visitor)) - } - - fn serialize_struct_variant(&mut self, - _name: &'static str, - _variant_index: usize, - variant: &'static str, - visitor: V) - -> Result<(), Self::Error> - where V: MapVisitor - { - self.single_key_dict(variant.to_owned(), - |this| this.serialize_struct(variant, visitor)) - } -} diff --git a/src/serde/de.rs b/src/serde/de.rs new file mode 100644 index 0000000..f888852 --- /dev/null +++ b/src/serde/de.rs @@ -0,0 +1,285 @@ +// 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_base::de::{Deserializer as SerdeDeserializer, Error as SerdeError, Visitor, SeqVisitor, + MapVisitor, VariantVisitor, Deserialize, EnumVisitor}; +use std::iter::Peekable; + +use {Error, PlistEvent, u64_option_to_usize}; + +macro_rules! expect { + ($next:expr, $pat:pat) => { + match $next { + Some(Ok(v@$pat)) => v, + None => return Err(Error::UnexpectedEof), + _ => return Err(event_mismatch_error()) + } + }; + ($next:expr, $pat:pat => $save:expr) => { + match $next { + Some(Ok($pat)) => $save, + None => return Err(Error::UnexpectedEof), + _ => return Err(event_mismatch_error()) + } + }; +} + +macro_rules! try_next { + ($next:expr) => { + match $next { + Some(Ok(v)) => v, + Some(Err(_)) => return Err(event_mismatch_error()), + None => return Err(Error::UnexpectedEof) + } + } +} + +fn event_mismatch_error() -> Error { + Error::InvalidData +} + +impl SerdeError for Error { + fn custom>(msg: T) -> Self { + Error::Serde(msg.into()) + } + + fn end_of_stream() -> Self { + Error::UnexpectedEof + } +} + +pub struct Deserializer + where I: IntoIterator> +{ + events: Peekable<::IntoIter>, +} + +impl Deserializer + where I: IntoIterator> +{ + pub fn new(iter: I) -> Deserializer { + Deserializer { events: iter.into_iter().peekable() } + } +} + +impl SerdeDeserializer for Deserializer + where I: IntoIterator> +{ + type Error = Error; + + fn deserialize(&mut self, mut visitor: V) -> Result + where V: Visitor + { + match try_next!(self.events.next()) { + PlistEvent::StartArray(len) => { + let len = try!(u64_option_to_usize(len)); + visitor.visit_seq(MapAndSeqVisitor::new(self, len)) + } + PlistEvent::EndArray => return Err(event_mismatch_error()), + + PlistEvent::StartDictionary(len) => { + let len = try!(u64_option_to_usize(len)); + visitor.visit_map(MapAndSeqVisitor::new(self, len)) + } + PlistEvent::EndDictionary => return Err(event_mismatch_error()), + + PlistEvent::BooleanValue(v) => visitor.visit_bool(v), + PlistEvent::DataValue(v) => visitor.visit_byte_buf(v), + PlistEvent::DateValue(v) => visitor.visit_string(v.to_rfc3339()), + PlistEvent::IntegerValue(v) if v.is_positive() => visitor.visit_u64(v as u64), + PlistEvent::IntegerValue(v) => visitor.visit_i64(v as i64), + PlistEvent::RealValue(v) => visitor.visit_f64(v), + PlistEvent::StringValue(v) => visitor.visit_string(v), + } + } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string + seq seq_fixed_size bytes map unit_struct + tuple_struct struct struct_field tuple ignored_any + } + + fn deserialize_unit(&mut self, mut visitor: V) -> Result + where V: Visitor + { + expect!(self.events.next(), PlistEvent::StringValue(_)); + visitor.visit_unit() + } + + fn deserialize_option(&mut self, mut visitor: V) -> Result + where V: Visitor + { + expect!(self.events.next(), PlistEvent::StartDictionary(_)); + + let ret = match try_next!(self.events.next()) { + PlistEvent::StringValue(ref s) if &s[..] == "None" => { + let ret = match visitor.visit_none() { + Ok(ret) => ret, + Err(e) => return Err(e), + }; + // For some reason the try! below doesn't work - probably a macro hygene issue + // with Error and ::Error + // let ret = try!(visitor.visit_none()); + expect!(self.events.next(), PlistEvent::StringValue(_)); + ret + } + PlistEvent::StringValue(ref s) if &s[..] == "Some" => try!(visitor.visit_some(self)), + _ => return Err(event_mismatch_error()), + }; + + expect!(self.events.next(), PlistEvent::EndDictionary); + + Ok(ret) + } + + fn deserialize_newtype_struct(&mut self, + _name: &'static str, + mut visitor: V) + -> Result + where V: Visitor + { + visitor.visit_newtype_struct(self) + } + + fn deserialize_enum(&mut self, + _enum: &'static str, + _variants: &'static [&'static str], + mut visitor: V) + -> Result + where V: EnumVisitor + { + expect!(self.events.next(), PlistEvent::StartDictionary(_)); + let ret = try!(visitor.visit(&mut *self)); + expect!(self.events.next(), PlistEvent::EndDictionary); + Ok(ret) + } +} + +impl VariantVisitor for Deserializer + where I: IntoIterator> +{ + type Error = Error; + + fn visit_variant(&mut self) -> Result + where V: Deserialize + { + ::deserialize(self) + } + + fn visit_unit(&mut self) -> Result<(), Self::Error> { + <() as Deserialize>::deserialize(self) + } + + fn visit_newtype(&mut self) -> Result + where T: Deserialize + { + ::deserialize(self) + } + + fn visit_tuple(&mut self, len: usize, visitor: V) -> Result + where V: Visitor + { + ::deserialize_tuple(self, len, visitor) + } + + fn visit_struct(&mut self, + fields: &'static [&'static str], + visitor: V) + -> Result + where V: Visitor + { + let name = ""; + ::deserialize_struct(self, name, fields, visitor) + } +} + +struct MapAndSeqVisitor<'a, I> + where I: 'a + IntoIterator> +{ + de: &'a mut Deserializer, + remaining: Option, + finished: bool, +} + +impl<'a, I> MapAndSeqVisitor<'a, I> + where I: 'a + IntoIterator> +{ + fn new(de: &'a mut Deserializer, len: Option) -> MapAndSeqVisitor<'a, I> { + MapAndSeqVisitor { + de: de, + remaining: len, + finished: false, + } + } +} + +impl<'a, I> SeqVisitor for MapAndSeqVisitor<'a, I> + where I: 'a + IntoIterator> +{ + type Error = Error; + + fn visit(&mut self) -> Result, Self::Error> + where T: Deserialize + { + match self.de.events.peek() { + Some(&Ok(PlistEvent::EndArray)) => { + self.de.events.next(); + self.finished = true; + return Ok(None); + } + _ => ::deserialize(self.de).map(|k| Some(k)), + } + } + + fn end(&mut self) -> Result<(), Self::Error> { + if !self.finished { + self.finished = true; + expect!(self.de.events.next(), PlistEvent::EndArray); + } + Ok(()) + } + + fn size_hint(&self) -> (usize, Option) { + ::size_hint(self) + } +} + +impl<'a, I> MapVisitor for MapAndSeqVisitor<'a, I> + where I: 'a + IntoIterator> +{ + type Error = Error; + + fn visit_key(&mut self) -> Result, Self::Error> + where K: Deserialize + { + match self.de.events.peek() { + Some(&Ok(PlistEvent::EndDictionary)) => { + self.de.events.next(); + self.finished = true; + return Ok(None); + } + _ => ::deserialize(self.de).map(|k| Some(k)), + } + } + + fn visit_value(&mut self) -> Result + where V: Deserialize + { + ::deserialize(self.de) + } + + fn end(&mut self) -> Result<(), Self::Error> { + if !self.finished { + self.finished = true; + expect!(self.de.events.next(), PlistEvent::EndDictionary); + } + Ok(()) + } + + fn size_hint(&self) -> (usize, Option) { + match self.remaining { + Some(len) => (len, Some(len)), + None => (0, None), + } + } +} diff --git a/src/serde/mod.rs b/src/serde/mod.rs new file mode 100644 index 0000000..0c2d7fa --- /dev/null +++ b/src/serde/mod.rs @@ -0,0 +1,24 @@ +mod de; +mod ser; + +pub use self::de::Deserializer; +pub use self::ser::Serializer; + +use serde_base::{Deserialize, Serialize}; +use std::io::{Read, Seek, Write}; + +use Result; +use xml::EventReader; +use xml::EventWriter; + +pub fn deserialize(reader: R) -> Result { + let reader = EventReader::new(reader); + let mut de = Deserializer::new(reader); + Deserialize::deserialize(&mut de) +} + +pub fn serialize_to_xml(writer: W, value: &T) -> Result<()> { + let writer = EventWriter::new(writer); + let mut ser = Serializer::new(writer); + value.serialize(&mut ser) +} diff --git a/src/serde/ser.rs b/src/serde/ser.rs new file mode 100644 index 0000000..2875ed2 --- /dev/null +++ b/src/serde/ser.rs @@ -0,0 +1,329 @@ +// 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_base::ser::{Error as SerdeError, Serialize, Serializer as SerdeSerializer}; + +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, +} + +impl Serializer { + pub fn new(writer: W) -> Serializer { + Serializer { writer: writer } + } + + #[inline] + fn emit(&mut self, event: PlistEvent) -> Result<(), ::Error> { + Ok(self.writer.write(&event)?) + } + + pub fn into_inner(self) -> W { + self.writer + } + + // Emit {key: value} + fn single_key_dict(&mut self, key: String) -> Result<(), ::Error> { + try!(self.emit(PlistEvent::StartDictionary(Some(1)))); + try!(self.emit(PlistEvent::StringValue(key))); + Ok(()) + } + + fn single_key_dict_end(&mut self) -> Result<(), ::Error> { + try!(self.emit(PlistEvent::EndDictionary)); + Ok(()) + } +} + +impl SerdeSerializer for Serializer { + type Error = Error; + type SeqState = (); + type TupleState = (); + type TupleStructState = (); + type TupleVariantState = (); + type MapState = (); + type StructState = (); + type StructVariantState = (); + + fn serialize_bool(&mut self, v: bool) -> Result<(), Self::Error> { + self.emit(PlistEvent::BooleanValue(v)) + } + + fn serialize_isize(&mut self, v: isize) -> Result<(), Self::Error> { + self.serialize_i64(v as i64) + } + + fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error> { + self.serialize_i64(v as i64) + } + + fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error> { + self.serialize_i64(v as i64) + } + + fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error> { + self.serialize_i64(v as i64) + } + + fn serialize_i64(&mut self, v: i64) -> Result<(), Self::Error> { + self.emit(PlistEvent::IntegerValue(v)) + } + + fn serialize_usize(&mut self, v: usize) -> Result<(), Self::Error> { + self.serialize_u64(v as u64) + } + + fn serialize_u8(&mut self, v: u8) -> Result<(), Self::Error> { + self.serialize_u64(v as u64) + } + + fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error> { + self.serialize_u64(v as u64) + } + + fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error> { + self.serialize_u64(v as u64) + } + + fn serialize_u64(&mut self, v: u64) -> Result<(), Self::Error> { + self.emit(PlistEvent::IntegerValue(v as i64)) + } + + fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error> { + self.serialize_f64(v as f64) + } + + fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error> { + self.emit(PlistEvent::RealValue(v)) + } + + fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> { + let sstr = v.to_string(); + self.serialize_str(&sstr) + } + + fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error> { + self.emit(PlistEvent::StringValue(value.to_owned())) + } + + fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> { + self.emit(PlistEvent::DataValue(value.to_owned())) + } + + fn serialize_unit(&mut self) -> Result<(), Self::Error> { + // Emit empty string + self.emit(PlistEvent::StringValue(String::new())) + } + + fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> { + self.serialize_unit() + } + + 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())?; + self.serialize_unit()?; + self.single_key_dict_end()?; + Ok(()) + } + + fn serialize_newtype_struct(&mut self, + _name: &'static str, + value: T) + -> Result<(), Self::Error> { + value.serialize(self) + } + + fn serialize_newtype_variant(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str, + value: T) + -> Result<(), Self::Error> { + self.single_key_dict(variant.to_owned())?; + value.serialize(self)?; + self.single_key_dict_end() + } + + fn serialize_none(&mut self) -> Result<(), Self::Error> { + self.single_key_dict("None".to_owned())?; + self.serialize_unit()?; + self.single_key_dict_end() + } + + fn serialize_some(&mut self, value: T) -> Result<(), Self::Error> { + self.single_key_dict("Some".to_owned())?; + value.serialize(self)?; + self.single_key_dict_end() + } + + fn serialize_seq(&mut self, len: Option) -> Result { + let len = len.map(|len| len as u64); + self.emit(PlistEvent::StartArray(len)) + } + + fn serialize_seq_elt(&mut self, + _state: &mut Self::SeqState, + value: T) + -> Result<(), Self::Error> { + value.serialize(self) + } + + fn serialize_seq_end(&mut self, _state: Self::SeqState) -> Result<(), Self::Error> { + self.emit(PlistEvent::EndArray) + } + + fn serialize_seq_fixed_size(&mut self, size: usize) -> Result { + self.serialize_seq(Some(size)) + } + + fn serialize_tuple(&mut self, len: usize) -> Result { + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_elt(&mut self, + state: &mut Self::TupleState, + value: T) + -> Result<(), Self::Error> { + self.serialize_seq_elt(state, value) + } + + fn serialize_tuple_end(&mut self, state: Self::TupleState) -> Result<(), Self::Error> { + self.serialize_seq_end(state) + } + + fn serialize_tuple_struct(&mut self, + _name: &'static str, + len: usize) + -> Result { + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_struct_elt(&mut self, + state: &mut Self::TupleStructState, + value: T) + -> Result<(), Self::Error> { + self.serialize_seq_elt(state, value) + } + + fn serialize_tuple_struct_end(&mut self, + state: Self::TupleStructState) + -> Result<(), Self::Error> { + self.serialize_seq_end(state) + } + + fn serialize_tuple_variant(&mut self, + _name: &'static str, + _variant_index: usize, + variant: &'static str, + len: usize) + -> Result { + + self.single_key_dict(variant.to_owned())?; + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_variant_elt(&mut self, + state: &mut Self::TupleVariantState, + value: T) + -> Result<(), Self::Error> { + self.serialize_seq_elt(state, value) + } + fn serialize_tuple_variant_end(&mut self, + state: Self::TupleVariantState) + -> Result<(), Self::Error> { + self.serialize_seq_end(state)?; + self.single_key_dict_end() + } + + + fn serialize_map(&mut self, len: Option) -> Result { + let len = len.map(|len| len as u64); + self.emit(PlistEvent::StartDictionary(len)) + } + + fn serialize_map_key(&mut self, + _state: &mut Self::MapState, + key: T) + -> Result<(), Self::Error> + where T: Serialize + { + key.serialize(self) + } + + fn serialize_map_value(&mut self, + _state: &mut Self::MapState, + value: T) + -> Result<(), Self::Error> + where T: Serialize + { + value.serialize(self) + } + + fn serialize_map_end(&mut self, _state: Self::MapState) -> Result<(), Self::Error> { + self.emit(PlistEvent::EndDictionary) + } + + fn serialize_struct(&mut self, + _name: &'static str, + len: usize) + -> Result { + self.serialize_map(Some(len))?; + Ok(()) + } + + fn serialize_struct_elt(&mut self, + state: &mut Self::StructState, + key: &'static str, + value: V) + -> Result<(), Self::Error> { + self.serialize_map_key(state, key)?; + self.serialize_map_value(state, value)?; + Ok(()) + } + + fn serialize_struct_end(&mut self, state: Self::StructState) -> Result<(), Self::Error> { + self.serialize_map_end(state) + } + + fn serialize_struct_variant(&mut self, + name: &'static str, + _variant_index: usize, + variant: &'static str, + len: usize) + -> Result { + self.single_key_dict(variant.to_owned())?; + self.serialize_struct(name, len)?; + Ok(()) + } + + fn serialize_struct_variant_elt(&mut self, + state: &mut Self::StructVariantState, + key: &'static str, + value: V) + -> Result<(), Self::Error> { + self.serialize_struct_elt(state, key, value) + } + + fn serialize_struct_variant_end(&mut self, + state: Self::StructVariantState) + -> Result<(), Self::Error> { + self.serialize_struct_end(state)?; + self.single_key_dict_end()?; + Ok(()) + } +} diff --git a/tests/serde_/mod.rs b/tests/serde_/mod.rs deleted file mode 100644 index f48058a..0000000 --- a/tests/serde_/mod.rs +++ /dev/null @@ -1,209 +0,0 @@ -use plist::{Deserializer, EventWriter, PlistEvent, Result as PlistResult, Serializer}; -use plist::PlistEvent::*; -use serde::{Deserialize, Serialize}; -use std::fmt::Debug; - -struct VecWriter { - events: Vec, -} - -impl VecWriter { - pub fn new() -> VecWriter { - VecWriter { events: Vec::new() } - } - - pub fn into_inner(self) -> Vec { - self.events - } -} - -impl EventWriter for VecWriter { - fn write(&mut self, event: &PlistEvent) -> PlistResult<()> { - self.events.push(event.clone()); - Ok(()) - } -} - -fn new_serializer() -> Serializer { - Serializer::new(VecWriter::new()) -} - -fn new_deserializer(events: Vec) -> Deserializer>> { - let result_events = events.into_iter().map(|e| Ok(e)).collect(); - Deserializer::new(result_events) -} - -fn assert_roundtrip(obj: T, comparison: Option<&[PlistEvent]>) - where T: Debug + Deserialize + PartialEq + Serialize -{ - let mut se = new_serializer(); - - obj.serialize(&mut se).unwrap(); - - let events = se.into_inner().into_inner(); - - match comparison { - Some(comparison) => { - assert_eq!(&events[..], comparison); - } - None => (), - } - - let mut de = new_deserializer(events); - - let new_obj = T::deserialize(&mut de).unwrap(); - - assert_eq!(new_obj, obj); -} - -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -enum Animal { - Cow, - Dog(DogOuter), - Frog(Result, Vec), - Cat { - age: usize, - name: String, - firmware: Option>, - }, -} - -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -struct DogOuter { - inner: Vec, -} - -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -struct DogInner { - a: (), - b: usize, - c: Vec, -} - -#[test] -fn cow() { - let cow = Animal::Cow; - - let comparison = &[StartDictionary(Some(1)), - StringValue("Cow".to_owned()), - StringValue("".to_owned()), - EndDictionary]; - - assert_roundtrip(cow, Some(comparison)); -} - - -#[test] -fn dog() { - let dog = Animal::Dog(DogOuter { - inner: vec![DogInner { - a: (), - b: 12, - c: vec!["a".to_string(), "b".to_string()], - }], - }); - - let comparison = &[StartDictionary(Some(1)), - StringValue("Dog".to_owned()), - StartDictionary(Some(1)), - StringValue("inner".to_owned()), - StartArray(Some(1)), - StartDictionary(Some(3)), - StringValue("a".to_owned()), - StringValue("".to_owned()), - StringValue("b".to_owned()), - IntegerValue(12), - StringValue("c".to_owned()), - StartArray(Some(2)), - StringValue("a".to_owned()), - StringValue("b".to_owned()), - EndArray, - EndDictionary, - EndArray, - EndDictionary, - EndDictionary]; - - assert_roundtrip(dog, Some(comparison)); -} - - -#[test] -fn frog() { - let frog = Animal::Frog(Ok("hello".to_owned()), - vec![1.0, 2.0, 3.14159, 0.000000001, 1.27e31]); - - let comparison = &[StartDictionary(Some(1)), - StringValue("Frog".to_owned()), - StartArray(Some(2)), - StartDictionary(Some(1)), - StringValue("Ok".to_owned()), - StringValue("hello".to_owned()), - EndDictionary, - StartArray(Some(5)), - RealValue(1.0), - RealValue(2.0), - RealValue(3.14159), - RealValue(0.000000001), - RealValue(1.27e31), - EndArray, - EndArray, - EndDictionary]; - - assert_roundtrip(frog, Some(comparison)); -} - - -#[test] -fn cat() { - let cat = Animal::Cat { - age: 12, - name: "Paws".to_owned(), - firmware: Some(vec![0, 1, 2, 3, 4, 5, 6, 7, 8]), - }; - - let comparison = &[StartDictionary(Some(1)), - StringValue("Cat".to_owned()), - StartDictionary(Some(3)), - StringValue("age".to_owned()), - IntegerValue(12), - StringValue("name".to_owned()), - StringValue("Paws".to_owned()), - StringValue("firmware".to_owned()), - StartDictionary(Some(1)), - StringValue("Some".to_owned()), - StartArray(Some(9)), - IntegerValue(0), - IntegerValue(1), - IntegerValue(2), - IntegerValue(3), - IntegerValue(4), - IntegerValue(5), - IntegerValue(6), - IntegerValue(7), - IntegerValue(8), - EndArray, - EndDictionary, - EndDictionary, - EndDictionary]; - - assert_roundtrip(cat, Some(comparison)); -} - -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -struct NewtypeStruct(NewtypeInner); - -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] -struct NewtypeInner(u8, u8, u8); - -#[test] -fn newtype_struct() { - let newtype = NewtypeStruct(NewtypeInner(34, 32, 13)); - - let comparison = &[StartArray(Some(3)), - IntegerValue(34), - IntegerValue(32), - IntegerValue(13), - EndArray]; - - assert_roundtrip(newtype, Some(comparison)); -} diff --git a/tests/serde_tests.rs.in b/tests/serde_tests.rs.in deleted file mode 100644 index 8e04ab0..0000000 --- a/tests/serde_tests.rs.in +++ /dev/null @@ -1,4 +0,0 @@ -extern crate serde; -extern crate plist; - -mod serde_; diff --git a/tests/serde_tests/mod.rs b/tests/serde_tests/mod.rs new file mode 100644 index 0000000..42f9824 --- /dev/null +++ b/tests/serde_tests/mod.rs @@ -0,0 +1,207 @@ +use plist::{EventWriter, PlistEvent, Result as PlistResult}; +use plist::serde::{Serializer, Deserializer}; +use plist::PlistEvent::*; +use serde::{Deserialize, Serialize}; +use std::fmt::Debug; + +struct VecWriter { + events: Vec, +} + +impl VecWriter { + pub fn new() -> VecWriter { + VecWriter { events: Vec::new() } + } + + pub fn into_inner(self) -> Vec { + self.events + } +} + +impl EventWriter for VecWriter { + fn write(&mut self, event: &PlistEvent) -> PlistResult<()> { + self.events.push(event.clone()); + Ok(()) + } +} + +fn new_serializer() -> Serializer { + Serializer::new(VecWriter::new()) +} + +fn new_deserializer(events: Vec) -> Deserializer>> { + let result_events = events.into_iter().map(|e| Ok(e)).collect(); + Deserializer::new(result_events) +} + +fn assert_roundtrip(obj: T, comparison: Option<&[PlistEvent]>) + where T: Debug + Deserialize + PartialEq + Serialize +{ + let mut se = new_serializer(); + + obj.serialize(&mut se).unwrap(); + + let events = se.into_inner().into_inner(); + + match comparison { + Some(comparison) => { + assert_eq!(&events[..], comparison); + } + None => (), + } + + let mut de = new_deserializer(events); + + let new_obj = T::deserialize(&mut de).unwrap(); + + assert_eq!(new_obj, obj); +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +enum Animal { + Cow, + Dog(DogOuter), + Frog(Result, Vec), + Cat { + age: usize, + name: String, + firmware: Option>, + }, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +struct DogOuter { + inner: Vec, +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +struct DogInner { + a: (), + b: usize, + c: Vec, +} + +#[test] +fn cow() { + let cow = Animal::Cow; + + let comparison = &[StartDictionary(Some(1)), + StringValue("Cow".to_owned()), + StringValue("".to_owned()), + EndDictionary]; + + assert_roundtrip(cow, Some(comparison)); +} + + +#[test] +fn dog() { + let dog = Animal::Dog(DogOuter { + inner: vec![DogInner { + a: (), + b: 12, + c: vec!["a".to_string(), "b".to_string()], + }], + }); + + let comparison = &[StartDictionary(Some(1)), + StringValue("Dog".to_owned()), + StartDictionary(Some(1)), + StringValue("inner".to_owned()), + StartArray(Some(1)), + StartDictionary(Some(3)), + StringValue("a".to_owned()), + StringValue("".to_owned()), + StringValue("b".to_owned()), + IntegerValue(12), + StringValue("c".to_owned()), + StartArray(Some(2)), + StringValue("a".to_owned()), + StringValue("b".to_owned()), + EndArray, + EndDictionary, + EndArray, + EndDictionary, + EndDictionary]; + + assert_roundtrip(dog, Some(comparison)); +} + + +#[test] +fn frog() { + let frog = Animal::Frog(Ok("hello".to_owned()), + vec![1.0, 2.0, 3.14159, 0.000000001, 1.27e31]); + + let comparison = &[StartDictionary(Some(1)), + StringValue("Frog".to_owned()), + StartArray(Some(2)), + StartDictionary(Some(1)), + StringValue("Ok".to_owned()), + StringValue("hello".to_owned()), + EndDictionary, + StartArray(Some(5)), + RealValue(1.0), + RealValue(2.0), + RealValue(3.14159), + RealValue(0.000000001), + RealValue(1.27e31), + EndArray, + EndArray, + EndDictionary]; + + assert_roundtrip(frog, Some(comparison)); +} + + +#[test] +fn cat() { + let cat = Animal::Cat { + age: 12, + name: "Paws".to_owned(), + firmware: Some(vec![0, 1, 2, 3, 4, 5, 6, 7, 8]), + }; + + let comparison = &[StartDictionary(Some(1)), + StringValue("Cat".to_owned()), + StartDictionary(Some(3)), + StringValue("age".to_owned()), + IntegerValue(12), + StringValue("name".to_owned()), + StringValue("Paws".to_owned()), + StringValue("firmware".to_owned()), + StartDictionary(Some(1)), + StringValue("Some".to_owned()), + StartArray(Some(9)), + IntegerValue(0), + IntegerValue(1), + IntegerValue(2), + IntegerValue(3), + IntegerValue(4), + IntegerValue(5), + IntegerValue(6), + IntegerValue(7), + IntegerValue(8), + EndArray, + EndDictionary, + EndDictionary, + EndDictionary]; + + assert_roundtrip(cat, Some(comparison)); +} + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +struct NewtypeStruct(NewtypeInner); + +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +struct NewtypeInner(u8, u8, u8); + +#[test] +fn newtype_struct() { + let newtype = NewtypeStruct(NewtypeInner(34, 32, 13)); + + let comparison = + &[StartArray(Some(3)), IntegerValue(34), IntegerValue(32), IntegerValue(13), EndArray]; + + assert_roundtrip(newtype, Some(comparison)); +} diff --git a/tests/tests.rs b/tests/tests.rs index 0aaf77c..8754b09 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -1,2 +1,10 @@ -#[cfg(feature = "serde_tests")] -include!(concat!(env!("OUT_DIR"), "/serde_tests.rs")); +extern crate plist; + +#[cfg(feature = "serde")] +extern crate serde; +#[cfg(feature = "serde")] +#[macro_use] +extern crate serde_derive; + +#[cfg(feature = "serde")] +mod serde_tests; -- cgit v1.2.3