Replace BytesText::from_escaped_str by BytesText::from_escaped

Replace `BytesText::from_plain_str` by `BytesText::new`

Author: Mingun

Changelog.md

@@ -147,7 +147,7 @@
 
 - [#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
+  but since now escaping works on strings. Use `BytesText::new` instead
 
 - [#428]: Removed `BytesText::escaped()`. Use `.as_ref()` provided by `Deref` impl instead.
 - [#428]: Removed `BytesText::from_escaped()`. Use constructors from strings instead,
@@ -168,6 +168,10 @@
   |`BytesStart::borrowed(&[u8], usize)`              |_(as above)_
   |`BytesEnd::owned(Vec<u8>)`                        |`BytesEnd::new(impl Into<Cow<str>>)`
   |`BytesEnd::borrowed(&[u8])`                       |_(as above)_
+  |`BytesText::from_escaped(impl Into<Cow<[u8]>>)`   |`BytesText::from_escaped(impl Into<Cow<str>>)`
+  |`BytesText::from_escaped_str(impl Into<Cow<str>>)`|_(as above)_
+  |`BytesText::from_plain(&[u8])`                    |`BytesText::new(&str)`
+  |`BytesText::from_plain_str(&str)`                 |_(as above)_
   |`BytesCData::new(impl Into<Cow<[u8]>>)`           |`BytesCData::new(impl Into<Cow<str>>)`
   |`BytesCData::from_str(&str)`                      |_(as above)_
 

src/de/mod.rs

@@ -1051,7 +1051,7 @@ mod tests {
                 de.write,
                 vec![
                     Start(BytesStart::new("inner")),
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     Start(BytesStart::new("inner")),
                     End(BytesEnd::new("inner")),
                     End(BytesEnd::new("inner")),
@@ -1085,7 +1085,7 @@ mod tests {
                 de.read,
                 vec![
                     Start(BytesStart::new("inner")),
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     Start(BytesStart::new("inner")),
                     End(BytesEnd::new("inner")),
                     End(BytesEnd::new("inner")),
@@ -1109,7 +1109,7 @@ mod tests {
                 vec![
                     // This comment here to keep the same formatting of both arrays
                     // otherwise rustfmt suggest one-line it
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                 ]
             );
 
@@ -1129,15 +1129,12 @@ mod tests {
             assert_eq!(
                 de.read,
                 vec![
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     End(BytesEnd::new("inner")),
                 ]
             );
             assert_eq!(de.write, vec![]);
-            assert_eq!(
-                de.next().unwrap(),
-                Text(BytesText::from_escaped_str("text"))
-            );
+            assert_eq!(de.next().unwrap(), Text(BytesText::from_escaped("text")));
             assert_eq!(de.next().unwrap(), End(BytesEnd::new("inner")));
             assert_eq!(de.next().unwrap(), Start(BytesStart::new("target")));
             assert_eq!(de.next().unwrap(), End(BytesEnd::new("target")));
@@ -1174,7 +1171,7 @@ mod tests {
                 de.write,
                 vec![
                     Start(BytesStart::new("skip")),
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     Start(BytesStart::new("skip")),
                     End(BytesEnd::new("skip")),
                     End(BytesEnd::new("skip")),
@@ -1195,7 +1192,7 @@ mod tests {
                 de.write,
                 vec![
                     Start(BytesStart::new("skip")),
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     Start(BytesStart::new("skip")),
                     End(BytesEnd::new("skip")),
                     End(BytesEnd::new("skip")),
@@ -1217,7 +1214,7 @@ mod tests {
                 de.read,
                 vec![
                     Start(BytesStart::new("skip")),
-                    Text(BytesText::from_escaped_str("text")),
+                    Text(BytesText::from_escaped("text")),
                     Start(BytesStart::new("skip")),
                     End(BytesEnd::new("skip")),
                     End(BytesEnd::new("skip")),
@@ -1368,7 +1365,7 @@ mod tests {
                     r#"item name="hello" source="world.rs""#,
                     4
                 )),
-                Text(BytesText::from_escaped_str("Some text")),
+                Text(BytesText::from_escaped("Some text")),
                 End(BytesEnd::new("item")),
                 Start(BytesStart::from_content("item2", 5)),
                 End(BytesEnd::new("item2")),

src/events/mod.rs

@@ -683,27 +683,15 @@ impl<'a> BytesText<'a> {
 
     /// Creates a new `BytesText` from an escaped string.
     #[inline]
-    pub fn from_escaped_str<C: Into<Cow<'a, str>>>(content: C) -> Self {
-        Self::wrap(
-            match content.into() {
-                Cow::Owned(o) => Cow::Owned(o.into_bytes()),
-                Cow::Borrowed(b) => Cow::Borrowed(b.as_bytes()),
-            },
-            Decoder::utf8(),
-        )
+    pub fn from_escaped<C: Into<Cow<'a, str>>>(content: C) -> Self {
+        Self::wrap(str_cow_to_bytes(content), Decoder::utf8())
     }
 
     /// Creates a new `BytesText` from a string. The string is expected not to
     /// be escaped.
     #[inline]
-    pub fn from_plain_str(content: &'a str) -> Self {
-        Self {
-            content: match escape(content) {
-                Cow::Borrowed(s) => Cow::Borrowed(s.as_bytes()),
-                Cow::Owned(s) => Cow::Owned(s.into_bytes()),
-            },
-            decoder: Decoder::utf8(),
-        }
+    pub fn new(content: &'a str) -> Self {
+        Self::from_escaped(escape(content))
     }
 
     /// Ensures that all data is owned to extend the object's lifetime if

src/reader/mod.rs

@@ -1844,7 +1844,7 @@ mod test {
 
                     assert_eq!(
                         reader.read_event_impl($buf).unwrap(),
-                        Event::StartText(BytesText::from_escaped_str("bom").into())
+                        Event::StartText(BytesText::from_escaped("bom").into())
                     );
                 }
 
@@ -1864,7 +1864,7 @@ mod test {
 
                     assert_eq!(
                         reader.read_event_impl($buf).unwrap(),
-                        Event::DocType(BytesText::from_escaped_str("x"))
+                        Event::DocType(BytesText::from_escaped("x"))
                     );
                 }
 
@@ -1874,7 +1874,7 @@ mod test {
 
                     assert_eq!(
                         reader.read_event_impl($buf).unwrap(),
-                        Event::PI(BytesText::from_escaped_str("xml-stylesheet"))
+                        Event::PI(BytesText::from_escaped("xml-stylesheet"))
                     );
                 }
 
@@ -1923,7 +1923,7 @@ mod test {
 
                     assert_eq!(
                         reader.read_event_impl($buf).unwrap(),
-                        Event::Text(BytesText::from_escaped_str("text"))
+                        Event::Text(BytesText::from_escaped("text"))
                     );
                 }
 
@@ -1943,7 +1943,7 @@ mod test {
 
                     assert_eq!(
                         reader.read_event_impl($buf).unwrap(),
-                        Event::Comment(BytesText::from_escaped_str(""))
+                        Event::Comment(BytesText::from_escaped(""))
                     );
                 }
 

src/se/mod.rs

@@ -102,9 +102,9 @@ impl<'r, W: Write> Serializer<'r, W> {
     ) -> Result<(), DeError> {
         let value = value.to_string();
         let event = if escaped {
-            BytesText::from_escaped_str(&value)
+            BytesText::from_escaped(&value)
         } else {
-            BytesText::from_plain_str(&value)
+            BytesText::new(&value)
         };
         self.writer.write_event(Event::Text(event))?;
         Ok(())

src/writer.rs

@@ -193,7 +193,7 @@ impl<W: Write> Writer<W> {
     /// // writes <tag attr1="value1" attr2="value2">with some text inside</tag>
     /// writer.create_element("tag")
     ///     .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter())  // or add attributes from an iterator
-    ///     .write_text_content(BytesText::from_plain_str("with some text inside"))?;
+    ///     .write_text_content(BytesText::new("with some text inside"))?;
     ///
     /// // writes <tag><fruit quantity="0">apple</fruit><fruit quantity="1">orange</fruit></tag>
     /// writer.create_element("tag")
@@ -203,7 +203,7 @@ impl<W: Write> Writer<W> {
     ///             writer
     ///                 .create_element("fruit")
     ///                 .with_attribute(("quantity", quant.to_string().as_str()))
-    ///                 .write_text_content(BytesText::from_plain_str(item))?;
+    ///                 .write_text_content(BytesText::new(item))?;
     ///         }
     ///         Ok(())
     ///     })?;
@@ -417,7 +417,7 @@ mod indentation {
         let start = BytesStart::new("paired")
             .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
         let end = start.to_end();
-        let text = BytesText::from_plain_str("text");
+        let text = BytesText::new("text");
 
         writer
             .write_event(Event::Start(start.clone()))
@@ -443,7 +443,7 @@ mod indentation {
         let start = BytesStart::new("paired")
             .with_attributes(vec![("attr1", "value1"), ("attr2", "value2")].into_iter());
         let end = start.to_end();
-        let text = BytesText::from_plain_str("text");
+        let text = BytesText::new("text");
         let inner = BytesStart::new("inner");
 
         writer
@@ -528,7 +528,7 @@ mod indentation {
             .create_element("paired")
             .with_attribute(("attr1", "value1"))
             .with_attribute(("attr2", "value2"))
-            .write_text_content(BytesText::from_plain_str("text"))
+            .write_text_content(BytesText::new("text"))
             .expect("failure");
 
         assert_eq!(
@@ -552,7 +552,7 @@ mod indentation {
                     writer
                         .create_element("fruit")
                         .with_attribute(("quantity", quant.to_string().as_str()))
-                        .write_text_content(BytesText::from_plain_str(item))?;
+                        .write_text_content(BytesText::new(item))?;
                 }
                 writer
                     .create_element("inner")

tests/unit_tests.rs

@@ -596,9 +596,7 @@ fn test_read_write_roundtrip_escape_text() -> Result<()> {
             Eof => break,
             Text(e) => {
                 let t = e.unescape().unwrap();
-                assert!(writer
-                    .write_event(Text(BytesText::from_plain_str(&t)))
-                    .is_ok());
+                assert!(writer.write_event(Text(BytesText::new(&t))).is_ok());
             }
             e => assert!(writer.write_event(e).is_ok()),
         }