Graydon Hoare | 00c856c | 2012-12-04 00:48:01 | [diff] [blame] | 1 | // Copyright 2012 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 | |
Elly Jones | 656a2af | 2011-11-07 23:24:44 | [diff] [blame] | 11 | // Rust JSON serialization library |
| 12 | // Copyright (c) 2011 Google Inc. |
Kevin Cantu | c43426e | 2012-09-13 05:09:55 | [diff] [blame] | 13 | #[forbid(non_camel_case_types)]; |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 14 | |
Gareth Daniel Smith | be01416 | 2012-07-04 21:53:12 | [diff] [blame] | 15 | //! json serialization |
Brian Anderson | 95521c4 | 2012-03-08 02:17:30 | [diff] [blame] | 16 | |
Patrick Walton | eb4d39e | 2013-01-26 00:57:39 | [diff] [blame] | 17 | use serialize::Encodable; |
Patrick Walton | 57c5999 | 2012-12-23 22:41:37 | [diff] [blame] | 18 | use serialize; |
Patrick Walton | 22b8757 | 2012-09-08 01:53:14 | [diff] [blame] | 19 | use sort::Sort; |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 20 | |
Patrick Walton | 57c5999 | 2012-12-23 22:41:37 | [diff] [blame] | 21 | use core::char; |
| 22 | use core::cmp::{Eq, Ord}; |
| 23 | use core::float; |
| 24 | use core::io::{WriterUtil, ReaderUtil}; |
| 25 | use core::io; |
Patrick Walton | 2db3abd | 2013-01-09 03:37:25 | [diff] [blame] | 26 | use core::prelude::*; |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 27 | use core::hashmap::linear::LinearMap; |
Patrick Walton | 57c5999 | 2012-12-23 22:41:37 | [diff] [blame] | 28 | use core::str; |
| 29 | use core::to_str; |
| 30 | use core::vec; |
| 31 | |
Gareth Daniel Smith | be01416 | 2012-07-04 21:53:12 | [diff] [blame] | 32 | /// Represents a json value |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 33 | pub enum Json { |
| 34 | Number(float), |
| 35 | String(~str), |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 36 | Boolean(bool), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 37 | List(List), |
| 38 | Object(~Object), |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 39 | Null, |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 40 | } |
| 41 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 42 | pub type List = ~[Json]; |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 43 | pub type Object = LinearMap<~str, Json>; |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 44 | |
| 45 | pub struct Error { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 46 | line: uint, |
| 47 | col: uint, |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 48 | msg: @~str, |
Kevin Cantu | d47cb10 | 2012-08-30 23:39:56 | [diff] [blame] | 49 | } |
| 50 | |
Kevin Cantu | c43426e | 2012-09-13 05:09:55 | [diff] [blame] | 51 | fn escape_str(s: &str) -> ~str { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 52 | let mut escaped = ~"\""; |
Niko Matsakis | 9cf271f | 2012-09-19 04:41:37 | [diff] [blame] | 53 | for str::chars_each(s) |c| { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 54 | match c { |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 55 | '"' => escaped += ~"\\\"", |
| 56 | '\\' => escaped += ~"\\\\", |
| 57 | '\x08' => escaped += ~"\\b", |
| 58 | '\x0c' => escaped += ~"\\f", |
| 59 | '\n' => escaped += ~"\\n", |
| 60 | '\r' => escaped += ~"\\r", |
| 61 | '\t' => escaped += ~"\\t", |
| 62 | _ => escaped += str::from_char(c) |
Erick Tryzelaar | b361f6c | 2012-06-13 00:20:51 | [diff] [blame] | 63 | } |
| 64 | }; |
| 65 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 66 | escaped += ~"\""; |
Erick Tryzelaar | b361f6c | 2012-06-13 00:20:51 | [diff] [blame] | 67 | |
| 68 | escaped |
| 69 | } |
| 70 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 71 | fn spaces(n: uint) -> ~str { |
| 72 | let mut ss = ~""; |
Tim Chevalier | 5a8ba07 | 2012-10-11 21:12:50 | [diff] [blame] | 73 | for n.times { str::push_str(&mut ss, " "); } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 74 | return ss; |
| 75 | } |
| 76 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 77 | pub struct Encoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 78 | priv wr: io::Writer, |
| 79 | } |
| 80 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 81 | pub fn Encoder(wr: io::Writer) -> Encoder { |
| 82 | Encoder { wr: wr } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 83 | } |
| 84 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 85 | pub impl Encoder: serialize::Encoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 86 | fn emit_nil(&self) { self.wr.write_str("null") } |
| 87 | |
| 88 | fn emit_uint(&self, v: uint) { self.emit_float(v as float); } |
| 89 | fn emit_u64(&self, v: u64) { self.emit_float(v as float); } |
| 90 | fn emit_u32(&self, v: u32) { self.emit_float(v as float); } |
| 91 | fn emit_u16(&self, v: u16) { self.emit_float(v as float); } |
| 92 | fn emit_u8(&self, v: u8) { self.emit_float(v as float); } |
| 93 | |
| 94 | fn emit_int(&self, v: int) { self.emit_float(v as float); } |
| 95 | fn emit_i64(&self, v: i64) { self.emit_float(v as float); } |
| 96 | fn emit_i32(&self, v: i32) { self.emit_float(v as float); } |
| 97 | fn emit_i16(&self, v: i16) { self.emit_float(v as float); } |
| 98 | fn emit_i8(&self, v: i8) { self.emit_float(v as float); } |
| 99 | |
| 100 | fn emit_bool(&self, v: bool) { |
| 101 | if v { |
| 102 | self.wr.write_str("true"); |
| 103 | } else { |
| 104 | self.wr.write_str("false"); |
| 105 | } |
| 106 | } |
| 107 | |
| 108 | fn emit_f64(&self, v: f64) { self.emit_float(v as float); } |
| 109 | fn emit_f32(&self, v: f32) { self.emit_float(v as float); } |
| 110 | fn emit_float(&self, v: float) { |
Marvin Löbel | a612e49 | 2013-01-27 02:28:39 | [diff] [blame] | 111 | self.wr.write_str(float::to_str_digits(v, 6u)); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 112 | } |
| 113 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 114 | fn emit_char(&self, v: char) { self.emit_borrowed_str(str::from_char(v)) } |
| 115 | |
| 116 | fn emit_borrowed_str(&self, v: &str) { self.wr.write_str(escape_str(v)) } |
| 117 | fn emit_owned_str(&self, v: &str) { self.emit_borrowed_str(v) } |
| 118 | fn emit_managed_str(&self, v: &str) { self.emit_borrowed_str(v) } |
| 119 | |
| 120 | fn emit_borrowed(&self, f: fn()) { f() } |
| 121 | fn emit_owned(&self, f: fn()) { f() } |
| 122 | fn emit_managed(&self, f: fn()) { f() } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 123 | |
John Clements | 394f8ee | 2013-02-07 01:23:41 | [diff] [blame] | 124 | fn emit_enum(&self, _name: &str, f: fn()) { |
John Clements | fe82374 | 2013-02-07 01:19:11 | [diff] [blame] | 125 | f() |
| 126 | } |
John Clements | 394f8ee | 2013-02-07 01:23:41 | [diff] [blame] | 127 | |
| 128 | fn emit_enum_variant(&self, name: &str, _id: uint, _cnt: uint, f: fn()) { |
John Clements | 7659614 | 2013-02-07 00:20:41 | [diff] [blame] | 129 | // emitting enums as arrays where the first |
| 130 | // element provides the enum variant name |
| 131 | self.wr.write_char('['); |
John Clements | 394f8ee | 2013-02-07 01:23:41 | [diff] [blame] | 132 | self.wr.write_str(escape_str(name)); |
John Clements | 7659614 | 2013-02-07 00:20:41 | [diff] [blame] | 133 | f(); |
| 134 | self.wr.write_char(']'); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 135 | } |
John Clements | f91160b | 2013-02-08 01:06:26 | [diff] [blame^] | 136 | |
| 137 | fn emit_enum_variant_arg(&self, _idx: uint, f: fn()) { |
John Clements | 0e9495b | 2013-02-07 22:39:02 | [diff] [blame] | 138 | self.wr.write_char(','); |
John Clements | fe82374 | 2013-02-07 01:19:11 | [diff] [blame] | 139 | f(); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 140 | } |
| 141 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 142 | fn emit_borrowed_vec(&self, _len: uint, f: fn()) { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 143 | self.wr.write_char('['); |
| 144 | f(); |
| 145 | self.wr.write_char(']'); |
| 146 | } |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 147 | fn emit_owned_vec(&self, len: uint, f: fn()) { |
| 148 | self.emit_borrowed_vec(len, f) |
| 149 | } |
| 150 | fn emit_managed_vec(&self, len: uint, f: fn()) { |
| 151 | self.emit_borrowed_vec(len, f) |
| 152 | } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 153 | fn emit_vec_elt(&self, idx: uint, f: fn()) { |
| 154 | if idx != 0 { self.wr.write_char(','); } |
| 155 | f() |
| 156 | } |
| 157 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 158 | fn emit_rec(&self, f: fn()) { |
| 159 | self.wr.write_char('{'); |
| 160 | f(); |
| 161 | self.wr.write_char('}'); |
| 162 | } |
Michael Neumann | 2b6c456 | 2012-12-27 12:16:16 | [diff] [blame] | 163 | fn emit_struct(&self, _name: &str, _len: uint, f: fn()) { |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 164 | self.wr.write_char('{'); |
| 165 | f(); |
| 166 | self.wr.write_char('}'); |
| 167 | } |
| 168 | fn emit_field(&self, name: &str, idx: uint, f: fn()) { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 169 | if idx != 0 { self.wr.write_char(','); } |
| 170 | self.wr.write_str(escape_str(name)); |
| 171 | self.wr.write_char(':'); |
| 172 | f(); |
| 173 | } |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 174 | |
| 175 | fn emit_tup(&self, len: uint, f: fn()) { |
| 176 | self.emit_borrowed_vec(len, f); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 177 | } |
| 178 | fn emit_tup_elt(&self, idx: uint, f: fn()) { |
| 179 | self.emit_vec_elt(idx, f) |
| 180 | } |
| 181 | } |
| 182 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 183 | pub struct PrettyEncoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 184 | priv wr: io::Writer, |
| 185 | priv mut indent: uint, |
| 186 | } |
| 187 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 188 | pub fn PrettyEncoder(wr: io::Writer) -> PrettyEncoder { |
| 189 | PrettyEncoder { wr: wr, indent: 0 } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 190 | } |
| 191 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 192 | pub impl PrettyEncoder: serialize::Encoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 193 | fn emit_nil(&self) { self.wr.write_str("null") } |
| 194 | |
| 195 | fn emit_uint(&self, v: uint) { self.emit_float(v as float); } |
| 196 | fn emit_u64(&self, v: u64) { self.emit_float(v as float); } |
| 197 | fn emit_u32(&self, v: u32) { self.emit_float(v as float); } |
| 198 | fn emit_u16(&self, v: u16) { self.emit_float(v as float); } |
| 199 | fn emit_u8(&self, v: u8) { self.emit_float(v as float); } |
| 200 | |
| 201 | fn emit_int(&self, v: int) { self.emit_float(v as float); } |
| 202 | fn emit_i64(&self, v: i64) { self.emit_float(v as float); } |
| 203 | fn emit_i32(&self, v: i32) { self.emit_float(v as float); } |
| 204 | fn emit_i16(&self, v: i16) { self.emit_float(v as float); } |
| 205 | fn emit_i8(&self, v: i8) { self.emit_float(v as float); } |
| 206 | |
| 207 | fn emit_bool(&self, v: bool) { |
| 208 | if v { |
| 209 | self.wr.write_str("true"); |
| 210 | } else { |
| 211 | self.wr.write_str("false"); |
| 212 | } |
| 213 | } |
| 214 | |
| 215 | fn emit_f64(&self, v: f64) { self.emit_float(v as float); } |
| 216 | fn emit_f32(&self, v: f32) { self.emit_float(v as float); } |
| 217 | fn emit_float(&self, v: float) { |
Marvin Löbel | a612e49 | 2013-01-27 02:28:39 | [diff] [blame] | 218 | self.wr.write_str(float::to_str_digits(v, 6u)); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 219 | } |
| 220 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 221 | fn emit_char(&self, v: char) { self.emit_borrowed_str(str::from_char(v)) } |
| 222 | |
| 223 | fn emit_borrowed_str(&self, v: &str) { self.wr.write_str(escape_str(v)); } |
| 224 | fn emit_owned_str(&self, v: &str) { self.emit_borrowed_str(v) } |
| 225 | fn emit_managed_str(&self, v: &str) { self.emit_borrowed_str(v) } |
| 226 | |
| 227 | fn emit_borrowed(&self, f: fn()) { f() } |
| 228 | fn emit_owned(&self, f: fn()) { f() } |
| 229 | fn emit_managed(&self, f: fn()) { f() } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 230 | |
| 231 | fn emit_enum(&self, name: &str, f: fn()) { |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 232 | if name != "option" { die!(~"only supports option enum") } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 233 | f() |
| 234 | } |
| 235 | fn emit_enum_variant(&self, _name: &str, id: uint, _cnt: uint, f: fn()) { |
| 236 | if id == 0 { |
| 237 | self.emit_nil(); |
| 238 | } else { |
| 239 | f() |
| 240 | } |
| 241 | } |
| 242 | fn emit_enum_variant_arg(&self, _idx: uint, f: fn()) { |
| 243 | f() |
| 244 | } |
| 245 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 246 | fn emit_borrowed_vec(&self, _len: uint, f: fn()) { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 247 | self.wr.write_char('['); |
| 248 | self.indent += 2; |
| 249 | f(); |
| 250 | self.indent -= 2; |
| 251 | self.wr.write_char(']'); |
| 252 | } |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 253 | fn emit_owned_vec(&self, len: uint, f: fn()) { |
| 254 | self.emit_borrowed_vec(len, f) |
| 255 | } |
| 256 | fn emit_managed_vec(&self, len: uint, f: fn()) { |
| 257 | self.emit_borrowed_vec(len, f) |
| 258 | } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 259 | fn emit_vec_elt(&self, idx: uint, f: fn()) { |
| 260 | if idx == 0 { |
| 261 | self.wr.write_char('\n'); |
| 262 | } else { |
| 263 | self.wr.write_str(",\n"); |
| 264 | } |
| 265 | self.wr.write_str(spaces(self.indent)); |
| 266 | f() |
| 267 | } |
| 268 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 269 | fn emit_rec(&self, f: fn()) { |
| 270 | self.wr.write_char('{'); |
| 271 | self.indent += 2; |
| 272 | f(); |
| 273 | self.indent -= 2; |
| 274 | self.wr.write_char('}'); |
| 275 | } |
Michael Neumann | 2b6c456 | 2012-12-27 12:16:16 | [diff] [blame] | 276 | fn emit_struct(&self, _name: &str, _len: uint, f: fn()) { |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 277 | self.emit_rec(f) |
| 278 | } |
| 279 | fn emit_field(&self, name: &str, idx: uint, f: fn()) { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 280 | if idx == 0 { |
| 281 | self.wr.write_char('\n'); |
| 282 | } else { |
| 283 | self.wr.write_str(",\n"); |
| 284 | } |
| 285 | self.wr.write_str(spaces(self.indent)); |
| 286 | self.wr.write_str(escape_str(name)); |
| 287 | self.wr.write_str(": "); |
| 288 | f(); |
| 289 | } |
| 290 | fn emit_tup(&self, sz: uint, f: fn()) { |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 291 | self.emit_borrowed_vec(sz, f); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 292 | } |
| 293 | fn emit_tup_elt(&self, idx: uint, f: fn()) { |
| 294 | self.emit_vec_elt(idx, f) |
| 295 | } |
| 296 | } |
| 297 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 298 | pub impl<S: serialize::Encoder> Json: serialize::Encodable<S> { |
| 299 | fn encode(&self, s: &S) { |
Erick Tryzelaar | ab89b5c | 2012-10-13 16:11:33 | [diff] [blame] | 300 | match *self { |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 301 | Number(v) => v.encode(s), |
| 302 | String(ref v) => v.encode(s), |
| 303 | Boolean(v) => v.encode(s), |
| 304 | List(ref v) => v.encode(s), |
Erick Tryzelaar | ab89b5c | 2012-10-13 16:11:33 | [diff] [blame] | 305 | Object(ref v) => { |
| 306 | do s.emit_rec || { |
| 307 | let mut idx = 0; |
Daniel Micay | 9599cc8 | 2013-02-08 02:03:13 | [diff] [blame] | 308 | for v.each |&(key, value)| { |
Erick Tryzelaar | ab89b5c | 2012-10-13 16:11:33 | [diff] [blame] | 309 | do s.emit_field(*key, idx) { |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 310 | value.encode(s); |
Erick Tryzelaar | ab89b5c | 2012-10-13 16:11:33 | [diff] [blame] | 311 | } |
| 312 | idx += 1; |
| 313 | } |
| 314 | } |
| 315 | }, |
| 316 | Null => s.emit_nil(), |
| 317 | } |
| 318 | } |
| 319 | } |
| 320 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 321 | /// Encodes a json value into a io::writer |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 322 | pub fn to_writer(wr: io::Writer, json: &Json) { |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 323 | json.encode(&Encoder(wr)) |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 324 | } |
| 325 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 326 | /// Encodes a json value into a string |
Patrick Walton | 54b2cad | 2013-01-23 19:43:58 | [diff] [blame] | 327 | pub pure fn to_str(json: &Json) -> ~str { |
| 328 | unsafe { |
| 329 | // ugh, should be safe |
| 330 | io::with_str_writer(|wr| to_writer(wr, json)) |
| 331 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 332 | } |
| 333 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 334 | /// Encodes a json value into a io::writer |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 335 | pub fn to_pretty_writer(wr: io::Writer, json: &Json) { |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 336 | json.encode(&PrettyEncoder(wr)) |
Kevin Cantu | d47cb10 | 2012-08-30 23:39:56 | [diff] [blame] | 337 | } |
| 338 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 339 | /// Encodes a json value into a string |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 340 | pub fn to_pretty_str(json: &Json) -> ~str { |
| 341 | io::with_str_writer(|wr| to_pretty_writer(wr, json)) |
Patrick Walton | db020ab | 2012-07-11 22:00:40 | [diff] [blame] | 342 | } |
| 343 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 344 | pub struct Parser { |
| 345 | priv rdr: io::Reader, |
| 346 | priv mut ch: char, |
| 347 | priv mut line: uint, |
| 348 | priv mut col: uint, |
| 349 | } |
| 350 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 351 | /// Decode a json value from an io::reader |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 352 | pub fn Parser(rdr: io::Reader) -> Parser { |
| 353 | Parser { |
| 354 | rdr: rdr, |
| 355 | ch: rdr.read_char(), |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 356 | line: 1, |
| 357 | col: 1, |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 358 | } |
| 359 | } |
| 360 | |
| 361 | pub impl Parser { |
| 362 | fn parse() -> Result<Json, Error> { |
| 363 | match move self.parse_value() { |
| 364 | Ok(move value) => { |
| 365 | // Skip trailing whitespaces. |
| 366 | self.parse_whitespace(); |
| 367 | // Make sure there is no trailing characters. |
| 368 | if self.eof() { |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 369 | Ok(move value) |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 370 | } else { |
| 371 | self.error(~"trailing characters") |
| 372 | } |
| 373 | } |
| 374 | Err(move e) => Err(e) |
| 375 | } |
| 376 | } |
| 377 | } |
| 378 | |
| 379 | priv impl Parser { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 380 | fn eof() -> bool { self.ch == -1 as char } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 381 | |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 382 | fn bump() { |
| 383 | self.ch = self.rdr.read_char(); |
| 384 | |
| 385 | if self.ch == '\n' { |
| 386 | self.line += 1u; |
| 387 | self.col = 1u; |
| 388 | } else { |
| 389 | self.col += 1u; |
| 390 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 391 | } |
| 392 | |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 393 | fn next_char() -> char { |
| 394 | self.bump(); |
| 395 | self.ch |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 396 | } |
| 397 | |
Tim Chevalier | f33539e | 2012-10-03 19:21:48 | [diff] [blame] | 398 | fn error<T>(msg: ~str) -> Result<T, Error> { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 399 | Err(Error { line: self.line, col: self.col, msg: @msg }) |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 400 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 401 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 402 | fn parse_value() -> Result<Json, Error> { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 403 | self.parse_whitespace(); |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 404 | |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 405 | if self.eof() { return self.error(~"EOF while parsing value"); } |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 406 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 407 | match self.ch { |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 408 | 'n' => self.parse_ident(~"ull", Null), |
| 409 | 't' => self.parse_ident(~"rue", Boolean(true)), |
| 410 | 'f' => self.parse_ident(~"alse", Boolean(false)), |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 411 | '0' .. '9' | '-' => self.parse_number(), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 412 | '"' => |
| 413 | match move self.parse_str() { |
| 414 | Ok(move s) => Ok(String(s)), |
| 415 | Err(move e) => Err(e), |
| 416 | }, |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 417 | '[' => self.parse_list(), |
| 418 | '{' => self.parse_object(), |
| 419 | _ => self.error(~"invalid syntax") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 420 | } |
| 421 | } |
| 422 | |
| 423 | fn parse_whitespace() { |
| 424 | while char::is_whitespace(self.ch) { self.bump(); } |
| 425 | } |
| 426 | |
Tim Chevalier | 8fc60af | 2012-10-05 02:58:31 | [diff] [blame] | 427 | fn parse_ident(ident: &str, value: Json) -> Result<Json, Error> { |
Brian Anderson | d1fc2b5 | 2012-06-30 23:19:07 | [diff] [blame] | 428 | if str::all(ident, |c| c == self.next_char()) { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 429 | self.bump(); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 430 | Ok(move value) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 431 | } else { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 432 | self.error(~"invalid syntax") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 433 | } |
| 434 | } |
| 435 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 436 | fn parse_number() -> Result<Json, Error> { |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 437 | let mut neg = 1f; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 438 | |
| 439 | if self.ch == '-' { |
| 440 | self.bump(); |
Marijn Haverbeke | 4f826d8 | 2011-12-16 09:11:00 | [diff] [blame] | 441 | neg = -1f; |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 442 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 443 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 444 | let mut res = match self.parse_integer() { |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 445 | Ok(res) => res, |
| 446 | Err(e) => return Err(e) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 447 | }; |
| 448 | |
| 449 | if self.ch == '.' { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 450 | match self.parse_decimal(res) { |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 451 | Ok(r) => res = r, |
| 452 | Err(e) => return Err(e) |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 453 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 454 | } |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 455 | |
| 456 | if self.ch == 'e' || self.ch == 'E' { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 457 | match self.parse_exponent(res) { |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 458 | Ok(r) => res = r, |
| 459 | Err(e) => return Err(e) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 460 | } |
| 461 | } |
| 462 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 463 | Ok(Number(neg * res)) |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 464 | } |
| 465 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 466 | fn parse_integer() -> Result<float, Error> { |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 467 | let mut res = 0f; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 468 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 469 | match self.ch { |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 470 | '0' => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 471 | self.bump(); |
| 472 | |
| 473 | // There can be only one leading '0'. |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 474 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 475 | '0' .. '9' => return self.error(~"invalid number"), |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 476 | _ => () |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 477 | } |
| 478 | } |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 479 | '1' .. '9' => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 480 | while !self.eof() { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 481 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 482 | '0' .. '9' => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 483 | res *= 10f; |
| 484 | res += ((self.ch as int) - ('0' as int)) as float; |
| 485 | |
| 486 | self.bump(); |
| 487 | } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 488 | _ => break |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 489 | } |
| 490 | } |
| 491 | } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 492 | _ => return self.error(~"invalid number") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 493 | } |
| 494 | |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 495 | Ok(res) |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 496 | } |
| 497 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 498 | fn parse_decimal(res: float) -> Result<float, Error> { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 499 | self.bump(); |
| 500 | |
| 501 | // Make sure a digit follows the decimal place. |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 502 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 503 | '0' .. '9' => (), |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 504 | _ => return self.error(~"invalid number") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 505 | } |
| 506 | |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 507 | let mut res = res; |
| 508 | let mut dec = 1f; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 509 | while !self.eof() { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 510 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 511 | '0' .. '9' => { |
Marijn Haverbeke | 4f826d8 | 2011-12-16 09:11:00 | [diff] [blame] | 512 | dec /= 10f; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 513 | res += (((self.ch as int) - ('0' as int)) as float) * dec; |
| 514 | |
| 515 | self.bump(); |
| 516 | } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 517 | _ => break |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 518 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 519 | } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 520 | |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 521 | Ok(res) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 522 | } |
| 523 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 524 | fn parse_exponent(res: float) -> Result<float, Error> { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 525 | self.bump(); |
| 526 | |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 527 | let mut res = res; |
| 528 | let mut exp = 0u; |
| 529 | let mut neg_exp = false; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 530 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 531 | match self.ch { |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 532 | '+' => self.bump(), |
| 533 | '-' => { self.bump(); neg_exp = true; } |
| 534 | _ => () |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 535 | } |
| 536 | |
| 537 | // Make sure a digit follows the exponent place. |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 538 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 539 | '0' .. '9' => (), |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 540 | _ => return self.error(~"invalid number") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 541 | } |
| 542 | |
| 543 | while !self.eof() { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 544 | match self.ch { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 545 | '0' .. '9' => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 546 | exp *= 10u; |
| 547 | exp += (self.ch as uint) - ('0' as uint); |
| 548 | |
| 549 | self.bump(); |
| 550 | } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 551 | _ => break |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 552 | } |
| 553 | } |
| 554 | |
| 555 | let exp = float::pow_with_uint(10u, exp); |
| 556 | if neg_exp { |
| 557 | res /= exp; |
| 558 | } else { |
| 559 | res *= exp; |
| 560 | } |
| 561 | |
Brian Anderson | 0c6e470 | 2012-08-26 23:54:31 | [diff] [blame] | 562 | Ok(res) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 563 | } |
| 564 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 565 | fn parse_str() -> Result<~str, Error> { |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 566 | let mut escape = false; |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 567 | let mut res = ~""; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 568 | |
| 569 | while !self.eof() { |
| 570 | self.bump(); |
| 571 | |
| 572 | if (escape) { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 573 | match self.ch { |
Tim Chevalier | 5a8ba07 | 2012-10-11 21:12:50 | [diff] [blame] | 574 | '"' => str::push_char(&mut res, '"'), |
| 575 | '\\' => str::push_char(&mut res, '\\'), |
| 576 | '/' => str::push_char(&mut res, '/'), |
| 577 | 'b' => str::push_char(&mut res, '\x08'), |
| 578 | 'f' => str::push_char(&mut res, '\x0c'), |
| 579 | 'n' => str::push_char(&mut res, '\n'), |
| 580 | 'r' => str::push_char(&mut res, '\r'), |
| 581 | 't' => str::push_char(&mut res, '\t'), |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 582 | 'u' => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 583 | // Parse \u1234. |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 584 | let mut i = 0u; |
| 585 | let mut n = 0u; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 586 | while i < 4u { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 587 | match self.next_char() { |
Brian Anderson | 80c4f74 | 2012-09-02 01:38:05 | [diff] [blame] | 588 | '0' .. '9' => { |
Kevin Cantu | 4fb675b | 2012-08-31 03:12:10 | [diff] [blame] | 589 | n = n * 16u + (self.ch as uint) |
| 590 | - ('0' as uint); |
| 591 | }, |
| 592 | 'a' | 'A' => n = n * 16u + 10u, |
| 593 | 'b' | 'B' => n = n * 16u + 11u, |
| 594 | 'c' | 'C' => n = n * 16u + 12u, |
| 595 | 'd' | 'D' => n = n * 16u + 13u, |
| 596 | 'e' | 'E' => n = n * 16u + 14u, |
| 597 | 'f' | 'F' => n = n * 16u + 15u, |
| 598 | _ => return self.error( |
| 599 | ~"invalid \\u escape (unrecognized hex)") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 600 | } |
Niko Matsakis | 6b35875 | 2012-03-14 18:03:56 | [diff] [blame] | 601 | i += 1u; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 602 | } |
| 603 | |
| 604 | // Error out if we didn't parse 4 digits. |
| 605 | if i != 4u { |
Kevin Cantu | 4fb675b | 2012-08-31 03:12:10 | [diff] [blame] | 606 | return self.error( |
| 607 | ~"invalid \\u escape (not four digits)"); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 608 | } |
| 609 | |
Tim Chevalier | 5a8ba07 | 2012-10-11 21:12:50 | [diff] [blame] | 610 | str::push_char(&mut res, n as char); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 611 | } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 612 | _ => return self.error(~"invalid escape") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 613 | } |
| 614 | escape = false; |
| 615 | } else if self.ch == '\\' { |
| 616 | escape = true; |
| 617 | } else { |
| 618 | if self.ch == '"' { |
| 619 | self.bump(); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 620 | return Ok(res); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 621 | } |
Tim Chevalier | 5a8ba07 | 2012-10-11 21:12:50 | [diff] [blame] | 622 | str::push_char(&mut res, self.ch); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 623 | } |
| 624 | } |
| 625 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 626 | self.error(~"EOF while parsing string") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 627 | } |
| 628 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 629 | fn parse_list() -> Result<Json, Error> { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 630 | self.bump(); |
| 631 | self.parse_whitespace(); |
| 632 | |
Michael Sullivan | 98e161f | 2012-06-29 23:26:56 | [diff] [blame] | 633 | let mut values = ~[]; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 634 | |
| 635 | if self.ch == ']' { |
| 636 | self.bump(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 637 | return Ok(List(move values)); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 638 | } |
| 639 | |
Tim Chevalier | 35400e1 | 2012-03-11 04:34:17 | [diff] [blame] | 640 | loop { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 641 | match move self.parse_value() { |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 642 | Ok(move v) => values.push(move v), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 643 | Err(move e) => return Err(e) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | self.parse_whitespace(); |
Tim Chevalier | 35400e1 | 2012-03-11 04:34:17 | [diff] [blame] | 647 | if self.eof() { |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 648 | return self.error(~"EOF while parsing list"); |
Tim Chevalier | 35400e1 | 2012-03-11 04:34:17 | [diff] [blame] | 649 | } |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 650 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 651 | match self.ch { |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 652 | ',' => self.bump(), |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 653 | ']' => { self.bump(); return Ok(List(move values)); } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 654 | _ => return self.error(~"expected `,` or `]`") |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 655 | } |
Tim Chevalier | 35400e1 | 2012-03-11 04:34:17 | [diff] [blame] | 656 | }; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 657 | } |
| 658 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 659 | fn parse_object() -> Result<Json, Error> { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 660 | self.bump(); |
| 661 | self.parse_whitespace(); |
| 662 | |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 663 | let mut values = ~LinearMap::new(); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 664 | |
| 665 | if self.ch == '}' { |
| 666 | self.bump(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 667 | return Ok(Object(move values)); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 668 | } |
| 669 | |
| 670 | while !self.eof() { |
| 671 | self.parse_whitespace(); |
| 672 | |
| 673 | if self.ch != '"' { |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 674 | return self.error(~"key must be a string"); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 675 | } |
| 676 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 677 | let key = match move self.parse_str() { |
| 678 | Ok(move key) => key, |
| 679 | Err(move e) => return Err(e) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 680 | }; |
| 681 | |
| 682 | self.parse_whitespace(); |
| 683 | |
| 684 | if self.ch != ':' { |
| 685 | if self.eof() { break; } |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 686 | return self.error(~"expected `:`"); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 687 | } |
| 688 | self.bump(); |
| 689 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 690 | match move self.parse_value() { |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 691 | Ok(move value) => { values.insert(key, move value); } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 692 | Err(move e) => return Err(e) |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 693 | } |
| 694 | self.parse_whitespace(); |
| 695 | |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 696 | match self.ch { |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 697 | ',' => self.bump(), |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 698 | '}' => { self.bump(); return Ok(Object(move values)); } |
Brian Anderson | 025d866 | 2012-08-04 02:59:04 | [diff] [blame] | 699 | _ => { |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 700 | if self.eof() { break; } |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 701 | return self.error(~"expected `,` or `}`"); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 702 | } |
| 703 | } |
| 704 | } |
| 705 | |
Brian Anderson | b355936 | 2012-08-02 00:30:05 | [diff] [blame] | 706 | return self.error(~"EOF while parsing object"); |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 707 | } |
| 708 | } |
| 709 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 710 | /// Decodes a json value from an io::reader |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 711 | pub fn from_reader(rdr: io::Reader) -> Result<Json, Error> { |
| 712 | Parser(rdr).parse() |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 713 | } |
| 714 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 715 | /// Decodes a json value from a string |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 716 | pub fn from_str(s: &str) -> Result<Json, Error> { |
| 717 | do io::with_str_reader(s) |rdr| { |
| 718 | from_reader(rdr) |
| 719 | } |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 720 | } |
| 721 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 722 | pub struct Decoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 723 | priv json: Json, |
| 724 | priv mut stack: ~[&Json], |
| 725 | } |
| 726 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 727 | pub fn Decoder(json: Json) -> Decoder { |
| 728 | Decoder { json: move json, stack: ~[] } |
Elly Jones | bd72626 | 2011-11-07 19:01:28 | [diff] [blame] | 729 | } |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 730 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 731 | priv impl Decoder { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 732 | fn peek(&self) -> &self/Json { |
| 733 | if self.stack.len() == 0 { self.stack.push(&self.json); } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 734 | vec::last(self.stack) |
| 735 | } |
| 736 | |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 737 | fn pop(&self) -> &self/Json { |
| 738 | if self.stack.len() == 0 { self.stack.push(&self.json); } |
Niko Matsakis | 21519bc | 2012-09-28 05:20:47 | [diff] [blame] | 739 | self.stack.pop() |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 740 | } |
| 741 | } |
| 742 | |
Erick Tryzelaar | 8650c6f | 2012-12-18 03:31:04 | [diff] [blame] | 743 | pub impl Decoder: serialize::Decoder { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 744 | fn read_nil(&self) -> () { |
| 745 | debug!("read_nil"); |
| 746 | match *self.pop() { |
| 747 | Null => (), |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 748 | _ => die!(~"not a null") |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 749 | } |
| 750 | } |
| 751 | |
| 752 | fn read_u64(&self) -> u64 { self.read_float() as u64 } |
| 753 | fn read_u32(&self) -> u32 { self.read_float() as u32 } |
| 754 | fn read_u16(&self) -> u16 { self.read_float() as u16 } |
| 755 | fn read_u8 (&self) -> u8 { self.read_float() as u8 } |
| 756 | fn read_uint(&self) -> uint { self.read_float() as uint } |
| 757 | |
| 758 | fn read_i64(&self) -> i64 { self.read_float() as i64 } |
| 759 | fn read_i32(&self) -> i32 { self.read_float() as i32 } |
| 760 | fn read_i16(&self) -> i16 { self.read_float() as i16 } |
| 761 | fn read_i8 (&self) -> i8 { self.read_float() as i8 } |
| 762 | fn read_int(&self) -> int { self.read_float() as int } |
| 763 | |
| 764 | fn read_bool(&self) -> bool { |
| 765 | debug!("read_bool"); |
| 766 | match *self.pop() { |
| 767 | Boolean(b) => b, |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 768 | _ => die!(~"not a boolean") |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 769 | } |
| 770 | } |
| 771 | |
| 772 | fn read_f64(&self) -> f64 { self.read_float() as f64 } |
| 773 | fn read_f32(&self) -> f32 { self.read_float() as f32 } |
| 774 | fn read_float(&self) -> float { |
| 775 | debug!("read_float"); |
| 776 | match *self.pop() { |
| 777 | Number(f) => f, |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 778 | _ => die!(~"not a number") |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 779 | } |
| 780 | } |
| 781 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 782 | fn read_char(&self) -> char { |
| 783 | let v = str::chars(self.read_owned_str()); |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 784 | if v.len() != 1 { die!(~"string must have one character") } |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 785 | v[0] |
| 786 | } |
| 787 | |
| 788 | fn read_owned_str(&self) -> ~str { |
| 789 | debug!("read_owned_str"); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 790 | match *self.pop() { |
| 791 | String(ref s) => copy *s, |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 792 | _ => die!(~"not a string") |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 793 | } |
| 794 | } |
| 795 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 796 | fn read_managed_str(&self) -> @str { |
Huon Wilson | 76dc781 | 2012-12-10 02:29:33 | [diff] [blame] | 797 | debug!("read_managed_str"); |
| 798 | match *self.pop() { |
| 799 | String(ref s) => s.to_managed(), |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 800 | _ => die!(~"not a string") |
Huon Wilson | 76dc781 | 2012-12-10 02:29:33 | [diff] [blame] | 801 | } |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 802 | } |
| 803 | |
| 804 | fn read_owned<T>(&self, f: fn() -> T) -> T { |
| 805 | debug!("read_owned()"); |
| 806 | f() |
| 807 | } |
| 808 | |
| 809 | fn read_managed<T>(&self, f: fn() -> T) -> T { |
| 810 | debug!("read_managed()"); |
| 811 | f() |
| 812 | } |
| 813 | |
Tim Chevalier | 9ff95e2 | 2012-10-01 19:36:06 | [diff] [blame] | 814 | fn read_enum<T>(&self, name: &str, f: fn() -> T) -> T { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 815 | debug!("read_enum(%s)", name); |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 816 | if name != ~"option" { die!(~"only supports the option enum") } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 817 | f() |
| 818 | } |
| 819 | |
| 820 | fn read_enum_variant<T>(&self, f: fn(uint) -> T) -> T { |
| 821 | debug!("read_enum_variant()"); |
| 822 | let idx = match *self.peek() { |
| 823 | Null => 0, |
| 824 | _ => 1, |
| 825 | }; |
| 826 | f(idx) |
| 827 | } |
| 828 | |
| 829 | fn read_enum_variant_arg<T>(&self, idx: uint, f: fn() -> T) -> T { |
| 830 | debug!("read_enum_variant_arg(idx=%u)", idx); |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 831 | if idx != 0 { die!(~"unknown index") } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 832 | f() |
| 833 | } |
| 834 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 835 | fn read_owned_vec<T>(&self, f: fn(uint) -> T) -> T { |
| 836 | debug!("read_owned_vec()"); |
| 837 | let len = match *self.peek() { |
Niko Matsakis | a380df8 | 2013-02-08 03:33:12 | [diff] [blame] | 838 | List(ref list) => list.len(), |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 839 | _ => die!(~"not a list"), |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 840 | }; |
| 841 | let res = f(len); |
| 842 | self.pop(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 843 | move res |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 844 | } |
| 845 | |
| 846 | fn read_managed_vec<T>(&self, f: fn(uint) -> T) -> T { |
| 847 | debug!("read_owned_vec()"); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 848 | let len = match *self.peek() { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 849 | List(ref list) => list.len(), |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 850 | _ => die!(~"not a list"), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 851 | }; |
| 852 | let res = f(len); |
| 853 | self.pop(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 854 | move res |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 855 | } |
| 856 | |
| 857 | fn read_vec_elt<T>(&self, idx: uint, f: fn() -> T) -> T { |
| 858 | debug!("read_vec_elt(idx=%u)", idx); |
| 859 | match *self.peek() { |
| 860 | List(ref list) => { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 861 | self.stack.push(&list[idx]); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 862 | f() |
| 863 | } |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 864 | _ => die!(~"not a list"), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 865 | } |
| 866 | } |
| 867 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 868 | fn read_rec<T>(&self, f: fn() -> T) -> T { |
| 869 | debug!("read_rec()"); |
| 870 | let value = f(); |
| 871 | self.pop(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 872 | move value |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 873 | } |
| 874 | |
Michael Neumann | 2b6c456 | 2012-12-27 12:16:16 | [diff] [blame] | 875 | fn read_struct<T>(&self, _name: &str, _len: uint, f: fn() -> T) -> T { |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 876 | debug!("read_struct()"); |
| 877 | let value = f(); |
| 878 | self.pop(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 879 | move value |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 880 | } |
| 881 | |
| 882 | fn read_field<T>(&self, name: &str, idx: uint, f: fn() -> T) -> T { |
| 883 | debug!("read_rec_field(%s, idx=%u)", name, idx); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 884 | let top = self.peek(); |
| 885 | match *top { |
| 886 | Object(ref obj) => { |
Daniel Micay | ee0a8c6 | 2013-01-23 16:47:43 | [diff] [blame] | 887 | match obj.find(&name.to_owned()) { |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 888 | None => die!(fmt!("no such field: %s", name)), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 889 | Some(json) => { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 890 | self.stack.push(json); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 891 | f() |
| 892 | } |
| 893 | } |
| 894 | } |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 895 | Number(_) => die!(~"num"), |
| 896 | String(_) => die!(~"str"), |
| 897 | Boolean(_) => die!(~"bool"), |
| 898 | List(_) => die!(fmt!("list: %?", top)), |
| 899 | Null => die!(~"null"), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 900 | |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 901 | //_ => die!(fmt!("not an object: %?", *top)) |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 902 | } |
| 903 | } |
| 904 | |
Erick Tryzelaar | 81423a3 | 2012-09-27 04:35:13 | [diff] [blame] | 905 | fn read_tup<T>(&self, len: uint, f: fn() -> T) -> T { |
| 906 | debug!("read_tup(len=%u)", len); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 907 | let value = f(); |
| 908 | self.pop(); |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 909 | move value |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 910 | } |
| 911 | |
| 912 | fn read_tup_elt<T>(&self, idx: uint, f: fn() -> T) -> T { |
| 913 | debug!("read_tup_elt(idx=%u)", idx); |
| 914 | match *self.peek() { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 915 | List(ref list) => { |
Niko Matsakis | 67a8e71 | 2012-09-27 00:33:34 | [diff] [blame] | 916 | self.stack.push(&list[idx]); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 917 | f() |
| 918 | } |
Nick Desaulniers | aee7929 | 2013-02-01 01:51:01 | [diff] [blame] | 919 | _ => die!(~"not a list") |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 920 | } |
| 921 | } |
| 922 | } |
| 923 | |
| 924 | impl Json : Eq { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 925 | pure fn eq(&self, other: &Json) -> bool { |
Tim Chevalier | 3e7da96 | 2013-01-11 04:09:16 | [diff] [blame] | 926 | match (self) { |
| 927 | &Number(f0) => |
| 928 | match other { &Number(f1) => f0 == f1, _ => false }, |
| 929 | &String(ref s0) => |
| 930 | match other { &String(ref s1) => s0 == s1, _ => false }, |
| 931 | &Boolean(b0) => |
| 932 | match other { &Boolean(b1) => b0 == b1, _ => false }, |
| 933 | &Null => |
| 934 | match other { &Null => true, _ => false }, |
| 935 | &List(ref v0) => |
| 936 | match other { &List(ref v1) => v0 == v1, _ => false }, |
| 937 | &Object(ref d0) => { |
| 938 | match other { |
| 939 | &Object(ref d1) => { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 940 | if d0.len() == d1.len() { |
| 941 | let mut equal = true; |
Daniel Micay | 9599cc8 | 2013-02-08 02:03:13 | [diff] [blame] | 942 | for d0.each |&(k, v0)| { |
Daniel Micay | ee0a8c6 | 2013-01-23 16:47:43 | [diff] [blame] | 943 | match d1.find(k) { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 944 | Some(v1) if v0 == v1 => { }, |
| 945 | _ => { equal = false; break } |
| 946 | } |
| 947 | }; |
| 948 | equal |
| 949 | } else { |
| 950 | false |
| 951 | } |
| 952 | } |
| 953 | _ => false |
| 954 | } |
| 955 | } |
| 956 | } |
| 957 | } |
Tim Chevalier | 3e7da96 | 2013-01-11 04:09:16 | [diff] [blame] | 958 | pure fn ne(&self, other: &Json) -> bool { !self.eq(other) } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 959 | } |
| 960 | |
Patrick Walton | 22b8757 | 2012-09-08 01:53:14 | [diff] [blame] | 961 | /// Test if two json values are less than one another |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 962 | impl Json : Ord { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 963 | pure fn lt(&self, other: &Json) -> bool { |
| 964 | match (*self) { |
| 965 | Number(f0) => { |
| 966 | match *other { |
| 967 | Number(f1) => f0 < f1, |
| 968 | String(_) | Boolean(_) | List(_) | Object(_) | |
| 969 | Null => true |
| 970 | } |
| 971 | } |
| 972 | |
| 973 | String(ref s0) => { |
| 974 | match *other { |
| 975 | Number(_) => false, |
| 976 | String(ref s1) => s0 < s1, |
| 977 | Boolean(_) | List(_) | Object(_) | Null => true |
| 978 | } |
| 979 | } |
| 980 | |
| 981 | Boolean(b0) => { |
| 982 | match *other { |
| 983 | Number(_) | String(_) => false, |
| 984 | Boolean(b1) => b0 < b1, |
| 985 | List(_) | Object(_) | Null => true |
| 986 | } |
| 987 | } |
| 988 | |
Patrick Walton | 98fdcb0 | 2012-12-08 03:34:57 | [diff] [blame] | 989 | List(ref l0) => { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 990 | match *other { |
| 991 | Number(_) | String(_) | Boolean(_) => false, |
Patrick Walton | 98fdcb0 | 2012-12-08 03:34:57 | [diff] [blame] | 992 | List(ref l1) => (*l0) < (*l1), |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 993 | Object(_) | Null => true |
| 994 | } |
| 995 | } |
| 996 | |
| 997 | Object(ref d0) => { |
| 998 | match *other { |
| 999 | Number(_) | String(_) | Boolean(_) | List(_) => false, |
| 1000 | Object(ref d1) => { |
| 1001 | unsafe { |
| 1002 | let mut d0_flat = ~[]; |
| 1003 | let mut d1_flat = ~[]; |
| 1004 | |
Tim Chevalier | 3e7da96 | 2013-01-11 04:09:16 | [diff] [blame] | 1005 | // FIXME #4430: this is horribly inefficient... |
Daniel Micay | 9599cc8 | 2013-02-08 02:03:13 | [diff] [blame] | 1006 | for d0.each |&(k, v)| { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1007 | d0_flat.push((@copy *k, @copy *v)); |
| 1008 | } |
| 1009 | d0_flat.qsort(); |
| 1010 | |
Daniel Micay | 9599cc8 | 2013-02-08 02:03:13 | [diff] [blame] | 1011 | for d1.each |&(k, v)| { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1012 | d1_flat.push((@copy *k, @copy *v)); |
| 1013 | } |
| 1014 | d1_flat.qsort(); |
| 1015 | |
| 1016 | d0_flat < d1_flat |
| 1017 | } |
| 1018 | } |
| 1019 | Null => true |
| 1020 | } |
| 1021 | } |
| 1022 | |
| 1023 | Null => { |
| 1024 | match *other { |
| 1025 | Number(_) | String(_) | Boolean(_) | List(_) | |
| 1026 | Object(_) => |
| 1027 | false, |
| 1028 | Null => true |
| 1029 | } |
| 1030 | } |
| 1031 | } |
| 1032 | } |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1033 | pure fn le(&self, other: &Json) -> bool { !(*other).lt(&(*self)) } |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1034 | pure fn ge(&self, other: &Json) -> bool { !(*self).lt(other) } |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1035 | pure fn gt(&self, other: &Json) -> bool { (*other).lt(&(*self)) } |
Patrick Walton | 22b8757 | 2012-09-08 01:53:14 | [diff] [blame] | 1036 | } |
| 1037 | |
Patrick Walton | 9117dcb | 2012-09-20 01:00:26 | [diff] [blame] | 1038 | impl Error : Eq { |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1039 | pure fn eq(&self, other: &Error) -> bool { |
| 1040 | (*self).line == other.line && |
| 1041 | (*self).col == other.col && |
| 1042 | (*self).msg == other.msg |
| 1043 | } |
Patrick Walton | 318e534 | 2012-11-15 02:59:30 | [diff] [blame] | 1044 | pure fn ne(&self, other: &Error) -> bool { !(*self).eq(other) } |
Patrick Walton | 9117dcb | 2012-09-20 01:00:26 | [diff] [blame] | 1045 | } |
Patrick Walton | 9653436 | 2012-08-27 23:26:35 | [diff] [blame] | 1046 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1047 | trait ToJson { fn to_json() -> Json; } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1048 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1049 | impl Json: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1050 | fn to_json() -> Json { copy self } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1051 | } |
| 1052 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1053 | impl @Json: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1054 | fn to_json() -> Json { (*self).to_json() } |
Erick Tryzelaar | 11a56c3 | 2012-06-13 15:30:54 | [diff] [blame] | 1055 | } |
| 1056 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1057 | impl int: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1058 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | 11a56c3 | 2012-06-13 15:30:54 | [diff] [blame] | 1059 | } |
| 1060 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1061 | impl i8: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1062 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1063 | } |
| 1064 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1065 | impl i16: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1066 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1067 | } |
| 1068 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1069 | impl i32: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1070 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1071 | } |
| 1072 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1073 | impl i64: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1074 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1075 | } |
| 1076 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1077 | impl uint: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1078 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | 11a56c3 | 2012-06-13 15:30:54 | [diff] [blame] | 1079 | } |
| 1080 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1081 | impl u8: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1082 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1083 | } |
| 1084 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1085 | impl u16: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1086 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1087 | } |
| 1088 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1089 | impl u32: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1090 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1091 | } |
| 1092 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1093 | impl u64: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1094 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1095 | } |
| 1096 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1097 | impl float: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1098 | fn to_json() -> Json { Number(self) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1099 | } |
| 1100 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1101 | impl f32: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1102 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1103 | } |
| 1104 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1105 | impl f64: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1106 | fn to_json() -> Json { Number(self as float) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1107 | } |
| 1108 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1109 | impl (): ToJson { |
| 1110 | fn to_json() -> Json { Null } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1111 | } |
| 1112 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1113 | impl bool: ToJson { |
| 1114 | fn to_json() -> Json { Boolean(self) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1115 | } |
| 1116 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1117 | impl ~str: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1118 | fn to_json() -> Json { String(copy self) } |
Erick Tryzelaar | b361f6c | 2012-06-13 00:20:51 | [diff] [blame] | 1119 | } |
| 1120 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1121 | impl @~str: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1122 | fn to_json() -> Json { String(copy *self) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1123 | } |
| 1124 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1125 | impl <A: ToJson, B: ToJson> (A, B): ToJson { |
| 1126 | fn to_json() -> Json { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 1127 | match self { |
Brian Anderson | bc9efaa | 2012-09-28 07:22:18 | [diff] [blame] | 1128 | (ref a, ref b) => { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1129 | List(~[a.to_json(), b.to_json()]) |
Niko Matsakis | 97452c0 | 2012-08-02 22:42:56 | [diff] [blame] | 1130 | } |
| 1131 | } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1132 | } |
| 1133 | } |
| 1134 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1135 | impl <A: ToJson, B: ToJson, C: ToJson> (A, B, C): ToJson { |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1136 | fn to_json() -> Json { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 1137 | match self { |
Brian Anderson | bc9efaa | 2012-09-28 07:22:18 | [diff] [blame] | 1138 | (ref a, ref b, ref c) => { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1139 | List(~[a.to_json(), b.to_json(), c.to_json()]) |
Niko Matsakis | 97452c0 | 2012-08-02 22:42:56 | [diff] [blame] | 1140 | } |
| 1141 | } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1142 | } |
| 1143 | } |
| 1144 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1145 | impl <A: ToJson> ~[A]: ToJson { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1146 | fn to_json() -> Json { List(self.map(|elt| elt.to_json())) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1147 | } |
| 1148 | |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 1149 | impl <A: ToJson Copy> LinearMap<~str, A>: ToJson { |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1150 | fn to_json() -> Json { |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 1151 | let mut d = LinearMap::new(); |
Daniel Micay | 9599cc8 | 2013-02-08 02:03:13 | [diff] [blame] | 1152 | for self.each |&(key, value)| { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1153 | d.insert(copy *key, value.to_json()); |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1154 | } |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1155 | Object(~d) |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1156 | } |
| 1157 | } |
| 1158 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1159 | impl <A: ToJson> Option<A>: ToJson { |
| 1160 | fn to_json() -> Json { |
Brian Anderson | ecaf9e3 | 2012-08-06 19:34:08 | [diff] [blame] | 1161 | match self { |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1162 | None => Null, |
Brian Anderson | bc9efaa | 2012-09-28 07:22:18 | [diff] [blame] | 1163 | Some(ref value) => value.to_json() |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1164 | } |
| 1165 | } |
| 1166 | } |
| 1167 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1168 | impl Json: to_str::ToStr { |
Erick Tryzelaar | 9adfa59 | 2013-02-04 04:47:26 | [diff] [blame] | 1169 | pure fn to_str(&self) -> ~str { to_str(self) } |
Erick Tryzelaar | ed5af70 | 2012-05-28 19:10:32 | [diff] [blame] | 1170 | } |
| 1171 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1172 | impl Error: to_str::ToStr { |
Erick Tryzelaar | 9adfa59 | 2013-02-04 04:47:26 | [diff] [blame] | 1173 | pure fn to_str(&self) -> ~str { |
Paul Stansifer | 29f32b4 | 2012-08-23 00:24:52 | [diff] [blame] | 1174 | fmt!("%u:%u: %s", self.line, self.col, *self.msg) |
Erick Tryzelaar | a816176 | 2012-06-11 15:32:38 | [diff] [blame] | 1175 | } |
| 1176 | } |
| 1177 | |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1178 | #[cfg(test)] |
| 1179 | mod tests { |
Patrick Walton | 2db3abd | 2013-01-09 03:37:25 | [diff] [blame] | 1180 | use core::prelude::*; |
| 1181 | |
| 1182 | use json::*; |
| 1183 | |
Patrick Walton | fa5ee93 | 2012-12-28 02:24:18 | [diff] [blame] | 1184 | use core::result; |
Daniel Micay | 7f0fa14 | 2013-01-23 22:06:32 | [diff] [blame] | 1185 | use core::hashmap::linear::LinearMap; |
John Clements | f91160b | 2013-02-08 01:06:26 | [diff] [blame^] | 1186 | use core::cmp; |
| 1187 | |
Patrick Walton | fa5ee93 | 2012-12-28 02:24:18 | [diff] [blame] | 1188 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1189 | fn mk_object(items: &[(~str, Json)]) -> Json { |
Daniel Micay | bba5520 | 2013-01-24 02:09:50 | [diff] [blame] | 1190 | let mut d = ~LinearMap::new(); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1191 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1192 | for items.each |item| { |
| 1193 | match *item { |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 1194 | (copy key, copy value) => { d.insert(key, move value); }, |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1195 | } |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1196 | }; |
| 1197 | |
Tim Chevalier | 90d06b8 | 2012-09-19 05:35:42 | [diff] [blame] | 1198 | Object(move d) |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1199 | } |
| 1200 | |
| 1201 | #[test] |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1202 | fn test_write_null() { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1203 | assert to_str(&Null) == ~"null"; |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1204 | } |
| 1205 | |
| 1206 | #[test] |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1207 | fn test_write_number() { |
| 1208 | assert to_str(&Number(3f)) == ~"3"; |
| 1209 | assert to_str(&Number(3.1f)) == ~"3.1"; |
| 1210 | assert to_str(&Number(-1.5f)) == ~"-1.5"; |
| 1211 | assert to_str(&Number(0.5f)) == ~"0.5"; |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1212 | } |
| 1213 | |
| 1214 | #[test] |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1215 | fn test_write_str() { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1216 | assert to_str(&String(~"")) == ~"\"\""; |
| 1217 | assert to_str(&String(~"foo")) == ~"\"foo\""; |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1218 | } |
| 1219 | |
| 1220 | #[test] |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1221 | fn test_write_bool() { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1222 | assert to_str(&Boolean(true)) == ~"true"; |
| 1223 | assert to_str(&Boolean(false)) == ~"false"; |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1224 | } |
| 1225 | |
| 1226 | #[test] |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1227 | fn test_write_list() { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1228 | assert to_str(&List(~[])) == ~"[]"; |
| 1229 | assert to_str(&List(~[Boolean(true)])) == ~"[true]"; |
| 1230 | assert to_str(&List(~[ |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1231 | Boolean(false), |
| 1232 | Null, |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1233 | List(~[String(~"foo\nbar"), Number(3.5f)]) |
| 1234 | ])) == ~"[false,null,[\"foo\\nbar\",3.5]]"; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1235 | } |
| 1236 | |
| 1237 | #[test] |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1238 | fn test_write_object() { |
| 1239 | assert to_str(&mk_object(~[])) == ~"{}"; |
| 1240 | assert to_str(&mk_object(~[(~"a", Boolean(true))])) |
| 1241 | == ~"{\"a\":true}"; |
| 1242 | let a = mk_object(~[ |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1243 | (~"a", Boolean(true)), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1244 | (~"b", List(~[ |
| 1245 | mk_object(~[(~"c", String(~"\x0c\r"))]), |
| 1246 | mk_object(~[(~"d", String(~""))]) |
Michael Sullivan | 98e161f | 2012-06-29 23:26:56 | [diff] [blame] | 1247 | ])) |
Graydon Hoare | 11871b8 | 2012-08-30 23:27:15 | [diff] [blame] | 1248 | ]); |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1249 | // We can't compare the strings directly because the object fields be |
| 1250 | // printed in a different order. |
| 1251 | let b = result::unwrap(from_str(to_str(&a))); |
Graydon Hoare | 11871b8 | 2012-08-30 23:27:15 | [diff] [blame] | 1252 | assert a == b; |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1253 | } |
| 1254 | |
John Clements | f91160b | 2013-02-08 01:06:26 | [diff] [blame^] | 1255 | // two fns copied from libsyntax/util/testing.rs. |
| 1256 | // Should they be in their own crate? |
| 1257 | pub pure fn check_equal_ptr<T : cmp::Eq> (given : &T, expected: &T) { |
| 1258 | if !((given == expected) && (expected == given )) { |
| 1259 | die!(fmt!("given %?, expected %?",given,expected)); |
| 1260 | } |
| 1261 | } |
| 1262 | |
| 1263 | pub pure fn check_equal<T : cmp::Eq> (given : T, expected: T) { |
| 1264 | if !((given == expected) && (expected == given )) { |
| 1265 | die!(fmt!("given %?, expected %?",given,expected)); |
| 1266 | } |
| 1267 | } |
| 1268 | |
| 1269 | // testing both auto_encode's calling patterns |
| 1270 | // and json... not sure where to put these tests. |
| 1271 | #[test] |
| 1272 | fn test_write_enum () { |
| 1273 | let bw = @io::BytesWriter {bytes: dvec::DVec(), pos: 0}; |
| 1274 | let bww : @io::Writer = (bw as @io::Writer); |
| 1275 | let encoder = (@Encoder(bww) as @serialize::Encoder); |
| 1276 | do encoder.emit_enum(~"animal") { |
| 1277 | do encoder.emit_enum_variant (~"frog",37,1242) { |
| 1278 | // name of frog: |
| 1279 | do encoder.emit_enum_variant_arg (0) { |
| 1280 | encoder.emit_owned_str(~"Henry") |
| 1281 | } |
| 1282 | // mass of frog in grams: |
| 1283 | do encoder.emit_enum_variant_arg (1) { |
| 1284 | encoder.emit_int(349); |
| 1285 | } |
| 1286 | } |
| 1287 | } |
| 1288 | check_equal(str::from_bytes(bw.bytes.data), |
| 1289 | ~"[\"frog\",\"Henry\",349]"); |
| 1290 | } |
| 1291 | |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1292 | #[test] |
| 1293 | fn test_trailing_characters() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1294 | assert from_str(~"nulla") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1295 | Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1296 | assert from_str(~"truea") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1297 | Err(Error {line: 1u, col: 5u, msg: @~"trailing characters"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1298 | assert from_str(~"falsea") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1299 | Err(Error {line: 1u, col: 6u, msg: @~"trailing characters"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1300 | assert from_str(~"1a") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1301 | Err(Error {line: 1u, col: 2u, msg: @~"trailing characters"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1302 | assert from_str(~"[]a") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1303 | Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1304 | assert from_str(~"{}a") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1305 | Err(Error {line: 1u, col: 3u, msg: @~"trailing characters"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1306 | } |
| 1307 | |
| 1308 | #[test] |
| 1309 | fn test_read_identifiers() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1310 | assert from_str(~"n") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1311 | Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1312 | assert from_str(~"nul") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1313 | Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1314 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1315 | assert from_str(~"t") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1316 | Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1317 | assert from_str(~"truz") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1318 | Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1319 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1320 | assert from_str(~"f") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1321 | Err(Error {line: 1u, col: 2u, msg: @~"invalid syntax"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1322 | assert from_str(~"faz") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1323 | Err(Error {line: 1u, col: 3u, msg: @~"invalid syntax"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1324 | |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1325 | assert from_str(~"null") == Ok(Null); |
| 1326 | assert from_str(~"true") == Ok(Boolean(true)); |
| 1327 | assert from_str(~"false") == Ok(Boolean(false)); |
| 1328 | assert from_str(~" null ") == Ok(Null); |
| 1329 | assert from_str(~" true ") == Ok(Boolean(true)); |
| 1330 | assert from_str(~" false ") == Ok(Boolean(false)); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1331 | } |
| 1332 | |
| 1333 | #[test] |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1334 | fn test_read_number() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1335 | assert from_str(~"+") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1336 | Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1337 | assert from_str(~".") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1338 | Err(Error {line: 1u, col: 1u, msg: @~"invalid syntax"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1339 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1340 | assert from_str(~"-") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1341 | Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1342 | assert from_str(~"00") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1343 | Err(Error {line: 1u, col: 2u, msg: @~"invalid number"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1344 | assert from_str(~"1.") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1345 | Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1346 | assert from_str(~"1e") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1347 | Err(Error {line: 1u, col: 3u, msg: @~"invalid number"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1348 | assert from_str(~"1e+") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1349 | Err(Error {line: 1u, col: 4u, msg: @~"invalid number"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1350 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1351 | assert from_str(~"3") == Ok(Number(3f)); |
| 1352 | assert from_str(~"3.1") == Ok(Number(3.1f)); |
| 1353 | assert from_str(~"-1.2") == Ok(Number(-1.2f)); |
| 1354 | assert from_str(~"0.4") == Ok(Number(0.4f)); |
| 1355 | assert from_str(~"0.4e5") == Ok(Number(0.4e5f)); |
| 1356 | assert from_str(~"0.4e+15") == Ok(Number(0.4e15f)); |
| 1357 | assert from_str(~"0.4e-01") == Ok(Number(0.4e-01f)); |
| 1358 | assert from_str(~" 3 ") == Ok(Number(3f)); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1359 | } |
| 1360 | |
| 1361 | #[test] |
| 1362 | fn test_read_str() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1363 | assert from_str(~"\"") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1364 | Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing string"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1365 | assert from_str(~"\"lol") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1366 | Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing string"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1367 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1368 | assert from_str(~"\"\"") == Ok(String(~"")); |
| 1369 | assert from_str(~"\"foo\"") == Ok(String(~"foo")); |
| 1370 | assert from_str(~"\"\\\"\"") == Ok(String(~"\"")); |
| 1371 | assert from_str(~"\"\\b\"") == Ok(String(~"\x08")); |
| 1372 | assert from_str(~"\"\\n\"") == Ok(String(~"\n")); |
| 1373 | assert from_str(~"\"\\r\"") == Ok(String(~"\r")); |
| 1374 | assert from_str(~"\"\\t\"") == Ok(String(~"\t")); |
| 1375 | assert from_str(~" \"foo\" ") == Ok(String(~"foo")); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1376 | } |
| 1377 | |
| 1378 | #[test] |
Kevin Cantu | cf38618 | 2012-08-31 04:03:19 | [diff] [blame] | 1379 | fn test_unicode_hex_escapes_in_str() { |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1380 | assert from_str(~"\"\\u12ab\"") == Ok(String(~"\u12ab")); |
| 1381 | assert from_str(~"\"\\uAB12\"") == Ok(String(~"\uAB12")); |
Kevin Cantu | cf38618 | 2012-08-31 04:03:19 | [diff] [blame] | 1382 | } |
| 1383 | |
| 1384 | #[test] |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1385 | fn test_read_list() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1386 | assert from_str(~"[") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1387 | Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing value"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1388 | assert from_str(~"[1") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1389 | Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing list"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1390 | assert from_str(~"[1,") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1391 | Err(Error {line: 1u, col: 4u, msg: @~"EOF while parsing value"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1392 | assert from_str(~"[1,]") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1393 | Err(Error {line: 1u, col: 4u, msg: @~"invalid syntax"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1394 | assert from_str(~"[6 7]") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1395 | Err(Error {line: 1u, col: 4u, msg: @~"expected `,` or `]`"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1396 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1397 | assert from_str(~"[]") == Ok(List(~[])); |
| 1398 | assert from_str(~"[ ]") == Ok(List(~[])); |
| 1399 | assert from_str(~"[true]") == Ok(List(~[Boolean(true)])); |
| 1400 | assert from_str(~"[ false ]") == Ok(List(~[Boolean(false)])); |
| 1401 | assert from_str(~"[null]") == Ok(List(~[Null])); |
| 1402 | assert from_str(~"[3, 1]") == Ok(List(~[Number(3f), Number(1f)])); |
| 1403 | assert from_str(~"\n[3, 2]\n") == Ok(List(~[Number(3f), Number(2f)])); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1404 | assert from_str(~"[2, [4, 1]]") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1405 | Ok(List(~[Number(2f), List(~[Number(4f), Number(1f)])])); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1406 | } |
| 1407 | |
| 1408 | #[test] |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1409 | fn test_read_object() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1410 | assert from_str(~"{") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1411 | Err(Error {line: 1u, col: 2u, msg: @~"EOF while parsing object"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1412 | assert from_str(~"{ ") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1413 | Err(Error {line: 1u, col: 3u, msg: @~"EOF while parsing object"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1414 | assert from_str(~"{1") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1415 | Err(Error {line: 1u, col: 2u, msg: @~"key must be a string"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1416 | assert from_str(~"{ \"a\"") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1417 | Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing object"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1418 | assert from_str(~"{\"a\"") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1419 | Err(Error {line: 1u, col: 5u, msg: @~"EOF while parsing object"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1420 | assert from_str(~"{\"a\" ") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1421 | Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing object"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1422 | |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1423 | assert from_str(~"{\"a\" 1") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1424 | Err(Error {line: 1u, col: 6u, msg: @~"expected `:`"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1425 | assert from_str(~"{\"a\":") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1426 | Err(Error {line: 1u, col: 6u, msg: @~"EOF while parsing value"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1427 | assert from_str(~"{\"a\":1") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1428 | Err(Error {line: 1u, col: 7u, msg: @~"EOF while parsing object"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1429 | assert from_str(~"{\"a\":1 1") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1430 | Err(Error {line: 1u, col: 8u, msg: @~"expected `,` or `}`"}); |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1431 | assert from_str(~"{\"a\":1,") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1432 | Err(Error {line: 1u, col: 8u, msg: @~"EOF while parsing object"}); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1433 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1434 | assert result::unwrap(from_str(~"{}")) == mk_object(~[]); |
| 1435 | assert result::unwrap(from_str(~"{\"a\": 3}")) == |
| 1436 | mk_object(~[(~"a", Number(3.0f))]); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1437 | |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1438 | assert result::unwrap(from_str(~"{ \"a\": null, \"b\" : true }")) == |
| 1439 | mk_object(~[ |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1440 | (~"a", Null), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1441 | (~"b", Boolean(true))]); |
| 1442 | assert result::unwrap( |
| 1443 | from_str(~"\n{ \"a\": null, \"b\" : true }\n")) == |
| 1444 | mk_object(~[ |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1445 | (~"a", Null), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1446 | (~"b", Boolean(true))]); |
| 1447 | assert result::unwrap(from_str(~"{\"a\" : 1.0 ,\"b\": [ true ]}")) == |
| 1448 | mk_object(~[ |
| 1449 | (~"a", Number(1.0)), |
| 1450 | (~"b", List(~[Boolean(true)])) |
| 1451 | ]); |
| 1452 | assert result::unwrap(from_str( |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1453 | ~"{" + |
| 1454 | ~"\"a\": 1.0, " + |
| 1455 | ~"\"b\": [" + |
| 1456 | ~"true," + |
| 1457 | ~"\"foo\\nbar\", " + |
| 1458 | ~"{ \"c\": {\"d\": null} } " + |
| 1459 | ~"]" + |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1460 | ~"}")) == |
| 1461 | mk_object(~[ |
| 1462 | (~"a", Number(1.0f)), |
| 1463 | (~"b", List(~[ |
Ben Striegel | a605fd0 | 2012-08-11 14:08:42 | [diff] [blame] | 1464 | Boolean(true), |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1465 | String(~"foo\nbar"), |
| 1466 | mk_object(~[ |
| 1467 | (~"c", mk_object(~[(~"d", Null)])) |
Michael Sullivan | 98e161f | 2012-06-29 23:26:56 | [diff] [blame] | 1468 | ]) |
| 1469 | ])) |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1470 | ]); |
Erick Tryzelaar | 012dec5 | 2012-02-26 00:39:32 | [diff] [blame] | 1471 | } |
| 1472 | |
| 1473 | #[test] |
| 1474 | fn test_multiline_errors() { |
Michael Sullivan | 92743dc | 2012-07-14 05:57:48 | [diff] [blame] | 1475 | assert from_str(~"{\n \"foo\":\n \"bar\"") == |
Erick Tryzelaar | 49d00b2 | 2012-09-24 16:55:42 | [diff] [blame] | 1476 | Err(Error {line: 3u, col: 8u, msg: @~"EOF while parsing object"}); |
Brian Anderson | 6e27b27 | 2012-01-18 03:05:07 | [diff] [blame] | 1477 | } |
| 1478 | } |