Fixing some minor things

Author: maciejhirsz

src/number.rs

@@ -49,6 +49,11 @@ impl Number {
     pub fn is_nan(&self) -> bool {
         self.category & NAN_MASK != 0
     }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.is_zero() || self.is_nan()
+    }
 }
 
 impl PartialEq for Number {

src/object.rs

@@ -130,9 +130,9 @@ impl Node {
     }
 
     // While `new` crates a fresh `Node` instance, it cannot do much about
-    // the `key_*` fields. In case of short keys that can be stored on the
-    // `Node`, only once the `Node` is somewhere on the heap, a persisting
-    // pointer to the key can be obtained.
+    // the `key_*` fields. In the case a short key can be stored on the `Node`
+    // itself, only once the `Node` is allocated on the heap can we obtain a
+    // persisting pointer to it.
     #[inline(always)]
     fn attach_key(&mut self, key: &[u8]) {
         if self.key_len <= KEY_BUF_LEN {
@@ -151,9 +151,9 @@ impl Node {
         }
     }
 
-    // Since `Node`s are stored on a `Vec<Node>`, they will suffer from
-    // reallocation, changing `key_ptr` addresses for buffered keys. This
-    // needs to be called on each `Node` after each reallocation.
+    // Since we store `Node`s on a vector, it will suffer from reallocation.
+    // Whenever that happens, `key_ptr` for short keys will turn into dangling
+    // pointers and will need to be re-cached.
     #[inline(always)]
     fn fix_key_ptr(&mut self) {
         if self.key_len <= KEY_BUF_LEN {

src/parser.rs

@@ -260,7 +260,7 @@ macro_rules! allow_number_extensions {
         match $ch {
             b'.'        => {
                 $parser.bump();
-                expect_fracton!($parser, $num, $e)
+                expect_fraction!($parser, $num, $e)
             },
             b'e' | b'E' => {
                 $parser.bump();
@@ -284,7 +284,7 @@ macro_rules! allow_number_extensions {
 
 // If a dot `b"."` byte has been read, start reading the decimal fraction
 // of the number.
-macro_rules! expect_fracton {
+macro_rules! expect_fraction {
     ($parser:ident, $num:ident, $e:ident) => ({
         let result: Number;
 
@@ -632,7 +632,7 @@ impl<'a> Parser<'a> {
                 },
                 b'.' => {
                     self.bump();
-                    return Ok(expect_fracton!(self, num, e));
+                    return Ok(expect_fraction!(self, num, e));
                 },
                 b'e' | b'E' => {
                     self.bump();

src/value.rs

@@ -112,7 +112,7 @@ impl JsonValue {
             JsonValue::Null               => true,
             JsonValue::Short(ref value)   => value.is_empty(),
             JsonValue::String(ref value)  => value.is_empty(),
-            JsonValue::Number(ref value)  => value.is_zero(),
+            JsonValue::Number(ref value)  => value.is_empty(),
             JsonValue::Boolean(ref value) => !value,
             JsonValue::Array(ref value)   => value.is_empty(),
             JsonValue::Object(ref value)  => value.is_empty(),