dbt_yaml/value/
ser.rs

1use crate::error::{self, Error, ErrorImpl};
2use crate::spanned;
3use crate::value::tagged::{self, MaybeTag};
4use crate::value::{to_value, Mapping, Number, Sequence, Tag, TaggedValue, Value};
5use crate::Span;
6use serde::ser::{self, Serialize};
7use std::fmt::Display;
8use std::mem;
9
10type Result<T, E = Error> = std::result::Result<T, E>;
11
12impl Serialize for Value {
13    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
14    where
15        S: serde::Serializer,
16    {
17        spanned::set_span(self.span().clone());
18        match self {
19            Value::Null(..) => serializer.serialize_unit(),
20            Value::Bool(b, ..) => serializer.serialize_bool(*b),
21            Value::Number(n, ..) => n.serialize(serializer),
22            Value::String(s, ..) => serializer.serialize_str(s),
23            Value::Sequence(seq, ..) => seq.serialize(serializer),
24            Value::Mapping(mapping, ..) => {
25                use serde::ser::SerializeMap;
26                let mut map = serializer.serialize_map(Some(mapping.len()))?;
27                for (k, v) in mapping {
28                    map.serialize_entry(k, v)?;
29                }
30                map.end()
31            }
32            Value::Tagged(tagged, ..) => tagged.serialize(serializer),
33        }
34    }
35}
36
37/// Serializer whose output is a `Value`.
38///
39/// This is the serializer that backs [`dbt_yaml::to_value`][crate::to_value].
40/// Unlike the main serde_yaml serializer which goes from some serializable
41/// value of type `T` to YAML text, this one goes from `T` to
42/// `dbt_yaml::Value`.
43///
44/// The `to_value` function is implementable as:
45///
46/// ```
47/// use serde::Serialize;
48/// use dbt_yaml::{Error, Value};
49///
50/// pub fn to_value<T>(input: T) -> Result<Value, Error>
51/// where
52///     T: Serialize,
53/// {
54///     input.serialize(dbt_yaml::value::Serializer)
55/// }
56/// ```
57pub struct Serializer;
58
59impl ser::Serializer for Serializer {
60    type Ok = Value;
61    type Error = Error;
62
63    type SerializeSeq = SerializeArray;
64    type SerializeTuple = SerializeArray;
65    type SerializeTupleStruct = SerializeArray;
66    type SerializeTupleVariant = SerializeTupleVariant;
67    type SerializeMap = SerializeMap;
68    type SerializeStruct = SerializeStruct;
69    type SerializeStructVariant = SerializeStructVariant;
70
71    fn serialize_bool(self, v: bool) -> Result<Value> {
72        let span = spanned::take_span().unwrap_or_default();
73        Ok(Value::Bool(v, span))
74    }
75
76    fn serialize_i8(self, v: i8) -> Result<Value> {
77        let span = spanned::take_span().unwrap_or_default();
78        Ok(Value::Number(Number::from(v), span))
79    }
80
81    fn serialize_i16(self, v: i16) -> Result<Value> {
82        let span = spanned::take_span().unwrap_or_default();
83        Ok(Value::Number(Number::from(v), span))
84    }
85
86    fn serialize_i32(self, v: i32) -> Result<Value> {
87        let span = spanned::take_span().unwrap_or_default();
88        Ok(Value::Number(Number::from(v), span))
89    }
90
91    fn serialize_i64(self, v: i64) -> Result<Value> {
92        let span = spanned::take_span().unwrap_or_default();
93        Ok(Value::Number(Number::from(v), span))
94    }
95
96    fn serialize_i128(self, v: i128) -> Result<Value> {
97        if let Ok(v) = u64::try_from(v) {
98            self.serialize_u64(v)
99        } else if let Ok(v) = i64::try_from(v) {
100            self.serialize_i64(v)
101        } else {
102            let span = spanned::take_span().unwrap_or_default();
103            Ok(Value::String(v.to_string(), span))
104        }
105    }
106
107    fn serialize_u8(self, v: u8) -> Result<Value> {
108        let span = spanned::take_span().unwrap_or_default();
109        Ok(Value::Number(Number::from(v), span))
110    }
111
112    fn serialize_u16(self, v: u16) -> Result<Value> {
113        let span = spanned::take_span().unwrap_or_default();
114        Ok(Value::Number(Number::from(v), span))
115    }
116
117    fn serialize_u32(self, v: u32) -> Result<Value> {
118        let span = spanned::take_span().unwrap_or_default();
119        Ok(Value::Number(Number::from(v), span))
120    }
121
122    fn serialize_u64(self, v: u64) -> Result<Value> {
123        let span = spanned::take_span().unwrap_or_default();
124        Ok(Value::Number(Number::from(v), span))
125    }
126
127    fn serialize_u128(self, v: u128) -> Result<Value> {
128        if let Ok(v) = u64::try_from(v) {
129            self.serialize_u64(v)
130        } else {
131            let span = spanned::take_span().unwrap_or_default();
132            Ok(Value::String(v.to_string(), span))
133        }
134    }
135
136    fn serialize_f32(self, v: f32) -> Result<Value> {
137        let span = spanned::take_span().unwrap_or_default();
138        Ok(Value::Number(Number::from(v), span))
139    }
140
141    fn serialize_f64(self, v: f64) -> Result<Value> {
142        let span = spanned::take_span().unwrap_or_default();
143        Ok(Value::Number(Number::from(v), span))
144    }
145
146    fn serialize_char(self, value: char) -> Result<Value> {
147        let span = spanned::take_span().unwrap_or_default();
148        Ok(Value::String(value.to_string(), span))
149    }
150
151    fn serialize_str(self, value: &str) -> Result<Value> {
152        let span = spanned::take_span().unwrap_or_default();
153        Ok(Value::String(value.to_owned(), span))
154    }
155
156    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
157        let span = spanned::take_span().unwrap_or_default();
158        let vec = value
159            .iter()
160            .map(|&b| Value::number(Number::from(b)))
161            .collect();
162        Ok(Value::Sequence(vec, span))
163    }
164
165    fn serialize_unit(self) -> Result<Value> {
166        let span = spanned::take_span().unwrap_or_default();
167        Ok(Value::Null(span))
168    }
169
170    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
171        self.serialize_unit()
172    }
173
174    fn serialize_unit_variant(
175        self,
176        _name: &str,
177        _variant_index: u32,
178        variant: &str,
179    ) -> Result<Value> {
180        let span = spanned::take_span().unwrap_or_default();
181        Ok(Value::String(variant.to_owned(), span))
182    }
183
184    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
185    where
186        T: ?Sized + ser::Serialize,
187    {
188        value.serialize(self)
189    }
190
191    fn serialize_newtype_variant<T>(
192        self,
193        _name: &str,
194        _variant_index: u32,
195        variant: &str,
196        value: &T,
197    ) -> Result<Value>
198    where
199        T: ?Sized + ser::Serialize,
200    {
201        let span = spanned::take_span().unwrap_or_default();
202        if variant.is_empty() {
203            return Err(error::new(ErrorImpl::EmptyTag));
204        }
205        Ok(Value::Tagged(
206            Box::new(TaggedValue {
207                tag: Tag::new(variant),
208                value: to_value(value)?,
209            }),
210            span,
211        ))
212    }
213
214    fn serialize_none(self) -> Result<Value> {
215        self.serialize_unit()
216    }
217
218    fn serialize_some<V>(self, value: &V) -> Result<Value>
219    where
220        V: ?Sized + ser::Serialize,
221    {
222        value.serialize(self)
223    }
224
225    fn serialize_seq(self, len: Option<usize>) -> Result<SerializeArray> {
226        let span = spanned::take_span().unwrap_or_default();
227        let sequence = match len {
228            None => Sequence::new(),
229            Some(len) => Sequence::with_capacity(len),
230        };
231        Ok(SerializeArray { sequence, span })
232    }
233
234    fn serialize_tuple(self, len: usize) -> Result<SerializeArray> {
235        self.serialize_seq(Some(len))
236    }
237
238    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<SerializeArray> {
239        self.serialize_seq(Some(len))
240    }
241
242    fn serialize_tuple_variant(
243        self,
244        _enum: &'static str,
245        _idx: u32,
246        variant: &'static str,
247        len: usize,
248    ) -> Result<SerializeTupleVariant> {
249        let span = spanned::take_span().unwrap_or_default();
250        if variant.is_empty() {
251            return Err(error::new(ErrorImpl::EmptyTag));
252        }
253        Ok(SerializeTupleVariant {
254            tag: variant,
255            sequence: Sequence::with_capacity(len),
256            span,
257        })
258    }
259
260    fn serialize_map(self, len: Option<usize>) -> Result<SerializeMap> {
261        let span = spanned::take_span().unwrap_or_default();
262        if len == Some(1) {
263            Ok(SerializeMap::CheckForTag(span))
264        } else {
265            Ok(SerializeMap::Untagged {
266                mapping: Mapping::new(),
267                next_key: None,
268                span,
269            })
270        }
271    }
272
273    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<SerializeStruct> {
274        Ok(SerializeStruct {
275            mapping: Mapping::new(),
276            span: spanned::take_span().unwrap_or_default(),
277        })
278    }
279
280    fn serialize_struct_variant(
281        self,
282        _enum: &'static str,
283        _idx: u32,
284        variant: &'static str,
285        _len: usize,
286    ) -> Result<SerializeStructVariant> {
287        if variant.is_empty() {
288            return Err(error::new(ErrorImpl::EmptyTag));
289        }
290        Ok(SerializeStructVariant {
291            tag: variant,
292            mapping: Mapping::new(),
293        })
294    }
295}
296
297pub struct SerializeArray {
298    sequence: Sequence,
299    span: Span,
300}
301
302impl ser::SerializeSeq for SerializeArray {
303    type Ok = Value;
304    type Error = Error;
305
306    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
307    where
308        T: ?Sized + ser::Serialize,
309    {
310        self.sequence.push(to_value(elem)?);
311        Ok(())
312    }
313
314    fn end(self) -> Result<Value> {
315        Ok(Value::Sequence(self.sequence, self.span))
316    }
317}
318
319impl ser::SerializeTuple for SerializeArray {
320    type Ok = Value;
321    type Error = Error;
322
323    fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
324    where
325        T: ?Sized + ser::Serialize,
326    {
327        ser::SerializeSeq::serialize_element(self, elem)
328    }
329
330    fn end(self) -> Result<Value> {
331        ser::SerializeSeq::end(self)
332    }
333}
334
335impl ser::SerializeTupleStruct for SerializeArray {
336    type Ok = Value;
337    type Error = Error;
338
339    fn serialize_field<V>(&mut self, value: &V) -> Result<()>
340    where
341        V: ?Sized + ser::Serialize,
342    {
343        ser::SerializeSeq::serialize_element(self, value)
344    }
345
346    fn end(self) -> Result<Value> {
347        ser::SerializeSeq::end(self)
348    }
349}
350
351pub struct SerializeTupleVariant {
352    tag: &'static str,
353    sequence: Sequence,
354    span: Span,
355}
356
357impl ser::SerializeTupleVariant for SerializeTupleVariant {
358    type Ok = Value;
359    type Error = Error;
360
361    fn serialize_field<V>(&mut self, v: &V) -> Result<()>
362    where
363        V: ?Sized + ser::Serialize,
364    {
365        self.sequence.push(to_value(v)?);
366        Ok(())
367    }
368
369    fn end(self) -> Result<Value> {
370        Ok(Value::Tagged(
371            Box::new(TaggedValue {
372                tag: Tag::new(self.tag),
373                value: Value::sequence(self.sequence),
374            }),
375            self.span,
376        ))
377    }
378}
379
380pub enum SerializeMap {
381    CheckForTag(Span),
382    Tagged(TaggedValue, Span),
383    Untagged {
384        mapping: Mapping,
385        next_key: Option<Value>,
386        span: Span,
387    },
388}
389
390impl ser::SerializeMap for SerializeMap {
391    type Ok = Value;
392    type Error = Error;
393
394    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
395    where
396        T: ?Sized + ser::Serialize,
397    {
398        let key = Some(to_value(key)?);
399        match self {
400            SerializeMap::CheckForTag(span) => {
401                *self = SerializeMap::Untagged {
402                    mapping: Mapping::new(),
403                    next_key: key,
404                    span: span.clone(),
405                };
406            }
407            SerializeMap::Tagged(tagged, span) => {
408                let mut mapping = Mapping::new();
409                mapping.insert(
410                    Value::string(tagged.tag.to_string()),
411                    mem::take(&mut tagged.value),
412                );
413                *self = SerializeMap::Untagged {
414                    mapping,
415                    next_key: key,
416                    span: span.clone(),
417                };
418            }
419            SerializeMap::Untagged { next_key, .. } => *next_key = key,
420        }
421        Ok(())
422    }
423
424    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
425    where
426        T: ?Sized + ser::Serialize,
427    {
428        let (mapping, key) = match self {
429            SerializeMap::CheckForTag(_) | SerializeMap::Tagged(_, _) => unreachable!(),
430            SerializeMap::Untagged {
431                mapping, next_key, ..
432            } => (mapping, next_key),
433        };
434        match key.take() {
435            Some(key) => mapping.insert(key, to_value(value)?),
436            None => panic!("serialize_value called before serialize_key"),
437        };
438        Ok(())
439    }
440
441    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
442    where
443        K: ?Sized + ser::Serialize,
444        V: ?Sized + ser::Serialize,
445    {
446        struct CheckForTag;
447        struct NotTag<T> {
448            delegate: T,
449        }
450
451        impl ser::Serializer for CheckForTag {
452            type Ok = MaybeTag<Value>;
453            type Error = Error;
454
455            type SerializeSeq = NotTag<SerializeArray>;
456            type SerializeTuple = NotTag<SerializeArray>;
457            type SerializeTupleStruct = NotTag<SerializeArray>;
458            type SerializeTupleVariant = NotTag<SerializeTupleVariant>;
459            type SerializeMap = NotTag<SerializeMap>;
460            type SerializeStruct = NotTag<SerializeStruct>;
461            type SerializeStructVariant = NotTag<SerializeStructVariant>;
462
463            fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
464                Serializer.serialize_bool(v).map(MaybeTag::NotTag)
465            }
466
467            fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
468                Serializer.serialize_i8(v).map(MaybeTag::NotTag)
469            }
470
471            fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
472                Serializer.serialize_i16(v).map(MaybeTag::NotTag)
473            }
474
475            fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
476                Serializer.serialize_i32(v).map(MaybeTag::NotTag)
477            }
478
479            fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
480                Serializer.serialize_i64(v).map(MaybeTag::NotTag)
481            }
482
483            fn serialize_i128(self, v: i128) -> Result<Self::Ok> {
484                Serializer.serialize_i128(v).map(MaybeTag::NotTag)
485            }
486
487            fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
488                Serializer.serialize_u8(v).map(MaybeTag::NotTag)
489            }
490
491            fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
492                Serializer.serialize_u16(v).map(MaybeTag::NotTag)
493            }
494
495            fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
496                Serializer.serialize_u32(v).map(MaybeTag::NotTag)
497            }
498
499            fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
500                Serializer.serialize_u64(v).map(MaybeTag::NotTag)
501            }
502
503            fn serialize_u128(self, v: u128) -> Result<Self::Ok> {
504                Serializer.serialize_u128(v).map(MaybeTag::NotTag)
505            }
506
507            fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
508                Serializer.serialize_f32(v).map(MaybeTag::NotTag)
509            }
510
511            fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
512                Serializer.serialize_f64(v).map(MaybeTag::NotTag)
513            }
514
515            fn serialize_char(self, value: char) -> Result<Self::Ok> {
516                Serializer.serialize_char(value).map(MaybeTag::NotTag)
517            }
518
519            fn serialize_str(self, value: &str) -> Result<Self::Ok> {
520                Serializer.serialize_str(value).map(MaybeTag::NotTag)
521            }
522
523            fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
524                Serializer.serialize_bytes(value).map(MaybeTag::NotTag)
525            }
526
527            fn serialize_unit(self) -> Result<Self::Ok> {
528                Serializer.serialize_unit().map(MaybeTag::NotTag)
529            }
530
531            fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
532                Serializer.serialize_unit_struct(name).map(MaybeTag::NotTag)
533            }
534
535            fn serialize_unit_variant(
536                self,
537                name: &'static str,
538                variant_index: u32,
539                variant: &'static str,
540            ) -> Result<Self::Ok> {
541                Serializer
542                    .serialize_unit_variant(name, variant_index, variant)
543                    .map(MaybeTag::NotTag)
544            }
545
546            fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Self::Ok>
547            where
548                T: ?Sized + ser::Serialize,
549            {
550                Serializer
551                    .serialize_newtype_struct(name, value)
552                    .map(MaybeTag::NotTag)
553            }
554
555            fn serialize_newtype_variant<T>(
556                self,
557                name: &'static str,
558                variant_index: u32,
559                variant: &'static str,
560                value: &T,
561            ) -> Result<Self::Ok>
562            where
563                T: ?Sized + ser::Serialize,
564            {
565                Serializer
566                    .serialize_newtype_variant(name, variant_index, variant, value)
567                    .map(MaybeTag::NotTag)
568            }
569
570            fn serialize_none(self) -> Result<Self::Ok> {
571                Serializer.serialize_none().map(MaybeTag::NotTag)
572            }
573
574            fn serialize_some<V>(self, value: &V) -> Result<Self::Ok>
575            where
576                V: ?Sized + ser::Serialize,
577            {
578                Serializer.serialize_some(value).map(MaybeTag::NotTag)
579            }
580
581            fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
582                Ok(NotTag {
583                    delegate: Serializer.serialize_seq(len)?,
584                })
585            }
586
587            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
588                Ok(NotTag {
589                    delegate: Serializer.serialize_tuple(len)?,
590                })
591            }
592
593            fn serialize_tuple_struct(
594                self,
595                name: &'static str,
596                len: usize,
597            ) -> Result<Self::SerializeTupleStruct> {
598                Ok(NotTag {
599                    delegate: Serializer.serialize_tuple_struct(name, len)?,
600                })
601            }
602
603            fn serialize_tuple_variant(
604                self,
605                name: &'static str,
606                variant_index: u32,
607                variant: &'static str,
608                len: usize,
609            ) -> Result<Self::SerializeTupleVariant> {
610                Ok(NotTag {
611                    delegate: Serializer.serialize_tuple_variant(
612                        name,
613                        variant_index,
614                        variant,
615                        len,
616                    )?,
617                })
618            }
619
620            fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
621                Ok(NotTag {
622                    delegate: Serializer.serialize_map(len)?,
623                })
624            }
625
626            fn serialize_struct(
627                self,
628                name: &'static str,
629                len: usize,
630            ) -> Result<Self::SerializeStruct> {
631                Ok(NotTag {
632                    delegate: Serializer.serialize_struct(name, len)?,
633                })
634            }
635
636            fn serialize_struct_variant(
637                self,
638                name: &'static str,
639                variant_index: u32,
640                variant: &'static str,
641                len: usize,
642            ) -> Result<Self::SerializeStructVariant> {
643                Ok(NotTag {
644                    delegate: Serializer.serialize_struct_variant(
645                        name,
646                        variant_index,
647                        variant,
648                        len,
649                    )?,
650                })
651            }
652
653            fn collect_str<T>(self, value: &T) -> Result<Self::Ok>
654            where
655                T: ?Sized + Display,
656            {
657                Ok(match tagged::check_for_tag(value) {
658                    MaybeTag::Tag(tag) => MaybeTag::Tag(tag),
659                    MaybeTag::NotTag(string) => MaybeTag::NotTag(Value::string(string)),
660                })
661            }
662        }
663
664        impl ser::SerializeSeq for NotTag<SerializeArray> {
665            type Ok = MaybeTag<Value>;
666            type Error = Error;
667
668            fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
669            where
670                T: ?Sized + ser::Serialize,
671            {
672                self.delegate.serialize_element(elem)
673            }
674
675            fn end(self) -> Result<Self::Ok> {
676                self.delegate.end().map(MaybeTag::NotTag)
677            }
678        }
679
680        impl ser::SerializeTuple for NotTag<SerializeArray> {
681            type Ok = MaybeTag<Value>;
682            type Error = Error;
683
684            fn serialize_element<T>(&mut self, elem: &T) -> Result<()>
685            where
686                T: ?Sized + ser::Serialize,
687            {
688                self.delegate.serialize_element(elem)
689            }
690
691            fn end(self) -> Result<Self::Ok> {
692                self.delegate.end().map(MaybeTag::NotTag)
693            }
694        }
695
696        impl ser::SerializeTupleStruct for NotTag<SerializeArray> {
697            type Ok = MaybeTag<Value>;
698            type Error = Error;
699
700            fn serialize_field<V>(&mut self, value: &V) -> Result<()>
701            where
702                V: ?Sized + ser::Serialize,
703            {
704                self.delegate.serialize_field(value)
705            }
706
707            fn end(self) -> Result<Self::Ok> {
708                self.delegate.end().map(MaybeTag::NotTag)
709            }
710        }
711
712        impl ser::SerializeTupleVariant for NotTag<SerializeTupleVariant> {
713            type Ok = MaybeTag<Value>;
714            type Error = Error;
715
716            fn serialize_field<V>(&mut self, v: &V) -> Result<()>
717            where
718                V: ?Sized + ser::Serialize,
719            {
720                self.delegate.serialize_field(v)
721            }
722
723            fn end(self) -> Result<Self::Ok> {
724                self.delegate.end().map(MaybeTag::NotTag)
725            }
726        }
727
728        impl ser::SerializeMap for NotTag<SerializeMap> {
729            type Ok = MaybeTag<Value>;
730            type Error = Error;
731
732            fn serialize_key<T>(&mut self, key: &T) -> Result<()>
733            where
734                T: ?Sized + ser::Serialize,
735            {
736                self.delegate.serialize_key(key)
737            }
738
739            fn serialize_value<T>(&mut self, value: &T) -> Result<()>
740            where
741                T: ?Sized + ser::Serialize,
742            {
743                self.delegate.serialize_value(value)
744            }
745
746            fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
747            where
748                K: ?Sized + ser::Serialize,
749                V: ?Sized + ser::Serialize,
750            {
751                self.delegate.serialize_entry(key, value)
752            }
753
754            fn end(self) -> Result<Self::Ok> {
755                self.delegate.end().map(MaybeTag::NotTag)
756            }
757        }
758
759        impl ser::SerializeStruct for NotTag<SerializeStruct> {
760            type Ok = MaybeTag<Value>;
761            type Error = Error;
762
763            fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
764            where
765                V: ?Sized + ser::Serialize,
766            {
767                self.delegate.serialize_field(key, value)
768            }
769
770            fn end(self) -> Result<Self::Ok> {
771                self.delegate.end().map(MaybeTag::NotTag)
772            }
773        }
774
775        impl ser::SerializeStructVariant for NotTag<SerializeStructVariant> {
776            type Ok = MaybeTag<Value>;
777            type Error = Error;
778
779            fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
780            where
781                V: ?Sized + ser::Serialize,
782            {
783                self.delegate.serialize_field(field, v)
784            }
785
786            fn end(self) -> Result<Self::Ok> {
787                self.delegate.end().map(MaybeTag::NotTag)
788            }
789        }
790
791        match self {
792            SerializeMap::CheckForTag(span) => {
793                let key = key.serialize(CheckForTag)?;
794                let mut mapping = Mapping::new();
795                *self = match key {
796                    MaybeTag::Tag(string) => SerializeMap::Tagged(
797                        TaggedValue {
798                            tag: Tag::new(string),
799                            value: to_value(value)?,
800                        },
801                        span.clone(),
802                    ),
803                    MaybeTag::NotTag(key) => {
804                        mapping.insert(key, to_value(value)?);
805                        SerializeMap::Untagged {
806                            mapping,
807                            next_key: None,
808                            span: span.clone(),
809                        }
810                    }
811                };
812            }
813            SerializeMap::Tagged(tagged, span) => {
814                let mut mapping = Mapping::new();
815                mapping.insert(
816                    Value::string(tagged.tag.to_string()),
817                    mem::take(&mut tagged.value),
818                );
819                mapping.insert(to_value(key)?, to_value(value)?);
820                *self = SerializeMap::Untagged {
821                    mapping,
822                    next_key: None,
823                    span: span.clone(),
824                };
825            }
826            SerializeMap::Untagged { mapping, .. } => {
827                mapping.insert(to_value(key)?, to_value(value)?);
828            }
829        }
830        Ok(())
831    }
832
833    fn end(self) -> Result<Value> {
834        Ok(match self {
835            SerializeMap::CheckForTag(span) => Value::Mapping(Mapping::new(), span),
836            SerializeMap::Tagged(tagged, span) => Value::Tagged(Box::new(tagged), span),
837            SerializeMap::Untagged { mapping, span, .. } => Value::Mapping(mapping, span),
838        })
839    }
840}
841
842pub struct SerializeStruct {
843    mapping: Mapping,
844    span: Span,
845}
846
847impl ser::SerializeStruct for SerializeStruct {
848    type Ok = Value;
849    type Error = Error;
850
851    fn serialize_field<V>(&mut self, key: &'static str, value: &V) -> Result<()>
852    where
853        V: ?Sized + ser::Serialize,
854    {
855        if crate::is_flatten_key(key.as_bytes()) {
856            let flattened = value.serialize(Serializer)?;
857            if let Value::Mapping(flattened, ..) = flattened {
858                for (k, v) in flattened {
859                    self.mapping.insert(k, v);
860                }
861                return Ok(());
862            } else {
863                return Err(error::new(ErrorImpl::FlattenNotMapping));
864            }
865        }
866
867        self.mapping.insert(to_value(key)?, to_value(value)?);
868        Ok(())
869    }
870
871    fn end(self) -> Result<Value> {
872        Ok(Value::Mapping(self.mapping, self.span))
873    }
874}
875
876pub struct SerializeStructVariant {
877    tag: &'static str,
878    mapping: Mapping,
879}
880
881impl ser::SerializeStructVariant for SerializeStructVariant {
882    type Ok = Value;
883    type Error = Error;
884
885    fn serialize_field<V>(&mut self, field: &'static str, v: &V) -> Result<()>
886    where
887        V: ?Sized + ser::Serialize,
888    {
889        if crate::is_flatten_key(field.as_bytes()) {
890            let flattened = v.serialize(Serializer)?;
891            if let Value::Mapping(flattened, ..) = flattened {
892                for (k, v) in flattened {
893                    self.mapping.insert(k, v);
894                }
895                return Ok(());
896            } else {
897                return Err(error::new(ErrorImpl::FlattenNotMapping));
898            }
899        }
900
901        self.mapping.insert(to_value(field)?, to_value(v)?);
902        Ok(())
903    }
904
905    fn end(self) -> Result<Value> {
906        Ok(Value::tagged(Box::new(TaggedValue {
907            tag: Tag::new(self.tag),
908            value: Value::mapping(self.mapping),
909        })))
910    }
911}
dbt_yaml/value/ser.rs

dbt_yaml/value/
ser.rs
