use std::fmt;
use serde::de::{self, Deserialize, Deserializer, MapAccess, SeqAccess, Visitor};
use crate::bdf::{BdfError, BdfResult, BdfValue};
pub fn plain_json_to_bdf(json: &str) -> BdfResult<BdfValue> {
let mut de = serde_json::Deserializer::from_str(json);
let value = PlainJson::deserialize(&mut de)
.map(|p| p.0)
.map_err(|e| BdfError::Json(e.to_string()))?;
de.end().map_err(|e| BdfError::Json(e.to_string()))?;
Ok(value)
}
pub fn bdf_to_plain_json(value: &BdfValue) -> BdfResult<String> {
let json = bdf_to_serde_value(value);
serde_json::to_string(&json).map_err(|e| BdfError::Json(e.to_string()))
}
pub fn bdf_to_plain_json_pretty(value: &BdfValue) -> BdfResult<String> {
let json = bdf_to_serde_value(value);
serde_json::to_string_pretty(&json).map_err(|e| BdfError::Json(e.to_string()))
}
pub fn bdf_to_serde_value(value: &BdfValue) -> serde_json::Value {
use serde_json::Value as J;
match value {
BdfValue::Null => J::Null,
BdfValue::Bool(b) => J::Bool(*b),
BdfValue::Int(i) => J::Number((*i).into()),
BdfValue::Float(f) => serde_json::Number::from_f64(*f).map_or(J::Null, J::Number),
BdfValue::Str(s) => J::String(s.clone()),
BdfValue::Bytes(bytes) => J::Array(bytes.iter().map(|b| J::Number((*b).into())).collect()),
BdfValue::Array(items) => J::Array(items.iter().map(bdf_to_serde_value).collect()),
BdfValue::Map(entries) => {
let mut obj = serde_json::Map::new();
for (k, v) in entries {
obj.insert(k.clone(), bdf_to_serde_value(v));
}
J::Object(obj)
}
}
}
struct PlainJson(BdfValue);
impl<'de> Deserialize<'de> for PlainJson {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
deserializer
.deserialize_any(PlainJsonVisitor)
.map(PlainJson)
}
}
struct PlainJsonVisitor;
impl<'de> Visitor<'de> for PlainJsonVisitor {
type Value = BdfValue;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("any JSON value")
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(BdfValue::Null)
}
fn visit_none<E>(self) -> Result<Self::Value, E> {
Ok(BdfValue::Null)
}
fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E> {
Ok(BdfValue::Bool(v))
}
fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E> {
Ok(BdfValue::Int(v))
}
fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
where
E: de::Error,
{
i64::try_from(v).map_or_else(|_| Ok(BdfValue::Float(v as f64)), |i| Ok(BdfValue::Int(i)))
}
fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E> {
Ok(BdfValue::Float(v))
}
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> {
Ok(BdfValue::Str(v.to_string()))
}
fn visit_string<E>(self, v: String) -> Result<Self::Value, E> {
Ok(BdfValue::Str(v))
}
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let mut items = Vec::new();
while let Some(PlainJson(v)) = seq.next_element()? {
items.push(v);
}
Ok(BdfValue::Array(items))
}
fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut entries = indexmap::IndexMap::new();
while let Some((k, PlainJson(v))) = map.next_entry::<String, PlainJson>()? {
entries.insert(k, v);
}
Ok(BdfValue::Map(entries))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn round_trips(json: &str) {
let value = plain_json_to_bdf(json).expect("parse");
let back = bdf_to_plain_json(&value).expect("serialize");
let original: serde_json::Value = serde_json::from_str(json).expect("orig");
let returned: serde_json::Value = serde_json::from_str(&back).expect("back");
assert_eq!(original, returned, "plain-json round-trip mismatch: {json}");
}
#[test]
fn scalars_round_trip() {
round_trips("null");
round_trips("true");
round_trips("false");
round_trips("0");
round_trips("-42");
round_trips("1.5");
round_trips("\"hello\"");
round_trips("\"café ☃ 日本語\"");
}
#[test]
fn containers_round_trip() {
round_trips("[]");
round_trips("[1,2,3]");
round_trips("{}");
round_trips(r#"{"a":1,"b":[true,null,"x"],"c":{"d":2.5}}"#);
}
#[test]
fn integer_and_float_distinction_is_preserved() {
let v = plain_json_to_bdf("7").expect("int");
assert_eq!(v, BdfValue::Int(7));
let f = plain_json_to_bdf("7.5").expect("float");
assert!(matches!(f, BdfValue::Float(x) if (x - 7.5).abs() < f64::EPSILON));
}
#[test]
fn object_key_order_is_preserved() {
let v = plain_json_to_bdf(r#"{"zeta":1,"alpha":2,"mu":3}"#).expect("parse");
if let BdfValue::Map(m) = v {
let keys: Vec<&str> = m.keys().map(String::as_str).collect();
assert_eq!(keys, vec!["zeta", "alpha", "mu"]);
} else {
panic!("expected map");
}
}
#[test]
fn rejects_malformed_json() {
assert!(plain_json_to_bdf("{not json").is_err());
assert!(plain_json_to_bdf("").is_err());
assert!(plain_json_to_bdf("{} trailing").is_err());
}
}