diff options
| -rw-r--r-- | .travis.yml | 2 | ||||
| -rw-r--r-- | Cargo.toml | 10 | ||||
| -rw-r--r-- | src/lib.rs | 26 | ||||
| -rw-r--r-- | src/ser.rs | 186 | ||||
| -rw-r--r-- | src/serde/de.rs (renamed from src/de.rs) | 47 | ||||
| -rw-r--r-- | src/serde/mod.rs | 24 | ||||
| -rw-r--r-- | src/serde/ser.rs | 329 | ||||
| -rw-r--r-- | tests/serde_tests.rs.in | 4 | ||||
| -rw-r--r-- | tests/serde_tests/mod.rs (renamed from tests/serde_/mod.rs) | 10 | ||||
| -rw-r--r-- | tests/tests.rs | 12 |
10 files changed, 409 insertions, 241 deletions
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 && @@ -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" } @@ -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<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> { - let reader = EventReader::new(reader); - let mut de = Deserializer::new(reader); - Deserialize::deserialize(&mut de) -} - -pub fn serialize_to_xml<W: Write, T: Serialize>(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<Plist>), 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<T: Into<String>>(msg: T) -> Self { - Error::Serde(msg.into()) - } - - fn invalid_value(_: &str) -> Self { - Error::InvalidData - } -} - -pub struct Serializer<W: EventWriter> { - writer: W, -} - -impl<W: EventWriter> Serializer<W> { - pub fn new(writer: W) -> Serializer<W> { - 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<F>(&mut self, - key: String, - value_fn: F) - -> Result<(), <Self as SerdeSerializer>::Error> - where F: FnOnce(&mut Serializer<W>) -> Result<(), <Self as SerdeSerializer>::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<W: EventWriter> SerdeSerializer for Serializer<W> { - 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<V>(&mut self, value: V) -> Result<(), Self::Error> - where V: Serialize - { - self.single_key_dict("Some".to_owned(), |this| value.serialize(this)) - } - - fn serialize_seq<V>(&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<T>(&mut self, value: T) -> Result<(), Self::Error> - where T: Serialize - { - value.serialize(self) - } - - fn serialize_map<V>(&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<K, V>(&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<T>(&mut self, _name: &'static str, value: T) -> Result<(), Self::Error> - where T: Serialize - { - value.serialize(self) - } - - fn serialize_newtype_variant<T>(&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<V>(&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<V>(&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/de.rs b/src/serde/de.rs index 1d9531c..f888852 100644 --- a/src/de.rs +++ b/src/serde/de.rs @@ -1,8 +1,8 @@ // 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 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}; @@ -54,7 +54,8 @@ pub struct Deserializer<I> events: Peekable<<I as IntoIterator>::IntoIter>, } -impl<I> Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>> +impl<I> Deserializer<I> + where I: IntoIterator<Item = Result<PlistEvent, Error>> { pub fn new(iter: I) -> Deserializer<I> { Deserializer { events: iter.into_iter().peekable() } @@ -72,13 +73,13 @@ impl<I> SerdeDeserializer for Deserializer<I> match try_next!(self.events.next()) { PlistEvent::StartArray(len) => { let len = try!(u64_option_to_usize(len)); - visitor.visit_seq(MapSeq::new(self, 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(MapSeq::new(self, len)) + visitor.visit_map(MapAndSeqVisitor::new(self, len)) } PlistEvent::EndDictionary => return Err(event_mismatch_error()), @@ -92,6 +93,12 @@ impl<I> SerdeDeserializer for Deserializer<I> } } + 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<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> where V: Visitor { @@ -126,19 +133,19 @@ impl<I> SerdeDeserializer for Deserializer<I> } fn deserialize_newtype_struct<V>(&mut self, - _name: &'static str, - mut visitor: V) - -> Result<V::Value, Self::Error> + _name: &'static str, + mut visitor: V) + -> Result<V::Value, Self::Error> where V: Visitor { visitor.visit_newtype_struct(self) } fn deserialize_enum<V>(&mut self, - _enum: &'static str, - _variants: &'static [&'static str], - mut visitor: V) - -> Result<V::Value, Self::Error> + _enum: &'static str, + _variants: &'static [&'static str], + mut visitor: V) + -> Result<V::Value, Self::Error> where V: EnumVisitor { expect!(self.events.next(), PlistEvent::StartDictionary(_)); @@ -148,7 +155,8 @@ impl<I> SerdeDeserializer for Deserializer<I> } } -impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<PlistEvent, Error>> +impl<I> VariantVisitor for Deserializer<I> + where I: IntoIterator<Item = Result<PlistEvent, Error>> { type Error = Error; @@ -185,7 +193,7 @@ impl<I> VariantVisitor for Deserializer<I> where I: IntoIterator<Item = Result<P } } -struct MapSeq<'a, I> +struct MapAndSeqVisitor<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>> { de: &'a mut Deserializer<I>, @@ -193,10 +201,11 @@ struct MapSeq<'a, I> finished: bool, } -impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>> +impl<'a, I> MapAndSeqVisitor<'a, I> + where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>> { - fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapSeq<'a, I> { - MapSeq { + fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapAndSeqVisitor<'a, I> { + MapAndSeqVisitor { de: de, remaining: len, finished: false, @@ -204,7 +213,7 @@ impl<'a, I> MapSeq<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, E } } -impl<'a, I> SeqVisitor for MapSeq<'a, I> +impl<'a, I> SeqVisitor for MapAndSeqVisitor<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>> { type Error = Error; @@ -235,7 +244,7 @@ impl<'a, I> SeqVisitor for MapSeq<'a, I> } } -impl<'a, I> MapVisitor for MapSeq<'a, I> +impl<'a, I> MapVisitor for MapAndSeqVisitor<'a, I> where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>> { type Error = Error; 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<R: Read + Seek, T: Deserialize>(reader: R) -> Result<T> { + let reader = EventReader::new(reader); + let mut de = Deserializer::new(reader); + Deserialize::deserialize(&mut de) +} + +pub fn serialize_to_xml<W: Write, T: Serialize>(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<T: Into<String>>(msg: T) -> Self { + Error::Serde(msg.into()) + } + + fn invalid_value(_: &str) -> Self { + Error::InvalidData + } +} + +pub struct Serializer<W: EventWriter> { + writer: W, +} + +impl<W: EventWriter> Serializer<W> { + pub fn new(writer: W) -> Serializer<W> { + Serializer { writer: writer } + } + + #[inline] + fn emit(&mut self, event: PlistEvent) -> Result<(), <Self as SerdeSerializer>::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<(), <Self as SerdeSerializer>::Error> { + try!(self.emit(PlistEvent::StartDictionary(Some(1)))); + try!(self.emit(PlistEvent::StringValue(key))); + Ok(()) + } + + fn single_key_dict_end(&mut self) -> Result<(), <Self as SerdeSerializer>::Error> { + try!(self.emit(PlistEvent::EndDictionary)); + Ok(()) + } +} + +impl<W: EventWriter> SerdeSerializer for Serializer<W> { + 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<T: Serialize>(&mut self, + _name: &'static str, + value: T) + -> Result<(), Self::Error> { + value.serialize(self) + } + + fn serialize_newtype_variant<T: Serialize>(&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<T: Serialize>(&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<usize>) -> Result<Self::SeqState, Self::Error> { + let len = len.map(|len| len as u64); + self.emit(PlistEvent::StartArray(len)) + } + + fn serialize_seq_elt<T: Serialize>(&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::SeqState, Self::Error> { + self.serialize_seq(Some(size)) + } + + fn serialize_tuple(&mut self, len: usize) -> Result<Self::TupleState, Self::Error> { + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_elt<T: Serialize>(&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::TupleStructState, Self::Error> { + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_struct_elt<T: Serialize>(&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::TupleVariantState, Self::Error> { + + self.single_key_dict(variant.to_owned())?; + self.serialize_seq_fixed_size(len) + } + + fn serialize_tuple_variant_elt<T: Serialize>(&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<usize>) -> Result<Self::MapState, Self::Error> { + let len = len.map(|len| len as u64); + self.emit(PlistEvent::StartDictionary(len)) + } + + fn serialize_map_key<T>(&mut self, + _state: &mut Self::MapState, + key: T) + -> Result<(), Self::Error> + where T: Serialize + { + key.serialize(self) + } + + fn serialize_map_value<T>(&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::StructState, Self::Error> { + self.serialize_map(Some(len))?; + Ok(()) + } + + fn serialize_struct_elt<V: Serialize>(&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::StructVariantState, Self::Error> { + self.single_key_dict(variant.to_owned())?; + self.serialize_struct(name, len)?; + Ok(()) + } + + fn serialize_struct_variant_elt<V: Serialize>(&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_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_/mod.rs b/tests/serde_tests/mod.rs index f48058a..42f9824 100644 --- a/tests/serde_/mod.rs +++ b/tests/serde_tests/mod.rs @@ -1,4 +1,5 @@ -use plist::{Deserializer, EventWriter, PlistEvent, Result as PlistResult, Serializer}; +use plist::{EventWriter, PlistEvent, Result as PlistResult}; +use plist::serde::{Serializer, Deserializer}; use plist::PlistEvent::*; use serde::{Deserialize, Serialize}; use std::fmt::Debug; @@ -199,11 +200,8 @@ struct NewtypeInner(u8, u8, u8); fn newtype_struct() { let newtype = NewtypeStruct(NewtypeInner(34, 32, 13)); - let comparison = &[StartArray(Some(3)), - IntegerValue(34), - IntegerValue(32), - IntegerValue(13), - EndArray]; + 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; |