create binary error type

Author: sanav33

src/binary.rs

@@ -0,0 +1,77 @@
+pub mod error;
+use std::fmt::{self, Display};
+use crate::{spec::BinarySubtype, RawBinaryRef, Document, binary::error::{Result, Error}};
+use std::convert::TryFrom;
+
+/// Represents a BSON binary value.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Binary {
+    /// The subtype of the bytes.
+    pub subtype: BinarySubtype,
+
+    /// The binary bytes.
+    pub bytes: Vec<u8>,
+}
+
+impl Display for Binary {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            fmt,
+            "Binary({:#x}, {})",
+            u8::from(self.subtype),
+            base64::encode(&self.bytes)
+        )
+    }
+}
+
+impl Binary {
+    /// Creates a [`Binary`] from a base64 string and optional [`BinarySubtype`]. If the
+    /// `subtype` argument is `None`, the [`Binary`] constructed will default to
+    /// [`BinarySubtype::Generic`].
+    pub fn from_base64(
+        input: &str,
+        subtype: impl Into<Option<BinarySubtype>>,
+    ) -> Result<Self> {
+        let bytes = base64::decode(input).map_err(|_| Error::DecodingError)?;
+        let subtype = match subtype.into() {
+            Some(s) => s,
+            None => BinarySubtype::Generic,
+        };
+        Ok(Binary { subtype, bytes })
+    }
+
+    pub(crate) fn from_extended_doc(doc: &Document) -> Option<Self> {
+        let binary_doc = doc.get_document("$binary").ok()?;
+
+        if let Ok(bytes) = binary_doc.get_str("base64") {
+            let bytes = base64::decode(bytes).ok()?;
+            let subtype = binary_doc.get_str("subType").ok()?;
+            let subtype = hex::decode(subtype).ok()?;
+            if subtype.len() == 1 {
+                Some(Self {
+                    bytes,
+                    subtype: subtype[0].into(),
+                })
+            } else {
+                None
+            }
+        } else {
+            // in non-human-readable mode, RawBinary will serialize as
+            // { "$binary": { "bytes": <bytes>, "subType": <i32> } };
+            let binary = binary_doc.get_binary_generic("bytes").ok()?;
+            let subtype = binary_doc.get_i32("subType").ok()?;
+
+            Some(Self {
+                bytes: binary.clone(),
+                subtype: u8::try_from(subtype).ok()?.into(),
+            })
+        }
+    }
+
+    pub(crate) fn as_raw_binary(&self) -> RawBinaryRef<'_> {
+        RawBinaryRef {
+            bytes: self.bytes.as_slice(),
+            subtype: self.subtype,
+        }
+    }
+}

src/binary/error.rs

@@ -0,0 +1,21 @@
+use std::{error, fmt};
+
+/// Possible errors that can arise during [`Binary`] construction.
+#[derive(Clone, Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// While trying to decode from base64, an error was returned.
+    DecodingError,
+}
+
+impl error::Error for Error {}
+
+impl std::fmt::Display for Error {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Error::DecodingError => fmt.write_str("couldn't decode to binary"),
+        }
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

src/bson.rs

@@ -26,15 +26,14 @@ use std::{
     fmt::{self, Debug, Display, Formatter},
 };
 
-use base64::DecodeError;
 use serde_json::{json, Value};
 
 pub use crate::document::Document;
 use crate::{
     oid::{self, ObjectId},
     spec::{BinarySubtype, ElementType},
     Decimal128,
-    RawBinaryRef,
+    binary::Binary,
 };
 
 /// Possible BSON value types.
@@ -1081,79 +1080,6 @@ impl Display for JavaScriptCodeWithScope {
     }
 }
 
