datetime and oid

Author: isabelatkinson

src/datetime.rs

@@ -1,25 +1,24 @@
 //! Module containing functionality related to BSON DateTimes.
 //! For more information, see the documentation for the [`DateTime`] type.
+pub(crate) mod builder;
 
 use std::{
     convert::TryInto,
-    error,
     fmt::{self, Display},
-    result,
     time::{Duration, SystemTime},
 };
 
-pub(crate) mod builder;
-pub use crate::datetime::builder::DateTimeBuilder;
-use time::format_description::well_known::Rfc3339;
-
 #[cfg(feature = "chrono-0_4")]
 use chrono::{LocalResult, TimeZone, Utc};
 #[cfg(all(
     feature = "serde_with-3",
     any(feature = "chrono-0_4", feature = "time-0_3")
 ))]
 use serde::{Deserialize, Deserializer, Serialize};
+use time::format_description::well_known::Rfc3339;
+
+pub use crate::datetime::builder::DateTimeBuilder;
+use crate::error::{Error, Result};
 
 /// Struct representing a BSON datetime.
 /// Note: BSON datetimes have millisecond precision.
@@ -390,19 +389,14 @@ impl crate::DateTime {
     pub fn try_to_rfc3339_string(self) -> Result<String> {
         self.to_time_0_3()
             .format(&Rfc3339)
-            .map_err(|e| Error::CannotFormat {
-                message: e.to_string(),
-            })
+            .map_err(Error::bad_conversion)
     }
 
     /// 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(|e| {
-            Error::InvalidTimestamp {
-                message: e.to_string(),
-            }
-        })?;
+        let odt =
+            time::OffsetDateTime::parse(s.as_ref(), &Rfc3339).map_err(Error::invalid_value)?;
         Ok(Self::from_time_0_3(odt))
     }
 
@@ -547,30 +541,3 @@ impl serde_with::SerializeAs<time::OffsetDateTime> for crate::DateTime {
         dt.serialize(serializer)
     }
 }
-
-/// Errors that can occur during [`DateTime`] construction and generation.
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub enum Error {
-    /// Error returned when an invalid datetime format is provided to a conversion method.
-    #[non_exhaustive]
-    InvalidTimestamp { message: String },
-    /// Error returned when a [`DateTime`] cannot be represented in a particular format.
-    #[non_exhaustive]
-    CannotFormat { message: String },
-}
-
-/// Alias for `Result<T, DateTime::Error>`
-pub type Result<T> = result::Result<T, Error>;
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::InvalidTimestamp { message } | Error::CannotFormat { message } => {
-                write!(fmt, "{}", message)
-            }
-        }
-    }
-}
-
-impl error::Error for Error {}

src/datetime/builder.rs

@@ -1,7 +1,12 @@
-use super::*;
 use std::convert::TryFrom;
+
 use time::Date;
 
+use crate::{
+    datetime::DateTime,
+    error::{Error, Result},
+};
+
 /// Builder for constructing a BSON [`DateTime`]
 pub struct DateTimeBuilder<Y = NoYear, M = NoMonth, D = NoDay> {
     pub(crate) year: Y,
@@ -169,19 +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 err = |e: time::error::ComponentRange| Error::InvalidTimestamp {
-            message: e.to_string(),
-        };
-        let month = time::Month::try_from(self.month.0).map_err(err)?;
+        let month = time::Month::try_from(self.month.0).map_err(Error::invalid_value)?;
         let dt = Date::from_calendar_date(self.year.0, month, self.day.0)
-            .map_err(err)?
+            .map_err(Error::invalid_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(err)?;
+            .map_err(Error::invalid_value)?;
         Ok(DateTime::from_time_private(dt.assume_utc()))
     }
 }

src/error.rs

@@ -5,7 +5,7 @@ use crate::spec::ElementType;
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// An error that can occur in the `bson` crate.
-#[derive(Debug, Error)]
+#[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub struct Error {
     /// The kind of error that occurred.
@@ -31,13 +31,22 @@ impl std::fmt::Display for Error {
 }
 
 /// The types of errors that can occur in the `bson` crate.
-#[derive(Debug, 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 occurred when attempting to parse a value from an external format to BSON.
+    #[error("Invalid value: {message}")]
+    #[non_exhaustive]
+    InvalidValue { message: String },
+
     /// Malformed BSON bytes were encountered.
     #[error("Malformed BSON: {message}")]
     #[non_exhaustive]
-    MalformedValue { message: String },
+    MalformedBytes { message: String },
 
     /// Invalid UTF-8 bytes were encountered.
     #[error("Invalid UTF-8")]
@@ -78,7 +87,7 @@ impl From<crate::de::Error> for Error {
 }
 
 /// The types of errors that can occur when attempting to access a value in a document.
