maintain datetime structure

Author: isabelatkinson

src/datetime.rs

@@ -396,14 +396,14 @@ impl crate::DateTime {
     pub fn try_to_rfc3339_string(self) -> Result<String> {
         self.to_time_0_3()
             .format(&Rfc3339)
-            .map_err(Error::bad_conversion)
+            .map_err(Error::cannot_format_datetime)
     }
 
     /// Convert the given RFC 3339 formatted string to a [`DateTime`], truncating it to millisecond
     /// precision.
     pub fn parse_rfc3339_str(s: impl AsRef<str>) -> Result<Self> {
-        let odt =
-            time::OffsetDateTime::parse(s.as_ref(), &Rfc3339).map_err(Error::invalid_value)?;
+        let odt = time::OffsetDateTime::parse(s.as_ref(), &Rfc3339)
+            .map_err(Error::invalid_datetime_value)?;
         Ok(Self::from_time_0_3(odt))
     }
 

src/datetime/builder.rs

@@ -174,16 +174,16 @@ impl DateTimeBuilder<Year, Month, Day> {
     ///
     /// Note: You cannot call `build()` before setting at least the year, month and day.
     pub fn build(self) -> Result<DateTime> {
-        let month = time::Month::try_from(self.month.0).map_err(Error::invalid_value)?;
+        let month = time::Month::try_from(self.month.0).map_err(Error::invalid_datetime_value)?;
         let dt = Date::from_calendar_date(self.year.0, month, self.day.0)
-            .map_err(Error::invalid_value)?
+            .map_err(Error::invalid_datetime_value)?
             .with_hms_milli(
                 self.hour.unwrap_or(0),
                 self.minute.unwrap_or(0),
                 self.second.unwrap_or(0),
                 self.millisecond.unwrap_or(0),
             )
-            .map_err(Error::invalid_value)?;
+            .map_err(Error::invalid_datetime_value)?;
         Ok(DateTime::from_time_private(dt.assume_utc()))
     }
 }

src/error.rs

@@ -1,9 +1,11 @@
+mod datetime;
 mod uuid;
 
 use thiserror::Error;
 
 use crate::spec::ElementType;
 
+pub use datetime::DateTimeErrorKind;
 pub use uuid::UuidErrorKind;
 
 pub type Result<T> = std::result::Result<T, Error>;
@@ -38,19 +40,28 @@ impl std::fmt::Display for Error {
 #[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum ErrorKind {
-    /// An error occurred when converting a BSON type to an external format.
-    #[error("Bad conversion: {message}")]
-    BadConversion { message: String },
+    /// An error related to the [`DateTime`](crate::DateTime) type occurred.
+    #[error("A DateTime-related error occurred: {kind}")]
+    DateTime {
+        /// The kind of error that occurred.
+        kind: DateTimeErrorKind,
+    },
 
     /// An error occurred when attempting to parse a value from an external format to BSON.
     #[error("Invalid value: {message}")]
     #[non_exhaustive]
-    InvalidValue { message: String },
+    InvalidValue {
+        /// A message describing the error.
+        message: String,
+    },
 
     /// Malformed BSON bytes were encountered.
-    #[error("Malformed BSON: {message}")]
+    #[error("Malformed BSON bytes: {message}")]
     #[non_exhaustive]
-    MalformedBytes { message: String },
+    MalformedBytes {
+        /// A message describing the error.
+        message: String,
+    },
 
     /// Invalid UTF-8 bytes were encountered.
     #[error("Invalid UTF-8")]
@@ -153,13 +164,6 @@ impl Error {
         .into()
     }
 
-    pub(crate) fn bad_conversion(message: impl ToString) -> Self {
-        ErrorKind::BadConversion {
-            message: message.to_string(),
-        }
-        .into()
-    }
-
     #[cfg(test)]
     pub(crate) fn is_value_access_not_present(&self) -> bool {
         matches!(

src/error/datetime.rs

@@ -0,0 +1,42 @@
+use thiserror::Error as ThisError;
+
+use crate::error::{Error, ErrorKind};
+
+#[derive(Clone, Debug, ThisError)]
+pub enum DateTimeErrorKind {
+    /// The `DateTime` could not be formatted.
+    #[error("{message}")]
+    #[non_exhaustive]
+    CannotFormat {
+        /// A message describing the error.
+        message: String,
+    },
+
+    /// An invalid value was provided.
+    #[error("{message}")]
+    #[non_exhaustive]
+    InvalidValue {
+        /// A message describing the error.
+        message: String,
+    },
+}
+
+impl Error {
+    pub(crate) fn invalid_datetime_value(message: impl ToString) -> Self {
+        ErrorKind::DateTime {
+            kind: DateTimeErrorKind::InvalidValue {
+                message: message.to_string(),
+            },
+        }
+        .into()
+    }
+
+    pub(crate) fn cannot_format_datetime(message: impl ToString) -> Self {
+        ErrorKind::DateTime {
+            kind: DateTimeErrorKind::CannotFormat {
+                message: message.to_string(),
+            },
+        }
+        .into()
+    }
+}