Support Serde 0.8. Bump minimum Rust version to 0.15.

3 files changed, 638 insertions, 0 deletions

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<T: Into<String>>(msg: T) -> Self {
+        Error::Serde(msg.into())
+    }
+
+    fn end_of_stream() -> Self {
+        Error::UnexpectedEof
+    }
+}
+
+pub struct Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    events: Peekable<<I as IntoIterator>::IntoIter>,
+}
+
+impl<I> Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    pub fn new(iter: I) -> Deserializer<I> {
+        Deserializer { events: iter.into_iter().peekable() }
+    }
+}
+
+impl<I> SerdeDeserializer for Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        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<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        expect!(self.events.next(), PlistEvent::StringValue(_));
+        visitor.visit_unit()
+    }
+
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        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<V>(&mut self,
+                                     _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>
+        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<I> VariantVisitor for Deserializer<I>
+    where I: IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize
+    {
+        <V as Deserialize>::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        <() as Deserialize>::deserialize(self)
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: Deserialize
+    {
+        <T as Deserialize>::deserialize(self)
+    }
+
+    fn visit_tuple<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        <Self as SerdeDeserializer>::deserialize_tuple(self, len, visitor)
+    }
+
+    fn visit_struct<V>(&mut self,
+                       fields: &'static [&'static str],
+                       visitor: V)
+                       -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        let name = "";
+        <Self as SerdeDeserializer>::deserialize_struct(self, name, fields, visitor)
+    }
+}
+
+struct MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    de: &'a mut Deserializer<I>,
+    remaining: Option<usize>,
+    finished: bool,
+}
+
+impl<'a, I> MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    fn new(de: &'a mut Deserializer<I>, len: Option<usize>) -> MapAndSeqVisitor<'a, I> {
+        MapAndSeqVisitor {
+            de: de,
+            remaining: len,
+            finished: false,
+        }
+    }
+}
+
+impl<'a, I> SeqVisitor for MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: Deserialize
+    {
+        match self.de.events.peek() {
+            Some(&Ok(PlistEvent::EndArray)) => {
+                self.de.events.next();
+                self.finished = true;
+                return Ok(None);
+            }
+            _ => <T as Deserialize>::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<usize>) {
+        <Self as MapVisitor>::size_hint(self)
+    }
+}
+
+impl<'a, I> MapVisitor for MapAndSeqVisitor<'a, I>
+    where I: 'a + IntoIterator<Item = Result<PlistEvent, Error>>
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
+        where K: Deserialize
+    {
+        match self.de.events.peek() {
+            Some(&Ok(PlistEvent::EndDictionary)) => {
+                self.de.events.next();
+                self.finished = true;
+                return Ok(None);
+            }
+            _ => <K as Deserialize>::deserialize(self.de).map(|k| Some(k)),
+        }
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize
+    {
+        <V as 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<usize>) {
+        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<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(())
+    }
+}