hcl/expr/ser/
mod.rs

1//! Serializer impls for HCL expression types.
2
3#[cfg(test)]
4mod tests;
5
6use super::*;
7use crate::ser::{in_internal_serialization, InternalHandles, SerializeInternalHandleStruct};
8use crate::Error;
9use serde::ser::{self, Impossible, SerializeMap};
10
11pub(crate) const EXPR_HANDLE_MARKER: &str = "\x00$hcl::ExprHandle";
12
13thread_local! {
14    pub(crate) static EXPR_HANDLES: InternalHandles<Expression> = InternalHandles::new(EXPR_HANDLE_MARKER);
15}
16
17macro_rules! impl_serialize_for_expr {
18    ($($ty:ty)*) => {
19        $(
20            impl ser::Serialize for $ty {
21                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
22                where
23                    S: ser::Serializer,
24                {
25                    if in_internal_serialization() {
26                        EXPR_HANDLES.with(|eh| eh.serialize(self.clone(), serializer))
27                    } else {
28                        let s = format::to_interpolated_string(self).map_err(ser::Error::custom)?;
29                        serializer.serialize_str(&s)
30                    }
31                }
32            }
33        )*
34    };
35}
36
37impl_serialize_for_expr! {
38    Conditional ForExpr FuncCall Operation UnaryOp BinaryOp
39    TemplateExpr Heredoc Traversal Variable
40}
41
42impl ser::Serialize for HeredocStripMode {
43    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
44    where
45        S: ser::Serializer,
46    {
47        serializer.serialize_str(self.as_str())
48    }
49}
50
51impl ser::Serialize for Expression {
52    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
53    where
54        S: ser::Serializer,
55    {
56        if in_internal_serialization() {
57            return EXPR_HANDLES.with(|eh| eh.serialize(self.clone(), serializer));
58        }
59
60        match self {
61            Expression::Null => serializer.serialize_unit(),
62            Expression::Bool(b) => serializer.serialize_bool(*b),
63            Expression::Number(num) => num.serialize(serializer),
64            Expression::String(s) => serializer.serialize_str(s),
65            Expression::Array(array) => array.serialize(serializer),
66            Expression::Object(object) => object.serialize(serializer),
67            Expression::Parenthesis(expr) => expr.serialize(serializer),
68            Expression::TemplateExpr(expr) => expr.serialize(serializer),
69            Expression::FuncCall(func_call) => func_call.serialize(serializer),
70            Expression::Variable(var) => var.serialize(serializer),
71            Expression::Traversal(traversal) => traversal.serialize(serializer),
72            Expression::Conditional(cond) => cond.serialize(serializer),
73            Expression::Operation(op) => op.serialize(serializer),
74            Expression::ForExpr(expr) => expr.serialize(serializer),
75        }
76    }
77}
78
79pub(crate) struct ExpressionSerializer;
80
81impl ser::Serializer for ExpressionSerializer {
82    type Ok = Expression;
83    type Error = Error;
84
85    type SerializeSeq = SerializeExpressionSeq;
86    type SerializeTuple = SerializeExpressionSeq;
87    type SerializeTupleStruct = SerializeExpressionSeq;
88    type SerializeTupleVariant = SerializeExpressionTupleVariant;
89    type SerializeMap = SerializeExpressionMap;
90    type SerializeStruct = SerializeExpressionStruct;
91    type SerializeStructVariant = SerializeExpressionStructVariant;
92
93    serialize_self! { some newtype_struct }
94    forward_to_serialize_seq! { tuple tuple_struct }
95
96    fn serialize_bool(self, value: bool) -> Result<Self::Ok> {
97        Ok(Expression::Bool(value))
98    }
99
100    fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
101        self.serialize_i64(value as i64)
102    }
103
104    fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
105        self.serialize_i64(value as i64)
106    }
107
108    fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
109        self.serialize_i64(value as i64)
110    }
111
112    fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
113        Ok(Expression::Number(value.into()))
114    }
115
116    fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
117        self.serialize_u64(value as u64)
118    }
119
120    fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
121        self.serialize_u64(value as u64)
122    }
123
124    fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
125        self.serialize_u64(value as u64)
126    }
127
128    fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
129        Ok(Expression::Number(value.into()))
130    }
131
132    fn serialize_f32(self, value: f32) -> Result<Self::Ok> {
133        self.serialize_f64(value as f64)
134    }
135
136    fn serialize_f64(self, value: f64) -> Result<Self::Ok> {
137        Ok(Number::from_f64(value).map_or(Expression::Null, Expression::Number))
138    }
139
140    fn serialize_char(self, value: char) -> Result<Self::Ok> {
141        Ok(Expression::String(value.to_string()))
142    }
143
144    fn serialize_str(self, value: &str) -> Result<Self::Ok> {
145        Ok(Expression::String(value.to_owned()))
146    }
147
148    fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
149        let vec = value
150            .iter()
151            .map(|&b| Expression::Number(b.into()))
152            .collect();
153        Ok(Expression::Array(vec))
154    }
155
156    fn serialize_unit(self) -> Result<Self::Ok> {
157        Ok(Expression::Null)
158    }
159
160    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
161        self.serialize_unit()
162    }
163
164    fn serialize_unit_variant(
165        self,
166        _name: &'static str,
167        _variant_index: u32,
168        variant: &'static str,
169    ) -> Result<Self::Ok> {
170        self.serialize_str(variant)
171    }
172
173    fn serialize_newtype_variant<T>(
174        self,
175        _name: &'static str,
176        _variant_index: u32,
177        variant: &'static str,
178        value: &T,
179    ) -> Result<Self::Ok>
180    where
181        T: ?Sized + ser::Serialize,
182    {
183        let mut object = Object::with_capacity(1);
184        object.insert(
185            ObjectKey::Identifier(Identifier::new(variant)?),
186            value.serialize(self)?,
187        );
188        Ok(Expression::Object(object))
189    }
190
191    fn serialize_none(self) -> Result<Self::Ok> {
192        self.serialize_unit()
193    }
194
195    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
196        Ok(SerializeExpressionSeq::new(len))
197    }
198
199    fn serialize_tuple_variant(
200        self,
201        _name: &'static str,
202        _variant_index: u32,
203        variant: &'static str,
204        len: usize,
205    ) -> Result<Self::SerializeTupleVariant> {
206        Ok(SerializeExpressionTupleVariant::new(variant, len))
207    }
208
209    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
210        Ok(SerializeExpressionMap::new(len))
211    }
212
213    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
214        Ok(SerializeExpressionStruct::new(name, len))
215    }
216
217    fn serialize_struct_variant(
218        self,
219        _name: &'static str,
220        _variant_index: u32,
221        variant: &'static str,
222        len: usize,
223    ) -> Result<Self::SerializeStructVariant> {
224        Ok(SerializeExpressionStructVariant::new(variant, len))
225    }
226
227    fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
228    where
229        T: ?Sized + fmt::Display,
230    {
231        Ok(Expression::String(value.to_string()))
232    }
233}
234
235pub(crate) struct SerializeExpressionSeq {
236    vec: Vec<Expression>,
237}
238
239impl SerializeExpressionSeq {
240    fn new(len: Option<usize>) -> Self {
241        SerializeExpressionSeq {
242            vec: Vec::with_capacity(len.unwrap_or(0)),
243        }
244    }
245}
246
247impl ser::SerializeSeq for SerializeExpressionSeq {
248    type Ok = Expression;
249    type Error = Error;
250
251    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
252    where
253        T: ?Sized + ser::Serialize,
254    {
255        self.vec.push(value.serialize(ExpressionSerializer)?);
256        Ok(())
257    }
258
259    fn end(self) -> Result<Self::Ok> {
260        Ok(Expression::Array(self.vec))
261    }
262}
263
264impl ser::SerializeTuple for SerializeExpressionSeq {
265    impl_forward_to_serialize_seq!(serialize_element, Expression);
266}
267
268impl ser::SerializeTupleStruct for SerializeExpressionSeq {
269    impl_forward_to_serialize_seq!(serialize_field, Expression);
270}
271
272pub(crate) struct SerializeExpressionTupleVariant {
273    name: ObjectKey,
274    vec: Vec<Expression>,
275}
276
277impl SerializeExpressionTupleVariant {
278    pub(crate) fn new(variant: &'static str, len: usize) -> Self {
279        SerializeExpressionTupleVariant {
280            name: ObjectKey::from(variant),
281            vec: Vec::with_capacity(len),
282        }
283    }
284}
285
286impl ser::SerializeTupleVariant for SerializeExpressionTupleVariant {
287    type Ok = Expression;
288    type Error = Error;
289
290    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
291    where
292        T: ?Sized + ser::Serialize,
293    {
294        self.vec.push(value.serialize(ExpressionSerializer)?);
295        Ok(())
296    }
297
298    fn end(self) -> Result<Self::Ok> {
299        let mut object = Object::with_capacity(1);
300        object.insert(self.name, self.vec.into());
301        Ok(Expression::Object(object))
302    }
303}
304
305pub(crate) struct SerializeExpressionMap {
306    map: Object<ObjectKey, Expression>,
307    next_key: Option<ObjectKey>,
308}
309
310impl SerializeExpressionMap {
311    pub(crate) fn new(len: Option<usize>) -> Self {
312        SerializeExpressionMap {
313            map: Object::with_capacity(len.unwrap_or(0)),
314            next_key: None,
315        }
316    }
317}
318
319impl ser::SerializeMap for SerializeExpressionMap {
320    type Ok = Expression;
321    type Error = Error;
322
323    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
324    where
325        T: ?Sized + ser::Serialize,
326    {
327        self.next_key = Some(key.serialize(ObjectKeySerializer)?);
328        Ok(())
329    }
330
331    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
332    where
333        T: ?Sized + ser::Serialize,
334    {
335        let key = self.next_key.take();
336        let key = key.expect("serialize_value called before serialize_key");
337        let expr = value.serialize(ExpressionSerializer)?;
338        self.map.insert(key, expr);
339        Ok(())
340    }
341
342    fn end(self) -> Result<Self::Ok> {
343        Ok(Expression::Object(self.map))
344    }
345}
346
347pub(crate) enum SerializeExpressionStruct {
348    InternalHandle(SerializeInternalHandleStruct),
349    Map(SerializeExpressionMap),
350}
351
352impl SerializeExpressionStruct {
353    pub(crate) fn new(name: &'static str, len: usize) -> Self {
354        if name == EXPR_HANDLE_MARKER {
355            SerializeExpressionStruct::InternalHandle(SerializeInternalHandleStruct::new())
356        } else {
357            SerializeExpressionStruct::Map(SerializeExpressionMap::new(Some(len)))
358        }
359    }
360}
361
362impl ser::SerializeStruct for SerializeExpressionStruct {
363    type Ok = Expression;
364    type Error = Error;
365
366    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
367    where
368        T: ?Sized + ser::Serialize,
369    {
370        match self {
371            SerializeExpressionStruct::InternalHandle(ser) => ser.serialize_field(key, value),
372            SerializeExpressionStruct::Map(ser) => ser.serialize_entry(key, value),
373        }
374    }
375
376    fn end(self) -> Result<Self::Ok> {
377        match self {
378            SerializeExpressionStruct::InternalHandle(ser) => ser
379                .end()
380                .map(|handle| EXPR_HANDLES.with(|eh| eh.remove(handle))),
381            SerializeExpressionStruct::Map(ser) => ser.end(),
382        }
383    }
384}
385
386pub(crate) struct SerializeExpressionStructVariant {
387    name: ObjectKey,
388    map: Object<ObjectKey, Expression>,
389}
390
391impl SerializeExpressionStructVariant {
392    pub(crate) fn new(variant: &'static str, len: usize) -> Self {
393        SerializeExpressionStructVariant {
394            name: ObjectKey::from(variant),
395            map: Object::with_capacity(len),
396        }
397    }
398}
399
400impl ser::SerializeStructVariant for SerializeExpressionStructVariant {
401    type Ok = Expression;
402    type Error = Error;
403
404    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
405    where
406        T: ?Sized + ser::Serialize,
407    {
408        let expr = value.serialize(ExpressionSerializer)?;
409        self.map.insert(ObjectKey::from(key), expr);
410        Ok(())
411    }
412
413    fn end(self) -> Result<Self::Ok> {
414        let mut object = Object::with_capacity(1);
415        object.insert(self.name, self.map.into());
416        Ok(Expression::Object(object))
417    }
418}
419
420pub(crate) struct ObjectKeySerializer;
421
422impl ser::Serializer for ObjectKeySerializer {
423    type Ok = ObjectKey;
424    type Error = Error;
425
426    type SerializeSeq = Impossible<ObjectKey, Error>;
427    type SerializeTuple = Impossible<ObjectKey, Error>;
428    type SerializeTupleStruct = Impossible<ObjectKey, Error>;
429    type SerializeTupleVariant = Impossible<ObjectKey, Error>;
430    type SerializeMap = Impossible<ObjectKey, Error>;
431    type SerializeStruct = Impossible<ObjectKey, Error>;
432    type SerializeStructVariant = Impossible<ObjectKey, Error>;
433
434    serialize_unsupported! {
435        bool f32 f64 bytes unit unit_struct none
436        seq tuple tuple_struct tuple_variant map struct struct_variant
437    }
438
439    serialize_self! { some newtype_struct newtype_variant }
440
441    fn serialize_i8(self, value: i8) -> Result<Self::Ok> {
442        Ok(ObjectKey::from(value))
443    }
444
445    fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
446        Ok(ObjectKey::from(value))
447    }
448
449    fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
450        Ok(ObjectKey::from(value))
451    }
452
453    fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
454        Ok(ObjectKey::from(value))
455    }
456
457    fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
458        Ok(ObjectKey::from(value))
459    }
460
461    fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
462        Ok(ObjectKey::from(value))
463    }
464
465    fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
466        Ok(ObjectKey::from(value))
467    }
468
469    fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
470        Ok(ObjectKey::from(value))
471    }
472
473    fn serialize_char(self, value: char) -> Result<Self::Ok> {
474        Ok(ObjectKey::from(value.to_string()))
475    }
476
477    fn serialize_str(self, value: &str) -> Result<Self::Ok> {
478        Ok(ObjectKey::from(value))
479    }
480
481    fn serialize_unit_variant(
482        self,
483        _name: &'static str,
484        _variant_index: u32,
485        variant: &'static str,
486    ) -> Result<Self::Ok> {
487        Identifier::new(variant).map(ObjectKey::Identifier)
488    }
489}
hcl/expr/ser/mod.rs

hcl/expr/ser/
mod.rs
