Stop exposing internal functions and chrono types in Date.

8 files changed, 38 insertions, 41 deletions

diff --git a/src/binary/reader.rs b/src/binary/reader.rs
index f63f127..bf21864 100644
--- a/src/binary/reader.rs
+++ b/src/binary/reader.rs
@@ -346,7 +346,7 @@ mod tests {
                            StringValue("Height".to_owned()),
                            RealValue(1.60),
                            StringValue("Birthdate".to_owned()),
-                           DateValue(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06).into()),
+                           DateValue(Date::from_chrono(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06))),
                            StringValue("Author".to_owned()),
                            StringValue("William Shakespeare".to_owned()),
                            StringValue("Data".to_owned()),
diff --git a/src/date.rs b/src/date.rs
index 4091f28..bb1a887 100644
--- a/src/date.rs
+++ b/src/date.rs
@@ -1,6 +1,5 @@
 use chrono::{DateTime, Duration, TimeZone, Utc};
-use std::fmt;
-use std::str::FromStr;
+use std::time::SystemTime;
 
 use {Error, Result};
 
@@ -11,8 +10,18 @@ pub struct Date {
 }
 
 impl Date {
-    #[doc(hidden)]
-    pub fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date> {
+    pub(crate) fn from_rfc3339(date: &str) -> Result<Self> {
+        let date = DateTime::parse_from_rfc3339(date).map_err(|_| Error::InvalidData)?;
+        Ok(Date {
+            inner: date.with_timezone(&Utc),
+        })
+    }
+
+    pub(crate) fn to_rfc3339(&self) -> String {
+        format!("{:?}", self.inner)
+    }
+
+    pub(crate) fn from_seconds_since_plist_epoch(timestamp: f64) -> Result<Date> {
         // Seconds since 1/1/2001 00:00:00.
 
         if timestamp.is_nan() {
@@ -37,32 +46,22 @@ impl Date {
 
         Ok(Date { inner: date })
     }
-}
 
-impl From<DateTime<Utc>> for Date {
-    fn from(date: DateTime<Utc>) -> Self {
+    #[cfg(test)]
+    pub(crate) fn from_chrono(date: DateTime<Utc>) -> Date {
         Date { inner: date }
     }
 }
 
-impl Into<DateTime<Utc>> for Date {
-    fn into(self) -> DateTime<Utc> {
-        self.inner
+impl From<SystemTime> for Date {
+    fn from(date: SystemTime) -> Self {
+        Date { inner: date.into() }
     }
 }
 
-impl fmt::Display for Date {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self.inner)
-    }
-}
-
-impl FromStr for Date {
-    type Err = ();
-
-    fn from_str(s: &str) -> ::std::result::Result<Self, Self::Err> {
-        let date = DateTime::parse_from_rfc3339(s).map_err(|_| ())?;
-        Ok(Date { inner: date.with_timezone(&Utc) })
+impl Into<SystemTime> for Date {
+    fn into(self) -> SystemTime {
+        self.inner.into()
     }
 }
 
@@ -71,7 +70,6 @@ pub 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;
 
@@ -81,7 +79,7 @@ pub mod serde_impls {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where S: Serializer
         {
-            let date_str = self.to_string();
+            let date_str = self.to_rfc3339();
             serializer.serialize_newtype_struct(DATE_NEWTYPE_STRUCT_NAME, &date_str)
         }
     }
@@ -114,7 +112,7 @@ pub mod serde_impls {
         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))
+            Date::from_rfc3339(v).map_err(|_| E::invalid_value(Unexpected::Str(v), &self))
         }
     }
 
diff --git a/src/plist.rs b/src/plist.rs
index 27df833..9fbfe5a 100644
--- a/src/plist.rs
+++ b/src/plist.rs
@@ -334,14 +334,13 @@ impl<'a> From<&'a str> for Plist {
 
 #[cfg(test)]
 mod tests {
-    use super::Plist;
+    use std::collections::BTreeMap;
+    use std::time::SystemTime;
+
+    use {Date, Plist};
 
     #[test]
     fn test_plist_access() {
-        use std::collections::BTreeMap;
-        use chrono::prelude::*;
-        use super::Date;
-
         let vec = vec![Plist::Real(0.0)];
         let mut array = Plist::Array(vec.clone());
         assert_eq!(array.as_array(), Some(&vec.clone()));
@@ -360,7 +359,7 @@ mod tests {
         assert_eq!(Plist::Data(slice.to_vec()).into_data(),
                    Some(slice.to_vec()));
 
-        let date: Date = Utc::now().into();
+        let date: Date = SystemTime::now().into();
         assert_eq!(Plist::Date(date.clone()).as_date(), Some(&date));
 
         assert_eq!(Plist::Real(0.0).as_real(), Some(0.0));
diff --git a/src/serde/de.rs b/src/serde/de.rs
index 87ccc64..a33b480 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -82,7 +82,7 @@ impl<'de, 'a, I> de::Deserializer<'de> for &'a mut Deserializer<I>
 
             PlistEvent::BooleanValue(v) => visitor.visit_bool(v),
             PlistEvent::DataValue(v) => visitor.visit_byte_buf(v),
-            PlistEvent::DateValue(v) => visitor.visit_string(v.to_string()),
+            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),
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 692bba0..5e04d2e 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -1,6 +1,5 @@
 use serde_base::ser;
 use std::fmt::Display;
-use std::str::FromStr;
 
 use {Date, Error, EventWriter, PlistEvent};
 use date::serde_impls::DATE_NEWTYPE_STRUCT_NAME;
@@ -455,7 +454,7 @@ impl<'a, W: EventWriter> ser::Serializer for DateSerializer<'a, W> {
     }
 
     fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
-        let date = Date::from_str(v).map_err(|_| self.expecting_date_error())?;
+        let date = Date::from_rfc3339(v).map_err(|_| self.expecting_date_error())?;
         self.ser.emit(PlistEvent::DateValue(date))
     }
 
diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index e6b6953..66fd8f1 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -72,7 +72,7 @@ impl<R: Read> EventReader<R> {
                         }
                         "date" => {
                             return Some(self.read_content(|s| {
-                                Ok(PlistEvent::DateValue(Date::from_str(&s).map_err(|_| Error::InvalidData)?))
+                                Ok(PlistEvent::DateValue(Date::from_rfc3339(&s)?))
                             }))
                         }
                         "integer" => {
@@ -176,7 +176,7 @@ mod tests {
                            StringValue("Data".to_owned()),
                            DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
                            StringValue("Birthdate".to_owned()),
-                           DateValue(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06).into()),
+                           DateValue(Date::from_chrono(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06))),
                            StringValue("Blank".to_owned()),
                            StringValue("".to_owned()),
                            EndDictionary];
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index 7048b32..ffb8aa4 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -166,7 +166,7 @@ impl<W: Write> PlistEventWriter for EventWriter<W> {
                 self.write_element_and_value("data", &base64_data)?;
             }
             PlistEvent::DateValue(ref value) => {
-                self.write_element_and_value("date", &value.to_string())?
+                self.write_element_and_value("date", &value.to_rfc3339())?
             }
             PlistEvent::IntegerValue(ref value) => {
                 self.write_element_and_value("integer", &value.to_string())?
@@ -190,6 +190,7 @@ mod tests {
     use chrono::{TimeZone, Utc};
     use std::io::Cursor;
 
+    use Date;
     use super::*;
 
     #[test]
@@ -211,7 +212,7 @@ mod tests {
                       StringValue("Data".to_owned()),
                       DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
                       StringValue("Birthdate".to_owned()),
-                      DateValue(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06).into()),
+                      DateValue(Date::from_chrono(Utc.ymd(1981, 05, 16).and_hms(11, 32, 06))),
                       EndDictionary];
 
         let mut cursor = Cursor::new(Vec::new());
diff --git a/tests/serde_tests/mod.rs b/tests/serde_tests/mod.rs
index 0793a98..d8583a2 100644
--- a/tests/serde_tests/mod.rs
+++ b/tests/serde_tests/mod.rs
@@ -1,10 +1,10 @@
-use chrono::{TimeZone, Utc};
 use plist::{Date, EventWriter, PlistEvent, Result as PlistResult};
 use plist::serde::{Serializer, Deserializer};
 use plist::PlistEvent::*;
 use serde::de::DeserializeOwned;
 use serde::ser::Serialize;
 use std::fmt::Debug;
+use std::time::SystemTime;
 
 struct VecWriter {
     events: Vec<PlistEvent>,
@@ -247,7 +247,7 @@ struct TypeWithDate {
 
 #[test]
 fn type_with_date() {
-    let date: Date = Utc.ymd(1981, 05, 16).and_hms(11, 32, 06).into();
+    let date: Date = SystemTime::now().into();
 
     let obj = TypeWithDate {
         a: Some(28),