marked_yaml/
spanned_serde.rs

1//! Serde support for marked data deserialisation
2
3use std::{
4    borrow::Borrow,
5    fmt,
6    hash::Hash,
7    iter::Peekable,
8    marker::PhantomData,
9    num::{ParseFloatError, ParseIntError},
10    ops::Deref,
11};
12
13use serde::{
14    de::{
15        value::BorrowedStrDeserializer, DeserializeOwned, EnumAccess, IntoDeserializer, MapAccess,
16        SeqAccess, Unexpected, VariantAccess, Visitor,
17    },
18    forward_to_deserialize_any, Deserialize, Deserializer, Serialize,
19};
20
21use crate::{
22    types::{MarkedMappingNode, MarkedScalarNode, MarkedSequenceNode},
23    LoaderOptions, Marker, Node, Span,
24};
25
26/// Wrapper which can be used when deserialising data from [`Node`]
27///
28/// You must use a compatible deserializer if you want to deserialize these values.
29///
30/// ```
31/// use marked_yaml::{from_yaml, Spanned};
32/// use serde::Deserialize;
33///
34/// #[derive(Deserialize)]
35/// struct MyStuff {
36///     num: Spanned<u32>,
37/// }
38/// let stuff: MyStuff = from_yaml(0, "num: 12").unwrap();
39/// ```
40///
41/// You can also serialize these values,
42/// however when serializing you will lose the span information so do not expect
43/// to round-trip these values.
44#[derive(Clone, Debug)]
45pub struct Spanned<T> {
46    span: Span,
47    inner: T,
48}
49
50impl<T> Spanned<T> {
51    /// Wrap an instance of something with the given span
52    ///
53    /// ```
54    /// # use marked_yaml::{Spanned, Span};
55    /// let spanned = Spanned::new(Span::new_blank(), "Hello World");
56    /// ```
57    pub fn new(span: Span, inner: T) -> Self {
58        Self { span, inner }
59    }
60
61    /// The span associated with this value
62    ///
63    /// ```
64    /// # use marked_yaml::{Spanned, Span, Marker};
65    /// # let span = Span::new_start(Marker::new(0, 1, 1, 2));
66    /// let spanned = Spanned::new(span, "Hello World");
67    /// assert_eq!(spanned.span(), &span);
68    /// ```
69    pub fn span(&self) -> &Span {
70        &self.span
71    }
72}
73
74impl<T> Deref for Spanned<T> {
75    type Target = T;
76
77    fn deref(&self) -> &Self::Target {
78        &self.inner
79    }
80}
81
82impl<T> PartialEq for Spanned<T>
83where
84    T: PartialEq,
85{
86    fn eq(&self, other: &Self) -> bool {
87        self.inner == other.inner
88    }
89}
90
91impl<T> PartialEq<T> for Spanned<T>
92where
93    T: PartialEq,
94{
95    fn eq(&self, other: &T) -> bool {
96        (&self.inner as &dyn PartialEq<T>).eq(other)
97    }
98}
99
100impl PartialEq<&str> for Spanned<String> {
101    fn eq(&self, other: &&str) -> bool {
102        self.inner == *other
103    }
104}
105
106impl<T> Eq for Spanned<T> where T: Eq {}
107
108impl<T> Hash for Spanned<T>
109where
110    T: Hash,
111{
112    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
113        self.inner.hash(state);
114    }
115}
116
117impl Borrow<str> for Spanned<String> {
118    fn borrow(&self) -> &str {
119        self.inner.borrow()
120    }
121}
122
123impl Borrow<str> for Spanned<&'_ str> {
124    fn borrow(&self) -> &str {
125        self.inner
126    }
127}
128
129// -------------------------------------------------------------------------------
130
131// Convention for these markers comes from the toml crates
132
133const SPANNED_TYPE: &str = "$___::marked_data::serde::Spanned<T>";
134const SPANNED_SPAN_START_SOURCE: &str = "$___::marked_data::serde::Spanned<T>::span_start_source";
135const SPANNED_SPAN_START_CHARACTER: &str = "$___::marked_data::serde::Spanned<T>::span_start_char";
136const SPANNED_SPAN_START_LINE: &str = "$___::marked_data::serde::Spanned<T>::span_start_line";
137const SPANNED_SPAN_START_COLUMN: &str = "$___::marked_data::serde::Spanned<T>::span_start_column";
138const SPANNED_SPAN_END_SOURCE: &str = "$___::marked_data::serde::Spanned<T>::span_end_source";
139const SPANNED_SPAN_END_CHARACTER: &str = "$___::marked_data::serde::Spanned<T>::span_end_char";
140const SPANNED_SPAN_END_LINE: &str = "$___::marked_data::serde::Spanned<T>::span_end_line";
141const SPANNED_SPAN_END_COLUMN: &str = "$___::marked_data::serde::Spanned<T>::span_end_column";
142const SPANNED_INNER: &str = "$___::marked_data::serde::Spanned<T>::inner";
143
144const SPANNED_FIELDS: [&str; 9] = [
145    SPANNED_SPAN_START_SOURCE,
146    SPANNED_SPAN_START_CHARACTER,
147    SPANNED_SPAN_START_LINE,
148    SPANNED_SPAN_START_COLUMN,
149    SPANNED_SPAN_END_SOURCE,
150    SPANNED_SPAN_END_CHARACTER,
151    SPANNED_SPAN_END_LINE,
152    SPANNED_SPAN_END_COLUMN,
153    SPANNED_INNER,
154];
155
156impl<'de, T> Deserialize<'de> for Spanned<T>
157where
158    T: Deserialize<'de>,
159{
160    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
161    where
162        D: serde::Deserializer<'de>,
163    {
164        struct MarkedNodeVisitor<T>(PhantomData<T>);
165
166        impl<'de, T> Visitor<'de> for MarkedNodeVisitor<T>
167        where
168            T: Deserialize<'de>,
169        {
170            type Value = Spanned<T>;
171
172            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
173                write!(f, "a verbatim marked_yaml::Node")
174            }
175
176            fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
177            where
178                V: MapAccess<'de>,
179            {
180                let mut key: Option<&str> = visitor.next_key()?;
181
182                let span_start = if key == Some(SPANNED_SPAN_START_SOURCE) {
183                    let source: usize = visitor.next_value()?;
184                    if visitor.next_key()? != Some(SPANNED_SPAN_START_CHARACTER) {
185                        return Err(serde::de::Error::custom(
186                            "marked node span start character missing",
187                        ));
188                    }
189                    let character: usize = visitor.next_value()?;
190                    if visitor.next_key()? != Some(SPANNED_SPAN_START_LINE) {
191                        return Err(serde::de::Error::custom(
192                            "marked node span start line missing",
193                        ));
194                    }
195                    let line: usize = visitor.next_value()?;
196                    if visitor.next_key()? != Some(SPANNED_SPAN_START_COLUMN) {
197                        return Err(serde::de::Error::custom(
198                            "marked node span start column missing",
199                        ));
200                    }
201                    let column: usize = visitor.next_value()?;
202                    key = visitor.next_key()?;
203                    Some(Marker::new(source, character, line, column))
204                } else {
205                    None
206                };
207
208                let span_end = if key == Some(SPANNED_SPAN_END_SOURCE) {
209                    let source: usize = visitor.next_value()?;
210                    if visitor.next_key()? != Some(SPANNED_SPAN_END_CHARACTER) {
211                        return Err(serde::de::Error::custom(
212                            "marked node span end character missing",
213                        ));
214                    }
215                    let character: usize = visitor.next_value()?;
216                    if visitor.next_key()? != Some(SPANNED_SPAN_END_LINE) {
217                        return Err(serde::de::Error::custom(
218                            "marked node span end line missing",
219                        ));
220                    }
221                    let line: usize = visitor.next_value()?;
222                    if visitor.next_key()? != Some(SPANNED_SPAN_END_COLUMN) {
223                        return Err(serde::de::Error::custom(
224                            "marked node span end column missing",
225                        ));
226                    }
227                    let column: usize = visitor.next_value()?;
228                    key = visitor.next_key()?;
229                    Some(Marker::new(source, character, line, column))
230                } else {
231                    None
232                };
233
234                if key != Some(SPANNED_INNER) {
235                    return Err(serde::de::Error::custom(
236                        "marked node inner value not found",
237                    ));
238                }
239                let inner: T = visitor.next_value()?;
240
241                let mut span = Span::new_blank();
242                span.set_start(span_start);
243                span.set_end(span_end);
244
245                Ok(Spanned::new(span, inner))
246            }
247        }
248        let visitor = MarkedNodeVisitor(PhantomData);
249
250        deserializer.deserialize_struct(SPANNED_TYPE, &SPANNED_FIELDS, visitor)
251    }
252}
253
254impl<T> Serialize for Spanned<T>
255where
256    T: Serialize,
257{
258    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
259    where
260        S: serde::Serializer,
261    {
262        self.inner.serialize(serializer)
263    }
264}
265
266#[cfg(test)]
267mod spanned_tests {
268    use super::Spanned;
269    use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
270
271    #[test]
272    fn spanned_always_map() {
273        struct NotSpanned;
274        impl<'de> Deserializer<'de> for NotSpanned {
275            type Error = super::Error;
276
277            fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
278            where
279                V: serde::de::Visitor<'de>,
280            {
281                visitor.visit_bool(false)
282            }
283
284            forward_to_deserialize_any! [
285                bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes byte_buf
286                unit unit_struct newtype_struct seq tuple tuple_struct
287                map identifier ignored_any option struct enum
288            ];
289        }
290        type T = Spanned<bool>;
291        assert!(T::deserialize(NotSpanned).is_err());
292    }
293}
294
295// -------------------------------------------------------------------------------
296
297/// Errors which can come from deserialisation
298#[derive(Debug)]
299pub enum Error {
300    /// The value was not a valid boolean
301    NotBoolean(Span),
302    /// Failed to parse integer
303    IntegerParseFailure(ParseIntError, Span),
304    /// Failed to parse float
305    FloatParseFailure(ParseFloatError, Span),
306    /// An unknown field was encountered
307    UnknownFieldError(String, &'static [&'static str], Span),
308    /// Some other error occurred
309    Other(String, Span),
310}
311
312impl Error {
313    fn set_span(&mut self, span: Span) {
314        let spanloc = match self {
315            Error::NotBoolean(s) => s,
316            Error::IntegerParseFailure(_, s) => s,
317            Error::FloatParseFailure(_, s) => s,
318            Error::UnknownFieldError(_, _, s) => s,
319            Error::Other(_, s) => s,
320        };
321        *spanloc = span;
322    }
323
324    /// Retrieve the start marker if there is one
325    ///
326    /// Most spans which are generated by the loader only have start
327    /// marks (containers have end marks as well, but these failures)
328    /// are unlikely to exist here.
329    ///
330    /// ```
331    /// # use marked_yaml::*;
332    /// # use serde::Deserialize;
333    /// const YAML: &str = r#"
334    /// bad: float
335    /// "#;
336    ///
337    /// #[derive(Deserialize)]
338    /// struct Example {
339    ///     bad: Spanned<f64>,
340    /// }
341    ///
342    /// let nodes = parse_yaml(0, YAML).unwrap();
343    /// let err = from_node::<Example>(&nodes).err().unwrap();
344    ///
345    /// assert!(matches!(&*err, Error::FloatParseFailure(_,_)));
346    ///
347    /// let mark = err.start_mark().unwrap();
348    ///
349    /// assert_eq!(mark.source(), 0);
350    /// assert_eq!(mark.line(), 2);
351    /// assert_eq!(mark.column(), 6);
352    /// ```
353    pub fn start_mark(&self) -> Option<Marker> {
354        let spanloc = match self {
355            Error::NotBoolean(s) => s,
356            Error::IntegerParseFailure(_, s) => s,
357            Error::FloatParseFailure(_, s) => s,
358            Error::UnknownFieldError(_, _, s) => s,
359            Error::Other(_, s) => s,
360        };
361        spanloc.start().copied()
362    }
363}
364
365impl fmt::Display for Error {
366    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
367        match self {
368            Error::NotBoolean(_) => f.write_str("Value was not a boolean"),
369            Error::IntegerParseFailure(e, _) => e.fmt(f),
370            Error::FloatParseFailure(e, _) => e.fmt(f),
371            Error::UnknownFieldError(field, expected, _) => match expected.len() {
372                0 => write!(f, "Unknown field `{field}`, there are no fields"),
373                1 => write!(f, "Unknown field `{field}`, expected `{}`", expected[0]),
374                2 => write!(
375                    f,
376                    "Unknown field `{field}`, expected `{}` or `{}`",
377                    expected[0], expected[1]
378                ),
379                _ => {
380                    write!(f, "Unknown field `{field}`, expected one of ")?;
381                    let last = expected[expected.len() - 1];
382                    for v in expected[..=expected.len() - 2].iter() {
383                        write!(f, "`{v}`, ")?;
384                    }
385                    write!(f, "or `{last}`")
386                }
387            },
388            Error::Other(e, _) => e.fmt(f),
389        }
390    }
391}
392
393impl std::error::Error for Error {}
394
395impl serde::de::Error for Error {
396    fn custom<T>(msg: T) -> Self
397    where
398        T: fmt::Display,
399    {
400        Error::Other(msg.to_string(), Span::new_blank())
401    }
402
403    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
404        Self::UnknownFieldError(field.to_string(), expected, Span::new_blank())
405    }
406}
407
408impl From<ParseIntError> for Error {
409    fn from(value: ParseIntError) -> Self {
410        Error::IntegerParseFailure(value, Span::new_blank())
411    }
412}
413
414impl From<ParseFloatError> for Error {
415    fn from(value: ParseFloatError) -> Self {
416        Error::FloatParseFailure(value, Span::new_blank())
417    }
418}
419
420trait AddSpans<T> {
421    fn addspans(self, span: Span) -> Result<T, Error>;
422}
423
424impl<T, E> AddSpans<T> for Result<T, E>
425where
426    E: Into<Error>,
427{
428    fn addspans(self, span: Span) -> Result<T, Error> {
429        self.map_err(|e| {
430            let mut e: Error = e.into();
431            e.set_span(span);
432            e
433        })
434    }
435}
436
437// -------------------------------------------------------------------------------
438
439impl<'de> IntoDeserializer<'de, Error> for &'de Node {
440    type Deserializer = NodeDeserializer<'de>;
441
442    fn into_deserializer(self) -> Self::Deserializer {
443        NodeDeserializer { node: self }
444    }
445}
446
447/// Deserializer for nodes
448pub struct NodeDeserializer<'node> {
449    node: &'node Node,
450}
451
452impl<'node> NodeDeserializer<'node> {
453    /// Create a new deserializer over a borrowed node
454    pub fn new(node: &'node Node) -> Self {
455        Self { node }
456    }
457}
458
459// -------------------------------------------------------------------------------
460
461/// The error returned by [`from_node`]
462///
463/// From here you can get the logical path to the error if
464/// one is available, and then via the error: the marker
465/// indicating where the error occurred if it's available.
466/// Finally you may extract the error itself.
467#[derive(Debug)]
468pub struct FromNodeError {
469    error: Box<Error>,
470    path: Option<String>,
471}
472
473impl FromNodeError {
474    #[cfg_attr(docsrs, doc(cfg(feature = "serde-path")))]
475    /// The logical path representing where the error occurred.
476    ///
477    /// Note: this likely will only ever be `Some(value)` if
478    /// you enable the `serde-path` feature, though the function
479    /// itself will be available with the `serde` feature.
480    pub fn path(&self) -> Option<&str> {
481        self.path.as_deref()
482    }
483
484    /// Extract the inner error
485    pub fn into_inner(self) -> Error {
486        *self.error
487    }
488}
489
490impl Deref for FromNodeError {
491    type Target = Error;
492
493    fn deref(&self) -> &Self::Target {
494        &self.error
495    }
496}
497
498impl fmt::Display for FromNodeError {
499    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
500        if let Some(path) = self.path() {
501            write!(f, "{}: {}", path, self.error)
502        } else {
503            (&self.error as &dyn fmt::Display).fmt(f)
504        }
505    }
506}
507
508// -------------------------------------------------------------------------------
509
510/// Errors which can occur when deserialising from YAML
511#[derive(Debug)]
512pub enum FromYamlError {
513    /// A problem was encountered when parsing YAML
514    ParseYaml(crate::LoadError),
515    /// A problem was encountered when deserializing from nodes
516    FromNode(FromNodeError),
517}
518
519impl fmt::Display for FromYamlError {
520    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
521        match self {
522            FromYamlError::ParseYaml(e) => write!(f, "{e}"),
523            FromYamlError::FromNode(e) => write!(f, "{e}"),
524        }
525    }
526}
527
528impl std::error::Error for FromYamlError {}
529
530impl From<crate::LoadError> for FromYamlError {
531    fn from(value: crate::LoadError) -> Self {
532        Self::ParseYaml(value)
533    }
534}
535
536impl From<FromNodeError> for FromYamlError {
537    fn from(value: FromNodeError) -> Self {
538        Self::FromNode(value)
539    }
540}
541
542// -------------------------------------------------------------------------------
543
544/// Deserialize some YAML into the requisite type
545///
546/// This permits deserialisation of a YAML string into
547/// any structure which [`serde`] can deserialize.  In
548/// addition, if any part of the type tree is [`Spanned`]
549/// then the spans are provided from the requisite marked
550/// node.
551///
552/// ```
553/// # use serde::Deserialize;
554/// # use marked_yaml::Spanned;
555/// const YAML: &str = "hello: world\n";
556/// #[derive(Deserialize)]
557/// struct Greeting {
558///     hello: Spanned<String>,
559/// }
560/// let greets: Greeting = marked_yaml::from_yaml(0, YAML).unwrap();
561/// let start = greets.hello.span().start().unwrap();
562/// assert_eq!(start.line(), 1);
563/// assert_eq!(start.column(), 8);
564/// ```
565#[allow(clippy::result_large_err)]
566pub fn from_yaml<T>(source: usize, yaml: &str) -> Result<T, FromYamlError>
567where
568    T: DeserializeOwned,
569{
570    from_yaml_with_options(source, yaml, LoaderOptions::default())
571}
572
573/// Deserialize some YAML into the requisite type
574///
575/// This permits deserialisation of a YAML string into
576/// any structure which [`serde`] can deserialize.  In
577/// addition, if any part of the type tree is [`Spanned`]
578/// then the spans are provided from the requisite marked
579/// node.
580///
581/// ```
582/// # use serde::Deserialize;
583/// # use marked_yaml::{Spanned, LoaderOptions};
584/// const YAML: &str = "hello: world\n";
585/// #[derive(Deserialize)]
586/// struct Greeting {
587///     hello: Spanned<String>,
588/// }
589/// let greets: Greeting = marked_yaml::from_yaml_with_options(0, YAML, LoaderOptions::default()).unwrap();
590/// let start = greets.hello.span().start().unwrap();
591/// assert_eq!(start.line(), 1);
592/// assert_eq!(start.column(), 8);
593/// ```
594#[allow(clippy::result_large_err)]
595pub fn from_yaml_with_options<T>(
596    source: usize,
597    yaml: &str,
598    options: LoaderOptions,
599) -> Result<T, FromYamlError>
600where
601    T: DeserializeOwned,
602{
603    let node = crate::parse_yaml_with_options(source, yaml, options)?;
604    Ok(from_node(&node)?)
605}
606
607// -------------------------------------------------------------------------------
608
609/// Deserialize some [`Node`] into the requisite type
610///
611/// This permits deserialisation of [`Node`]s into any structure
612/// which [`serde`] can deserialize.  In addition, if any part of
613/// the type tree is [`Spanned`] then the spans are provided
614/// from the requisite marked node.
615///
616/// ```
617/// # use serde::Deserialize;
618/// # use marked_yaml::Spanned;
619/// const YAML: &str = "hello: world\n";
620/// let node = marked_yaml::parse_yaml(0, YAML).unwrap();
621/// #[derive(Deserialize)]
622/// struct Greeting {
623///     hello: Spanned<String>,
624/// }
625/// let greets: Greeting = marked_yaml::from_node(&node).unwrap();
626/// let start = greets.hello.span().start().unwrap();
627/// assert_eq!(start.line(), 1);
628/// assert_eq!(start.column(), 8);
629/// ```
630#[allow(clippy::result_large_err)]
631pub fn from_node<'de, T>(node: &'de Node) -> Result<T, FromNodeError>
632where
633    T: Deserialize<'de>,
634{
635    #[cfg(not(feature = "serde-path"))]
636    {
637        T::deserialize(NodeDeserializer::new(node)).map_err(|e| FromNodeError {
638            error: Box::new(e),
639            path: None,
640        })
641    }
642
643    #[cfg(feature = "serde-path")]
644    {
645        use serde_path_to_error::Segment;
646
647        let p2e: Result<T, _> = serde_path_to_error::deserialize(NodeDeserializer::new(node));
648
649        p2e.map_err(|e| {
650            if e.inner().start_mark().is_none() {
651                let p = e.path().clone();
652                let path = render_path(&p);
653                let mut e = e.into_inner();
654                let mut prev_best_node = node;
655                let mut best_node = node;
656                for seg in p.iter() {
657                    match seg {
658                        Segment::Seq { index } => {
659                            if let Some(seq) = best_node.as_sequence() {
660                                if let Some(node) = seq.get(*index) {
661                                    prev_best_node = best_node;
662                                    best_node = node;
663                                } else {
664                                    // We can't traverse this?
665                                    break;
666                                }
667                            } else {
668                                // We can't traverse this?
669                                break;
670                            }
671                        }
672                        Segment::Map { key } => {
673                            if let Some(map) = best_node.as_mapping() {
674                                // What we want here is the entry which matches the key
675                                // if there is one
676                                if let Some(node) = map.get(key.as_str()) {
677                                    prev_best_node = best_node;
678                                    best_node = node;
679                                } else {
680                                    // We can't traverse this?
681                                    break;
682                                }
683                            } else {
684                                // We can't traverse this?
685                                break;
686                            }
687                        }
688                        Segment::Enum { .. } => break,
689                        Segment::Unknown => break,
690                    }
691                }
692                let mut best_span = *best_node.span();
693                if let Error::UnknownFieldError(field, _, _) = &e {
694                    // We actually would prefer to point at the key not the value,
695                    if let Some(map) = prev_best_node.as_mapping() {
696                        for (k, _) in map.iter() {
697                            if k.as_str() == field.as_str() {
698                                best_span = *k.span();
699                                break;
700                            }
701                        }
702                    }
703                }
704                e.set_span(best_span);
705                FromNodeError {
706                    error: Box::new(e),
707                    path,
708                }
709            } else {
710                let path = render_path(e.path());
711                FromNodeError {
712                    error: Box::new(e.into_inner()),
713                    path,
714                }
715            }
716        })
717    }
718}
719
720#[cfg(feature = "serde-path")]
721fn render_path(path: &serde_path_to_error::Path) -> Option<String> {
722    use serde_path_to_error::Segment::*;
723    use std::fmt::Write;
724    let mut ret = String::new();
725    let mut separator = "";
726    for segment in path.iter() {
727        if let Map { key } = segment {
728            if key == SPANNED_INNER {
729                continue;
730            }
731        }
732        if !matches!(segment, Seq { .. }) {
733            write!(ret, "{separator}{segment}").expect("Cannot format");
734        } else {
735            write!(ret, "{segment}").expect("Cannot format");
736        }
737        separator = ".";
738    }
739    if ret.is_empty() {
740        None
741    } else {
742        Some(ret)
743    }
744}
745
746// -------------------------------------------------------------------------------
747
748macro_rules! forward_to_nodes {
749    () => {
750        forward_to_nodes! [
751            deserialize_any()
752            deserialize_bool()
753            deserialize_i8()
754            deserialize_i16()
755            deserialize_i32()
756            deserialize_i64()
757            deserialize_i128()
758            deserialize_u8()
759            deserialize_u16()
760            deserialize_u32()
761            deserialize_u64()
762            deserialize_u128()
763            deserialize_f32()
764            deserialize_f64()
765            deserialize_char()
766            deserialize_str()
767            deserialize_string()
768            deserialize_bytes()
769            deserialize_byte_buf()
770            deserialize_option()
771            deserialize_unit()
772            deserialize_unit_struct(name: &'static str)
773            deserialize_newtype_struct(name: &'static str)
774            deserialize_seq()
775            deserialize_tuple(len: usize)
776            deserialize_tuple_struct(name: &'static str, len: usize)
777            deserialize_map()
778            deserialize_struct(name: &'static str, fields: &'static [&'static str])
779            deserialize_enum(name: &'static str, variants: &'static [&'static str])
780            deserialize_identifier()
781            deserialize_ignored_any()
782        ];
783    };
784
785    ($($meth:ident($($arg:ident: $ty:ty),*))*) => {
786        $(
787            fn $meth<V>(self, $($arg: $ty,)* visitor: V) -> Result<V::Value, Self::Error>
788            where
789              V: Visitor<'de>,
790            {
791                match self.node {
792                    Node::Scalar(s) => s
793                        .into_deserializer()
794                        .$meth($($arg,)* visitor),
795                    Node::Mapping(m) => m
796                        .into_deserializer()
797                        .$meth($($arg,)* visitor),
798                    Node::Sequence(s) => s
799                        .into_deserializer()
800                        .$meth($($arg,)* visitor),
801                }
802            }
803        )*
804    };
805}
806
807impl<'de> Deserializer<'de> for NodeDeserializer<'de> {
808    type Error = Error;
809
810    forward_to_nodes!();
811}
812
813// -------------------------------------------------------------------------------
814
815trait MarkedValue {
816    fn mark_span(&self) -> &Span;
817}
818
819impl MarkedValue for MarkedScalarNode {
820    fn mark_span(&self) -> &Span {
821        self.span()
822    }
823}
824
825impl MarkedValue for MarkedMappingNode {
826    fn mark_span(&self) -> &Span {
827        self.span()
828    }
829}
830
831impl MarkedValue for MarkedSequenceNode {
832    fn mark_span(&self) -> &Span {
833        self.span()
834    }
835}
836
837impl MarkedValue for Node {
838    fn mark_span(&self) -> &Span {
839        self.span()
840    }
841}
842
843// -------------------------------------------------------------------------------
844
845struct SpannedDeserializer<'de, T> {
846    node: &'de T,
847    state: SpannedDeserializerState,
848}
849
850enum SpannedDeserializerState {
851    SendStartSource,
852    SendStartCharacter,
853    SendStartLine,
854    SendStartColumn,
855    SendEndSource,
856    SendEndCharacter,
857    SendEndLine,
858    SendEndColumn,
859    SendValue,
860    Done,
861}
862
863impl<'de, T> SpannedDeserializer<'de, T>
864where
865    T: MarkedValue,
866{
867    fn new(node: &'de T) -> Self {
868        let state = if node.mark_span().start().is_some() {
869            SpannedDeserializerState::SendStartSource
870        } else if node.mark_span().end().is_some() {
871            SpannedDeserializerState::SendEndSource
872        } else {
873            SpannedDeserializerState::SendValue
874        };
875        Self { node, state }
876    }
877}
878
879impl<'de, T> MapAccess<'de> for SpannedDeserializer<'de, T>
880where
881    T: MarkedValue,
882    &'de T: IntoDeserializer<'de, Error>,
883{
884    type Error = Error;
885
886    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
887    where
888        K: serde::de::DeserializeSeed<'de>,
889    {
890        let key = match self.state {
891            SpannedDeserializerState::SendStartSource => SPANNED_SPAN_START_SOURCE,
892            SpannedDeserializerState::SendStartCharacter => SPANNED_SPAN_START_CHARACTER,
893            SpannedDeserializerState::SendStartLine => SPANNED_SPAN_START_LINE,
894            SpannedDeserializerState::SendStartColumn => SPANNED_SPAN_START_COLUMN,
895            SpannedDeserializerState::SendEndSource => SPANNED_SPAN_END_SOURCE,
896            SpannedDeserializerState::SendEndCharacter => SPANNED_SPAN_END_CHARACTER,
897            SpannedDeserializerState::SendEndLine => SPANNED_SPAN_END_LINE,
898            SpannedDeserializerState::SendEndColumn => SPANNED_SPAN_END_COLUMN,
899            SpannedDeserializerState::SendValue => SPANNED_INNER,
900            SpannedDeserializerState::Done => return Ok(None),
901        };
902        seed.deserialize(BorrowedStrDeserializer::new(key))
903            .map(Some)
904    }
905
906    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
907    where
908        V: serde::de::DeserializeSeed<'de>,
909    {
910        match self.state {
911            SpannedDeserializerState::SendStartSource => {
912                let v = self
913                    .node
914                    .mark_span()
915                    .start()
916                    .expect("Span missing start")
917                    .source();
918                self.state = SpannedDeserializerState::SendStartCharacter;
919                seed.deserialize(v.into_deserializer())
920            }
921            SpannedDeserializerState::SendStartCharacter => {
922                let v = self
923                    .node
924                    .mark_span()
925                    .start()
926                    .expect("Span missing start")
927                    .character();
928                self.state = SpannedDeserializerState::SendStartLine;
929                seed.deserialize(v.into_deserializer())
930            }
931            SpannedDeserializerState::SendStartLine => {
932                let v = self
933                    .node
934                    .mark_span()
935                    .start()
936                    .expect("Span missing start")
937                    .line();
938                self.state = SpannedDeserializerState::SendStartColumn;
939                seed.deserialize(v.into_deserializer())
940            }
941            SpannedDeserializerState::SendStartColumn => {
942                let v = self
943                    .node
944                    .mark_span()
945                    .start()
946                    .expect("Span missing start")
947                    .column();
948                self.state = if self.node.mark_span().end().is_some() {
949                    SpannedDeserializerState::SendEndSource
950                } else {
951                    SpannedDeserializerState::SendValue
952                };
953                seed.deserialize(v.into_deserializer())
954            }
955            SpannedDeserializerState::SendEndSource => {
956                let v = self
957                    .node
958                    .mark_span()
959                    .end()
960                    .expect("Span missing end")
961                    .source();
962                self.state = SpannedDeserializerState::SendEndCharacter;
963                seed.deserialize(v.into_deserializer())
964            }
965            SpannedDeserializerState::SendEndCharacter => {
966                let v = self
967                    .node
968                    .mark_span()
969                    .end()
970                    .expect("Span missing end")
971                    .character();
972                self.state = SpannedDeserializerState::SendEndLine;
973                seed.deserialize(v.into_deserializer())
974            }
975            SpannedDeserializerState::SendEndLine => {
976                let v = self
977                    .node
978                    .mark_span()
979                    .end()
980                    .expect("Span missing end")
981                    .line();
982                self.state = SpannedDeserializerState::SendEndColumn;
983                seed.deserialize(v.into_deserializer())
984            }
985            SpannedDeserializerState::SendEndColumn => {
986                let v = self
987                    .node
988                    .mark_span()
989                    .end()
990                    .expect("Span missing end")
991                    .column();
992                self.state = SpannedDeserializerState::SendValue;
993                seed.deserialize(v.into_deserializer())
994            }
995            SpannedDeserializerState::SendValue => {
996                self.state = SpannedDeserializerState::Done;
997                seed.deserialize(self.node.into_deserializer())
998            }
999            SpannedDeserializerState::Done => panic!("next_value_seed called before next_key_seed"),
1000        }
1001    }
1002}
1003
1004// -------------------------------------------------------------------------------
1005
1006impl<'de> IntoDeserializer<'de, Error> for &'de MarkedScalarNode {
1007    type Deserializer = MarkedScalarNodeDeserializer<'de>;
1008    fn into_deserializer(self) -> MarkedScalarNodeDeserializer<'de> {
1009        MarkedScalarNodeDeserializer { node: self }
1010    }
1011}
1012
1013/// Deserializer for scalar nodes
1014pub struct MarkedScalarNodeDeserializer<'node> {
1015    node: &'node MarkedScalarNode,
1016}
1017
1018macro_rules! scalar_fromstr {
1019    () => {
1020        scalar_fromstr!(deserialize_u8 visit_u8 u8);
1021        scalar_fromstr!(deserialize_u16 visit_u16 u16);
1022        scalar_fromstr!(deserialize_u32 visit_u32 u32);
1023        scalar_fromstr!(deserialize_u64 visit_u64 u64);
1024        scalar_fromstr!(deserialize_u128 visit_u128 u128);
1025        scalar_fromstr!(deserialize_i8 visit_i8 i8);
1026        scalar_fromstr!(deserialize_i16 visit_i16 i16);
1027        scalar_fromstr!(deserialize_i32 visit_i32 i32);
1028        scalar_fromstr!(deserialize_i64 visit_i64 i64);
1029        scalar_fromstr!(deserialize_i128 visit_i128 i128);
1030        scalar_fromstr!(deserialize_f32 visit_f32 f32);
1031        scalar_fromstr!(deserialize_f64 visit_f64 f64);
1032    };
1033
1034    ($meth:ident $visit:ident $ty:ty) => {
1035        fn $meth<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1036        where
1037            V: Visitor<'de>,
1038        {
1039            if self.node.may_coerce() {
1040                let value: $ty = self.node.as_str().parse().addspans(*self.node.span())?;
1041                visitor.$visit(value)
1042            } else {
1043                visitor.visit_str(self.node.deref())
1044            }
1045        }
1046    };
1047}
1048
1049impl<'de> Deserializer<'de> for MarkedScalarNodeDeserializer<'de> {
1050    type Error = Error;
1051
1052    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1053    where
1054        V: Visitor<'de>,
1055    {
1056        self.node
1057            .deref()
1058            .into_deserializer()
1059            .deserialize_any(visitor)
1060    }
1061
1062    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1063    where
1064        V: Visitor<'de>,
1065    {
1066        visitor.visit_bool(
1067            self.node
1068                .as_bool()
1069                .ok_or(Error::NotBoolean(*self.node.span()))?,
1070        )
1071    }
1072
1073    scalar_fromstr!();
1074
1075    fn deserialize_struct<V>(
1076        self,
1077        name: &'static str,
1078        fields: &'static [&'static str],
1079        visitor: V,
1080    ) -> Result<V::Value, Self::Error>
1081    where
1082        V: Visitor<'de>,
1083    {
1084        if name == SPANNED_TYPE && fields == SPANNED_FIELDS {
1085            return visitor.visit_map(SpannedDeserializer::new(self.node));
1086        }
1087
1088        if self.node.is_empty_scalar() {
1089            return visitor.visit_map(EmptyMap);
1090        }
1091
1092        self.deserialize_any(visitor)
1093    }
1094
1095    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1096    where
1097        V: Visitor<'de>,
1098    {
1099        // Since we're here, there is no none, so visit as a some
1100        visitor.visit_some(self)
1101    }
1102
1103    fn deserialize_enum<V>(
1104        self,
1105        _name: &'static str,
1106        _variants: &'static [&'static str],
1107        visitor: V,
1108    ) -> Result<V::Value, Self::Error>
1109    where
1110        V: Visitor<'de>,
1111    {
1112        visitor.visit_enum(self.node.as_str().into_deserializer())
1113    }
1114
1115    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1116    where
1117        V: Visitor<'de>,
1118    {
1119        if self.node.is_empty_scalar() {
1120            return visitor.visit_map(EmptyMap);
1121        }
1122
1123        self.deserialize_any(visitor)
1124    }
1125
1126    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1127    where
1128        V: Visitor<'de>,
1129    {
1130        if self.node.is_empty_scalar() {
1131            return visitor.visit_seq(EmptySeq);
1132        }
1133
1134        self.deserialize_any(visitor)
1135    }
1136
1137    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1138    where
1139        V: Visitor<'de>,
1140    {
1141        if self.node.is_empty_scalar() {
1142            return visitor.visit_unit();
1143        }
1144
1145        self.deserialize_any(visitor)
1146    }
1147
1148    forward_to_deserialize_any! [
1149        char str string bytes byte_buf tuple
1150        unit_struct newtype_struct tuple_struct
1151        identifier ignored_any
1152    ];
1153}
1154
1155struct EmptyMap;
1156
1157impl<'de> MapAccess<'de> for EmptyMap {
1158    type Error = Error; // FUTURE: change to never type once stable
1159
1160    fn next_key_seed<K>(&mut self, _seed: K) -> Result<Option<K::Value>, Self::Error>
1161    where
1162        K: serde::de::DeserializeSeed<'de>,
1163    {
1164        Ok(None)
1165    }
1166
1167    fn next_value_seed<V>(&mut self, _seed: V) -> Result<V::Value, Self::Error>
1168    where
1169        V: serde::de::DeserializeSeed<'de>,
1170    {
1171        unreachable!()
1172    }
1173}
1174
1175struct EmptySeq;
1176
1177impl<'de> SeqAccess<'de> for EmptySeq {
1178    type Error = Error; // FUTURE: change to never type once stable
1179
1180    fn next_element_seed<T>(&mut self, _seed: T) -> Result<Option<T::Value>, Self::Error>
1181    where
1182        T: serde::de::DeserializeSeed<'de>,
1183    {
1184        Ok(None)
1185    }
1186}
1187
1188// -------------------------------------------------------------------------------
1189
1190type MappingValueSeq<'de> = hashlink::linked_hash_map::Iter<'de, MarkedScalarNode, Node>;
1191struct MappingAccess<'de> {
1192    items: Peekable<MappingValueSeq<'de>>,
1193}
1194
1195impl<'de> MappingAccess<'de> {
1196    fn new(items: MappingValueSeq<'de>) -> Self {
1197        Self {
1198            items: items.peekable(),
1199        }
1200    }
1201}
1202
1203impl<'de> MapAccess<'de> for MappingAccess<'de> {
1204    type Error = Error;
1205
1206    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
1207    where
1208        K: serde::de::DeserializeSeed<'de>,
1209    {
1210        if let Some(next_key) = self.items.peek().map(|(k, _v)| k) {
1211            seed.deserialize(next_key.into_deserializer()).map(Some)
1212        } else {
1213            Ok(None)
1214        }
1215    }
1216
1217    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
1218    where
1219        V: serde::de::DeserializeSeed<'de>,
1220    {
1221        seed.deserialize(
1222            self.items
1223                .next()
1224                .expect("next_value_seed called before next_key_seed")
1225                .1
1226                .into_deserializer(),
1227        )
1228    }
1229}
1230
1231// -------------------------------------------------------------------------------
1232
1233struct MarkedMappingNodeEnumAccess<'de> {
1234    node: &'de MarkedMappingNode,
1235}
1236
1237impl<'de> MarkedMappingNodeEnumAccess<'de> {
1238    fn first(&self) -> &'de Node {
1239        self.node
1240            .values()
1241            .next()
1242            .expect("variant accessed before variant seed")
1243    }
1244}
1245
1246impl<'de> EnumAccess<'de> for MarkedMappingNodeEnumAccess<'de> {
1247    type Error = Error;
1248    type Variant = Self;
1249
1250    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
1251    where
1252        V: serde::de::DeserializeSeed<'de>,
1253    {
1254        if let Some(first) = self.node.keys().next() {
1255            seed.deserialize(first.into_deserializer())
1256                .map(|v| (v, self))
1257        } else {
1258            Err(serde::de::Error::custom(
1259                "Unexpected empty map when looking for enum variant",
1260            ))
1261        }
1262    }
1263}
1264
1265impl<'de> VariantAccess<'de> for MarkedMappingNodeEnumAccess<'de> {
1266    type Error = Error;
1267
1268    fn unit_variant(self) -> Result<(), Self::Error> {
1269        Err(serde::de::Error::invalid_type(Unexpected::Map, &"String"))
1270    }
1271
1272    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
1273    where
1274        T: serde::de::DeserializeSeed<'de>,
1275    {
1276        seed.deserialize(self.first().into_deserializer())
1277    }
1278
1279    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
1280    where
1281        V: Visitor<'de>,
1282    {
1283        self.first().into_deserializer().deserialize_seq(visitor)
1284    }
1285
1286    fn struct_variant<V>(
1287        self,
1288        _fields: &'static [&'static str],
1289        visitor: V,
1290    ) -> Result<V::Value, Self::Error>
1291    where
1292        V: Visitor<'de>,
1293    {
1294        self.first().into_deserializer().deserialize_map(visitor)
1295    }
1296}
1297
1298// -------------------------------------------------------------------------------
1299
1300impl<'de> IntoDeserializer<'de, Error> for &'de MarkedMappingNode {
1301    type Deserializer = MarkedMappingNodeDeserializer<'de>;
1302
1303    fn into_deserializer(self) -> Self::Deserializer {
1304        MarkedMappingNodeDeserializer { node: self }
1305    }
1306}
1307
1308/// Deserializer for mapping nodes
1309pub struct MarkedMappingNodeDeserializer<'de> {
1310    node: &'de MarkedMappingNode,
1311}
1312
1313impl<'de> Deserializer<'de> for MarkedMappingNodeDeserializer<'de> {
1314    type Error = Error;
1315
1316    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1317    where
1318        V: Visitor<'de>,
1319    {
1320        visitor.visit_map(MappingAccess::new(self.node.iter()))
1321    }
1322
1323    fn deserialize_struct<V>(
1324        self,
1325        name: &'static str,
1326        fields: &'static [&'static str],
1327        visitor: V,
1328    ) -> Result<V::Value, Self::Error>
1329    where
1330        V: Visitor<'de>,
1331    {
1332        if name == SPANNED_TYPE && fields == SPANNED_FIELDS {
1333            return visitor.visit_map(SpannedDeserializer::new(self.node));
1334        }
1335
1336        self.deserialize_any(visitor)
1337    }
1338
1339    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1340    where
1341        V: Visitor<'de>,
1342    {
1343        // Since we're here, there is no none, so visit as a some
1344        visitor.visit_some(self)
1345    }
1346
1347    fn deserialize_enum<V>(
1348        self,
1349        _name: &'static str,
1350        _variants: &'static [&'static str],
1351        visitor: V,
1352    ) -> Result<V::Value, Self::Error>
1353    where
1354        V: Visitor<'de>,
1355    {
1356        match self.node.len() {
1357            0 => Err(serde::de::Error::custom(
1358                "Expected map with one value, got empty map",
1359            )),
1360            1 => visitor.visit_enum(MarkedMappingNodeEnumAccess { node: self.node }),
1361            n => Err(serde::de::Error::custom(format!(
1362                "Expected map with one value, got {n} values"
1363            ))),
1364        }
1365    }
1366
1367    forward_to_deserialize_any! [
1368        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes byte_buf
1369        unit unit_struct newtype_struct seq tuple tuple_struct
1370        map identifier ignored_any
1371    ];
1372}
1373
1374// -------------------------------------------------------------------------------
1375
1376struct SequenceAccess<'de> {
1377    items: &'de [Node],
1378    pos: usize,
1379}
1380
1381impl<'de> SequenceAccess<'de> {
1382    fn new(items: &'de [Node]) -> Self {
1383        Self { items, pos: 0 }
1384    }
1385}
1386
1387impl<'de> SeqAccess<'de> for SequenceAccess<'de> {
1388    type Error = Error;
1389
1390    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
1391    where
1392        T: serde::de::DeserializeSeed<'de>,
1393    {
1394        if self.pos == self.items.len() {
1395            return Ok(None);
1396        }
1397        let pos = self.pos;
1398        self.pos += 1;
1399
1400        seed.deserialize(self.items[pos].into_deserializer())
1401            .map(Some)
1402    }
1403}
1404
1405// -------------------------------------------------------------------------------
1406
1407impl<'de> IntoDeserializer<'de, Error> for &'de MarkedSequenceNode {
1408    type Deserializer = MarkedSequenceNodeDeserializer<'de>;
1409
1410    fn into_deserializer(self) -> Self::Deserializer {
1411        MarkedSequenceNodeDeserializer { node: self }
1412    }
1413}
1414
1415/// Deserializer for sequence nodes
1416pub struct MarkedSequenceNodeDeserializer<'de> {
1417    node: &'de MarkedSequenceNode,
1418}
1419
1420impl<'de> Deserializer<'de> for MarkedSequenceNodeDeserializer<'de> {
1421    type Error = Error;
1422
1423    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1424    where
1425        V: Visitor<'de>,
1426    {
1427        visitor.visit_seq(SequenceAccess::new(self.node.as_slice()))
1428    }
1429
1430    fn deserialize_struct<V>(
1431        self,
1432        name: &'static str,
1433        fields: &'static [&'static str],
1434        visitor: V,
1435    ) -> Result<V::Value, Self::Error>
1436    where
1437        V: Visitor<'de>,
1438    {
1439        if name == SPANNED_TYPE && fields == SPANNED_FIELDS {
1440            return visitor.visit_map(SpannedDeserializer::new(self.node));
1441        }
1442
1443        self.deserialize_any(visitor)
1444    }
1445
1446    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1447    where
1448        V: Visitor<'de>,
1449    {
1450        // Since we're here, there is no none, so visit as a some
1451        visitor.visit_some(self)
1452    }
1453
1454    forward_to_deserialize_any! [
1455        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes byte_buf
1456        unit unit_struct newtype_struct seq tuple tuple_struct
1457        map enum identifier ignored_any
1458    ];
1459}
1460
1461// -------------------------------------------------------------------------------
1462
1463#[cfg(test)]
1464mod test {
1465    use std::collections::HashMap;
1466
1467    use super::*;
1468
1469    const TEST_DOC: &str = r#"hello: world
1470some: [ value, or, other ]
1471says: { grow: nothing, or: die }
1472numbers: [ 1, 2, 3, 500 ]
1473success: true
1474failure: False
1475shouting: TRUE
1476"#;
1477
1478    #[test]
1479    #[allow(dead_code)]
1480    fn basic_deserialize() {
1481        #[derive(Deserialize, Debug)]
1482        struct TestDoc {
1483            hello: String,
1484            some: Vec<String>,
1485            says: HashMap<String, String>,
1486        }
1487        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1488        let doc: TestDoc = from_node(&node).unwrap();
1489        println!("{doc:#?}");
1490    }
1491
1492    #[test]
1493    #[allow(dead_code)]
1494    fn basic_deserialize_spanned_scalars() {
1495        #[derive(Deserialize, Debug)]
1496        struct TestDoc {
1497            hello: Spanned<String>,
1498            some: Vec<Spanned<String>>,
1499            says: HashMap<Spanned<String>, Spanned<String>>,
1500        }
1501        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1502        let doc: TestDoc = from_node(&node).unwrap();
1503        println!("{doc:#?}");
1504    }
1505
1506    #[test]
1507    #[allow(dead_code)]
1508    fn basic_deserialize_spanned_everything() {
1509        #[derive(Deserialize, Debug)]
1510        struct TestDoc {
1511            hello: Spanned<String>,
1512            some: Spanned<Vec<Spanned<String>>>,
1513            says: Spanned<HashMap<Spanned<String>, Spanned<String>>>,
1514        }
1515        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1516        let doc: Spanned<TestDoc> = from_node(&node).unwrap();
1517        println!("{doc:#?}");
1518    }
1519
1520    #[test]
1521    #[allow(dead_code)]
1522    fn basic_deserialize_numbers() {
1523        #[derive(Deserialize, Debug)]
1524        struct TestDoc {
1525            numbers: Vec<u16>,
1526        }
1527        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1528        let doc: Spanned<TestDoc> = from_node(&node).unwrap();
1529        println!("{doc:#?}");
1530    }
1531
1532    #[test]
1533    #[allow(dead_code)]
1534    #[cfg(not(feature = "serde-path"))]
1535    fn basic_deserialize_bad_numbers() {
1536        #[derive(Deserialize, Debug)]
1537        struct TestDoc {
1538            numbers: Vec<u8>,
1539        }
1540        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1541        let err = from_node::<TestDoc>(&node).err().unwrap().into_inner();
1542        match err {
1543            Error::IntegerParseFailure(_e, s) => {
1544                let start = s.start().unwrap();
1545                assert_eq!(start.source(), 0);
1546                assert_eq!(start.character(), 93);
1547                assert_eq!(start.line(), 4);
1548                assert_eq!(start.column(), 21);
1549            }
1550            _ => panic!("Unexpected error"),
1551        }
1552    }
1553
1554    #[test]
1555    #[allow(dead_code)]
1556    #[cfg(feature = "serde-path")]
1557    fn basic_deserialize_bad_numbers() {
1558        #[derive(Deserialize, Debug)]
1559        struct TestDoc {
1560            numbers: Vec<u8>,
1561        }
1562        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1563        let err = from_node::<TestDoc>(&node).err().unwrap();
1564        assert_eq!(err.path(), Some("numbers[3]"));
1565        let err = err.into_inner();
1566        match err {
1567            Error::IntegerParseFailure(_e, s) => {
1568                let start = s.start().unwrap();
1569                assert_eq!(start.source(), 0);
1570                assert_eq!(start.line(), 4);
1571                assert_eq!(start.column(), 21);
1572            }
1573            _ => panic!("Unexpected error"),
1574        }
1575    }
1576
1577    #[test]
1578    #[allow(dead_code)]
1579    fn basic_deserialize_spanned_numbers() {
1580        #[derive(Deserialize, Debug)]
1581        struct TestDoc {
1582            numbers: Vec<Spanned<i128>>,
1583        }
1584        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1585        let doc: Spanned<TestDoc> = from_node(&node).unwrap();
1586        println!("{doc:#?}");
1587    }
1588
1589    #[test]
1590    #[allow(dead_code)]
1591    fn basic_deserialize_bools() {
1592        #[derive(Deserialize, Debug)]
1593        struct TestDoc {
1594            success: bool,
1595            failure: Spanned<bool>,
1596            shouting: Spanned<bool>,
1597        }
1598        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1599        let doc: Spanned<TestDoc> = from_node(&node).unwrap();
1600        println!("{doc:#?}");
1601    }
1602
1603    #[test]
1604    #[allow(dead_code)]
1605    fn disallowed_keys() {
1606        #[derive(Deserialize)]
1607        #[serde(deny_unknown_fields)]
1608        struct TestDoc {
1609            success: bool,
1610        }
1611        let node = crate::parse_yaml(0, TEST_DOC).unwrap();
1612        let err = from_node::<TestDoc>(&node).err().unwrap();
1613        #[cfg(feature = "serde-path")]
1614        {
1615            assert_eq!(err.path(), Some("hello"));
1616            let mark = err.start_mark().unwrap();
1617            assert_eq!(mark.source(), 0);
1618            assert_eq!(mark.line(), 1);
1619            assert_eq!(mark.column(), 1);
1620        };
1621        assert!(matches!(&*err, Error::UnknownFieldError(_, _, _)));
1622    }
1623}
marked_yaml/spanned_serde.rs

marked_yaml/
spanned_serde.rs
