json_syntax/serde/de/

mod.rs

use std::fmt;

use serde::{
	Deserialize,
	de::{
		DeserializeSeed, EnumAccess, Expected, IntoDeserializer, MapAccess, SeqAccess, Unexpected,
		VariantAccess, Visitor,
	},
	forward_to_deserialize_any,
};

use crate::{
	JsonArrayBuf, JsonNumberBuf, JsonObject, JsonValue,
	object::{Entry, Key},
	serde::NUMBER_TOKEN,
};

mod number;

pub use number::JsonNumberVisitor;

impl JsonValue {
	#[cold]
	fn invalid_type<E>(&self, exp: &dyn Expected) -> E
	where
		E: serde::de::Error,
	{
		serde::de::Error::invalid_type(self.unexpected(), exp)
	}

	#[cold]
	fn unexpected(&self) -> Unexpected<'_> {
		match self {
			Self::Null => Unexpected::Unit,
			Self::Boolean(b) => Unexpected::Bool(*b),
			Self::Number(n) => match n.as_u64() {
				Some(u) => Unexpected::Unsigned(u),
				None => match n.as_i64() {
					Some(i) => Unexpected::Signed(i),
					None => Unexpected::Float(n.as_f64_lossy()),
				},
			},
			Self::String(s) => Unexpected::Str(s),
			Self::Array(_) => Unexpected::Seq,
			Self::Object(_) => Unexpected::Map,
		}
	}
}

impl<'de> Deserialize<'de> for JsonValue {
	#[inline]
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: serde::Deserializer<'de>,
	{
		struct ValueVisitor;

		impl<'de> Visitor<'de> for ValueVisitor {
			type Value = JsonValue;

			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
				formatter.write_str("any valid JSON value")
			}

			#[inline]
			fn visit_bool<E>(self, value: bool) -> Result<JsonValue, E> {
				Ok(JsonValue::Boolean(value))
			}

			#[inline]
			fn visit_i64<E>(self, value: i64) -> Result<JsonValue, E> {
				Ok(JsonValue::Number(value.into()))
			}

			#[inline]
			fn visit_u64<E>(self, value: u64) -> Result<JsonValue, E> {
				Ok(JsonValue::Number(value.into()))
			}

			#[inline]
			fn visit_f64<E>(self, value: f64) -> Result<JsonValue, E> {
				Ok(JsonNumberBuf::try_from(value).map_or(JsonValue::Null, JsonValue::Number))
			}

			#[inline]
			fn visit_str<E>(self, value: &str) -> Result<JsonValue, E>
			where
				E: serde::de::Error,
			{
				Ok(JsonValue::String(value.into()))
			}

			#[inline]
			fn visit_string<E>(self, value: String) -> Result<JsonValue, E> {
				Ok(JsonValue::String(value.into()))
			}

			#[inline]
			fn visit_none<E>(self) -> Result<JsonValue, E> {
				Ok(JsonValue::Null)
			}

			#[inline]
			fn visit_some<D>(self, deserializer: D) -> Result<JsonValue, D::Error>
			where
				D: serde::Deserializer<'de>,
			{
				Deserialize::deserialize(deserializer)
			}

			#[inline]
			fn visit_unit<E>(self) -> Result<JsonValue, E> {
				Ok(JsonValue::Null)
			}

			#[inline]
			fn visit_seq<V>(self, mut visitor: V) -> Result<JsonValue, V::Error>
			where
				V: SeqAccess<'de>,
			{
				let mut vec = Vec::new();

				while let Some(elem) = visitor.next_element()? {
					vec.push(elem);
				}

				Ok(JsonValue::Array(vec))
			}

			fn visit_map<V>(self, mut visitor: V) -> Result<JsonValue, V::Error>
			where
				V: MapAccess<'de>,
			{
				enum MapTag {
					Number,
					None(Key),
				}

				impl<'de> Deserialize<'de> for MapTag {
					fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
					where
						D: serde::Deserializer<'de>,
					{
						struct Visitor;

						impl<'de> serde::de::Visitor<'de> for Visitor {
							type Value = MapTag;

							fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
								formatter.write_str("a string key")
							}

							fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
							where
								E: serde::de::Error,
							{
								if v == NUMBER_TOKEN {
									Ok(MapTag::Number)
								} else {
									Ok(MapTag::None(v.into()))
								}
							}

							fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
							where
								E: serde::de::Error,
							{
								if v == NUMBER_TOKEN {
									Ok(MapTag::Number)
								} else {
									Ok(MapTag::None(v.into()))
								}
							}
						}

						deserializer.deserialize_string(Visitor)
					}
				}

				match visitor.next_key()? {
					Some(MapTag::Number) => {
						let value: String = visitor.next_value()?;
						JsonNumberBuf::new(value)
							.map(JsonValue::Number)
							.map_err(serde::de::Error::custom)
					}
					Some(MapTag::None(key)) => {
						let mut object = JsonObject::new();

						object.insert(key, visitor.next_value()?);
						while let Some((key, value)) = visitor.next_entry::<Key, JsonValue>()? {
							object.insert(key, value);
						}

						Ok(JsonValue::Object(object))
					}
					None => Ok(JsonValue::Object(JsonObject::new())),
				}
			}
		}

		deserializer.deserialize_any(ValueVisitor)
	}
}

