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 28 29 30 31 32 33 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 64 65 66 67 68 69 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 141 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 172 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 197 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 366 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}