1use std::borrow::Cow;23use jrsonnet_interner::IStr;4use serde::{5 de::{self, Visitor},6 ser::{7 Error, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,8 SerializeTupleStruct, SerializeTupleVariant,9 },10 Deserialize, Serialize, Serializer,11};1213use crate::{14 arr::ArrValue, runtime_error, val::NumValue, Error as JrError, ObjValue, ObjValueBuilder,15 Result, State, Val,16};1718impl<'de> Deserialize<'de> for Val {19 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>20 where21 D: serde::Deserializer<'de>,22 {23 struct ValVisitor;2425 26 27 28 29 30 31 32 33 34 3536 impl<'de> Visitor<'de> for ValVisitor {37 type Value = Val;3839 fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>40 where41 E: de::Error,42 {43 Ok(Val::Bool(v))44 }45 fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>46 where47 E: de::Error,48 {49 Ok(Val::Num(NumValue::new(v).ok_or_else(|| {50 E::custom("only finite numbers are supported")51 })?))52 }53 fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>54 where55 E: de::Error,56 {57 Ok(Val::string(v))58 }5960 61 62 63 64 65 66 67 68 fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>69 where70 E: de::Error,71 {72 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))73 }74 fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>75 where76 E: de::Error,77 {78 Ok(Val::Num(NumValue::new(v as f64).expect("no overflow")))79 }8081 fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>82 where83 E: de::Error,84 {85 Ok(Val::Arr(ArrValue::bytes(v.into())))86 }8788 fn visit_none<E>(self) -> Result<Self::Value, E>89 where90 E: de::Error,91 {92 Ok(Val::Null)93 }94 fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>95 where96 D: serde::Deserializer<'de>,97 {98 deserializer.deserialize_any(self)99 }100101 fn visit_unit<E>(self) -> Result<Self::Value, E>102 where103 E: de::Error,104 {105 Ok(Val::Null)106 }107108 fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>109 where110 D: serde::Deserializer<'de>,111 {112 deserializer.deserialize_any(self)113 }114115 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>116 where117 A: de::SeqAccess<'de>,118 {119 let mut out = seq.size_hint().map_or_else(Vec::new, Vec::with_capacity);120121 while let Some(val) = seq.next_element::<Val>()? {122 out.push(val);123 }124125 Ok(Val::Arr(ArrValue::eager(out)))126 }127128 fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>129 where130 A: de::MapAccess<'de>,131 {132 let mut out = map133 .size_hint()134 .map_or_else(ObjValueBuilder::new, ObjValueBuilder::with_capacity);135136 while let Some((k, v)) = map.next_entry::<Cow<'de, str>, Val>()? {137 138 out.field(k).value(v);139 }140141 Ok(Val::Obj(out.build()))142 }143144 fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {145 write!(formatter, "any valid jsonnet value")146 }147 }148 deserializer.deserialize_any(ValVisitor)149 }150}151152impl Serialize for Val {153 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>154 where155 S: serde::Serializer,156 {157 match self {158 Self::Bool(v) => serializer.serialize_bool(*v),159 Self::Null => serializer.serialize_none(),160 Self::Str(s) => serializer.serialize_str(&s.clone().into_flat()),161 Self::Num(n) => {162 let n = n.get();163 if n.fract() == 0.0 {164 let n = n as i64;165 serializer.serialize_i64(n)166 } else {167 serializer.serialize_f64(n)168 }169 }170 #[cfg(feature = "exp-bigint")]171 Self::BigInt(b) => b.serialize(serializer),172 Self::Arr(arr) => {173 let mut seq = serializer.serialize_seq(Some(arr.len()))?;174 for (i, element) in arr.iter().enumerate() {175 let mut serde_error = None;176 177 State::push_description(178 || format!("array index [{i}]"),179 || {180 let e = element?;181 if let Err(e) = seq.serialize_element(&e) {182 serde_error = Some(e);183 }184 Ok(())185 },186 )187 .map_err(|e| S::Error::custom(e.to_string()))?;188 if let Some(e) = serde_error {189 return Err(e);190 }191 }192 seq.end()193 }194 Self::Obj(obj) => {195 let mut map = serializer.serialize_map(Some(obj.len()))?;196 for (field, value) in obj.iter(197 #[cfg(feature = "exp-preserve-order")]198 true,199 ) {200 let mut serde_error = None;201 202 State::push_description(203 || format!("object field {field:?}"),204 || {205 let v = value?;206 if let Err(e) = map.serialize_entry(field.as_str(), &v) {207 serde_error = Some(e);208 }209 Ok(())210 },211 )212 .map_err(|e| S::Error::custom(e.to_string()))?;213 if let Some(e) = serde_error {214 return Err(e);215 }216 }217 map.end()218 }219 Self::Func(_) => Err(S::Error::custom("tried to manifest function")),220 }221 }222}223224struct IntoVecValSerializer {225 variant: Option<IStr>,226 data: Vec<Val>,227}228impl IntoVecValSerializer {229 fn new() -> Self {230 Self {231 variant: None,232 data: Vec::new(),233 }234 }235 fn with_capacity(capacity: usize) -> Self {236 Self {237 variant: None,238 data: Vec::with_capacity(capacity),239 }240 }241 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {242 Self {243 variant: Some(variant.into()),244 data: Vec::with_capacity(capacity),245 }246 }247}248impl SerializeSeq for IntoVecValSerializer {249 type Ok = Val;250 type Error = JrError;251252 fn serialize_element<T>(&mut self, value: &T) -> Result<()>253 where254 T: ?Sized + Serialize,255 {256 let value = value.serialize(IntoValSerializer)?;257 self.data.push(value);258 Ok(())259 }260261 fn end(self) -> Result<Val> {262 let inner = Val::Arr(ArrValue::eager(self.data));263 if let Some(variant) = self.variant {264 let mut out = ObjValue::builder_with_capacity(1);265 out.field(variant).value(inner);266 Ok(Val::Obj(out.build()))267 } else {268 Ok(inner)269 }270 }271}272impl SerializeTuple for IntoVecValSerializer {273 type Ok = Val;274 type Error = JrError;275276 fn serialize_element<T>(&mut self, value: &T) -> Result<()>277 where278 T: ?Sized + Serialize,279 {280 SerializeSeq::serialize_element(self, value)281 }282283 fn end(self) -> Result<Val> {284 SerializeSeq::end(self)285 }286}287impl SerializeTupleVariant for IntoVecValSerializer {288 type Ok = Val;289 type Error = JrError;290291 fn serialize_field<T>(&mut self, value: &T) -> Result<()>292 where293 T: ?Sized + Serialize,294 {295 SerializeSeq::serialize_element(self, value)296 }297298 fn end(self) -> Result<Val> {299 SerializeSeq::end(self)300 }301}302impl SerializeTupleStruct for IntoVecValSerializer {303 type Ok = Val;304 type Error = JrError;305306 fn serialize_field<T>(&mut self, value: &T) -> Result<()>307 where308 T: ?Sized + Serialize,309 {310 SerializeSeq::serialize_element(self, value)311 }312313 fn end(self) -> Result<Val> {314 SerializeSeq::end(self)315 }316}317318struct IntoObjValueSerializer {319 variant: Option<IStr>,320 data: ObjValueBuilder,321 key: Option<IStr>,322}323impl IntoObjValueSerializer {324 fn new() -> Self {325 Self {326 variant: None,327 data: ObjValue::builder(),328 key: None,329 }330 }331 fn with_capacity(capacity: usize) -> Self {332 Self {333 variant: None,334 data: ObjValue::builder_with_capacity(capacity),335 key: None,336 }337 }338 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {339 Self {340 variant: Some(variant.into()),341 data: ObjValue::builder_with_capacity(capacity),342 key: None,343 }344 }345}346impl SerializeMap for IntoObjValueSerializer {347 type Ok = Val;348 type Error = JrError;349350 fn serialize_key<T>(&mut self, key: &T) -> Result<()>351 where352 T: ?Sized + Serialize,353 {354 let key = key.serialize(IntoValSerializer)?;355 let key = key.to_string()?;356 self.key = Some(key);357 Ok(())358 }359360 fn serialize_value<T>(&mut self, value: &T) -> Result<()>361 where362 T: ?Sized + Serialize,363 {364 let key = self.key.take().expect("no serialize_key called");365 let value = value.serialize(IntoValSerializer)?;366 self.data.field(key).try_value(value)?;367 Ok(())368 }369370 371 fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>372 where373 K: ?Sized + Serialize,374 V: ?Sized + Serialize,375 {376 let key = key.serialize(IntoValSerializer)?;377 let key = key.to_string()?;378 let value = value.serialize(IntoValSerializer)?;379 self.data.field(key).try_value(value)?;380 Ok(())381 }382383 fn end(self) -> Result<Val> {384 let inner = Val::Obj(self.data.build());385 if let Some(variant) = self.variant {386 let mut out = ObjValue::builder_with_capacity(1);387 out.field(variant).value(inner);388 Ok(Val::Obj(out.build()))389 } else {390 Ok(inner)391 }392 }393}394impl SerializeStruct for IntoObjValueSerializer {395 type Ok = Val;396 type Error = JrError;397398 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>399 where400 T: ?Sized + Serialize,401 {402 SerializeMap::serialize_entry(self, key, value)?;403 Ok(())404 }405406 fn end(self) -> Result<Val> {407 SerializeMap::end(self)408 }409}410impl SerializeStructVariant for IntoObjValueSerializer {411 type Ok = Val;412413 type Error = JrError;414415 fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>416 where417 T: ?Sized + Serialize,418 {419 SerializeMap::serialize_entry(self, key, value)?;420 Ok(())421 }422423 fn end(self) -> Result<Val> {424 SerializeMap::end(self)425 }426}427428struct IntoValSerializer;429impl Serializer for IntoValSerializer {430 type Ok = Val;431432 type Error = JrError;433434 type SerializeSeq = IntoVecValSerializer;435436 type SerializeTuple = IntoVecValSerializer;437438 type SerializeTupleStruct = IntoVecValSerializer;439440 type SerializeTupleVariant = IntoVecValSerializer;441442 type SerializeMap = IntoObjValueSerializer;443444 type SerializeStruct = IntoObjValueSerializer;445446 type SerializeStructVariant = IntoObjValueSerializer;447448 fn serialize_bool(self, v: bool) -> Result<Val> {449 Ok(Val::Bool(v))450 }451452 fn serialize_i8(self, v: i8) -> Result<Val> {453 Ok(Val::Num(v.into()))454 }455456 fn serialize_i16(self, v: i16) -> Result<Val> {457 Ok(Val::Num(v.into()))458 }459460 fn serialize_i32(self, v: i32) -> Result<Val> {461 Ok(Val::Num(v.into()))462 }463464 fn serialize_i64(self, v: i64) -> Result<Val> {465 Ok(Val::Str(v.to_string().into()))466 }467468 fn serialize_u8(self, v: u8) -> Result<Val> {469 Ok(Val::Num(v.into()))470 }471472 fn serialize_u16(self, v: u16) -> Result<Val> {473 Ok(Val::Num(v.into()))474 }475476 fn serialize_u32(self, v: u32) -> Result<Val> {477 Ok(Val::Num(v.into()))478 }479480 fn serialize_u64(self, v: u64) -> Result<Val> {481 Ok(Val::Str(v.to_string().into()))482 }483484 fn serialize_f32(self, v: f32) -> Result<Val> {485 Ok(Val::try_num(f64::from(v))?)486 }487488 fn serialize_f64(self, v: f64) -> Result<Val> {489 Ok(Val::try_num(v)?)490 }491492 fn serialize_char(self, v: char) -> Result<Val> {493 Ok(Val::Str(v.to_string().into()))494 }495496 fn serialize_str(self, v: &str) -> Result<Val> {497 Ok(Val::Str(v.into()))498 }499500 fn serialize_bytes(self, v: &[u8]) -> Result<Val> {501 Ok(Val::Arr(ArrValue::bytes(v.into())))502 }503504 fn serialize_none(self) -> Result<Val> {505 Ok(Val::Null)506 }507508 fn serialize_some<T>(self, value: &T) -> Result<Val>509 where510 T: ?Sized + Serialize,511 {512 value.serialize(self)513 }514515 fn serialize_unit(self) -> Result<Val> {516 Ok(Val::Null)517 }518519 fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {520 Ok(Val::Null)521 }522523 fn serialize_unit_variant(524 self,525 _name: &'static str,526 _variant_index: u32,527 variant: &'static str,528 ) -> Result<Val> {529 Ok(Val::Str(variant.into()))530 }531532 fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Val>533 where534 T: ?Sized + Serialize,535 {536 value.serialize(self)537 }538539 fn serialize_newtype_variant<T>(540 self,541 _name: &'static str,542 _variant_index: u32,543 variant: &'static str,544 value: &T,545 ) -> Result<Val>546 where547 T: ?Sized + Serialize,548 {549 let mut out = ObjValue::builder_with_capacity(1);550 let value = value.serialize(self)?;551 out.field(variant).value(value);552 Ok(Val::Obj(out.build()))553 }554555 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {556 Ok(len.map_or_else(557 IntoVecValSerializer::new,558 IntoVecValSerializer::with_capacity,559 ))560 }561562 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {563 Ok(IntoVecValSerializer::with_capacity(len))564 }565566 fn serialize_tuple_struct(567 self,568 _name: &'static str,569 len: usize,570 ) -> Result<Self::SerializeTupleStruct, Self::Error> {571 Ok(IntoVecValSerializer::with_capacity(len))572 }573574 fn serialize_tuple_variant(575 self,576 _name: &'static str,577 _variant_index: u32,578 variant: &'static str,579 len: usize,580 ) -> Result<Self::SerializeTupleVariant, Self::Error> {581 Ok(IntoVecValSerializer::variant_with_capacity(variant, len))582 }583584 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {585 Ok(len.map_or_else(586 IntoObjValueSerializer::new,587 IntoObjValueSerializer::with_capacity,588 ))589 }590591 fn serialize_struct(592 self,593 _name: &'static str,594 len: usize,595 ) -> Result<Self::SerializeStruct, Self::Error> {596 Ok(IntoObjValueSerializer::with_capacity(len))597 }598599 fn serialize_struct_variant(600 self,601 _name: &'static str,602 _variant_index: u32,603 variant: &'static str,604 len: usize,605 ) -> Result<Self::SerializeStructVariant, Self::Error> {606 Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))607 }608}609610impl Val {611 pub fn from_serde(v: impl Serialize) -> Result<Self, JrError> {612 v.serialize(IntoValSerializer)613 }614}615616impl serde::ser::Error for JrError {617 fn custom<T>(msg: T) -> Self618 where619 T: std::fmt::Display,620 {621 runtime_error!("serde: {msg}")622 }623}