Refactor bson macro

Remove root parens
Add support for arrays with documents

Author: kyeah

src/macros.rs

@@ -1,20 +1,29 @@
 #[macro_export]
-macro_rules! add_to_doc {
-    ($doc:expr, $key:expr => ($val:expr)) => {{
-        $doc.insert($key.to_owned(), ::std::convert::From::from($val));
+macro_rules! bson {
+    ([$($val:tt),*]) => {{
+        let mut array = Vec::new();
+
+        $(
+            array.push(bson!($val));
+        )*
+
+        $crate::Bson::Array(array)
     }};
 
-    ($doc:expr, $key:expr => [$($val:expr),*]) => {{
-        let vec = vec![$(::std::convert::From::from($val)),*];
-        $doc.insert($key.to_owned(), $crate::Bson::Array(vec));
+    ([$val:expr]) => {{
+        $crate::Bson::Array(vec!(::std::convert::From::from($val)))
     }};
 
-    ($doc:expr, $key:expr => { $($k:expr => $v:tt),* }) => {{
-        $doc.insert($key.to_owned(), $crate::Bson::Document(doc! {
+    ({ $($k:expr => $v:tt),* }) => {{
+        $crate::Bson::Document(doc! {
             $(
                 $k => $v
             ),*
-        }));
+        })
+    }};
+
+    ($val:expr) => {{
+        ::std::convert::From::from($val)
     }};
 }
 
@@ -24,7 +33,7 @@ macro_rules! doc {
         let mut document = $crate::Document::new();
 
         $(
-            add_to_doc!(document, $key => $val);
+            document.insert($key.to_owned(), bson!($val));
         )*
 
         document

tests/lib.rs

@@ -1,4 +1,4 @@
-#[macro_use(add_to_doc, doc)]
+#[macro_use(bson, doc)]
 extern crate bson;
 extern crate rustc_serialize;
 

tests/modules/macros.rs

@@ -3,15 +3,21 @@ use bson::Bson;
 #[test]
 fn recursive_macro() {
     let doc = doc! {
-        "a" => ("foo"),
+        "a" => "foo",
         "b" => {
             "bar" => {
                 "harbor" => ["seal", false],
-                "jelly" => (42.0)
+                "jelly" => 42.0
             },
-            "grape" => (27)
+            "grape" => 27
         },
-        "c" => [-7]
+        "c" => [-7],
+        "d" => [
+            {
+                "apple" => "ripe"
+            }
+        ],
+        "e" => { "single" => "test" }
     };
 
     match doc.get("a") {
@@ -57,7 +63,7 @@ fn recursive_macro() {
         _ => panic!("Inner document was not inserted correctly."),
     }
 
-    // Outer array
+    // Single-item array
     match doc.get("c") {
         Some(&Bson::Array(ref arr)) => {
             assert_eq!(1, arr.len());
@@ -68,6 +74,40 @@ fn recursive_macro() {
                 _ => panic!("I32 '-7' was not inserted correctly."),
             }
         },
+        _ => panic!("Single-item array was not inserted correctly."),
+    }
+
+    // Document nested in array
+    match doc.get("d") {
+        Some(&Bson::Array(ref arr)) => {
+            assert_eq!(1, arr.len());
+
+            // Nested document
+            match arr[0] {
+                Bson::Document(ref doc) => {
+
+                    // String
+                    match doc.get("apple") {
+                        Some(&Bson::String(ref s)) => assert_eq!("ripe", s),
+                        _ => panic!("String 'ripe' was not inserted correctly."),
+                    }
+                },
+                _ => panic!("Document was not inserted into array correctly."),
+            }
+        },
         _ => panic!("Array was not inserted correctly."),
     }
+
+    // Single-item document
+    match doc.get("e") {
+        Some(&Bson::Document(ref bdoc)) => {
+
+            // String
+            match bdoc.get("single") {
+                Some(&Bson::String(ref s)) => assert_eq!("test", s),
+                _ => panic!("String 'test' was not inserted correctly."),
+            }
+        },
+        _ => panic!("Single-item document was not inserted correctly."),
+    }
 }