0.7.2 cleanup and tests

Author: maciejhirsz

src/lib.rs

@@ -246,6 +246,11 @@ impl fmt::Display for JsonValue {
     }
 }
 
+/// Convenience for `JsonValue::from(value)`
+pub fn from<T>(value: T) -> JsonValue where T: Into<JsonValue> {
+    value.into()
+}
+
 #[deprecated(since="0.5.0", note="Use `value.dump(0)` instead")]
 pub fn stringify_ref(root: &JsonValue) -> String {
     root.dump()
@@ -264,6 +269,7 @@ pub fn stringify_pretty<T>(root: T, spaces: u16) -> String where T: Into<JsonVal
     root.pretty(spaces)
 }
 
+
 #[macro_export]
 macro_rules! array {
     [] => ($crate::JsonValue::new_array());
@@ -296,27 +302,27 @@ macro_rules! object {
     })
 }
 
-macro_rules! partial_eq {
-    ($to:ident, $from:ty, $self_cast:expr => $from_cast:expr) => {
-        impl PartialEq<$from> for JsonValue {
-            fn eq(&self, other: &$from) -> bool {
-                match *self {
-                    JsonValue::$to(ref value) => value == $from_cast,
-                    _ => false
-                }
-            }
-        }
-
-        impl<'a> PartialEq<JsonValue> for $from {
-            fn eq(&self, other: &JsonValue) -> bool {
-                match *other {
-                    JsonValue::$to(ref value) => value == $self_cast,
-                    _ => false
-                }
-            }
-        }
-    }
-}
+// macro_rules! partial_eq {
+//     ($to:ident, $from:ty, $self_cast:expr => $from_cast:expr) => {
+//         impl PartialEq<$from> for JsonValue {
+//             fn eq(&self, other: &$from) -> bool {
+//                 match *self {
+//                     JsonValue::$to(ref value) => value == $from_cast,
+//                     _ => false
+//                 }
+//             }
+//         }
+
+//         impl<'a> PartialEq<JsonValue> for $from {
+//             fn eq(&self, other: &JsonValue) -> bool {
+//                 match *other {
+//                     JsonValue::$to(ref value) => value == $self_cast,
+//                     _ => false
+//                 }
+//             }
+//         }
+//     }
+// }
 
 macro_rules! implement_extras {
     ($from:ty) => {

src/value.rs

@@ -97,6 +97,14 @@ impl JsonValue {
         }
     }
 
+    /// Checks whether the value is empty. Returns true for:
+    ///
+    /// - empty string (`""`)
+    /// - number `0`
+    /// - boolean `false`
+    /// - null
+    /// - empty array (`array![]`)
+    /// - empty object (`object!{}`)
     pub fn is_empty(&self) -> bool {
         match *self {
             JsonValue::String(ref string)   => string.is_empty(),

tests/lib.rs

@@ -76,12 +76,28 @@ fn is_false() {
 }
 
 #[test]
-fn is_nul() {
+fn is_null() {
     let null = JsonValue::Null;
 
     assert!(null.is_null());
 }
 
+#[test]
+fn is_empty() {
+    assert!(Null.is_empty());
+    assert!(json::from(0).is_empty());
+    assert!(json::from("").is_empty());
+    assert!(json::from(false).is_empty());
+    assert!(array![].is_empty());
+    assert!(object!{}.is_empty());
+
+    assert!(!json::from(1).is_empty());
+    assert!(!json::from("foo").is_empty());
+    assert!(!json::from(true).is_empty());
+    assert!(!array![0].is_empty());
+    assert!(!object!{ "foo" => false }.is_empty());
+}
+
 #[test]
 fn stringify_null() {
     assert_eq!(stringify(Null), "null");
@@ -238,34 +254,6 @@ fn stringify_pretty_object() {
                 \"Brutus\",\n    \"mother\": \"Helga\"\n  }\n}");
 }
 
-#[test]
-fn object_dump_minified() {
-    let object = object!{
-        "name" => "Maciej",
-        "age" => 30
-    };
-
-    assert_eq!(object.dump(), "{\"age\":30,\"name\":\"Maciej\"}");
-}
-
-#[test]
-fn object_dump_pretty() {
-    let object = object!{
-        "name" => "Urlich",
-        "age" => 50,
-        "parents" => object!{
-            "mother" => "Helga",
-            "father" => "Brutus"
-        },
-        "cars" => array![ "Golf", "Mercedes", "Porsche" ]
-    };
-
-    assert_eq!(object.pretty(2),
-               "{\n  \"age\": 50,\n  \"cars\": [\n    \"Golf\",\n    \"Mercedes\",\n    \
-                \"Porsche\"\n  ],\n  \"name\": \"Urlich\",\n  \"parents\": {\n    \"father\": \
-                \"Brutus\",\n    \"mother\": \"Helga\"\n  }\n}");
-}
-
 #[test]
 fn parse_true() {
     assert_eq!(parse("true").unwrap(), true);
@@ -473,16 +461,6 @@ fn parse_error() {
     assert!(parse("10 20").is_err());
 }
 
-#[test]
-fn object_len() {
-    let data = object!{
-        "a" => true,
-        "b" => false
-    };
-
-    assert_eq!(data.len(), 2);
-}
-
 #[test]
 fn array_len() {
     let data = array![0, 1, 2, 3];
@@ -505,14 +483,72 @@ fn array_contains() {
 }
 
 #[test]
-fn null_len() {
-    let data = json::Null;
+fn array_push() {
+    let mut data = array![1, 2];
 
-    assert_eq!(data.len(), 0);
+    data.push(3).unwrap();
+
+    assert_eq!(data, array![1, 2, 3]);
+}
+
+#[test]
+fn array_pop() {
+    let mut data = array![1, 2, 3];
+
+    assert_eq!(data.pop(), 3);
+    assert_eq!(data, array![1, 2]);
 }
 
 #[test]
-fn iter_entries() {
+fn array_members() {
+    let data = array![1, "foo"];
+
+    for member in data.members() {
+        assert!(!member.is_null());
+    }
+
+    let mut members = data.members();
+
+    assert_eq!(members.next().unwrap(), 1);
+    assert_eq!(members.next().unwrap(), "foo");
+    assert!(members.next().is_none());
+}
+
+#[test]
+fn array_members_mut() {
+    let mut data = array![Null, Null];
+
+    for member in data.members_mut() {
+        assert!(member.is_null());
+        *member = 100.into();
+    }
+
+    assert_eq!(data, array![100, 100]);
+}
+
+#[test]
+fn object_len() {
+    let data = object!{
+        "a" => true,
+        "b" => false
+    };
+
+    assert_eq!(data.len(), 2);
+}
+
+#[test]
+fn object_remove() {
+    let mut data = object!{
+        "foo" => "bar",
+        "answer" => 42
+    };
+
+    assert_eq!(data.remove("foo"), "bar");
+    assert_eq!(data, object!{ "answer" => 42 });
+}
+
+#[test]
+fn object_entries() {
     let data = object!{
         "a" => 1,
         "b" => "foo"
@@ -536,7 +572,7 @@ fn iter_entries() {
 }
 
 #[test]
-fn iter_entries_mut() {
+fn object_entries_mut() {
     let mut data = object!{
         "a" => Null,
         "b" => Null
@@ -554,30 +590,38 @@ fn iter_entries_mut() {
 }
 
 #[test]
-fn iter_members() {
-    let data = array![1, "foo"];
+fn object_dump_minified() {
+    let object = object!{
+        "name" => "Maciej",
+        "age" => 30
+    };
 
-    for member in data.members() {
-        assert!(!member.is_null());
-    }
+    assert_eq!(object.dump(), "{\"age\":30,\"name\":\"Maciej\"}");
+}
 
-    let mut members = data.members();
+#[test]
+fn object_dump_pretty() {
+    let object = object!{
+        "name" => "Urlich",
+        "age" => 50,
+        "parents" => object!{
+            "mother" => "Helga",
+            "father" => "Brutus"
+        },
+        "cars" => array![ "Golf", "Mercedes", "Porsche" ]
+    };
 
-    assert_eq!(members.next().unwrap(), 1);
-    assert_eq!(members.next().unwrap(), "foo");
-    assert!(members.next().is_none());
+    assert_eq!(object.pretty(2),
+               "{\n  \"age\": 50,\n  \"cars\": [\n    \"Golf\",\n    \"Mercedes\",\n    \
+                \"Porsche\"\n  ],\n  \"name\": \"Urlich\",\n  \"parents\": {\n    \"father\": \
+                \"Brutus\",\n    \"mother\": \"Helga\"\n  }\n}");
 }
 
 #[test]
-fn iter_members_mut() {
-    let mut data = array![Null, Null];
-
-    for member in data.members_mut() {
-        assert!(member.is_null());
-        *member = 100.into();
-    }
+fn null_len() {
+    let data = json::Null;
 
-    assert_eq!(data, array![100, 100]);
+    assert_eq!(data.len(), 0);
 }
 
 #[test]