Change read_to_end* and read_text to accept QName instead of AsRef<[u8]>

AsRef is too unsafe because you accidentally could pass wrong parameters

Also fixes using incorrect encoding if `read_to_end` family of methods or `read_text`
method would not find a corresponding end tag and the reader has a non-UTF-8 encoding

Author: Mingun

Changelog.md

@@ -38,6 +38,8 @@
   returns `ResolveResult::Unknown` if prefix was not registered in namespace buffer
 - [#393]: Fix breaking processing after encounter an attribute with a reserved name (started with "xmlns")
 - [#363]: Do not generate empty `Event::Text` events
+- [#412]: Fix using incorrect encoding if `read_to_end` family of methods or `read_text`
+  method not found a corresponding end tag and reader has non-UTF-8 encoding
 
 ### Misc Changes
 
@@ -104,6 +106,7 @@
   |`read_text`              |`read_text_into`
   |`read_event_unbuffered`  |`read_event`
   |`read_to_end_unbuffered` |`read_to_end`
+- [#412]: Change `read_to_end*` and `read_text_into` to accept `QName` instead of `AsRef<[u8]>`
 
 ### New Tests
 

examples/read_texts.rs

@@ -1,5 +1,6 @@
 fn main() {
     use quick_xml::events::Event;
+    use quick_xml::name::QName;
     use quick_xml::Reader;
 
     let xml = "<tag1>text1</tag1><tag1>text2</tag1>\
@@ -16,7 +17,7 @@ fn main() {
             Ok(Event::Start(ref e)) if e.name().as_ref() == b"tag2" => {
                 txt.push(
                     reader
-                        .read_text_into(b"tag2", &mut Vec::new())
+                        .read_text_into(QName(b"tag2"), &mut Vec::new())
                         .expect("Cannot decode text value"),
                 );
                 println!("{:?}", txt);

src/reader.rs

@@ -610,21 +610,22 @@ impl<R: BufRead> Reader<R> {
     /// Reads until end element is found
     ///
     /// Manages nested cases where parent and child elements have the same name
-    pub fn read_to_end_into<K: AsRef<[u8]>>(&mut self, end: K, buf: &mut Vec<u8>) -> Result<()> {
+    pub fn read_to_end_into(&mut self, end: QName, buf: &mut Vec<u8>) -> Result<()> {
         let mut depth = 0;
-        let end = end.as_ref();
         loop {
             match self.read_event_into(buf) {
-                Ok(Event::End(ref e)) if e.name().as_ref() == end => {
+                Err(e) => return Err(e),
+
+                Ok(Event::Start(e)) if e.name() == end => depth += 1,
+                Ok(Event::End(e)) if e.name() == end => {
                     if depth == 0 {
                         return Ok(());
                     }
                     depth -= 1;
                 }
-                Ok(Event::Start(ref e)) if e.name().as_ref() == end => depth += 1,
-                Err(e) => return Err(e),
                 Ok(Event::Eof) => {
-                    return Err(Error::UnexpectedEof(format!("</{:?}>", from_utf8(end))));
+                    let name = self.decoder().decode(end.as_ref());
+                    return Err(Error::UnexpectedEof(format!("</{:?}>", name)));
                 }
                 _ => (),
             }
@@ -665,13 +666,14 @@ impl<R: BufRead> Reader<R> {
     /// }
     /// ```
     ///
-    /// [`Text`]: events/enum.Event.html#variant.Text
-    /// [`End`]: events/enum.Event.html#variant.End
-    pub fn read_text_into<K: AsRef<[u8]>>(&mut self, end: K, buf: &mut Vec<u8>) -> Result<String> {
+    /// [`Text`]: Event::Text
+    /// [`End`]: Event::End
+    pub fn read_text_into(&mut self, end: QName, buf: &mut Vec<u8>) -> Result<String> {
         let s = match self.read_event_into(buf) {
-            Ok(Event::Text(e)) => e.unescape_and_decode(self),
-            Ok(Event::End(ref e)) if e.name().as_ref() == end.as_ref() => return Ok("".to_string()),
             Err(e) => return Err(e),
+
+            Ok(Event::Text(e)) => e.unescape_and_decode(self),
+            Ok(Event::End(e)) if e.name() == end => return Ok("".to_string()),
             Ok(Event::Eof) => return Err(Error::UnexpectedEof("Text".to_string())),
             _ => return Err(Error::TextNotFound),
         };
@@ -975,21 +977,22 @@ impl<'a> Reader<&'a [u8]> {
     /// Reads until end element is found
     ///
     /// Manages nested cases where parent and child elements have the same name
-    pub fn read_to_end<K: AsRef<[u8]>>(&mut self, end: K) -> Result<()> {
+    pub fn read_to_end(&mut self, end: QName) -> Result<()> {
         let mut depth = 0;
-        let end = end.as_ref();
         loop {
             match self.read_event() {
-                Ok(Event::End(ref e)) if e.name().as_ref() == end => {
+                Err(e) => return Err(e),
+
+                Ok(Event::Start(e)) if e.name() == end => depth += 1,
+                Ok(Event::End(e)) if e.name() == end => {
                     if depth == 0 {
                         return Ok(());
                     }
                     depth -= 1;
                 }
-                Ok(Event::Start(ref e)) if e.name().as_ref() == end => depth += 1,
-                Err(e) => return Err(e),
                 Ok(Event::Eof) => {
-                    return Err(Error::UnexpectedEof(format!("</{:?}>", from_utf8(end))));
+                    let name = self.decoder().decode(end.as_ref());
+                    return Err(Error::UnexpectedEof(format!("</{:?}>", name)));
                 }
                 _ => (),
             }