Merge pull request #19 from maciejhirsz/0.6.0

0.6.0 closes #13, closes #16, closes #17

Author: maciejhirsz

Cargo.toml

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

README.md

@@ -44,7 +44,7 @@ assert!(data["payload"]["features"].contains("easyAPI"));
 assert!(data["this"]["does"]["not"]["exist"].is_null());
 ```
 
-## Easily create JSON data without defining structs
+## Create JSON data without defining structs
 
 ```rust
 #[macro_use]
@@ -60,6 +60,27 @@ fn main() {
 }
 ```
 
+## Mutate simply by assigning new values
+
+```rust
+let mut data = json::parse(r#"
+
+{
+    "name": "Bob",
+    "isAwesome": false
+}
+
+"#).unwrap();
+
+data["isAwesome"] = true.into();
+data["likes"] = "Rust".into();
+
+assert_eq!(data.dump(), r#"{"isAwesome":true,"likes":"Rust","name":"Bob"}"#);
+
+// Pretty print the output
+println!("{:#}", data);
+```
+
 ## Installation
 
 Just add it to your `Cargo.toml` file:

src/lib.rs

@@ -44,7 +44,7 @@
 //! assert!(data["this"]["does"]["not"]["exist"].is_null());
 //! ```
 //!
-//! ## Easily create JSON data without defining structs
+//! ## Create JSON data without defining structs
 //!
 //! ```
 //! #[macro_use]
@@ -60,6 +60,27 @@
 //! }
 //! ```
 //!
+//! ## Mutate simply by assigning new values
+//!
+//! ```
+//! let mut data = json::parse(r#"
+//!
+//! {
+//!     "name": "Bob",
+//!     "isAwesome": false
+//! }
+//!
+//! "#).unwrap();
+//!
+//! data["isAwesome"] = true.into();
+//! data["likes"] = "Rust".into();
+//!
+//! assert_eq!(data.dump(), r#"{"isAwesome":true,"likes":"Rust","name":"Bob"}"#);
+//!
+//! // Pretty print the output
+//! println!("{:#}", data);
+//! ```
+//!
 //! ## Serialize with `json::stringify(value)`
 //!
 //! Primitives:
@@ -126,8 +147,8 @@
 //! ```
 //! let mut data = json::JsonValue::new_object();
 //!
-//! data.put("answer", 42);
-//! data.put("foo", "bar");
+//! data["answer"] = 42.into();
+//! data["foo"] = "bar".into();
 //!
 //! assert_eq!(json::stringify(data), "{\"answer\":42,\"foo\":\"bar\"}");
 //! ```
@@ -177,6 +198,7 @@ use codegen::Generator;
 
 use std::collections::HashMap;
 use std::collections::BTreeMap;
+use std::fmt;
 
 pub type Array = Vec<JsonValue>;
 pub type Object = BTreeMap<String, JsonValue>;
@@ -198,6 +220,30 @@ impl JsonValue {
     }
 }
 
+/// Implements formatting
+///
+/// ```
+/// # use json;
+/// let data = json::parse(r#"{"url":"https://github.com/"}"#).unwrap();
+/// println!("{}", data);
+/// println!("{:#}", data);
+/// ```
+impl fmt::Display for JsonValue {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        if f.alternate() {
+            f.write_str(&self.pretty(4))
+        } else {
+            match *self {
+                JsonValue::String(ref value)  => value.fmt(f),
+                JsonValue::Number(ref value)  => value.fmt(f),
+                JsonValue::Boolean(ref value) => value.fmt(f),
+                JsonValue::Null               => f.write_str("null"),
+                _                             => f.write_str(&self.dump())
+            }
+        }
+    }
+}
+
 #[deprecated(since="0.5.0", note="Use `value.dump(0)` instead")]
 pub fn stringify_ref(root: &JsonValue) -> String {
     root.dump()

src/parser.rs

@@ -29,12 +29,14 @@ pub enum Token {
 
 struct Tokenizer<'a> {
     source: Peekable<Chars<'a>>,
+    buffer: String,
 }
 
 impl<'a> Tokenizer<'a> {
     pub fn new(source: &'a str) -> Self {
         Tokenizer {
             source: source.chars().peekable(),
+            buffer: String::new()
         }
     }
 
@@ -64,20 +66,21 @@ impl<'a> Tokenizer<'a> {
         })
     }
 
-    fn read_label(&mut self, first: char) -> String {
-        let mut label = first.to_string();
+    fn read_label(&mut self, first: char) -> &String {
+        self.buffer.clear();
+        self.buffer.push(first);
 
         while let Some(&ch) = self.source.peek() {
             match ch {
                 'a'...'z' => {
-                    label.push(ch);
+                    self.buffer.push(ch);
                     self.source.next();
                 },
                 _ => break,
             }
         }
 
-        label
+        &self.buffer
     }
 
     fn read_codepoint(&mut self) -> JsonResult<char> {
@@ -122,30 +125,53 @@ impl<'a> Tokenizer<'a> {
         Ok(value)
     }
 
+    fn read_digits_to_buffer(&mut self) {
+        while let Some(&ch) = self.source.peek() {
+            match ch {
+                '0' ... '9' => {
+                    self.buffer.push(ch);
+                    self.source.next();
+                },
+                _ => break
+            }
+        }
+    }
+
     fn read_number(&mut self, first: char) -> f64 {
-        let mut value = first.to_string();
+        self.buffer.clear();
+        self.buffer.push(first);
+        self.read_digits_to_buffer();
+
         let mut period = false;
 
         while let Some(&ch) = self.source.peek() {
             match ch {
-                '0'...'9' => {
-                    value.push(ch);
+                '.' => {
+                    if period {
+                        panic!("Invalid character `{:?}`", ch);
+                    }
+                    period = true;
+                    self.buffer.push(ch);
                     self.source.next();
+                    self.read_digits_to_buffer();
                 },
-                '.' => {
-                    if !period {
-                        period = true;
-                        value.push(ch);
-                        self.source.next();
-                    } else {
-                        return value.parse::<f64>().unwrap();
+                'e' | 'E' => {
+                    self.buffer.push(ch);
+                    self.source.next();
+                    match self.source.peek() {
+                        Some(&'-') | Some(&'+') => {
+                            self.buffer.push(self.source.next().unwrap());
+                        },
+                        _ => {}
                     }
+                    self.read_digits_to_buffer();
+                    break;
                 },
-                _ => return value.parse::<f64>().unwrap(),
+                _ => break
             }
         }
 
-        value.parse::<f64>().unwrap()
+        self.buffer.parse::<f64>().unwrap()
     }
 }