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) => {165 if n.fract() != 0.0 {166 serializer.serialize_f64(*n)167 } else {168 let n = *n as i64;169 serializer.serialize_i64(n)170 }171 }172 #[cfg(feature = "exp-bigint")]173 Val::BigInt(b) => b.serialize(serializer),174 Val::Arr(arr) => {175 let mut seq = serializer.serialize_seq(Some(arr.len()))?;176 for (i, element) in arr.iter().enumerate() {177 let mut serde_error = None;178 179 State::push_description(180 || format!("array index [{i}]"),181 || {182 let e = element?;183 if let Err(e) = seq.serialize_element(&e) {184 serde_error = Some(e);185 }186 Ok(())187 },188 )189 .map_err(|e| S::Error::custom(e.to_string()))?;190 if let Some(e) = serde_error {191 return Err(e);192 }193 }194 seq.end()195 }196 Val::Obj(obj) => {197 let mut map = serializer.serialize_map(Some(obj.len()))?;198 for (field, value) in obj.iter(199 #[cfg(feature = "exp-preserve-order")]200 true,201 ) {202 let mut serde_error = None;203 204 State::push_description(205 || format!("object field {field:?}"),206 || {207 let v = value?;208 if let Err(e) = map.serialize_entry(field.as_str(), &v) {209 serde_error = Some(e);210 }211 Ok(())212 },213 )214 .map_err(|e| S::Error::custom(e.to_string()))?;215 if let Some(e) = serde_error {216 return Err(e);217 }218 }219 map.end()220 }221 Val::Func(_) => Err(S::Error::custom("tried to manifest function")),222 }223 }224}225226struct IntoVecValSerializer {227 variant: Option<IStr>,228 data: Vec<Val>,229}230impl IntoVecValSerializer {231 fn new() -> Self {232 Self {233 variant: None,234 data: Vec::new(),235 }236 }237 fn with_capacity(capacity: usize) -> Self {238 Self {239 variant: None,240 data: Vec::with_capacity(capacity),241 }242 }243 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {244 Self {245 variant: Some(variant.into()),246 data: Vec::with_capacity(capacity),247 }248 }249}250impl SerializeSeq for IntoVecValSerializer {251 type Ok = Val;252 type Error = JrError;253254 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>255 where256 T: Serialize,257 {258 let value = value.serialize(IntoValSerializer)?;259 self.data.push(value);260 Ok(())261 }262263 fn end(self) -> Result<Val> {264 let inner = Val::Arr(ArrValue::eager(self.data));265 if let Some(variant) = self.variant {266 let mut out = ObjValue::builder_with_capacity(1);267 out.member(variant).value_unchecked(inner);268 Ok(Val::Obj(out.build()))269 } else {270 Ok(inner)271 }272 }273}274impl SerializeTuple for IntoVecValSerializer {275 type Ok = Val;276 type Error = JrError;277278 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>279 where280 T: Serialize,281 {282 SerializeSeq::serialize_element(self, value)283 }284285 fn end(self) -> Result<Val> {286 SerializeSeq::end(self)287 }288}289impl SerializeTupleVariant for IntoVecValSerializer {290 type Ok = Val;291 type Error = JrError;292293 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>294 where295 T: Serialize,296 {297 SerializeSeq::serialize_element(self, value)298 }299300 fn end(self) -> Result<Val> {301 SerializeSeq::end(self)302 }303}304impl SerializeTupleStruct for IntoVecValSerializer {305 type Ok = Val;306 type Error = JrError;307308 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>309 where310 T: Serialize,311 {312 SerializeSeq::serialize_element(self, value)313 }314315 fn end(self) -> Result<Val> {316 SerializeSeq::end(self)317 }318}319320struct IntoObjValueSerializer {321 variant: Option<IStr>,322 data: ObjValueBuilder,323 key: Option<IStr>,324}325impl IntoObjValueSerializer {326 fn new() -> Self {327 Self {328 variant: None,329 data: ObjValue::builder(),330 key: None,331 }332 }333 fn with_capacity(capacity: usize) -> Self {334 Self {335 variant: None,336 data: ObjValue::builder_with_capacity(capacity),337 key: None,338 }339 }340 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {341 Self {342 variant: Some(variant.into()),343 data: ObjValue::builder_with_capacity(capacity),344 key: None,345 }346 }347}348impl SerializeMap for IntoObjValueSerializer {349 type Ok = Val;350 type Error = JrError;351352 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>353 where354 T: Serialize,355 {356 let key = key.serialize(IntoValSerializer)?;357 let key = key.to_string()?;358 self.key = Some(key);359 Ok(())360 }361362 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>363 where364 T: Serialize,365 {366 let key = self.key.take().expect("no serialize_key called");367 let value = value.serialize(IntoValSerializer)?;368 self.data.member(key).value(value)?;369 Ok(())370 }371372 373 fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>374 where375 K: Serialize,376 V: Serialize,377 {378 let key = key.serialize(IntoValSerializer)?;379 let key = key.to_string()?;380 let value = value.serialize(IntoValSerializer)?;381 self.data.member(key).value(value)?;382 Ok(())383 }384385 fn end(self) -> Result<Val> {386 let inner = Val::Obj(self.data.build());387 if let Some(variant) = self.variant {388 let mut out = ObjValue::builder_with_capacity(1);389 out.member(variant).value_unchecked(inner);390 Ok(Val::Obj(out.build()))391 } else {392 Ok(inner)393 }394 }395}396impl SerializeStruct for IntoObjValueSerializer {397 type Ok = Val;398 type Error = JrError;399400 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>401 where402 T: Serialize,403 {404 SerializeMap::serialize_entry(self, key, value)?;405 Ok(())406 }407408 fn end(self) -> Result<Val> {409 SerializeMap::end(self)410 }411}412impl SerializeStructVariant for IntoObjValueSerializer {413 type Ok = Val;414415 type Error = JrError;416417 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>418 where419 T: Serialize,420 {421 SerializeMap::serialize_entry(self, key, value)?;422 Ok(())423 }424425 fn end(self) -> Result<Val> {426 SerializeMap::end(self)427 }428}429430struct IntoValSerializer;431impl Serializer for IntoValSerializer {432 type Ok = Val;433434 type Error = JrError;435436 type SerializeSeq = IntoVecValSerializer;437438 type SerializeTuple = IntoVecValSerializer;439440 type SerializeTupleStruct = IntoVecValSerializer;441442 type SerializeTupleVariant = IntoVecValSerializer;443444 type SerializeMap = IntoObjValueSerializer;445446 type SerializeStruct = IntoObjValueSerializer;447448 type SerializeStructVariant = IntoObjValueSerializer;449450 fn serialize_bool(self, v: bool) -> Result<Val> {451 Ok(Val::Bool(v))452 }453454 fn serialize_i8(self, v: i8) -> Result<Val> {455 Ok(Val::Num(f64::from(v)))456 }457458 fn serialize_i16(self, v: i16) -> Result<Val> {459 Ok(Val::Num(f64::from(v)))460 }461462 fn serialize_i32(self, v: i32) -> Result<Val> {463 Ok(Val::Num(f64::from(v)))464 }465466 fn serialize_i64(self, v: i64) -> Result<Val> {467 Ok(Val::Str(v.to_string().into()))468 }469470 fn serialize_u8(self, v: u8) -> Result<Val> {471 Ok(Val::Num(f64::from(v)))472 }473474 fn serialize_u16(self, v: u16) -> Result<Val> {475 Ok(Val::Num(f64::from(v)))476 }477478 fn serialize_u32(self, v: u32) -> Result<Val> {479 Ok(Val::Num(f64::from(v)))480 }481482 fn serialize_u64(self, v: u64) -> Result<Val> {483 Ok(Val::Str(v.to_string().into()))484 }485486 fn serialize_f32(self, v: f32) -> Result<Val> {487 Ok(Val::Num(f64::from(v)))488 }489490 fn serialize_f64(self, v: f64) -> Result<Val> {491 Ok(Val::Num(v))492 }493494 fn serialize_char(self, v: char) -> Result<Val> {495 Ok(Val::Str(v.to_string().into()))496 }497498 fn serialize_str(self, v: &str) -> Result<Val> {499 Ok(Val::Str(v.into()))500 }501502 fn serialize_bytes(self, v: &[u8]) -> Result<Val> {503 Ok(Val::Arr(ArrValue::bytes(v.into())))504 }505506 fn serialize_none(self) -> Result<Val> {507 Ok(Val::Null)508 }509510 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Val>511 where512 T: Serialize,513 {514 value.serialize(self)515 }516517 fn serialize_unit(self) -> Result<Val> {518 Ok(Val::Null)519 }520521 fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {522 Ok(Val::Null)523 }524525 fn serialize_unit_variant(526 self,527 _name: &'static str,528 _variant_index: u32,529 variant: &'static str,530 ) -> Result<Val> {531 Ok(Val::Str(variant.into()))532 }533534 fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Val>535 where536 T: Serialize,537 {538 value.serialize(self)539 }540541 fn serialize_newtype_variant<T: ?Sized>(542 self,543 _name: &'static str,544 _variant_index: u32,545 variant: &'static str,546 value: &T,547 ) -> Result<Val>548 where549 T: Serialize,550 {551 let mut out = ObjValue::builder_with_capacity(1);552 let value = value.serialize(self)?;553 out.member(variant.into()).value_unchecked(value);554 Ok(Val::Obj(out.build()))555 }556557 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {558 Ok(len.map_or_else(559 IntoVecValSerializer::new,560 IntoVecValSerializer::with_capacity,561 ))562 }563564 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {565 Ok(IntoVecValSerializer::with_capacity(len))566 }567568 fn serialize_tuple_struct(569 self,570 _name: &'static str,571 len: usize,572 ) -> Result<Self::SerializeTupleStruct, Self::Error> {573 Ok(IntoVecValSerializer::with_capacity(len))574 }575576 fn serialize_tuple_variant(577 self,578 _name: &'static str,579 _variant_index: u32,580 variant: &'static str,581 len: usize,582 ) -> Result<Self::SerializeTupleVariant, Self::Error> {583 Ok(IntoVecValSerializer::variant_with_capacity(variant, len))584 }585586 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {587 Ok(len.map_or_else(588 IntoObjValueSerializer::new,589 IntoObjValueSerializer::with_capacity,590 ))591 }592593 fn serialize_struct(594 self,595 _name: &'static str,596 len: usize,597 ) -> Result<Self::SerializeStruct, Self::Error> {598 Ok(IntoObjValueSerializer::with_capacity(len))599 }600601 fn serialize_struct_variant(602 self,603 _name: &'static str,604 _variant_index: u32,605 variant: &'static str,606 len: usize,607 ) -> Result<Self::SerializeStructVariant, Self::Error> {608 Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))609 }610}611612impl Val {613 pub fn from_serde(v: impl Serialize) -> Result<Val, JrError> {614 v.serialize(IntoValSerializer)615 }616}617618impl serde::ser::Error for JrError {619 fn custom<T>(msg: T) -> Self620 where621 T: std::fmt::Display,622 {623 JrError::new(ErrorKind::RuntimeError(format!("serde: {msg}").into()))624 }625}