Implement serializing CDATA in SimpleTypeSerializer

Author: Ninja3047

src/se/simple_type.rs

@@ -5,6 +5,7 @@
 
 use crate::escape::escape_char;
 use crate::se::{QuoteLevel, SeError};
+use crate::utils::CDataIterator;
 use serde::ser::{
     Impossible, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
     SerializeTupleVariant, Serializer,
@@ -20,6 +21,9 @@ pub enum QuoteTarget {
     DoubleQAttr,
     /// Escape data for a single-quoted attribute. `'` always escaped
     SingleQAttr,
+    /// Escape data for a CDATA content. No escaping for `&` and `>`, but split
+    /// content on `]]>` and make several CDATA sections
+    CData,
 }
 
 fn escape_into<W, F>(mut writer: W, value: &str, escape_chars: F) -> fmt::Result
@@ -44,14 +48,25 @@ where
 
 /// Escapes atomic value that could be part of a `xs:list`. All whitespace characters
 /// additionally escaped
-fn escape_item<W>(writer: W, value: &str, target: QuoteTarget, level: QuoteLevel) -> fmt::Result
+fn escape_item<W>(mut writer: W, value: &str, target: QuoteTarget, level: QuoteLevel) -> fmt::Result
 where
     W: Write,
 {
     use QuoteLevel::*;
     use QuoteTarget::*;
 
     match (target, level) {
+        (CData, _) => {
+            let mut it = CDataIterator::new(value);
+            if let Some(part) = it.next() {
+                writer.write_str(part)?;
+            }
+            while let Some(part) = it.next() {
+                writer.write_str("]]><![CDATA[")?;
+                writer.write_str(part)?;
+            }
+            Ok(())
+        }
         (_, Full) => escape_into(writer, value, |ch| match ch {
             // Spaces used as delimiters of list items, cannot be used in the item
             b' ' | b'\r' | b'\n' | b'\t' => true,
@@ -116,14 +131,22 @@ where
 }
 
 /// Escapes XSD simple type value
-fn escape_list<W>(writer: W, value: &str, target: QuoteTarget, level: QuoteLevel) -> fmt::Result
+fn escape_list<W>(mut writer: W, value: &str, target: QuoteTarget, level: QuoteLevel) -> fmt::Result
 where
     W: Write,
 {
     use QuoteLevel::*;
     use QuoteTarget::*;
 
     match (target, level) {
+        (CData, _) => {
+            for part in CDataIterator::new(value) {
+                writer.write_str("<![CDATA[")?;
+                writer.write_str(part)?;
+                writer.write_str("]]>")?;
+            }
+            Ok(())
+        }
         (_, Full) => escape_into(writer, value, |ch| match ch {
             // Required characters to escape
             b'&' | b'<' | b'>' | b'\'' | b'\"' => true,
@@ -488,7 +511,10 @@ impl<W: Write> Serializer for SimpleTypeSerializer<W> {
     }
 
     #[inline]
-    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+    fn serialize_seq(mut self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        if let QuoteTarget::CData = self.target {
+            self.writer.write_str("<![CDATA[")?;
+        }
         Ok(SimpleSeq {
             writer: self.writer,
             target: self.target,
@@ -585,7 +611,10 @@ impl<W: Write> SerializeSeq for SimpleSeq<W> {
     }
 
     #[inline]
-    fn end(self) -> Result<Self::Ok, Self::Error> {
+    fn end(mut self) -> Result<Self::Ok, Self::Error> {
+        if let QuoteTarget::CData = self.target {
+            self.writer.write_str("]]>")?;
+        }
         Ok(self.writer)
     }
 }
@@ -683,6 +712,7 @@ mod tests {
 
     mod escape_item {
         use super::*;
+        use pretty_assertions::assert_eq;
 
         fn escape_item(value: &str, target: QuoteTarget, level: QuoteLevel) -> String {
             let mut result = String::new();
@@ -808,10 +838,40 @@ mod tests {
                 );
             }
         }
+
+        /// Escape function does not surround text with `<![CDATA[` and `]]>`, that should be done outside
+        #[test]
+        fn cdata() {
+            assert_eq!(
+                escape_item(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Full
+                ),
+                "text<\"'&>]]]]><![CDATA[> \t\n\rtext"
+            );
+            assert_eq!(
+                escape_item(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Partial
+                ),
+                "text<\"'&>]]]]><![CDATA[> \t\n\rtext"
+            );
+            assert_eq!(
+                escape_item(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Minimal
+                ),
+                "text<\"'&>]]]]><![CDATA[> \t\n\rtext"
+            );
+        }
     }
 
     mod escape_list {
         use super::*;
+        use pretty_assertions::assert_eq;
 
         fn escape_list(value: &str, target: QuoteTarget, level: QuoteLevel) -> String {
             let mut result = String::new();
@@ -937,6 +997,34 @@ mod tests {
                 );
             }
         }
+
+        #[test]
+        fn cdata() {
+            assert_eq!(
+                escape_list(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Full
+                ),
+                "<![CDATA[text<\"'&>]]]]><![CDATA[> \t\n\rtext]]>"
+            );
+            assert_eq!(
+                escape_list(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Partial
+                ),
+                "<![CDATA[text<\"'&>]]]]><![CDATA[> \t\n\rtext]]>"
+            );
+            assert_eq!(
+                escape_list(
+                    "text<\"'&>]]> \t\n\rtext",
+                    QuoteTarget::CData,
+                    QuoteLevel::Minimal
+                ),
+                "<![CDATA[text<\"'&>]]]]><![CDATA[> \t\n\rtext]]>"
+            );
+        }
     }
 
     /// Tests for serialize atomic and union values, as defined in XSD specification
@@ -1261,4 +1349,44 @@ mod tests {
             assert_eq!(buffer, "1 2 3");
         }
     }
+
+    mod cdata {
+        use super::*;
+        use pretty_assertions::assert_eq;
+
+        macro_rules! serialize_as_cdata {
+            ($name:ident: $data:expr => $expected:literal) => {
+                #[test]
+                fn $name() {
+                    let ser = SimpleTypeSerializer {
+                        writer: String::new(),
+                        target: QuoteTarget::CData,
+                        level: QuoteLevel::Full,
+                    };
+
+                    let buffer = $data.serialize(ser).unwrap();
+                    assert_eq!(buffer, $expected);
+                }
+            };
+        }
+
+        serialize_as_cdata!(empty_string: "" => "");
+        serialize_as_cdata!(simple_text: "Hello World" => "<![CDATA[Hello World]]>");
+        serialize_as_cdata!(with_markup: "<tag>content</tag>" => "<![CDATA[<tag>content</tag>]]>");
+        serialize_as_cdata!(with_ampersand: "Tom & Jerry" => "<![CDATA[Tom & Jerry]]>");
+        serialize_as_cdata!(with_quotes: r#"He said "Hello""# => r#"<![CDATA[He said "Hello"]]>"#);
+        serialize_as_cdata!(all_xml_chars: "<>&\"'" => "<![CDATA[<>&\"']]>");
+
+        serialize_as_cdata!(with_cdata_end: "foo]]>bar" => "<![CDATA[foo]]]]><![CDATA[>bar]]>");
+        serialize_as_cdata!(multiple_cdata_ends: "a]]>b]]>c" => "<![CDATA[a]]]]><![CDATA[>b]]]]><![CDATA[>c]]>");
+        serialize_as_cdata!(starts_with_cdata_end: "]]>hello" => "<![CDATA[]]]]><![CDATA[>hello]]>");
+        serialize_as_cdata!(ends_with_cdata_end: "hello]]>" => "<![CDATA[hello]]]]><![CDATA[>]]>");
+        serialize_as_cdata!(only_cdata_end: "]]>" => "<![CDATA[]]]]><![CDATA[>]]>");
+
+        serialize_as_cdata!(seq_basic: vec!["foo", "bar", "baz"] => "<![CDATA[foo bar baz]]>");
+        serialize_as_cdata!(seq_with_space: vec!["hello world", "hello\tworld", "world"] => "<![CDATA[hello world hello\tworld world]]>");
+        serialize_as_cdata!(seq_with_markup_chars: vec!["<tag>", "&entity", "\"quoted\""] => "<![CDATA[<tag> &entity \"quoted\"]]>");
+        serialize_as_cdata!(seq_with_cdata_end_split: vec!["foo]]>bar", "test"] => "<![CDATA[foo]]]]><![CDATA[>bar test]]>");
+        serialize_as_cdata!(tuple_cdata: ("first", 42, "third") => "<![CDATA[first 42 third]]>");
+    }
 }