-#[derive(Debug, Error)]
+#[derive(Clone, Debug, Error)]
 #[non_exhaustive]
 pub enum ValueAccessErrorKind {
     /// No value for the specified key was present in the document.
@@ -134,8 +143,22 @@ impl Error {
         .into()
     }
 
-    pub(crate) fn malformed_value(message: impl ToString) -> Self {
-        ErrorKind::MalformedValue {
+    pub(crate) fn malformed_bytes(message: impl ToString) -> Self {
+        ErrorKind::MalformedBytes {
+            message: message.to_string(),
+        }
+        .into()
+    }
+
+    pub(crate) fn invalid_value(message: impl ToString) -> Self {
+        ErrorKind::InvalidValue {
+            message: message.to_string(),
+        }
+        .into()
+    }
+
+    pub(crate) fn bad_conversion(message: impl ToString) -> Self {
+        ErrorKind::BadConversion {
             message: message.to_string(),
         }
         .into()

src/extjson/de.rs

@@ -25,14 +25,14 @@ use std::convert::{TryFrom, TryInto};
 
 use serde::de::{Error as _, Unexpected};
 
-use crate::{extjson::models, oid, Bson, Document};
+use crate::{extjson::models, Bson, Document};
 
 #[derive(Clone, Debug)]
 #[non_exhaustive]
 /// Error cases that can occur during deserialization from [extended JSON](https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/).
 pub enum Error {
     /// Errors that can occur during OID construction and generation from the input data.
-    InvalidObjectId(oid::Error),
+    InvalidObjectId(crate::error::Error),
 
     /// A general error encountered during deserialization.
     /// See: <https://docs.serde.rs/serde/de/trait.Error.html>
@@ -69,12 +69,6 @@ impl From<serde_json::Error> for Error {
     }
 }
 
-impl From<oid::Error> for Error {
-    fn from(err: oid::Error) -> Self {
-        Self::InvalidObjectId(err)
-    }
-}
-
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// This converts from the input JSON object as if it were [MongoDB Extended JSON v2](https://www.mongodb.com/docs/manual/reference/mongodb-extended-json/).

src/extjson/models.rs

@@ -100,7 +100,8 @@ pub(crate) struct ObjectId {
 
 impl ObjectId {
     pub(crate) fn parse(self) -> extjson::de::Result<oid::ObjectId> {
-        let oid = oid::ObjectId::parse_str(self.oid.as_str())?;
+        let oid = oid::ObjectId::parse_str(self.oid.as_str())
+            .map_err(extjson::de::Error::InvalidObjectId)?;
         Ok(oid)
     }
 }

src/oid.rs

@@ -1,21 +1,20 @@
 //! Module containing functionality related to BSON ObjectIds.
 //! For more information, see the documentation for the [`ObjectId`] type.
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+use std::{convert::TryInto, time::SystemTime};
 use std::{
-    error,
     fmt,
-    result,
     str::FromStr,
     sync::atomic::{AtomicUsize, Ordering},
 };
 
-#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
-use std::{convert::TryInto, time::SystemTime};
-
 use hex::{self, FromHexError};
 use once_cell::sync::Lazy;
 use rand::{random, rng, Rng};
 
+use crate::error::{Error, Result};
+
 const TIMESTAMP_SIZE: usize = 4;
 const PROCESS_ID_SIZE: usize = 5;
 const COUNTER_SIZE: usize = 3;
@@ -29,49 +28,6 @@ const MAX_U24: usize = 0xFF_FFFF;
 static OID_COUNTER: Lazy<AtomicUsize> =
     Lazy::new(|| AtomicUsize::new(rng().random_range(0..=MAX_U24)));
 
-/// Errors that can occur during [`ObjectId`] construction and generation.
-#[derive(Clone, Debug)]
-#[non_exhaustive]
-pub enum Error {
-    /// An invalid character was found in the provided hex string. Valid characters are: `0...9`,
-    /// `a...f`, or `A...F`.
-    #[non_exhaustive]
-    InvalidHexStringCharacter { c: char, index: usize, hex: String },
-
-    /// An [`ObjectId`]'s hex string representation must be an exactly 12-byte (24-char)
-    /// hexadecimal string.
-    #[non_exhaustive]
-    InvalidHexStringLength { length: usize, hex: String },
-}
-
-/// Alias for Result<T, oid::Error>.
-pub type Result<T> = result::Result<T, Error>;
-
-impl fmt::Display for Error {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            Error::InvalidHexStringCharacter { c, index, hex } => {
-                write!(
-                    fmt,
-                    "invalid character '{}' was found at index {} in the provided hex string: \
-                     \"{}\"",
-                    c, index, hex
-                )
-            }
-            Error::InvalidHexStringLength { length, hex } => {
-                write!(
-                    fmt,
-                    "provided hex string representation must be exactly 12 bytes, instead got: \
-                     \"{}\", length {}",
-                    hex, length
-                )
-            }
-        }
-    }
-}
-
-impl error::Error for Error {}
-
 /// A wrapper around a raw 12-byte ObjectId.
 ///
 /// ## `serde` integration
@@ -198,24 +154,22 @@ impl ObjectId {
     pub fn parse_str(s: impl AsRef<str>) -> Result<ObjectId> {
         let s = s.as_ref();
 
-        let bytes: Vec<u8> = hex::decode(s.as_bytes()).map_err(|e| match e {
-            FromHexError::InvalidHexCharacter { c, index } => Error::InvalidHexStringCharacter {
-                c,
-                index,
-                hex: s.to_string(),
-            },
-            FromHexError::InvalidStringLength | FromHexError::OddLength => {
-                Error::InvalidHexStringLength {
-                    length: s.len(),
-                    hex: s.to_string(),
+        let bytes: Vec<u8> = hex::decode(s.as_bytes()).map_err(|e| {
+            let message = match e {
+                FromHexError::InvalidHexCharacter { c, index } => {
+                    format!("invalid hex character {c} encountered at index {index}")
+                }
+                FromHexError::InvalidStringLength | FromHexError::OddLength => {
+                    format!("invalid hex string length {}", s.len())
                 }
-            }
+            };
+            Error::invalid_value(message)
         })?;
         if bytes.len() != 12 {
-            Err(Error::InvalidHexStringLength {
-                length: s.len(),
-                hex: s.to_string(),
-            })
+            Err(Error::invalid_value(format!(
+                "invalid object ID byte vector length {}",
+                bytes.len()
+            )))
         } else {
             let mut byte_array: [u8; 12] = [0; 12];
             byte_array[..].copy_from_slice(&bytes[..]);