use std::fmt;
use serde::de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
use serde::ser::{Serialize, SerializeMap, Serializer};
#[derive(Debug, Clone, PartialEq)]
pub(crate) enum Json {
Null,
Bool(bool),
Number(serde_json::Number),
String(String),
Array(Vec<Json>),
Object(Vec<(String, Json)>),
}
impl Json {
pub(crate) fn object<K: Into<String>>(entries: impl IntoIterator<Item = (K, Json)>) -> Json {
Json::Object(entries.into_iter().map(|(k, v)| (k.into(), v)).collect())
}
pub(crate) fn as_str(&self) -> Option<&str> {
match self {
Json::String(s) => Some(s),
_ => None,
}
}
pub(crate) fn get(&self, key: &str) -> Option<&Json> {
match self {
Json::Object(entries) => entries.iter().rev().find(|(k, _)| k == key).map(|(_, v)| v),
_ => None,
}
}
pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut Json> {
match self {
Json::Object(entries) => entries
.iter_mut()
.rev()
.find(|(k, _)| k == key)
.map(|(_, v)| v),
_ => None,
}
}
pub(crate) fn entry(&mut self, key: &str, default: impl FnOnce() -> Json) -> Option<&mut Json> {
let Json::Object(entries) = self else {
return None;
};
let at = match entries.iter().rposition(|(k, _)| k == key) {
Some(at) => at,
None => {
entries.push((key.to_string(), default()));
entries.len() - 1
}
};
Some(&mut entries[at].1)
}
}
impl From<&str> for Json {
fn from(s: &str) -> Self {
Json::String(s.to_string())
}
}
impl From<u64> for Json {
fn from(n: u64) -> Self {
Json::Number(n.into())
}
}
impl Serialize for Json {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
match self {
Json::Null => serializer.serialize_unit(),
Json::Bool(b) => serializer.serialize_bool(*b),
Json::Number(n) => n.serialize(serializer),
Json::String(s) => serializer.serialize_str(s),
Json::Array(items) => serializer.collect_seq(items),
Json::Object(entries) => {
let mut map = serializer.serialize_map(Some(entries.len()))?;
for (key, value) in entries {
map.serialize_entry(key, value)?;
}
map.end()
}
}
}
}
impl<'de> Deserialize<'de> for Json {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
deserializer.deserialize_any(JsonVisitor)
}
}
struct JsonVisitor;
impl<'de> Visitor<'de> for JsonVisitor {
type Value = Json;
fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.write_str("any JSON value")
}
fn visit_unit<E>(self) -> Result<Json, E> {
Ok(Json::Null)
}
fn visit_bool<E>(self, b: bool) -> Result<Json, E> {
Ok(Json::Bool(b))
}
fn visit_i64<E>(self, n: i64) -> Result<Json, E> {
Ok(Json::Number(n.into()))
}
fn visit_u64<E>(self, n: u64) -> Result<Json, E> {
Ok(Json::Number(n.into()))
}
fn visit_f64<E: de::Error>(self, n: f64) -> Result<Json, E> {
serde_json::Number::from_f64(n)
.map(Json::Number)
.ok_or_else(|| E::custom("a JSON number must be finite"))
}
fn visit_str<E>(self, s: &str) -> Result<Json, E> {
Ok(Json::String(s.to_string()))
}
fn visit_string<E>(self, s: String) -> Result<Json, E> {
Ok(Json::String(s))
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Json, A::Error> {
let mut items = Vec::new();
while let Some(item) = seq.next_element()? {
items.push(item);
}
Ok(Json::Array(items))
}
fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Json, A::Error> {
let mut entries = Vec::new();
while let Some((key, value)) = map.next_entry::<String, Json>()? {
entries.push((key, value));
}
Ok(Json::Object(entries))
}
}
#[cfg(test)]
mod tests {
use super::*;
const TEXT: &str = r#"{
"zeta": 1,
"alpha": {
"mid": [
true,
null,
-2,
1.5,
"s"
],
"beta": {}
},
"empty": []
}"#;
#[test]
fn a_pretty_file_round_trips_byte_for_byte_in_key_order() {
let doc: Json = serde_json::from_str(TEXT).unwrap();
assert_eq!(serde_json::to_string_pretty(&doc).unwrap(), TEXT);
}
#[test]
fn entry_appends_a_missing_key_at_the_end_and_keeps_an_existing_one() {
let mut doc: Json = serde_json::from_str(TEXT).unwrap();
*doc.entry("new", || Json::Null).unwrap() = Json::from(7);
assert_eq!(doc.entry("zeta", || Json::Null).unwrap(), &Json::from(1));
let Json::Object(entries) = &doc else {
panic!("{doc:?}")
};
let keys: Vec<&str> = entries.iter().map(|(k, _)| k.as_str()).collect();
assert_eq!(keys, ["zeta", "alpha", "empty", "new"]);
assert_eq!(doc.get("new"), Some(&Json::from(7)));
}
#[test]
fn entry_on_a_non_object_is_none() {
assert!(Json::Array(vec![]).entry("k", || Json::Null).is_none());
}
}