Return &str instead of &[u8] in escape functions

Author: Mingun

Changelog.md

@@ -134,7 +134,7 @@
   scheme, for example, HEX or Base64
 - [#421]: All unescaping functions now accepts and returns strings instead of byte slices
 
-- [#423]: All escaping functions now accepts strings instead of byte slices
+- [#423]: All escaping functions now accepts and returns strings instead of byte slices
 - [#423]: Removed `BytesText::from_plain` because it internally did escaping of a byte array,
   but since now escaping works on strings. Use `BytesText::from_plain_str` instead
 

src/escapei.rs

@@ -71,7 +71,7 @@ impl std::error::Error for EscapeError {}
 /// | `&`       | `&`
 /// | `'`       | `'`
 /// | `"`       | `"`
-pub fn escape(raw: &str) -> Cow<[u8]> {
+pub fn escape(raw: &str) -> Cow<str> {
     _escape(raw, |ch| matches!(ch, b'<' | b'>' | b'&' | b'\'' | b'\"'))
 }
 
@@ -88,25 +88,25 @@ pub fn escape(raw: &str) -> Cow<[u8]> {
 /// | `<`       | `&lt;`
 /// | `>`       | `&gt;`
 /// | `&`       | `&amp;`
-pub fn partial_escape(raw: &str) -> Cow<[u8]> {
+pub fn partial_escape(raw: &str) -> Cow<str> {
     _escape(raw, |ch| matches!(ch, b'<' | b'>' | b'&'))
 }
 
 /// Escapes an `&str` and replaces a subset of xml special characters (`<`, `>`,
 /// `&`, `'`, `"`) with their corresponding xml escaped value.
-fn _escape<F: Fn(u8) -> bool>(raw: &str, escape_chars: F) -> Cow<[u8]> {
-    let raw = raw.as_bytes();
+fn _escape<F: Fn(u8) -> bool>(raw: &str, escape_chars: F) -> Cow<str> {
+    let bytes = raw.as_bytes();
     let mut escaped = None;
-    let mut bytes = raw.iter();
+    let mut iter = bytes.iter();
     let mut pos = 0;
-    while let Some(i) = bytes.position(|&b| escape_chars(b)) {
+    while let Some(i) = iter.position(|&b| escape_chars(b)) {
         if escaped.is_none() {
             escaped = Some(Vec::with_capacity(raw.len()));
         }
         let escaped = escaped.as_mut().expect("initialized");
         let new_pos = pos + i;
-        escaped.extend_from_slice(&raw[pos..new_pos]);
-        match raw[new_pos] {
+        escaped.extend_from_slice(&bytes[pos..new_pos]);
+        match bytes[new_pos] {
             b'<' => escaped.extend_from_slice(b"&lt;"),
             b'>' => escaped.extend_from_slice(b"&gt;"),
             b'\'' => escaped.extend_from_slice(b"&apos;"),
@@ -118,10 +118,14 @@ fn _escape<F: Fn(u8) -> bool>(raw: &str, escape_chars: F) -> Cow<[u8]> {
     }
 
     if let Some(mut escaped) = escaped {
-        if let Some(raw) = raw.get(pos..) {
+        if let Some(raw) = bytes.get(pos..) {
             escaped.extend_from_slice(raw);
         }
-        Cow::Owned(escaped)
+        // SAFETY: we operate on UTF-8 input and search for an one byte chars only,
+        // so all slices that was put to the `escaped` is a valid UTF-8 encoded strings
+        // TODO: Can be replaced with `unsafe { String::from_utf8_unchecked() }`
+        // if unsafe code will be allowed
+        Cow::Owned(String::from_utf8(escaped).unwrap())
     } else {
         Cow::Borrowed(raw)
     }
@@ -1745,24 +1749,24 @@ fn test_unescape_with() {
 
 #[test]
 fn test_escape() {
-    assert_eq!(&*escape("test"), b"test");
-    assert_eq!(&*escape("<test>"), b"&lt;test&gt;");
-    assert_eq!(&*escape("\"a\"bc"), b"&quot;a&quot;bc");
-    assert_eq!(&*escape("\"a\"b&c"), b"&quot;a&quot;b&amp;c");
+    assert_eq!(&*escape("test"), "test");
+    assert_eq!(&*escape("<test>"), "&lt;test&gt;");
+    assert_eq!(&*escape("\"a\"bc"), "&quot;a&quot;bc");
+    assert_eq!(&*escape("\"a\"b&c"), "&quot;a&quot;b&amp;c");
     assert_eq!(
         &*escape("prefix_\"a\"b&<>c"),
-        "prefix_&quot;a&quot;b&amp;&lt;&gt;c".as_bytes()
+        "prefix_&quot;a&quot;b&amp;&lt;&gt;c"
     );
 }
 
 #[test]
 fn test_partial_escape() {
-    assert_eq!(&*partial_escape("test"), b"test");
-    assert_eq!(&*partial_escape("<test>"), b"&lt;test&gt;");
-    assert_eq!(&*partial_escape("\"a\"bc"), b"\"a\"bc");
-    assert_eq!(&*partial_escape("\"a\"b&c"), b"\"a\"b&amp;c");
+    assert_eq!(&*partial_escape("test"), "test");
+    assert_eq!(&*partial_escape("<test>"), "&lt;test&gt;");
+    assert_eq!(&*partial_escape("\"a\"bc"), "\"a\"bc");
+    assert_eq!(&*partial_escape("\"a\"b&c"), "\"a\"b&amp;c");
     assert_eq!(
         &*partial_escape("prefix_\"a\"b&<>c"),
-        "prefix_\"a\"b&amp;&lt;&gt;c".as_bytes()
+        "prefix_\"a\"b&amp;&lt;&gt;c"
     );
 }

src/events/attributes.rs

@@ -143,7 +143,10 @@ impl<'a> From<(&'a str, &'a str)> for Attribute<'a> {
     fn from(val: (&'a str, &'a str)) -> Attribute<'a> {
         Attribute {
             key: QName(val.0.as_bytes()),
-            value: escape(val.1),
+            value: match escape(val.1) {
+                Cow::Borrowed(s) => Cow::Borrowed(s.as_bytes()),
+                Cow::Owned(s) => Cow::Owned(s.into_bytes()),
+            },
         }
     }
 }

src/events/mod.rs

@@ -695,7 +695,10 @@ impl<'a> BytesText<'a> {
     #[inline]
     pub fn from_plain_str(content: &'a str) -> Self {
         Self {
-            content: escape(content),
+            content: match escape(content) {
+                Cow::Borrowed(s) => Cow::Borrowed(s.as_bytes()),
+                Cow::Owned(s) => Cow::Owned(s.into_bytes()),
+            },
         }
     }
 
@@ -897,8 +900,9 @@ impl<'a> BytesCData<'a> {
     pub fn escape(self, decoder: Decoder) -> Result<BytesText<'a>> {
         let decoded = self.decode(decoder)?;
         Ok(BytesText::from_escaped(match escape(&decoded) {
+            // Because result is borrowed, no replacements was done and we can use original content
             Cow::Borrowed(_) => self.content,
-            Cow::Owned(escaped) => Cow::Owned(escaped),
+            Cow::Owned(escaped) => Cow::Owned(escaped.into_bytes()),
         }))
     }
 
@@ -918,8 +922,9 @@ impl<'a> BytesCData<'a> {
     pub fn partial_escape(self, decoder: Decoder) -> Result<BytesText<'a>> {
         let decoded = self.decode(decoder)?;
         Ok(BytesText::from_escaped(match partial_escape(&decoded) {
+            // Because result is borrowed, no replacements was done and we can use original content
             Cow::Borrowed(_) => self.content,
-            Cow::Owned(escaped) => Cow::Owned(escaped),
+            Cow::Owned(escaped) => Cow::Owned(escaped.into_bytes()),
         }))
     }