git.delta.rocks / jrsonnet / refs/commits / d0fb5f4781e5

1use std::borrow::Cow;23use jrsonnet_interner::IStr;4use serde::{5	de::Visitor,6	ser::{7		Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,8		SerializeTupleStruct, SerializeTupleVariant,9	},10	Deserialize, Serialize, Serializer,11};1213use crate::{14	arr::ArrValue,15	error::{Error as JrError, ErrorKind, Result},16	val::StrValue,17	ObjValue, ObjValueBuilder, State, Val,18};1920impl<'de> Deserialize<'de> for Val {21	fn deserialize<D>(deserializer: D) -> Result<Val, D::Error>22	where23		D: serde::Deserializer<'de>,24	{25		struct ValVisitor;2627		// macro_rules! visit_num {28		// 	($($method:ident => $ty:ty),* $(,)?) => {$(29		// 		fn $method<E>(self, v: $ty) -> Result<Self::Value, E>30		// 		where31		// 			E: serde::de::Error,32		// 		{33		// 			Ok(Val::Num(f64::from(v)))34		// 		}35		// 	)*};36		// }3738		impl<'de> Visitor<'de> for ValVisitor {39			type Value = Val;4041			fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>42			where43				E: serde::de::Error,44			{45				Ok(Val::Bool(v))46			}47			fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>48			where49				E: serde::de::Error,50			{51				if !v.is_finite() {52					return Err(E::custom("only finite numbers are supported"));53				}54				Ok(Val::Num(v))55			}56			fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>57			where58				E: serde::de::Error,59			{60				Ok(Val::Str(StrValue::Flat(v.into())))61			}6263			// visit_num! {64			// 	visit_i8 => i8,65			// 	visit_i16 => i16,66			// 	visit_i32 => i32,67			// 	visit_u8 => u8,68			// 	visit_u16 => u16,69			// 	visit_u32 => u32,70			// }71			fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>72			where73				E: serde::de::Error,74			{75				Ok(Val::Num(v as f64))76			}77			fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>78			where79				E: serde::de::Error,80			{81				Ok(Val::Num(v as f64))82			}8384			fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>85			where86				E: serde::de::Error,87			{88				Ok(Val::Arr(ArrValue::bytes(v.into())))89			}9091			fn visit_none<E>(self) -> Result<Self::Value, E>92			where93				E: serde::de::Error,94			{95				Ok(Val::Null)96			}97			fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>98			where99				D: serde::Deserializer<'de>,100			{101				deserializer.deserialize_any(self)102			}103104			fn visit_unit<E>(self) -> Result<Self::Value, E>105			where106				E: serde::de::Error,107			{108				Ok(Val::Null)109			}110111			fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>112			where113				D: serde::Deserializer<'de>,114			{115				deserializer.deserialize_any(self)116			}117118			fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>119			where120				A: serde::de::SeqAccess<'de>,121			{122				let mut out = seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);123124				while let Some(val) = seq.next_element::<Val>()? {125					out.push(val);126				}127128				Ok(Val::Arr(ArrValue::eager(out)))129			}130131			fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>132			where133				A: serde::de::MapAccess<'de>,134			{135				let mut out = map136					.size_hint()137					.map_or_else(ObjValueBuilder::new, ObjValueBuilder::with_capacity);138139				while let Some((k, v)) = map.next_entry::<Cow<'de, str>, Val>()? {140					// Jsonnet ignores duplicate keys141					out.member(k.into()).value_unchecked(v);142				}143144				Ok(Val::Obj(out.build()))145			}146147			fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {148				write!(formatter, "any valid jsonnet value")149			}150		}151		deserializer.deserialize_any(ValVisitor)152	}153}154155impl Serialize for Val {156	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>157	where158		S: serde::Serializer,159	{160		match self {161			Val::Bool(v) => serializer.serialize_bool(*v),162			Val::Null => serializer.serialize_none(),163			Val::Str(s) => serializer.serialize_str(&s.clone().into_flat()),164			Val::Num(n) => serializer.serialize_f64(*n),165			#[cfg(feature = "exp-bigint")]166			Val::BigInt(b) => b.serialize(serializer),167			Val::Arr(arr) => {168				let mut seq = serializer.serialize_seq(Some(arr.len()))?;169				for (i, element) in arr.iter().enumerate() {170					let mut serde_error = None;171					// TODO: rewrite using try{} after stabilization172					State::push_description(173						|| format!("array index [{i}]"),174						|| {175							let e = element?;176							if let Err(e) = seq.serialize_element(&e) {177								serde_error = Some(e);178							}179							Ok(())180						},181					)182					.map_err(|e| S::Error::custom(e.to_string()))?;183					if let Some(e) = serde_error {184						return Err(e);185					}186				}187				seq.end()188			}189			Val::Obj(obj) => {190				let mut map = serializer.serialize_map(Some(obj.len()))?;191				for (field, value) in obj.iter(192					#[cfg(feature = "exp-preserve-order")]193					true,194				) {195					let mut serde_error = None;196					// TODO: rewrite using try{} after stabilization197					State::push_description(198						|| format!("object field {field:?}"),199						|| {200							let v = value?;201							if let Err(e) = map.serialize_entry(field.as_str(), &v) {202								serde_error = Some(e);203							}204							Ok(())205						},206					)207					.map_err(|e| S::Error::custom(e.to_string()))?;208					if let Some(e) = serde_error {209						return Err(e);210					}211				}212				map.end()213			}214			Val::Func(_) => Err(S::Error::custom("tried to manifest function")),215		}216	}217}218219struct IntoVecValSerializer {220	variant: Option<IStr>,221	data: Vec<Val>,222}223impl IntoVecValSerializer {224	fn new() -> Self {225		Self {226			variant: None,227			data: Vec::new(),228		}229	}230	fn with_capacity(capacity: usize) -> Self {231		Self {232			variant: None,233			data: Vec::with_capacity(capacity),234		}235	}236	fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {237		Self {238			variant: Some(variant.into()),239			data: Vec::with_capacity(capacity),240		}241	}242}243impl SerializeSeq for IntoVecValSerializer {244	type Ok = Val;245	type Error = JrError;246247	fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>248	where249		T: Serialize,250	{251		let value = value.serialize(IntoValSerializer)?;252		self.data.push(value);253		Ok(())254	}255256	fn end(self) -> Result<Val> {257		let inner = Val::Arr(ArrValue::eager(self.data));258		if let Some(variant) = self.variant {259			let mut out = ObjValue::builder_with_capacity(1);260			out.member(variant).value_unchecked(inner);261			Ok(Val::Obj(out.build()))262		} else {263			Ok(inner)264		}265	}266}267impl SerializeTuple for IntoVecValSerializer {268	type Ok = Val;269	type Error = JrError;270271	fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>272	where273		T: Serialize,274	{275		SerializeSeq::serialize_element(self, value)276	}277278	fn end(self) -> Result<Val> {279		SerializeSeq::end(self)280	}281}282impl SerializeTupleVariant for IntoVecValSerializer {283	type Ok = Val;284	type Error = JrError;285286	fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>287	where288		T: Serialize,289	{290		SerializeSeq::serialize_element(self, value)291	}292293	fn end(self) -> Result<Val> {294		SerializeSeq::end(self)295	}296}297impl SerializeTupleStruct for IntoVecValSerializer {298	type Ok = Val;299	type Error = JrError;300301	fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>302	where303		T: Serialize,304	{305		SerializeSeq::serialize_element(self, value)306	}307308	fn end(self) -> Result<Val> {309		SerializeSeq::end(self)310	}311}312313struct IntoObjValueSerializer {314	variant: Option<IStr>,315	data: ObjValueBuilder,316	key: Option<IStr>,317}318impl IntoObjValueSerializer {319	fn new() -> Self {320		Self {321			variant: None,322			data: ObjValue::builder(),323			key: None,324		}325	}326	fn with_capacity(capacity: usize) -> Self {327		Self {328			variant: None,329			data: ObjValue::builder_with_capacity(capacity),330			key: None,331		}332	}333	fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {334		Self {335			variant: Some(variant.into()),336			data: ObjValue::builder_with_capacity(capacity),337			key: None,338		}339	}340}341impl SerializeMap for IntoObjValueSerializer {342	type Ok = Val;343	type Error = JrError;344345	fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>346	where347		T: Serialize,348	{349		let key = key.serialize(IntoValSerializer)?;350		let key = key.to_string()?;351		self.key = Some(key);352		Ok(())353	}354355	fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>356	where357		T: Serialize,358	{359		let key = self.key.take().expect("no serialize_key called");360		let value = value.serialize(IntoValSerializer)?;361		self.data.member(key).value(value)?;362		Ok(())363	}364365	// TODO: serialize_key/serialize_value366	fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>367	where368		K: Serialize,369		V: Serialize,370	{371		let key = key.serialize(IntoValSerializer)?;372		let key = key.to_string()?;373		let value = value.serialize(IntoValSerializer)?;374		self.data.member(key).value(value)?;375		Ok(())376	}377378	fn end(self) -> Result<Val> {379		let inner = Val::Obj(self.data.build());380		if let Some(variant) = self.variant {381			let mut out = ObjValue::builder_with_capacity(1);382			out.member(variant).value_unchecked(inner);383			Ok(Val::Obj(out.build()))384		} else {385			Ok(inner)386		}387	}388}389impl SerializeStruct for IntoObjValueSerializer {390	type Ok = Val;391	type Error = JrError;392393	fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>394	where395		T: Serialize,396	{397		SerializeMap::serialize_entry(self, key, value)?;398		Ok(())399	}400401	fn end(self) -> Result<Val> {402		SerializeMap::end(self)403	}404}405impl SerializeStructVariant for IntoObjValueSerializer {406	type Ok = Val;407408	type Error = JrError;409410	fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>411	where412		T: Serialize,413	{414		SerializeMap::serialize_entry(self, key, value)?;415		Ok(())416	}417418	fn end(self) -> Result<Val> {419		SerializeMap::end(self)420	}421}422423struct IntoValSerializer;424impl Serializer for IntoValSerializer {425	type Ok = Val;426427	type Error = JrError;428429	type SerializeSeq = IntoVecValSerializer;430431	type SerializeTuple = IntoVecValSerializer;432433	type SerializeTupleStruct = IntoVecValSerializer;434435	type SerializeTupleVariant = IntoVecValSerializer;436437	type SerializeMap = IntoObjValueSerializer;438439	type SerializeStruct = IntoObjValueSerializer;440441	type SerializeStructVariant = IntoObjValueSerializer;442443	fn serialize_bool(self, v: bool) -> Result<Val> {444		Ok(Val::Bool(v))445	}446447	fn serialize_i8(self, v: i8) -> Result<Val> {448		Ok(Val::Num(f64::from(v)))449	}450451	fn serialize_i16(self, v: i16) -> Result<Val> {452		Ok(Val::Num(f64::from(v)))453	}454455	fn serialize_i32(self, v: i32) -> Result<Val> {456		Ok(Val::Num(f64::from(v)))457	}458459	fn serialize_i64(self, v: i64) -> Result<Val> {460		Ok(Val::Str(v.to_string().into()))461	}462463	fn serialize_u8(self, v: u8) -> Result<Val> {464		Ok(Val::Num(f64::from(v)))465	}466467	fn serialize_u16(self, v: u16) -> Result<Val> {468		Ok(Val::Num(f64::from(v)))469	}470471	fn serialize_u32(self, v: u32) -> Result<Val> {472		Ok(Val::Num(f64::from(v)))473	}474475	fn serialize_u64(self, v: u64) -> Result<Val> {476		Ok(Val::Str(v.to_string().into()))477	}478479	fn serialize_f32(self, v: f32) -> Result<Val> {480		Ok(Val::Num(f64::from(v)))481	}482483	fn serialize_f64(self, v: f64) -> Result<Val> {484		Ok(Val::Num(v))485	}486487	fn serialize_char(self, v: char) -> Result<Val> {488		Ok(Val::Str(v.to_string().into()))489	}490491	fn serialize_str(self, v: &str) -> Result<Val> {492		Ok(Val::Str(v.into()))493	}494495	fn serialize_bytes(self, v: &[u8]) -> Result<Val> {496		Ok(Val::Arr(ArrValue::bytes(v.into())))497	}498499	fn serialize_none(self) -> Result<Val> {500		Ok(Val::Null)501	}502503	fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Val>504	where505		T: Serialize,506	{507		value.serialize(self)508	}509510	fn serialize_unit(self) -> Result<Val> {511		Ok(Val::Null)512	}513514	fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {515		Ok(Val::Null)516	}517518	fn serialize_unit_variant(519		self,520		_name: &'static str,521		_variant_index: u32,522		variant: &'static str,523	) -> Result<Val> {524		Ok(Val::Str(variant.into()))525	}526527	fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Val>528	where529		T: Serialize,530	{531		value.serialize(self)532	}533534	fn serialize_newtype_variant<T: ?Sized>(535		self,536		_name: &'static str,537		_variant_index: u32,538		variant: &'static str,539		value: &T,540	) -> Result<Val>541	where542		T: Serialize,543	{544		let mut out = ObjValue::builder_with_capacity(1);545		let value = value.serialize(self)?;546		out.member(variant.into()).value_unchecked(value);547		Ok(Val::Obj(out.build()))548	}549550	fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {551		Ok(len.map_or_else(552			IntoVecValSerializer::new,553			IntoVecValSerializer::with_capacity,554		))555	}556557	fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {558		Ok(IntoVecValSerializer::with_capacity(len))559	}560561	fn serialize_tuple_struct(562		self,563		_name: &'static str,564		len: usize,565	) -> Result<Self::SerializeTupleStruct, Self::Error> {566		Ok(IntoVecValSerializer::with_capacity(len))567	}568569	fn serialize_tuple_variant(570		self,571		_name: &'static str,572		_variant_index: u32,573		variant: &'static str,574		len: usize,575	) -> Result<Self::SerializeTupleVariant, Self::Error> {576		Ok(IntoVecValSerializer::variant_with_capacity(variant, len))577	}578579	fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {580		Ok(len.map_or_else(581			IntoObjValueSerializer::new,582			IntoObjValueSerializer::with_capacity,583		))584	}585586	fn serialize_struct(587		self,588		_name: &'static str,589		len: usize,590	) -> Result<Self::SerializeStruct, Self::Error> {591		Ok(IntoObjValueSerializer::with_capacity(len))592	}593594	fn serialize_struct_variant(595		self,596		_name: &'static str,597		_variant_index: u32,598		variant: &'static str,599		len: usize,600	) -> Result<Self::SerializeStructVariant, Self::Error> {601		Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))602	}603}604605impl Val {606	pub fn from_serde(v: impl Serialize) -> Result<Val, JrError> {607		v.serialize(IntoValSerializer)608	}609}610611impl serde::ser::Error for JrError {612	fn custom<T>(msg: T) -> Self613	where614		T: std::fmt::Display,615	{616		JrError::new(ErrorKind::RuntimeError(format!("serde: {msg}").into()))617	}618}