use alloc::string::String;
use alloc::vec::Vec;
use core::cell::Cell;
use core::fmt;
use serde::de::{Deserialize, DeserializeSeed, Deserializer, Error, MapAccess, SeqAccess, Visitor};
use serde_json::{Map, Number, Value};
#[derive(Clone, Debug, PartialEq)]
pub struct BufferedValue(pub Value);
#[derive(Clone, Debug, PartialEq)]
pub struct BufferedObject(pub Map<String, Value>);
impl From<BufferedValue> for Value {
fn from(BufferedValue(value): BufferedValue) -> Self {
value
}
}
impl From<BufferedObject> for Map<String, Value> {
fn from(BufferedObject(object): BufferedObject) -> Self {
object
}
}
pub fn value<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Value, D::Error> {
BufferedValue::deserialize(deserializer).map(Value::from)
}
pub fn opt_value<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Option<Value>, D::Error> {
Option::<BufferedValue>::deserialize(deserializer).map(|value| value.map(Value::from))
}
pub fn object<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Map<String, Value>, D::Error> {
BufferedObject::deserialize(deserializer).map(Map::from)
}
impl<'de> Deserialize<'de> for BufferedValue {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
d.deserialize_any(ValueVisitor).map(Self)
}
}
impl<'de> Deserialize<'de> for BufferedObject {
fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
d.deserialize_map(ObjectVisitor).map(Self)
}
}
fn read_object<'de, A: MapAccess<'de>>(mut map: A) -> Result<Map<String, Value>, A::Error> {
let mut out = Map::new();
while let Some(key) = map.next_key::<String>()? {
let BufferedValue(value) = map.next_value()?;
out.insert(key, value);
}
Ok(out)
}
struct ObjectVisitor;
impl<'de> Visitor<'de> for ObjectVisitor {
type Value = Map<String, Value>;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a map")
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(Map::new())
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
read_object(map)
}
}
struct ValueVisitor;
impl<'de> Visitor<'de> for ValueVisitor {
type Value = Value;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("any valid JSON value")
}
fn visit_bool<E>(self, v: bool) -> Result<Value, E> {
Ok(Value::Bool(v))
}
fn visit_i64<E>(self, v: i64) -> Result<Value, E> {
Ok(Value::Number(v.into()))
}
fn visit_i128<E: Error>(self, v: i128) -> Result<Value, E> {
Number::deserialize(serde::de::value::I128Deserializer::new(v)).map(Value::Number)
}
fn visit_u64<E>(self, v: u64) -> Result<Value, E> {
Ok(Value::Number(v.into()))
}
fn visit_u128<E: Error>(self, v: u128) -> Result<Value, E> {
Number::deserialize(serde::de::value::U128Deserializer::new(v)).map(Value::Number)
}
fn visit_f64<E>(self, v: f64) -> Result<Value, E> {
Ok(Number::from_f64(v).map_or(Value::Null, Value::Number))
}
fn visit_str<E>(self, v: &str) -> Result<Value, E> {
Ok(Value::String(String::from(v)))
}
fn visit_string<E>(self, v: String) -> Result<Value, E> {
Ok(Value::String(v))
}
fn visit_none<E>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_some<D: Deserializer<'de>>(self, d: D) -> Result<Value, D::Error> {
BufferedValue::deserialize(d).map(|BufferedValue(v)| v)
}
fn visit_unit<E>(self) -> Result<Value, E> {
Ok(Value::Null)
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Value, A::Error> {
let mut out = Vec::new();
while let Some(BufferedValue(element)) = seq.next_element()? {
out.push(element);
}
Ok(Value::Array(out))
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Value, A::Error> {
read_object(map).map(Value::Object)
}
}
#[doc(hidden)]
pub fn charged_object<'de, D: Deserializer<'de>>(
deserializer: D,
remaining: &Cell<usize>,
per_member: usize,
per_element: usize,
limit_msg: &'static str,
) -> Result<Map<String, Value>, D::Error> {
deserializer.deserialize_map(ChargingObjectVisitor(Budget {
remaining,
per_member,
per_element,
limit_msg,
}))
}
#[derive(Clone, Copy)]
struct Budget<'a> {
remaining: &'a Cell<usize>,
per_member: usize,
per_element: usize,
limit_msg: &'static str,
}
impl Budget<'_> {
fn charge<E: Error>(&self, bytes: usize) -> Result<(), E> {
let left = self.remaining.get();
if bytes > left {
return Err(E::custom(self.limit_msg));
}
self.remaining.set(left - bytes);
Ok(())
}
}
#[derive(Clone, Copy)]
struct ChargingValue<'a>(Budget<'a>);
impl<'de> DeserializeSeed<'de> for ChargingValue<'_> {
type Value = Value;
fn deserialize<D: Deserializer<'de>>(self, d: D) -> Result<Value, D::Error> {
d.deserialize_any(ChargingValueVisitor(self.0))
}
}
fn read_charging_object<'de, A: MapAccess<'de>>(
mut map: A,
budget: Budget<'_>,
) -> Result<Map<String, Value>, A::Error> {
let mut out = Map::new();
while let Some(key) = map.next_key::<String>()? {
let value = map.next_value_seed(ChargingValue(budget))?;
budget.charge(budget.per_member)?;
out.insert(key, value);
}
Ok(out)
}
struct ChargingObjectVisitor<'a>(Budget<'a>);
impl<'de> Visitor<'de> for ChargingObjectVisitor<'_> {
type Value = Map<String, Value>;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("a map")
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(Map::new())
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Self::Value, A::Error> {
read_charging_object(map, self.0)
}
}
struct ChargingValueVisitor<'a>(Budget<'a>);
impl<'de> Visitor<'de> for ChargingValueVisitor<'_> {
type Value = Value;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("any valid JSON value")
}
fn visit_bool<E: Error>(self, v: bool) -> Result<Value, E> {
ValueVisitor.visit_bool(v)
}
fn visit_i64<E: Error>(self, v: i64) -> Result<Value, E> {
ValueVisitor.visit_i64(v)
}
fn visit_i128<E: Error>(self, v: i128) -> Result<Value, E> {
ValueVisitor.visit_i128(v)
}
fn visit_u64<E: Error>(self, v: u64) -> Result<Value, E> {
ValueVisitor.visit_u64(v)
}
fn visit_u128<E: Error>(self, v: u128) -> Result<Value, E> {
ValueVisitor.visit_u128(v)
}
fn visit_f64<E: Error>(self, v: f64) -> Result<Value, E> {
ValueVisitor.visit_f64(v)
}
fn visit_str<E: Error>(self, v: &str) -> Result<Value, E> {
ValueVisitor.visit_str(v)
}
fn visit_string<E: Error>(self, v: String) -> Result<Value, E> {
ValueVisitor.visit_string(v)
}
fn visit_none<E: Error>(self) -> Result<Value, E> {
ValueVisitor.visit_none()
}
fn visit_unit<E: Error>(self) -> Result<Value, E> {
ValueVisitor.visit_unit()
}
fn visit_some<D: Deserializer<'de>>(self, d: D) -> Result<Value, D::Error> {
ChargingValue(self.0).deserialize(d)
}
fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Value, A::Error> {
let budget = self.0;
let mut out = Vec::new();
while let Some(element) = seq.next_element_seed(ChargingValue(budget))? {
budget.charge(budget.per_element)?;
out.push(element);
}
Ok(Value::Array(out))
}
fn visit_map<A: MapAccess<'de>>(self, map: A) -> Result<Value, A::Error> {
read_charging_object(map, self.0).map(Value::Object)
}
}
#[cfg(test)]
mod tests {
use super::*;
use alloc::format;
use alloc::string::ToString;
use serde_json::json;
const RAW_VALUE_KEY: &str = "$serde_json::private::RawValue";
fn buffer(text: &str) -> serde_json::Result<Value> {
serde_json::from_str(text).map(|BufferedValue(v)| v)
}
fn depth(v: &Value) -> usize {
match v {
Value::Array(a) => 1 + a.iter().map(depth).max().unwrap_or(0),
Value::Object(o) => 1 + o.values().map(depth).max().unwrap_or(0),
Value::Null | Value::Bool(_) | Value::Number(_) | Value::String(_) => 0,
}
}
fn nested_raw_values(levels: usize, arrays: usize) -> alloc::string::String {
let mut inner = "0".to_string();
for _ in 0..levels {
let object = json!({ RAW_VALUE_KEY: inner }).to_string();
inner = format!("{}{object}{}", "[".repeat(arrays), "]".repeat(arrays));
}
inner
}
#[test]
fn the_test_build_has_serde_json_raw_value_enabled() {
let text = json!({ RAW_VALUE_KEY: "[1]" }).to_string();
let value: Value = serde_json::from_str(&text).unwrap();
assert_eq!(value, json!([1]));
}
#[test]
fn ordinary_json_buffers_as_serde_json_does() {
for text in [
"null",
"true",
"0",
"-1",
"18446744073709551615",
"-9223372036854775808",
"1.5",
"1e400",
r#""a\"é\n""#,
"[]",
"{}",
r#"[1, [2, [3, {"a": [null]}]], "x"]"#,
r#"{"a": 1, "b": {"c": [true, false]}, "a": 2}"#,
r#"{"$serde_json::private::Number": "1"}"#,
] {
let expected = serde_json::from_str::<Value>(text).map_err(|e| e.to_string());
let got = buffer(text).map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
}
}
#[test]
fn the_raw_value_key_is_data_in_json_text() {
let text = json!({ RAW_VALUE_KEY: "[1]" }).to_string();
let mut expected = Map::new();
expected.insert(RAW_VALUE_KEY.to_string(), Value::String("[1]".to_string()));
assert_eq!(buffer(&text).unwrap(), Value::Object(expected.clone()));
let in_list = format!("[{text}]");
assert_eq!(
buffer(&in_list).unwrap(),
Value::Array(alloc::vec![Value::Object(expected.clone())])
);
let BufferedObject(object) = serde_json::from_str(&format!(r#"{{"f": {text}}}"#)).unwrap();
assert_eq!(object["f"], Value::Object(expected));
}
#[test]
fn the_raw_value_key_is_data_in_a_value_that_is_already_built() {
let built = json!({ "f": [{ RAW_VALUE_KEY: "[1]" }] });
let BufferedValue(again) = BufferedValue::deserialize(built.clone()).unwrap();
assert_eq!(again, built);
let BufferedObject(object) = BufferedObject::deserialize(built.clone()).unwrap();
assert_eq!(Value::Object(object), built);
}
#[test]
fn nested_raw_value_strings_do_not_add_depth() {
let text = nested_raw_values(3, 120);
let value = buffer(&text).unwrap();
assert_eq!(depth(&value), 121);
let too_deep = nested_raw_values(1, 128);
let err = buffer(&too_deep).unwrap_err();
assert!(err.to_string().contains("recursion limit"), "{err}");
}
#[test]
fn an_object_buffer_accepts_what_a_serde_json_map_accepts() {
for text in ["{}", r#"{"a": [1]}"#, "null", "[]", "1", r#""x""#, "true"] {
let expected =
serde_json::from_str::<Map<String, Value>>(text).map_err(|e| e.to_string());
let got = serde_json::from_str(text)
.map(|BufferedObject(o)| o)
.map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
let built: Value = serde_json::from_str(text).unwrap();
let expected =
Map::<String, Value>::deserialize(built.clone()).map_err(|e| e.to_string());
let got = BufferedObject::deserialize(built)
.map(|BufferedObject(o)| o)
.map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
}
assert!(serde_json::from_str::<BufferedObject>("null").is_err());
assert!(BufferedObject::deserialize(Value::Null).is_err());
}
#[test]
fn the_field_functions_read_the_raw_value_key_as_data() {
#[derive(Debug, serde::Deserialize)]
struct Fields {
#[serde(deserialize_with = "value")]
required: Value,
#[serde(default, deserialize_with = "opt_value")]
optional: Option<Value>,
#[serde(deserialize_with = "object")]
named: Map<String, Value>,
#[serde(flatten, deserialize_with = "object")]
rest: Map<String, Value>,
}
let hidden = json!({ RAW_VALUE_KEY: "[1]" });
let built = json!({
"required": hidden,
"optional": hidden,
"named": { "a": hidden },
"other": hidden,
});
let from_text: Fields = serde_json::from_str(&built.to_string()).unwrap();
let from_value: Fields = serde_json::from_value(built).unwrap();
for fields in [from_text, from_value] {
assert_eq!(fields.required, hidden);
assert_eq!(fields.optional, Some(hidden.clone()));
assert_eq!(fields.named["a"], hidden);
assert_eq!(fields.rest["other"], hidden);
}
for text in [
r#"{"required": 1, "named": {}}"#,
r#"{"required": 1, "named": {}, "optional": null}"#,
] {
let fields: Fields = serde_json::from_str(text).unwrap();
assert_eq!(fields.optional, None, "{text}");
}
let err = serde_json::from_str::<Fields>(r#"{"required": 1, "named": null}"#).unwrap_err();
assert!(err.to_string().contains("expected a map"), "{err}");
}
#[test]
fn a_field_with_a_field_function_and_no_default_is_required() {
#[derive(Debug, serde::Deserialize)]
struct Fields {
#[serde(deserialize_with = "opt_value")]
#[allow(dead_code)]
optional: Option<Value>,
}
let err = serde_json::from_str::<Fields>("{}").unwrap_err();
assert!(
err.to_string().contains("missing field `optional`"),
"{err}"
);
}
#[test]
fn a_buffer_converts_into_what_it_holds() {
let built = json!({ "a": [1] });
let buffered = BufferedValue::deserialize(built.clone()).unwrap();
assert_eq!(buffered, BufferedValue(built.clone()));
assert_eq!(Value::from(buffered), built);
let object = BufferedObject::deserialize(built.clone()).unwrap();
assert_eq!(Value::Object(object.into()), built);
}
#[test]
fn a_float_with_no_json_form_buffers_as_null() {
use serde::de::value::{Error, F64Deserializer};
for v in [f64::NAN, f64::INFINITY] {
let BufferedValue(value) =
BufferedValue::deserialize(F64Deserializer::<Error>::new(v)).unwrap();
assert_eq!(value, Value::Null);
}
}
#[test]
fn wide_integers_buffer_as_serde_json_does() {
use serde::de::value::{Error, I128Deserializer, U128Deserializer};
let small = BufferedValue::deserialize(I128Deserializer::<Error>::new(-5)).unwrap();
assert_eq!(small.0, json!(-5));
let small = BufferedValue::deserialize(U128Deserializer::<Error>::new(5)).unwrap();
assert_eq!(small.0, json!(5));
let wide = U128Deserializer::<Error>::new(u128::MAX);
assert_eq!(
BufferedValue::deserialize(wide).map(|v| v.0).ok(),
Value::deserialize(U128Deserializer::<Error>::new(u128::MAX)).ok(),
);
}
const CHARGED_OUT: &str = "charged out";
fn charge_at(
text: &str,
per_member: usize,
per_element: usize,
limit: usize,
) -> (serde_json::Result<Value>, usize) {
let remaining = Cell::new(limit);
let budget = Budget {
remaining: &remaining,
per_member,
per_element,
limit_msg: CHARGED_OUT,
};
let result =
ChargingValue(budget).deserialize(&mut serde_json::Deserializer::from_str(text));
(result, remaining.get())
}
fn charge(text: &str, per_value: usize, limit: usize) -> (serde_json::Result<Value>, usize) {
charge_at(text, per_value, per_value, limit)
}
#[test]
fn a_charging_buffer_builds_what_a_plain_buffer_does() {
for text in [
"null",
"true",
"-1",
"1.5",
r#""x""#,
"[1,[2,[3,{}]]]",
r#"{"a":1,"b":{"c":[true,false]},"a":2}"#,
r#"{"$serde_json::private::RawValue":"[1]"}"#,
r#"{"$serde_json::private::Number":"1"}"#,
] {
let got = charge(text, 1, usize::MAX).0.map_err(|e| e.to_string());
let expected = serde_json::from_str::<BufferedValue>(text)
.map(|BufferedValue(v)| v)
.map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
}
}
#[test]
fn a_charging_buffer_reads_the_raw_value_key_as_data() {
let text = json!({ RAW_VALUE_KEY: "[1]" }).to_string();
let value = charge(&text, 1, usize::MAX).0.unwrap();
assert_eq!(value[RAW_VALUE_KEY], Value::String("[1]".to_string()));
}
#[test]
fn each_array_element_and_object_member_is_charged_once() {
let text = r#"{"a":1,"b":[1,2]}"#;
let (value, left) = charge(text, 1, 10);
assert_eq!(value.unwrap(), json!({"a":1,"b":[1,2]}));
assert_eq!(left, 6);
assert_eq!(charge(text, 64, 1000).1, 1000 - 4 * 64);
assert_eq!(charge("7", 1, 0).0.unwrap(), json!(7));
assert_eq!(charge("[]", 1, 0).0.unwrap(), json!([]));
assert_eq!(charge("{}", 1, 0).0.unwrap(), json!({}));
}
#[test]
fn members_and_elements_are_charged_at_their_own_rates() {
let text = r#"{"a":[1,{"b":2,"c":[3]},4]}"#;
let (value, left) = charge_at(text, 100, 1, 1000);
assert_eq!(value.unwrap(), json!({"a":[1,{"b":2,"c":[3]},4]}));
assert_eq!(left, 1000 - (3 * 100 + 4));
let (result, _) = charge_at(text, 100, 1, 303);
let err = result.unwrap_err();
assert!(err.to_string().starts_with(CHARGED_OUT), "{err}");
}
#[test]
fn a_charge_larger_than_what_is_left_fails_and_leaves_the_rest() {
let text = r#"{"a":1,"b":[1,2]}"#;
let (result, left) = charge(text, 2, 7);
let err = result.unwrap_err();
assert!(err.to_string().starts_with(CHARGED_OUT), "{err}");
assert_eq!(left, 1);
let (result, left) = charge(text, 2, 8);
assert!(result.is_ok());
assert_eq!(left, 0);
}
#[test]
fn a_failed_charge_stops_before_the_rest_of_the_input_is_read() {
let (result, left) = charge("[1,2,!", 1, 1);
let err = result.unwrap_err();
assert!(err.to_string().starts_with(CHARGED_OUT), "{err}");
assert_eq!(left, 0);
let (result, _) = charge(r#"{"a":[1,2],"b":!"#, 1, 2);
let err = result.unwrap_err();
assert!(err.to_string().starts_with(CHARGED_OUT), "{err}");
}
#[test]
fn an_object_buffer_charges_from_text_and_from_a_built_value() {
let text = r#"{"a":{"b":[1,2,3]},"c":null}"#;
let expected = json!({"a":{"b":[1,2,3]},"c":null});
let remaining = Cell::new(33);
let from_text = charged_object(
&mut serde_json::Deserializer::from_str(text),
&remaining,
10,
1,
CHARGED_OUT,
)
.unwrap();
assert_eq!(Value::Object(from_text), expected);
assert_eq!(remaining.get(), 0);
let remaining = Cell::new(33);
let from_value = charged_object(expected.clone(), &remaining, 10, 1, CHARGED_OUT).unwrap();
assert_eq!(Value::Object(from_value), expected);
assert_eq!(remaining.get(), 0);
let remaining = Cell::new(32);
let err = charged_object(expected, &remaining, 10, 1, CHARGED_OUT).unwrap_err();
assert!(err.to_string().starts_with(CHARGED_OUT), "{err}");
}
#[test]
fn a_charged_object_buffer_accepts_what_a_plain_one_accepts() {
let remaining = Cell::new(usize::MAX);
for text in ["{}", r#"{"a": [1]}"#, "null", "[]", "1", r#""x""#, "true"] {
let expected =
object(&mut serde_json::Deserializer::from_str(text)).map_err(|e| e.to_string());
let got = charged_object(
&mut serde_json::Deserializer::from_str(text),
&remaining,
1,
1,
CHARGED_OUT,
)
.map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
let built: Value = serde_json::from_str(text).unwrap();
let expected = object(built.clone()).map_err(|e| e.to_string());
let got =
charged_object(built, &remaining, 1, 1, CHARGED_OUT).map_err(|e| e.to_string());
assert_eq!(got, expected, "{text}");
}
}
}