impl<'de> IntoDeserializer<'de, DeserializeError> for JsonValue {
	type Deserializer = Self;

	fn into_deserializer(self) -> Self::Deserializer {
		self
	}
}

impl<'de> Deserialize<'de> for JsonObject {
	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
	where
		D: serde::Deserializer<'de>,
	{
		struct Visitor;

		impl<'de> serde::de::Visitor<'de> for Visitor {
			type Value = JsonObject;

			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
				write!(formatter, "a JSON object")
			}

			fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
			where
				A: MapAccess<'de>,
			{
				let mut object = JsonObject::new();

				while let Some((key, value)) = map.next_entry::<Key, JsonValue>()? {
					object.insert(key, value);
				}

				Ok(object)
			}
		}

		deserializer.deserialize_map(Visitor)
	}
}

impl<'de> IntoDeserializer<'de, DeserializeError> for JsonObject {
	type Deserializer = JsonValue;

	fn into_deserializer(self) -> Self::Deserializer {
		JsonValue::Object(self)
	}
}

#[derive(Debug, Clone)]
pub enum DeserializeError {
	Custom(String),
	NonStringKey,
}

impl fmt::Display for DeserializeError {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		match self {
			Self::Custom(msg) => msg.fmt(f),
			Self::NonStringKey => write!(f, "key must be a string"),
		}
	}
}

impl From<number::Unexpected> for DeserializeError {
	fn from(value: number::Unexpected) -> Self {
		Self::Custom(value.to_string())
	}
}

impl std::error::Error for DeserializeError {}

impl serde::de::Error for DeserializeError {
	fn custom<T>(msg: T) -> Self
	where
		T: fmt::Display,
	{
		Self::Custom(msg.to_string())
	}
}

macro_rules! deserialize_number {
	($method:ident) => {
		fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
		where
			V: serde::de::Visitor<'de>,
		{
			match self {
				JsonValue::Number(n) => Ok(n.deserialize_any(visitor)?),
				_ => Err(self.invalid_type(&visitor)),
			}
		}
	};
}

impl<'de> serde::Deserializer<'de> for JsonValue {
	type Error = DeserializeError;

