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 Val::Arr(arr) => {166 let mut seq = serializer.serialize_seq(Some(arr.len()))?;167 for (i, element) in arr.iter().enumerate() {168 let mut serde_error = None;169 170 State::push_description(171 || format!("array index [{i}]"),172 || {173 let e = element?;174 if let Err(e) = seq.serialize_element(&e) {175 serde_error = Some(e);176 }177 Ok(())178 },179 )180 .map_err(|e| S::Error::custom(e.to_string()))?;181 if let Some(e) = serde_error {182 return Err(e);183 }184 }185 seq.end()186 }187 Val::Obj(obj) => {188 let mut map = serializer.serialize_map(Some(obj.len()))?;189 for (field, value) in obj.iter(190 #[cfg(feature = "exp-preserve-order")]191 true,192 ) {193 let mut serde_error = None;194 195 State::push_description(196 || format!("object field {field:?}"),197 || {198 let v = value?;199 if let Err(e) = map.serialize_entry(field.as_str(), &v) {200 serde_error = Some(e);201 }202 Ok(())203 },204 )205 .map_err(|e| S::Error::custom(e.to_string()))?;206 if let Some(e) = serde_error {207 return Err(e);208 }209 }210 map.end()211 }212 Val::Func(_) => Err(S::Error::custom("tried to manifest function")),213 }214 }215}216217struct IntoVecValSerializer {218 variant: Option<IStr>,219 data: Vec<Val>,220}221impl IntoVecValSerializer {222 fn new() -> Self {223 Self {224 variant: None,225 data: Vec::new(),226 }227 }228 fn with_capacity(capacity: usize) -> Self {229 Self {230 variant: None,231 data: Vec::with_capacity(capacity),232 }233 }234 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {235 Self {236 variant: Some(variant.into()),237 data: Vec::with_capacity(capacity),238 }239 }240}241impl SerializeSeq for IntoVecValSerializer {242 type Ok = Val;243 type Error = JrError;244245 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>246 where247 T: Serialize,248 {249 let value = value.serialize(IntoValSerializer)?;250 self.data.push(value);251 Ok(())252 }253254 fn end(self) -> Result<Val> {255 let inner = Val::Arr(ArrValue::eager(self.data));256 if let Some(variant) = self.variant {257 let mut out = ObjValue::builder_with_capacity(1);258 out.member(variant).value_unchecked(inner);259 Ok(Val::Obj(out.build()))260 } else {261 Ok(inner)262 }263 }264}265impl SerializeTuple for IntoVecValSerializer {266 type Ok = Val;267 type Error = JrError;268269 fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>270 where271 T: Serialize,272 {273 SerializeSeq::serialize_element(self, value)274 }275276 fn end(self) -> Result<Val> {277 SerializeSeq::end(self)278 }279}280impl SerializeTupleVariant for IntoVecValSerializer {281 type Ok = Val;282 type Error = JrError;283284 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>285 where286 T: Serialize,287 {288 SerializeSeq::serialize_element(self, value)289 }290291 fn end(self) -> Result<Val> {292 SerializeSeq::end(self)293 }294}295impl SerializeTupleStruct for IntoVecValSerializer {296 type Ok = Val;297 type Error = JrError;298299 fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>300 where301 T: Serialize,302 {303 SerializeSeq::serialize_element(self, value)304 }305306 fn end(self) -> Result<Val> {307 SerializeSeq::end(self)308 }309}310311struct IntoObjValueSerializer {312 variant: Option<IStr>,313 data: ObjValueBuilder,314 key: Option<IStr>,315}316impl IntoObjValueSerializer {317 fn new() -> Self {318 Self {319 variant: None,320 data: ObjValue::builder(),321 key: None,322 }323 }324 fn with_capacity(capacity: usize) -> Self {325 Self {326 variant: None,327 data: ObjValue::builder_with_capacity(capacity),328 key: None,329 }330 }331 fn variant_with_capacity(variant: impl Into<IStr>, capacity: usize) -> Self {332 Self {333 variant: Some(variant.into()),334 data: ObjValue::builder_with_capacity(capacity),335 key: None,336 }337 }338}339impl SerializeMap for IntoObjValueSerializer {340 type Ok = Val;341 type Error = JrError;342343 fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>344 where345 T: Serialize,346 {347 let key = key.serialize(IntoValSerializer)?;348 let key = key.to_string()?;349 self.key = Some(key);350 Ok(())351 }352353 fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>354 where355 T: Serialize,356 {357 let key = self.key.take().expect("no serialize_key called");358 let value = value.serialize(IntoValSerializer)?;359 self.data.member(key).value(value)?;360 Ok(())361 }362363 364 fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>365 where366 K: Serialize,367 V: Serialize,368 {369 let key = key.serialize(IntoValSerializer)?;370 let key = key.to_string()?;371 let value = value.serialize(IntoValSerializer)?;372 self.data.member(key).value(value)?;373 Ok(())374 }375376 fn end(self) -> Result<Val> {377 let inner = Val::Obj(self.data.build());378 if let Some(variant) = self.variant {379 let mut out = ObjValue::builder_with_capacity(1);380 out.member(variant).value_unchecked(inner);381 Ok(Val::Obj(out.build()))382 } else {383 Ok(inner)384 }385 }386}387impl SerializeStruct for IntoObjValueSerializer {388 type Ok = Val;389 type Error = JrError;390391 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>392 where393 T: Serialize,394 {395 SerializeMap::serialize_entry(self, key, value)?;396 Ok(())397 }398399 fn end(self) -> Result<Val> {400 SerializeMap::end(self)401 }402}403impl SerializeStructVariant for IntoObjValueSerializer {404 type Ok = Val;405406 type Error = JrError;407408 fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>409 where410 T: Serialize,411 {412 SerializeMap::serialize_entry(self, key, value)?;413 Ok(())414 }415416 fn end(self) -> Result<Val> {417 SerializeMap::end(self)418 }419}420421struct IntoValSerializer;422impl Serializer for IntoValSerializer {423 type Ok = Val;424425 type Error = JrError;426427 type SerializeSeq = IntoVecValSerializer;428429 type SerializeTuple = IntoVecValSerializer;430431 type SerializeTupleStruct = IntoVecValSerializer;432433 type SerializeTupleVariant = IntoVecValSerializer;434435 type SerializeMap = IntoObjValueSerializer;436437 type SerializeStruct = IntoObjValueSerializer;438439 type SerializeStructVariant = IntoObjValueSerializer;440441 fn serialize_bool(self, v: bool) -> Result<Val> {442 Ok(Val::Bool(v))443 }444445 fn serialize_i8(self, v: i8) -> Result<Val> {446 Ok(Val::Num(f64::from(v)))447 }448449 fn serialize_i16(self, v: i16) -> Result<Val> {450 Ok(Val::Num(f64::from(v)))451 }452453 fn serialize_i32(self, v: i32) -> Result<Val> {454 Ok(Val::Num(f64::from(v)))455 }456457 fn serialize_i64(self, v: i64) -> Result<Val> {458 Ok(Val::Str(v.to_string().into()))459 }460461 fn serialize_u8(self, v: u8) -> Result<Val> {462 Ok(Val::Num(f64::from(v)))463 }464465 fn serialize_u16(self, v: u16) -> Result<Val> {466 Ok(Val::Num(f64::from(v)))467 }468469 fn serialize_u32(self, v: u32) -> Result<Val> {470 Ok(Val::Num(f64::from(v)))471 }472473 fn serialize_u64(self, v: u64) -> Result<Val> {474 Ok(Val::Str(v.to_string().into()))475 }476477 fn serialize_f32(self, v: f32) -> Result<Val> {478 Ok(Val::Num(f64::from(v)))479 }480481 fn serialize_f64(self, v: f64) -> Result<Val> {482 Ok(Val::Num(v))483 }484485 fn serialize_char(self, v: char) -> Result<Val> {486 Ok(Val::Str(v.to_string().into()))487 }488489 fn serialize_str(self, v: &str) -> Result<Val> {490 Ok(Val::Str(v.into()))491 }492493 fn serialize_bytes(self, v: &[u8]) -> Result<Val> {494 Ok(Val::Arr(ArrValue::bytes(v.into())))495 }496497 fn serialize_none(self) -> Result<Val> {498 Ok(Val::Null)499 }500501 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Val>502 where503 T: Serialize,504 {505 value.serialize(self)506 }507508 fn serialize_unit(self) -> Result<Val> {509 Ok(Val::Null)510 }511512 fn serialize_unit_struct(self, _name: &'static str) -> Result<Val> {513 Ok(Val::Null)514 }515516 fn serialize_unit_variant(517 self,518 _name: &'static str,519 _variant_index: u32,520 variant: &'static str,521 ) -> Result<Val> {522 Ok(Val::Str(variant.into()))523 }524525 fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Val>526 where527 T: Serialize,528 {529 value.serialize(self)530 }531532 fn serialize_newtype_variant<T: ?Sized>(533 self,534 _name: &'static str,535 _variant_index: u32,536 variant: &'static str,537 value: &T,538 ) -> Result<Val>539 where540 T: Serialize,541 {542 let mut out = ObjValue::builder_with_capacity(1);543 let value = value.serialize(self)?;544 out.member(variant.into()).value_unchecked(value);545 Ok(Val::Obj(out.build()))546 }547548 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {549 Ok(len.map_or_else(550 IntoVecValSerializer::new,551 IntoVecValSerializer::with_capacity,552 ))553 }554555 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {556 Ok(IntoVecValSerializer::with_capacity(len))557 }558559 fn serialize_tuple_struct(560 self,561 _name: &'static str,562 len: usize,563 ) -> Result<Self::SerializeTupleStruct, Self::Error> {564 Ok(IntoVecValSerializer::with_capacity(len))565 }566567 fn serialize_tuple_variant(568 self,569 _name: &'static str,570 _variant_index: u32,571 variant: &'static str,572 len: usize,573 ) -> Result<Self::SerializeTupleVariant, Self::Error> {574 Ok(IntoVecValSerializer::variant_with_capacity(variant, len))575 }576577 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {578 Ok(len.map_or_else(579 IntoObjValueSerializer::new,580 IntoObjValueSerializer::with_capacity,581 ))582 }583584 fn serialize_struct(585 self,586 _name: &'static str,587 len: usize,588 ) -> Result<Self::SerializeStruct, Self::Error> {589 Ok(IntoObjValueSerializer::with_capacity(len))590 }591592 fn serialize_struct_variant(593 self,594 _name: &'static str,595 _variant_index: u32,596 variant: &'static str,597 len: usize,598 ) -> Result<Self::SerializeStructVariant, Self::Error> {599 Ok(IntoObjValueSerializer::variant_with_capacity(variant, len))600 }601}602603impl Val {604 pub fn from_serde(v: impl Serialize) -> Result<Val, JrError> {605 v.serialize(IntoValSerializer)606 }607}608609impl serde::ser::Error for JrError {610 fn custom<T>(msg: T) -> Self611 where612 T: std::fmt::Display,613 {614 JrError::new(ErrorKind::RuntimeError(format!("serde: {msg}").into()))615 }616}