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