use std::collections::BTreeMap;
use std::fmt;
use crate::error::{Error, Result};
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum Json {
Null,
Bool(bool),
Int(i64),
Float(f64),
String(String),
Array(Vec<Json>),
Object(BTreeMap<String, Json>),
}
impl Json {
pub fn object<K: Into<String>>(pairs: Vec<(K, Json)>) -> Json {
let mut map = BTreeMap::new();
for (k, v) in pairs {
map.insert(k.into(), v);
}
Json::Object(map)
}
pub fn is_null(&self) -> bool {
matches!(self, Json::Null)
}
pub fn get(&self, key: &str) -> Option<&Json> {
match self {
Json::Object(map) => map.get(key),
_ => None,
}
}
pub fn as_str(&self) -> Option<&str> {
match self {
Json::String(s) => Some(s),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match self {
Json::Float(n) => Some(*n),
Json::Int(i) => Some(*i as f64),
_ => None,
}
}
pub fn as_i64(&self) -> Option<i64> {
match self {
Json::Int(i) => Some(*i),
Json::Float(n) if n.fract() == 0.0 && *n >= i64::MIN as f64 && *n < i64::MAX as f64 => {
Some(*n as i64)
}
_ => None,
}
}
pub fn as_bool(&self) -> Option<bool> {
match self {
Json::Bool(b) => Some(*b),
_ => None,
}
}
pub fn as_array(&self) -> Option<&[Json]> {
match self {
Json::Array(v) => Some(v),
_ => None,
}
}
pub fn as_object(&self) -> Option<&BTreeMap<String, Json>> {
match self {
Json::Object(m) => Some(m),
_ => None,
}
}
pub fn parse(input: &str) -> Result<Json> {
let mut p = Parser {
bytes: input.as_bytes(),
pos: 0,
depth: 0,
};
p.skip_whitespace();
let value = p.value()?;
p.skip_whitespace();
if p.pos != p.bytes.len() {
return Err(Error::Json(format!(
"unexpected trailing input at byte {}",
p.pos
)));
}
Ok(value)
}
}
impl fmt::Display for Json {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Json::Null => f.write_str("null"),
Json::Bool(true) => f.write_str("true"),
Json::Bool(false) => f.write_str("false"),
Json::Int(i) => write!(f, "{i}"),
Json::Float(n) => write_float(f, *n),
Json::String(s) => write_escaped(f, s),
Json::Array(items) => {
f.write_str("[")?;
for (i, item) in items.iter().enumerate() {
if i > 0 {
f.write_str(",")?;
}
write!(f, "{item}")?;
}
f.write_str("]")
}
Json::Object(map) => {
f.write_str("{")?;
for (i, (k, v)) in map.iter().enumerate() {
if i > 0 {
f.write_str(",")?;
}
write_escaped(f, k)?;
f.write_str(":")?;
write!(f, "{v}")?;
}
f.write_str("}")
}
}
}
}
fn write_float(f: &mut fmt::Formatter<'_>, n: f64) -> fmt::Result {
if !n.is_finite() {
return f.write_str("null");
}
let text = n.to_string();
f.write_str(&text)?;
if !text.contains(['.', 'e', 'E']) {
f.write_str(".0")?;
}
Ok(())
}
fn write_escaped(f: &mut fmt::Formatter<'_>, s: &str) -> fmt::Result {
f.write_str("\"")?;
for ch in s.chars() {
match ch {
'"' => f.write_str("\\\"")?,
'\\' => f.write_str("\\\\")?,
'\n' => f.write_str("\\n")?,
'\r' => f.write_str("\\r")?,
'\t' => f.write_str("\\t")?,
'\u{08}' => f.write_str("\\b")?,
'\u{0c}' => f.write_str("\\f")?,
c if (c as u32) < 0x20 => write!(f, "\\u{:04x}", c as u32)?,
c => write!(f, "{c}")?,
}
}
f.write_str("\"")
}
impl From<&str> for Json {
fn from(v: &str) -> Json {
Json::String(v.to_string())
}
}
impl From<String> for Json {
fn from(v: String) -> Json {
Json::String(v)
}
}
impl From<bool> for Json {
fn from(v: bool) -> Json {
Json::Bool(v)
}
}
impl From<f64> for Json {
fn from(v: f64) -> Json {
Json::Float(v)
}
}
impl From<i64> for Json {
fn from(v: i64) -> Json {
Json::Int(v)
}
}
impl From<usize> for Json {
fn from(v: usize) -> Json {
match i64::try_from(v) {
Ok(i) => Json::Int(i),
Err(_) => Json::Float(v as f64),
}
}
}
impl From<Vec<Json>> for Json {
fn from(v: Vec<Json>) -> Json {
Json::Array(v)
}
}
const MAX_DEPTH: usize = 128;
struct Parser<'a> {
bytes: &'a [u8],
pos: usize,
depth: usize,
}
impl<'a> Parser<'a> {
fn err<T>(&self, msg: &str) -> Result<T> {
Err(Error::Json(format!("{msg} at byte {}", self.pos)))
}
fn peek(&self) -> Option<u8> {
self.bytes.get(self.pos).copied()
}
fn skip_whitespace(&mut self) {
while let Some(b) = self.peek() {
if b == b' ' || b == b'\t' || b == b'\n' || b == b'\r' {
self.pos += 1;
} else {
break;
}
}
}
fn expect(&mut self, b: u8) -> Result<()> {
if self.peek() == Some(b) {
self.pos += 1;
Ok(())
} else {
self.err(&format!("expected '{}'", b as char))
}
}
fn value(&mut self) -> Result<Json> {
if self.depth > MAX_DEPTH {
return self.err("nesting too deep");
}
match self.peek() {
None => self.err("unexpected end of input"),
Some(b'n') => self.literal("null", Json::Null),
Some(b't') => self.literal("true", Json::Bool(true)),
Some(b'f') => self.literal("false", Json::Bool(false)),
Some(b'"') => Ok(Json::String(self.string()?)),
Some(b'[') => self.array(),
Some(b'{') => self.object(),
Some(_) => self.number(),
}
}
fn literal(&mut self, word: &str, value: Json) -> Result<Json> {
if self.bytes[self.pos..].starts_with(word.as_bytes()) {
self.pos += word.len();
Ok(value)
} else {
self.err("invalid literal")
}
}
fn string(&mut self) -> Result<String> {
self.expect(b'"')?;
let mut out = String::new();
loop {
let b = match self.peek() {
Some(b) => b,
None => return self.err("unterminated string"),
};
self.pos += 1;
match b {
b'"' => return Ok(out),
b'\\' => {
let esc = match self.peek() {
Some(e) => e,
None => return self.err("unterminated escape"),
};
self.pos += 1;
match esc {
b'"' => out.push('"'),
b'\\' => out.push('\\'),
b'/' => out.push('/'),
b'b' => out.push('\u{08}'),
b'f' => out.push('\u{0c}'),
b'n' => out.push('\n'),
b'r' => out.push('\r'),
b't' => out.push('\t'),
b'u' => out.push(self.unicode_escape()?),
_ => return self.err("invalid escape"),
}
}
0x00..=0x1f => return self.err("unescaped control character"),
_ => {
let start = self.pos - 1;
let len = utf8_len(b);
if start + len > self.bytes.len() {
return self.err("truncated utf-8 sequence");
}
self.pos = start + len;
match std::str::from_utf8(&self.bytes[start..self.pos]) {
Ok(s) => out.push_str(s),
Err(_) => return self.err("invalid utf-8"),
}
}
}
}
}
fn unicode_escape(&mut self) -> Result<char> {
let high = self.hex4()?;
if (0xD800..0xDC00).contains(&high) {
if self.peek() != Some(b'\\') {
return self.err("expected a low surrogate");
}
self.pos += 1;
if self.peek() != Some(b'u') {
return self.err("expected a low surrogate");
}
self.pos += 1;
let low = self.hex4()?;
if !(0xDC00..0xE000).contains(&low) {
return self.err("invalid low surrogate");
}
let combined = 0x10000 + ((high - 0xD800) << 10) + (low - 0xDC00);
return match char::from_u32(combined) {
Some(c) => Ok(c),
None => self.err("invalid code point"),
};
}
match char::from_u32(high) {
Some(c) => Ok(c),
None => self.err("invalid code point"),
}
}
fn hex4(&mut self) -> Result<u32> {
if self.pos + 4 > self.bytes.len() {
return self.err("truncated \\u escape");
}
let slice = &self.bytes[self.pos..self.pos + 4];
let text = match std::str::from_utf8(slice) {
Ok(t) => t,
Err(_) => return self.err("invalid \\u escape"),
};
match u32::from_str_radix(text, 16) {
Ok(v) => {
self.pos += 4;
Ok(v)
}
Err(_) => self.err("invalid \\u escape"),
}
}
fn number(&mut self) -> Result<Json> {
let start = self.pos;
if self.peek() == Some(b'-') {
self.pos += 1;
}
while let Some(b) = self.peek() {
if b.is_ascii_digit() || b == b'.' || b == b'e' || b == b'E' || b == b'+' || b == b'-' {
self.pos += 1;
} else {
break;
}
}
if start == self.pos {
return self.err("expected a value");
}
let text = match std::str::from_utf8(&self.bytes[start..self.pos]) {
Ok(t) => t,
Err(_) => return self.err("invalid number"),
};
if !text.contains(['.', 'e', 'E']) {
if let Ok(i) = text.parse::<i64>() {
return Ok(Json::Int(i));
}
}
match text.parse::<f64>() {
Ok(n) => Ok(Json::Float(n)),
Err(_) => self.err("invalid number"),
}
}
fn array(&mut self) -> Result<Json> {
self.expect(b'[')?;
self.depth += 1;
let mut items = Vec::new();
self.skip_whitespace();
if self.peek() == Some(b']') {
self.pos += 1;
self.depth -= 1;
return Ok(Json::Array(items));
}
loop {
self.skip_whitespace();
items.push(self.value()?);
self.skip_whitespace();
match self.peek() {
Some(b',') => self.pos += 1,
Some(b']') => {
self.pos += 1;
self.depth -= 1;
return Ok(Json::Array(items));
}
_ => return self.err("expected ',' or ']'"),
}
}
}
fn object(&mut self) -> Result<Json> {
self.expect(b'{')?;
self.depth += 1;
let mut map = BTreeMap::new();
self.skip_whitespace();
if self.peek() == Some(b'}') {
self.pos += 1;
self.depth -= 1;
return Ok(Json::Object(map));
}
loop {
self.skip_whitespace();
let key = self.string()?;
self.skip_whitespace();
self.expect(b':')?;
self.skip_whitespace();
let value = self.value()?;
map.insert(key, value);
self.skip_whitespace();
match self.peek() {
Some(b',') => self.pos += 1,
Some(b'}') => {
self.pos += 1;
self.depth -= 1;
return Ok(Json::Object(map));
}
_ => return self.err("expected ',' or '}'"),
}
}
}
}
fn utf8_len(first: u8) -> usize {
if first < 0x80 {
1
} else if first >> 5 == 0b110 {
2
} else if first >> 4 == 0b1110 {
3
} else {
4
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn round_trips_scalars() {
for src in [
"null",
"true",
"false",
"42",
"-1.5",
"1.0",
"9223372036854775807",
"-9223372036854775808",
"\"hi\"",
] {
let v = Json::parse(src).unwrap();
assert_eq!(Json::parse(&v.to_string()).unwrap(), v, "for {src}");
}
}
#[test]
fn large_integers_keep_every_digit() {
for n in [9_007_199_254_740_993i64, i64::MAX, i64::MIN] {
let value = Json::from(n);
assert_eq!(value.as_i64(), Some(n));
let text = value.to_string();
assert_eq!(text, n.to_string());
assert_eq!(Json::parse(&text).unwrap().as_i64(), Some(n));
}
}
#[test]
fn integers_and_floats_are_separate_values() {
assert_eq!(Json::parse("1").unwrap(), Json::Int(1));
assert_eq!(Json::parse("1.0").unwrap(), Json::Float(1.0));
assert_ne!(Json::from(1i64), Json::from(1.0));
assert_eq!(Json::Float(1.0).to_string(), "1.0");
assert_eq!(Json::Float(-0.0).to_string(), "-0.0");
assert_eq!(Json::Int(1).to_string(), "1");
assert_eq!(Json::parse("1e2").unwrap(), Json::Float(100.0));
assert_eq!(Json::parse("1e2").unwrap().to_string(), "100.0");
}
#[test]
fn a_float_that_is_a_whole_number_still_reads_as_an_integer() {
assert_eq!(Json::parse("3.0").unwrap().as_i64(), Some(3));
assert_eq!(Json::parse("3.5").unwrap().as_i64(), None);
assert_eq!(Json::parse("1e30").unwrap().as_i64(), None);
assert_eq!(Json::parse("3").unwrap().as_f64(), Some(3.0));
}
#[test]
fn an_integer_too_large_for_i64_becomes_a_float() {
let value = Json::parse("18446744073709551616").unwrap();
assert!(matches!(value, Json::Float(_)));
assert_eq!(value.as_i64(), None);
}
#[test]
fn parses_nested_structures() {
let v = Json::parse(r#"{"a":[1,2,{"b":null}],"c":true}"#).unwrap();
assert_eq!(v.get("c").and_then(Json::as_bool), Some(true));
let a = v.get("a").and_then(Json::as_array).unwrap();
assert_eq!(a.len(), 3);
assert!(a[2].get("b").unwrap().is_null());
}
#[test]
fn object_output_is_deterministic() {
let src = r#"{"z":1,"a":2,"m":3}"#;
let once = Json::parse(src).unwrap().to_string();
for _ in 0..50 {
assert_eq!(Json::parse(src).unwrap().to_string(), once);
}
assert_eq!(once, r#"{"a":2,"m":3,"z":1}"#);
}
#[test]
fn escapes_and_unescapes() {
let v = Json::String("quote \" back \\ newline \n tab \t".into());
let text = v.to_string();
assert!(text.contains("\\\""));
assert!(text.contains("\\n"));
assert_eq!(Json::parse(&text).unwrap(), v);
}
#[test]
fn handles_surrogate_pairs() {
let v = Json::parse(r#""🚀""#).unwrap();
assert_eq!(v.as_str(), Some("🚀"));
}
#[test]
fn rejects_malformed_input() {
for src in [
"",
"{",
"[1,]",
"{\"a\":}",
"tru",
"\"unterminated",
"{\"a\":1} trailing",
"01x",
] {
assert!(Json::parse(src).is_err(), "expected {src:?} to fail");
}
}
#[test]
fn rejects_runaway_nesting() {
let deep = format!("{}1{}", "[".repeat(500), "]".repeat(500));
assert!(Json::parse(&deep).is_err());
}
#[test]
fn non_finite_numbers_serialise_as_null() {
assert_eq!(Json::Float(f64::NAN).to_string(), "null");
assert_eq!(Json::Float(f64::INFINITY).to_string(), "null");
}
}