Permalink
Fetching contributors…
Cannot retrieve contributors at this time
4000 lines (3571 sloc) 131 KB
// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// Rust JSON serialization library
// Copyright (c) 2011 Google Inc.
//! JSON parsing and serialization
//!
//! # What is JSON?
//!
//! JSON (JavaScript Object Notation) is a way to write data in Javascript.
//! Like XML, it allows encoding structured data in a text format that can be
//! easily read by humans. Its simple syntax and native compatibility with
//! JavaScript have made it a widely used format.
//!
//! Data types that can be encoded are JavaScript types (see the `Json` enum
//! for more details):
//!
//! * `I64`: equivalent to rust's `i64`
//! * `U64`: equivalent to rust's `u64`
//! * `F64`: equivalent to rust's `f64`
//! * `Boolean`: equivalent to rust's `bool`
//! * `String`: equivalent to rust's `String`
//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of
//! different types in the
//! same array
//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
//! * `Null`
//!
//! An object is a series of string keys mapping to values, in `"key": value`
//! format. Arrays are enclosed in square brackets ([ ... ]) and objects in
//! curly brackets ({ ... }). A simple JSON document encoding a person,
//! their age, address and phone numbers could look like
//!
//! ```ignore
//! {
//! "FirstName": "John",
//! "LastName": "Doe",
//! "Age": 43,
//! "Address": {
//! "Street": "Downing Street 10",
//! "City": "London",
//! "Country": "Great Britain"
//! },
//! "PhoneNumbers": [
//! "+44 1234567",
//! "+44 2345678"
//! ]
//! }
//! ```
//!
//! # Rust Type-based Encoding and Decoding
//!
//! Rust provides a mechanism for low boilerplate encoding & decoding of values
//! to and from JSON via the serialization API. To be able to encode a piece
//! of data, it must implement the `rustc_serialize::Encodable` trait. To be
//! able to decode a piece of data, it must implement the
//! `rustc_serialize::Decodable` trait. The Rust compiler provides an
//! annotation to automatically generate the code for these traits:
//! `#[derive(RustcDecodable, RustcEncodable)]`
//!
//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode
//! objects. The `ToJson` trait provides a `to_json` method to convert an
//! object into a `json::Json` value. A `json::Json` value can be encoded as a
//! string or buffer using the functions described above. You can also use the
//! `json::Encoder` object, which implements the `Encoder` trait.
//!
//! When using `ToJson`, the `Encodable` trait implementation is not
//! mandatory.
//!
//! # Examples of use
//!
//! ## Using Autoserialization
//!
//! Create a struct called `TestStruct` and serialize and deserialize it to and
//! from JSON using the serialization API, using the derived serialization code.
//!
//! ```rust
//! extern crate rustc_serialize;
//! use rustc_serialize::json;
//!
//! // Automatically generate `RustcDecodable` and `RustcEncodable` trait
//! // implementations
//! #[derive(RustcDecodable, RustcEncodable)]
//! pub struct TestStruct {
//! data_int: u8,
//! data_str: String,
//! data_vector: Vec<u8>,
//! }
//!
//! fn main() {
//! let object = TestStruct {
//! data_int: 1,
//! data_str: "homura".to_string(),
//! data_vector: vec![2,3,4,5],
//! };
//!
//! // Serialize using `json::encode`
//! let encoded = json::encode(&object).unwrap();
//!
//! // Deserialize using `json::decode`
//! let decoded: TestStruct = json::decode(&encoded).unwrap();
//! }
//! ```
//!
//! ## Using the `ToJson` trait
//!
//! The examples below use the `ToJson` trait to generate the JSON string,
//! which is required for custom mappings.
//!
//! ### Simple example of `ToJson` usage
//!
//! ```rust
//! extern crate rustc_serialize;
//! use rustc_serialize::json::{self, ToJson, Json};
//!
//! // A custom data structure
//! struct ComplexNum {
//! a: f64,
//! b: f64,
//! }
//!
//! // JSON value representation
//! impl ToJson for ComplexNum {
//! fn to_json(&self) -> Json {
//! Json::String(format!("{}+{}i", self.a, self.b))
//! }
//! }
//!
//! // Only generate `RustcEncodable` trait implementation
//! #[derive(RustcEncodable)]
//! pub struct ComplexNumRecord {
//! uid: u8,
//! dsc: String,
//! val: Json,
//! }
//!
//! fn main() {
//! let num = ComplexNum { a: 0.0001, b: 12.539 };
//! let data: String = json::encode(&ComplexNumRecord{
//! uid: 1,
//! dsc: "test".to_string(),
//! val: num.to_json(),
//! }).unwrap();
//! println!("data: {}", data);
//! // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"};
//! }
//! ```
//!
//! ### Verbose example of `ToJson` usage
//!
//! ```rust
//! extern crate rustc_serialize;
//! use std::collections::BTreeMap;
//! use rustc_serialize::json::{self, Json, ToJson};
//!
//! // Only generate `Decodable` trait implementation
//! #[derive(RustcDecodable)]
//! pub struct TestStruct {
//! data_int: u8,
//! data_str: String,
//! data_vector: Vec<u8>,
//! }
//!
//! // Specify encoding method manually
//! impl ToJson for TestStruct {
//! fn to_json(&self) -> Json {
//! let mut d = BTreeMap::new();
//! // All standard types implement `to_json()`, so use it
//! d.insert("data_int".to_string(), self.data_int.to_json());
//! d.insert("data_str".to_string(), self.data_str.to_json());
//! d.insert("data_vector".to_string(), self.data_vector.to_json());
//! Json::Object(d)
//! }
//! }
//!
//! fn main() {
//! // Serialize using `ToJson`
//! let input_data = TestStruct {
//! data_int: 1,
//! data_str: "madoka".to_string(),
//! data_vector: vec![2,3,4,5],
//! };
//! let json_obj: Json = input_data.to_json();
//! let json_str: String = json_obj.to_string();
//!
//! // Deserialize like before
//! let decoded: TestStruct = json::decode(&json_str).unwrap();
//! }
//! ```
//!
//! ## Parsing a `str` to `Json` and reading the result
//!
//! ```rust
//! extern crate rustc_serialize;
//! use rustc_serialize::json::Json;
//!
//! fn main() {
//! let data = Json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
//! println!("data: {}", data);
//! // data: {"bar":"baz","foo":13}
//! println!("object? {}", data.is_object());
//! // object? true
//!
//! let obj = data.as_object().unwrap();
//! let foo = obj.get("foo").unwrap();
//!
//! println!("array? {:?}", foo.as_array());
//! // array? None
//! println!("u64? {:?}", foo.as_u64());
//! // u64? Some(13u64)
//!
//! for (key, value) in obj.iter() {
//! println!("{}: {}", key, match *value {
//! Json::U64(v) => format!("{} (u64)", v),
//! Json::String(ref v) => format!("{} (string)", v),
//! _ => format!("other")
//! });
//! }
//! // bar: baz (string)
//! // foo: 13 (u64)
//! }
//! ```
//!
//! # The status of this library
//!
//! While this library is the standard way of working with JSON in Rust,
//! there is a next-generation library called Serde that's in the works (it's
//! faster, overcomes some design limitations of rustc-serialize and has more
//! features). You might consider using it when starting a new project or
//! evaluating Rust JSON performance.
use self::JsonEvent::*;
use self::ErrorCode::*;
use self::ParserError::*;
use self::DecoderError::*;
use self::ParserState::*;
use self::InternalStackElement::*;
use std::collections::{HashMap, BTreeMap};
use std::error::Error as StdError;
use std::i64;
use std::io::prelude::*;
use std::mem::swap;
use std::ops::Index;
use std::str::FromStr;
use std::string;
use std::{char, f64, fmt, io, str};
use Encodable;
/// Represents a json value
#[derive(Clone, PartialEq, PartialOrd, Debug)]
pub enum Json {
I64(i64),
U64(u64),
F64(f64),
String(string::String),
Boolean(bool),
Array(self::Array),
Object(self::Object),
Null,
}
pub type Array = Vec<Json>;
pub type Object = BTreeMap<string::String, Json>;
pub struct PrettyJson<'a> { inner: &'a Json }
pub struct AsJson<'a, T: 'a> { inner: &'a T }
pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<u32> }
/// The errors that can arise while parsing a JSON stream.
#[derive(Clone, Copy, PartialEq)]
pub enum ErrorCode {
InvalidSyntax,
InvalidNumber,
EOFWhileParsingObject,
EOFWhileParsingArray,
EOFWhileParsingValue,
EOFWhileParsingString,
KeyMustBeAString,
ExpectedColon,
TrailingCharacters,
TrailingComma,
InvalidEscape,
InvalidUnicodeCodePoint,
LoneLeadingSurrogateInHexEscape,
UnexpectedEndOfHexEscape,
UnrecognizedHex,
NotFourDigit,
ControlCharacterInString,
NotUtf8,
}
#[derive(Debug)]
pub enum ParserError {
/// msg, line, col
SyntaxError(ErrorCode, usize, usize),
IoError(io::Error),
}
impl PartialEq for ParserError {
fn eq(&self, other: &ParserError) -> bool {
match (self, other) {
(&SyntaxError(msg0, line0, col0), &SyntaxError(msg1, line1, col1)) =>
msg0 == msg1 && line0 == line1 && col0 == col1,
(&IoError(_), _) => false,
(_, &IoError(_)) => false,
}
}
}
// Builder and Parser have the same errors.
pub type BuilderError = ParserError;
#[derive(PartialEq, Debug)]
pub enum DecoderError {
ParseError(ParserError),
ExpectedError(string::String, string::String),
MissingFieldError(string::String),
UnknownVariantError(string::String),
ApplicationError(string::String),
EOF,
}
#[derive(Copy, Debug)]
pub enum EncoderError {
FmtError(fmt::Error),
BadHashmapKey,
}
impl PartialEq for EncoderError {
fn eq(&self, other: &EncoderError) -> bool {
match (*self, *other) {
(EncoderError::FmtError(_), EncoderError::FmtError(_)) => true,
(EncoderError::BadHashmapKey, EncoderError::BadHashmapKey) => true,
_ => false,
}
}
}
impl Clone for EncoderError {
fn clone(&self) -> Self { *self }
}
/// Returns a readable error string for a given error code.
pub fn error_str(error: ErrorCode) -> &'static str {
match error {
InvalidSyntax => "invalid syntax",
InvalidNumber => "invalid number",
EOFWhileParsingObject => "EOF While parsing object",
EOFWhileParsingArray => "EOF While parsing array",
EOFWhileParsingValue => "EOF While parsing value",
EOFWhileParsingString => "EOF While parsing string",
KeyMustBeAString => "key must be a string",
ExpectedColon => "expected `:`",
TrailingCharacters => "trailing characters",
TrailingComma => "trailing comma",
InvalidEscape => "invalid escape",
UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
ControlCharacterInString => "unescaped control character in string",
NotUtf8 => "contents not utf-8",
InvalidUnicodeCodePoint => "invalid Unicode code point",
LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
UnexpectedEndOfHexEscape => "unexpected end of hex escape",
}
}
/// Shortcut function to decode a JSON `&str` into an object
pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
let json = match Json::from_str(s) {
Ok(x) => x,
Err(e) => return Err(ParseError(e))
};
let mut decoder = Decoder::new(json);
::Decodable::decode(&mut decoder)
}
/// Shortcut function to encode a `T` into a JSON `String`
pub fn encode<T: ::Encodable>(object: &T) -> EncodeResult<string::String> {
let mut s = String::new();
{
let mut encoder = Encoder::new(&mut s);
try!(object.encode(&mut encoder));
}
Ok(s)
}
impl fmt::Debug for ErrorCode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
error_str(*self).fmt(f)
}
}
impl StdError for DecoderError {
fn description(&self) -> &str { "decoder error" }
fn cause(&self) -> Option<&StdError> {
match *self {
DecoderError::ParseError(ref e) => Some(e),
_ => None,
}
}
}
impl fmt::Display for DecoderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
impl From<ParserError> for DecoderError {
fn from(err: ParserError) -> DecoderError {
ParseError(From::from(err))
}
}
impl StdError for ParserError {
fn description(&self) -> &str { "failed to parse json" }
}
impl fmt::Display for ParserError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
impl From<io::Error> for ParserError {
fn from(err: io::Error) -> ParserError {
IoError(err)
}
}
impl StdError for EncoderError {
fn description(&self) -> &str { "encoder error" }
}
impl fmt::Display for EncoderError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
impl From<fmt::Error> for EncoderError {
fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
}
pub type EncodeResult<T> = Result<T, EncoderError>;
pub type DecodeResult<T> = Result<T, DecoderError>;
fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> {
try!(wr.write_str("\""));
let mut start = 0;
for (i, byte) in v.bytes().enumerate() {
let escaped = match byte {
b'"' => "\\\"",
b'\\' => "\\\\",
b'\x00' => "\\u0000",
b'\x01' => "\\u0001",
b'\x02' => "\\u0002",
b'\x03' => "\\u0003",
b'\x04' => "\\u0004",
b'\x05' => "\\u0005",
b'\x06' => "\\u0006",
b'\x07' => "\\u0007",
b'\x08' => "\\b",
b'\t' => "\\t",
b'\n' => "\\n",
b'\x0b' => "\\u000b",
b'\x0c' => "\\f",
b'\r' => "\\r",
b'\x0e' => "\\u000e",
b'\x0f' => "\\u000f",
b'\x10' => "\\u0010",
b'\x11' => "\\u0011",
b'\x12' => "\\u0012",
b'\x13' => "\\u0013",
b'\x14' => "\\u0014",
b'\x15' => "\\u0015",
b'\x16' => "\\u0016",
b'\x17' => "\\u0017",
b'\x18' => "\\u0018",
b'\x19' => "\\u0019",
b'\x1a' => "\\u001a",
b'\x1b' => "\\u001b",
b'\x1c' => "\\u001c",
b'\x1d' => "\\u001d",
b'\x1e' => "\\u001e",
b'\x1f' => "\\u001f",
b'\x7f' => "\\u007f",
_ => { continue; }
};
if start < i {
try!(wr.write_str(&v[start..i]));
}
try!(wr.write_str(escaped));
start = i + 1;
}
if start != v.len() {
try!(wr.write_str(&v[start..]));
}
try!(wr.write_str("\""));
Ok(())
}
fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult<()> {
let mut buf = [0; 4];
let _ = write!(&mut &mut buf[..], "{}", v);
let buf = unsafe { str::from_utf8_unchecked(&buf[..v.len_utf8()]) };
escape_str(writer, buf)
}
fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> {
let mut n = n as usize;
const BUF: &'static str = " ";
while n >= BUF.len() {
try!(wr.write_str(BUF));
n -= BUF.len();
}
if n > 0 {
try!(wr.write_str(&BUF[..n]));
}
Ok(())
}
fn fmt_number_or_null(v: f64) -> string::String {
use std::num::FpCategory::{Nan, Infinite};
match v.classify() {
Nan | Infinite => "null".to_string(),
_ => {
let s = v.to_string();
if s.contains(".") {s} else {s + ".0"}
}
}
}
macro_rules! emit_enquoted_if_mapkey {
($enc:ident,$e:expr) => {
if $enc.is_emitting_map_key {
try!(write!($enc.writer, "\"{}\"", $e));
Ok(())
} else {
try!(write!($enc.writer, "{}", $e));
Ok(())
}
}
}
enum EncodingFormat {
Compact,
Pretty {
curr_indent: u32,
indent: u32
}
}
/// A structure for implementing serialization to JSON.
pub struct Encoder<'a> {
writer: &'a mut (fmt::Write+'a),
format : EncodingFormat,
is_emitting_map_key: bool,
}
impl<'a> Encoder<'a> {
/// Creates a new encoder whose output will be written in human-readable
/// JSON to the specified writer
pub fn new_pretty(writer: &'a mut fmt::Write) -> Encoder<'a> {
Encoder {
writer: writer,
format: EncodingFormat::Pretty {
curr_indent: 0,
indent: 2,
},
is_emitting_map_key: false,
}
}
/// Creates a new encoder whose output will be written in compact
/// JSON to the specified writer
pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
Encoder {
writer: writer,
format: EncodingFormat::Compact,
is_emitting_map_key: false,
}
}
/// Set the number of spaces to indent for each level.
/// This is safe to set during encoding.
pub fn set_indent(&mut self, new_indent: u32) -> Result<(), ()> {
if let EncodingFormat::Pretty{ref mut curr_indent, ref mut indent} = self.format {
// self.indent very well could be 0 so we need to use checked division.
let level = curr_indent.checked_div(*indent).unwrap_or(0);
*indent = new_indent;
*curr_indent = level * *indent;
Ok(())
} else {
Err(())
}
}
}
impl<'a> ::Encoder for Encoder<'a> {
type Error = EncoderError;
fn emit_nil(&mut self) -> EncodeResult<()> {
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
try!(write!(self.writer, "null"));
Ok(())
}
fn emit_usize(&mut self, v: usize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_u64(&mut self, v: u64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_u32(&mut self, v: u32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_u16(&mut self, v: u16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_u8(&mut self, v: u8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_isize(&mut self, v: isize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_i64(&mut self, v: i64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_i32(&mut self, v: i32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_i16(&mut self, v: i16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_i8(&mut self, v: i8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
fn emit_bool(&mut self, v: bool) -> EncodeResult<()> {
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if v {
try!(write!(self.writer, "true"));
} else {
try!(write!(self.writer, "false"));
}
Ok(())
}
fn emit_f64(&mut self, v: f64) -> EncodeResult<()> {
emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
}
fn emit_f32(&mut self, v: f32) -> EncodeResult<()> {
self.emit_f64(v as f64)
}
fn emit_char(&mut self, v: char) -> EncodeResult<()> {
escape_char(self.writer, v)
}
fn emit_str(&mut self, v: &str) -> EncodeResult<()> {
escape_str(self.writer, v)
}
fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
f(self)
}
fn emit_enum_variant<F>(&mut self,
name: &str,
_id: usize,
cnt: usize,
f: F)
-> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
// enums are encoded as strings or objects
// Bunny => "Bunny"
// Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
if cnt == 0 {
escape_str(self.writer, name)
} else {
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
try!(write!(self.writer, "{{\n"));
*curr_indent += indent;
try!(spaces(self.writer, *curr_indent));
try!(write!(self.writer, "\"variant\": "));
try!(escape_str(self.writer, name));
try!(write!(self.writer, ",\n"));
try!(spaces(self.writer, *curr_indent));
try!(write!(self.writer, "\"fields\": [\n"));
*curr_indent += indent;
} else {
try!(write!(self.writer, "{{\"variant\":"));
try!(escape_str(self.writer, name));
try!(write!(self.writer, ",\"fields\":["));
}
try!(f(self));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent -= indent;
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, *curr_indent));
*curr_indent -= indent;
try!(write!(self.writer, "]\n"));
try!(spaces(self.writer, *curr_indent));
try!(write!(self.writer, "}}"));
} else {
try!(write!(self.writer, "]}}"));
}
Ok(())
}
}
fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if idx != 0 {
try!(write!(self.writer, ","));
if let EncodingFormat::Pretty{..} = self.format {
try!(write!(self.writer, "\n"));
}
}
if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
try!(spaces(self.writer, curr_indent));
}
f(self)
}
fn emit_enum_struct_variant<F>(&mut self,
name: &str,
id: usize,
cnt: usize,
f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_enum_variant(name, id, cnt, f)
}
fn emit_enum_struct_variant_field<F>(&mut self,
_: &str,
idx: usize,
f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_enum_variant_arg(idx, f)
}
fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if len == 0 {
try!(write!(self.writer, "{{}}"));
} else {
try!(write!(self.writer, "{{"));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent += indent;
}
try!(f(self));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent -= indent;
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, *curr_indent));
}
try!(write!(self.writer, "}}"));
}
Ok(())
}
fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if idx != 0 {
try!(write!(self.writer, ","));
}
if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, curr_indent));
}
try!(escape_str(self.writer, name));
if let EncodingFormat::Pretty{..} = self.format {
try!(write!(self.writer, ": "));
} else {
try!(write!(self.writer, ":"));
}
f(self)
}
fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq_elt(idx, f)
}
fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq(len, f)
}
fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_seq_elt(idx, f)
}
fn emit_option<F>(&mut self, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
fn emit_option_none(&mut self) -> EncodeResult<()> {
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
self.emit_nil()
}
fn emit_option_some<F>(&mut self, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
f(self)
}
fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if len == 0 {
try!(write!(self.writer, "[]"));
} else {
try!(write!(self.writer, "["));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent += indent;
}
try!(f(self));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent -= indent;
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, *curr_indent));
}
try!(write!(self.writer, "]"));
}
Ok(())
}
fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if idx != 0 {
try!(write!(self.writer, ","));
}
if let EncodingFormat::Pretty{ref mut curr_indent, ..} = self.format {
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, *curr_indent));
}
f(self)
}
fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if len == 0 {
try!(write!(self.writer, "{{}}"));
} else {
try!(write!(self.writer, "{{"));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent += indent;
}
try!(f(self));
if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
*curr_indent -= indent;
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, *curr_indent));
}
try!(write!(self.writer, "}}"));
}
Ok(())
}
fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if idx != 0 {
try!(write!(self.writer, ","));
}
if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
try!(write!(self.writer, "\n"));
try!(spaces(self.writer, curr_indent));
}
self.is_emitting_map_key = true;
try!(f(self));
self.is_emitting_map_key = false;
Ok(())
}
fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult<()> where
F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
{
if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
if let EncodingFormat::Pretty{..} = self.format {
try!(write!(self.writer, ": "));
} else {
try!(write!(self.writer, ":"));
}
f(self)
}
}
impl Encodable for Json {
fn encode<S: ::Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
match *self {
Json::I64(v) => v.encode(e),
Json::U64(v) => v.encode(e),
Json::F64(v) => v.encode(e),
Json::String(ref v) => v.encode(e),
Json::Boolean(v) => v.encode(e),
Json::Array(ref v) => v.encode(e),
Json::Object(ref v) => v.encode(e),
Json::Null => e.emit_nil(),
}
}
}
/// Create an `AsJson` wrapper which can be used to print a value as JSON
/// on-the-fly via `write!`
pub fn as_json<T: Encodable>(t: &T) -> AsJson<T> {
AsJson { inner: t }
}
/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
/// on-the-fly via `write!`
pub fn as_pretty_json<T: Encodable>(t: &T) -> AsPrettyJson<T> {
AsPrettyJson { inner: t, indent: None }
}
impl Json {
/// Decodes a json value from an `&mut io::Read`
pub fn from_reader(rdr: &mut io::Read) -> Result<Self, BuilderError> {
let contents = {
let mut c = Vec::new();
try!(rdr.read_to_end(&mut c));
c
};
let s = match str::from_utf8(&contents).ok() {
Some(s) => s,
_ => return Err(SyntaxError(NotUtf8, 0, 0))
};
let mut builder = Builder::new(s.chars());
builder.build()
}
/// Decodes a json value from a string
pub fn from_str(s: &str) -> Result<Self, BuilderError> {
let mut builder = Builder::new(s.chars());
builder.build()
}
/// Borrow this json object as a pretty object to generate a pretty
/// representation for it via `Display`.
pub fn pretty(&self) -> PrettyJson {
PrettyJson { inner: self }
}
/// If the Json value is an Object, returns the value associated with the provided key.
/// Otherwise, returns None.
pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
match self {
&Json::Object(ref map) => map.get(key),
_ => None
}
}
/// Attempts to get a nested Json Object for each key in `keys`.
/// If any key is found not to exist, find_path will return None.
/// Otherwise, it will return the Json value associated with the final key.
pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
let mut target = self;
for key in keys.iter() {
match target.find(*key) {
Some(t) => { target = t; },
None => return None
}
}
Some(target)
}
/// If the Json value is an Object, performs a depth-first search until
/// a value associated with the provided key is found. If no value is found
/// or the Json value is not an Object, returns None.
pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
match self {
&Json::Object(ref map) => {
match map.get(key) {
Some(json_value) => Some(json_value),
None => {
for (_, v) in map.iter() {
match v.search(key) {
x if x.is_some() => return x,
_ => ()
}
}
None
}
}
},
_ => None
}
}
/// Returns true if the Json value is an Object. Returns false otherwise.
pub fn is_object<'a>(&'a self) -> bool {
self.as_object().is_some()
}
/// If the Json value is an Object, returns a reference to the associated BTreeMap.
/// Returns None otherwise.
pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
match self {
&Json::Object(ref map) => Some(map),
_ => None
}
}
/// If the Json value is an Object, returns a mutable reference to the associated BTreeMap.
/// Returns None otherwise.
pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut Object> {
match self {
&mut Json::Object(ref mut map) => Some(map),
_ => None
}
}
/// If the Json value is an Object, returns the associated BTreeMap.
/// Returns None otherwise.
pub fn into_object(self) -> Option<Object> {
match self {
Json::Object(map) => Some(map),
_ => None
}
}
/// Returns true if the Json value is an Array. Returns false otherwise.
pub fn is_array<'a>(&'a self) -> bool {
self.as_array().is_some()
}
/// If the Json value is an Array, returns a reference to the associated vector.
/// Returns None otherwise.
pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
match self {
&Json::Array(ref array) => Some(&*array),
_ => None
}
}
/// If the Json value is an Array, returns a mutable reference to the associated vector.
/// Returns None otherwise.
pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Array> {
match self {
&mut Json::Array(ref mut list) => Some(list),
_ => None
}
}
/// If the Json value is an Array, returns the associated vector.
/// Returns None otherwise.
pub fn into_array(self) -> Option<Array> {
match self {
Json::Array(array) => Some(array),
_ => None
}
}
/// Returns true if the Json value is a String. Returns false otherwise.
pub fn is_string<'a>(&'a self) -> bool {
self.as_string().is_some()
}
/// If the Json value is a String, returns the associated str.
/// Returns None otherwise.
pub fn as_string<'a>(&'a self) -> Option<&'a str> {
match *self {
Json::String(ref s) => Some(&s),
_ => None
}
}
/// Returns true if the Json value is a Number. Returns false otherwise.
pub fn is_number(&self) -> bool {
match *self {
Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
_ => false,
}
}
/// Returns true if the Json value is a i64. Returns false otherwise.
pub fn is_i64(&self) -> bool {
match *self {
Json::I64(_) => true,
_ => false,
}
}
/// Returns true if the Json value is a u64. Returns false otherwise.
pub fn is_u64(&self) -> bool {
match *self {
Json::U64(_) => true,
_ => false,
}
}
/// Returns true if the Json value is a f64. Returns false otherwise.
pub fn is_f64(&self) -> bool {
match *self {
Json::F64(_) => true,
_ => false,
}
}
/// If the Json value is a number, return or cast it to a i64.
/// Returns None otherwise.
pub fn as_i64(&self) -> Option<i64> {
match *self {
Json::I64(n) => Some(n),
Json::U64(n) if n >= i64::MAX as u64 => None,
Json::U64(n) => Some(n as i64),
_ => None
}
}
/// If the Json value is a number, return or cast it to a u64.
/// Returns None otherwise.
pub fn as_u64(&self) -> Option<u64> {
match *self {
Json::I64(n) if n >= 0 => Some(n as u64),
Json::U64(n) => Some(n),
_ => None
}
}
/// If the Json value is a number, return or cast it to a f64.
/// Returns None otherwise.
pub fn as_f64(&self) -> Option<f64> {
match *self {
Json::I64(n) => Some(n as f64),
Json::U64(n) => Some(n as f64),
Json::F64(n) => Some(n),
_ => None
}
}
/// Returns true if the Json value is a Boolean. Returns false otherwise.
pub fn is_boolean(&self) -> bool {
self.as_boolean().is_some()
}
/// If the Json value is a Boolean, returns the associated bool.
/// Returns None otherwise.
pub fn as_boolean(&self) -> Option<bool> {
match self {
&Json::Boolean(b) => Some(b),
_ => None
}
}
/// Returns true if the Json value is a Null. Returns false otherwise.
pub fn is_null(&self) -> bool {
self.as_null().is_some()
}
/// If the Json value is a Null, returns ().
/// Returns None otherwise.
pub fn as_null(&self) -> Option<()> {
match self {
&Json::Null => Some(()),
_ => None
}
}
}
impl<'a> Index<&'a str> for Json {
type Output = Json;
fn index(&self, idx: &str) -> &Json {
self.find(idx).unwrap()
}
}
impl Index<usize> for Json {
type Output = Json;
fn index<'a>(&'a self, idx: usize) -> &'a Json {
match self {
&Json::Array(ref v) => &v[idx],
_ => panic!("can only index Json with usize if it is an array")
}
}
}
/// The output of the streaming parser.
#[derive(PartialEq, Debug)]
pub enum JsonEvent {
ObjectStart,
ObjectEnd,
ArrayStart,
ArrayEnd,
BooleanValue(bool),
I64Value(i64),
U64Value(u64),
F64Value(f64),
StringValue(string::String),
NullValue,
Error(ParserError),
}
#[derive(PartialEq, Debug)]
enum ParserState {
// Parse a value in an array, true means first element.
ParseArray(bool),
// Parse ',' or ']' after an element in an array.
ParseArrayComma,
// Parse a key:value in an object, true means first element.
ParseObject(bool),
// Parse ',' or ']' after an element in an object.
ParseObjectComma,
// Initial state.
ParseStart,
// Expecting the stream to end.
ParseBeforeFinish,
// Parsing can't continue.
ParseFinished,
}
/// A Stack represents the current position of the parser in the logical
/// structure of the JSON stream.
/// For example foo.bar[3].x
pub struct Stack {
stack: Vec<InternalStackElement>,
str_buffer: Vec<u8>,
}
/// StackElements compose a Stack.
/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
/// StackElements compositing the stack that represents foo.bar[3].x
#[derive(PartialEq, Clone, Debug)]
pub enum StackElement<'l> {
Index(u32),
Key(&'l str),
}
// Internally, Key elements are stored as indices in a buffer to avoid
// allocating a string for every member of an object.
#[derive(PartialEq, Clone, Debug)]
enum InternalStackElement {
InternalIndex(u32),
InternalKey(u16, u16), // start, size
}
impl Stack {
pub fn new() -> Stack {
Stack { stack: Vec::new(), str_buffer: Vec::new() }
}
/// Returns The number of elements in the Stack.
pub fn len(&self) -> usize { self.stack.len() }
/// Returns true if the stack is empty.
pub fn is_empty(&self) -> bool { self.stack.is_empty() }
/// Provides access to the StackElement at a given index.
/// lower indices are at the bottom of the stack while higher indices are
/// at the top.
pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
match self.stack[idx] {
InternalIndex(i) => StackElement::Index(i),
InternalKey(start, size) => {
StackElement::Key(str::from_utf8(
&self.str_buffer[start as usize .. start as usize + size as usize]).unwrap())
}
}
}
/// Compares this stack with an array of StackElements.
pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
if self.stack.len() != rhs.len() { return false; }
for i in 0..rhs.len() {
if self.get(i) != rhs[i] { return false; }
}
return true;
}
/// Returns true if the bottom-most elements of this stack are the same as
/// the ones passed as parameter.
pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
if self.stack.len() < rhs.len() { return false; }
for i in 0..rhs.len() {
if self.get(i) != rhs[i] { return false; }
}
return true;
}
/// Returns true if the top-most elements of this stack are the same as
/// the ones passed as parameter.
pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
if self.stack.len() < rhs.len() { return false; }
let offset = self.stack.len() - rhs.len();
for i in 0..rhs.len() {
if self.get(i + offset) != rhs[i] { return false; }
}
return true;
}
/// Returns the top-most element (if any).
pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
return match self.stack.last() {
None => None,
Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
Some(&InternalKey(start, size)) => {
Some(StackElement::Key(str::from_utf8(
&self.str_buffer[start as usize .. (start+size) as usize]
).unwrap()))
}
}
}
// Used by Parser to insert Key elements at the top of the stack.
fn push_key(&mut self, key: string::String) {
self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
for c in key.as_bytes().iter() {
self.str_buffer.push(*c);
}
}
// Used by Parser to insert Index elements at the top of the stack.
fn push_index(&mut self, index: u32) {
self.stack.push(InternalIndex(index));
}
// Used by Parser to remove the top-most element of the stack.
fn pop(&mut self) {
assert!(!self.is_empty());
match *self.stack.last().unwrap() {
InternalKey(_, sz) => {
let new_size = self.str_buffer.len() - sz as usize;
self.str_buffer.truncate(new_size);
}
InternalIndex(_) => {}
}
self.stack.pop();
}
// Used by Parser to test whether the top-most element is an index.
fn last_is_index(&self) -> bool {
if self.is_empty() { return false; }
return match *self.stack.last().unwrap() {
InternalIndex(_) => true,
_ => false,
}
}
// Used by Parser to increment the index of the top-most element.
fn bump_index(&mut self) {
let len = self.stack.len();
let idx = match *self.stack.last().unwrap() {
InternalIndex(i) => { i + 1 }
_ => { panic!(); }
};
self.stack[len - 1] = InternalIndex(idx);
}
}
/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
/// an iterator of char.
pub struct Parser<T> {
rdr: T,
ch: Option<char>,
line: usize,
col: usize,
// We maintain a stack representing where we are in the logical structure
// of the JSON stream.
stack: Stack,
// A state machine is kept to make it possible to interrupt and resume parsing.
state: ParserState,
}
impl<T: Iterator<Item = char>> Iterator for Parser<T> {
type Item = JsonEvent;
fn next(&mut self) -> Option<JsonEvent> {
if self.state == ParseFinished {
return None;
}
if self.state == ParseBeforeFinish {
self.parse_whitespace();
// Make sure there is no trailing characters.
if self.eof() {
self.state = ParseFinished;
return None;
} else {
return Some(self.error_event(TrailingCharacters));
}
}
return Some(self.parse());
}
}
impl<T: Iterator<Item = char>> Parser<T> {
/// Creates the JSON parser.
pub fn new(rdr: T) -> Parser<T> {
let mut p = Parser {
rdr: rdr,
ch: Some('\x00'),
line: 1,
col: 0,
stack: Stack::new(),
state: ParseStart,
};
p.bump();
return p;
}
/// Provides access to the current position in the logical structure of the
/// JSON stream.
pub fn stack<'l>(&'l self) -> &'l Stack {
return &self.stack;
}
fn eof(&self) -> bool { self.ch.is_none() }
fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
fn bump(&mut self) {
self.ch = self.rdr.next();
if self.ch_is('\n') {
self.line += 1;
self.col = 1;
} else {
self.col += 1;
}
}
fn next_char(&mut self) -> Option<char> {
self.bump();
self.ch
}
fn ch_is(&self, c: char) -> bool {
self.ch == Some(c)
}
fn error<E>(&self, reason: ErrorCode) -> Result<E, ParserError> {
Err(SyntaxError(reason, self.line, self.col))
}
fn parse_whitespace(&mut self) {
while self.ch_is(' ') ||
self.ch_is('\n') ||
self.ch_is('\t') ||
self.ch_is('\r') { self.bump(); }
}
fn parse_number(&mut self) -> JsonEvent {
let mut neg = false;
if self.ch_is('-') {
self.bump();
neg = true;
}
let res = match self.parse_u64() {
Ok(res) => res,
Err(e) => { return Error(e); }
};
if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
let mut res = res as f64;
if self.ch_is('.') {
res = match self.parse_decimal(res) {
Ok(res) => res,
Err(e) => { return Error(e); }
};
}
if self.ch_is('e') || self.ch_is('E') {
res = match self.parse_exponent(res) {
Ok(res) => res,
Err(e) => { return Error(e); }
};
}
if neg {
res *= -1.0;
}
F64Value(res)
} else {
if neg {
// Make sure we don't underflow.
if res > (i64::MAX as u64) + 1 {
Error(SyntaxError(InvalidNumber, self.line, self.col))
} else if res == 0 {
I64Value(res as i64)
} else {
I64Value((!res + 1) as i64)
}
} else {
U64Value(res)
}
}
}
fn parse_u64(&mut self) -> Result<u64, ParserError> {
let mut accum: u64 = 0;
match self.ch_or_null() {
'0' => {
self.bump();
// A leading '0' must be the only digit before the decimal point.
match self.ch_or_null() {
'0' ... '9' => return self.error(InvalidNumber),
_ => ()
}
},
'1' ... '9' => {
while !self.eof() {
match self.ch_or_null() {
c @ '0' ... '9' => {
macro_rules! try_or_invalid {
($e: expr) => {
match $e {
Some(v) => v,
None => return self.error(InvalidNumber)
}
}
}
accum = try_or_invalid!(accum.checked_mul(10));
accum = try_or_invalid!(accum.checked_add((c as u64) - ('0' as u64)));
self.bump();
}
_ => break,
}
}
}
_ => return self.error(InvalidNumber),
}
Ok(accum)
}
fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
self.bump();
// Make sure a digit follows the decimal place.
match self.ch_or_null() {
'0' ... '9' => (),
_ => return self.error(InvalidNumber)
}
let mut dec = 1.0;
let mut frac = 0.0;
while !self.eof() {
match self.ch_or_null() {
c @ '0' ... '9' => {
dec /= 10.0;
frac += (((c as isize) - ('0' as isize)) as f64) * dec;
self.bump();
}
_ => break,
}
}
res += frac;
Ok(res)
}
fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
self.bump();
let mut exp = 0;
let mut neg_exp = false;
if self.ch_is('+') {
self.bump();
} else if self.ch_is('-') {
self.bump();
neg_exp = true;
}
// Make sure a digit follows the exponent place.
match self.ch_or_null() {
'0' ... '9' => (),
_ => return self.error(InvalidNumber)
}
while !self.eof() {
match self.ch_or_null() {
c @ '0' ... '9' => {
exp *= 10;
exp += (c as usize) - ('0' as usize);
self.bump();
}
_ => break
}
}
let exp = 10_f64.powi(exp as i32);
if neg_exp {
res /= exp;
} else {
res *= exp;
}
Ok(res)
}
fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
let mut i = 0;
let mut n = 0;
while i < 4 {
self.bump();
n = match self.ch_or_null() {
c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
c @ 'a' ... 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)),
c @ 'A' ... 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)),
_ => return self.error(InvalidEscape)
};
i += 1;
}
Ok(n)
}
fn parse_str(&mut self) -> Result<string::String, ParserError> {
let mut escape = false;
let mut res = string::String::new();
loop {
self.bump();
if self.eof() {
return self.error(EOFWhileParsingString);
}
if escape {
match self.ch_or_null() {
'"' => res.push('"'),
'\\' => res.push('\\'),
'/' => res.push('/'),
'b' => res.push('\x08'),
'f' => res.push('\x0c'),
'n' => res.push('\n'),
'r' => res.push('\r'),
't' => res.push('\t'),
'u' => match try!(self.decode_hex_escape()) {
0xDC00 ... 0xDFFF => {
return self.error(LoneLeadingSurrogateInHexEscape)
}
// Non-BMP characters are encoded as a sequence of
// two hex escapes, representing UTF-16 surrogates.
n1 @ 0xD800 ... 0xDBFF => {
match (self.next_char(), self.next_char()) {
(Some('\\'), Some('u')) => (),
_ => return self.error(UnexpectedEndOfHexEscape),
}
let n2 = try!(self.decode_hex_escape());
if n2 < 0xDC00 || n2 > 0xDFFF {
return self.error(LoneLeadingSurrogateInHexEscape)
}
let c = (((n1 - 0xD800) as u32) << 10 |
(n2 - 0xDC00) as u32) + 0x1_0000;
res.push(char::from_u32(c).unwrap());
}
n => match char::from_u32(n as u32) {
Some(c) => res.push(c),
None => return self.error(InvalidUnicodeCodePoint),
},
},
_ => return self.error(InvalidEscape),
}
escape = false;
} else if self.ch_is('\\') {
escape = true;
} else {
match self.ch {
Some('"') => {
self.bump();
return Ok(res);
},
Some(c) if c <= '\u{1F}' =>
return self.error(ControlCharacterInString),
Some(c) => res.push(c),
None => unreachable!()
}
}
}
}
// Invoked at each iteration, consumes the stream until it has enough
// information to return a JsonEvent.
// Manages an internal state so that parsing can be interrupted and resumed.
// Also keeps track of the position in the logical structure of the json
// stream int the form of a stack that can be queried by the user using the
// stack() method.
fn parse(&mut self) -> JsonEvent {
loop {
// The only paths where the loop can spin a new iteration
// are in the cases ParseArrayComma and ParseObjectComma if ','
// is parsed. In these cases the state is set to (respectively)
// ParseArray(false) and ParseObject(false), which always return,
// so there is no risk of getting stuck in an infinite loop.
// All other paths return before the end of the loop's iteration.
self.parse_whitespace();
match self.state {
ParseStart => {
return self.parse_start();
}
ParseArray(first) => {
return self.parse_array(first);
}
ParseArrayComma => {
match self.parse_array_comma_or_end() {
Some(evt) => { return evt; }
None => {}
}
}
ParseObject(first) => {
return self.parse_object(first);
}
ParseObjectComma => {
self.stack.pop();
if self.ch_is(',') {
self.state = ParseObject(false);
self.bump();
} else {
return self.parse_object_end();
}
}
_ => {
return self.error_event(InvalidSyntax);
}
}
}
}
fn parse_start(&mut self) -> JsonEvent {
let val = self.parse_value();
self.state = match val {
Error(_) => ParseFinished,
ArrayStart => ParseArray(true),
ObjectStart => ParseObject(true),
_ => ParseBeforeFinish,
};
return val;
}
fn parse_array(&mut self, first: bool) -> JsonEvent {
if self.ch_is(']') {
if !first {
self.error_event(InvalidSyntax)
} else {
self.state = if self.stack.is_empty() {
ParseBeforeFinish
} else if self.stack.last_is_index() {
ParseArrayComma
} else {
ParseObjectComma
};
self.bump();
ArrayEnd
}
} else {
if first {
self.stack.push_index(0);
}
let val = self.parse_value();
self.state = match val {
Error(_) => ParseFinished,
ArrayStart => ParseArray(true),
ObjectStart => ParseObject(true),
_ => ParseArrayComma,
};
val
}
}
fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
if self.ch_is(',') {
self.stack.bump_index();
self.state = ParseArray(false);
self.bump();
None
} else if self.ch_is(']') {
self.stack.pop();
self.state = if self.stack.is_empty() {
ParseBeforeFinish
} else if self.stack.last_is_index() {
ParseArrayComma
} else {
ParseObjectComma
};
self.bump();
Some(ArrayEnd)
} else if self.eof() {
Some(self.error_event(EOFWhileParsingArray))
} else {
Some(self.error_event(InvalidSyntax))
}
}
fn parse_object(&mut self, first: bool) -> JsonEvent {
if self.ch_is('}') {
if !first {
if self.stack.is_empty() {
return self.error_event(TrailingComma);
} else {
self.stack.pop();
}
}
self.state = if self.stack.is_empty() {
ParseBeforeFinish
} else if self.stack.last_is_index() {
ParseArrayComma
} else {
ParseObjectComma
};
self.bump();
return ObjectEnd;
}
if self.eof() {
return self.error_event(EOFWhileParsingObject);
}
if !self.ch_is('"') {
return self.error_event(KeyMustBeAString);
}
let s = match self.parse_str() {
Ok(s) => s,
Err(e) => {
self.state = ParseFinished;
return Error(e);
}
};
self.parse_whitespace();
if self.eof() {
return self.error_event(EOFWhileParsingObject);
} else if self.ch_or_null() != ':' {
return self.error_event(ExpectedColon);
}
self.stack.push_key(s);
self.bump();
self.parse_whitespace();
let val = self.parse_value();
self.state = match val {
Error(_) => ParseFinished,
ArrayStart => ParseArray(true),
ObjectStart => ParseObject(true),
_ => ParseObjectComma,
};
return val;
}
fn parse_object_end(&mut self) -> JsonEvent {
if self.ch_is('}') {
self.state = if self.stack.is_empty() {
ParseBeforeFinish
} else if self.stack.last_is_index() {
ParseArrayComma
} else {
ParseObjectComma
};
self.bump();
ObjectEnd
} else if self.eof() {
self.error_event(EOFWhileParsingObject)
} else {
self.error_event(InvalidSyntax)
}
}
fn parse_value(&mut self) -> JsonEvent {
if self.eof() { return self.error_event(EOFWhileParsingValue); }
match self.ch_or_null() {
'n' => { self.parse_ident("ull", NullValue) }
't' => { self.parse_ident("rue", BooleanValue(true)) }
'f' => { self.parse_ident("alse", BooleanValue(false)) }
'0' ... '9' | '-' => self.parse_number(),
'"' => match self.parse_str() {
Ok(s) => StringValue(s),
Err(e) => Error(e),
},
'[' => {
self.bump();
ArrayStart
}
'{' => {
self.bump();
ObjectStart
}
_ => { self.error_event(InvalidSyntax) }
}
}
fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
if ident.chars().all(|c| Some(c) == self.next_char()) {
self.bump();
value
} else {
Error(SyntaxError(InvalidSyntax, self.line, self.col))
}
}
fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
self.state = ParseFinished;
Error(SyntaxError(reason, self.line, self.col))
}
}
/// A Builder consumes a json::Parser to create a generic Json structure.
pub struct Builder<T> {
parser: Parser<T>,
token: Option<JsonEvent>,
}
impl<T: Iterator<Item = char>> Builder<T> {
/// Create a JSON Builder.
pub fn new(src: T) -> Builder<T> {
Builder { parser: Parser::new(src), token: None, }
}
// Decode a Json value from a Parser.
pub fn build(&mut self) -> Result<Json, BuilderError> {
self.bump();
let result = self.build_value();
self.bump();
match self.token.take() {
None => {}
Some(Error(e)) => { return Err(e); }
_ => { return Err(SyntaxError(InvalidSyntax, self.parser.line, self.parser.col)); }
}
result
}
fn bump(&mut self) {
self.token = self.parser.next();
}
fn build_value(&mut self) -> Result<Json, BuilderError> {
return match self.token.take() {
Some(NullValue) => Ok(Json::Null),
Some(I64Value(n)) => Ok(Json::I64(n)),
Some(U64Value(n)) => Ok(Json::U64(n)),
Some(F64Value(n)) => Ok(Json::F64(n)),
Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
Some(StringValue(ref mut s)) => {
let mut temp = string::String::new();
swap(s, &mut temp);
Ok(Json::String(temp))
}
Some(Error(e)) => Err(e),
Some(ArrayStart) => self.build_array(),
Some(ObjectStart) => self.build_object(),
Some(ObjectEnd) => self.parser.error(InvalidSyntax),
Some(ArrayEnd) => self.parser.error(InvalidSyntax),
None => self.parser.error(EOFWhileParsingValue),
}
}
fn build_array(&mut self) -> Result<Json, BuilderError> {
self.bump();
let mut values = Vec::new();
loop {
if let Some(ArrayEnd) = self.token {
return Ok(Json::Array(values.into_iter().collect()));
}
match self.build_value() {
Ok(v) => values.push(v),
Err(e) => { return Err(e) }
}
self.bump();
}
}
fn build_object(&mut self) -> Result<Json, BuilderError> {
self.bump();
let mut values = BTreeMap::new();
loop {
match self.token.take() {
Some(ObjectEnd) => { return Ok(Json::Object(values)); }
Some(Error(e)) => { return Err(e); }
None => { break; }
token => { self.token = token; }
}
let key = match self.parser.stack().top() {
Some(StackElement::Key(k)) => { k.to_string() }
_ => { panic!("invalid state"); }
};
match self.build_value() {
Ok(value) => { values.insert(key, value); }
Err(e) => { return Err(e); }
}
self.bump();
}
return self.parser.error(EOFWhileParsingObject);
}
}
/// A structure to decode JSON to values in rust.
pub struct Decoder {
stack: Vec<Json>,
}
impl Decoder {
/// Creates a new decoder instance for decoding the specified JSON value.
pub fn new(json: Json) -> Decoder {
Decoder { stack: vec![json] }
}
}
impl Decoder {
fn pop(&mut self) -> DecodeResult<Json> {
match self.stack.pop() {
Some(s) => Ok(s),
None => Err(EOF),
}
}
}
macro_rules! expect {
($e:expr, Null) => ({
match try!($e) {
Json::Null => Ok(()),
other => Err(ExpectedError("Null".to_string(),
format!("{}", other)))
}
});
($e:expr, $t:ident) => ({
match try!($e) {
Json::$t(v) => Ok(v),
other => {
Err(ExpectedError(stringify!($t).to_string(),
format!("{}", other)))
}
}
})
}
macro_rules! read_primitive {
($name:ident, $ty:ident) => {
#[allow(unused_comparisons)]
fn $name(&mut self) -> DecodeResult<$ty> {
match try!(self.pop()) {
Json::I64(i) => {
let other = i as $ty;
if i == other as i64 && (other > 0) == (i > 0) {
Ok(other)
} else {
Err(ExpectedError("Number".to_string(), i.to_string()))
}
}
Json::U64(u) => {
let other = u as $ty;
if u == other as u64 && other >= 0 {
Ok(other)
} else {
Err(ExpectedError("Number".to_string(), u.to_string()))
}
}
Json::F64(f) => {
Err(ExpectedError("Integer".to_string(), f.to_string()))
}
// re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
// is going to have a string here, as per JSON spec.
Json::String(s) => match s.parse() {
Ok(f) => Ok(f),
Err(_) => Err(ExpectedError("Number".to_string(), s)),
},
value => {
Err(ExpectedError("Number".to_string(), value.to_string()))
}
}
}
}
}
impl ::Decoder for Decoder {
type Error = DecoderError;
fn read_nil(&mut self) -> DecodeResult<()> {
expect!(self.pop(), Null)
}
read_primitive! { read_usize, usize }
read_primitive! { read_u8, u8 }
read_primitive! { read_u16, u16 }
read_primitive! { read_u32, u32 }
read_primitive! { read_u64, u64 }
read_primitive! { read_isize, isize }
read_primitive! { read_i8, i8 }
read_primitive! { read_i16, i16 }
read_primitive! { read_i32, i32 }
read_primitive! { read_i64, i64 }
fn read_f32(&mut self) -> DecodeResult<f32> {
self.read_f64().map(|x| x as f32)
}
fn read_f64(&mut self) -> DecodeResult<f64> {
match try!(self.pop()) {
Json::I64(f) => Ok(f as f64),
Json::U64(f) => Ok(f as f64),
Json::F64(f) => Ok(f),
Json::String(s) => {
// re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
// is going to have a string here, as per JSON spec.
match s.parse() {
Ok(f) => Ok(f),
Err(_) => Err(ExpectedError("Number".to_string(), s)),
}
},
Json::Null => Ok(f64::NAN),
value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
}
}
fn read_bool(&mut self) -> DecodeResult<bool> {
expect!(self.pop(), Boolean)
}
fn read_char(&mut self) -> DecodeResult<char> {
let s = try!(self.read_str());
{
let mut it = s.chars();
match (it.next(), it.next()) {
// exactly one character
(Some(c), None) => return Ok(c),
_ => ()
}
}
Err(ExpectedError("single character string".to_string(), format!("{}", s)))
}
fn read_str(&mut self) -> DecodeResult<string::String> {
expect!(self.pop(), String)
}
fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_enum_variant<T, F>(&mut self, names: &[&str],
mut f: F) -> DecodeResult<T>
where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
{
let name = match try!(self.pop()) {
Json::String(s) => s,
Json::Object(mut o) => {
let n = match o.remove(&"variant".to_string()) {
Some(Json::String(s)) => s,
Some(val) => {
return Err(ExpectedError("String".to_string(), format!("{}", val)))
}
None => {
return Err(MissingFieldError("variant".to_string()))
}
};
match o.remove(&"fields".to_string()) {
Some(Json::Array(l)) => {
for field in l.into_iter().rev() {
self.stack.push(field);
}
},
Some(val) => {
return Err(ExpectedError("Array".to_string(), format!("{}", val)))
}
None => {
return Err(MissingFieldError("fields".to_string()))
}
}
n
}
json => {
return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
}
};
let idx = match names.iter().position(|n| *n == name) {
Some(idx) => idx,
None => return Err(UnknownVariantError(name))
};
f(self, idx)
}
fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
{
self.read_enum_variant(names, f)
}
fn read_enum_struct_variant_field<T, F>(&mut self,
_name: &str,
idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_enum_variant_arg(idx, f)
}
fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
let value = try!(f(self));
try!(self.pop());
Ok(value)
}
fn read_struct_field<T, F>(&mut self,
name: &str,
_idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
let mut obj = try!(expect!(self.pop(), Object));
let value = match obj.remove(&name.to_string()) {
None => {
// Add a Null and try to parse it as an Option<_>
// to get None as a default value.
self.stack.push(Json::Null);
match f(self) {
Ok(x) => x,
Err(_) => return Err(MissingFieldError(name.to_string())),
}
},
Some(json) => {
self.stack.push(json);
try!(f(self))
}
};
self.stack.push(Json::Object(obj));
Ok(value)
}
fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_seq(move |d, len| {
if len == tuple_len {
f(d)
} else {
Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
}
})
}
fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_seq_elt(idx, f)
}
fn read_tuple_struct<T, F>(&mut self,
_name: &str,
len: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_tuple(len, f)
}
fn read_tuple_struct_arg<T, F>(&mut self,
idx: usize,
f: F)
-> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
self.read_tuple_arg(idx, f)
}
fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
{
match try!(self.pop()) {
Json::Null => f(self, false),
value => { self.stack.push(value); f(self, true) }
}
}
fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
{
let array = try!(expect!(self.pop(), Array));
let len = array.len();
for v in array.into_iter().rev() {
self.stack.push(v);
}
f(self, len)
}
fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
{
let obj = try!(expect!(self.pop(), Object));
let len = obj.len();
for (key, value) in obj.into_iter() {
self.stack.push(value);
self.stack.push(Json::String(key));
}
f(self, len)
}
fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
F: FnOnce(&mut Decoder) -> DecodeResult<T>,
{
f(self)
}
fn error(&mut self, err: &str) -> DecoderError {
ApplicationError(err.to_string())
}
}
/// A trait for converting values to JSON
pub trait ToJson {
/// Converts the value of `self` to an instance of JSON
fn to_json(&self) -> Json;
}
macro_rules! to_json_impl_i64 {
($($t:ty), +) => (
$(impl ToJson for $t {
fn to_json(&self) -> Json { Json::I64(*self as i64) }
})+
)
}
to_json_impl_i64! { isize, i8, i16, i32, i64 }
macro_rules! to_json_impl_u64 {
($($t:ty), +) => (
$(impl ToJson for $t {
fn to_json(&self) -> Json { Json::U64(*self as u64) }
})+
)
}
to_json_impl_u64! { usize, u8, u16, u32, u64 }
impl ToJson for Json {
fn to_json(&self) -> Json { self.clone() }
}
impl ToJson for f32 {
fn to_json(&self) -> Json { (*self as f64).to_json() }
}
impl ToJson for f64 {
fn to_json(&self) -> Json {
use std::num::FpCategory::{Nan, Infinite};
match self.classify() {
Nan | Infinite => Json::Null,
_ => Json::F64(*self)
}
}
}
impl ToJson for () {
fn to_json(&self) -> Json { Json::Null }
}
impl ToJson for bool {
fn to_json(&self) -> Json { Json::Boolean(*self) }
}
impl ToJson for str {
fn to_json(&self) -> Json { Json::String(self.to_string()) }
}
impl ToJson for string::String {
fn to_json(&self) -> Json { Json::String((*self).clone()) }
}
macro_rules! tuple_impl {
// use variables to indicate the arity of the tuple
($($tyvar:ident),* ) => {
// the trailing commas are for the 1 tuple
impl<
$( $tyvar : ToJson ),*
> ToJson for ( $( $tyvar ),* , ) {
#[inline]
#[allow(non_snake_case)]
fn to_json(&self) -> Json {
match *self {
($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
}
}
}
}
}
tuple_impl!{A}
tuple_impl!{A, B}
tuple_impl!{A, B, C}
tuple_impl!{A, B, C, D}
tuple_impl!{A, B, C, D, E}
tuple_impl!{A, B, C, D, E, F}
tuple_impl!{A, B, C, D, E, F, G}
tuple_impl!{A, B, C, D, E, F, G, H}
tuple_impl!{A, B, C, D, E, F, G, H, I}
tuple_impl!{A, B, C, D, E, F, G, H, I, J}
tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
impl<A: ToJson> ToJson for [A] {
fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
}
impl<A: ToJson> ToJson for Vec<A> {
fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
}
impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
fn to_json(&self) -> Json {
let mut d = BTreeMap::new();
for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Json::Object(d)
}
}
impl<A: ToJson> ToJson for HashMap<string::String, A> {
fn to_json(&self) -> Json {
let mut d = BTreeMap::new();
for (key, value) in self.iter() {
d.insert((*key).clone(), value.to_json());
}
Json::Object(d)
}
}
impl<A:ToJson> ToJson for Option<A> {
fn to_json(&self) -> Json {
match *self {
None => Json::Null,
Some(ref value) => value.to_json()
}
}
}
struct FormatShim<'a, 'b: 'a> {
inner: &'a mut fmt::Formatter<'b>,
}
impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
fn write_str(&mut self, s: &str) -> fmt::Result {
match self.inner.write_str(s) {
Ok(_) => Ok(()),
Err(_) => Err(fmt::Error)
}
}
}
impl fmt::Display for Json {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new(&mut shim);
match self.encode(&mut encoder) {
Ok(_) => Ok(()),
Err(_) => Err(fmt::Error)
}
}
}
impl<'a> fmt::Display for PrettyJson<'a> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new_pretty(&mut shim);
match self.inner.encode(&mut encoder) {
Ok(_) => Ok(()),
Err(_) => Err(fmt::Error)
}
}
}
impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new(&mut shim);
match self.inner.encode(&mut encoder) {
Ok(_) => Ok(()),
Err(_) => Err(fmt::Error)
}
}
}
impl<'a, T> AsPrettyJson<'a, T> {
/// Set the indentation level for the emitted JSON
pub fn indent(mut self, indent: u32) -> AsPrettyJson<'a, T> {
self.indent = Some(indent);
self
}
}
impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
/// Encodes a json value into a string
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut shim = FormatShim { inner: f };
let mut encoder = Encoder::new_pretty(&mut shim);
if let Some(n) = self.indent {
// unwrap cannot panic for pretty encoders
let _ = encoder.set_indent(n);
}
match self.inner.encode(&mut encoder) {
Ok(_) => Ok(()),
Err(_) => Err(fmt::Error)
}
}
}
impl FromStr for Json {
type Err = ParserError;
fn from_str(s: &str) -> Result<Json, ParserError> {
Json::from_str(s)
}
}
#[cfg(test)]
mod tests {
use self::Animal::*;
use {Encodable, Decodable};
use super::Json::*;
use super::ErrorCode::*;
use super::ParserError::*;
use super::DecoderError::*;
use super::JsonEvent::*;
use super::StackElement::*;
use super::{Json, DecodeResult, DecoderError, JsonEvent, Parser,
StackElement, Stack, Decoder, Encoder, EncoderError};
use std::{i64, u64, f32, f64};
use std::collections::BTreeMap;
use std::string;
#[derive(RustcDecodable, Eq, PartialEq, Debug)]
struct OptionData {
opt: Option<usize>,
}
#[test]
fn test_decode_option_none() {
let s ="{}";
let obj: OptionData = super::decode(s).unwrap();
assert_eq!(obj, OptionData { opt: None });
}
#[test]
fn test_decode_option_some() {
let s = "{ \"opt\": 10 }";
let obj: OptionData = super::decode(s).unwrap();
assert_eq!(obj, OptionData { opt: Some(10) });
}
#[test]
fn test_decode_option_malformed() {
check_err::<OptionData>("{ \"opt\": [] }",
ExpectedError("Number".to_string(), "[]".to_string()));
check_err::<OptionData>("{ \"opt\": false }",
ExpectedError("Number".to_string(), "false".to_string()));
}
#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
enum Animal {
Dog,
Frog(string::String, isize)
}
#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
struct Inner {
a: (),
b: usize,
c: Vec<string::String>,
}
#[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
struct Outer {
inner: Vec<Inner>,
}
fn mk_object(items: &[(string::String, Json)]) -> Json {
let mut d = BTreeMap::new();
for item in items.iter() {
match *item {
(ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
}
};
Object(d)
}
#[test]
fn test_from_str_trait() {
let s = "null";
assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
}
#[test]
fn test_write_null() {
assert_eq!(Null.to_string(), "null");
assert_eq!(Null.pretty().to_string(), "null");
}
#[test]
fn test_write_i64() {
assert_eq!(U64(0).to_string(), "0");
assert_eq!(U64(0).pretty().to_string(), "0");
assert_eq!(U64(1234).to_string(), "1234");
assert_eq!(U64(1234).pretty().to_string(), "1234");
assert_eq!(I64(-5678).to_string(), "-5678");
assert_eq!(I64(-5678).pretty().to_string(), "-5678");
assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
}
#[test]
fn test_write_f64() {
assert_eq!(F64(3.0).to_string(), "3.0");
assert_eq!(F64(3.0).pretty().to_string(), "3.0");
assert_eq!(F64(3.1).to_string(), "3.1");
assert_eq!(F64(3.1).pretty().to_string(), "3.1");
assert_eq!(F64(-1.5).to_string(), "-1.5");
assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
assert_eq!(F64(0.5).to_string(), "0.5");
assert_eq!(F64(0.5).pretty().to_string(), "0.5");
assert_eq!(F64(f64::NAN).to_string(), "null");
assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
assert_eq!(F64(f64::INFINITY).to_string(), "null");
assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
}
#[test]
fn test_write_str() {
assert_eq!(String("".to_string()).to_string(), "\"\"");
assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
}
#[test]
fn test_write_bool() {
assert_eq!(Boolean(true).to_string(), "true");
assert_eq!(Boolean(true).pretty().to_string(), "true");
assert_eq!(Boolean(false).to_string(), "false");
assert_eq!(Boolean(false).pretty().to_string(), "false");
}
#[test]
fn test_write_array() {
assert_eq!(Array(vec![]).to_string(), "[]");
assert_eq!(Array(vec![]).pretty().to_string(), "[]");
assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
assert_eq!(
Array(vec![Boolean(true)]).pretty().to_string(),
"\
[\n \
true\n\
]"
);
let long_test_array = Array(vec![
Boolean(false),
Null,
Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
assert_eq!(long_test_array.to_string(),
"[false,null,[\"foo\\nbar\",3.5]]");
assert_eq!(
long_test_array.pretty().to_string(),
"\
[\n \
false,\n \
null,\n \
[\n \
\"foo\\nbar\",\n \
3.5\n \
]\n\
]"
);
}
#[test]
fn test_write_object() {
assert_eq!(mk_object(&[]).to_string(), "{}");
assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
assert_eq!(
mk_object(&[
("a".to_string(), Boolean(true))
]).to_string(),
"{\"a\":true}"
);
assert_eq!(
mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
"\
{\n \
\"a\": true\n\
}"
);
let complex_obj = mk_object(&[
("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))])
]))
]);
assert_eq!(
complex_obj.to_string(),
"{\
\"b\":[\
{\"c\":\"\\f\\r\"},\
{\"d\":\"\"}\
]\
}"
);
assert_eq!(
complex_obj.pretty().to_string(),
"\
{\n \
\"b\": [\n \
{\n \
\"c\": \"\\f\\r\"\n \
},\n \
{\n \
\"d\": \"\"\n \
}\n \
]\n\
}"
);
let a = mk_object(&[
("a".to_string(), Boolean(true)),
("b".to_string(), Array(vec![
mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
mk_object(&[("d".to_string(), String("".to_string()))])
]))
]);
// We can't compare the strings directly because the object fields be
// printed in a different order.
assert_eq!(a.clone(), a.to_string().parse().unwrap());
assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
}
#[test]
fn test_write_enum() {
let animal = Dog;
assert_eq!(
format!("{}", super::as_json(&animal)),
"\"Dog\""
);
assert_eq!(
format!("{}", super::as_pretty_json(&animal)),
"\"Dog\""
);
let animal = Frog("Henry".to_string(), 349);
assert_eq!(
format!("{}", super::as_json(&animal)),
"{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
);
assert_eq!(
format!("{}", super::as_pretty_json(&animal)),
"{\n \
\"variant\": \"Frog\",\n \
\"fields\": [\n \
\"Henry\",\n \
349\n \
]\n\
}"
);
}
macro_rules! check_encoder_for_simple {
($value:expr, $expected:expr) => ({
let s = format!("{}", super::as_json(&$value));
assert_eq!(s, $expected);
let s = format!("{}", super::as_pretty_json(&$value));
assert_eq!(s, $expected);
})
}
#[test]
fn test_write_some() {
check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
}
#[test]
fn test_write_none() {
check_encoder_for_simple!(None::<string::String>, "null");
}
#[test]
fn test_write_char() {
check_encoder_for_simple!('a', "\"a\"");
check_encoder_for_simple!('\t', "\"\\t\"");
check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
}
#[test]
fn test_trailing_characters() {
assert_eq!(Json::from_str("nulla"), Err(SyntaxError(TrailingCharacters, 1, 5)));
assert_eq!(Json::from_str("truea"), Err(SyntaxError(TrailingCharacters, 1, 5)));
assert_eq!(Json::from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
assert_eq!(Json::from_str("1a"), Err(SyntaxError(TrailingCharacters, 1, 2)));
assert_eq!(Json::from_str("[]a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
assert_eq!(Json::from_str("{}a"), Err(SyntaxError(TrailingCharacters, 1, 3)));
}
#[test]
fn test_read_identifiers() {
assert_eq!(Json::from_str("n"), Err(SyntaxError(InvalidSyntax, 1, 2)));
assert_eq!(Json::from_str("nul"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(Json::from_str("t"), Err(SyntaxError(InvalidSyntax, 1, 2)));
assert_eq!(Json::from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(Json::from_str("f"), Err(SyntaxError(InvalidSyntax, 1, 2)));
assert_eq!(Json::from_str("faz"), Err(SyntaxError(InvalidSyntax, 1, 3)));
assert_eq!(Json::from_str("null"), Ok(Null));
assert_eq!(Json::from_str("true"), Ok(Boolean(true)));
assert_eq!(Json::from_str("false"), Ok(Boolean(false)));
assert_eq!(Json::from_str(" null "), Ok(Null));
assert_eq!(Json::from_str(" true "), Ok(Boolean(true)));
assert_eq!(Json::from_str(" false "), Ok(Boolean(false)));
}
#[test]
fn test_decode_identifiers() {
let v: () = super::decode("null").unwrap();
assert_eq!(v, ());
let v: bool = super::decode("true").unwrap();
assert_eq!(v, true);
let v: bool = super::decode("false").unwrap();
assert_eq!(v, false);
}
#[test]
fn test_read_number() {
assert_eq!(Json::from_str("+"), Err(SyntaxError(InvalidSyntax, 1, 1)));
assert_eq!(Json::from_str("."), Err(SyntaxError(InvalidSyntax, 1, 1)));
assert_eq!(Json::from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
assert_eq!(Json::from_str("-"), Err(SyntaxError(InvalidNumber, 1, 2)));
assert_eq!(Json::from_str("00"), Err(SyntaxError(InvalidNumber, 1, 2)));
assert_eq!(Json::from_str("1."), Err(SyntaxError(InvalidNumber, 1, 3)));
assert_eq!(Json::from_str("1e"), Err(SyntaxError(InvalidNumber, 1, 3)));
assert_eq!(Json::from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
assert_eq!(Json::from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
assert_eq!(Json::from_str("18446744073709551617"), Err(SyntaxError(InvalidNumber, 1, 20)));
assert_eq!(Json::from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
assert_eq!(Json::from_str("3"), Ok(U64(3)));
assert_eq!(Json::from_str("3.1"), Ok(F64(3.1)));
assert_eq!(Json::from_str("-1.2"), Ok(F64(-1.2)));
assert_eq!(Json::from_str("0.4"), Ok(F64(0.4)));
assert_eq!(Json::from_str("0.4e5"), Ok(F64(0.4e5)));
assert_eq!(Json::from_str("0.4e+15"), Ok(F64(0.4e15)));
assert_eq!(Json::from_str("0.4e-01"), Ok(F64(0.4e-01)));
assert_eq!(Json::from_str("123456789.5024"), Ok(F64(123456789.5024)));
assert_eq!(Json::from_str(" 3 "), Ok(U64(3)));
assert_eq!(Json::from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
assert_eq!(Json::from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
assert_eq!(Json::from_str("18446744073709551615"), Ok(U64(u64::MAX)));
}
#[test]
fn test_decode_numbers() {
let v: f64 = super::decode("3").unwrap();
assert_eq!(v, 3.0);
let v: f64 = super::decode("3.1").unwrap();
assert_eq!(v, 3.1);
let v: f64 = super::decode("-1.2").unwrap();
assert_eq!(v, -1.2);
let v: f64 = super::decode("0.4").unwrap();
assert_eq!(v, 0.4);
let v: f64 = super::decode("0.4e5").unwrap();
assert_eq!(v, 0.4e5);
let v: f64 = super::decode("0.4e15").unwrap();
assert_eq!(v, 0.4e15);
let v: f64 = super::decode("0.4e-01").unwrap();
assert_eq!(v, 0.4e-01);
let v: f64 = super::decode("123456789.5024").unwrap();
assert_eq!(v, 123456789.5024);
let v: u64 = super::decode("0").unwrap();
assert_eq!(v, 0);
let v: u64 = super::decode("18446744073709551615").unwrap();
assert_eq!(v, u64::MAX);
let v: i64 = super::decode("-9223372036854775808").unwrap();
assert_eq!(v, i64::MIN);
let v: i64 = super::decode("9223372036854775807").unwrap();
assert_eq!(v, i64::MAX);
let res: DecodeResult<i64> = super::decode("765.25252");
match res {
Ok(..) => panic!("expected an error"),
Err(ExpectedError(ref s, _)) => assert_eq!(s, "Integer"),
Err(..) => panic!("expected an 'expected integer' error"),
}
}
#[test]
fn test_read_str() {
assert_eq!(Json::from_str("\""), Err(SyntaxError(EOFWhileParsingString, 1, 2)));
assert_eq!(Json::from_str("\"lol"), Err(SyntaxError(EOFWhileParsingString, 1, 5)));
assert_eq!(Json::from_str("\"\n\""), Err(SyntaxError(ControlCharacterInString, 2, 1)));
assert_eq!(Json::from_str("\"\0\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
assert_eq!(Json::from_str("\"\u{1}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
assert_eq!(Json::from_str("\"\u{1F}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
// Only C0 control characters are excluded.
assert!('\u{7F}'.is_control());
assert!('\u{80}'.is_control());
assert!('\u{9F}'.is_control());
let c1_controls = "\u{7F}\u{80}\u{9F}".to_string();
assert_eq!(Json::from_str(&format!("\"{}\"", c1_controls)), Ok(String(c1_controls)));
assert_eq!(Json::from_str("\"\""), Ok(String("".to_string())));
assert_eq!(Json::from_str("\"foo\""), Ok(String("foo".to_string())));
assert_eq!(Json::from_str("\"\\\"\""), Ok(String("\"".to_string())));
assert_eq!(Json::from_str("\"\\b\""), Ok(String("\x08".to_string())));
assert_eq!(Json::from_str("\"\\n\""), Ok(String("\n".to_string())));
assert_eq!(Json::from_str("\"\\r\""), Ok(String("\r".to_string())));
assert_eq!(Json::from_str("\"\\t\""), Ok(String("\t".to_string())));
assert_eq!(Json::from_str(" \"foo\" "), Ok(String("foo".to_string())));
assert_eq!(Json::from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
assert_eq!(Json::from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
}
#[test]
fn test_decode_str() {
let s = [("\"\"", ""),
("\"foo\"", "foo"),
("\"\\\"\"", "\""),
("\"\\b\"", "\x08"),
("\"\\n\"", "\n"),
("\"\\r\"", "\r"),
("\"\\t\"", "\t"),
("\"\\u12ab\"", "\u{12ab}"),
("\"\\uAB12\"", "\u{AB12}")];
for &(i, o) in s.iter() {
let v: string::String = super::decode(i).unwrap();
assert_eq!(v, o);
}
}
#[test]
fn test_read_array() {
assert_eq!(Json::from_str("["), Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
assert_eq!(Json::from_str("[1"), Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
assert_eq!(Json::from_str("[1,"), Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
assert_eq!(Json::from_str("[1,]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax, 1, 4)));
assert_eq!(Json::from_str("[]"), Ok(Array(vec![])));
assert_eq!(Json::from_str("[ ]"), Ok(Array(vec![])));
assert_eq!(Json::from_str("[true]"), Ok(Array(vec![Boolean(true)])));
assert_eq!(Json::from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
assert_eq!(Json::from_str("[null]"), Ok(Array(vec![Null])));
assert_eq!(Json::from_str("[3, 1]"),
Ok(Array(vec![U64(3), U64(1)])));
assert_eq!(Json::from_str("\n[3, 2]\n"),
Ok(Array(vec![U64(3), U64(2)])));
assert_eq!(Json::from_str("[2, [4, 1]]"),
Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
}
#[test]
fn test_decode_array() {
let v: Vec<()> = super::decode("[]").unwrap();
assert_eq!(v, vec![]);
let v: Vec<()> = super::decode("[null]").unwrap();
assert_eq!(v, vec![()]);
let v: Vec<bool> = super::decode("[true]").unwrap();
assert_eq!(v, vec![true]);
let v: Vec<isize> = super::decode("[3, 1]").unwrap();
assert_eq!(v, vec![3, 1]);
let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
assert_eq!(v, vec![vec![3], vec![1, 2]]);
}
#[test]
fn test_decode_tuple() {
let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
assert_eq!(t, (1, 2, 3));
let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
assert_eq!(t, (1, "two".to_string()));
}
#[test]
fn test_decode_tuple_malformed_types() {
assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
}
#[test]
fn test_decode_tuple_malformed_length() {
assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
}
#[test]
fn test_read_object() {
assert_eq!(Json::from_str("{"), Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
assert_eq!(Json::from_str("{ "), Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
assert_eq!(Json::from_str("{1"), Err(SyntaxError(KeyMustBeAString, 1, 2)));
assert_eq!(Json::from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
assert_eq!(Json::from_str("{\"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
assert_eq!(Json::from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
assert_eq!(Json::from_str("{\"a\" 1"), Err(SyntaxError(ExpectedColon, 1, 6)));
assert_eq!(Json::from_str("{\"a\":"), Err(SyntaxError(EOFWhileParsingValue, 1, 6)));
assert_eq!(Json::from_str("{\"a\":1"), Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
assert_eq!(Json::from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax, 1, 8)));
assert_eq!(Json::from_str("{\"a\":1,"), Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
assert_eq!(Json::from_str("{}").unwrap(), mk_object(&[]));
assert_eq!(Json::from_str("{\"a\": 3}").unwrap(),
mk_object(&[("a".to_string(), U64(3))]));
assert_eq!(Json::from_str(
"{ \"a\": null, \"b\" : true }").unwrap(),
mk_object(&[
("a".to_string(), Null),
("b".to_string(), Boolean(true))]));
assert_eq!(Json::from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
mk_object(&[
("a".to_string(), Null),
("b".to_string(), Boolean(true))]));
assert_eq!(Json::from_str(
"{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
mk_object(&[
("a".to_string(), F64(1.0)),
("b".to_string(), Array(vec![Boolean(true)]))
]));
assert_eq!(Json::from_str(
"{\
\"a\": 1.0, \
\"b\": [\
true,\
\"foo\\nbar\", \
{ \"c\": {\"d\": null} } \
]\
}").unwrap(),
mk_object(&[
("a".to_string(), F64(1.0)),
("b".to_string(), Array(vec![
Boolean(true),
String("foo\nbar".to_string()),
mk_object(&[
("c".to_string(), mk_object(&[("d".to_string(), Null)]))
])
]))
]));
}
#[test]
fn test_decode_struct() {
let s = "{
\"inner\": [
{ \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
]
}";
let v: Outer = super::decode(s).unwrap();
assert_eq!(
v,
Outer {
inner: vec![
Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
]
}
);
}
#[derive(RustcDecodable)]
struct FloatStruct {
f: f64,
a: Vec<f64>
}
#[test]
fn test_decode_struct_with_nan() {
let s = "{\"f\":null,\"a\":[null,123]}";
let obj: FloatStruct = super::decode(s).unwrap();
assert!(obj.f.is_nan());
assert!(obj.a[0].is_nan());
assert_eq!(obj.a[1], 123f64);
}
#[test]
fn test_decode_option() {
let value: Option<string::String> = super::decode("null").unwrap();
assert_eq!(value, None);
let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
assert_eq!(value, Some("jodhpurs".to_string()));
}
#[test]
fn test_decode_enum() {
let value: Animal = super::decode("\"Dog\"").unwrap();
assert_eq!(value, Dog);
let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
let value: Animal = super::decode(s).unwrap();
assert_eq!(value, Frog("Henry".to_string(), 349));
}
#[test]
fn test_decode_result() {
let value: Result<i32, i8> = Ok(4);
let json_value = super::encode(&value).unwrap();
assert_eq!(json_value, "{\"variant\":\"Ok\",\"fields\":[4]}");
let decoded_value: Result<i32, i8> = super::decode(&json_value).unwrap();
assert_eq!(decoded_value, Ok(4));
}
#[test]
fn test_decode_map() {
let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
\"fields\":[\"Henry\", 349]}}";
let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
assert_eq!(map.remove(&"a".to_string()), Some(Dog));
assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
}
#[test]
fn test_multiline_errors() {
assert_eq!(Json::from_str("{\n \"foo\":\n \"bar\""),
Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
}
#[derive(RustcDecodable)]
#[allow(dead_code)]
struct DecodeStruct {
x: f64,
y: bool,
z: string::String,
w: Vec<DecodeStruct>
}
#[derive(RustcDecodable)]
enum DecodeEnum {
A(f64),
B(string::String)
}
fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
let res: DecodeResult<T> = match Json::from_str(to_parse) {
Err(e) => Err(ParseError(e)),
Ok(json) => Decodable::decode(&mut Decoder::new(json))
};
match res {
Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
to_parse, expected),
Err(ParseError(e)) => panic!("`{}` is not valid json: {:?}",
to_parse, e),
Err(e) => {
assert_eq!(e, expected);
}
}
}
#[test]
fn test_decode_errors_struct() {
check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
ExpectedError("Number".to_string(), "true".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
ExpectedError("Boolean".to_string(), "[]".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
ExpectedError("String".to_string(), "{}".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
MissingFieldError("w".to_string()));
}
#[test]
fn test_decode_errors_enum() {
check_err::<DecodeEnum>("{}",
MissingFieldError("variant".to_string()));
check_err::<DecodeEnum>("{\"variant\": 1}",
ExpectedError("String".to_string(), "1".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\"}",
MissingFieldError("fields".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
ExpectedError("Array".to_string(), "null".to_string()));
check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
UnknownVariantError("C".to_string()));
}
#[test]
fn test_find(){
let json_value = Json::from_str("{\"dog\" : \"cat\"}").unwrap();
let found_str = json_value.find("dog");
assert!(found_str.unwrap().as_string().unwrap() == "cat");
}
#[test]
fn test_find_path(){
let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
assert!(found_str.unwrap().as_string().unwrap() == "cheese");
}
#[test]
fn test_search(){
let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
let found_str = json_value.search("mouse").and_then(|j| j.as_string());
assert!(found_str.unwrap() == "cheese");
}
#[test]
fn test_index(){
let json_value = Json::from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
let ref array = json_value["animals"];
assert_eq!(array[0].as_string().unwrap(), "dog");
assert_eq!(array[1].as_string().unwrap(), "cat");
assert_eq!(array[2].as_string().unwrap(), "mouse");
}
#[test]
fn test_is_object(){
let json_value = Json::from_str("{}").unwrap();
assert!(json_value.is_object());
}
#[test]
fn test_as_object(){
let json_value = Json::from_str("{}").unwrap();
let json_object = json_value.as_object();
assert!(json_object.is_some());
}
#[test]
fn test_is_array(){
let json_value = Json::from_str("[1, 2, 3]").unwrap();
assert!(json_value.is_array());
}
#[test]
fn test_as_array(){
let json_value = Json::from_str("[1, 2, 3]").unwrap();
let json_array = json_value.as_array();
let expected_length = 3;
assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
}
#[test]
fn test_is_string(){
let json_value = Json::from_str("\"dog\"").unwrap();
assert!(json_value.is_string());
}
#[test]
fn test_as_string(){
let json_value = Json::from_str("\"dog\"").unwrap();
let json_str = json_value.as_string();
let expected_str = "dog";
assert_eq!(json_str, Some(expected_str));
}
#[test]
fn test_is_number(){
let json_value = Json::from_str("12").unwrap();
assert!(json_value.is_number());
}
#[test]
fn test_is_i64(){
let json_value = Json::from_str("-12").unwrap();
assert!(json_value.is_i64());
let json_value = Json::from_str("12").unwrap();
assert!(!json_value.is_i64());
let json_value = Json::from_str("12.0").unwrap();
assert!(!json_value.is_i64());
}
#[test]
fn test_is_u64(){
let json_value = Json::from_str("12").unwrap();
assert!(json_value.is_u64());
let json_value = Json::from_str("-12").unwrap();
assert!(!json_value.is_u64());
let json_value = Json::from_str("12.0").unwrap();
assert!(!json_value.is_u64());
}
#[test]
fn test_is_f64(){
let json_value = Json::from_str("12").unwrap();
assert!(!json_value.is_f64());
let json_value = Json::from_str("-12").unwrap();
assert!(!json_value.is_f64());
let json_value = Json::from_str("12.0").unwrap();
assert!(json_value.is_f64());
let json_value = Json::from_str("-12.0").unwrap();
assert!(json_value.is_f64());
}
#[test]
fn test_as_i64(){
let json_value = Json::from_str("-12").unwrap();
let json_num = json_value.as_i64();
assert_eq!(json_num, Some(-12));
}
#[test]
fn test_as_u64(){
let json_value = Json::from_str("12").unwrap();
let json_num = json_value.as_u64();
assert_eq!(json_num, Some(12));
}
#[test]
fn test_as_f64(){
let json_value = Json::from_str("12.0").unwrap();
let json_num = json_value.as_f64();
assert_eq!(json_num, Some(12f64));
}
#[test]
fn test_is_boolean(){
let json_value = Json::from_str("false").unwrap();
assert!(json_value.is_boolean());
}
#[test]
fn test_as_boolean(){
let json_value = Json::from_str("false").unwrap();
let json_bool = json_value.as_boolean();
let expected_bool = false;
assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
}
#[test]
fn test_is_null(){
let json_value = Json::from_str("null").unwrap();
assert!(json_value.is_null());
}
#[test]
fn test_as_null(){
let json_value = Json::from_str("null").unwrap();
let json_null = json_value.as_null();
let expected_null = ();
assert!(json_null.is_some() && json_null.unwrap() == expected_null);
}
#[test]
fn test_encode_hashmap_with_numeric_key() {
use std::collections::HashMap;
let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let json_str = super::as_pretty_json(&hm).to_string();
match Json::from_str(&json_str) {
Err(_) => panic!("Unable to parse json_str: {}", json_str),
_ => {} // it parsed and we are good to go
}
}
#[test]
fn test_negative_zero() {
Json::from_str("{\"test\":-0}").unwrap();
}
#[test]
fn test_prettyencode_hashmap_with_numeric_key() {
use std::collections::HashMap;
let mut hm: HashMap<usize, bool> = HashMap::new();
hm.insert(1, true);
let json_str = super::as_pretty_json(&hm).to_string();
match Json::from_str(&json_str) {
Err(_) => panic!("Unable to parse json_str: {}", json_str),
_ => {} // it parsed and we are good to go
}
}
#[test]
fn test_prettyencoder_indent_level_param() {
use std::collections::BTreeMap;
let mut tree = BTreeMap::new();
tree.insert("hello".to_string(), String("guten tag".to_string()));
tree.insert("goodbye".to_string(), String("sayonara".to_string()));
let json = Array(
// The following layout below should look a lot like
// the pretty-printed JSON (indent * x)
vec!
( // 0x
String("greetings".to_string()), // 1x
Object(tree), // 1x + 2x + 2x + 1x
) // 0x
// End JSON array (7 lines)
);
// Helper function for counting indents
fn indents(source: &str) -> usize {
let trimmed = source.trim_left_matches(' ');
source.len() - trimmed.len()
}
// Test up to 4 spaces of indents (more?)
for i in 0..4 {
let printed = super::as_pretty_json(&json).indent(i as u32)
.to_string();
// Check for indents at each line
let lines: Vec<&str> = printed.lines().collect();
assert_eq!(lines.len(), 7); // JSON should be 7 lines
assert_eq!(indents(lines[0]), 0 * i); // [
assert_eq!(indents(lines[1]), 1 * i); // "greetings",
assert_eq!(indents(lines[2]), 1 * i); // {
assert_eq!(indents(lines[3]), 2 * i); // "hello": "guten tag",
assert_eq!(indents(lines[4]), 2 * i); // "goodbye": "sayonara"
assert_eq!(indents(lines[5]), 1 * i); // },
assert_eq!(indents(lines[6]), 0 * i); // ]
// Finally, test that the pretty-printed JSON is valid
Json::from_str(&printed).ok()
.expect("Pretty-printed JSON is invalid!");
}
}
#[test]
fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
use std::collections::HashMap;
use Decodable;
let json_str = "{\"1\":true}";
let json_obj = match Json::from_str(json_str) {
Err(_) => panic!("Unable to parse json_str: {}", json_str),