Support Serde 0.8. Bump minimum Rust version to 0.15.

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 &&
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/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<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;