Remove the ability to use SliceReader with raw bytes.

In the near future, decoding will be performed automatically as the
input is read. If the input has an unknown encoding, it must be decoded
first, necessitating a buffer. Therefore only the buffered
implementation can be used for `Reader::from_bytes()`

If the encoding of the bytes is known up-front, you can decode them
up-front and subsequently use `Reader::from_str()` if desired.

Author: dralley

Changelog.md

@@ -138,8 +138,12 @@
 - [#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
 - [#425]: Split the internal implementation of `Reader` into multiple files to better separate the
-  buffered and unbuffered implementations. The buffered methods, e.g. `read_event_into(&mut buf)`,
+  buffered and unbuffered implementations. The unbuffered methods, e.g. `read_event()`,
   will no longer be available when reading from a slice.
+- [#436]: When using `Reader` with raw bytes, a buffered parsing implementation will always be used.
+  If using `Reader::from_str()`, the reader will borrow directly from the `&str`. If you have a byte
+  array known to be valid UTF-8, it is recommended to convert it to `&str` first, which will enable
+  the unbuffered (borrowing) implementation.
 
 ### New Tests
 
@@ -171,6 +175,7 @@
 [#421]: https://github.com/tafia/quick-xml/pull/421
 [#423]: https://github.com/tafia/quick-xml/pull/423
 [#425]: https://github.com/tafia/quick-xml/pull/425
+[#436]: https://github.com/tafia/quick-xml/pull/430
 
 ## 0.23.0 -- 2022-05-08
 

src/de/mod.rs

@@ -306,8 +306,8 @@ where
 }
 
 /// Deserialize from a reader. This method will do internal copies of data
-/// readed from `reader`. If you want have a `&[u8]` or `&str` input and want
-/// to borrow as much as possible, use [`from_slice`] or [`from_str`]
+/// readed from `reader`. If you want have a `&str` input and want
+/// to borrow as much as possible, use [`from_str`]
 pub fn from_reader<R, T>(reader: R) -> Result<T, DeError>
 where
     R: BufRead,
@@ -685,17 +685,7 @@ where
 impl<'de> Deserializer<'de, SliceReader<'de>> {
     /// Create new deserializer that will borrow data from the specified string
     pub fn from_str(s: &'de str) -> Self {
-        Self::from_borrowing_reader(Reader::from_str(s))
-    }
-
-    /// Create new deserializer that will borrow data from the specified byte array
-    pub fn from_slice(bytes: &'de [u8]) -> Self {
-        Self::from_borrowing_reader(Reader::from_bytes(bytes))
-    }
-
-    /// Create new deserializer that will borrow data from the specified borrowing reader
-    #[inline]
-    fn from_borrowing_reader(mut reader: Reader<crate::SliceReader<'de>>) -> Self {
+        let mut reader = Reader::from_str(s);
         reader
             .expand_empty_elements(true)
             .check_end_names(true)
@@ -726,6 +716,13 @@ where
     }
 }
 
+impl<'de> Deserializer<'de, IoReader<&'de [u8]>> {
+    /// Create new deserializer that will borrow data from the specified byte array
+    pub fn from_slice(bytes: &'de [u8]) -> Self {
+        Self::from_reader(bytes)
+    }
+}
+
 impl<'de, 'a, R> de::Deserializer<'de> for &'a mut Deserializer<'de, R>
 where
     R: XmlRead<'de>,
@@ -970,10 +967,10 @@ impl<'i, R: BufRead> XmlRead<'i> for IoReader<R> {
     }
 }
 
-/// XML input source that reads from a slice of bytes and can borrow from it.
+/// XML input source that reads from a `&str` and can borrow from it.
 ///
 /// You cannot create it, it is created automatically when you call
-/// [`Deserializer::from_str`] or [`Deserializer::from_slice`]
+/// [`Deserializer::from_str`] or [`Deserializer::from_str`]
 pub struct SliceReader<'de> {
     reader: Reader<crate::SliceReader<'de>>,
 }
@@ -1025,8 +1022,8 @@ mod tests {
         /// Checks that `peek()` and `read()` behaves correctly after `skip()`
         #[test]
         fn read_and_peek() {
-            let mut de = Deserializer::from_slice(
-                br#"
+            let mut de = Deserializer::from_str(
+                r#"
                 <root>
                     <inner>
                         text
@@ -1166,8 +1163,8 @@ mod tests {
         /// Checks that `read_to_end()` behaves correctly after `skip()`
         #[test]
         fn read_to_end() {
-            let mut de = Deserializer::from_slice(
-                br#"
+            let mut de = Deserializer::from_str(
+                r#"
                 <root>
                     <skip>
                         text
@@ -1270,8 +1267,8 @@ mod tests {
                 item: Vec<()>,
             }
 
-            let mut de = Deserializer::from_slice(
-                br#"
+            let mut de = Deserializer::from_str(
+                r#"
                 <any-name>
                     <item/>
                     <another-item>
@@ -1296,8 +1293,8 @@ mod tests {
     fn read_to_end() {
         use crate::de::DeEvent::*;
 
-        let mut de = Deserializer::from_slice(
-            br#"
+        let mut de = Deserializer::from_str(
+            r#"
             <root>
                 <tag a="1"><tag>text</tag>content</tag>
                 <tag a="2"><![CDATA[cdata content]]></tag>
@@ -1343,15 +1340,14 @@ mod tests {
             <item name="hello" source="world.rs">Some text</item>
             <item2/>
             <item3 value="world" />
-    	"##
-        .as_bytes();
+    	"##;
 
         let mut reader1 = IoReader {
-            reader: Reader::from_reader(s),
+            reader: Reader::from_reader(s.as_bytes()),
             buf: Vec::new(),
         };
         let mut reader2 = SliceReader {
-            reader: Reader::from_bytes(s),
+            reader: Reader::from_str(s),
         };
 
         loop {
@@ -1373,11 +1369,10 @@ mod tests {
             <item2></item2>
             <item3/>
             <item4 value="world" />
-        "##
-        .as_bytes();
+        "##;
 
         let mut reader = SliceReader {
-            reader: Reader::from_bytes(s),
+            reader: Reader::from_str(s),
         };
 
         reader

src/events/mod.rs

@@ -983,8 +983,9 @@ pub enum Event<'a> {
     /// let xml = b"\xEF\xBB\xBF<?xml version='1.0'?>";
     /// let mut reader = Reader::from_bytes(xml);
     /// let mut events_processed = 0;
+    /// let mut event_buffer = Vec::new();
     /// loop {
-    ///     match reader.read_event() {
+    ///     match reader.read_event_into(&mut event_buffer) {
     ///         Ok(Event::StartText(e)) => {
     ///             assert_eq!(events_processed, 0);
     ///             // Content contains BOM

src/reader/buffered_reader.rs

@@ -406,6 +406,14 @@ impl Reader<BufferedReader<BufReader<File>>> {
     }
 }
 
+/// Builder for reading from any [`&[u8]`].
+impl<'buf> Reader<BufferedReader<&'buf [u8]>> {
+    /// Creates an XML reader from any type implementing [`BufRead`].
+    pub fn from_bytes(s: &'buf [u8]) -> Self {
+        Self::from_reader_internal(BufferedReader(s))
+    }
+}
+
 /// Builder for reading from any [`BufRead`].
 impl<R: BufRead> Reader<BufferedReader<R>> {
     /// Creates an XML reader from any type implementing [`BufRead`].
@@ -652,17 +660,63 @@ mod test {
     use super::*;
     use crate::reader::test::check;
 
-    fn input_from_bytes(bytes: &[u8]) -> BufferedReader<&[u8]> {
-        BufferedReader(bytes)
+    fn input_from_str(s: &str) -> BufferedReader<&[u8]> {
+        BufferedReader(s.as_bytes())
     }
 
     fn reader_from_str(s: &str) -> Reader<BufferedReader<&[u8]>> {
         Reader::from_reader_internal(BufferedReader(s.as_bytes()))
     }
 
     #[allow(dead_code)]
-    fn reader_from_bytes(s: &[u8]) -> Reader<BufferedReader<&[u8]>> {
-        Reader::from_reader_internal(BufferedReader(s))
+    fn reader_from_bytes(bytes: &[u8]) -> Reader<BufferedReader<&[u8]>> {
+        Reader::from_reader_internal(BufferedReader(bytes))
+    }
+
+    #[cfg(feature = "encoding")]
+    mod encoding {
+        use super::reader_from_bytes;
+        use crate::events::Event;
+        use encoding_rs::{UTF_16LE, UTF_8, WINDOWS_1251};
+
+        mod bytes {
+            use super::reader_from_bytes;
+            use super::*;
+            use pretty_assertions::assert_eq;
+
+            /// Checks that encoding is detected by BOM and changed after XML declaration
+            #[test]
+            fn bom_detected() {
+                let mut reader = reader_from_bytes(b"\xFF\xFE<?xml encoding='windows-1251'?>");
+                let mut buf = Vec::new();
+
+                assert_eq!(reader.decoder().encoding(), UTF_8);
+                reader.read_event_impl(&mut buf).unwrap();
+                assert_eq!(reader.decoder().encoding(), UTF_16LE);
+
+                reader.read_event_impl(&mut buf).unwrap();
+                assert_eq!(reader.decoder().encoding(), WINDOWS_1251);
+
+                assert_eq!(reader.read_event_impl(&mut buf).unwrap(), Event::Eof);
+            }
+
+            /// Checks that encoding is changed by XML declaration, but only once
+            #[test]
+            fn xml_declaration() {
+                let mut reader =
+                    reader_from_bytes(b"<?xml encoding='UTF-16'?><?xml encoding='windows-1251'?>");
+                let mut buf = Vec::new();
+
+                assert_eq!(reader.decoder().encoding(), UTF_8);
+                reader.read_event_impl(&mut buf).unwrap();
+                assert_eq!(reader.decoder().encoding(), UTF_16LE);
+
+                reader.read_event_impl(&mut buf).unwrap();
+                assert_eq!(reader.decoder().encoding(), UTF_16LE);
+
+                assert_eq!(reader.read_event_impl(&mut buf).unwrap(), Event::Eof);
+            }
+        }
     }
 
     check!(let mut buf = Vec::new(););