feat: Add support for time::PrimitiveDateTime (#322)

Mark `TryFrom<OffsetDateTime> for DateTime` and
`TryFrom<DateTime> for OffsetDateTime` as deprecated.

Author: sorairolake

src/types.rs

@@ -137,7 +137,8 @@ impl DateTime {
     /// Returns the current time if possible, otherwise the default of 1980-01-01.
     #[cfg(feature = "time")]
     pub fn default_for_write() -> Self {
-        OffsetDateTime::now_utc()
+        let now = OffsetDateTime::now_utc();
+        PrimitiveDateTime::new(now.date(), now.time())
             .try_into()
             .unwrap_or_else(|_| DateTime::default())
     }
@@ -437,7 +438,21 @@ impl DateTime {
 impl TryFrom<OffsetDateTime> for DateTime {
     type Error = DateTimeRangeError;
 
+    #[allow(useless_deprecated)]
+    #[deprecated(
+        since = "2.5.0",
+        note = "use `TryFrom<PrimitiveDateTime> for DateTime` instead"
+    )]
     fn try_from(dt: OffsetDateTime) -> Result<Self, Self::Error> {
+        Self::try_from(PrimitiveDateTime::new(dt.date(), dt.time()))
+    }
+}
+
+#[cfg(feature = "time")]
+impl TryFrom<PrimitiveDateTime> for DateTime {
+    type Error = DateTimeRangeError;
+
+    fn try_from(dt: PrimitiveDateTime) -> Result<Self, Self::Error> {
         Self::from_date_and_time(
             dt.year().try_into()?,
             dt.month().into(),
@@ -453,11 +468,25 @@ impl TryFrom<OffsetDateTime> for DateTime {
 impl TryFrom<DateTime> for OffsetDateTime {
     type Error = ComponentRange;
 
+    #[allow(useless_deprecated)]
+    #[deprecated(
+        since = "2.5.0",
+        note = "use `TryFrom<DateTime> for PrimitiveDateTime` instead"
+    )]
+    fn try_from(dt: DateTime) -> Result<Self, Self::Error> {
+        PrimitiveDateTime::try_from(dt).map(PrimitiveDateTime::assume_utc)
+    }
+}
+
+#[cfg(feature = "time")]
+impl TryFrom<DateTime> for PrimitiveDateTime {
+    type Error = ComponentRange;
+
     fn try_from(dt: DateTime) -> Result<Self, Self::Error> {
         let date =
             Date::from_calendar_date(dt.year() as i32, Month::try_from(dt.month())?, dt.day())?;
         let time = Time::from_hms(dt.hour(), dt.minute(), dt.second())?;
-        Ok(PrimitiveDateTime::new(date, time).assume_utc())
+        Ok(PrimitiveDateTime::new(date, time))
     }
 }
 
@@ -1314,7 +1343,7 @@ mod test {
     }
 
     #[cfg(feature = "time")]
-    use time::{format_description::well_known::Rfc3339, OffsetDateTime};
+    use time::{format_description::well_known::Rfc3339, OffsetDateTime, PrimitiveDateTime};
 
     #[cfg(feature = "time")]
     #[test]
@@ -1333,23 +1362,40 @@ mod test {
         assert_eq!(dt.second(), 30);
     }
 
+    #[cfg(feature = "time")]
+    #[test]
+    fn datetime_try_from_primitive_datetime() {
+        use time::macros::datetime;
+
+        use super::DateTime;
+
+        // 2018-11-17 10:38:30
+        let dt = DateTime::try_from(datetime!(2018-11-17 10:38:30)).unwrap();
+        assert_eq!(dt.year(), 2018);
+        assert_eq!(dt.month(), 11);
+        assert_eq!(dt.day(), 17);
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 38);
+        assert_eq!(dt.second(), 30);
+    }
+
     #[cfg(feature = "time")]
     #[test]
     fn datetime_try_from_bounds() {
         use super::DateTime;
         use time::macros::datetime;
 
         // 1979-12-31 23:59:59
-        assert!(DateTime::try_from(datetime!(1979-12-31 23:59:59 UTC)).is_err());
+        assert!(DateTime::try_from(datetime!(1979-12-31 23:59:59)).is_err());
 
         // 1980-01-01 00:00:00
-        assert!(DateTime::try_from(datetime!(1980-01-01 00:00:00 UTC)).is_ok());
+        assert!(DateTime::try_from(datetime!(1980-01-01 00:00:00)).is_ok());
 
         // 2107-12-31 23:59:59
-        assert!(DateTime::try_from(datetime!(2107-12-31 23:59:59 UTC)).is_ok());
+        assert!(DateTime::try_from(datetime!(2107-12-31 23:59:59)).is_ok());
 
         // 2108-01-01 00:00:00
-        assert!(DateTime::try_from(datetime!(2108-01-01 00:00:00 UTC)).is_err());
+        assert!(DateTime::try_from(datetime!(2108-01-01 00:00:00)).is_err());
     }
 
     #[cfg(feature = "time")]
@@ -1365,6 +1411,19 @@ mod test {
         assert_eq!(dt, datetime!(2018-11-17 10:38:30 UTC));
     }
 
+    #[cfg(feature = "time")]
+    #[test]
+    fn primitive_datetime_try_from_datetime() {
+        use time::macros::datetime;
+
+        use super::DateTime;
+
+        // 2018-11-17 10:38:30
+        let dt =
+            PrimitiveDateTime::try_from(DateTime::try_from_msdos(0x4D71, 0x54CF).unwrap()).unwrap();
+        assert_eq!(dt, datetime!(2018-11-17 10:38:30));
+    }
+
     #[cfg(feature = "time")]
     #[test]
     fn offset_datetime_try_from_bounds() {
@@ -1383,6 +1442,24 @@ mod test {
         .is_err());
     }
 
+    #[cfg(feature = "time")]
+    #[test]
+    fn primitive_datetime_try_from_bounds() {
+        use super::DateTime;
+
+        // 1980-00-00 00:00:00
+        assert!(PrimitiveDateTime::try_from(unsafe {
+            DateTime::from_msdos_unchecked(0x0000, 0x0000)
+        })
+        .is_err());
+
+        // 2107-15-31 31:63:62
+        assert!(PrimitiveDateTime::try_from(unsafe {
+            DateTime::from_msdos_unchecked(0xFFFF, 0xFFFF)
+        })
+        .is_err());
+    }
+
     #[cfg(feature = "jiff-02")]
     #[test]
     fn datetime_try_from_civil_datetime() {
@@ -1517,6 +1594,6 @@ mod test {
         // 2020-01-01 00:00:00
         let clock = OffsetDateTime::from_unix_timestamp(1_577_836_800).unwrap();
 
-        assert!(DateTime::try_from(clock).is_ok());
+        assert!(DateTime::try_from(PrimitiveDateTime::new(clock.date(), clock.time())).is_ok());
     }
 }