RUST-2019 Respect pretty printing flag for Document and Bson

src/bson.rs

@@ -134,19 +134,38 @@ impl Display for Bson {
             Bson::Array(ref vec) => {
                 fmt.write_str("[")?;
 
+                let indent_str;
+                if let Some(width) = fmt.width() {
+                    indent_str = " ".repeat(width);
+                } else {
+                    indent_str = "".to_string();
+                }
+
                 let mut first = true;
                 for bson in vec {
                     if !first {
                         fmt.write_str(", ")?;
                     }
-
-                    write!(fmt, "{}", bson)?;
+                    if fmt.alternate() {
+                        write!(fmt, "\n {indent_str}{}", bson)?;
+                    } else {
+                        write!(fmt, "{}", bson)?;
+                    }
                     first = false;
                 }
-
-                fmt.write_str("]")
+                if fmt.alternate() && !vec.is_empty() {
+                    write!(fmt, "\n{indent_str}]")
+                } else {
+                    fmt.write_str("]")
+                }
+            }
+            Bson::Document(ref doc) => {
+                if fmt.alternate() {
+                    write!(fmt, "{doc:#}")
+                } else {
+                    write!(fmt, "{doc}")
+                }
             }
-            Bson::Document(ref doc) => write!(fmt, "{}", doc),
             Bson::Boolean(b) => write!(fmt, "{}", b),
             Bson::Null => write!(fmt, "null"),
             Bson::RegularExpression(ref x) => write!(fmt, "{}", x),

src/document.rs

@@ -80,21 +80,56 @@ impl Hash for Document {
 
 impl Display for Document {
     fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
-        fmt.write_str("{")?;
+        let indent_str;
+        if let Some(width) = fmt.width() {
+            indent_str = " ".repeat(width);
+        } else {
+            indent_str = "".to_string();
+        }
+        write!(fmt, "{{")?;
+        if fmt.alternate() && !self.inner.is_empty() {
+            fmt.write_str("\n")?;
+        }
 
         let mut first = true;
         for (k, v) in self {
             if first {
                 first = false;
-                fmt.write_str(" ")?;
+                write!(fmt, " ")?;
             } else {
-                fmt.write_str(", ")?;
+                fmt.write_str(if fmt.alternate() { ",\n " } else { ", " })?;
             }
 
-            write!(fmt, "\"{}\": {}", k, v)?;
+            if fmt.alternate() {
+                let mut indent;
+                if let Some(width) = fmt.width() {
+                    indent = width;
+                } else {
+                    indent = 0;
+                }
+                match v {
+                    Bson::Document(ref doc) => {
+                        indent += 1;
+                        write!(fmt, "{indent_str}\"{}\": {doc:#indent$}", k)?;
+                    }
+                    Bson::Array(_arr) => {
+                        indent += 1;
+                        write!(fmt, "{indent_str}\"{}\": {v:#indent$}", k)?;
+                    }
+                    _ => {
+                        write!(fmt, "{indent_str}\"{}\": {}", k, v)?;
+                    }
+                }
+            } else {
+                write!(fmt, "{indent_str}\"{}\": {}", k, v)?;
+            }
         }
 
-        write!(fmt, "{}}}", if !first { " " } else { "" })
+        if fmt.alternate() && !self.inner.is_empty() {
+            write!(fmt, "\n{indent_str}}}")
+        } else {
+            write!(fmt, "{}}}", if !first { " " } else { "" })
+        }
     }
 }
 

src/tests/modules/document.rs

@@ -245,3 +245,113 @@ fn extend() {
         },
     );
 }
+
+#[test]
+fn test_display_empty_doc() {
+    let empty_expectation = "{}";
+    let doc = doc! {};
+    let doc_display = format!("{doc}");
+    assert_eq!(empty_expectation, doc_display);
+
+    let doc_display_pretty = format!("{doc:#}");
+    assert_eq!(empty_expectation, doc_display_pretty);
+}
+
+#[test]
+fn test_display_doc() {
+    let doc = doc! {
+        "hello": "world"
+    };
+
+    let doc_display_expectation = "{ \"hello\": \"world\" }";
+    assert_eq!(doc_display_expectation, format!("{doc}"));
+
+    let doc_display_pretty_expectation = r#"{
+ "hello": "world"
+}"#;
+    assert_eq!(doc_display_pretty_expectation, format!("{doc:#}"));
+}
+
+#[test]
+fn test_display_nested_doc() {
+    let doc = doc! {
+        "hello": {
+            "hello": 2
+        }
+    };
+
+    let doc_display_expectation = "{ \"hello\": { \"hello\": 2 } }";
+    assert_eq!(doc_display_expectation, format!("{doc}"));
+
+    let doc_display_pretty_expectation = r#"{
+ "hello": {
+  "hello": 2
+ }
+}"#;
+    let formatted = format!("{doc:#}");
+    assert_eq!(doc_display_pretty_expectation, formatted);
+}
+
+#[test]
+fn test_display_doc_with_array() {
+    let doc = doc! {
+        "hello": [1, 2, 3]
+    };
+
+    let doc_display_expectation = "{ \"hello\": [1, 2, 3] }";
+    assert_eq!(doc_display_expectation, format!("{doc}"));
+
+    let doc_display_pretty_expectation = r#"{
+ "hello": [
+  1, 
+  2, 
+  3
+ ]
+}"#;
+    let formatted = format!("{doc:#}");
+    assert_eq!(doc_display_pretty_expectation, formatted);
+}
+
+#[test]
+fn test_pretty_printing() {
+    let d = doc! { "hello": "world!", "world": "hello", "key": "val" };
+    let expected = r#"{ "hello": "world!", "world": "hello", "key": "val" }"#;
+    let formatted = format!("{d}");
+    assert_eq!(
+        expected, formatted,
+        "expected:\n{expected}\ngot:\n{formatted}"
+    );
+
+    let d = doc! { "hello": "world!", "nested": { "key": "val", "double": { "a": "thing" } } };
+    let expected = r#"{
+ "hello": "world!",
+ "nested": {
+  "key": "val",
+  "double": {
+   "a": "thing"
+  }
+ }
+}"#;
+    let formatted = format!("{d:#}");
+    assert_eq!(
+        expected, formatted,
+        "expected:\n{expected}\ngot:\n{formatted}"
+    );
+
+    let d =
+        doc! { "hello": "world!", "nested": { "key": "val", "double": { "a": [1, 2], "c": "d"} } };
+    let expected = r#"{
+ "hello": "world!",
+ "nested": {
+  "key": "val",
+  "double": {
+   "a": [
+    1, 
+    2
+   ],
+   "c": "d"
+  }
+ }
+}"#;
+    assert_eq!(expected, format!("{d:#}"));
+}