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.
+- [#430]: 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
+[#430]: https://github.com/tafia/quick-xml/pull/430
 
 ## 0.23.0 -- 2022-05-08
 

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,17 @@ 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))
     }
 
     check!(let mut buf = Vec::new(););

src/reader/mod.rs

@@ -132,11 +132,6 @@ impl<'buf> Reader<SliceReader<'buf>> {
 
         reader
     }
-
-    /// Creates an XML reader from a slice of bytes.
-    pub fn from_bytes(s: &'buf [u8]) -> Self {
-        Self::from_reader_internal(SliceReader(s))
-    }
 }
 
 /// Public reading methods for a [`Reader`] based on an [`SliceReader`].
@@ -473,18 +468,13 @@ mod test {
     use super::*;
     use crate::reader::test::check;
 
-    fn input_from_bytes<'buf>(bytes: &'buf [u8]) -> SliceReader<'buf> {
-        SliceReader(bytes)
+    fn input_from_str<'buf>(s: &'buf str) -> SliceReader<'buf> {
+        SliceReader(s.as_bytes())
     }
 
     fn reader_from_str<'buf>(s: &'buf str) -> Reader<SliceReader<'buf>> {
         Reader::from_str(s)
     }
 
-    #[allow(dead_code)]
-    fn reader_from_bytes<'buf>(s: &'buf [u8]) -> Reader<SliceReader<'buf>> {
-        Reader::from_bytes(s)
-    }
-
     check!();
 }

src/reader/slice_reader.rs

@@ -138,9 +138,9 @@ fn default_namespace_reset() {
 /// The code path for namespace handling is slightly different for `Empty` vs. `Start+End`.
 #[test]
 fn attributes_empty_ns() {
-    let src = b"<a att1='a' r:att2='b' xmlns:r='urn:example:r' />";
+    let src = "<a att1='a' r:att2='b' xmlns:r='urn:example:r' />";
 
-    let mut r = Reader::from_bytes(src);
+    let mut r = Reader::from_str(src);
     r.trim_text(true).expand_empty_elements(false);
     let mut ns_buf = Vec::new();
 
@@ -178,9 +178,9 @@ fn attributes_empty_ns() {
 /// The code path for namespace handling is slightly different for `Empty` vs. `Start+End`.
 #[test]
 fn attributes_empty_ns_expanded() {
-    let src = b"<a att1='a' r:att2='b' xmlns:r='urn:example:r' />";
+    let src = "<a att1='a' r:att2='b' xmlns:r='urn:example:r' />";
 
-    let mut r = Reader::from_bytes(src);
+    let mut r = Reader::from_str(src);
     r.trim_text(true).expand_empty_elements(true);
     let mut ns_buf = Vec::new();
     {
@@ -221,9 +221,9 @@ fn attributes_empty_ns_expanded() {
 
 #[test]
 fn default_ns_shadowing_empty() {
-    let src = b"<e xmlns='urn:example:o'><e att1='a' xmlns='urn:example:i' /></e>";
+    let src = "<e xmlns='urn:example:o'><e att1='a' xmlns='urn:example:i' /></e>";
 
-    let mut r = Reader::from_bytes(src);
+    let mut r = Reader::from_str(src);
     r.trim_text(true).expand_empty_elements(false);
     let mut ns_buf = Vec::new();
 
@@ -279,9 +279,9 @@ fn default_ns_shadowing_empty() {
 
 #[test]
 fn default_ns_shadowing_expanded() {
-    let src = b"<e xmlns='urn:example:o'><e att1='a' xmlns='urn:example:i' /></e>";
+    let src = "<e xmlns='urn:example:o'><e att1='a' xmlns='urn:example:i' /></e>";
 
-    let mut r = Reader::from_bytes(src);
+    let mut r = Reader::from_str(src);
     r.trim_text(true).expand_empty_elements(true);
     let mut ns_buf = Vec::new();
 

tests/namespaces.rs

@@ -9,8 +9,8 @@ use pretty_assertions::assert_eq;
 
 #[test]
 fn test_sample() {
-    let src: &[u8] = include_bytes!("documents/sample_rss.xml");
-    let mut r = Reader::from_bytes(src);
+    let src: &str = include_str!("documents/sample_rss.xml");
+    let mut r = Reader::from_str(src);
     let mut count = 0;
     loop {
         match r.read_event().unwrap() {
@@ -25,8 +25,8 @@ fn test_sample() {
 
 #[test]
 fn test_attributes_empty() {
-    let src = b"<a att1='a' att2='b'/>";
-    let mut r = Reader::from_bytes(src);
+    let src = "<a att1='a' att2='b'/>";
+    let mut r = Reader::from_str(src);
     r.trim_text(true).expand_empty_elements(false);
     match r.read_event() {
         Ok(Empty(e)) => {

tests/test.rs

@@ -369,10 +369,11 @@ fn test_bytes(input: &[u8], output: &[u8], trim: bool) {
         .expand_empty_elements(false);
 
     let mut spec_lines = SpecIter(output).enumerate();
+    let mut event_buffer = Vec::new();
     let mut ns_buffer = Vec::new();
 
     loop {
-        let event = reader.read_namespaced_event(&mut ns_buffer);
+        let event = reader.read_namespaced_event_into(&mut event_buffer, &mut ns_buffer);
         let line = xmlrs_display(event, reader.decoder());
         if let Some((n, spec)) = spec_lines.next() {
             if spec.trim() == "EndDocument" {