use std::fmt;
use serde::de::Error as _;
use serde::de::{self, MapAccess, SeqAccess, Visitor};
use serde::Deserialize;
use serde_json::{Map, Value};
struct StrictValue(Value);
impl<'de> Deserialize<'de> for StrictValue {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
deserializer.deserialize_any(StrictValueVisitor)
}
}
struct StrictValueVisitor;
impl<'de> Visitor<'de> for StrictValueVisitor {
type Value = StrictValue;
fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str("a JSON value without duplicate object keys")
}
fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
Ok(StrictValue(Value::Bool(value)))
}
fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
Ok(StrictValue(Value::Number(value.into())))
}
fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
Ok(StrictValue(Value::Number(value.into())))
}
fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E>
where
E: de::Error,
{
serde_json::Number::from_f64(value)
.map(Value::Number)
.map(StrictValue)
.ok_or_else(|| E::custom("non-finite JSON numbers are not permitted"))
}
fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> {
Ok(StrictValue(Value::String(value.to_string())))
}
fn visit_string<E>(self, value: String) -> Result<Self::Value, E> {
Ok(StrictValue(Value::String(value)))
}
fn visit_none<E>(self) -> Result<Self::Value, E> {
Ok(StrictValue(Value::Null))
}
fn visit_unit<E>(self) -> Result<Self::Value, E> {
Ok(StrictValue(Value::Null))
}
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
D: serde::Deserializer<'de>,
{
StrictValue::deserialize(deserializer)
}
fn visit_seq<A>(self, mut sequence: A) -> Result<Self::Value, A::Error>
where
A: SeqAccess<'de>,
{
let mut values = Vec::new();
while let Some(StrictValue(value)) = sequence.next_element()? {
values.push(value);
}
Ok(StrictValue(Value::Array(values)))
}
fn visit_map<A>(self, mut object: A) -> Result<Self::Value, A::Error>
where
A: MapAccess<'de>,
{
let mut values = Map::new();
while let Some(key) = object.next_key::<String>()? {
if values.contains_key(&key) {
return Err(A::Error::custom(format!(
"duplicate JSON object key: {key:?}"
)));
}
let StrictValue(value) = object.next_value()?;
values.insert(key, value);
}
Ok(StrictValue(Value::Object(values)))
}
}
pub(crate) fn from_str(input: &str) -> serde_json::Result<Value> {
let mut deserializer = serde_json::Deserializer::from_str(input);
let StrictValue(value) = StrictValue::deserialize(&mut deserializer)?;
deserializer.end()?;
Ok(value)
}
#[cfg(any(test, not(all(target_arch = "wasm32", target_os = "unknown"))))]
pub(crate) fn from_slice(input: &[u8]) -> serde_json::Result<Value> {
let mut deserializer = serde_json::Deserializer::from_slice(input);
let StrictValue(value) = StrictValue::deserialize(&mut deserializer)?;
deserializer.end()?;
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_duplicate_keys_at_any_depth() {
for malformed in [
r#"{"a": 1, "a": 2}"#,
r#"{"outer": {"a": 1, "a": 2}}"#,
r#"[{"a": 1, "a": 2}]"#,
r#"{"a": 1, "\u0061": 2}"#,
] {
assert!(from_str(malformed).is_err(), "accepted {malformed}");
}
}
#[test]
fn preserves_valid_json_values_and_rejects_trailing_data() {
let input = br#"{"array":[null,true,-1,2,3.5],"text":"ok"}"#;
assert_eq!(
from_slice(input).unwrap(),
serde_json::from_slice::<Value>(input).unwrap()
);
assert!(from_str(r#"{"valid":true} false"#).is_err());
}
}