implement Display for Bson and OrderedDocument

Author: saghm

src/bson.rs

@@ -21,6 +21,9 @@
 
 //! BSON definition
 
+use std::fmt::{Display, Error, Formatter};
+use std::str;
+
 use chrono::{DateTime, UTC};
 use rustc_serialize::json;
 use rustc_serialize::hex::ToHex;
@@ -54,6 +57,60 @@ pub type Array = Vec<Bson>;
 /// Alias for `OrderedDocument`.
 pub type Document = OrderedDocument;
 
+impl Display for Bson {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        let bson_string = match self {
+            &Bson::FloatingPoint(f) => format!("{}", f),
+            &Bson::String(ref s) => format!("\"{}\"", s),
+            &Bson::Array(ref vec) => {
+                let mut string = "[".to_owned();
+
+                for bson in vec.iter() {
+                    if !string.eq("[") {
+                        string.push_str(", ");
+                    }
+
+                    string.push_str(&format!("{}", bson));
+                }
+
+                string.push_str("]");
+                string
+            },
+            &Bson::Document(ref doc) => format!("{}", doc),
+            &Bson::Boolean(b) => format!("{}", b),
+            &Bson::Null => "null".to_owned(),
+            &Bson::RegExp(ref pat, ref opt) => format!("/{}/{}", pat, opt),
+            &Bson::JavaScriptCode(ref s) |
+            &Bson::JavaScriptCodeWithScope(ref s, _) => s.to_owned(),
+            &Bson::I32(i) => format!("{}", i),
+            &Bson::I64(i) => format!("{}", i),
+            &Bson::TimeStamp(i) => {
+                let time = (i >> 32) as i32;
+                let inc = (i & 0xFFFFFFFF) as i32;
+
+                format!("Timestamp({}, {})", time, inc)
+            },
+            &Bson::Binary(t, ref vec) => {
+                let string = unsafe { str::from_utf8_unchecked(vec) };
+                format!("BinData({}, \"{}\")", u8::from(t), string)
+            }
+            &Bson::ObjectId(ref id) => {
+                let mut vec = vec![];
+
+                for byte in id.bytes().iter() {
+                    vec.push(byte.to_owned());
+                }
+
+                let string = unsafe { String::from_utf8_unchecked(vec) };
+                format!("ObjectId(\"{}\")", string)
+            }
+            &Bson::UtcDatetime(date_time) => format!("Date(\"{}\")", date_time)
+        };
+
+        fmt.write_str(&bson_string)
+    }
+}
+
 impl From<f32> for Bson {
     fn from(a: f32) -> Bson {
         Bson::FloatingPoint(a as f64)

src/ordered.rs

@@ -1,5 +1,6 @@
 use bson::Bson;
 use std::collections::BTreeMap;
+use std::fmt::{Display, Error, Formatter};
 use std::iter::{FromIterator, Map};
 use std::vec::IntoIter;
 use std::slice;
@@ -11,6 +12,23 @@ pub struct OrderedDocument {
     document: BTreeMap<String, Bson>,
 }
 
+impl Display for OrderedDocument {
+    fn fmt(&self, fmt: &mut Formatter) -> Result<(), Error> {
+        let mut string = "{ ".to_owned();
+
+        for (key, value) in self.iter() {
+            if !string.eq("{ ") {
+                string.push_str(", ");
+            }
+
+            string.push_str(&format!("{}: {}", key, value));
+        }
+
+        string.push_str(" }");
+        fmt.write_str(&string)
+    }
+}
+
 /// An iterator over OrderedDocument entries.
 pub struct OrderedDocumentIntoIterator {
     vec_iter: IntoIter<String>,

tests/lib.rs

@@ -1,5 +1,50 @@
-#[macro_use(bson, doc)]
+#[macro_use]
 extern crate bson;
+extern crate chrono;
 extern crate rustc_serialize;
 
 mod modules;
+
+use bson::Bson;
+use bson::spec::BinarySubtype;
+use bson::oid::ObjectId;
+use chrono::offset::utc::UTC;
+
+#[test]
+fn test_format() {
+    let id_string = "thisismyname";
+    let string_bytes : Vec<_> = id_string.bytes().collect();
+    let mut bytes = [0; 12];
+
+    for i in 0..12 {
+        bytes[i] = string_bytes[i];
+    }
+
+    let id = ObjectId::with_bytes(bytes);
+    let date = UTC::now();
+
+    let doc = doc! {
+        "float" => 2.4,
+        "string" => "hello",
+        "array" => ["testing", 1],
+        "doc" => {
+            "fish" => "in",
+            "a" => "barrel",
+            "!" => 1
+        },
+        "bool" => true,
+        "null" => (Bson::Null),
+        "regexp" => (Bson::RegExp("s[ao]d".to_owned(), "i".to_owned())),
+        "code" => (Bson::JavaScriptCode("function(x) { return x._id; }".to_owned())),
+        "i32" => 12,
+        "i64" => (-55),
+        "timestamp" => (Bson::TimeStamp(229999444)),
+        "binary" => (Bson::Binary(BinarySubtype::Md5, "thingies".to_owned().into_bytes())),
+        "_id" => id,
+        "date" => (Bson::UtcDatetime(date))
+    };
+
+    let expected = format!("{{ float: 2.4, string: \"hello\", array: [\"testing\", 1], doc: {{ fish: \"in\", a: \"barrel\", !: 1 }}, bool: true, null: null, regexp: /s[ao]d/i, code: function(x) {{ return x._id; }}, i32: 12, i64: -55, timestamp: Timestamp(0, 229999444), binary: BinData(5, \"thingies\"), _id: ObjectId(\"{}\"), date: Date(\"{}\") }}", id_string, date);
+
+    assert_eq!(expected, format!("{}", doc));
+}