Revert "Revert "Merge branch 'master' of https://github.com/mongodb/bson-rust""

This reverts commit 1fff644.
This puts back the commits that were accidentally reverted when the
merge commit was reverted.

Author: patrickfreed

src/bson.rs

@@ -21,7 +21,7 @@
 
 //! BSON definition
 
-use std::fmt::{self, Debug, Display};
+use std::fmt::{self, Debug, Display, Formatter};
 
 use chrono::Datelike;
 use serde_json::{json, Value};
@@ -34,7 +34,7 @@ use crate::{
 };
 
 /// Possible BSON value types.
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub enum Bson {
     /// 64-bit binary floating point
     Double(f64),
@@ -146,6 +146,40 @@ impl Display for Bson {
     }
 }
 
+impl Debug for Bson {
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        match *self {
+            Bson::Double(f) => fmt.debug_tuple("Double").field(&f).finish(),
+            Bson::String(ref s) => fmt.debug_tuple("String").field(s).finish(),
+            Bson::Array(ref vec) => {
+                write!(fmt, "Array(")?;
+                Debug::fmt(vec, fmt)?;
+                write!(fmt, ")")
+            }
+            Bson::Document(ref doc) => Debug::fmt(doc, fmt),
+            Bson::Boolean(b) => fmt.debug_tuple("Boolean").field(&b).finish(),
+            Bson::Null => write!(fmt, "Null"),
+            Bson::RegularExpression(ref regex) => Debug::fmt(regex, fmt),
+            Bson::JavaScriptCode(ref code) => {
+                fmt.debug_tuple("JavaScriptCode").field(code).finish()
+            }
+            Bson::JavaScriptCodeWithScope(ref code) => Debug::fmt(code, fmt),
+            Bson::Int32(i) => fmt.debug_tuple("Int32").field(&i).finish(),
+            Bson::Int64(i) => fmt.debug_tuple("Int64").field(&i).finish(),
+            Bson::Timestamp(ref t) => Debug::fmt(t, fmt),
+            Bson::Binary(ref b) => Debug::fmt(b, fmt),
+            Bson::ObjectId(ref id) => Debug::fmt(id, fmt),
+            Bson::DateTime(ref date_time) => Debug::fmt(date_time, fmt),
+            Bson::Symbol(ref sym) => fmt.debug_tuple("Symbol").field(sym).finish(),
+            Bson::Decimal128(ref d) => Debug::fmt(d, fmt),
+            Bson::Undefined => write!(fmt, "Undefined"),
+            Bson::MinKey => write!(fmt, "MinKey"),
+            Bson::MaxKey => write!(fmt, "MaxKey"),
+            Bson::DbPointer(ref pointer) => Debug::fmt(pointer, fmt),
+        }
+    }
+}
+
 impl From<f32> for Bson {
     fn from(a: f32) -> Bson {
         Bson::Double(a as f64)

src/datetime.rs

@@ -70,7 +70,7 @@ impl crate::DateTime {
 
     /// Returns a [`DateTime`] which corresponds to the current date and time.
     pub fn now() -> DateTime {
-        Self::from_chrono(Utc::now())
+        Self::from_system_time(SystemTime::now())
     }
 
     #[cfg(not(feature = "chrono-0_4"))]

src/document.rs

@@ -92,8 +92,10 @@ impl Display for Document {
 }
 
 impl Debug for Document {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "Document({:?})", self.inner)
+    fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
+        write!(fmt, "Document(")?;
+        Debug::fmt(&self.inner, fmt)?;
+        write!(fmt, ")")
     }
 }
 

src/oid.rs

@@ -163,7 +163,7 @@ impl ObjectId {
     }
 
     /// Returns the raw byte representation of an ObjectId.
-    pub fn bytes(&self) -> [u8; 12] {
+    pub const fn bytes(&self) -> [u8; 12] {
         self.id
     }
 
@@ -223,7 +223,7 @@ impl fmt::Display for ObjectId {
 
 impl fmt::Debug for ObjectId {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(&format!("ObjectId({})", self.to_hex()))
+        f.debug_tuple("ObjectId").field(&self.to_hex()).finish()
     }
 }
 
@@ -301,7 +301,14 @@ mod test {
     fn test_debug() {
         let id = super::ObjectId::parse_str("53e37d08776f724e42000000").unwrap();
 
-        assert_eq!(format!("{:?}", id), "ObjectId(53e37d08776f724e42000000)")
+        assert_eq!(
+            format!("{:?}", id),
+            "ObjectId(\"53e37d08776f724e42000000\")"
+        );
+        assert_eq!(
+            format!("{:#?}", id),
+            "ObjectId(\n    \"53e37d08776f724e42000000\",\n)"
+        );
     }
 
     #[test]

src/ser/error.rs

@@ -14,7 +14,7 @@ pub enum Error {
     /// A key could not be serialized to a BSON string.
     InvalidDocumentKey(Bson),
 
-    /// A general error that ocurred during serialization.
+    /// A general error that occurred during serialization.
     /// See: https://docs.rs/serde/1.0.110/serde/ser/trait.Error.html#tymethod.custom
     #[non_exhaustive]
     SerializationError {

src/tests/modules/bson.rs

@@ -306,3 +306,43 @@ fn system_time() {
         0
     );
 }
+
+#[test]
+fn debug_print() {
+    let oid = ObjectId::parse_str("000000000000000000000000").unwrap();
+
+    let doc = doc! {
+        "oid": oid,
+        "arr": Bson::Array(vec! [
+            Bson::Null,
+            Bson::Timestamp(Timestamp { time: 1, increment: 1 }),
+        ]),
+        "doc": doc! { "a": 1, "b": "data"},
+    };
+    let normal_print = "Document({\"oid\": ObjectId(\"000000000000000000000000\"), \"arr\": \
+                        Array([Null, Timestamp { time: 1, increment: 1 }]), \"doc\": \
+                        Document({\"a\": Int32(1), \"b\": String(\"data\")})})";
+    let pretty_print = "Document({
+    \"oid\": ObjectId(
+        \"000000000000000000000000\",
+    ),
+    \"arr\": Array([
+        Null,
+        Timestamp {
+            time: 1,
+            increment: 1,
+        },
+    ]),
+    \"doc\": Document({
+        \"a\": Int32(
+            1,
+        ),
+        \"b\": String(
+            \"data\",
+        ),
+    }),
+})";
+
+    assert_eq!(format!("{:?}", doc), normal_print);
+    assert_eq!(format!("{:#?}", doc), pretty_print);
+}