Merge pull request #30 from maciejhirsz/dev

0.7.3 Closes #28

Author: maciejhirsz

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "json"
-version = "0.7.2"
+version = "0.7.3"
 authors = ["Maciej Hirsz <maciej.hirsz@gmail.com>"]
 description = "JSON implementation in Rust"
 repository = "https://github.com/maciejhirsz/json-rust"

src/codegen.rs

@@ -1,6 +1,8 @@
 use JsonValue;
 
 pub trait Generator {
+    fn current_index(&self) -> usize;
+
     fn new_line(&mut self) {}
 
     fn write(&mut self, slice: &[u8]);
@@ -34,31 +36,35 @@ pub trait Generator {
         self.write_char(b'"');
     }
 
-    fn write_digits_from_u64(&mut self, mut num: u64, length: &mut u8) {
+    fn write_digits_from_u64(&mut self, mut num: u64) {
         let digit = (num % 10) as u8;
         if num > 9 {
             num /= 10;
-            self.write_digits_from_u64(num, length);
+            self.write_digits_from_u64(num);
         }
-        *length += 1;
         self.write_char(digit + b'0');
     }
 
     fn write_number(&mut self, mut num: f64) {
-        let mut length = 0;
         if num < 0.0 {
             num = -num;
             self.write_char(b'-');
         }
 
-        self.write_digits_from_u64(num as u64, &mut length);
+        let start = self.current_index();
+
+        self.write_digits_from_u64(num as u64);
 
         let mut fract = num.fract();
+
         if fract < 1e-16 {
             return;
         }
 
+        let mut length = self.current_index() - start;
+
         fract *= 10.0;
+
         self.write_char(b'.');
         self.write_char((fract as u8) + b'0');
         fract = fract.fract();
@@ -76,7 +82,8 @@ pub trait Generator {
         match *json {
             JsonValue::String(ref string) => self.write_string(string),
             JsonValue::Number(ref number) => self.write_number(*number),
-            JsonValue::Boolean(ref value) => self.write(if *value { b"true" } else { b"false" }),
+            JsonValue::Boolean(true)      => self.write(b"true"),
+            JsonValue::Boolean(false)     => self.write(b"false"),
             JsonValue::Null               => self.write(b"null"),
             JsonValue::Array(ref array)   => {
                 self.write_char(b'[');
@@ -135,6 +142,10 @@ impl DumpGenerator {
 }
 
 impl Generator for DumpGenerator {
+    fn current_index(&self) -> usize {
+        self.code.len()
+    }
+
     fn write(&mut self, slice: &[u8]) {
         self.code.extend_from_slice(slice);
     }
@@ -169,6 +180,10 @@ impl PrettyGenerator {
 }
 
 impl Generator for PrettyGenerator {
+    fn current_index(&self) -> usize {
+        self.code.len()
+    }
+
     fn new_line(&mut self) {
         self.code.push(b'\n');
         for _ in 0..(self.dent * self.spaces_per_indent) {

src/lib.rs

@@ -15,12 +15,12 @@
 //! some keys under some conditions. Mapping that to idiomatic Rust structs
 //! introduces friction.
 //!
-//! This crate intends to avoid that friction by extensively using static dispatch
-//! and hiding type information behind enums, while still giving you all the
-//! guarantees of safe Rust code.
+//! This crate intends to avoid that friction.
 //!
-//! ```
-//! let data = json::parse(r#"
+//! ```rust
+//! # #[macro_use] extern crate json;
+//! # fn main() {
+//! let parsed = json::parse(r#"
 //!
 //! {
 //!     "code": 200,
@@ -36,51 +36,64 @@
 //!
 //! "#).unwrap();
 //!
-//! assert!(data["code"] == 200);
-//! assert!(data["success"] == true);
-//! assert!(data["payload"]["features"].is_array());
-//! assert!(data["payload"]["features"][0] == "awesome");
-//! assert!(data["payload"]["features"].contains("easyAPI"));
+//! let instantiated = object!{
+//!     "code" => 200,
+//!     "success" => true,
+//!     "payload" => object!{
+//!         "features" => array![
+//!             "awesome",
+//!             "easyAPI",
+//!             "lowLearningCurve"
+//!         ]
+//!     }
+//! };
 //!
-//! // Error resilient: non-existent values default to null
-//! assert!(data["this"]["does"]["not"]["exist"].is_null());
+//! assert_eq!(parsed, instantiated);
+//! # }
 //! ```
 //!
-//! ## Create JSON data without defining structs
+//! ## First class citizen
 //!
-//! ```
-//! #[macro_use]
-//! extern crate json;
+//! Using macros and easy indexing, it's easy to work with the data.
 //!
-//! fn main() {
-//!     let data = object!{
-//!         "a" => "bar",
-//!         "b" => array![1, false, "foo"]
-//!     };
+//! ```rust
+//! # #[macro_use] extern crate json;
+//! # fn main() {
+//! let mut data = object!{
+//!     "foo" => false,
+//!     "bar" => json::Null,
+//!     "answer" => 42,
+//!     "list" => array![json::Null, "world", true]
+//! };
 //!
-//!     assert_eq!(data.dump(), r#"{"a":"bar","b":[1,false,"foo"]}"#);
-//! }
-//! ```
+//! // Partial equality is implemented for most raw types:
+//! assert!(data["foo"] == false);
 //!
-//! ## Mutate simply by assigning new values
+//! // And it's type aware, `null` and `false` are different values:
+//! assert!(data["bar"] != false);
 //!
-//! ```
-//! let mut data = json::parse(r#"
+//! // But you can use any Rust number types:
+//! assert!(data["answer"] == 42);
+//! assert!(data["answer"] == 42.0);
+//! assert!(data["answer"] == 42isize);
 //!
-//! {
-//!     "name": "Bob",
-//!     "isAwesome": false
-//! }
+//! // Access nested structures, arrays and objects:
+//! assert!(data["list"][0].is_null());
+//! assert!(data["list"][1] == "world");
+//! assert!(data["list"][2] == true);
 //!
-//! "#).unwrap();
+//! // Error resilient - accessing properties that don't exist yield null:
+//! assert!(data["this"]["does"]["not"]["exist"].is_null());
 //!
-//! data["isAwesome"] = true.into();
-//! data["likes"] = "Rust".into();
+//! // Mutate by assigning:
+//! data["list"][0] = "Hello".into();
 //!
-//! assert_eq!(data.dump(), r#"{"isAwesome":true,"likes":"Rust","name":"Bob"}"#);
+//! // Use the `dump` method to serialize the data:
+//! assert_eq!(data.dump(), r#"{"answer":42,"bar":null,"foo":false,"list":["Hello","world",true]}"#);
 //!
-//! // Pretty print the output
+//! // Or pretty print it out:
 //! println!("{:#}", data);
+//! # }
 //! ```
 //!
 //! ## Serialize with `json::stringify(value)`