	#[inline]
	fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			Self::Null => visitor.visit_unit(),
			Self::Boolean(v) => visitor.visit_bool(v),
			Self::Number(n) => Ok(n.deserialize_any(visitor)?),
			Self::String(s) => visitor.visit_string(s.into_string()),
			Self::Array(a) => visit_array(a, visitor),
			Self::Object(o) => visit_object(o, visitor),
		}
	}

	deserialize_number!(deserialize_i8);
	deserialize_number!(deserialize_i16);
	deserialize_number!(deserialize_i32);
	deserialize_number!(deserialize_i64);
	deserialize_number!(deserialize_i128);
	deserialize_number!(deserialize_u8);
	deserialize_number!(deserialize_u16);
	deserialize_number!(deserialize_u32);
	deserialize_number!(deserialize_u64);
	deserialize_number!(deserialize_u128);
	deserialize_number!(deserialize_f32);
	deserialize_number!(deserialize_f64);

	#[inline]
	fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Null => visitor.visit_none(),
			_ => visitor.visit_some(self),
		}
	}

	#[inline]
	fn deserialize_enum<V>(
		self,
		_name: &str,
		_variants: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		let (variant, value) = match self {
			JsonValue::Object(value) => {
				let mut iter = value.into_iter();
				let (variant, value) = match iter.next() {
					Some(v) => v,
					None => {
						return Err(serde::de::Error::invalid_value(
							Unexpected::Map,
							&"map with a single key",
						));
					}
				};
				// enums are encoded in json as maps with a single key:value pair
				if iter.next().is_some() {
					return Err(serde::de::Error::invalid_value(
						Unexpected::Map,
						&"map with a single key",
					));
				}
				(variant, Some(value))
			}
			JsonValue::String(variant) => (variant, None),
			other => {
				return Err(serde::de::Error::invalid_type(
					other.unexpected(),
					&"string or map",
				));
			}
		};

		visitor.visit_enum(EnumDeserializer { variant, value })
	}

	#[inline]
	fn deserialize_newtype_struct<V>(
		self,
		_name: &'static str,
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		visitor.visit_newtype_struct(self)
	}

	fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Boolean(v) => visitor.visit_bool(v),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_string(visitor)
	}

	fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_string(visitor)
	}

	fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::String(v) => visitor.visit_string(v.into_string()),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_byte_buf(visitor)
	}

	fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::String(v) => visitor.visit_string(v.into_string()),
			JsonValue::Array(v) => visit_array(v, visitor),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Null => visitor.visit_unit(),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_unit_struct<V>(
		self,
		_name: &'static str,
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_unit(visitor)
	}

	fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Array(v) => visit_array(v, visitor),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_seq(visitor)
	}

	fn deserialize_tuple_struct<V>(
		self,
		_name: &'static str,
		_len: usize,
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_seq(visitor)
	}

	fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Object(v) => visit_object(v, visitor),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_struct<V>(
		self,
		_name: &'static str,
		_fields: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self {
			JsonValue::Array(v) => visit_array(v, visitor),
			JsonValue::Object(v) => visit_object(v, visitor),
			_ => Err(self.invalid_type(&visitor)),
		}
	}

	fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.deserialize_string(visitor)
	}

	fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		drop(self);
		visitor.visit_unit()
	}
}

fn visit_array<'de, V>(a: JsonArrayBuf, visitor: V) -> Result<V::Value, DeserializeError>
where
	V: serde::de::Visitor<'de>,
{
	let len = a.len();
	let mut deserializer = ArrayDeserializer::new(a);
	let seq = visitor.visit_seq(&mut deserializer)?;
	let remaining = deserializer.iter.len();
	if remaining == 0 {
		Ok(seq)
	} else {
		Err(serde::de::Error::invalid_length(
			len,
			&"fewer elements in array",
		))
	}
}

fn visit_object<'de, V>(o: JsonObject, visitor: V) -> Result<V::Value, DeserializeError>
where
	V: serde::de::Visitor<'de>,
{
	let len = o.len();
	let mut deserializer = ObjectDeserializer::new(o);
	let map = visitor.visit_map(&mut deserializer)?;
	let remaining = deserializer.iter.len();
	if remaining == 0 {
		Ok(map)
	} else {
		Err(serde::de::Error::invalid_length(
			len,
			&"fewer elements in map",
		))
	}
}

struct ArrayDeserializer {
	iter: std::vec::IntoIter<JsonValue>,
}

impl ArrayDeserializer {
	fn new(array: JsonArrayBuf) -> Self {
		Self {
			iter: array.into_iter(),
		}
	}
}

impl<'de> SeqAccess<'de> for ArrayDeserializer {
	type Error = DeserializeError;

	fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
	where
		T: DeserializeSeed<'de>,
	{
		match self.iter.next() {
			Some(value) => seed.deserialize(value).map(Some),
			None => Ok(None),
		}
	}

	fn size_hint(&self) -> Option<usize> {
		match self.iter.size_hint() {
			(lower, Some(upper)) if lower == upper => Some(upper),
			_ => None,
		}
	}
}

struct ObjectDeserializer {
	iter: std::vec::IntoIter<Entry>,
	value: Option<JsonValue>,
}

impl ObjectDeserializer {
	fn new(obj: JsonObject) -> Self {
		Self {
			iter: obj.into_iter(),
			value: None,
		}
	}
}

impl<'de> MapAccess<'de> for ObjectDeserializer {
	type Error = DeserializeError;

	fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
	where
		T: DeserializeSeed<'de>,
	{
		match self.iter.next() {
			Some((key, value)) => {
				self.value = Some(value);
				let key_de = MapKeyDeserializer { key };
				seed.deserialize(key_de).map(Some)
			}
			None => Ok(None),
		}
	}

	fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
	where
		T: DeserializeSeed<'de>,
	{
		match self.value.take() {
			Some(value) => seed.deserialize(value),
			None => Err(serde::de::Error::custom("value is missing")),
		}
	}

	fn size_hint(&self) -> Option<usize> {
		match self.iter.size_hint() {
			(lower, Some(upper)) if lower == upper => Some(upper),
			_ => None,
		}
	}
}

struct MapKeyDeserializer {
	key: Key,
}

macro_rules! deserialize_integer_key {
	($method:ident => $visit:ident) => {
		fn $method<V>(self, visitor: V) -> Result<V::Value, Self::Error>
		where
			V: serde::de::Visitor<'de>,
		{
			match (self.key.parse(), self.key) {
				(Ok(integer), _) => visitor.$visit(integer),
				(Err(_), key) => visitor.visit_string(key.into_string()),
			}
		}
	};
}

impl<'de> serde::Deserializer<'de> for MapKeyDeserializer {
	type Error = DeserializeError;

	fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		visitor.visit_string(self.key.into_string())
	}

	deserialize_integer_key!(deserialize_i8 => visit_i8);
	deserialize_integer_key!(deserialize_i16 => visit_i16);
	deserialize_integer_key!(deserialize_i32 => visit_i32);
	deserialize_integer_key!(deserialize_i64 => visit_i64);
	deserialize_integer_key!(deserialize_i128 => visit_i128);
	deserialize_integer_key!(deserialize_u8 => visit_u8);
	deserialize_integer_key!(deserialize_u16 => visit_u16);
	deserialize_integer_key!(deserialize_u32 => visit_u32);
	deserialize_integer_key!(deserialize_u64 => visit_u64);
	deserialize_integer_key!(deserialize_u128 => visit_u128);

	#[inline]
	fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		// Map keys cannot be null.
		visitor.visit_some(self)
	}

	#[inline]
	fn deserialize_newtype_struct<V>(
		self,
		_name: &'static str,
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		visitor.visit_newtype_struct(self)
	}

	fn deserialize_enum<V>(
		self,
		name: &'static str,
		variants: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		self.key
			.into_deserializer()
			.deserialize_enum(name, variants, visitor)
	}

	forward_to_deserialize_any! {
		bool f32 f64 char str string bytes byte_buf unit unit_struct seq tuple
		tuple_struct map struct identifier ignored_any
	}
}

struct EnumDeserializer {
	variant: Key,
	value: Option<JsonValue>,
}

impl<'de> EnumAccess<'de> for EnumDeserializer {
	type Error = DeserializeError;
	type Variant = VariantDeserializer;

	fn variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer), Self::Error>
	where
		V: DeserializeSeed<'de>,
	{
		let variant = self.variant.into_deserializer();
		let visitor = VariantDeserializer { value: self.value };
		seed.deserialize(variant).map(|v| (v, visitor))
	}
}

struct VariantDeserializer {
	value: Option<JsonValue>,
}

impl<'de> VariantAccess<'de> for VariantDeserializer {
	type Error = DeserializeError;

	fn unit_variant(self) -> Result<(), Self::Error> {
		match self.value {
			Some(value) => serde::Deserialize::deserialize(value),
			None => Ok(()),
		}
	}

	fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
	where
		T: DeserializeSeed<'de>,
	{
		match self.value {
			Some(value) => seed.deserialize(value),
			None => Err(serde::de::Error::invalid_type(
				Unexpected::UnitVariant,
				&"newtype variant",
			)),
		}
	}

	fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self.value {
			Some(JsonValue::Array(v)) => {
				if v.is_empty() {
					visitor.visit_unit()
				} else {
					visit_array(v, visitor)
				}
			}
			Some(other) => Err(serde::de::Error::invalid_type(
				other.unexpected(),
				&"tuple variant",
			)),
			None => Err(serde::de::Error::invalid_type(
				Unexpected::UnitVariant,
				&"tuple variant",
			)),
		}
	}

	fn struct_variant<V>(
		self,
		_fields: &'static [&'static str],
		visitor: V,
	) -> Result<V::Value, Self::Error>
	where
		V: serde::de::Visitor<'de>,
	{
		match self.value {
			Some(JsonValue::Object(v)) => visit_object(v, visitor),
			Some(other) => Err(serde::de::Error::invalid_type(
				other.unexpected(),
				&"struct variant",
			)),
			None => Err(serde::de::Error::invalid_type(
				Unexpected::UnitVariant,
				&"struct variant",
			)),
		}
	}
}