Fixed PartialEq for Short, more comments.

Author: maciejhirsz

README.md

@@ -88,7 +88,7 @@ assert!(data["this"]["does"]["not"]["exist"].is_null());
 data["list"][0] = "Hello".into();
 
 // Use the `dump` method to serialize the data:
-assert_eq!(data.dump(), r#"{"answer":42,"bar":null,"foo":false,"list":["Hello","world",true]}"#);
+assert_eq!(data.dump(), r#"{"foo":false,"bar":null,"answer":42,"list":["Hello","world",true]}"#);
 
 // Or pretty print it out:
 println!("{:#}", data);

src/error.rs

@@ -1,6 +1,11 @@
 use std::{ char, error, fmt };
 
 #[derive(Debug, PartialEq)]
+/// Error type of this crate.
+///
+///
+/// *Note:* Since `0.9.0` using `JsonError` is deprecated. Always use
+/// `json::Error` instead!
 pub enum Error {
     UnexpectedCharacter {
         ch: char,

src/lib.rs

@@ -213,6 +213,12 @@ use object::Object;
 pub use error::Error;
 pub use value::JsonValue;
 pub use value::JsonValue::Null;
+
+/// Result type used by this crate.
+///
+///
+/// *Note:* Since 0.9.0 the old `JsonResult` type is depreacted. Always use
+/// `json::Result` instead.
 pub type Result<T> = result::Result<T, Error>;
 
 /// Iterator over members of `JsonValue::Array`.
@@ -222,11 +228,9 @@ pub type Members<'a> = slice::Iter<'a, JsonValue>;
 pub type MembersMut<'a> = slice::IterMut<'a, JsonValue>;
 
 /// Iterator over key value pairs of `JsonValue::Object`.
-// pub type Entries<'a> = btree_map::Iter<'a, String, JsonValue>;
 pub type Entries<'a> = object::Iter<'a>;
 
 /// Mutable iterator over key value pairs of `JsonValue::Object`.
-// pub type EntriesMut<'a> = btree_map::IterMut<'a, String, JsonValue>;
 pub type EntriesMut<'a> = object::IterMut<'a>;
 
 #[deprecated(since="0.9.0", note="use `json::Error` instead")]

src/object.rs

@@ -221,7 +221,7 @@ impl Clone for Node {
     }
 }
 
-/// A binary tree implementation of string -> `JsonValue` map. You normally don't
+/// A binary tree implementation of a string -> `JsonValue` map. You normally don't
 /// have to interact with instances of `Object`, much more likely you will be
 /// using the `JsonValue::Object` variant, which wraps around this struct.
 #[derive(Debug)]
@@ -231,14 +231,14 @@ pub struct Object {
 
 impl Object {
     /// Create a new, empty instance of `Object`. Empty `Object` performs no
-    /// allocation until a value is pushed onto it.
+    /// allocation until a value is inserted into it.
     pub fn new() -> Self {
         Object {
             store: Vec::new()
         }
     }
 
-    /// Create a new object with memory preallocated with `capacity` for a number
+    /// Create a new `Object` with memory preallocated for `capacity` number
     /// of entries.
     pub fn with_capacity(capacity: usize) -> Self {
         Object {

src/short.rs

@@ -3,7 +3,7 @@ use std::ops::Deref;
 
 pub const MAX_LEN: usize = 30;
 
-#[derive(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy)]
 pub struct Short {
     value: [u8; MAX_LEN],
     len: u8,
@@ -13,10 +13,13 @@ pub struct Short {
 /// the expensive heap allocation performed for the regular `String` type.
 impl Short {
     /// Creates a `Short` from a `&str` slice. This method can cause buffer
-    /// overflow if the length of the slice is larger than `MAX_LEN`. Typically
-    /// you should never want to create your own `Short`s, instead creating a
-    /// `JsonValue` (using `.into()` or `JsonValue::from(slice)`) out of a slice
-    /// will automatically decide on `String` or `Short` for you.
+    /// overflow if the length of the slice is larger than `MAX_LEN`, which is why
+    /// it is marked as `unsafe`.
+    ///
+    ///
+    /// Typically you should avoid creating your own `Short`s, instead create a
+    /// `JsonValue` (either using `"foo".into()` or `JsonValue::from("foo")`) out
+    /// of a slice. This will automatically decide on `String` or `Short` for you.
     #[inline]
     pub unsafe fn from_slice(slice: &str) -> Self {
         let mut short = Short {
@@ -41,6 +44,12 @@ impl Short {
     }
 }
 
+impl PartialEq for Short {
+    fn eq(&self, other: &Short) -> bool {
+        self.as_str() == other.as_str()
+    }
+}
+
 impl fmt::Debug for Short {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Debug::fmt(self.as_str(), f)