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