serde_xml/
de.rs

1//! Serde deserializer for XML.
2//!
3//! This module provides a full-featured Serde deserializer that converts
4//! XML documents into Rust data structures.
5
6use crate::error::{Error, Result};
7use crate::reader::{XmlEvent, XmlReader};
8use serde::de::{self, DeserializeSeed, MapAccess, SeqAccess, Visitor};
9
10/// Deserializes a value from an XML string.
11///
12/// # Example
13///
14/// ```
15/// use serde::Deserialize;
16/// use serde_xml::from_str;
17///
18/// #[derive(Deserialize)]
19/// struct Person {
20///     name: String,
21///     age: u32,
22/// }
23///
24/// let xml = "<Person><name>Alice</name><age>30</age></Person>";
25/// let person: Person = from_str(xml).unwrap();
26/// assert_eq!(person.name, "Alice");
27/// assert_eq!(person.age, 30);
28/// ```
29pub fn from_str<'de, T>(s: &'de str) -> Result<T>
30where
31    T: de::Deserialize<'de>,
32{
33    let mut de = Deserializer::from_str(s);
34    T::deserialize(&mut de)
35}
36
37/// Deserializes a value from XML bytes.
38pub fn from_bytes<'de, T>(bytes: &'de [u8]) -> Result<T>
39where
40    T: de::Deserialize<'de>,
41{
42    let s = std::str::from_utf8(bytes)
43        .map_err(|_| Error::new(crate::error::ErrorKind::InvalidUtf8))?;
44    from_str(s)
45}
46
47/// The XML deserializer.
48pub struct Deserializer<'de> {
49    reader: XmlReader<'de>,
50    /// Peeked event for look-ahead.
51    peeked: Option<XmlEvent<'de>>,
52    /// Pending value to deserialize (for text content or attribute values).
53    pending_value: Option<String>,
54    /// Whether we already consumed the start element for the current struct.
55    start_consumed: bool,
56    /// Whether the current element is empty (<tag/>).
57    is_empty_element: bool,
58}
59
60impl<'de> Deserializer<'de> {
61    /// Creates a new deserializer from a string.
62    #[allow(clippy::should_implement_trait)]
63    pub fn from_str(s: &'de str) -> Self {
64        Self {
65            reader: XmlReader::from_str(s),
66            peeked: None,
67            pending_value: None,
68            start_consumed: false,
69            is_empty_element: false,
70        }
71    }
72
73    /// Peeks at the next event without consuming it.
74    fn peek_event(&mut self) -> Result<&XmlEvent<'de>> {
75        if self.peeked.is_none() {
76            self.peeked = Some(self.reader.next_event()?);
77        }
78        Ok(self.peeked.as_ref().unwrap())
79    }
80
81    /// Consumes and returns the next event.
82    fn next_event(&mut self) -> Result<XmlEvent<'de>> {
83        if let Some(event) = self.peeked.take() {
84            Ok(event)
85        } else {
86            self.reader.next_event()
87        }
88    }
89
90    /// Reads text content until we hit an end tag or another element.
91    fn read_text_content(&mut self) -> Result<String> {
92        let mut content = String::new();
93
94        loop {
95            match self.peek_event()? {
96                XmlEvent::Text(text) => {
97                    content.push_str(text);
98                    self.next_event()?;
99                }
100                XmlEvent::CData(data) => {
101                    content.push_str(data);
102                    self.next_event()?;
103                }
104                _ => break,
105            }
106        }
107
108        Ok(content)
109    }
110
111    /// Reads element text and consumes the end tag.
112    fn read_element_text(&mut self) -> Result<String> {
113        if self.is_empty_element {
114            self.is_empty_element = false;
115            self.start_consumed = false;
116            return Ok(String::new());
117        }
118
119        let content = self.read_text_content()?;
120
121        // Consume end element if we're after a start element
122        if self.start_consumed {
123            self.start_consumed = false;
124            if let XmlEvent::EndElement { .. } = self.peek_event()? {
125                self.next_event()?;
126            }
127        }
128
129        Ok(content)
130    }
131
132    /// Skips the current element and all its children.
133    fn skip_element(&mut self) -> Result<()> {
134        let mut depth = 1;
135        while depth > 0 {
136            match self.next_event()? {
137                XmlEvent::StartElement { .. } => depth += 1,
138                XmlEvent::EndElement { .. } => depth -= 1,
139                XmlEvent::EmptyElement { .. } => {}
140                XmlEvent::Eof => return Err(Error::unexpected_eof()),
141                _ => {}
142            }
143        }
144        Ok(())
145    }
146
147    /// Parses a value from a string.
148    fn parse_value<T>(&self, s: &str) -> Result<T>
149    where
150        T: std::str::FromStr,
151        T::Err: std::fmt::Display,
152    {
153        s.parse()
154            .map_err(|e: T::Err| Error::invalid_value(e.to_string()))
155    }
156
157    /// Gets text for primitive deserialization.
158    fn get_text(&mut self) -> Result<String> {
159        if let Some(value) = self.pending_value.take() {
160            return Ok(value);
161        }
162
163        // If start was already consumed
164        if self.start_consumed {
165            return self.read_element_text();
166        }
167
168        // Otherwise, we might need to consume a start element first
169        match self.peek_event()? {
170            XmlEvent::StartElement { .. } => {
171                self.next_event()?;
172                self.start_consumed = true;
173                self.is_empty_element = false;
174                self.read_element_text()
175            }
176            XmlEvent::EmptyElement { .. } => {
177                self.next_event()?;
178                Ok(String::new())
179            }
180            _ => self.read_text_content(),
181        }
182    }
183}
184
185impl<'de> de::Deserializer<'de> for &mut Deserializer<'de> {
186    type Error = Error;
187
188    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
189    where
190        V: Visitor<'de>,
191    {
192        if let Some(value) = self.pending_value.take() {
193            return visitor.visit_string(value);
194        }
195
196        match self.peek_event()? {
197            XmlEvent::StartElement { .. } | XmlEvent::EmptyElement { .. } => {
198                self.deserialize_map(visitor)
199            }
200            XmlEvent::Text(text) => {
201                let text = text.clone().into_owned();
202                self.next_event()?;
203                visitor.visit_string(text)
204            }
205            XmlEvent::CData(data) => {
206                let data = data.clone().into_owned();
207                self.next_event()?;
208                visitor.visit_string(data)
209            }
210            XmlEvent::EndElement { .. } => visitor.visit_unit(),
211            XmlEvent::Eof => visitor.visit_unit(),
212            _ => {
213                self.next_event()?;
214                self.deserialize_any(visitor)
215            }
216        }
217    }
218
219    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
220    where
221        V: Visitor<'de>,
222    {
223        let text = self.get_text()?;
224        match text.as_str() {
225            "true" | "1" | "yes" => visitor.visit_bool(true),
226            "false" | "0" | "no" => visitor.visit_bool(false),
227            _ => Err(Error::invalid_value(format!("expected boolean, got '{}'", text))),
228        }
229    }
230
231    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
232    where
233        V: Visitor<'de>,
234    {
235        let text = self.get_text()?;
236        visitor.visit_i8(self.parse_value(&text)?)
237    }
238
239    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
240    where
241        V: Visitor<'de>,
242    {
243        let text = self.get_text()?;
244        visitor.visit_i16(self.parse_value(&text)?)
245    }
246
247    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
248    where
249        V: Visitor<'de>,
250    {
251        let text = self.get_text()?;
252        visitor.visit_i32(self.parse_value(&text)?)
253    }
254
255    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
256    where
257        V: Visitor<'de>,
258    {
259        let text = self.get_text()?;
260        visitor.visit_i64(self.parse_value(&text)?)
261    }
262
263    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
264    where
265        V: Visitor<'de>,
266    {
267        let text = self.get_text()?;
268        visitor.visit_u8(self.parse_value(&text)?)
269    }
270
271    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
272    where
273        V: Visitor<'de>,
274    {
275        let text = self.get_text()?;
276        visitor.visit_u16(self.parse_value(&text)?)
277    }
278
279    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
280    where
281        V: Visitor<'de>,
282    {
283        let text = self.get_text()?;
284        visitor.visit_u32(self.parse_value(&text)?)
285    }
286
287    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
288    where
289        V: Visitor<'de>,
290    {
291        let text = self.get_text()?;
292        visitor.visit_u64(self.parse_value(&text)?)
293    }
294
295    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
296    where
297        V: Visitor<'de>,
298    {
299        let text = self.get_text()?;
300        visitor.visit_f32(self.parse_value(&text)?)
301    }
302
303    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
304    where
305        V: Visitor<'de>,
306    {
307        let text = self.get_text()?;
308        visitor.visit_f64(self.parse_value(&text)?)
309    }
310
311    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
312    where
313        V: Visitor<'de>,
314    {
315        let text = self.get_text()?;
316        let mut chars = text.chars();
317        match (chars.next(), chars.next()) {
318            (Some(c), None) => visitor.visit_char(c),
319            _ => Err(Error::invalid_value("expected single character")),
320        }
321    }
322
323    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
324    where
325        V: Visitor<'de>,
326    {
327        self.deserialize_string(visitor)
328    }
329
330    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
331    where
332        V: Visitor<'de>,
333    {
334        let text = self.get_text()?;
335        visitor.visit_string(text)
336    }
337
338    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
339    where
340        V: Visitor<'de>,
341    {
342        let text = self.get_text()?;
343        visitor.visit_bytes(text.as_bytes())
344    }
345
346    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
347    where
348        V: Visitor<'de>,
349    {
350        self.deserialize_bytes(visitor)
351    }
352
353    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
354    where
355        V: Visitor<'de>,
356    {
357        if self.pending_value.is_some() || self.start_consumed {
358            return visitor.visit_some(self);
359        }
360
361        match self.peek_event()? {
362            XmlEvent::EndElement { .. } | XmlEvent::Eof => visitor.visit_none(),
363            _ => visitor.visit_some(self),
364        }
365    }
366
367    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
368    where
369        V: Visitor<'de>,
370    {
371        self.pending_value = None;
372        if self.start_consumed && !self.is_empty_element {
373            // Consume end element
374            if let XmlEvent::EndElement { .. } = self.peek_event()? {
375                self.next_event()?;
376            }
377        }
378        self.start_consumed = false;
379        self.is_empty_element = false;
380        visitor.visit_unit()
381    }
382
383    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
384    where
385        V: Visitor<'de>,
386    {
387        if self.start_consumed {
388            if !self.is_empty_element {
389                // Consume end element
390                loop {
391                    match self.next_event()? {
392                        XmlEvent::EndElement { .. } => break,
393                        XmlEvent::Eof => break,
394                        _ => {}
395                    }
396                }
397            }
398            self.start_consumed = false;
399            self.is_empty_element = false;
400            return visitor.visit_unit();
401        }
402
403        match self.peek_event()? {
404            XmlEvent::EmptyElement { .. } => {
405                self.next_event()?;
406            }
407            XmlEvent::StartElement { .. } => {
408                self.next_event()?;
409                loop {
410                    match self.next_event()? {
411                        XmlEvent::EndElement { .. } => break,
412                        XmlEvent::Eof => break,
413                        _ => {}
414                    }
415                }
416            }
417            _ => {}
418        }
419        visitor.visit_unit()
420    }
421
422    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
423    where
424        V: Visitor<'de>,
425    {
426        visitor.visit_newtype_struct(self)
427    }
428
429    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
430    where
431        V: Visitor<'de>,
432    {
433        visitor.visit_seq(SeqDeserializer::new(self))
434    }
435
436    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
437    where
438        V: Visitor<'de>,
439    {
440        self.deserialize_seq(visitor)
441    }
442
443    fn deserialize_tuple_struct<V>(
444        self,
445        _name: &'static str,
446        _len: usize,
447        visitor: V,
448    ) -> Result<V::Value>
449    where
450        V: Visitor<'de>,
451    {
452        self.deserialize_seq(visitor)
453    }
454
455    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
456    where
457        V: Visitor<'de>,
458    {
459        // Check if start was already consumed (for nested structs)
460        let (attrs, is_empty) = if self.start_consumed {
461            self.start_consumed = false;
462            let is_empty = self.is_empty_element;
463            self.is_empty_element = false;
464            (vec![], is_empty)
465        } else {
466            // Get attributes from the start element
467            match self.next_event()? {
468                XmlEvent::StartElement { attributes, .. } => {
469                    let attrs: Vec<_> = attributes
470                        .into_iter()
471                        .map(|a| (a.name.into_owned(), a.value.into_owned()))
472                        .collect();
473                    (attrs, false)
474                }
475                XmlEvent::EmptyElement { attributes, .. } => {
476                    let attrs: Vec<_> = attributes
477                        .into_iter()
478                        .map(|a| (a.name.into_owned(), a.value.into_owned()))
479                        .collect();
480                    (attrs, true)
481                }
482                XmlEvent::Eof => (vec![], true),
483                _ => (vec![], false),
484            }
485        };
486
487        let result = visitor.visit_map(MapDeserializer {
488            de: self,
489            attrs,
490            attr_idx: 0,
491            finished: is_empty,
492        })?;
493
494        // Consume remaining content until end element
495        if !is_empty {
496            loop {
497                match self.peek_event()? {
498                    XmlEvent::EndElement { .. } => {
499                        self.next_event()?;
500                        break;
501                    }
502                    XmlEvent::Eof => break,
503                    _ => {
504                        self.next_event()?;
505                    }
506                }
507            }
508        }
509
510        Ok(result)
511    }
512
513    fn deserialize_struct<V>(
514        self,
515        _name: &'static str,
516        _fields: &'static [&'static str],
517        visitor: V,
518    ) -> Result<V::Value>
519    where
520        V: Visitor<'de>,
521    {
522        self.deserialize_map(visitor)
523    }
524
525    fn deserialize_enum<V>(
526        self,
527        _name: &'static str,
528        _variants: &'static [&'static str],
529        visitor: V,
530    ) -> Result<V::Value>
531    where
532        V: Visitor<'de>,
533    {
534        visitor.visit_enum(EnumDeserializer::new(self))
535    }
536
537    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
538    where
539        V: Visitor<'de>,
540    {
541        self.deserialize_string(visitor)
542    }
543
544    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
545    where
546        V: Visitor<'de>,
547    {
548        self.pending_value = None;
549
550        if self.start_consumed {
551            if !self.is_empty_element {
552                self.skip_element()?;
553            }
554            self.start_consumed = false;
555            self.is_empty_element = false;
556            return visitor.visit_unit();
557        }
558
559        match self.peek_event()? {
560            XmlEvent::StartElement { .. } => {
561                self.next_event()?;
562                self.skip_element()?;
563            }
564            XmlEvent::EmptyElement { .. } => {
565                self.next_event()?;
566            }
567            XmlEvent::Text(_) | XmlEvent::CData(_) => {
568                self.next_event()?;
569            }
570            _ => {}
571        }
572        visitor.visit_unit()
573    }
574}
575
576/// Sequence deserializer for arrays and vectors.
577struct SeqDeserializer<'a, 'de> {
578    de: &'a mut Deserializer<'de>,
579    element_name: Option<String>,
580}
581
582impl<'a, 'de> SeqDeserializer<'a, 'de> {
583    fn new(de: &'a mut Deserializer<'de>) -> Self {
584        Self {
585            de,
586            element_name: None,
587        }
588    }
589}
590
591impl<'de, 'a> SeqAccess<'de> for SeqDeserializer<'a, 'de> {
592    type Error = Error;
593
594    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
595    where
596        T: DeserializeSeed<'de>,
597    {
598        loop {
599            match self.de.peek_event()? {
600                XmlEvent::StartElement { name, .. } | XmlEvent::EmptyElement { name, .. } => {
601                    let current_name = name.clone().into_owned();
602
603                    if let Some(ref expected) = self.element_name {
604                        if &current_name != expected {
605                            return Ok(None);
606                        }
607                    } else {
608                        self.element_name = Some(current_name);
609                    }
610
611                    return seed.deserialize(&mut *self.de).map(Some);
612                }
613                XmlEvent::EndElement { .. } | XmlEvent::Eof => return Ok(None),
614                XmlEvent::Text(_) | XmlEvent::CData(_) => {
615                    return seed.deserialize(&mut *self.de).map(Some);
616                }
617                _ => {
618                    self.de.next_event()?;
619                }
620            }
621        }
622    }
623}
624
625/// Map deserializer for structs.
626struct MapDeserializer<'a, 'de> {
627    de: &'a mut Deserializer<'de>,
628    attrs: Vec<(String, String)>,
629    attr_idx: usize,
630    finished: bool,
631}
632
633impl<'de, 'a> MapAccess<'de> for MapDeserializer<'a, 'de> {
634    type Error = Error;
635
636    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
637    where
638        K: DeserializeSeed<'de>,
639    {
640        // First, return any remaining attributes (prefixed with @)
641        if self.attr_idx < self.attrs.len() {
642            let (name, _) = &self.attrs[self.attr_idx];
643            // Prefix with @ to match serde rename convention for attributes
644            self.de.pending_value = Some(format!("@{}", name));
645            return seed.deserialize(&mut *self.de).map(Some);
646        }
647
648        if self.finished {
649            return Ok(None);
650        }
651
652        // Then check for child elements
653        loop {
654            match self.de.peek_event()? {
655                XmlEvent::StartElement { name, .. } | XmlEvent::EmptyElement { name, .. } => {
656                    let name = name.clone().into_owned();
657                    // Don't consume the element here - let the value deserializer do it
658                    self.de.pending_value = Some(name);
659                    return seed.deserialize(&mut *self.de).map(Some);
660                }
661                XmlEvent::EndElement { .. } | XmlEvent::Eof => {
662                    self.finished = true;
663                    return Ok(None);
664                }
665                XmlEvent::Text(_) | XmlEvent::CData(_) => {
666                    self.de.pending_value = Some("$value".to_string());
667                    return seed.deserialize(&mut *self.de).map(Some);
668                }
669                _ => {
670                    self.de.next_event()?;
671                }
672            }
673        }
674    }
675
676    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
677    where
678        V: DeserializeSeed<'de>,
679    {
680        // Handle attribute values
681        if self.attr_idx < self.attrs.len() {
682            let (_, value) = &self.attrs[self.attr_idx];
683            self.attr_idx += 1;
684            self.de.pending_value = Some(value.clone());
685            return seed.deserialize(&mut *self.de);
686        }
687
688        // Handle element values - element already consumed in next_key_seed
689        seed.deserialize(&mut *self.de)
690    }
691}
692
693/// Enum deserializer.
694struct EnumDeserializer<'a, 'de> {
695    de: &'a mut Deserializer<'de>,
696}
697
698impl<'a, 'de> EnumDeserializer<'a, 'de> {
699    fn new(de: &'a mut Deserializer<'de>) -> Self {
700        Self { de }
701    }
702}
703
704impl<'de, 'a> de::EnumAccess<'de> for EnumDeserializer<'a, 'de> {
705    type Error = Error;
706    type Variant = Self;
707
708    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
709    where
710        V: DeserializeSeed<'de>,
711    {
712        // Check for pending value (text-based enum)
713        if self.de.pending_value.is_some() {
714            let variant = seed.deserialize(&mut *self.de)?;
715            return Ok((variant, self));
716        }
717
718        // The variant name is the element name
719        match self.de.peek_event()? {
720            XmlEvent::StartElement { name, .. } | XmlEvent::EmptyElement { name, .. } => {
721                let name = name.clone().into_owned();
722                self.de.pending_value = Some(name);
723            }
724            XmlEvent::Text(text) => {
725                let text = text.clone().into_owned();
726                self.de.pending_value = Some(text);
727            }
728            _ => {}
729        }
730
731        let variant = seed.deserialize(&mut *self.de)?;
732        Ok((variant, self))
733    }
734}
735
736impl<'de, 'a> de::VariantAccess<'de> for EnumDeserializer<'a, 'de> {
737    type Error = Error;
738
739    fn unit_variant(self) -> Result<()> {
740        if self.de.start_consumed {
741            if !self.de.is_empty_element {
742                self.de.skip_element()?;
743            }
744            self.de.start_consumed = false;
745            self.de.is_empty_element = false;
746            return Ok(());
747        }
748
749        match self.de.peek_event()? {
750            XmlEvent::EmptyElement { .. } => {
751                self.de.next_event()?;
752            }
753            XmlEvent::StartElement { .. } => {
754                self.de.next_event()?;
755                self.de.skip_element()?;
756            }
757            _ => {}
758        }
759        Ok(())
760    }
761
762    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
763    where
764        T: DeserializeSeed<'de>,
765    {
766        seed.deserialize(&mut *self.de)
767    }
768
769    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
770    where
771        V: Visitor<'de>,
772    {
773        de::Deserializer::deserialize_seq(&mut *self.de, visitor)
774    }
775
776    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
777    where
778        V: Visitor<'de>,
779    {
780        de::Deserializer::deserialize_map(&mut *self.de, visitor)
781    }
782}
783
784#[cfg(test)]
785mod tests {
786    use super::*;
787    use serde::Deserialize;
788
789    #[test]
790    fn test_deserialize_simple_struct() {
791        #[derive(Debug, Deserialize, PartialEq)]
792        struct Person {
793            name: String,
794            age: u32,
795        }
796
797        let xml = "<Person><name>Alice</name><age>30</age></Person>";
798        let person: Person = from_str(xml).unwrap();
799        assert_eq!(person.name, "Alice");
800        assert_eq!(person.age, 30);
801    }
802
803    #[test]
804    fn test_deserialize_with_attributes() {
805        #[derive(Debug, Deserialize, PartialEq)]
806        struct Item {
807            #[serde(rename = "@id")]
808            id: String,
809            name: String,
810        }
811
812        let xml = r#"<Item id="123"><name>Widget</name></Item>"#;
813        let item: Item = from_str(xml).unwrap();
814        assert_eq!(item.id, "123");
815        assert_eq!(item.name, "Widget");
816    }
817
818    #[test]
819    fn test_deserialize_nested_struct() {
820        #[derive(Debug, Deserialize, PartialEq)]
821        struct Address {
822            city: String,
823            country: String,
824        }
825
826        #[derive(Debug, Deserialize, PartialEq)]
827        struct Person {
828            name: String,
829            address: Address,
830        }
831
832        let xml = r#"
833            <Person>
834                <name>Bob</name>
835                <address>
836                    <city>New York</city>
837                    <country>USA</country>
838                </address>
839            </Person>
840        "#;
841        let person: Person = from_str(xml).unwrap();
842        assert_eq!(person.name, "Bob");
843        assert_eq!(person.address.city, "New York");
844    }
845
846    #[test]
847    fn test_deserialize_optional() {
848        #[derive(Debug, Deserialize, PartialEq)]
849        struct Config {
850            name: String,
851            #[serde(default)]
852            value: Option<String>,
853        }
854
855        let xml1 = "<Config><name>test</name><value>val</value></Config>";
856        let config1: Config = from_str(xml1).unwrap();
857        assert_eq!(config1.value, Some("val".to_string()));
858
859        let xml2 = "<Config><name>test</name></Config>";
860        let config2: Config = from_str(xml2).unwrap();
861        assert_eq!(config2.value, None);
862    }
863
864    #[test]
865    fn test_deserialize_bool() {
866        #[derive(Debug, Deserialize, PartialEq)]
867        struct Flags {
868            enabled: bool,
869            active: bool,
870        }
871
872        let xml = "<Flags><enabled>true</enabled><active>false</active></Flags>";
873        let flags: Flags = from_str(xml).unwrap();
874        assert!(flags.enabled);
875        assert!(!flags.active);
876    }
877
878    #[test]
879    fn test_deserialize_numbers() {
880        #[derive(Debug, Deserialize, PartialEq)]
881        struct Numbers {
882            i: i32,
883            u: u64,
884            f: f64,
885        }
886
887        let xml = "<Numbers><i>-42</i><u>100</u><f>1.234</f></Numbers>";
888        let nums: Numbers = from_str(xml).unwrap();
889        assert_eq!(nums.i, -42);
890        assert_eq!(nums.u, 100);
891        assert!((nums.f - 1.234).abs() < 0.001);
892    }
893
894    #[test]
895    fn test_deserialize_vector() {
896        #[derive(Debug, Deserialize, PartialEq)]
897        struct Items {
898            item: Vec<String>,
899        }
900
901        let xml = r#"<Items><item>one</item><item>two</item><item>three</item></Items>"#;
902        let items: Items = from_str(xml).unwrap();
903        assert_eq!(items.item, vec!["one", "two", "three"]);
904    }
905
906    #[test]
907    fn test_deserialize_escaped_content() {
908        #[derive(Debug, Deserialize, PartialEq)]
909        struct Data {
910            content: String,
911        }
912
913        let xml = "<Data><content>&lt;hello&gt; &amp; &quot;world&quot;</content></Data>";
914        let data: Data = from_str(xml).unwrap();
915        assert_eq!(data.content, "<hello> & \"world\"");
916    }
917
918    #[test]
919    fn test_deserialize_empty_element() {
920        #[derive(Debug, Deserialize, PartialEq)]
921        struct Empty {
922            #[serde(default)]
923            value: String,
924        }
925
926        let xml = "<Empty><value></value></Empty>";
927        let empty: Empty = from_str(xml).unwrap();
928        assert_eq!(empty.value, "");
929    }
930
931    #[test]
932    fn test_deserialize_char() {
933        #[derive(Debug, Deserialize, PartialEq)]
934        struct Data {
935            c: char,
936        }
937
938        let xml = "<Data><c>A</c></Data>";
939        let data: Data = from_str(xml).unwrap();
940        assert_eq!(data.c, 'A');
941    }
942
943    #[test]
944    fn test_deserialize_unit_struct() {
945        #[derive(Debug, Deserialize, PartialEq)]
946        struct Unit;
947
948        let xml = "<Unit/>";
949        let _unit: Unit = from_str(xml).unwrap();
950    }
951
952    #[test]
953    fn test_from_bytes() {
954        #[derive(Debug, Deserialize, PartialEq)]
955        struct Data {
956            value: String,
957        }
958
959        let bytes = b"<Data><value>test</value></Data>";
960        let data: Data = from_bytes(bytes).unwrap();
961        assert_eq!(data.value, "test");
962    }
963
964    #[test]
965    fn test_deserialize_vector_of_structs() {
966        #[derive(Debug, Deserialize, PartialEq)]
967        struct Item {
968            name: String,
969            count: u32,
970        }
971
972        #[derive(Debug, Deserialize, PartialEq)]
973        struct Items {
974            item: Vec<Item>,
975        }
976
977        let xml = r#"<Items><item><name>A</name><count>1</count></item><item><name>B</name><count>2</count></item></Items>"#;
978        let items: Items = from_str(xml).unwrap();
979        assert_eq!(items.item.len(), 2);
980        assert_eq!(items.item[0].name, "A");
981        assert_eq!(items.item[1].name, "B");
982    }
983
984    #[test]
985    fn test_deserialize_multiple_attributes() {
986        #[derive(Debug, Deserialize, PartialEq)]
987        struct Element {
988            #[serde(rename = "@id")]
989            id: String,
990            #[serde(rename = "@class")]
991            class: String,
992            name: String,
993        }
994
995        let xml = r#"<Element id="main" class="container"><name>Test</name></Element>"#;
996        let elem: Element = from_str(xml).unwrap();
997        assert_eq!(elem.id, "main");
998        assert_eq!(elem.class, "container");
999        assert_eq!(elem.name, "Test");
1000    }
1001
1002    #[test]
1003    fn test_deserialize_attributes_with_special_chars() {
1004        #[derive(Debug, Deserialize, PartialEq)]
1005        struct Element {
1006            #[serde(rename = "@title")]
1007            title: String,
1008        }
1009
1010        let xml = r#"<Element title="Hello &amp; &quot;World&quot;"/>"#;
1011        let elem: Element = from_str(xml).unwrap();
1012        assert_eq!(elem.title, "Hello & \"World\"");
1013    }
1014
1015    #[test]
1016    fn test_deserialize_numeric_attributes() {
1017        #[derive(Debug, Deserialize, PartialEq)]
1018        struct Item {
1019            #[serde(rename = "@id")]
1020            id: u32,
1021            #[serde(rename = "@count")]
1022            count: i32,
1023            #[serde(rename = "@price")]
1024            price: f64,
1025            #[serde(rename = "@active")]
1026            active: bool,
1027        }
1028
1029        let xml = r#"<Item id="42" count="-10" price="19.99" active="true"/>"#;
1030        let item: Item = from_str(xml).unwrap();
1031        assert_eq!(item.id, 42);
1032        assert_eq!(item.count, -10);
1033        assert!((item.price - 19.99).abs() < 0.001);
1034        assert!(item.active);
1035    }
1036
1037    #[test]
1038    fn test_deserialize_empty_element_with_attributes() {
1039        #[derive(Debug, Deserialize, PartialEq)]
1040        struct Empty {
1041            #[serde(rename = "@id")]
1042            id: String,
1043            #[serde(default)]
1044            value: String,
1045        }
1046
1047        let xml = r#"<Empty id="test"/>"#;
1048        let elem: Empty = from_str(xml).unwrap();
1049        assert_eq!(elem.id, "test");
1050        assert_eq!(elem.value, "");
1051    }
1052
1053    #[test]
1054    fn test_deserialize_nested_with_attributes() {
1055        #[derive(Debug, Deserialize, PartialEq)]
1056        struct Child {
1057            #[serde(rename = "@name")]
1058            name: String,
1059        }
1060
1061        #[derive(Debug, Deserialize, PartialEq)]
1062        struct Parent {
1063            #[serde(rename = "@id")]
1064            id: String,
1065            child: Child,
1066        }
1067
1068        let xml = r#"<Parent id="p1"><child name="c1"/></Parent>"#;
1069        let parent: Parent = from_str(xml).unwrap();
1070        assert_eq!(parent.id, "p1");
1071        assert_eq!(parent.child.name, "c1");
1072    }
1073
1074    #[test]
1075    fn test_deserialize_vector_with_attributes() {
1076        #[derive(Debug, Deserialize, PartialEq)]
1077        struct Item {
1078            #[serde(rename = "@id")]
1079            id: u32,
1080            name: String,
1081        }
1082
1083        #[derive(Debug, Deserialize, PartialEq)]
1084        struct List {
1085            #[serde(rename = "@version")]
1086            version: String,
1087            item: Vec<Item>,
1088        }
1089
1090        let xml = r#"<List version="1.0"><item id="1"><name>A</name></item><item id="2"><name>B</name></item></List>"#;
1091        let list: List = from_str(xml).unwrap();
1092        assert_eq!(list.version, "1.0");
1093        assert_eq!(list.item.len(), 2);
1094        assert_eq!(list.item[0].id, 1);
1095        assert_eq!(list.item[1].id, 2);
1096    }
1097}
serde_xml/de.rs

serde_xml/
de.rs
