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