fix(quick-xml): Fix bug in sub-access of attributes in elements. (#123)

Author: lukasfri

xmlity-quick-xml/src/de.rs

@@ -623,7 +623,7 @@ impl<'de> de::AttributesAccess<'de> for SubAttributesAccess<'_, 'de> {
             deserializer: self.deserializer,
             bytes_start: self.bytes_start,
             attribute_index: self.attribute_index,
-            write_attribute_to: self.write_attribute_to,
+            write_attribute_to: &mut self.attribute_index,
         })
     }
 }

xmlity-quick-xml/tests/elements/any_attributes.rs

@@ -0,0 +1,119 @@
+use xmlity::{
+    de::DeserializationGroupBuilder,
+    value::{XmlAttribute, XmlText},
+    DeserializationGroup, Deserialize, ExpandedName, LocalName, SerializationGroup, Serialize,
+};
+
+use crate::define_test;
+
+#[derive(Debug, PartialEq)]
+pub struct AnyAttributes {
+    /// The attributes of the element.
+    pub attributes: Vec<XmlAttribute>,
+}
+
+impl<'de> DeserializationGroupBuilder<'de> for AnyAttributes {
+    type Value = Self;
+
+    fn contribute_attributes<D: xmlity::de::AttributesAccess<'de>>(
+        &mut self,
+        mut access: D,
+    ) -> Result<bool, D::Error> {
+        if let Ok(Some(attr)) = access.next_attribute::<XmlAttribute>() {
+            self.attributes.push(attr);
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn attributes_done(&self) -> bool {
+        false
+    }
+
+    fn finish<E: xmlity::de::Error>(self) -> Result<Self::Value, E> {
+        Ok(self)
+    }
+}
+
+impl<'de> DeserializationGroup<'de> for AnyAttributes {
+    type Builder = Self;
+
+    fn builder() -> Self::Builder {
+        Self {
+            attributes: Vec::new(),
+        }
+    }
+}
+
+impl SerializationGroup for AnyAttributes {
+    fn serialize_attributes<S: xmlity::ser::SerializeAttributes>(
+        &self,
+        serializer: &mut S,
+    ) -> Result<(), S::Error> {
+        self.attributes
+            .iter()
+            .try_for_each(|attr| serializer.serialize_attribute(attr).map(|_| ()))
+    }
+
+    fn serialize_children<S: xmlity::ser::SerializeSeq>(
+        &self,
+        serializer: &mut S,
+    ) -> Result<(), S::Error> {
+        let _ = serializer;
+
+        Ok(())
+    }
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[xelement(name = "a")]
+pub struct A {
+    #[xgroup]
+    any_attributes: AnyAttributes,
+}
+
+define_test!(
+    any_attributes_element,
+    [(
+        A {
+            any_attributes: AnyAttributes {
+                attributes: vec![XmlAttribute::new(
+                    ExpandedName::new(LocalName::new_dangerous("test"), None),
+                    XmlText::new("testVal")
+                )],
+            }
+        },
+        r###"<a test="testVal"/>"###
+    )]
+);
+
+#[derive(Debug, PartialEq, SerializationGroup, DeserializationGroup)]
+pub struct B {
+    #[xgroup]
+    any_attributes: AnyAttributes,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[xelement(name = "a")]
+pub struct C {
+    #[xgroup]
+    b: B,
+}
+
+define_test!(
+    any_attributes_element_in_group,
+    [(
+        C {
+            b: B {
+                any_attributes: AnyAttributes {
+                    attributes: vec![XmlAttribute::new(
+                        ExpandedName::new(LocalName::new_dangerous("test"), None),
+                        XmlText::new("testVal")
+                    )],
+                }
+            }
+        },
+        r###"<a test="testVal"/>"###
+    )]
+);

xmlity-quick-xml/tests/elements/mod.rs

@@ -1,9 +1,12 @@
 pub mod allow_unknown;
+pub mod any_attributes;
 pub mod attribute;
+pub mod attribute_namespace;
 pub mod basic;
 pub mod default;
 pub mod extendable;
 pub mod generics;
+pub mod group_element_equivalent;
 pub mod ignore_comments;
 pub mod ignore_whitespace;
 pub mod inline_attribute_declarations;
@@ -16,6 +19,3 @@ pub mod option;
 pub mod single_namespace;
 pub mod skip_serializing_if;
 pub mod strict_order;
-
-pub mod attribute_namespace;
-pub mod group_element_equivalent;