restructure, maintain oid structure

Author: isabelatkinson

src/error.rs

@@ -1,12 +1,14 @@
 mod datetime;
+mod oid;
 mod uuid;
+mod value_access;
 
 use thiserror::Error;
 
-use crate::spec::ElementType;
-
 pub use datetime::DateTimeErrorKind;
+pub use oid::ObjectIdErrorKind;
 pub use uuid::UuidErrorKind;
+pub use value_access::ValueAccessErrorKind;
 
 pub type Result<T> = std::result::Result<T, Error>;
 
@@ -63,6 +65,13 @@ pub enum ErrorKind {
         message: String,
     },
 
+    /// An error related to the [`ObjectId`](crate::oid::ObjectId) type occurred.
+    #[error("An ObjectId-related error occurred: {kind}")]
+    ObjectId {
+        /// The kind of error that occurred.
+        kind: ObjectIdErrorKind,
+    },
+
     /// Invalid UTF-8 bytes were encountered.
     #[error("Invalid UTF-8")]
     Utf8Encoding,
@@ -93,31 +102,6 @@ impl From<ErrorKind> for Error {
     }
 }
 
-/// The types of errors that can occur when attempting to access a value in a document.
-#[derive(Clone, Debug, Error)]
-#[non_exhaustive]
-pub enum ValueAccessErrorKind {
-    /// No value for the specified key was present in the document.
-    #[error("The key was not present in the document")]
-    NotPresent,
-
-    /// The type of the value in the document did not match the requested type.
-    #[error("Expected type {expected:?}, got type {actual:?}")]
-    #[non_exhaustive]
-    UnexpectedType {
-        /// The actual type of the value.
-        actual: ElementType,
-
-        /// The expected type of the value.
-        expected: ElementType,
-    },
-
-    /// An error occurred when attempting to parse the document's BSON bytes.
-    #[error("{message}")]
-    #[non_exhaustive]
-    InvalidBson { message: String },
-}
-
 impl Error {
     pub(crate) fn with_key(mut self, key: impl Into<String>) -> Self {
         self.key = Some(key.into());
@@ -129,27 +113,6 @@ impl Error {
         self
     }
 
-    pub(crate) fn value_access_not_present() -> Self {
-        ErrorKind::ValueAccess {
-            kind: ValueAccessErrorKind::NotPresent,
-        }
-        .into()
-    }
-
-    pub(crate) fn value_access_unexpected_type(actual: ElementType, expected: ElementType) -> Self {
-        ErrorKind::ValueAccess {
-            kind: ValueAccessErrorKind::UnexpectedType { actual, expected },
-        }
-        .into()
-    }
-
-    pub(crate) fn value_access_invalid_bson(message: String) -> Self {
-        ErrorKind::ValueAccess {
-            kind: ValueAccessErrorKind::InvalidBson { message },
-        }
-        .into()
-    }
-
     pub(crate) fn malformed_bytes(message: impl ToString) -> Self {
         ErrorKind::MalformedBytes {
             message: message.to_string(),
@@ -163,26 +126,4 @@ impl Error {
         }
         .into()
     }
-
-    #[cfg(test)]
-    pub(crate) fn is_value_access_not_present(&self) -> bool {
-        matches!(
-            self.kind,
-            ErrorKind::ValueAccess {
-                kind: ValueAccessErrorKind::NotPresent,
-                ..
-            }
-        )
-    }
-
-    #[cfg(test)]
-    pub(crate) fn is_value_access_unexpected_type(&self) -> bool {
-        matches!(
-            self.kind,
-            ErrorKind::ValueAccess {
-                kind: ValueAccessErrorKind::UnexpectedType { .. },
-                ..
-            }
-        )
-    }
 }

src/error/datetime.rs

@@ -2,6 +2,7 @@ use thiserror::Error as ThisError;
 
 use crate::error::{Error, ErrorKind};
 
+/// The kinds of errors that can occur when working with the [`DateTime`](crate::DateTime) type.
 #[derive(Clone, Debug, ThisError)]
 pub enum DateTimeErrorKind {
     /// The `DateTime` could not be formatted.

src/error/oid.rs

@@ -0,0 +1,51 @@
+use hex::FromHexError;
+use thiserror::Error as ThisError;
+
+use crate::error::{Error, ErrorKind};
+
+/// The kinds of errors that can occur when working with the [`ObjectId`](crate::oid::ObjectId)
+/// type.
+#[derive(Clone, Debug, ThisError)]
+pub enum ObjectIdErrorKind {
+    /// An invalid character was found in the provided hex string. Valid characters are: `0...9`,
+    /// `a...f`, or `A...F`.
+    #[error("invalid character '{c}' encountered at index {index}")]
+    #[non_exhaustive]
+    InvalidHexStringCharacter {
+        /// The invalid character.
+        c: char,
+
+        /// The index at which the invalid character was encountered.
+        index: usize,
+    },
+
+    /// An `ObjectId` with an invalid length was encountered.
+    #[error("invalid hex string length {length}")]
+    #[non_exhaustive]
+    InvalidHexStringLength {
+        /// The length of the invalid hex string.
+        length: usize,
+    },
+}
+
+impl Error {
+    // This method is not a From implementation so that it is not part of the public API.
+    pub(crate) fn from_hex_error(error: FromHexError, length: usize) -> Self {
+        let kind = match error {
+            FromHexError::InvalidHexCharacter { c, index } => {
+                ObjectIdErrorKind::InvalidHexStringCharacter { c, index }
+            }
+            FromHexError::InvalidStringLength | FromHexError::OddLength => {
+                ObjectIdErrorKind::InvalidHexStringLength { length }
+            }
+        };
+        ErrorKind::ObjectId { kind }.into()
+    }
+
+    pub(crate) fn oid_invalid_length(length: usize) -> Self {
+        ErrorKind::ObjectId {
+            kind: ObjectIdErrorKind::InvalidHexStringLength { length },
+        }
+        .into()
+    }
+}

src/error/value_access.rs

@@ -0,0 +1,76 @@
+use thiserror::Error as ThisError;
+
+use crate::{
+    error::{Error, ErrorKind},
+    spec::ElementType,
+};
+
+/// The types of errors that can occur when attempting to access a value in a document.
+#[derive(Clone, Debug, ThisError)]
+#[non_exhaustive]
+pub enum ValueAccessErrorKind {
+    /// No value for the specified key was present in the document.
+    #[error("the key was not present in the document")]
+    NotPresent,
+
+    /// The type of the value in the document did not match the requested type.
+    #[error("expected type {expected:?}, got type {actual:?}")]
+    #[non_exhaustive]
+    UnexpectedType {
+        /// The actual type of the value.
+        actual: ElementType,
+
+        /// The expected type of the value.
+        expected: ElementType,
+    },
+
+    /// An error occurred when attempting to parse the document's BSON bytes.
+    #[error("{message}")]
+    #[non_exhaustive]
+    InvalidBson { message: String },
+}
+
+impl Error {
+    pub(crate) fn value_access_not_present() -> Self {
+        ErrorKind::ValueAccess {
+            kind: ValueAccessErrorKind::NotPresent,
+        }
+        .into()
+    }
+
+    pub(crate) fn value_access_unexpected_type(actual: ElementType, expected: ElementType) -> Self {
+        ErrorKind::ValueAccess {
+            kind: ValueAccessErrorKind::UnexpectedType { actual, expected },
+        }
+        .into()
+    }
+
+    pub(crate) fn value_access_invalid_bson(message: String) -> Self {
+        ErrorKind::ValueAccess {
+            kind: ValueAccessErrorKind::InvalidBson { message },
+        }
+        .into()
+    }
+
+    #[cfg(test)]
+    pub(crate) fn is_value_access_not_present(&self) -> bool {
+        matches!(
+            self.kind,
+            ErrorKind::ValueAccess {
+                kind: ValueAccessErrorKind::NotPresent,
+                ..
+            }
+        )
+    }
+
+    #[cfg(test)]
+    pub(crate) fn is_value_access_unexpected_type(&self) -> bool {
+        matches!(
+            self.kind,
+            ErrorKind::ValueAccess {
+                kind: ValueAccessErrorKind::UnexpectedType { .. },
+                ..
+            }
+        )
+    }
+}

src/oid.rs

@@ -9,7 +9,6 @@ use std::{
     sync::atomic::{AtomicUsize, Ordering},
 };
 
-use hex::{self, FromHexError};
 use once_cell::sync::Lazy;
 use rand::{random, rng, Rng};
 
@@ -154,22 +153,10 @@ 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| {
-            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)
-        })?;
+        let bytes: Vec<u8> =
+            hex::decode(s.as_bytes()).map_err(|e| Error::from_hex_error(e, s.len()))?;
         if bytes.len() != 12 {
-            Err(Error::invalid_value(format!(
-                "invalid object ID byte vector length {}",
-                bytes.len()
-            )))
+            Err(Error::oid_invalid_length(bytes.len()))
         } else {
             let mut byte_array: [u8; 12] = [0; 12];
             byte_array[..].copy_from_slice(&bytes[..]);