src/libserialize/json.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Rust JSON serialization library
  12 // Copyright (c) 2011 Google Inc.
  13
  14 #![forbid(non_camel_case_types)]
  15 #![allow(missing_docs)]
  16
  17 //! JSON parsing and serialization
  18 //!
  19 //! # What is JSON?
  20 //!
  21 //! JSON (JavaScript Object Notation) is a way to write data in Javascript.
  22 //! Like XML, it allows to encode structured data in a text format that can be easily read by humans
  23 //! Its simple syntax and native compatibility with JavaScript have made it a widely used format.
  24 //!
  25 //! Data types that can be encoded are JavaScript types (see the `Json` enum for more details):
  26 //!
  27 //! * `Boolean`: equivalent to rust's `bool`
  28 //! * `Number`: equivalent to rust's `f64`
  29 //! * `String`: equivalent to rust's `String`
  30 //! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
  31 //!   same array
  32 //! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
  33 //! * `Null`
  34 //!
  35 //! An object is a series of string keys mapping to values, in `"key": value` format.
  36 //! Arrays are enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).
  37 //! A simple JSON document encoding a person, their age, address and phone numbers could look like
  38 //!
  39 //! ```ignore
  40 //! {
  41 //!     "FirstName": "John",
  42 //!     "LastName": "Doe",
  43 //!     "Age": 43,
  44 //!     "Address": {
  45 //!         "Street": "Downing Street 10",
  46 //!         "City": "London",
  47 //!         "Country": "Great Britain"
  48 //!     },
  49 //!     "PhoneNumbers": [
  50 //!         "+44 1234567",
  51 //!         "+44 2345678"
  52 //!     ]
  53 //! }
  54 //! ```
  55 //!
  56 //! # Rust Type-based Encoding and Decoding
  57 //!
  58 //! Rust provides a mechanism for low boilerplate encoding & decoding of values to and from JSON via
  59 //! the serialization API.
  60 //! To be able to encode a piece of data, it must implement the `serialize::RustcEncodable` trait.
  61 //! To be able to decode a piece of data, it must implement the `serialize::RustcDecodable` trait.
  62 //! The Rust compiler provides an annotation to automatically generate the code for these traits:
  63 //! `#[derive(RustcDecodable, RustcEncodable)]`
  64 //!
  65 //! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode objects.
  66 //! The `ToJson` trait provides a `to_json` method to convert an object into a `json::Json` value.
  67 //! A `json::Json` value can be encoded as a string or buffer using the functions described above.
  68 //! You can also use the `json::Encoder` object, which implements the `Encoder` trait.
  69 //!
  70 //! When using `ToJson` the `RustcEncodable` trait implementation is not mandatory.
  71 //!
  72 //! # Examples of use
  73 //!
  74 //! ## Using Autoserialization
  75 //!
  76 //! Create a struct called `TestStruct` and serialize and deserialize it to and from JSON using the
  77 //! serialization API, using the derived serialization code.
  78 //!
  79 //! ```notrust
  80 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
  81 //! extern crate serialize;
  82 //! use serialize::json;
  83 //!
  84 //! // Automatically generate `Decodable` and `Encodable` trait implementations
  85 //! #[derive(RustcDecodable, RustcEncodable)]
  86 //! pub struct TestStruct  {
  87 //!     data_int: u8,
  88 //!     data_str: String,
  89 //!     data_vector: Vec<u8>,
  90 //! }
  91 //!
  92 //! fn main() {
  93 //!     let object = TestStruct {
  94 //!         data_int: 1,
  95 //!         data_str: "homura".to_string(),
  96 //!         data_vector: vec![2,3,4,5],
  97 //!     };
  98 //!
  99 //!     // Serialize using `json::encode`
 100 //!     let encoded = json::encode(&object).unwrap();
 101 //!
 102 //!     // Deserialize using `json::decode`
 103 //!     let decoded: TestStruct = json::decode(encoded.as_slice()).unwrap();
 104 //! }
 105 //! ```
 106 //!
 107 //! ## Using the `ToJson` trait
 108 //!
 109 //! The examples above use the `ToJson` trait to generate the JSON string, which is required
 110 //! for custom mappings.
 111 //!
 112 //! ### Simple example of `ToJson` usage
 113 //!
 114 //! ```notrust
 115 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
 116 //! extern crate serialize;
 117 //! use serialize::json::{self, ToJson, Json};
 118 //!
 119 //! // A custom data structure
 120 //! struct ComplexNum {
 121 //!     a: f64,
 122 //!     b: f64,
 123 //! }
 124 //!
 125 //! // JSON value representation
 126 //! impl ToJson for ComplexNum {
 127 //!     fn to_json(&self) -> Json {
 128 //!         Json::String(format!("{}+{}i", self.a, self.b))
 129 //!     }
 130 //! }
 131 //!
 132 //! // Only generate `RustcEncodable` trait implementation
 133 //! #[derive(Encodable)]
 134 //! pub struct ComplexNumRecord {
 135 //!     uid: u8,
 136 //!     dsc: String,
 137 //!     val: Json,
 138 //! }
 139 //!
 140 //! fn main() {
 141 //!     let num = ComplexNum { a: 0.0001, b: 12.539 };
 142 //!     let data: String = json::encode(&ComplexNumRecord{
 143 //!         uid: 1,
 144 //!         dsc: "test".to_string(),
 145 //!         val: num.to_json(),
 146 //!     }).unwrap();
 147 //!     println!("data: {}", data);
 148 //!     // data: {"uid":1,"dsc":"test","val":"0.0001+12.539j"};
 149 //! }
 150 //! ```
 151 //!
 152 //! ### Verbose example of `ToJson` usage
 153 //!
 154 //! ```notrust
 155 //! // FIXME(#19470): this cannot be ```rust``` because it fails orphan checking at the moment
 156 //! extern crate serialize;
 157 //! use std::collections::BTreeMap;
 158 //! use serialize::json::{self, Json, ToJson};
 159 //!
 160 //! // Only generate `Decodable` trait implementation
 161 //! #[derive(Decodable)]
 162 //! pub struct TestStruct {
 163 //!     data_int: u8,
 164 //!     data_str: String,
 165 //!     data_vector: Vec<u8>,
 166 //! }
 167 //!
 168 //! // Specify encoding method manually
 169 //! impl ToJson for TestStruct {
 170 //!     fn to_json(&self) -> Json {
 171 //!         let mut d = BTreeMap::new();
 172 //!         // All standard types implement `to_json()`, so use it
 173 //!         d.insert("data_int".to_string(), self.data_int.to_json());
 174 //!         d.insert("data_str".to_string(), self.data_str.to_json());
 175 //!         d.insert("data_vector".to_string(), self.data_vector.to_json());
 176 //!         Json::Object(d)
 177 //!     }
 178 //! }
 179 //!
 180 //! fn main() {
 181 //!     // Serialize using `ToJson`
 182 //!     let input_data = TestStruct {
 183 //!         data_int: 1,
 184 //!         data_str: "madoka".to_string(),
 185 //!         data_vector: vec![2,3,4,5],
 186 //!     };
 187 //!     let json_obj: Json = input_data.to_json();
 188 //!     let json_str: String = json_obj.to_string();
 189 //!
 190 //!     // Deserialize like before
 191 //!     let decoded: TestStruct = json::decode(json_str)).unwrap();
 192 //! }
 193 //! ```
 194
 195 use self::JsonEvent::*;
 196 use self::ErrorCode::*;
 197 use self::ParserError::*;
 198 use self::DecoderError::*;
 199 use self::ParserState::*;
 200 use self::InternalStackElement::*;
 201
 202 use std::collections::{HashMap, BTreeMap};
 203 use std::io::prelude::*;
 204 use std::io;
 205 use std::mem::swap;
 206 use std::num::FpCategory as Fp;
 207 use std::ops::Index;
 208 use std::str::FromStr;
 209 use std::string;
 210 use std::{char, f64, fmt, num, str};
 211 use std;
 212 use unicode::str as unicode_str;
 213 use unicode::str::Utf16Item;
 214
 215 use Encodable;
 216
 217 /// Represents a json value
 218 #[derive(Clone, PartialEq, PartialOrd, Debug)]
 219 pub enum Json {
 220     I64(i64),
 221     U64(u64),
 222     F64(f64),
 223     String(string::String),
 224     Boolean(bool),
 225     Array(self::Array),
 226     Object(self::Object),
 227     Null,
 228 }
 229
 230 pub type Array = Vec<Json>;
 231 pub type Object = BTreeMap<string::String, Json>;
 232
 233 pub struct PrettyJson<'a> { inner: &'a Json }
 234
 235 pub struct AsJson<'a, T: 'a> { inner: &'a T }
 236 pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<usize> }
 237
 238 /// The errors that can arise while parsing a JSON stream.
 239 #[derive(Clone, Copy, PartialEq, Debug)]
 240 pub enum ErrorCode {
 241     InvalidSyntax,
 242     InvalidNumber,
 243     EOFWhileParsingObject,
 244     EOFWhileParsingArray,
 245     EOFWhileParsingValue,
 246     EOFWhileParsingString,
 247     KeyMustBeAString,
 248     ExpectedColon,
 249     TrailingCharacters,
 250     TrailingComma,
 251     InvalidEscape,
 252     InvalidUnicodeCodePoint,
 253     LoneLeadingSurrogateInHexEscape,
 254     UnexpectedEndOfHexEscape,
 255     UnrecognizedHex,
 256     NotFourDigit,
 257     NotUtf8,
 258 }
 259
 260 #[derive(Clone, PartialEq, Debug)]
 261 pub enum ParserError {
 262     /// msg, line, col
 263     SyntaxError(ErrorCode, usize, usize),
 264     IoError(io::ErrorKind, String),
 265 }
 266
 267 // Builder and Parser have the same errors.
 268 pub type BuilderError = ParserError;
 269
 270 #[derive(Clone, PartialEq, Debug)]
 271 pub enum DecoderError {
 272     ParseError(ParserError),
 273     ExpectedError(string::String, string::String),
 274     MissingFieldError(string::String),
 275     UnknownVariantError(string::String),
 276     ApplicationError(string::String)
 277 }
 278
 279 #[derive(Copy, Debug)]
 280 pub enum EncoderError {
 281     FmtError(fmt::Error),
 282     BadHashmapKey,
 283 }
 284
 285 /// Returns a readable error string for a given error code.
 286 pub fn error_str(error: ErrorCode) -> &'static str {
 287     match error {
 288         InvalidSyntax => "invalid syntax",
 289         InvalidNumber => "invalid number",
 290         EOFWhileParsingObject => "EOF While parsing object",
 291         EOFWhileParsingArray => "EOF While parsing array",
 292         EOFWhileParsingValue => "EOF While parsing value",
 293         EOFWhileParsingString => "EOF While parsing string",
 294         KeyMustBeAString => "key must be a string",
 295         ExpectedColon => "expected `:`",
 296         TrailingCharacters => "trailing characters",
 297         TrailingComma => "trailing comma",
 298         InvalidEscape => "invalid escape",
 299         UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
 300         NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
 301         NotUtf8 => "contents not utf-8",
 302         InvalidUnicodeCodePoint => "invalid Unicode code point",
 303         LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
 304         UnexpectedEndOfHexEscape => "unexpected end of hex escape",
 305     }
 306 }
 307
 308 /// Shortcut function to decode a JSON `&str` into an object
 309 pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
 310     let json = match from_str(s) {
 311         Ok(x) => x,
 312         Err(e) => return Err(ParseError(e))
 313     };
 314
 315     let mut decoder = Decoder::new(json);
 316     ::Decodable::decode(&mut decoder)
 317 }
 318
 319 /// Shortcut function to encode a `T` into a JSON `String`
 320 pub fn encode<T: ::Encodable>(object: &T) -> Result<string::String, EncoderError> {
 321     let mut s = String::new();
 322     {
 323         let mut encoder = Encoder::new(&mut s);
 324         try!(object.encode(&mut encoder));
 325     }
 326     Ok(s)
 327 }
 328
 329 impl fmt::Display for ErrorCode {
 330     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 331         error_str(*self).fmt(f)
 332     }
 333 }
 334
 335 fn io_error_to_error(io: io::Error) -> ParserError {
 336     IoError(io.kind(), io.to_string())
 337 }
 338
 339 impl fmt::Display for ParserError {
 340     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 341         // FIXME this should be a nicer error
 342         fmt::Debug::fmt(self, f)
 343     }
 344 }
 345
 346 impl fmt::Display for DecoderError {
 347     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 348         // FIXME this should be a nicer error
 349         fmt::Debug::fmt(self, f)
 350     }
 351 }
 352
 353 impl std::error::Error for DecoderError {
 354     fn description(&self) -> &str { "decoder error" }
 355 }
 356
 357 impl fmt::Display for EncoderError {
 358     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 359         // FIXME this should be a nicer error
 360         fmt::Debug::fmt(self, f)
 361     }
 362 }
 363
 364 impl std::error::Error for EncoderError {
 365     fn description(&self) -> &str { "encoder error" }
 366 }
 367
 368 impl std::error::FromError<fmt::Error> for EncoderError {
 369     fn from_error(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
 370 }
 371
 372 pub type EncodeResult = Result<(), EncoderError>;
 373 pub type DecodeResult<T> = Result<T, DecoderError>;
 374
 375 fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult {
 376     try!(wr.write_str("\""));
 377
 378     let mut start = 0;
 379
 380     for (i, byte) in v.bytes().enumerate() {
 381         let escaped = match byte {
 382             b'"' => "\\\"",
 383             b'\\' => "\\\\",
 384             b'\x00' => "\\u0000",
 385             b'\x01' => "\\u0001",
 386             b'\x02' => "\\u0002",
 387             b'\x03' => "\\u0003",
 388             b'\x04' => "\\u0004",
 389             b'\x05' => "\\u0005",
 390             b'\x06' => "\\u0006",
 391             b'\x07' => "\\u0007",
 392             b'\x08' => "\\b",
 393             b'\t' => "\\t",
 394             b'\n' => "\\n",
 395             b'\x0b' => "\\u000b",
 396             b'\x0c' => "\\f",
 397             b'\r' => "\\r",
 398             b'\x0e' => "\\u000e",
 399             b'\x0f' => "\\u000f",
 400             b'\x10' => "\\u0010",
 401             b'\x11' => "\\u0011",
 402             b'\x12' => "\\u0012",
 403             b'\x13' => "\\u0013",
 404             b'\x14' => "\\u0014",
 405             b'\x15' => "\\u0015",
 406             b'\x16' => "\\u0016",
 407             b'\x17' => "\\u0017",
 408             b'\x18' => "\\u0018",
 409             b'\x19' => "\\u0019",
 410             b'\x1a' => "\\u001a",
 411             b'\x1b' => "\\u001b",
 412             b'\x1c' => "\\u001c",
 413             b'\x1d' => "\\u001d",
 414             b'\x1e' => "\\u001e",
 415             b'\x1f' => "\\u001f",
 416             b'\x7f' => "\\u007f",
 417             _ => { continue; }
 418         };
 419
 420         if start < i {
 421             try!(wr.write_str(&v[start..i]));
 422         }
 423
 424         try!(wr.write_str(escaped));
 425
 426         start = i + 1;
 427     }
 428
 429     if start != v.len() {
 430         try!(wr.write_str(&v[start..]));
 431     }
 432
 433     try!(wr.write_str("\""));
 434     Ok(())
 435 }
 436
 437 fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult {
 438     let mut buf = [0; 4];
 439     let n = v.encode_utf8(&mut buf).unwrap();
 440     let buf = unsafe { str::from_utf8_unchecked(&buf[..n]) };
 441     escape_str(writer, buf)
 442 }
 443
 444 fn spaces(wr: &mut fmt::Write, mut n: usize) -> EncodeResult {
 445     const BUF: &'static str = "                ";
 446
 447     while n >= BUF.len() {
 448         try!(wr.write_str(BUF));
 449         n -= BUF.len();
 450     }
 451
 452     if n > 0 {
 453         try!(wr.write_str(&BUF[..n]));
 454     }
 455     Ok(())
 456 }
 457
 458 fn fmt_number_or_null(v: f64) -> string::String {
 459     match v.classify() {
 460         Fp::Nan | Fp::Infinite => string::String::from_str("null"),
 461         _ if v.fract() != 0f64 => f64::to_str_digits(v, 6),
 462         _ => f64::to_str_digits(v, 6) + ".0",
 463     }
 464 }
 465
 466 /// A structure for implementing serialization to JSON.
 467 pub struct Encoder<'a> {
 468     writer: &'a mut (fmt::Write+'a),
 469     is_emitting_map_key: bool,
 470 }
 471
 472 impl<'a> Encoder<'a> {
 473     /// Creates a new JSON encoder whose output will be written to the writer
 474     /// specified.
 475     pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
 476         Encoder { writer: writer, is_emitting_map_key: false, }
 477     }
 478 }
 479
 480 macro_rules! emit_enquoted_if_mapkey {
 481     ($enc:ident,$e:expr) => {
 482         if $enc.is_emitting_map_key {
 483             try!(write!($enc.writer, "\"{}\"", $e));
 484             Ok(())
 485         } else {
 486             try!(write!($enc.writer, "{}", $e));
 487             Ok(())
 488         }
 489     }
 490 }
 491
 492 impl<'a> ::Encoder for Encoder<'a> {
 493     type Error = EncoderError;
 494
 495     fn emit_nil(&mut self) -> EncodeResult {
 496         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 497         try!(write!(self.writer, "null"));
 498         Ok(())
 499     }
 500
 501     fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 502     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 503     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 504     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 505     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 506
 507     fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 508     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 509     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 510     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 511     fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 512
 513     fn emit_bool(&mut self, v: bool) -> EncodeResult {
 514         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 515         if v {
 516             try!(write!(self.writer, "true"));
 517         } else {
 518             try!(write!(self.writer, "false"));
 519         }
 520         Ok(())
 521     }
 522
 523     fn emit_f64(&mut self, v: f64) -> EncodeResult {
 524         emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
 525     }
 526     fn emit_f32(&mut self, v: f32) -> EncodeResult {
 527         self.emit_f64(v as f64)
 528     }
 529
 530     fn emit_char(&mut self, v: char) -> EncodeResult {
 531         escape_char(self.writer, v)
 532     }
 533     fn emit_str(&mut self, v: &str) -> EncodeResult {
 534         escape_str(self.writer, v)
 535     }
 536
 537     fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
 538         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 539     {
 540         f(self)
 541     }
 542
 543     fn emit_enum_variant<F>(&mut self,
 544                             name: &str,
 545                             _id: usize,
 546                             cnt: usize,
 547                             f: F) -> EncodeResult where
 548         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 549     {
 550         // enums are encoded as strings or objects
 551         // Bunny => "Bunny"
 552         // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
 553         if cnt == 0 {
 554             escape_str(self.writer, name)
 555         } else {
 556             if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 557             try!(write!(self.writer, "{{\"variant\":"));
 558             try!(escape_str(self.writer, name));
 559             try!(write!(self.writer, ",\"fields\":["));
 560             try!(f(self));
 561             try!(write!(self.writer, "]}}"));
 562             Ok(())
 563         }
 564     }
 565
 566     fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 567         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 568     {
 569         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 570         if idx != 0 {
 571             try!(write!(self.writer, ","));
 572         }
 573         f(self)
 574     }
 575
 576     fn emit_enum_struct_variant<F>(&mut self,
 577                                    name: &str,
 578                                    id: usize,
 579                                    cnt: usize,
 580                                    f: F) -> EncodeResult where
 581         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 582     {
 583         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 584         self.emit_enum_variant(name, id, cnt, f)
 585     }
 586
 587     fn emit_enum_struct_variant_field<F>(&mut self,
 588                                          _: &str,
 589                                          idx: usize,
 590                                          f: F) -> EncodeResult where
 591         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 592     {
 593         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 594         self.emit_enum_variant_arg(idx, f)
 595     }
 596
 597     fn emit_struct<F>(&mut self, _: &str, _: usize, f: F) -> EncodeResult where
 598         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 599     {
 600         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 601         try!(write!(self.writer, "{{"));
 602         try!(f(self));
 603         try!(write!(self.writer, "}}"));
 604         Ok(())
 605     }
 606
 607     fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
 608         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 609     {
 610         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 611         if idx != 0 { try!(write!(self.writer, ",")); }
 612         try!(escape_str(self.writer, name));
 613         try!(write!(self.writer, ":"));
 614         f(self)
 615     }
 616
 617     fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
 618         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 619     {
 620         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 621         self.emit_seq(len, f)
 622     }
 623     fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 624         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 625     {
 626         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 627         self.emit_seq_elt(idx, f)
 628     }
 629
 630     fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> EncodeResult where
 631         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 632     {
 633         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 634         self.emit_seq(len, f)
 635     }
 636     fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 637         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 638     {
 639         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 640         self.emit_seq_elt(idx, f)
 641     }
 642
 643     fn emit_option<F>(&mut self, f: F) -> EncodeResult where
 644         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 645     {
 646         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 647         f(self)
 648     }
 649     fn emit_option_none(&mut self) -> EncodeResult {
 650         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 651         self.emit_nil()
 652     }
 653     fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
 654         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 655     {
 656         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 657         f(self)
 658     }
 659
 660     fn emit_seq<F>(&mut self, _len: usize, f: F) -> EncodeResult where
 661         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 662     {
 663         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 664         try!(write!(self.writer, "["));
 665         try!(f(self));
 666         try!(write!(self.writer, "]"));
 667         Ok(())
 668     }
 669
 670     fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 671         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 672     {
 673         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 674         if idx != 0 {
 675             try!(write!(self.writer, ","));
 676         }
 677         f(self)
 678     }
 679
 680     fn emit_map<F>(&mut self, _len: usize, f: F) -> EncodeResult where
 681         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 682     {
 683         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 684         try!(write!(self.writer, "{{"));
 685         try!(f(self));
 686         try!(write!(self.writer, "}}"));
 687         Ok(())
 688     }
 689
 690     fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 691         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 692     {
 693         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 694         if idx != 0 { try!(write!(self.writer, ",")) }
 695         self.is_emitting_map_key = true;
 696         try!(f(self));
 697         self.is_emitting_map_key = false;
 698         Ok(())
 699     }
 700
 701     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
 702         F: FnOnce(&mut Encoder<'a>) -> EncodeResult,
 703     {
 704         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 705         try!(write!(self.writer, ":"));
 706         f(self)
 707     }
 708 }
 709
 710 /// Another encoder for JSON, but prints out human-readable JSON instead of
 711 /// compact data
 712 pub struct PrettyEncoder<'a> {
 713     writer: &'a mut (fmt::Write+'a),
 714     curr_indent: usize,
 715     indent: usize,
 716     is_emitting_map_key: bool,
 717 }
 718
 719 impl<'a> PrettyEncoder<'a> {
 720     /// Creates a new encoder whose output will be written to the specified writer
 721     pub fn new(writer: &'a mut fmt::Write) -> PrettyEncoder<'a> {
 722         PrettyEncoder {
 723             writer: writer,
 724             curr_indent: 0,
 725             indent: 2,
 726             is_emitting_map_key: false,
 727         }
 728     }
 729
 730     /// Set the number of spaces to indent for each level.
 731     /// This is safe to set during encoding.
 732     pub fn set_indent(&mut self, indent: usize) {
 733         // self.indent very well could be 0 so we need to use checked division.
 734         let level = self.curr_indent.checked_div(self.indent).unwrap_or(0);
 735         self.indent = indent;
 736         self.curr_indent = level * self.indent;
 737     }
 738 }
 739
 740 impl<'a> ::Encoder for PrettyEncoder<'a> {
 741     type Error = EncoderError;
 742
 743     fn emit_nil(&mut self) -> EncodeResult {
 744         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 745         try!(write!(self.writer, "null"));
 746         Ok(())
 747     }
 748
 749     fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 750     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 751     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 752     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 753     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 754
 755     fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 756     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 757     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 758     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 759     fn emit_i8(&mut self, v: i8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 760
 761     fn emit_bool(&mut self, v: bool) -> EncodeResult {
 762         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 763         if v {
 764             try!(write!(self.writer, "true"));
 765         } else {
 766             try!(write!(self.writer, "false"));
 767         }
 768         Ok(())
 769     }
 770
 771     fn emit_f64(&mut self, v: f64) -> EncodeResult {
 772         emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
 773     }
 774     fn emit_f32(&mut self, v: f32) -> EncodeResult {
 775         self.emit_f64(v as f64)
 776     }
 777
 778     fn emit_char(&mut self, v: char) -> EncodeResult {
 779         escape_char(self.writer, v)
 780     }
 781     fn emit_str(&mut self, v: &str) -> EncodeResult {
 782         escape_str(self.writer, v)
 783     }
 784
 785     fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult where
 786         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 787     {
 788         f(self)
 789     }
 790
 791     fn emit_enum_variant<F>(&mut self,
 792                             name: &str,
 793                             _id: usize,
 794                             cnt: usize,
 795                             f: F)
 796                             -> EncodeResult where
 797         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 798     {
 799         if cnt == 0 {
 800             escape_str(self.writer, name)
 801         } else {
 802             if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 803             try!(write!(self.writer, "{{\n"));
 804             self.curr_indent += self.indent;
 805             try!(spaces(self.writer, self.curr_indent));
 806             try!(write!(self.writer, "\"variant\": "));
 807             try!(escape_str(self.writer, name));
 808             try!(write!(self.writer, ",\n"));
 809             try!(spaces(self.writer, self.curr_indent));
 810             try!(write!(self.writer, "\"fields\": [\n"));
 811             self.curr_indent += self.indent;
 812             try!(f(self));
 813             self.curr_indent -= self.indent;
 814             try!(write!(self.writer, "\n"));
 815             try!(spaces(self.writer, self.curr_indent));
 816             self.curr_indent -= self.indent;
 817             try!(write!(self.writer, "]\n"));
 818             try!(spaces(self.writer, self.curr_indent));
 819             try!(write!(self.writer, "}}"));
 820             Ok(())
 821         }
 822     }
 823
 824     fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 825         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 826     {
 827         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 828         if idx != 0 {
 829             try!(write!(self.writer, ",\n"));
 830         }
 831         try!(spaces(self.writer, self.curr_indent));
 832         f(self)
 833     }
 834
 835     fn emit_enum_struct_variant<F>(&mut self,
 836                                    name: &str,
 837                                    id: usize,
 838                                    cnt: usize,
 839                                    f: F) -> EncodeResult where
 840         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 841     {
 842         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 843         self.emit_enum_variant(name, id, cnt, f)
 844     }
 845
 846     fn emit_enum_struct_variant_field<F>(&mut self,
 847                                          _: &str,
 848                                          idx: usize,
 849                                          f: F) -> EncodeResult where
 850         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 851     {
 852         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 853         self.emit_enum_variant_arg(idx, f)
 854     }
 855
 856
 857     fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
 858         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 859     {
 860         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 861         if len == 0 {
 862             try!(write!(self.writer, "{{}}"));
 863         } else {
 864             try!(write!(self.writer, "{{"));
 865             self.curr_indent += self.indent;
 866             try!(f(self));
 867             self.curr_indent -= self.indent;
 868             try!(write!(self.writer, "\n"));
 869             try!(spaces(self.writer, self.curr_indent));
 870             try!(write!(self.writer, "}}"));
 871         }
 872         Ok(())
 873     }
 874
 875     fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult where
 876         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 877     {
 878         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 879         if idx == 0 {
 880             try!(write!(self.writer, "\n"));
 881         } else {
 882             try!(write!(self.writer, ",\n"));
 883         }
 884         try!(spaces(self.writer, self.curr_indent));
 885         try!(escape_str(self.writer, name));
 886         try!(write!(self.writer, ": "));
 887         f(self)
 888     }
 889
 890     fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult where
 891         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 892     {
 893         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 894         self.emit_seq(len, f)
 895     }
 896     fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 897         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 898     {
 899         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 900         self.emit_seq_elt(idx, f)
 901     }
 902
 903     fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult where
 904         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 905     {
 906         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 907         self.emit_seq(len, f)
 908     }
 909     fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 910         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 911     {
 912         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 913         self.emit_seq_elt(idx, f)
 914     }
 915
 916     fn emit_option<F>(&mut self, f: F) -> EncodeResult where
 917         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 918     {
 919         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 920         f(self)
 921     }
 922     fn emit_option_none(&mut self) -> EncodeResult {
 923         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 924         self.emit_nil()
 925     }
 926     fn emit_option_some<F>(&mut self, f: F) -> EncodeResult where
 927         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 928     {
 929         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 930         f(self)
 931     }
 932
 933     fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult where
 934         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 935     {
 936         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 937         if len == 0 {
 938             try!(write!(self.writer, "[]"));
 939         } else {
 940             try!(write!(self.writer, "["));
 941             self.curr_indent += self.indent;
 942             try!(f(self));
 943             self.curr_indent -= self.indent;
 944             try!(write!(self.writer, "\n"));
 945             try!(spaces(self.writer, self.curr_indent));
 946             try!(write!(self.writer, "]"));
 947         }
 948         Ok(())
 949     }
 950
 951     fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 952         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 953     {
 954         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 955         if idx == 0 {
 956             try!(write!(self.writer, "\n"));
 957         } else {
 958             try!(write!(self.writer, ",\n"));
 959         }
 960         try!(spaces(self.writer, self.curr_indent));
 961         f(self)
 962     }
 963
 964     fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult where
 965         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 966     {
 967         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 968         if len == 0 {
 969             try!(write!(self.writer, "{{}}"));
 970         } else {
 971             try!(write!(self.writer, "{{"));
 972             self.curr_indent += self.indent;
 973             try!(f(self));
 974             self.curr_indent -= self.indent;
 975             try!(write!(self.writer, "\n"));
 976             try!(spaces(self.writer, self.curr_indent));
 977             try!(write!(self.writer, "}}"));
 978         }
 979         Ok(())
 980     }
 981
 982     fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult where
 983         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
 984     {
 985         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
 986         if idx == 0 {
 987             try!(write!(self.writer, "\n"));
 988         } else {
 989             try!(write!(self.writer, ",\n"));
 990         }
 991         try!(spaces(self.writer, self.curr_indent));
 992         self.is_emitting_map_key = true;
 993         try!(f(self));
 994         self.is_emitting_map_key = false;
 995         Ok(())
 996     }
 997
 998     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult where
 999         F: FnOnce(&mut PrettyEncoder<'a>) -> EncodeResult,
1000     {
1001         if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
1002         try!(write!(self.writer, ": "));
1003         f(self)
1004     }
1005 }
1006
1007 impl Encodable for Json {
1008     fn encode<E: ::Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
1009         match *self {
1010             Json::I64(v) => v.encode(e),
1011             Json::U64(v) => v.encode(e),
1012             Json::F64(v) => v.encode(e),
1013             Json::String(ref v) => v.encode(e),
1014             Json::Boolean(v) => v.encode(e),
1015             Json::Array(ref v) => v.encode(e),
1016             Json::Object(ref v) => v.encode(e),
1017             Json::Null => e.emit_nil(),
1018         }
1019     }
1020 }
1021
1022 /// Create an `AsJson` wrapper which can be used to print a value as JSON
1023 /// on-the-fly via `write!`
1024 pub fn as_json<T>(t: &T) -> AsJson<T> {
1025     AsJson { inner: t }
1026 }
1027
1028 /// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
1029 /// on-the-fly via `write!`
1030 pub fn as_pretty_json<T>(t: &T) -> AsPrettyJson<T> {
1031     AsPrettyJson { inner: t, indent: None }
1032 }
1033
1034 impl Json {
1035     /// Borrow this json object as a pretty object to generate a pretty
1036     /// representation for it via `Display`.
1037     pub fn pretty(&self) -> PrettyJson {
1038         PrettyJson { inner: self }
1039     }
1040
1041      /// If the Json value is an Object, returns the value associated with the provided key.
1042     /// Otherwise, returns None.
1043     pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
1044         match self {
1045             &Json::Object(ref map) => map.get(key),
1046             _ => None
1047         }
1048     }
1049
1050     /// Attempts to get a nested Json Object for each key in `keys`.
1051     /// If any key is found not to exist, find_path will return None.
1052     /// Otherwise, it will return the Json value associated with the final key.
1053     pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
1054         let mut target = self;
1055         for key in keys {
1056             match target.find(*key) {
1057                 Some(t) => { target = t; },
1058                 None => return None
1059             }
1060         }
1061         Some(target)
1062     }
1063
1064     /// If the Json value is an Object, performs a depth-first search until
1065     /// a value associated with the provided key is found. If no value is found
1066     /// or the Json value is not an Object, returns None.
1067     pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
1068         match self {
1069             &Json::Object(ref map) => {
1070                 match map.get(key) {
1071                     Some(json_value) => Some(json_value),
1072                     None => {
1073                         for (_, v) in map {
1074                             match v.search(key) {
1075                                 x if x.is_some() => return x,
1076                                 _ => ()
1077                             }
1078                         }
1079                         None
1080                     }
1081                 }
1082             },
1083             _ => None
1084         }
1085     }
1086
1087     /// Returns true if the Json value is an Object. Returns false otherwise.
1088     pub fn is_object<'a>(&'a self) -> bool {
1089         self.as_object().is_some()
1090     }
1091
1092     /// If the Json value is an Object, returns the associated BTreeMap.
1093     /// Returns None otherwise.
1094     pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
1095         match self {
1096             &Json::Object(ref map) => Some(map),
1097             _ => None
1098         }
1099     }
1100
1101     /// Returns true if the Json value is an Array. Returns false otherwise.
1102     pub fn is_array<'a>(&'a self) -> bool {
1103         self.as_array().is_some()
1104     }
1105
1106     /// If the Json value is an Array, returns the associated vector.
1107     /// Returns None otherwise.
1108     pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
1109         match self {
1110             &Json::Array(ref array) => Some(&*array),
1111             _ => None
1112         }
1113     }
1114
1115     /// Returns true if the Json value is a String. Returns false otherwise.
1116     pub fn is_string<'a>(&'a self) -> bool {
1117         self.as_string().is_some()
1118     }
1119
1120     /// If the Json value is a String, returns the associated str.
1121     /// Returns None otherwise.
1122     pub fn as_string<'a>(&'a self) -> Option<&'a str> {
1123         match *self {
1124             Json::String(ref s) => Some(&s[..]),
1125             _ => None
1126         }
1127     }
1128
1129     /// Returns true if the Json value is a Number. Returns false otherwise.
1130     pub fn is_number(&self) -> bool {
1131         match *self {
1132             Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
1133             _ => false,
1134         }
1135     }
1136
1137     /// Returns true if the Json value is a i64. Returns false otherwise.
1138     pub fn is_i64(&self) -> bool {
1139         match *self {
1140             Json::I64(_) => true,
1141             _ => false,
1142         }
1143     }
1144
1145     /// Returns true if the Json value is a u64. Returns false otherwise.
1146     pub fn is_u64(&self) -> bool {
1147         match *self {
1148             Json::U64(_) => true,
1149             _ => false,
1150         }
1151     }
1152
1153     /// Returns true if the Json value is a f64. Returns false otherwise.
1154     pub fn is_f64(&self) -> bool {
1155         match *self {
1156             Json::F64(_) => true,
1157             _ => false,
1158         }
1159     }
1160
1161     /// If the Json value is a number, return or cast it to a i64.
1162     /// Returns None otherwise.
1163     pub fn as_i64(&self) -> Option<i64> {
1164         match *self {
1165             Json::I64(n) => Some(n),
1166             Json::U64(n) => num::cast(n),
1167             _ => None
1168         }
1169     }
1170
1171     /// If the Json value is a number, return or cast it to a u64.
1172     /// Returns None otherwise.
1173     pub fn as_u64(&self) -> Option<u64> {
1174         match *self {
1175             Json::I64(n) => num::cast(n),
1176             Json::U64(n) => Some(n),
1177             _ => None
1178         }
1179     }
1180
1181     /// If the Json value is a number, return or cast it to a f64.
1182     /// Returns None otherwise.
1183     pub fn as_f64(&self) -> Option<f64> {
1184         match *self {
1185             Json::I64(n) => num::cast(n),
1186             Json::U64(n) => num::cast(n),
1187             Json::F64(n) => Some(n),
1188             _ => None
1189         }
1190     }
1191
1192     /// Returns true if the Json value is a Boolean. Returns false otherwise.
1193     pub fn is_boolean(&self) -> bool {
1194         self.as_boolean().is_some()
1195     }
1196
1197     /// If the Json value is a Boolean, returns the associated bool.
1198     /// Returns None otherwise.
1199     pub fn as_boolean(&self) -> Option<bool> {
1200         match self {
1201             &Json::Boolean(b) => Some(b),
1202             _ => None
1203         }
1204     }
1205
1206     /// Returns true if the Json value is a Null. Returns false otherwise.
1207     pub fn is_null(&self) -> bool {
1208         self.as_null().is_some()
1209     }
1210
1211     /// If the Json value is a Null, returns ().
1212     /// Returns None otherwise.
1213     pub fn as_null(&self) -> Option<()> {
1214         match self {
1215             &Json::Null => Some(()),
1216             _ => None
1217         }
1218     }
1219 }
1220
1221 impl<'a> Index<&'a str>  for Json {
1222     type Output = Json;
1223
1224     fn index(&self, idx: &'a str) -> &Json {
1225         self.find(idx).unwrap()
1226     }
1227 }
1228
1229 impl Index<usize> for Json {
1230     type Output = Json;
1231
1232     fn index<'a>(&'a self, idx: usize) -> &'a Json {
1233         match self {
1234             &Json::Array(ref v) => &v[idx],
1235             _ => panic!("can only index Json with usize if it is an array")
1236         }
1237     }
1238 }
1239
1240 /// The output of the streaming parser.
1241 #[derive(PartialEq, Clone, Debug)]
1242 pub enum JsonEvent {
1243     ObjectStart,
1244     ObjectEnd,
1245     ArrayStart,
1246     ArrayEnd,
1247     BooleanValue(bool),
1248     I64Value(i64),
1249     U64Value(u64),
1250     F64Value(f64),
1251     StringValue(string::String),
1252     NullValue,
1253     Error(ParserError),
1254 }
1255
1256 #[derive(PartialEq, Debug)]
1257 enum ParserState {
1258     // Parse a value in an array, true means first element.
1259     ParseArray(bool),
1260     // Parse ',' or ']' after an element in an array.
1261     ParseArrayComma,
1262     // Parse a key:value in an object, true means first element.
1263     ParseObject(bool),
1264     // Parse ',' or ']' after an element in an object.
1265     ParseObjectComma,
1266     // Initial state.
1267     ParseStart,
1268     // Expecting the stream to end.
1269     ParseBeforeFinish,
1270     // Parsing can't continue.
1271     ParseFinished,
1272 }
1273
1274 /// A Stack represents the current position of the parser in the logical
1275 /// structure of the JSON stream.
1276 /// For example foo.bar[3].x
1277 pub struct Stack {
1278     stack: Vec<InternalStackElement>,
1279     str_buffer: Vec<u8>,
1280 }
1281
1282 /// StackElements compose a Stack.
1283 /// For example, StackElement::Key("foo"), StackElement::Key("bar"),
1284 /// StackElement::Index(3) and StackElement::Key("x") are the
1285 /// StackElements compositing the stack that represents foo.bar[3].x
1286 #[derive(PartialEq, Clone, Debug)]
1287 pub enum StackElement<'l> {
1288     Index(u32),
1289     Key(&'l str),
1290 }
1291
1292 // Internally, Key elements are stored as indices in a buffer to avoid
1293 // allocating a string for every member of an object.
1294 #[derive(PartialEq, Clone, Debug)]
1295 enum InternalStackElement {
1296     InternalIndex(u32),
1297     InternalKey(u16, u16), // start, size
1298 }
1299
1300 impl Stack {
1301     pub fn new() -> Stack {
1302         Stack { stack: Vec::new(), str_buffer: Vec::new() }
1303     }
1304
1305     /// Returns The number of elements in the Stack.
1306     pub fn len(&self) -> usize { self.stack.len() }
1307
1308     /// Returns true if the stack is empty.
1309     pub fn is_empty(&self) -> bool { self.stack.is_empty() }
1310
1311     /// Provides access to the StackElement at a given index.
1312     /// lower indices are at the bottom of the stack while higher indices are
1313     /// at the top.
1314     pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
1315         match self.stack[idx] {
1316             InternalIndex(i) => StackElement::Index(i),
1317             InternalKey(start, size) => {
1318                 StackElement::Key(str::from_utf8(
1319                     &self.str_buffer[start as usize .. start as usize + size as usize])
1320                         .unwrap())
1321             }
1322         }
1323     }
1324
1325     /// Compares this stack with an array of StackElements.
1326     pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
1327         if self.stack.len() != rhs.len() { return false; }
1328         for i in 0..rhs.len() {
1329             if self.get(i) != rhs[i] { return false; }
1330         }
1331         return true;
1332     }
1333
1334     /// Returns true if the bottom-most elements of this stack are the same as
1335     /// the ones passed as parameter.
1336     pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
1337         if self.stack.len() < rhs.len() { return false; }
1338         for i in 0..rhs.len() {
1339             if self.get(i) != rhs[i] { return false; }
1340         }
1341         return true;
1342     }
1343
1344     /// Returns true if the top-most elements of this stack are the same as
1345     /// the ones passed as parameter.
1346     pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
1347         if self.stack.len() < rhs.len() { return false; }
1348         let offset = self.stack.len() - rhs.len();
1349         for i in 0..rhs.len() {
1350             if self.get(i + offset) != rhs[i] { return false; }
1351         }
1352         return true;
1353     }
1354
1355     /// Returns the top-most element (if any).
1356     pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
1357         return match self.stack.last() {
1358             None => None,
1359             Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
1360             Some(&InternalKey(start, size)) => {
1361                 Some(StackElement::Key(str::from_utf8(
1362                     &self.str_buffer[start as usize .. (start+size) as usize]
1363                 ).unwrap()))
1364             }
1365         }
1366     }
1367
1368     // Used by Parser to insert StackElement::Key elements at the top of the stack.
1369     fn push_key(&mut self, key: string::String) {
1370         self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
1371         for c in key.as_bytes() {
1372             self.str_buffer.push(*c);
1373         }
1374     }
1375
1376     // Used by Parser to insert StackElement::Index elements at the top of the stack.
1377     fn push_index(&mut self, index: u32) {
1378         self.stack.push(InternalIndex(index));
1379     }
1380
1381     // Used by Parser to remove the top-most element of the stack.
1382     fn pop(&mut self) {
1383         assert!(!self.is_empty());
1384         match *self.stack.last().unwrap() {
1385             InternalKey(_, sz) => {
1386                 let new_size = self.str_buffer.len() - sz as usize;
1387                 self.str_buffer.truncate(new_size);
1388             }
1389             InternalIndex(_) => {}
1390         }
1391         self.stack.pop();
1392     }
1393
1394     // Used by Parser to test whether the top-most element is an index.
1395     fn last_is_index(&self) -> bool {
1396         if self.is_empty() { return false; }
1397         return match *self.stack.last().unwrap() {
1398             InternalIndex(_) => true,
1399             _ => false,
1400         }
1401     }
1402
1403     // Used by Parser to increment the index of the top-most element.
1404     fn bump_index(&mut self) {
1405         let len = self.stack.len();
1406         let idx = match *self.stack.last().unwrap() {
1407             InternalIndex(i) => { i + 1 }
1408             _ => { panic!(); }
1409         };
1410         self.stack[len - 1] = InternalIndex(idx);
1411     }
1412 }
1413
1414 /// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
1415 /// an iterator of char.
1416 pub struct Parser<T> {
1417     rdr: T,
1418     ch: Option<char>,
1419     line: usize,
1420     col: usize,
1421     // We maintain a stack representing where we are in the logical structure
1422     // of the JSON stream.
1423     stack: Stack,
1424     // A state machine is kept to make it possible to interrupt and resume parsing.
1425     state: ParserState,
1426 }
1427
1428 impl<T: Iterator<Item=char>> Iterator for Parser<T> {
1429     type Item = JsonEvent;
1430
1431     fn next(&mut self) -> Option<JsonEvent> {
1432         if self.state == ParseFinished {
1433             return None;
1434         }
1435
1436         if self.state == ParseBeforeFinish {
1437             self.parse_whitespace();
1438             // Make sure there is no trailing characters.
1439             if self.eof() {
1440                 self.state = ParseFinished;
1441                 return None;
1442             } else {
1443                 return Some(self.error_event(TrailingCharacters));
1444             }
1445         }
1446
1447         return Some(self.parse());
1448     }
1449 }
1450
1451 impl<T: Iterator<Item=char>> Parser<T> {
1452     /// Creates the JSON parser.
1453     pub fn new(rdr: T) -> Parser<T> {
1454         let mut p = Parser {
1455             rdr: rdr,
1456             ch: Some('\x00'),
1457             line: 1,
1458             col: 0,
1459             stack: Stack::new(),
1460             state: ParseStart,
1461         };
1462         p.bump();
1463         return p;
1464     }
1465
1466     /// Provides access to the current position in the logical structure of the
1467     /// JSON stream.
1468     pub fn stack<'l>(&'l self) -> &'l Stack {
1469         return &self.stack;
1470     }
1471
1472     fn eof(&self) -> bool { self.ch.is_none() }
1473     fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
1474     fn bump(&mut self) {
1475         self.ch = self.rdr.next();
1476
1477         if self.ch_is('\n') {
1478             self.line += 1;
1479             self.col = 1;
1480         } else {
1481             self.col += 1;
1482         }
1483     }
1484
1485     fn next_char(&mut self) -> Option<char> {
1486         self.bump();
1487         self.ch
1488     }
1489     fn ch_is(&self, c: char) -> bool {
1490         self.ch == Some(c)
1491     }
1492
1493     fn error<U>(&self, reason: ErrorCode) -> Result<U, ParserError> {
1494         Err(SyntaxError(reason, self.line, self.col))
1495     }
1496
1497     fn parse_whitespace(&mut self) {
1498         while self.ch_is(' ') ||
1499               self.ch_is('\n') ||
1500               self.ch_is('\t') ||
1501               self.ch_is('\r') { self.bump(); }
1502     }
1503
1504     fn parse_number(&mut self) -> JsonEvent {
1505         let mut neg = false;
1506
1507         if self.ch_is('-') {
1508             self.bump();
1509             neg = true;
1510         }
1511
1512         let res = match self.parse_u64() {
1513             Ok(res) => res,
1514             Err(e) => { return Error(e); }
1515         };
1516
1517         if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
1518             let mut res = res as f64;
1519
1520             if self.ch_is('.') {
1521                 res = match self.parse_decimal(res) {
1522                     Ok(res) => res,
1523                     Err(e) => { return Error(e); }
1524                 };
1525             }
1526
1527             if self.ch_is('e') || self.ch_is('E') {
1528                 res = match self.parse_exponent(res) {
1529                     Ok(res) => res,
1530                     Err(e) => { return Error(e); }
1531                 };
1532             }
1533
1534             if neg {
1535                 res *= -1.0;
1536             }
1537
1538             F64Value(res)
1539         } else {
1540             if neg {
1541                 let res = -(res as i64);
1542
1543                 // Make sure we didn't underflow.
1544                 if res > 0 {
1545                     Error(SyntaxError(InvalidNumber, self.line, self.col))
1546                 } else {
1547                     I64Value(res)
1548                 }
1549             } else {
1550                 U64Value(res)
1551             }
1552         }
1553     }
1554
1555     fn parse_u64(&mut self) -> Result<u64, ParserError> {
1556         let mut accum = 0;
1557         let last_accum = 0; // necessary to detect overflow.
1558
1559         match self.ch_or_null() {
1560             '0' => {
1561                 self.bump();
1562
1563                 // A leading '0' must be the only digit before the decimal point.
1564                 match self.ch_or_null() {
1565                     '0' ... '9' => return self.error(InvalidNumber),
1566                     _ => ()
1567                 }
1568             },
1569             '1' ... '9' => {
1570                 while !self.eof() {
1571                     match self.ch_or_null() {
1572                         c @ '0' ... '9' => {
1573                             accum = accum.wrapping_mul(10);
1574                             accum = accum.wrapping_add((c as u64) - ('0' as u64));
1575
1576                             // Detect overflow by comparing to the last value.
1577                             if accum <= last_accum { return self.error(InvalidNumber); }
1578
1579                             self.bump();
1580                         }
1581                         _ => break,
1582                     }
1583                 }
1584             }
1585             _ => return self.error(InvalidNumber),
1586         }
1587
1588         Ok(accum)
1589     }
1590
1591     fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
1592         self.bump();
1593
1594         // Make sure a digit follows the decimal place.
1595         match self.ch_or_null() {
1596             '0' ... '9' => (),
1597              _ => return self.error(InvalidNumber)
1598         }
1599
1600         let mut dec = 1.0;
1601         while !self.eof() {
1602             match self.ch_or_null() {
1603                 c @ '0' ... '9' => {
1604                     dec /= 10.0;
1605                     res += (((c as isize) - ('0' as isize)) as f64) * dec;
1606                     self.bump();
1607                 }
1608                 _ => break,
1609             }
1610         }
1611
1612         Ok(res)
1613     }
1614
1615     fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
1616         self.bump();
1617
1618         let mut exp = 0;
1619         let mut neg_exp = false;
1620
1621         if self.ch_is('+') {
1622             self.bump();
1623         } else if self.ch_is('-') {
1624             self.bump();
1625             neg_exp = true;
1626         }
1627
1628         // Make sure a digit follows the exponent place.
1629         match self.ch_or_null() {
1630             '0' ... '9' => (),
1631             _ => return self.error(InvalidNumber)
1632         }
1633         while !self.eof() {
1634             match self.ch_or_null() {
1635                 c @ '0' ... '9' => {
1636                     exp *= 10;
1637                     exp += (c as usize) - ('0' as usize);
1638
1639                     self.bump();
1640                 }
1641                 _ => break
1642             }
1643         }
1644
1645         let exp = 10_f64.powi(exp as i32);
1646         if neg_exp {
1647             res /= exp;
1648         } else {
1649             res *= exp;
1650         }
1651
1652         Ok(res)
1653     }
1654
1655     fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
1656         let mut i = 0;
1657         let mut n = 0;
1658         while i < 4 && !self.eof() {
1659             self.bump();
1660             n = match self.ch_or_null() {
1661                 c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
1662                 'a' | 'A' => n * 16 + 10,
1663                 'b' | 'B' => n * 16 + 11,
1664                 'c' | 'C' => n * 16 + 12,
1665                 'd' | 'D' => n * 16 + 13,
1666                 'e' | 'E' => n * 16 + 14,
1667                 'f' | 'F' => n * 16 + 15,
1668                 _ => return self.error(InvalidEscape)
1669             };
1670
1671             i += 1;
1672         }
1673
1674         // Error out if we didn't parse 4 digits.
1675         if i != 4 {
1676             return self.error(InvalidEscape);
1677         }
1678
1679         Ok(n)
1680     }
1681
1682     fn parse_str(&mut self) -> Result<string::String, ParserError> {
1683         let mut escape = false;
1684         let mut res = string::String::new();
1685
1686         loop {
1687             self.bump();
1688             if self.eof() {
1689                 return self.error(EOFWhileParsingString);
1690             }
1691
1692             if escape {
1693                 match self.ch_or_null() {
1694                     '"' => res.push('"'),
1695                     '\\' => res.push('\\'),
1696                     '/' => res.push('/'),
1697                     'b' => res.push('\x08'),
1698                     'f' => res.push('\x0c'),
1699                     'n' => res.push('\n'),
1700                     'r' => res.push('\r'),
1701                     't' => res.push('\t'),
1702                     'u' => match try!(self.decode_hex_escape()) {
1703                         0xDC00 ... 0xDFFF => {
1704                             return self.error(LoneLeadingSurrogateInHexEscape)
1705                         }
1706
1707                         // Non-BMP characters are encoded as a sequence of
1708                         // two hex escapes, representing UTF-16 surrogates.
1709                         n1 @ 0xD800 ... 0xDBFF => {
1710                             match (self.next_char(), self.next_char()) {
1711                                 (Some('\\'), Some('u')) => (),
1712                                 _ => return self.error(UnexpectedEndOfHexEscape),
1713                             }
1714
1715                             let buf = [n1, try!(self.decode_hex_escape())];
1716                             match unicode_str::utf16_items(&buf).next() {
1717                                 Some(Utf16Item::ScalarValue(c)) => res.push(c),
1718                                 _ => return self.error(LoneLeadingSurrogateInHexEscape),
1719                             }
1720                         }
1721
1722                         n => match char::from_u32(n as u32) {
1723                             Some(c) => res.push(c),
1724                             None => return self.error(InvalidUnicodeCodePoint),
1725                         },
1726                     },
1727                     _ => return self.error(InvalidEscape),
1728                 }
1729                 escape = false;
1730             } else if self.ch_is('\\') {
1731                 escape = true;
1732             } else {
1733                 match self.ch {
1734                     Some('"') => {
1735                         self.bump();
1736                         return Ok(res);
1737                     },
1738                     Some(c) => res.push(c),
1739                     None => unreachable!()
1740                 }
1741             }
1742         }
1743     }
1744
1745     // Invoked at each iteration, consumes the stream until it has enough
1746     // information to return a JsonEvent.
1747     // Manages an internal state so that parsing can be interrupted and resumed.
1748     // Also keeps track of the position in the logical structure of the json
1749     // stream isize the form of a stack that can be queried by the user using the
1750     // stack() method.
1751     fn parse(&mut self) -> JsonEvent {
1752         loop {
1753             // The only paths where the loop can spin a new iteration
1754             // are in the cases ParseArrayComma and ParseObjectComma if ','
1755             // is parsed. In these cases the state is set to (respectively)
1756             // ParseArray(false) and ParseObject(false), which always return,
1757             // so there is no risk of getting stuck in an infinite loop.
1758             // All other paths return before the end of the loop's iteration.
1759             self.parse_whitespace();
1760
1761             match self.state {
1762                 ParseStart => {
1763                     return self.parse_start();
1764                 }
1765                 ParseArray(first) => {
1766                     return self.parse_array(first);
1767                 }
1768                 ParseArrayComma => {
1769                     match self.parse_array_comma_or_end() {
1770                         Some(evt) => { return evt; }
1771                         None => {}
1772                     }
1773                 }
1774                 ParseObject(first) => {
1775                     return self.parse_object(first);
1776                 }
1777                 ParseObjectComma => {
1778                     self.stack.pop();
1779                     if self.ch_is(',') {
1780                         self.state = ParseObject(false);
1781                         self.bump();
1782                     } else {
1783                         return self.parse_object_end();
1784                     }
1785                 }
1786                 _ => {
1787                     return self.error_event(InvalidSyntax);
1788                 }
1789             }
1790         }
1791     }
1792
1793     fn parse_start(&mut self) -> JsonEvent {
1794         let val = self.parse_value();
1795         self.state = match val {
1796             Error(_) => ParseFinished,
1797             ArrayStart => ParseArray(true),
1798             ObjectStart => ParseObject(true),
1799             _ => ParseBeforeFinish,
1800         };
1801         return val;
1802     }
1803
1804     fn parse_array(&mut self, first: bool) -> JsonEvent {
1805         if self.ch_is(']') {
1806             if !first {
1807                 self.error_event(InvalidSyntax)
1808             } else {
1809                 self.state = if self.stack.is_empty() {
1810                     ParseBeforeFinish
1811                 } else if self.stack.last_is_index() {
1812                     ParseArrayComma
1813                 } else {
1814                     ParseObjectComma
1815                 };
1816                 self.bump();
1817                 ArrayEnd
1818             }
1819         } else {
1820             if first {
1821                 self.stack.push_index(0);
1822             }
1823             let val = self.parse_value();
1824             self.state = match val {
1825                 Error(_) => ParseFinished,
1826                 ArrayStart => ParseArray(true),
1827                 ObjectStart => ParseObject(true),
1828                 _ => ParseArrayComma,
1829             };
1830             val
1831         }
1832     }
1833
1834     fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
1835         if self.ch_is(',') {
1836             self.stack.bump_index();
1837             self.state = ParseArray(false);
1838             self.bump();
1839             None
1840         } else if self.ch_is(']') {
1841             self.stack.pop();
1842             self.state = if self.stack.is_empty() {
1843                 ParseBeforeFinish
1844             } else if self.stack.last_is_index() {
1845                 ParseArrayComma
1846             } else {
1847                 ParseObjectComma
1848             };
1849             self.bump();
1850             Some(ArrayEnd)
1851         } else if self.eof() {
1852             Some(self.error_event(EOFWhileParsingArray))
1853         } else {
1854             Some(self.error_event(InvalidSyntax))
1855         }
1856     }
1857
1858     fn parse_object(&mut self, first: bool) -> JsonEvent {
1859         if self.ch_is('}') {
1860             if !first {
1861                 if self.stack.is_empty() {
1862                     return self.error_event(TrailingComma);
1863                 } else {
1864                     self.stack.pop();
1865                 }
1866             }
1867             self.state = if self.stack.is_empty() {
1868                 ParseBeforeFinish
1869             } else if self.stack.last_is_index() {
1870                 ParseArrayComma
1871             } else {
1872                 ParseObjectComma
1873             };
1874             self.bump();
1875             return ObjectEnd;
1876         }
1877         if self.eof() {
1878             return self.error_event(EOFWhileParsingObject);
1879         }
1880         if !self.ch_is('"') {
1881             return self.error_event(KeyMustBeAString);
1882         }
1883         let s = match self.parse_str() {
1884             Ok(s) => s,
1885             Err(e) => {
1886                 self.state = ParseFinished;
1887                 return Error(e);
1888             }
1889         };
1890         self.parse_whitespace();
1891         if self.eof() {
1892             return self.error_event(EOFWhileParsingObject);
1893         } else if self.ch_or_null() != ':' {
1894             return self.error_event(ExpectedColon);
1895         }
1896         self.stack.push_key(s);
1897         self.bump();
1898         self.parse_whitespace();
1899
1900         let val = self.parse_value();
1901
1902         self.state = match val {
1903             Error(_) => ParseFinished,
1904             ArrayStart => ParseArray(true),
1905             ObjectStart => ParseObject(true),
1906             _ => ParseObjectComma,
1907         };
1908         return val;
1909     }
1910
1911     fn parse_object_end(&mut self) -> JsonEvent {
1912         if self.ch_is('}') {
1913             self.state = if self.stack.is_empty() {
1914                 ParseBeforeFinish
1915             } else if self.stack.last_is_index() {
1916                 ParseArrayComma
1917             } else {
1918                 ParseObjectComma
1919             };
1920             self.bump();
1921             ObjectEnd
1922         } else if self.eof() {
1923             self.error_event(EOFWhileParsingObject)
1924         } else {
1925             self.error_event(InvalidSyntax)
1926         }
1927     }
1928
1929     fn parse_value(&mut self) -> JsonEvent {
1930         if self.eof() { return self.error_event(EOFWhileParsingValue); }
1931         match self.ch_or_null() {
1932             'n' => { self.parse_ident("ull", NullValue) }
1933             't' => { self.parse_ident("rue", BooleanValue(true)) }
1934             'f' => { self.parse_ident("alse", BooleanValue(false)) }
1935             '0' ... '9' | '-' => self.parse_number(),
1936             '"' => match self.parse_str() {
1937                 Ok(s) => StringValue(s),
1938                 Err(e) => Error(e),
1939             },
1940             '[' => {
1941                 self.bump();
1942                 ArrayStart
1943             }
1944             '{' => {
1945                 self.bump();
1946                 ObjectStart
1947             }
1948             _ => { self.error_event(InvalidSyntax) }
1949         }
1950     }
1951
1952     fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
1953         if ident.chars().all(|c| Some(c) == self.next_char()) {
1954             self.bump();
1955             value
1956         } else {
1957             Error(SyntaxError(InvalidSyntax, self.line, self.col))
1958         }
1959     }
1960
1961     fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
1962         self.state = ParseFinished;
1963         Error(SyntaxError(reason, self.line, self.col))
1964     }
1965 }
1966
1967 /// A Builder consumes a json::Parser to create a generic Json structure.
1968 pub struct Builder<T> {
1969     parser: Parser<T>,
1970     token: Option<JsonEvent>,
1971 }
1972
1973 impl<T: Iterator<Item=char>> Builder<T> {
1974     /// Create a JSON Builder.
1975     pub fn new(src: T) -> Builder<T> {
1976         Builder { parser: Parser::new(src), token: None, }
1977     }
1978
1979     // Decode a Json value from a Parser.
1980     pub fn build(&mut self) -> Result<Json, BuilderError> {
1981         self.bump();
1982         let result = self.build_value();
1983         self.bump();
1984         match self.token {
1985             None => {}
1986             Some(Error(ref e)) => { return Err(e.clone()); }
1987             ref tok => { panic!("unexpected token {:?}", tok.clone()); }
1988         }
1989         result
1990     }
1991
1992     fn bump(&mut self) {
1993         self.token = self.parser.next();
1994     }
1995
1996     fn build_value(&mut self) -> Result<Json, BuilderError> {
1997         return match self.token {
1998             Some(NullValue) => Ok(Json::Null),
1999             Some(I64Value(n)) => Ok(Json::I64(n)),
2000             Some(U64Value(n)) => Ok(Json::U64(n)),
2001             Some(F64Value(n)) => Ok(Json::F64(n)),
2002             Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
2003             Some(StringValue(ref mut s)) => {
2004                 let mut temp = string::String::new();
2005                 swap(s, &mut temp);
2006                 Ok(Json::String(temp))
2007             }
2008             Some(Error(ref e)) => Err(e.clone()),
2009             Some(ArrayStart) => self.build_array(),
2010             Some(ObjectStart) => self.build_object(),
2011             Some(ObjectEnd) => self.parser.error(InvalidSyntax),
2012             Some(ArrayEnd) => self.parser.error(InvalidSyntax),
2013             None => self.parser.error(EOFWhileParsingValue),
2014         }
2015     }
2016
2017     fn build_array(&mut self) -> Result<Json, BuilderError> {
2018         self.bump();
2019         let mut values = Vec::new();
2020
2021         loop {
2022             if self.token == Some(ArrayEnd) {
2023                 return Ok(Json::Array(values.into_iter().collect()));
2024             }
2025             match self.build_value() {
2026                 Ok(v) => values.push(v),
2027                 Err(e) => { return Err(e) }
2028             }
2029             self.bump();
2030         }
2031     }
2032
2033     fn build_object(&mut self) -> Result<Json, BuilderError> {
2034         self.bump();
2035
2036         let mut values = BTreeMap::new();
2037
2038         loop {
2039             match self.token {
2040                 Some(ObjectEnd) => { return Ok(Json::Object(values)); }
2041                 Some(Error(ref e)) => { return Err(e.clone()); }
2042                 None => { break; }
2043                 _ => {}
2044             }
2045             let key = match self.parser.stack().top() {
2046                 Some(StackElement::Key(k)) => { k.to_string() }
2047                 _ => { panic!("invalid state"); }
2048             };
2049             match self.build_value() {
2050                 Ok(value) => { values.insert(key, value); }
2051                 Err(e) => { return Err(e); }
2052             }
2053             self.bump();
2054         }
2055         return self.parser.error(EOFWhileParsingObject);
2056     }
2057 }
2058
2059 /// Decodes a json value from an `&mut old_io::Reader`
2060 pub fn from_reader(rdr: &mut Read) -> Result<Json, BuilderError> {
2061     let mut contents = Vec::new();
2062     match rdr.read_to_end(&mut contents) {
2063         Ok(c)  => c,
2064         Err(e) => return Err(io_error_to_error(e))
2065     };
2066     let s = match str::from_utf8(&contents).ok() {
2067         Some(s) => s,
2068         _       => return Err(SyntaxError(NotUtf8, 0, 0))
2069     };
2070     let mut builder = Builder::new(s.chars());
2071     builder.build()
2072 }
2073
2074 /// Decodes a json value from a string
2075 pub fn from_str(s: &str) -> Result<Json, BuilderError> {
2076     let mut builder = Builder::new(s.chars());
2077     builder.build()
2078 }
2079
2080 /// A structure to decode JSON to values in rust.
2081 pub struct Decoder {
2082     stack: Vec<Json>,
2083 }
2084
2085 impl Decoder {
2086     /// Creates a new decoder instance for decoding the specified JSON value.
2087     pub fn new(json: Json) -> Decoder {
2088         Decoder { stack: vec![json] }
2089     }
2090 }
2091
2092 impl Decoder {
2093     fn pop(&mut self) -> Json {
2094         self.stack.pop().unwrap()
2095     }
2096 }
2097
2098 macro_rules! expect {
2099     ($e:expr, Null) => ({
2100         match $e {
2101             Json::Null => Ok(()),
2102             other => Err(ExpectedError("Null".to_string(),
2103                                        format!("{}", other)))
2104         }
2105     });
2106     ($e:expr, $t:ident) => ({
2107         match $e {
2108             Json::$t(v) => Ok(v),
2109             other => {
2110                 Err(ExpectedError(stringify!($t).to_string(),
2111                                   format!("{}", other)))
2112             }
2113         }
2114     })
2115 }
2116
2117 macro_rules! read_primitive {
2118     ($name:ident, $ty:ty) => {
2119         fn $name(&mut self) -> DecodeResult<$ty> {
2120             match self.pop() {
2121                 Json::I64(f) => match num::cast(f) {
2122                     Some(f) => Ok(f),
2123                     None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
2124                 },
2125                 Json::U64(f) => match num::cast(f) {
2126                     Some(f) => Ok(f),
2127                     None => Err(ExpectedError("Number".to_string(), format!("{}", f))),
2128                 },
2129                 Json::F64(f) => Err(ExpectedError("Integer".to_string(), format!("{}", f))),
2130                 // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
2131                 // is going to have a string here, as per JSON spec.
2132                 Json::String(s) => match s.parse().ok() {
2133                     Some(f) => Ok(f),
2134                     None => Err(ExpectedError("Number".to_string(), s)),
2135                 },
2136                 value => Err(ExpectedError("Number".to_string(), format!("{}", value))),
2137             }
2138         }
2139     }
2140 }
2141
2142 impl ::Decoder for Decoder {
2143     type Error = DecoderError;
2144
2145     fn read_nil(&mut self) -> DecodeResult<()> {
2146         expect!(self.pop(), Null)
2147     }
2148
2149     read_primitive! { read_uint, usize }
2150     read_primitive! { read_u8, u8 }
2151     read_primitive! { read_u16, u16 }
2152     read_primitive! { read_u32, u32 }
2153     read_primitive! { read_u64, u64 }
2154     read_primitive! { read_int, isize }
2155     read_primitive! { read_i8, i8 }
2156     read_primitive! { read_i16, i16 }
2157     read_primitive! { read_i32, i32 }
2158     read_primitive! { read_i64, i64 }
2159
2160     fn read_f32(&mut self) -> DecodeResult<f32> { self.read_f64().map(|x| x as f32) }
2161
2162     fn read_f64(&mut self) -> DecodeResult<f64> {
2163         match self.pop() {
2164             Json::I64(f) => Ok(f as f64),
2165             Json::U64(f) => Ok(f as f64),
2166             Json::F64(f) => Ok(f),
2167             Json::String(s) => {
2168                 // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
2169                 // is going to have a string here, as per JSON spec.
2170                 match s.parse().ok() {
2171                     Some(f) => Ok(f),
2172                     None => Err(ExpectedError("Number".to_string(), s)),
2173                 }
2174             },
2175             Json::Null => Ok(f64::NAN),
2176             value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
2177         }
2178     }
2179
2180     fn read_bool(&mut self) -> DecodeResult<bool> {
2181         expect!(self.pop(), Boolean)
2182     }
2183
2184     fn read_char(&mut self) -> DecodeResult<char> {
2185         let s = try!(self.read_str());
2186         {
2187             let mut it = s.chars();
2188             match (it.next(), it.next()) {
2189                 // exactly one character
2190                 (Some(c), None) => return Ok(c),
2191                 _ => ()
2192             }
2193         }
2194         Err(ExpectedError("single character string".to_string(), format!("{}", s)))
2195     }
2196
2197     fn read_str(&mut self) -> DecodeResult<string::String> {
2198         expect!(self.pop(), String)
2199     }
2200
2201     fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
2202         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2203     {
2204         f(self)
2205     }
2206
2207     fn read_enum_variant<T, F>(&mut self, names: &[&str],
2208                                mut f: F) -> DecodeResult<T>
2209         where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
2210     {
2211         let name = match self.pop() {
2212             Json::String(s) => s,
2213             Json::Object(mut o) => {
2214                 let n = match o.remove(&"variant".to_string()) {
2215                     Some(Json::String(s)) => s,
2216                     Some(val) => {
2217                         return Err(ExpectedError("String".to_string(), format!("{}", val)))
2218                     }
2219                     None => {
2220                         return Err(MissingFieldError("variant".to_string()))
2221                     }
2222                 };
2223                 match o.remove(&"fields".to_string()) {
2224                     Some(Json::Array(l)) => {
2225                         for field in l.into_iter().rev() {
2226                             self.stack.push(field);
2227                         }
2228                     },
2229                     Some(val) => {
2230                         return Err(ExpectedError("Array".to_string(), format!("{}", val)))
2231                     }
2232                     None => {
2233                         return Err(MissingFieldError("fields".to_string()))
2234                     }
2235                 }
2236                 n
2237             }
2238             json => {
2239                 return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
2240             }
2241         };
2242         let idx = match names.iter().position(|n| *n == &name[..]) {
2243             Some(idx) => idx,
2244             None => return Err(UnknownVariantError(name))
2245         };
2246         f(self, idx)
2247     }
2248
2249     fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2250         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2251     {
2252         f(self)
2253     }
2254
2255     fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
2256         F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
2257     {
2258         self.read_enum_variant(names, f)
2259     }
2260
2261
2262     fn read_enum_struct_variant_field<T, F>(&mut self,
2263                                          _name: &str,
2264                                          idx: usize,
2265                                          f: F)
2266                                          -> DecodeResult<T> where
2267         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2268     {
2269         self.read_enum_variant_arg(idx, f)
2270     }
2271
2272     fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
2273         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2274     {
2275         let value = try!(f(self));
2276         self.pop();
2277         Ok(value)
2278     }
2279
2280     fn read_struct_field<T, F>(&mut self,
2281                                name: &str,
2282                                _idx: usize,
2283                                f: F)
2284                                -> DecodeResult<T> where
2285         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2286     {
2287         let mut obj = try!(expect!(self.pop(), Object));
2288
2289         let value = match obj.remove(&name.to_string()) {
2290             None => {
2291                 // Add a Null and try to parse it as an Option<_>
2292                 // to get None as a default value.
2293                 self.stack.push(Json::Null);
2294                 match f(self) {
2295                     Ok(x) => x,
2296                     Err(_) => return Err(MissingFieldError(name.to_string())),
2297                 }
2298             },
2299             Some(json) => {
2300                 self.stack.push(json);
2301                 try!(f(self))
2302             }
2303         };
2304         self.stack.push(Json::Object(obj));
2305         Ok(value)
2306     }
2307
2308     fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
2309         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2310     {
2311         self.read_seq(move |d, len| {
2312             if len == tuple_len {
2313                 f(d)
2314             } else {
2315                 Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
2316             }
2317         })
2318     }
2319
2320     fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
2321         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2322     {
2323         self.read_seq_elt(idx, f)
2324     }
2325
2326     fn read_tuple_struct<T, F>(&mut self,
2327                                _name: &str,
2328                                len: usize,
2329                                f: F)
2330                                -> DecodeResult<T> where
2331         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2332     {
2333         self.read_tuple(len, f)
2334     }
2335
2336     fn read_tuple_struct_arg<T, F>(&mut self,
2337                                    idx: usize,
2338                                    f: F)
2339                                    -> DecodeResult<T> where
2340         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2341     {
2342         self.read_tuple_arg(idx, f)
2343     }
2344
2345     fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
2346         F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
2347     {
2348         match self.pop() {
2349             Json::Null => f(self, false),
2350             value => { self.stack.push(value); f(self, true) }
2351         }
2352     }
2353
2354     fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
2355         F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
2356     {
2357         let array = try!(expect!(self.pop(), Array));
2358         let len = array.len();
2359         for v in array.into_iter().rev() {
2360             self.stack.push(v);
2361         }
2362         f(self, len)
2363     }
2364
2365     fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2366         F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2367     {
2368         f(self)
2369     }
2370
2371     fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
2372         F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
2373     {
2374         let obj = try!(expect!(self.pop(), Object));
2375         let len = obj.len();
2376         for (key, value) in obj {
2377             self.stack.push(value);
2378             self.stack.push(Json::String(key));
2379         }
2380         f(self, len)
2381     }
2382
2383     fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2384        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2385     {
2386         f(self)
2387     }
2388
2389     fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
2390        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
2391     {
2392         f(self)
2393     }
2394
2395     fn error(&mut self, err: &str) -> DecoderError {
2396         ApplicationError(err.to_string())
2397     }
2398 }
2399
2400 /// A trait for converting values to JSON
2401 pub trait ToJson {
2402     /// Converts the value of `self` to an instance of JSON
2403     fn to_json(&self) -> Json;
2404 }
2405
2406 macro_rules! to_json_impl_i64 {
2407     ($($t:ty), +) => (
2408         $(impl ToJson for $t {
2409             fn to_json(&self) -> Json {
2410                 Json::I64(*self as i64)
2411             }
2412         })+
2413     )
2414 }
2415
2416 to_json_impl_i64! { isize, i8, i16, i32, i64 }
2417
2418 macro_rules! to_json_impl_u64 {
2419     ($($t:ty), +) => (
2420         $(impl ToJson for $t {
2421             fn to_json(&self) -> Json {
2422                 Json::U64(*self as u64)
2423             }
2424         })+
2425     )
2426 }
2427
2428 to_json_impl_u64! { usize, u8, u16, u32, u64 }
2429
2430 impl ToJson for Json {
2431     fn to_json(&self) -> Json { self.clone() }
2432 }
2433
2434 impl ToJson for f32 {
2435     fn to_json(&self) -> Json { (*self as f64).to_json() }
2436 }
2437
2438 impl ToJson for f64 {
2439     fn to_json(&self) -> Json {
2440         match self.classify() {
2441             Fp::Nan | Fp::Infinite => Json::Null,
2442             _                  => Json::F64(*self)
2443         }
2444     }
2445 }
2446
2447 impl ToJson for () {
2448     fn to_json(&self) -> Json { Json::Null }
2449 }
2450
2451 impl ToJson for bool {
2452     fn to_json(&self) -> Json { Json::Boolean(*self) }
2453 }
2454
2455 impl ToJson for str {
2456     fn to_json(&self) -> Json { Json::String(self.to_string()) }
2457 }
2458
2459 impl ToJson for string::String {
2460     fn to_json(&self) -> Json { Json::String((*self).clone()) }
2461 }
2462
2463 macro_rules! tuple_impl {
2464     // use variables to indicate the arity of the tuple
2465     ($($tyvar:ident),* ) => {
2466         // the trailing commas are for the 1 tuple
2467         impl<
2468             $( $tyvar : ToJson ),*
2469             > ToJson for ( $( $tyvar ),* , ) {
2470
2471             #[inline]
2472             #[allow(non_snake_case)]
2473             fn to_json(&self) -> Json {
2474                 match *self {
2475                     ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
2476                 }
2477             }
2478         }
2479     }
2480 }
2481
2482 tuple_impl!{A}
2483 tuple_impl!{A, B}
2484 tuple_impl!{A, B, C}
2485 tuple_impl!{A, B, C, D}
2486 tuple_impl!{A, B, C, D, E}
2487 tuple_impl!{A, B, C, D, E, F}
2488 tuple_impl!{A, B, C, D, E, F, G}
2489 tuple_impl!{A, B, C, D, E, F, G, H}
2490 tuple_impl!{A, B, C, D, E, F, G, H, I}
2491 tuple_impl!{A, B, C, D, E, F, G, H, I, J}
2492 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
2493 tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
2494
2495 impl<A: ToJson> ToJson for [A] {
2496     fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2497 }
2498
2499 impl<A: ToJson> ToJson for Vec<A> {
2500     fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
2501 }
2502
2503 impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
2504     fn to_json(&self) -> Json {
2505         let mut d = BTreeMap::new();
2506         for (key, value) in self {
2507             d.insert((*key).clone(), value.to_json());
2508         }
2509         Json::Object(d)
2510     }
2511 }
2512
2513 impl<A: ToJson> ToJson for HashMap<string::String, A> {
2514     fn to_json(&self) -> Json {
2515         let mut d = BTreeMap::new();
2516         for (key, value) in self {
2517             d.insert((*key).clone(), value.to_json());
2518         }
2519         Json::Object(d)
2520     }
2521 }
2522
2523 impl<A:ToJson> ToJson for Option<A> {
2524     fn to_json(&self) -> Json {
2525         match *self {
2526             None => Json::Null,
2527             Some(ref value) => value.to_json()
2528         }
2529     }
2530 }
2531
2532 struct FormatShim<'a, 'b: 'a> {
2533     inner: &'a mut fmt::Formatter<'b>,
2534 }
2535
2536 impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
2537     fn write_str(&mut self, s: &str) -> fmt::Result {
2538         match self.inner.write_str(s) {
2539             Ok(_) => Ok(()),
2540             Err(_) => Err(fmt::Error)
2541         }
2542     }
2543 }
2544
2545 impl fmt::Display for Json {
2546     /// Encodes a json value into a string
2547     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2548         let mut shim = FormatShim { inner: f };
2549         let mut encoder = Encoder::new(&mut shim);
2550         match self.encode(&mut encoder) {
2551             Ok(_) => Ok(()),
2552             Err(_) => Err(fmt::Error)
2553         }
2554     }
2555 }
2556
2557 impl<'a> fmt::Display for PrettyJson<'a> {
2558     /// Encodes a json value into a string
2559     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2560         let mut shim = FormatShim { inner: f };
2561         let mut encoder = PrettyEncoder::new(&mut shim);
2562         match self.inner.encode(&mut encoder) {
2563             Ok(_) => Ok(()),
2564             Err(_) => Err(fmt::Error)
2565         }
2566     }
2567 }
2568
2569 impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
2570     /// Encodes a json value into a string
2571     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2572         let mut shim = FormatShim { inner: f };
2573         let mut encoder = Encoder::new(&mut shim);
2574         match self.inner.encode(&mut encoder) {
2575             Ok(_) => Ok(()),
2576             Err(_) => Err(fmt::Error)
2577         }
2578     }
2579 }
2580
2581 impl<'a, T> AsPrettyJson<'a, T> {
2582     /// Set the indentation level for the emitted JSON
2583     pub fn indent(mut self, indent: usize) -> AsPrettyJson<'a, T> {
2584         self.indent = Some(indent);
2585         self
2586     }
2587 }
2588
2589 impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
2590     /// Encodes a json value into a string
2591     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2592         let mut shim = FormatShim { inner: f };
2593         let mut encoder = PrettyEncoder::new(&mut shim);
2594         match self.indent {
2595             Some(n) => encoder.set_indent(n),
2596             None => {}
2597         }
2598         match self.inner.encode(&mut encoder) {
2599             Ok(_) => Ok(()),
2600             Err(_) => Err(fmt::Error)
2601         }
2602     }
2603 }
2604
2605 impl FromStr for Json {
2606     type Err = BuilderError;
2607     fn from_str(s: &str) -> Result<Json, BuilderError> {
2608         from_str(s)
2609     }
2610 }
2611
2612 #[cfg(test)]
2613 mod tests {
2614     extern crate test;
2615     use self::Animal::*;
2616     use self::DecodeEnum::*;
2617     use self::test::Bencher;
2618     use {Encodable, Decodable};
2619     use super::Json::*;
2620     use super::ErrorCode::*;
2621     use super::ParserError::*;
2622     use super::DecoderError::*;
2623     use super::JsonEvent::*;
2624     use super::{Json, from_str, DecodeResult, DecoderError, JsonEvent, Parser,
2625                 StackElement, Stack, Decoder, Encoder, EncoderError};
2626     use std::{i64, u64, f32, f64};
2627     use std::collections::BTreeMap;
2628     use std::string;
2629     use std::old_io::Writer;
2630
2631     #[derive(RustcDecodable, Eq, PartialEq, Debug)]
2632     struct OptionData {
2633         opt: Option<usize>,
2634     }
2635
2636     #[test]
2637     fn test_decode_option_none() {
2638         let s ="{}";
2639         let obj: OptionData = super::decode(s).unwrap();
2640         assert_eq!(obj, OptionData { opt: None });
2641     }
2642
2643     #[test]
2644     fn test_decode_option_some() {
2645         let s = "{ \"opt\": 10 }";
2646         let obj: OptionData = super::decode(s).unwrap();
2647         assert_eq!(obj, OptionData { opt: Some(10) });
2648     }
2649
2650     #[test]
2651     fn test_decode_option_malformed() {
2652         check_err::<OptionData>("{ \"opt\": [] }",
2653                                 ExpectedError("Number".to_string(), "[]".to_string()));
2654         check_err::<OptionData>("{ \"opt\": false }",
2655                                 ExpectedError("Number".to_string(), "false".to_string()));
2656     }
2657
2658     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2659     enum Animal {
2660         Dog,
2661         Frog(string::String, isize)
2662     }
2663
2664     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2665     struct Inner {
2666         a: (),
2667         b: usize,
2668         c: Vec<string::String>,
2669     }
2670
2671     #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
2672     struct Outer {
2673         inner: Vec<Inner>,
2674     }
2675
2676     fn mk_object(items: &[(string::String, Json)]) -> Json {
2677         let mut d = BTreeMap::new();
2678
2679         for item in items {
2680             match *item {
2681                 (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
2682             }
2683         };
2684
2685         Object(d)
2686     }
2687
2688     #[test]
2689     fn test_from_str_trait() {
2690         let s = "null";
2691         assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
2692     }
2693
2694     #[test]
2695     fn test_write_null() {
2696         assert_eq!(Null.to_string(), "null");
2697         assert_eq!(Null.pretty().to_string(), "null");
2698     }
2699
2700     #[test]
2701     fn test_write_i64() {
2702         assert_eq!(U64(0).to_string(), "0");
2703         assert_eq!(U64(0).pretty().to_string(), "0");
2704
2705         assert_eq!(U64(1234).to_string(), "1234");
2706         assert_eq!(U64(1234).pretty().to_string(), "1234");
2707
2708         assert_eq!(I64(-5678).to_string(), "-5678");
2709         assert_eq!(I64(-5678).pretty().to_string(), "-5678");
2710
2711         assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
2712         assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
2713     }
2714
2715     #[test]
2716     fn test_write_f64() {
2717         assert_eq!(F64(3.0).to_string(), "3.0");
2718         assert_eq!(F64(3.0).pretty().to_string(), "3.0");
2719
2720         assert_eq!(F64(3.1).to_string(), "3.1");
2721         assert_eq!(F64(3.1).pretty().to_string(), "3.1");
2722
2723         assert_eq!(F64(-1.5).to_string(), "-1.5");
2724         assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
2725
2726         assert_eq!(F64(0.5).to_string(), "0.5");
2727         assert_eq!(F64(0.5).pretty().to_string(), "0.5");
2728
2729         assert_eq!(F64(f64::NAN).to_string(), "null");
2730         assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
2731
2732         assert_eq!(F64(f64::INFINITY).to_string(), "null");
2733         assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
2734
2735         assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
2736         assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
2737     }
2738
2739     #[test]
2740     fn test_write_str() {
2741         assert_eq!(String("".to_string()).to_string(), "\"\"");
2742         assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
2743
2744         assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
2745         assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
2746     }
2747
2748     #[test]
2749     fn test_write_bool() {
2750         assert_eq!(Boolean(true).to_string(), "true");
2751         assert_eq!(Boolean(true).pretty().to_string(), "true");
2752
2753         assert_eq!(Boolean(false).to_string(), "false");
2754         assert_eq!(Boolean(false).pretty().to_string(), "false");
2755     }
2756
2757     #[test]
2758     fn test_write_array() {
2759         assert_eq!(Array(vec![]).to_string(), "[]");
2760         assert_eq!(Array(vec![]).pretty().to_string(), "[]");
2761
2762         assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
2763         assert_eq!(
2764             Array(vec![Boolean(true)]).pretty().to_string(),
2765             "\
2766             [\n  \
2767                 true\n\
2768             ]"
2769         );
2770
2771         let long_test_array = Array(vec![
2772             Boolean(false),
2773             Null,
2774             Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
2775
2776         assert_eq!(long_test_array.to_string(),
2777             "[false,null,[\"foo\\nbar\",3.5]]");
2778         assert_eq!(
2779             long_test_array.pretty().to_string(),
2780             "\
2781             [\n  \
2782                 false,\n  \
2783                 null,\n  \
2784                 [\n    \
2785                     \"foo\\nbar\",\n    \
2786                     3.5\n  \
2787                 ]\n\
2788             ]"
2789         );
2790     }
2791
2792     #[test]
2793     fn test_write_object() {
2794         assert_eq!(mk_object(&[]).to_string(), "{}");
2795         assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
2796
2797         assert_eq!(
2798             mk_object(&[
2799                 ("a".to_string(), Boolean(true))
2800             ]).to_string(),
2801             "{\"a\":true}"
2802         );
2803         assert_eq!(
2804             mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
2805             "\
2806             {\n  \
2807                 \"a\": true\n\
2808             }"
2809         );
2810
2811         let complex_obj = mk_object(&[
2812                 ("b".to_string(), Array(vec![
2813                     mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
2814                     mk_object(&[("d".to_string(), String("".to_string()))])
2815                 ]))
2816             ]);
2817
2818         assert_eq!(
2819             complex_obj.to_string(),
2820             "{\
2821                 \"b\":[\
2822                     {\"c\":\"\\f\\r\"},\
2823                     {\"d\":\"\"}\
2824                 ]\
2825             }"
2826         );
2827         assert_eq!(
2828             complex_obj.pretty().to_string(),
2829             "\
2830             {\n  \
2831                 \"b\": [\n    \
2832                     {\n      \
2833                         \"c\": \"\\f\\r\"\n    \
2834                     },\n    \
2835                     {\n      \
2836                         \"d\": \"\"\n    \
2837                     }\n  \
2838                 ]\n\
2839             }"
2840         );
2841
2842         let a = mk_object(&[
2843             ("a".to_string(), Boolean(true)),
2844             ("b".to_string(), Array(vec![
2845                 mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
2846                 mk_object(&[("d".to_string(), String("".to_string()))])
2847             ]))
2848         ]);
2849
2850         // We can't compare the strings directly because the object fields be
2851         // printed in a different order.
2852         assert_eq!(a.clone(), a.to_string().parse().unwrap());
2853         assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
2854     }
2855
2856     #[test]
2857     fn test_write_enum() {
2858         let animal = Dog;
2859         assert_eq!(
2860             format!("{}", super::as_json(&animal)),
2861             "\"Dog\""
2862         );
2863         assert_eq!(
2864             format!("{}", super::as_pretty_json(&animal)),
2865             "\"Dog\""
2866         );
2867
2868         let animal = Frog("Henry".to_string(), 349);
2869         assert_eq!(
2870             format!("{}", super::as_json(&animal)),
2871             "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
2872         );
2873         assert_eq!(
2874             format!("{}", super::as_pretty_json(&animal)),
2875             "{\n  \
2876                \"variant\": \"Frog\",\n  \
2877                \"fields\": [\n    \
2878                  \"Henry\",\n    \
2879                  349\n  \
2880                ]\n\
2881              }"
2882         );
2883     }
2884
2885     macro_rules! check_encoder_for_simple {
2886         ($value:expr, $expected:expr) => ({
2887             let s = format!("{}", super::as_json(&$value));
2888             assert_eq!(s, $expected);
2889
2890             let s = format!("{}", super::as_pretty_json(&$value));
2891             assert_eq!(s, $expected);
2892         })
2893     }
2894
2895     #[test]
2896     fn test_write_some() {
2897         check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
2898     }
2899
2900     #[test]
2901     fn test_write_none() {
2902         check_encoder_for_simple!(None::<string::String>, "null");
2903     }
2904
2905     #[test]
2906     fn test_write_char() {
2907         check_encoder_for_simple!('a', "\"a\"");
2908         check_encoder_for_simple!('\t', "\"\\t\"");
2909         check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
2910         check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
2911         check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
2912         check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
2913         check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
2914         check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
2915     }
2916
2917     #[test]
2918     fn test_trailing_characters() {
2919         assert_eq!(from_str("nulla"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
2920         assert_eq!(from_str("truea"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
2921         assert_eq!(from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
2922         assert_eq!(from_str("1a"),     Err(SyntaxError(TrailingCharacters, 1, 2)));
2923         assert_eq!(from_str("[]a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
2924         assert_eq!(from_str("{}a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
2925     }
2926
2927     #[test]
2928     fn test_read_identifiers() {
2929         assert_eq!(from_str("n"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2930         assert_eq!(from_str("nul"),  Err(SyntaxError(InvalidSyntax, 1, 4)));
2931         assert_eq!(from_str("t"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2932         assert_eq!(from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
2933         assert_eq!(from_str("f"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
2934         assert_eq!(from_str("faz"),  Err(SyntaxError(InvalidSyntax, 1, 3)));
2935
2936         assert_eq!(from_str("null"), Ok(Null));
2937         assert_eq!(from_str("true"), Ok(Boolean(true)));
2938         assert_eq!(from_str("false"), Ok(Boolean(false)));
2939         assert_eq!(from_str(" null "), Ok(Null));
2940         assert_eq!(from_str(" true "), Ok(Boolean(true)));
2941         assert_eq!(from_str(" false "), Ok(Boolean(false)));
2942     }
2943
2944     #[test]
2945     fn test_decode_identifiers() {
2946         let v: () = super::decode("null").unwrap();
2947         assert_eq!(v, ());
2948
2949         let v: bool = super::decode("true").unwrap();
2950         assert_eq!(v, true);
2951
2952         let v: bool = super::decode("false").unwrap();
2953         assert_eq!(v, false);
2954     }
2955
2956     #[test]
2957     fn test_read_number() {
2958         assert_eq!(from_str("+"),   Err(SyntaxError(InvalidSyntax, 1, 1)));
2959         assert_eq!(from_str("."),   Err(SyntaxError(InvalidSyntax, 1, 1)));
2960         assert_eq!(from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
2961         assert_eq!(from_str("-"),   Err(SyntaxError(InvalidNumber, 1, 2)));
2962         assert_eq!(from_str("00"),  Err(SyntaxError(InvalidNumber, 1, 2)));
2963         assert_eq!(from_str("1."),  Err(SyntaxError(InvalidNumber, 1, 3)));
2964         assert_eq!(from_str("1e"),  Err(SyntaxError(InvalidNumber, 1, 3)));
2965         assert_eq!(from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
2966
2967         assert_eq!(from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
2968         assert_eq!(from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
2969
2970         assert_eq!(from_str("3"), Ok(U64(3)));
2971         assert_eq!(from_str("3.1"), Ok(F64(3.1)));
2972         assert_eq!(from_str("-1.2"), Ok(F64(-1.2)));
2973         assert_eq!(from_str("0.4"), Ok(F64(0.4)));
2974         assert_eq!(from_str("0.4e5"), Ok(F64(0.4e5)));
2975         assert_eq!(from_str("0.4e+15"), Ok(F64(0.4e15)));
2976         assert_eq!(from_str("0.4e-01"), Ok(F64(0.4e-01)));
2977         assert_eq!(from_str(" 3 "), Ok(U64(3)));
2978
2979         assert_eq!(from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
2980         assert_eq!(from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
2981         assert_eq!(from_str("18446744073709551615"), Ok(U64(u64::MAX)));
2982     }
2983
2984     #[test]
2985     fn test_decode_numbers() {
2986         let v: f64 = super::decode("3").unwrap();
2987         assert_eq!(v, 3.0);
2988
2989         let v: f64 = super::decode("3.1").unwrap();
2990         assert_eq!(v, 3.1);
2991
2992         let v: f64 = super::decode("-1.2").unwrap();
2993         assert_eq!(v, -1.2);
2994
2995         let v: f64 = super::decode("0.4").unwrap();
2996         assert_eq!(v, 0.4);
2997
2998         let v: f64 = super::decode("0.4e5").unwrap();
2999         assert_eq!(v, 0.4e5);
3000
3001         let v: f64 = super::decode("0.4e15").unwrap();
3002         assert_eq!(v, 0.4e15);
3003
3004         let v: f64 = super::decode("0.4e-01").unwrap();
3005         assert_eq!(v, 0.4e-01);
3006
3007         let v: u64 = super::decode("0").unwrap();
3008         assert_eq!(v, 0);
3009
3010         let v: u64 = super::decode("18446744073709551615").unwrap();
3011         assert_eq!(v, u64::MAX);
3012
3013         let v: i64 = super::decode("-9223372036854775808").unwrap();
3014         assert_eq!(v, i64::MIN);
3015
3016         let v: i64 = super::decode("9223372036854775807").unwrap();
3017         assert_eq!(v, i64::MAX);
3018
3019         let res: DecodeResult<i64> = super::decode("765.25252");
3020         assert_eq!(res, Err(ExpectedError("Integer".to_string(),
3021                                           "765.25252".to_string())));
3022     }
3023
3024     #[test]
3025     fn test_read_str() {
3026         assert_eq!(from_str("\""),    Err(SyntaxError(EOFWhileParsingString, 1, 2)));
3027         assert_eq!(from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
3028
3029         assert_eq!(from_str("\"\""), Ok(String("".to_string())));
3030         assert_eq!(from_str("\"foo\""), Ok(String("foo".to_string())));
3031         assert_eq!(from_str("\"\\\"\""), Ok(String("\"".to_string())));
3032         assert_eq!(from_str("\"\\b\""), Ok(String("\x08".to_string())));
3033         assert_eq!(from_str("\"\\n\""), Ok(String("\n".to_string())));
3034         assert_eq!(from_str("\"\\r\""), Ok(String("\r".to_string())));
3035         assert_eq!(from_str("\"\\t\""), Ok(String("\t".to_string())));
3036         assert_eq!(from_str(" \"foo\" "), Ok(String("foo".to_string())));
3037         assert_eq!(from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
3038         assert_eq!(from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
3039     }
3040
3041     #[test]
3042     fn test_decode_str() {
3043         let s = [("\"\"", ""),
3044                  ("\"foo\"", "foo"),
3045                  ("\"\\\"\"", "\""),
3046                  ("\"\\b\"", "\x08"),
3047                  ("\"\\n\"", "\n"),
3048                  ("\"\\r\"", "\r"),
3049                  ("\"\\t\"", "\t"),
3050                  ("\"\\u12ab\"", "\u{12ab}"),
3051                  ("\"\\uAB12\"", "\u{AB12}")];
3052
3053         for &(i, o) in &s {
3054             let v: string::String = super::decode(i).unwrap();
3055             assert_eq!(v, o);
3056         }
3057     }
3058
3059     #[test]
3060     fn test_read_array() {
3061         assert_eq!(from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3062         assert_eq!(from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3063         assert_eq!(from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3064         assert_eq!(from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
3065         assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
3066
3067         assert_eq!(from_str("[]"), Ok(Array(vec![])));
3068         assert_eq!(from_str("[ ]"), Ok(Array(vec![])));
3069         assert_eq!(from_str("[true]"), Ok(Array(vec![Boolean(true)])));
3070         assert_eq!(from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
3071         assert_eq!(from_str("[null]"), Ok(Array(vec![Null])));
3072         assert_eq!(from_str("[3, 1]"),
3073                      Ok(Array(vec![U64(3), U64(1)])));
3074         assert_eq!(from_str("\n[3, 2]\n"),
3075                      Ok(Array(vec![U64(3), U64(2)])));
3076         assert_eq!(from_str("[2, [4, 1]]"),
3077                Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
3078     }
3079
3080     #[test]
3081     fn test_decode_array() {
3082         let v: Vec<()> = super::decode("[]").unwrap();
3083         assert_eq!(v, []);
3084
3085         let v: Vec<()> = super::decode("[null]").unwrap();
3086         assert_eq!(v, [()]);
3087
3088         let v: Vec<bool> = super::decode("[true]").unwrap();
3089         assert_eq!(v, [true]);
3090
3091         let v: Vec<isize> = super::decode("[3, 1]").unwrap();
3092         assert_eq!(v, [3, 1]);
3093
3094         let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
3095         assert_eq!(v, [vec![3], vec![1, 2]]);
3096     }
3097
3098     #[test]
3099     fn test_decode_tuple() {
3100         let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
3101         assert_eq!(t, (1, 2, 3));
3102
3103         let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
3104         assert_eq!(t, (1, "two".to_string()));
3105     }
3106
3107     #[test]
3108     fn test_decode_tuple_malformed_types() {
3109         assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
3110     }
3111
3112     #[test]
3113     fn test_decode_tuple_malformed_length() {
3114         assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
3115     }
3116
3117     #[test]
3118     fn test_read_object() {
3119         assert_eq!(from_str("{"),       Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
3120         assert_eq!(from_str("{ "),      Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
3121         assert_eq!(from_str("{1"),      Err(SyntaxError(KeyMustBeAString,      1, 2)));
3122         assert_eq!(from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3123         assert_eq!(from_str("{\"a\""),  Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
3124         assert_eq!(from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
3125
3126         assert_eq!(from_str("{\"a\" 1"),   Err(SyntaxError(ExpectedColon,         1, 6)));
3127         assert_eq!(from_str("{\"a\":"),    Err(SyntaxError(EOFWhileParsingValue,  1, 6)));
3128         assert_eq!(from_str("{\"a\":1"),   Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
3129         assert_eq!(from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax,         1, 8)));
3130         assert_eq!(from_str("{\"a\":1,"),  Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
3131
3132         assert_eq!(from_str("{}").unwrap(), mk_object(&[]));
3133         assert_eq!(from_str("{\"a\": 3}").unwrap(),
3134                   mk_object(&[("a".to_string(), U64(3))]));
3135
3136         assert_eq!(from_str(
3137                       "{ \"a\": null, \"b\" : true }").unwrap(),
3138                   mk_object(&[
3139                       ("a".to_string(), Null),
3140                       ("b".to_string(), Boolean(true))]));
3141         assert_eq!(from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
3142                   mk_object(&[
3143                       ("a".to_string(), Null),
3144                       ("b".to_string(), Boolean(true))]));
3145         assert_eq!(from_str(
3146                       "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
3147                   mk_object(&[
3148                       ("a".to_string(), F64(1.0)),
3149                       ("b".to_string(), Array(vec![Boolean(true)]))
3150                   ]));
3151         assert_eq!(from_str(
3152                       "{\
3153                           \"a\": 1.0, \
3154                           \"b\": [\
3155                               true,\
3156                               \"foo\\nbar\", \
3157                               { \"c\": {\"d\": null} } \
3158                           ]\
3159                       }").unwrap(),
3160                   mk_object(&[
3161                       ("a".to_string(), F64(1.0)),
3162                       ("b".to_string(), Array(vec![
3163                           Boolean(true),
3164                           String("foo\nbar".to_string()),
3165                           mk_object(&[
3166                               ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
3167                           ])
3168                       ]))
3169                   ]));
3170     }
3171
3172     #[test]
3173     fn test_decode_struct() {
3174         let s = "{
3175             \"inner\": [
3176                 { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
3177             ]
3178         }";
3179
3180         let v: Outer = super::decode(s).unwrap();
3181         assert_eq!(
3182             v,
3183             Outer {
3184                 inner: vec![
3185                     Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
3186                 ]
3187             }
3188         );
3189     }
3190
3191     #[derive(RustcDecodable)]
3192     struct FloatStruct {
3193         f: f64,
3194         a: Vec<f64>
3195     }
3196     #[test]
3197     fn test_decode_struct_with_nan() {
3198         let s = "{\"f\":null,\"a\":[null,123]}";
3199         let obj: FloatStruct = super::decode(s).unwrap();
3200         assert!(obj.f.is_nan());
3201         assert!(obj.a[0].is_nan());
3202         assert_eq!(obj.a[1], 123f64);
3203     }
3204
3205     #[test]
3206     fn test_decode_option() {
3207         let value: Option<string::String> = super::decode("null").unwrap();
3208         assert_eq!(value, None);
3209
3210         let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
3211         assert_eq!(value, Some("jodhpurs".to_string()));
3212     }
3213
3214     #[test]
3215     fn test_decode_enum() {
3216         let value: Animal = super::decode("\"Dog\"").unwrap();
3217         assert_eq!(value, Dog);
3218
3219         let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
3220         let value: Animal = super::decode(s).unwrap();
3221         assert_eq!(value, Frog("Henry".to_string(), 349));
3222     }
3223
3224     #[test]
3225     fn test_decode_map() {
3226         let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
3227                   \"fields\":[\"Henry\", 349]}}";
3228         let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
3229
3230         assert_eq!(map.remove(&"a".to_string()), Some(Dog));
3231         assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
3232     }
3233
3234     #[test]
3235     fn test_multiline_errors() {
3236         assert_eq!(from_str("{\n  \"foo\":\n \"bar\""),
3237             Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
3238     }
3239
3240     #[derive(RustcDecodable)]
3241     #[allow(dead_code)]
3242     struct DecodeStruct {
3243         x: f64,
3244         y: bool,
3245         z: string::String,
3246         w: Vec<DecodeStruct>
3247     }
3248     #[derive(RustcDecodable)]
3249     enum DecodeEnum {
3250         A(f64),
3251         B(string::String)
3252     }
3253     fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
3254         let res: DecodeResult<T> = match from_str(to_parse) {
3255             Err(e) => Err(ParseError(e)),
3256             Ok(json) => Decodable::decode(&mut Decoder::new(json))
3257         };
3258         match res {
3259             Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
3260                               to_parse, expected),
3261             Err(ParseError(e)) => panic!("`{:?}` is not valid json: {:?}",
3262                                            to_parse, e),
3263             Err(e) => {
3264                 assert_eq!(e, expected);
3265             }
3266         }
3267     }
3268     #[test]
3269     fn test_decode_errors_struct() {
3270         check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
3271         check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
3272                                   ExpectedError("Number".to_string(), "true".to_string()));
3273         check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
3274                                   ExpectedError("Boolean".to_string(), "[]".to_string()));
3275         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
3276                                   ExpectedError("String".to_string(), "{}".to_string()));
3277         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
3278                                   ExpectedError("Array".to_string(), "null".to_string()));
3279         check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
3280                                   MissingFieldError("w".to_string()));
3281     }
3282     #[test]
3283     fn test_decode_errors_enum() {
3284         check_err::<DecodeEnum>("{}",
3285                                 MissingFieldError("variant".to_string()));
3286         check_err::<DecodeEnum>("{\"variant\": 1}",
3287                                 ExpectedError("String".to_string(), "1".to_string()));
3288         check_err::<DecodeEnum>("{\"variant\": \"A\"}",
3289                                 MissingFieldError("fields".to_string()));
3290         check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
3291                                 ExpectedError("Array".to_string(), "null".to_string()));
3292         check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
3293                                 UnknownVariantError("C".to_string()));
3294     }
3295
3296     #[test]
3297     fn test_find(){
3298         let json_value = from_str("{\"dog\" : \"cat\"}").unwrap();
3299         let found_str = json_value.find("dog");
3300         assert!(found_str.unwrap().as_string().unwrap() == "cat");
3301     }
3302
3303     #[test]
3304     fn test_find_path(){
3305         let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3306         let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
3307         assert!(found_str.unwrap().as_string().unwrap() == "cheese");
3308     }
3309
3310     #[test]
3311     fn test_search(){
3312         let json_value = from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
3313         let found_str = json_value.search("mouse").and_then(|j| j.as_string());
3314         assert!(found_str.unwrap() == "cheese");
3315     }
3316
3317     #[test]
3318     fn test_index(){
3319         let json_value = from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
3320         let ref array = json_value["animals"];
3321         assert_eq!(array[0].as_string().unwrap(), "dog");
3322         assert_eq!(array[1].as_string().unwrap(), "cat");
3323         assert_eq!(array[2].as_string().unwrap(), "mouse");
3324     }
3325
3326     #[test]
3327     fn test_is_object(){
3328         let json_value = from_str("{}").unwrap();
3329         assert!(json_value.is_object());
3330     }
3331
3332     #[test]
3333     fn test_as_object(){
3334         let json_value = from_str("{}").unwrap();
3335         let json_object = json_value.as_object();
3336         assert!(json_object.is_some());
3337     }
3338
3339     #[test]
3340     fn test_is_array(){
3341         let json_value = from_str("[1, 2, 3]").unwrap();
3342         assert!(json_value.is_array());
3343     }
3344
3345     #[test]
3346     fn test_as_array(){
3347         let json_value = from_str("[1, 2, 3]").unwrap();
3348         let json_array = json_value.as_array();
3349         let expected_length = 3;
3350         assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
3351     }
3352
3353     #[test]
3354     fn test_is_string(){
3355         let json_value = from_str("\"dog\"").unwrap();
3356         assert!(json_value.is_string());
3357     }
3358
3359     #[test]
3360     fn test_as_string(){
3361         let json_value = from_str("\"dog\"").unwrap();
3362         let json_str = json_value.as_string();
3363         let expected_str = "dog";
3364         assert_eq!(json_str, Some(expected_str));
3365     }
3366
3367     #[test]
3368     fn test_is_number(){
3369         let json_value = from_str("12").unwrap();
3370         assert!(json_value.is_number());
3371     }
3372
3373     #[test]
3374     fn test_is_i64(){
3375         let json_value = from_str("-12").unwrap();
3376         assert!(json_value.is_i64());
3377
3378         let json_value = from_str("12").unwrap();
3379         assert!(!json_value.is_i64());
3380
3381         let json_value = from_str("12.0").unwrap();
3382         assert!(!json_value.is_i64());
3383     }
3384
3385     #[test]
3386     fn test_is_u64(){
3387         let json_value = from_str("12").unwrap();
3388         assert!(json_value.is_u64());
3389
3390         let json_value = from_str("-12").unwrap();
3391         assert!(!json_value.is_u64());
3392
3393         let json_value = from_str("12.0").unwrap();
3394         assert!(!json_value.is_u64());
3395     }
3396
3397     #[test]
3398     fn test_is_f64(){
3399         let json_value = from_str("12").unwrap();
3400         assert!(!json_value.is_f64());
3401
3402         let json_value = from_str("-12").unwrap();
3403         assert!(!json_value.is_f64());
3404
3405         let json_value = from_str("12.0").unwrap();
3406         assert!(json_value.is_f64());
3407
3408         let json_value = from_str("-12.0").unwrap();
3409         assert!(json_value.is_f64());
3410     }
3411
3412     #[test]
3413     fn test_as_i64(){
3414         let json_value = from_str("-12").unwrap();
3415         let json_num = json_value.as_i64();
3416         assert_eq!(json_num, Some(-12));
3417     }
3418
3419     #[test]
3420     fn test_as_u64(){
3421         let json_value = from_str("12").unwrap();
3422         let json_num = json_value.as_u64();
3423         assert_eq!(json_num, Some(12));
3424     }
3425
3426     #[test]
3427     fn test_as_f64(){
3428         let json_value = from_str("12.0").unwrap();
3429         let json_num = json_value.as_f64();
3430         assert_eq!(json_num, Some(12f64));
3431     }
3432
3433     #[test]
3434     fn test_is_boolean(){
3435         let json_value = from_str("false").unwrap();
3436         assert!(json_value.is_boolean());
3437     }
3438
3439     #[test]
3440     fn test_as_boolean(){
3441         let json_value = from_str("false").unwrap();
3442         let json_bool = json_value.as_boolean();
3443         let expected_bool = false;
3444         assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
3445     }
3446
3447     #[test]
3448     fn test_is_null(){
3449         let json_value = from_str("null").unwrap();
3450         assert!(json_value.is_null());
3451     }
3452
3453     #[test]
3454     fn test_as_null(){
3455         let json_value = from_str("null").unwrap();
3456         let json_null = json_value.as_null();
3457         let expected_null = ();
3458         assert!(json_null.is_some() && json_null.unwrap() == expected_null);
3459     }
3460
3461     #[test]
3462     fn test_encode_hashmap_with_numeric_key() {
3463         use std::str::from_utf8;
3464         use std::old_io::Writer;
3465         use std::collections::HashMap;
3466         let mut hm: HashMap<usize, bool> = HashMap::new();
3467         hm.insert(1, true);
3468         let mut mem_buf = Vec::new();
3469         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
3470         let json_str = from_utf8(&mem_buf[..]).unwrap();
3471         match from_str(json_str) {
3472             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3473             _ => {} // it parsed and we are good to go
3474         }
3475     }
3476
3477     #[test]
3478     fn test_prettyencode_hashmap_with_numeric_key() {
3479         use std::str::from_utf8;
3480         use std::old_io::Writer;
3481         use std::collections::HashMap;
3482         let mut hm: HashMap<usize, bool> = HashMap::new();
3483         hm.insert(1, true);
3484         let mut mem_buf = Vec::new();
3485         write!(&mut mem_buf, "{}", super::as_pretty_json(&hm)).unwrap();
3486         let json_str = from_utf8(&mem_buf[..]).unwrap();
3487         match from_str(json_str) {
3488             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3489             _ => {} // it parsed and we are good to go
3490         }
3491     }
3492
3493     #[test]
3494     fn test_prettyencoder_indent_level_param() {
3495         use std::str::from_utf8;
3496         use std::collections::BTreeMap;
3497
3498         let mut tree = BTreeMap::new();
3499
3500         tree.insert("hello".to_string(), String("guten tag".to_string()));
3501         tree.insert("goodbye".to_string(), String("sayonara".to_string()));
3502
3503         let json = Array(
3504             // The following layout below should look a lot like
3505             // the pretty-printed JSON (indent * x)
3506             vec!
3507             ( // 0x
3508                 String("greetings".to_string()), // 1x
3509                 Object(tree), // 1x + 2x + 2x + 1x
3510             ) // 0x
3511             // End JSON array (7 lines)
3512         );
3513
3514         // Helper function for counting indents
3515         fn indents(source: &str) -> usize {
3516             let trimmed = source.trim_left_matches(' ');
3517             source.len() - trimmed.len()
3518         }
3519
3520         // Test up to 4 spaces of indents (more?)
3521         for i in 0..4 {
3522             let mut writer = Vec::new();
3523             write!(&mut writer, "{}",
3524                    super::as_pretty_json(&json).indent(i)).unwrap();
3525
3526             let printed = from_utf8(&writer[..]).unwrap();
3527
3528             // Check for indents at each line
3529             let lines: Vec<&str> = printed.lines().collect();
3530             assert_eq!(lines.len(), 7); // JSON should be 7 lines
3531
3532             assert_eq!(indents(lines[0]), 0 * i); // [
3533             assert_eq!(indents(lines[1]), 1 * i); //   "greetings",
3534             assert_eq!(indents(lines[2]), 1 * i); //   {
3535             assert_eq!(indents(lines[3]), 2 * i); //     "hello": "guten tag",
3536             assert_eq!(indents(lines[4]), 2 * i); //     "goodbye": "sayonara"
3537             assert_eq!(indents(lines[5]), 1 * i); //   },
3538             assert_eq!(indents(lines[6]), 0 * i); // ]
3539
3540             // Finally, test that the pretty-printed JSON is valid
3541             from_str(printed).ok().expect("Pretty-printed JSON is invalid!");
3542         }
3543     }
3544
3545     #[test]
3546     fn test_hashmap_with_enum_key() {
3547         use std::collections::HashMap;
3548         use json;
3549         #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
3550         enum Enum {
3551             Foo,
3552             #[allow(dead_code)]
3553             Bar,
3554         }
3555         let mut map = HashMap::new();
3556         map.insert(Enum::Foo, 0);
3557         let result = json::encode(&map).unwrap();
3558         assert_eq!(&result[..], r#"{"Foo":0}"#);
3559         let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
3560         assert_eq!(map, decoded);
3561     }
3562
3563     #[test]
3564     fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
3565         use std::collections::HashMap;
3566         use Decodable;
3567         let json_str = "{\"1\":true}";
3568         let json_obj = match from_str(json_str) {
3569             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3570             Ok(o) => o
3571         };
3572         let mut decoder = Decoder::new(json_obj);
3573         let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
3574     }
3575
3576     #[test]
3577     fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
3578         use std::collections::HashMap;
3579         use Decodable;
3580         let json_str = "{\"a\":true}";
3581         let json_obj = match from_str(json_str) {
3582             Err(_) => panic!("Unable to parse json_str: {:?}", json_str),
3583             Ok(o) => o
3584         };
3585         let mut decoder = Decoder::new(json_obj);
3586         let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
3587         assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
3588     }
3589
3590     fn assert_stream_equal(src: &str,
3591                            expected: Vec<(JsonEvent, Vec<StackElement>)>) {
3592         let mut parser = Parser::new(src.chars());
3593         let mut i = 0;
3594         loop {
3595             let evt = match parser.next() {
3596                 Some(e) => e,
3597                 None => { break; }
3598             };
3599             let (ref expected_evt, ref expected_stack) = expected[i];
3600             if !parser.stack().is_equal_to(expected_stack) {
3601                 panic!("Parser stack is not equal to {:?}", expected_stack);
3602             }
3603             assert_eq!(&evt, expected_evt);
3604             i+=1;
3605         }
3606     }
3607     #[test]
3608     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3609     fn test_streaming_parser() {
3610         assert_stream_equal(
3611             r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
3612             vec![
3613                 (ObjectStart,             vec![]),
3614                   (StringValue("bar".to_string()),   vec![StackElement::Key("foo")]),
3615                   (ArrayStart,            vec![StackElement::Key("array")]),
3616                     (U64Value(0),         vec![StackElement::Key("array"), StackElement::Index(0)]),
3617                     (U64Value(1),         vec![StackElement::Key("array"), StackElement::Index(1)]),
3618                     (U64Value(2),         vec![StackElement::Key("array"), StackElement::Index(2)]),
3619                     (U64Value(3),         vec![StackElement::Key("array"), StackElement::Index(3)]),
3620                     (U64Value(4),         vec![StackElement::Key("array"), StackElement::Index(4)]),
3621                     (U64Value(5),         vec![StackElement::Key("array"), StackElement::Index(5)]),
3622                   (ArrayEnd,              vec![StackElement::Key("array")]),
3623                   (ArrayStart,            vec![StackElement::Key("idents")]),
3624                     (NullValue,           vec![StackElement::Key("idents"),
3625                                                StackElement::Index(0)]),
3626                     (BooleanValue(true),  vec![StackElement::Key("idents"),
3627                                                StackElement::Index(1)]),
3628                     (BooleanValue(false), vec![StackElement::Key("idents"),
3629                                                StackElement::Index(2)]),
3630                   (ArrayEnd,              vec![StackElement::Key("idents")]),
3631                 (ObjectEnd,               vec![]),
3632             ]
3633         );
3634     }
3635     fn last_event(src: &str) -> JsonEvent {
3636         let mut parser = Parser::new(src.chars());
3637         let mut evt = NullValue;
3638         loop {
3639             evt = match parser.next() {
3640                 Some(e) => e,
3641                 None => return evt,
3642             }
3643         }
3644     }
3645
3646     #[test]
3647     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3648     fn test_read_object_streaming() {
3649         assert_eq!(last_event("{ "),      Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
3650         assert_eq!(last_event("{1"),      Error(SyntaxError(KeyMustBeAString,      1, 2)));
3651         assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3652         assert_eq!(last_event("{\"a\""),  Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
3653         assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
3654
3655         assert_eq!(last_event("{\"a\" 1"),   Error(SyntaxError(ExpectedColon,         1, 6)));
3656         assert_eq!(last_event("{\"a\":"),    Error(SyntaxError(EOFWhileParsingValue,  1, 6)));
3657         assert_eq!(last_event("{\"a\":1"),   Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
3658         assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax,         1, 8)));
3659         assert_eq!(last_event("{\"a\":1,"),  Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
3660         assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
3661
3662         assert_stream_equal(
3663             "{}",
3664             vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
3665         );
3666         assert_stream_equal(
3667             "{\"a\": 3}",
3668             vec![
3669                 (ObjectStart,        vec![]),
3670                   (U64Value(3),      vec![StackElement::Key("a")]),
3671                 (ObjectEnd,          vec![]),
3672             ]
3673         );
3674         assert_stream_equal(
3675             "{ \"a\": null, \"b\" : true }",
3676             vec![
3677                 (ObjectStart,           vec![]),
3678                   (NullValue,           vec![StackElement::Key("a")]),
3679                   (BooleanValue(true),  vec![StackElement::Key("b")]),
3680                 (ObjectEnd,             vec![]),
3681             ]
3682         );
3683         assert_stream_equal(
3684             "{\"a\" : 1.0 ,\"b\": [ true ]}",
3685             vec![
3686                 (ObjectStart,           vec![]),
3687                   (F64Value(1.0),       vec![StackElement::Key("a")]),
3688                   (ArrayStart,          vec![StackElement::Key("b")]),
3689                     (BooleanValue(true),vec![StackElement::Key("b"), StackElement::Index(0)]),
3690                   (ArrayEnd,            vec![StackElement::Key("b")]),
3691                 (ObjectEnd,             vec![]),
3692             ]
3693         );
3694         assert_stream_equal(
3695             r#"{
3696                 "a": 1.0,
3697                 "b": [
3698                     true,
3699                     "foo\nbar",
3700                     { "c": {"d": null} }
3701                 ]
3702             }"#,
3703             vec![
3704                 (ObjectStart,                   vec![]),
3705                   (F64Value(1.0),               vec![StackElement::Key("a")]),
3706                   (ArrayStart,                  vec![StackElement::Key("b")]),
3707                     (BooleanValue(true),        vec![StackElement::Key("b"),
3708                                                      StackElement::Index(0)]),
3709                     (StringValue("foo\nbar".to_string()),  vec![StackElement::Key("b"),
3710                                                                 StackElement::Index(1)]),
3711                     (ObjectStart,               vec![StackElement::Key("b"),
3712                                                      StackElement::Index(2)]),
3713                       (ObjectStart,             vec![StackElement::Key("b"),
3714                                                      StackElement::Index(2),
3715                                                      StackElement::Key("c")]),
3716                         (NullValue,             vec![StackElement::Key("b"),
3717                                                      StackElement::Index(2),
3718                                                      StackElement::Key("c"),
3719                                                      StackElement::Key("d")]),
3720                       (ObjectEnd,               vec![StackElement::Key("b"),
3721                                                      StackElement::Index(2),
3722                                                      StackElement::Key("c")]),
3723                     (ObjectEnd,                 vec![StackElement::Key("b"),
3724                                                      StackElement::Index(2)]),
3725                   (ArrayEnd,                    vec![StackElement::Key("b")]),
3726                 (ObjectEnd,                     vec![]),
3727             ]
3728         );
3729     }
3730     #[test]
3731     #[cfg_attr(target_pointer_width = "32", ignore)] // FIXME(#14064)
3732     fn test_read_array_streaming() {
3733         assert_stream_equal(
3734             "[]",
3735             vec![
3736                 (ArrayStart, vec![]),
3737                 (ArrayEnd,   vec![]),
3738             ]
3739         );
3740         assert_stream_equal(
3741             "[ ]",
3742             vec![
3743                 (ArrayStart, vec![]),
3744                 (ArrayEnd,   vec![]),
3745             ]
3746         );
3747         assert_stream_equal(
3748             "[true]",
3749             vec![
3750                 (ArrayStart,             vec![]),
3751                     (BooleanValue(true), vec![StackElement::Index(0)]),
3752                 (ArrayEnd,               vec![]),
3753             ]
3754         );
3755         assert_stream_equal(
3756             "[ false ]",
3757             vec![
3758                 (ArrayStart,              vec![]),
3759                     (BooleanValue(false), vec![StackElement::Index(0)]),
3760                 (ArrayEnd,                vec![]),
3761             ]
3762         );
3763         assert_stream_equal(
3764             "[null]",
3765             vec![
3766                 (ArrayStart,    vec![]),
3767                     (NullValue, vec![StackElement::Index(0)]),
3768                 (ArrayEnd,      vec![]),
3769             ]
3770         );
3771         assert_stream_equal(
3772             "[3, 1]",
3773             vec![
3774                 (ArrayStart,      vec![]),
3775                     (U64Value(3), vec![StackElement::Index(0)]),
3776                     (U64Value(1), vec![StackElement::Index(1)]),
3777                 (ArrayEnd,        vec![]),
3778             ]
3779         );
3780         assert_stream_equal(
3781             "\n[3, 2]\n",
3782             vec![
3783                 (ArrayStart,      vec![]),
3784                     (U64Value(3), vec![StackElement::Index(0)]),
3785                     (U64Value(2), vec![StackElement::Index(1)]),
3786                 (ArrayEnd,        vec![]),
3787             ]
3788         );
3789         assert_stream_equal(
3790             "[2, [4, 1]]",
3791             vec![
3792                 (ArrayStart,           vec![]),
3793                     (U64Value(2),      vec![StackElement::Index(0)]),
3794                     (ArrayStart,       vec![StackElement::Index(1)]),
3795                         (U64Value(4),  vec![StackElement::Index(1), StackElement::Index(0)]),
3796                         (U64Value(1),  vec![StackElement::Index(1), StackElement::Index(1)]),
3797                     (ArrayEnd,         vec![StackElement::Index(1)]),
3798                 (ArrayEnd,             vec![]),
3799             ]
3800         );
3801
3802         assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1,  2)));
3803
3804         assert_eq!(from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
3805         assert_eq!(from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
3806         assert_eq!(from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
3807         assert_eq!(from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
3808         assert_eq!(from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
3809
3810     }
3811     #[test]
3812     fn test_trailing_characters_streaming() {
3813         assert_eq!(last_event("nulla"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
3814         assert_eq!(last_event("truea"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
3815         assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
3816         assert_eq!(last_event("1a"),     Error(SyntaxError(TrailingCharacters, 1, 2)));
3817         assert_eq!(last_event("[]a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
3818         assert_eq!(last_event("{}a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
3819     }
3820     #[test]
3821     fn test_read_identifiers_streaming() {
3822         assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
3823         assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
3824         assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
3825
3826         assert_eq!(last_event("n"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3827         assert_eq!(last_event("nul"),  Error(SyntaxError(InvalidSyntax, 1, 4)));
3828         assert_eq!(last_event("t"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3829         assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
3830         assert_eq!(last_event("f"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
3831         assert_eq!(last_event("faz"),  Error(SyntaxError(InvalidSyntax, 1, 3)));
3832     }
3833
3834     #[test]
3835     fn test_stack() {
3836         let mut stack = Stack::new();
3837
3838         assert!(stack.is_empty());
3839         assert!(stack.len() == 0);
3840         assert!(!stack.last_is_index());
3841
3842         stack.push_index(0);
3843         stack.bump_index();
3844
3845         assert!(stack.len() == 1);
3846         assert!(stack.is_equal_to(&[StackElement::Index(1)]));
3847         assert!(stack.starts_with(&[StackElement::Index(1)]));
3848         assert!(stack.ends_with(&[StackElement::Index(1)]));
3849         assert!(stack.last_is_index());
3850         assert!(stack.get(0) == StackElement::Index(1));
3851
3852         stack.push_key("foo".to_string());
3853
3854         assert!(stack.len() == 2);
3855         assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
3856         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3857         assert!(stack.starts_with(&[StackElement::Index(1)]));
3858         assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3859         assert!(stack.ends_with(&[StackElement::Key("foo")]));
3860         assert!(!stack.last_is_index());
3861         assert!(stack.get(0) == StackElement::Index(1));
3862         assert!(stack.get(1) == StackElement::Key("foo"));
3863
3864         stack.push_key("bar".to_string());
3865
3866         assert!(stack.len() == 3);
3867         assert!(stack.is_equal_to(&[StackElement::Index(1),
3868                                     StackElement::Key("foo"),
3869                                     StackElement::Key("bar")]));
3870         assert!(stack.starts_with(&[StackElement::Index(1)]));
3871         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3872         assert!(stack.starts_with(&[StackElement::Index(1),
3873                                     StackElement::Key("foo"),
3874                                     StackElement::Key("bar")]));
3875         assert!(stack.ends_with(&[StackElement::Key("bar")]));
3876         assert!(stack.ends_with(&[StackElement::Key("foo"), StackElement::Key("bar")]));
3877         assert!(stack.ends_with(&[StackElement::Index(1),
3878                                   StackElement::Key("foo"),
3879                                   StackElement::Key("bar")]));
3880         assert!(!stack.last_is_index());
3881         assert!(stack.get(0) == StackElement::Index(1));
3882         assert!(stack.get(1) == StackElement::Key("foo"));
3883         assert!(stack.get(2) == StackElement::Key("bar"));
3884
3885         stack.pop();
3886
3887         assert!(stack.len() == 2);
3888         assert!(stack.is_equal_to(&[StackElement::Index(1), StackElement::Key("foo")]));
3889         assert!(stack.starts_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3890         assert!(stack.starts_with(&[StackElement::Index(1)]));
3891         assert!(stack.ends_with(&[StackElement::Index(1), StackElement::Key("foo")]));
3892         assert!(stack.ends_with(&[StackElement::Key("foo")]));
3893         assert!(!stack.last_is_index());
3894         assert!(stack.get(0) == StackElement::Index(1));
3895         assert!(stack.get(1) == StackElement::Key("foo"));
3896     }
3897
3898     #[test]
3899     fn test_to_json() {
3900         use std::collections::{HashMap,BTreeMap};
3901         use super::ToJson;
3902
3903         let array2 = Array(vec!(U64(1), U64(2)));
3904         let array3 = Array(vec!(U64(1), U64(2), U64(3)));
3905         let object = {
3906             let mut tree_map = BTreeMap::new();
3907             tree_map.insert("a".to_string(), U64(1));
3908             tree_map.insert("b".to_string(), U64(2));
3909             Object(tree_map)
3910         };
3911
3912         assert_eq!(array2.to_json(), array2);
3913         assert_eq!(object.to_json(), object);
3914         assert_eq!(3_isize.to_json(), I64(3));
3915         assert_eq!(4_i8.to_json(), I64(4));
3916         assert_eq!(5_i16.to_json(), I64(5));
3917         assert_eq!(6_i32.to_json(), I64(6));
3918         assert_eq!(7_i64.to_json(), I64(7));
3919         assert_eq!(8_usize.to_json(), U64(8));
3920         assert_eq!(9_u8.to_json(), U64(9));
3921         assert_eq!(10_u16.to_json(), U64(10));
3922         assert_eq!(11_u32.to_json(), U64(11));
3923         assert_eq!(12_u64.to_json(), U64(12));
3924         assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
3925         assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
3926         assert_eq!(().to_json(), Null);
3927         assert_eq!(f32::INFINITY.to_json(), Null);
3928         assert_eq!(f64::NAN.to_json(), Null);
3929         assert_eq!(true.to_json(), Boolean(true));
3930         assert_eq!(false.to_json(), Boolean(false));
3931         assert_eq!("abc".to_json(), String("abc".to_string()));
3932         assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
3933         assert_eq!((1_usize, 2_usize).to_json(), array2);
3934         assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
3935         assert_eq!([1_usize, 2_usize].to_json(), array2);
3936         assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
3937         assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
3938         assert_eq!(vec!(1_usize, 2_usize, 3_usize).to_json(), array3);
3939         let mut tree_map = BTreeMap::new();
3940         tree_map.insert("a".to_string(), 1 as usize);
3941         tree_map.insert("b".to_string(), 2);
3942         assert_eq!(tree_map.to_json(), object);
3943         let mut hash_map = HashMap::new();
3944         hash_map.insert("a".to_string(), 1 as usize);
3945         hash_map.insert("b".to_string(), 2);
3946         assert_eq!(hash_map.to_json(), object);
3947         assert_eq!(Some(15).to_json(), I64(15));
3948         assert_eq!(Some(15 as usize).to_json(), U64(15));
3949         assert_eq!(None::<isize>.to_json(), Null);
3950     }
3951
3952     #[test]
3953     fn test_encode_hashmap_with_arbitrary_key() {
3954         use std::collections::HashMap;
3955         #[derive(PartialEq, Eq, Hash, RustcEncodable)]
3956         struct ArbitraryType(usize);
3957         let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
3958         hm.insert(ArbitraryType(1), true);
3959         let mut mem_buf = string::String::new();
3960         let mut encoder = Encoder::new(&mut mem_buf);
3961         let result = hm.encode(&mut encoder);
3962         match result.err().unwrap() {
3963             EncoderError::BadHashmapKey => (),
3964             _ => panic!("expected bad hash map key")
3965         }
3966     }
3967
3968     #[bench]
3969     fn bench_streaming_small(b: &mut Bencher) {
3970         b.iter( || {
3971             let mut parser = Parser::new(
3972                 r#"{
3973                     "a": 1.0,
3974                     "b": [
3975                         true,
3976                         "foo\nbar",
3977                         { "c": {"d": null} }
3978                     ]
3979                 }"#.chars()
3980             );
3981             loop {
3982                 match parser.next() {
3983                     None => return,
3984                     _ => {}
3985                 }
3986             }
3987         });
3988     }
3989     #[bench]
3990     fn bench_small(b: &mut Bencher) {
3991         b.iter( || {
3992             let _ = from_str(r#"{
3993                 "a": 1.0,
3994                 "b": [
3995                     true,
3996                     "foo\nbar",
3997                     { "c": {"d": null} }
3998                 ]
3999             }"#);
4000         });
4001     }
4002
4003     fn big_json() -> string::String {
4004         let mut src = "[\n".to_string();
4005         for _ in 0..500 {
4006             src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
4007                             [1,2,3]},"#);
4008         }
4009         src.push_str("{}]");
4010         return src;
4011     }
4012
4013     #[bench]
4014     fn bench_streaming_large(b: &mut Bencher) {
4015         let src = big_json();
4016         b.iter( || {
4017             let mut parser = Parser::new(src.chars());
4018             loop {
4019                 match parser.next() {
4020                     None => return,
4021                     _ => {}
4022                 }
4023             }
4024         });
4025     }
4026     #[bench]
4027     fn bench_large(b: &mut Bencher) {
4028         let src = big_json();
4029         b.iter( || { let _ = from_str(&src); });
4030     }
4031 }