initial slash

Author: abr-egn

src/datetime.rs

@@ -386,13 +386,6 @@ impl crate::DateTime {
         }
     }
 
-    #[deprecated(since = "2.3.0", note = "Use try_to_rfc3339_string instead.")]
-    /// Convert this [`DateTime`] to an RFC 3339 formatted string.  Panics if it could not be
-    /// represented in that format.
-    pub fn to_rfc3339_string(self) -> String {
-        self.try_to_rfc3339_string().unwrap()
-    }
-
     /// Convert this [`DateTime`] to an RFC 3339 formatted string.
     pub fn try_to_rfc3339_string(self) -> Result<String> {
         self.to_time_0_3()

src/de.rs

@@ -137,40 +137,12 @@ where
     from_slice(bytes.as_slice())
 }
 
-/// Deserialize an instance of type `T` from an I/O stream of BSON, replacing any invalid UTF-8
-/// sequences with the Unicode replacement character.
-///
-/// This is mainly useful when reading raw BSON returned from a MongoDB server, which
-/// in rare cases can contain invalidly truncated strings (<https://jira.mongodb.org/browse/SERVER-24007>).
-/// For most use cases, [`crate::from_reader`] can be used instead.
-pub fn from_reader_utf8_lossy<R, T>(reader: R) -> Result<T>
-where
-    T: DeserializeOwned,
-    R: Read,
-{
-    let bytes = reader_to_vec(reader)?;
-    from_slice_utf8_lossy(bytes.as_slice())
-}
-
 /// Deserialize an instance of type `T` from a slice of BSON bytes.
 pub fn from_slice<'de, T>(bytes: &'de [u8]) -> Result<T>
 where
     T: Deserialize<'de>,
 {
-    from_raw(raw::Deserializer::new(bytes, false)?)
-}
-
-/// Deserialize an instance of type `T` from a slice of BSON bytes, replacing any invalid UTF-8
-/// sequences with the Unicode replacement character.
-///
-/// This is mainly useful when reading raw BSON returned from a MongoDB server, which
-/// in rare cases can contain invalidly truncated strings (<https://jira.mongodb.org/browse/SERVER-24007>).
-/// For most use cases, [`crate::from_slice`] can be used instead.
-pub fn from_slice_utf8_lossy<'de, T>(bytes: &'de [u8]) -> Result<T>
-where
-    T: Deserialize<'de>,
-{
-    from_raw(raw::Deserializer::new(bytes, true)?)
+    from_raw(raw::Deserializer::new(bytes)?)
 }
 
 pub(crate) fn from_raw<'de, T: Deserialize<'de>>(

src/de/raw.rs

@@ -50,11 +50,11 @@ struct DeserializerOptions {
 }
 
 impl<'de> Deserializer<'de> {
-    pub(crate) fn new(buf: &'de [u8], utf8_lossy: bool) -> Result<Self> {
+    pub(crate) fn new(buf: &'de [u8]) -> Result<Self> {
         Ok(Self {
             element: RawElement::toplevel(buf)?,
             options: DeserializerOptions {
-                utf8_lossy,
+                utf8_lossy: false,
                 human_readable: false,
             },
         })

src/document.rs

@@ -598,9 +598,9 @@ impl Document {
         Ok(())
     }
 
-    fn decode<R: Read + ?Sized>(reader: &mut R, utf_lossy: bool) -> crate::de::Result<Document> {
+    fn decode<R: Read + ?Sized>(reader: &mut R) -> crate::de::Result<Document> {
         let buf = crate::de::reader_to_vec(reader)?;
-        crate::de::from_raw(crate::de::RawDeserializer::new(&buf, utf_lossy)?)
+        crate::de::from_raw(crate::de::RawDeserializer::new(&buf)?)
     }
 
     /// Attempts to deserialize a [`Document`] from a byte stream.
@@ -632,18 +632,7 @@ impl Document {
     /// # }
     /// ```
     pub fn from_reader<R: Read>(mut reader: R) -> crate::de::Result<Document> {
-        Self::decode(&mut reader, false)
-    }
-
-    /// Attempt to deserialize a [`Document`] that may contain invalid UTF-8 strings from a byte
-    /// stream.
-    ///
-    /// This is mainly useful when reading raw BSON returned from a MongoDB server, which
-    /// in rare cases can contain invalidly truncated strings (<https://jira.mongodb.org/browse/SERVER-24007>).
-    /// For most use cases, `Document::from_reader` can be used instead.
-    #[deprecated = "use bson::serde_helpers::Utf8LossyDeserialization"]
-    pub fn from_reader_utf8_lossy<R: Read>(mut reader: R) -> crate::de::Result<Document> {
-        Self::decode(&mut reader, true)
+        Self::decode(&mut reader)
     }
 }
 

src/lib.rs

@@ -308,9 +308,6 @@ pub use self::{
     uuid::{Uuid, UuidRepresentation},
 };
 
-#[allow(deprecated)]
-pub use self::de::{from_reader_utf8_lossy, from_slice_utf8_lossy};
-
 #[macro_use]
 mod macros;
 mod base64;

src/raw/document.rs

@@ -531,6 +531,17 @@ impl RawDocument {
         let bytes = self.cstring_bytes_at(start_at)?;
         try_to_str(bytes)
     }
+
+    /// Copy this into a [`Document`], returning an error if invalid BSON is encountered.
+    pub fn to_document(&self) -> Result<Document> {
+        self.as_ref().try_into()
+    }
+
+    /// Copy this into a [`Document`], returning an error if invalid BSON is encountered.  Any
+    /// invalid UTF-8 sequences will be replaced with the Unicode replacement character.
+    pub fn to_document_utf8_lossy(&self) -> Result<Document> {
+        todo!()
+    }
 }
 
 impl<'de: 'a, 'a> Deserialize<'de> for &'a RawDocument {

src/raw/document_buf.rs

@@ -1,6 +1,6 @@
 use std::{
     borrow::{Borrow, Cow},
-    convert::{TryFrom, TryInto},
+    convert::TryFrom,
     iter::FromIterator,
     ops::Deref,
 };
@@ -66,7 +66,7 @@ pub struct RawDocumentBuf {
 
 impl RawDocumentBuf {
     /// Creates a new, empty [`RawDocumentBuf`].
-    pub fn new() -> RawDocumentBuf {
+    pub fn new() -> Self {
         let mut data = Vec::new();
         data.extend(MIN_BSON_DOCUMENT_SIZE.to_le_bytes());
         data.push(0);
@@ -90,11 +90,16 @@ impl RawDocumentBuf {
     /// let doc = RawDocumentBuf::from_bytes(b"\x05\0\0\0\0".to_vec())?;
     /// # Ok::<(), Error>(())
     /// ```
-    pub fn from_bytes(data: Vec<u8>) -> Result<RawDocumentBuf> {
+    pub fn from_bytes(data: Vec<u8>) -> Result<Self> {
         let _ = RawDocument::from_bytes(data.as_slice())?;
         Ok(Self { data })
     }
 
+    pub fn from_reader<R: std::io::Read>(reader: R) -> Result<Self> {
+        let buf = crate::de::reader_to_vec(reader)?;
+        Self::from_bytes(buf)
+    }
+
     /// Create a [`RawDocumentBuf`] from a [`Document`].
     ///
     /// ```
@@ -222,12 +227,6 @@ impl RawDocumentBuf {
                 .expect("key should not contain interior null byte")
         })
     }
-
-    /// Convert this [`RawDocumentBuf`] to a [`Document`], returning an error
-    /// if invalid BSON is encountered.
-    pub fn to_document(&self) -> Result<Document> {
-        self.as_ref().try_into()
-    }
 }
 
 impl Default for RawDocumentBuf {

src/raw/error.rs

@@ -34,7 +34,7 @@ impl Error {
 }
 
 /// The different categories of errors that can be returned when reading from raw BSON.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug)]
 #[non_exhaustive]
 pub enum ErrorKind {
     /// A BSON value did not fit the proper format.
@@ -43,6 +43,24 @@ pub enum ErrorKind {
 
     /// Improper UTF-8 bytes were found when proper UTF-8 was expected.
     Utf8EncodingError,
+
+    /// A wrapped deserialization error.
+    /// TODO RUST-1406: collapse this
+    DeError(crate::de::Error),
+}
+
+impl PartialEq for ErrorKind {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Self::MalformedValue { message: l_message },
+                Self::MalformedValue { message: r_message },
+            ) => l_message == r_message,
+            (Self::Utf8EncodingError, Self::Utf8EncodingError) => true,
+            (Self::DeError(_), Self::DeError(_)) => true,
+            _ => false,
+        }
+    }
 }
 
 impl std::fmt::Display for Error {
@@ -59,10 +77,17 @@ impl std::fmt::Display for Error {
                 write!(f, "{}malformed value: {:?}", prefix, message)
             }
             ErrorKind::Utf8EncodingError => write!(f, "{}utf-8 encoding error", prefix),
+            ErrorKind::DeError(e) => write!(f, "{}deserialization error: {}", prefix, e),
         }
     }
 }
 
+impl From<crate::de::Error> for Error {
+    fn from(value: crate::de::Error) -> Self {
+        Self::new(ErrorKind::DeError(value))
+    }
+}
+
 impl std::error::Error for Error {}
 
 pub type Result<T> = std::result::Result<T, Error>;

src/serde_helpers.rs

@@ -817,7 +817,8 @@ where
 ///
 /// This wrapper type has no impact on serialization. Serializing a `Utf8LossyDeserialization<T>`
 /// will call the `serialize` method for the wrapped `T`.
-#[derive(PartialEq, Eq, PartialOrd, Ord, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash, Default)]
+#[repr(transparent)]
 pub struct Utf8LossyDeserialization<T>(pub T);
 
 pub(crate) const UTF8_LOSSY_NEWTYPE: &str = "$__bson_private_utf8_lossy";
@@ -852,3 +853,48 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for Utf8LossyDeserialization<T>
         deserializer.deserialize_newtype_struct(UTF8_LOSSY_NEWTYPE, V(PhantomData))
     }
 }
+
+impl<T: std::fmt::Display> std::fmt::Display for Utf8LossyDeserialization<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T> From<T> for Utf8LossyDeserialization<T> {
+    fn from(value: T) -> Self {
+        Self(value)
+    }
+}
+
+impl<T> Deref for Utf8LossyDeserialization<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T> DerefMut for Utf8LossyDeserialization<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<T, R> AsRef<R> for Utf8LossyDeserialization<T>
+where
+    R: ?Sized,
+    <Utf8LossyDeserialization<T> as Deref>::Target: AsRef<R>,
+{
+    fn as_ref(&self) -> &R {
+        self.deref().as_ref()
+    }
+}
+
+impl<T, R: ?Sized> AsMut<R> for Utf8LossyDeserialization<T>
+where
+    <Utf8LossyDeserialization<T> as Deref>::Target: AsMut<R>,
+{
+    fn as_mut(&mut self) -> &mut R {
+        self.deref_mut().as_mut()
+    }
+}

src/tests/modules/serializer_deserializer.rs

@@ -18,6 +18,7 @@ use crate::{
     Decimal128,
     Document,
     JavaScriptCodeWithScope,
+    RawDocumentBuf,
     Regex,
     Timestamp,
 };
@@ -73,8 +74,10 @@ fn test_encode_decode_utf8_string_invalid() {
     doc.to_writer(&mut buf).unwrap();
 
     let expected = doc! { "key": "��" };
-    #[allow(deprecated)]
-    let decoded = Document::from_reader_utf8_lossy(&mut Cursor::new(buf)).unwrap();
+    let decoded = RawDocumentBuf::from_reader(&mut Cursor::new(buf))
+        .unwrap()
+        .to_document_utf8_lossy()
+        .unwrap();
     assert_eq!(decoded, expected);
 }