Add support for serializing as CDATA

instant-xml/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "instant-xml"
-version = "0.6.1"
+version = "0.6.2"
 edition = "2021"
 rust-version = "1.68"
 workspace = ".."

instant-xml/src/impls.rs

@@ -873,6 +873,49 @@ impl<'xml> FromXml<'xml> for IpAddr {
     const KIND: Kind = Kind::Scalar;
 }
 
+#[derive(Debug, PartialEq, Eq)]
+pub struct CData<T>(pub T);
+
+impl<'xml, T: FromXml<'xml>> FromXml<'xml> for CData<T> {
+    fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool {
+        T::matches(id, field)
+    }
+
+    fn deserialize<'cx>(
+        into: &mut Self::Accumulator,
+        field: &'static str,
+        deserializer: &mut Deserializer<'cx, 'xml>,
+    ) -> Result<(), Error> {
+        if into.is_some() {
+            return Err(Error::DuplicateValue(field));
+        }
+
+        let mut accumulator = T::Accumulator::default();
+        T::deserialize(&mut accumulator, field, deserializer)?;
+        *into = Some(CData(accumulator.try_done(field)?));
+        Ok(())
+    }
+
+    type Accumulator = Option<CData<T>>;
+    const KIND: Kind = Kind::Scalar;
+}
+
+impl<T: fmt::Display> ToXml for CData<T> {
+    fn serialize<W: fmt::Write + ?Sized>(
+        &self,
+        field: Option<Id<'_>>,
+        serializer: &mut Serializer<W>,
+    ) -> Result<(), Error> {
+        DisplayToXml(self).serialize(field, serializer)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for CData<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<![CDATA[{}]]>", self.0)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

instant-xml/src/lib.rs

@@ -288,7 +288,7 @@ pub mod de;
 mod impls;
 use de::Context;
 pub use de::Deserializer;
-pub use impls::{display_to_xml, from_xml_str, OptionAccumulator};
+pub use impls::{display_to_xml, from_xml_str, CData, OptionAccumulator};
 #[doc(hidden)]
 pub mod ser;
 pub use ser::Serializer;

instant-xml/tests/escaping.rs

@@ -2,7 +2,7 @@ use std::borrow::Cow;
 
 use similar_asserts::assert_eq;
 
-use instant_xml::{from_str, to_string, FromXml, ToXml};
+use instant_xml::{from_str, to_string, CData, FromXml, ToXml};
 
 #[derive(Debug, PartialEq, Eq, FromXml, ToXml)]
 #[xml(ns("URI"))]
@@ -80,3 +80,30 @@ fn simple_cdata() {
         "<SimpleCData><foo>&lt;foo&gt;</foo></SimpleCData>",
     );
 }
+
+#[derive(Debug, PartialEq, Eq, FromXml, ToXml)]
+struct SerializeCData<'a> {
+    #[xml(borrow)]
+    foo: CData<Cow<'a, str>>,
+}
+
+#[test]
+fn serialize_cdata() {
+    assert_eq!(
+        from_str::<SerializeCData>(
+            "<SerializeCData><foo><![CDATA[<fo&amp;o>]]></foo></SerializeCData>"
+        )
+        .unwrap(),
+        SerializeCData {
+            foo: CData(Cow::Borrowed("<fo&amp;o>")),
+        }
+    );
+
+    assert_eq!(
+        to_string(&SerializeCData {
+            foo: CData(Cow::Borrowed("<foo>")),
+        })
+        .unwrap(),
+        "<SerializeCData><foo><![CDATA[<foo>]]></foo></SerializeCData>",
+    );
+}