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

marked_yaml/
spanned_serde.rs
