Implement serialisation and deserialisation for the plist Date type.v0.2.0

2 files changed, 77 insertions, 4 deletions

diff --git a/src/date.rs b/src/date.rs
index 2bcf9da..1aa0e72 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -65,3 +65,62 @@ impl FromStr for Date {
         })
     }
 }
+
+#[cfg(feature = "serde")]
+mod serde_impls {
+    use serde_base::de::{Deserialize, Deserializer, Error, Visitor, Unexpected};
+    use serde_base::ser::{Serialize, Serializer};
+    use std::fmt;
+    use std::str::FromStr;
+
+    use Date;
+
+    impl Serialize for Date {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where S: Serializer,
+        {
+            let date_str = self.to_string();
+            serializer.serialize_newtype_struct("PLIST-DATE", &date_str)
+        }
+    }
+
+    struct DateNewtypeVisitor;
+
+    impl<'de> Visitor<'de> for DateNewtypeVisitor {
+        type Value = Date;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a plist date newtype")
+        }
+
+        fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+            where D: Deserializer<'de>,
+        {
+            deserializer.deserialize_str(DateStrVisitor)
+        }
+    }
+
+    struct DateStrVisitor;
+
+    impl<'de> Visitor<'de> for DateStrVisitor {
+        type Value = Date;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str("a plist date string")
+        }
+
+        fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where E: Error,
+        {
+            Date::from_str(v).map_err(|_| E::invalid_value(Unexpected::Str(v), &self))
+        }
+    }
+
+    impl<'de> Deserialize<'de> for Date {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where D: Deserializer<'de>,
+        {
+            deserializer.deserialize_newtype_struct("PLIST-DATE", DateNewtypeVisitor)
+        }
+    }
+}
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index b5eca6a..a77dc23 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -3,8 +3,9 @@
 
 use serde_base::ser;
 use std::fmt::Display;
+use std::str::FromStr;
 
-use {Error, EventWriter, PlistEvent};
+use {Date, Error, EventWriter, PlistEvent};
 
 impl ser::Error for Error {
     fn custom<T: Display>(msg: T) -> Self {
@@ -17,14 +18,16 @@ pub struct Serializer<W: EventWriter> {
     // We don't want to serialize None if the Option is in a struct field as this is how null
     // fields are represented in plists. This is fragile but results in minimal code duplication.
     // TODO: This is fragile. Use distinct types instead.
-    maybe_option_field_name: Option<&'static str>
+    maybe_option_field_name: Option<&'static str>,
+    expecting_date: bool
 }
 
 impl<W: EventWriter> Serializer<W> {
     pub fn new(writer: W) -> Serializer<W> {
         Serializer {
             writer: writer,
-            maybe_option_field_name: None
+            maybe_option_field_name: None,
+            expecting_date: false
         }
     }
 
@@ -34,6 +37,9 @@ impl<W: EventWriter> Serializer<W> {
         if let Some(field_name) = self.maybe_option_field_name.take() {
             self.emit(PlistEvent::StringValue(field_name.to_owned()))?;
         }
+        if self.expecting_date {
+            panic!("Expecting date");
+        }
         Ok(self.writer.write(&event)?)
     }
 
@@ -115,7 +121,12 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
     }
 
     fn serialize_str(self, value: &str) -> Result<(), Self::Error> {
-        self.emit(PlistEvent::StringValue(value.to_owned()))
+        if self.expecting_date {
+            self.expecting_date = false;
+            self.emit(PlistEvent::DateValue(Date::from_str(value).expect("Invalid date format")))
+        } else {
+            self.emit(PlistEvent::StringValue(value.to_owned()))
+        }
     }
 
     fn serialize_bytes(self, value: &[u8]) -> Result<(), Self::Error> {
@@ -171,6 +182,9 @@ impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
                                                             _name: &'static str,
                                                             value: &T)
                                                             -> Result<(), Self::Error> {
+        if _name == "PLIST-DATE" {
+            self.expecting_date = true;
+        }
         value.serialize(self)
     }