-/// Represents a BSON binary value.
-#[derive(Debug, Clone, PartialEq)]
-pub struct Binary {
-    /// The subtype of the bytes.
-    pub subtype: BinarySubtype,
-
-    /// The binary bytes.
-    pub bytes: Vec<u8>,
-}
-
-impl Display for Binary {
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            fmt,
-            "Binary({:#x}, {})",
-            u8::from(self.subtype),
-            base64::encode(&self.bytes)
-        )
-    }
-}
-
-impl Binary {
-    /// Creates a [`Binary`] from a base64 string and optional [`BinarySubtype`]. If the
-    /// `subtype` argument is `None`, the [`Binary`] constructed will default to
-    /// [`BinarySubtype::Generic`].
-    pub fn from_base64(
-        input: &str,
-        subtype: impl Into<Option<BinarySubtype>>,
-    ) -> Result<Self, DecodeError> {
-        let bytes = base64::decode(input)?;
-        let subtype = match subtype.into() {
-            Some(s) => s,
-            None => BinarySubtype::Generic,
-        };
-        Ok(Binary { subtype, bytes })
-    }
-
-    pub(crate) fn from_extended_doc(doc: &Document) -> Option<Self> {
-        let binary_doc = doc.get_document("$binary").ok()?;
-
-        if let Ok(bytes) = binary_doc.get_str("base64") {
-            let bytes = base64::decode(bytes).ok()?;
-            let subtype = binary_doc.get_str("subType").ok()?;
-            let subtype = hex::decode(subtype).ok()?;
-            if subtype.len() == 1 {
-                Some(Self {
-                    bytes,
-                    subtype: subtype[0].into(),
-                })
-            } else {
-                None
-            }
-        } else {
-            // in non-human-readable mode, RawBinary will serialize as
-            // { "$binary": { "bytes": <bytes>, "subType": <i32> } };
-            let binary = binary_doc.get_binary_generic("bytes").ok()?;
-            let subtype = binary_doc.get_i32("subType").ok()?;
-
-            Some(Self {
-                bytes: binary.clone(),
-                subtype: u8::try_from(subtype).ok()?.into(),
-            })
-        }
-    }
-
-    pub(crate) fn as_raw_binary(&self) -> RawBinaryRef<'_> {
-        RawBinaryRef {
-            bytes: self.bytes.as_slice(),
-            subtype: self.subtype,
-        }
-    }
-}
-
 /// Represents a DBPointer. (Deprecated)
 #[derive(Debug, Clone, PartialEq)]
 pub struct DbPointer {

src/de/mod.rs

@@ -33,7 +33,8 @@ pub use self::{
 use std::io::Read;
 
 use crate::{
-    bson::{Array, Binary, Bson, DbPointer, Document, JavaScriptCodeWithScope, Regex, Timestamp},
+    bson::{Array, Bson, DbPointer, Document, JavaScriptCodeWithScope, Regex, Timestamp},
+    binary::Binary,
     oid::{self, ObjectId},
     raw::RawBinaryRef,
     ser::write_i32,

src/de/serde.rs

@@ -21,7 +21,8 @@ use serde::de::{
 use serde_bytes::ByteBuf;
 
 use crate::{
-    bson::{Binary, Bson, DbPointer, JavaScriptCodeWithScope, Regex, Timestamp},
+    bson::{Bson, DbPointer, JavaScriptCodeWithScope, Regex, Timestamp},
+    binary::Binary,
     datetime::DateTime,
     document::{Document, IntoIter},
     oid::ObjectId,

src/document.rs

@@ -13,8 +13,9 @@ use indexmap::IndexMap;
 use serde::de::Error;
 
 use crate::{
-    bson::{Array, Binary, Bson, Timestamp},
+    bson::{Array, Bson, Timestamp},
     de::{deserialize_bson_kvp, ensure_read_exactly, read_i32, MIN_BSON_DOCUMENT_SIZE},
+    binary::Binary,
     oid::ObjectId,
     ser::{serialize_bson, write_i32},
     spec::BinarySubtype,

src/lib.rs

@@ -269,8 +269,9 @@
 
 #[doc(inline)]
 pub use self::{
-    bson::{Array, Binary, Bson, DbPointer, Document, JavaScriptCodeWithScope, Regex, Timestamp},
+    bson::{Array, Bson, DbPointer, Document, JavaScriptCodeWithScope, Regex, Timestamp},
     datetime::DateTime,
+    binary::Binary,
     de::{
         from_bson, from_bson_with_options, from_document, from_document_with_options, from_reader,
         from_reader_utf8_lossy, from_slice, from_slice_utf8_lossy, Deserializer,
@@ -291,6 +292,7 @@ pub use self::{
 #[macro_use]
 mod macros;
 mod bson;
+pub mod binary;
 pub mod datetime;
 pub mod de;
 pub mod decimal128;