Position tracking: add span to BytesStart

Author: Themayu

src/events/mod.rs

@@ -48,6 +48,7 @@ use crate::encoding::Decoder;
 use crate::errors::{Error, Result};
 use crate::escape::{escape, partial_escape, unescape_with};
 use crate::name::{LocalName, QName};
+use crate::reader::Span;
 use crate::utils::write_cow_string;
 use attributes::{Attribute, Attributes};
 
@@ -67,15 +68,18 @@ pub struct BytesStart<'a> {
     pub(crate) buf: Cow<'a, [u8]>,
     /// end of the element name, the name starts at that the start of `buf`
     pub(crate) name_len: usize,
+    /// the position of the element in the input, this does not reflect updates to the struct
+    pub(crate) span: Span,
 }
 
 impl<'a> BytesStart<'a> {
     /// Internal constructor, used by `Reader`. Supplies data in reader's encoding
     #[inline]
-    pub(crate) fn wrap(content: &'a [u8], name_len: usize) -> Self {
+    pub(crate) fn wrap(content: &'a [u8], name_len: usize, span: Span) -> Self {
         BytesStart {
             buf: Cow::Borrowed(content),
             name_len,
+            span,
         }
     }
 
@@ -89,6 +93,7 @@ impl<'a> BytesStart<'a> {
         let buf = str_cow_to_bytes(name);
         BytesStart {
             name_len: buf.len(),
+            span: 0..buf.len(),
             buf,
         }
     }
@@ -102,8 +107,11 @@ impl<'a> BytesStart<'a> {
     /// to generate invalid XML if `content` or `name_len` are incorrect.
     #[inline]
     pub fn from_content<C: Into<Cow<'a, str>>>(content: C, name_len: usize) -> Self {
+        let buf = str_cow_to_bytes(content);
+
         BytesStart {
-            buf: str_cow_to_bytes(content),
+            span: 0..buf.len(),
+            buf,
             name_len,
         }
     }
@@ -113,6 +121,7 @@ impl<'a> BytesStart<'a> {
         BytesStart {
             buf: Cow::Owned(self.buf.into_owned()),
             name_len: self.name_len,
+            span: self.span,
         }
     }
 
@@ -121,6 +130,7 @@ impl<'a> BytesStart<'a> {
         BytesStart {
             buf: Cow::Owned(self.buf.to_owned().into()),
             name_len: self.name_len,
+            span: self.span(),
         }
     }
 
@@ -153,6 +163,7 @@ impl<'a> BytesStart<'a> {
         BytesStart {
             buf: Cow::Borrowed(&self.buf),
             name_len: self.name_len,
+            span: self.span(),
         }
     }
 
@@ -176,6 +187,17 @@ impl<'a> BytesStart<'a> {
         self.name().into()
     }
 
+    /// Gets the range of bytes this element spans in the input stream.
+    ///
+    /// This does not reflect updates to the struct. I.e. if [`set_name`] is called, this will not
+    /// update the span, as the underlying source is not altered by this operation.
+    ///
+    /// [`set_name`]: Self::set_name
+    #[inline]
+    pub fn span(&self) -> Span {
+        self.span.clone()
+    }
+
     /// Edit the name of the BytesStart in-place
     ///
     /// # Warning
@@ -273,7 +295,7 @@ impl<'a> Debug for BytesStart<'a> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
         write!(f, "BytesStart {{ buf: ")?;
         write_cow_string(f, &self.buf)?;
-        write!(f, ", name_len: {} }}", self.name_len)
+        write!(f, ", name_len: {}, span: {:?} }}", self.name_len, self.span)
     }
 }
 

src/reader/mod.rs

@@ -213,6 +213,9 @@ macro_rules! read_until_close {
     ) => {{
         $self.parser.state = ParseState::ClosedTag;
 
+        // save the current offset of the parser to use later
+        let position = $self.parser.offset;
+
         match $reader.peek_one() $(.$await)? {
             // `<!` - comment, CDATA or DOCTYPE declaration
             Ok(Some(b'!')) => match $reader
@@ -238,7 +241,7 @@ macro_rules! read_until_close {
                 $(.$await)?
             {
                 Ok(None) => Ok(Event::Eof),
-                Ok(Some(bytes)) => $self.parser.read_question_mark(bytes),
+                Ok(Some(bytes)) => $self.parser.read_question_mark(bytes, position),
                 Err(e) => Err(e),
             },
             // `<...` - opening or self-closed tag
@@ -247,7 +250,7 @@ macro_rules! read_until_close {
                 $(.$await)?
             {
                 Ok(None) => Ok(Event::Eof),
-                Ok(Some(bytes)) => $self.parser.read_start(bytes),
+                Ok(Some(bytes)) => $self.parser.read_start(bytes, position),
                 Err(e) => Err(e),
             },
             Ok(None) => Ok(Event::Eof),

src/reader/parser.rs

@@ -180,11 +180,13 @@ impl Parser {
 
     /// reads `BytesElement` starting with a `?`,
     /// return `Decl` or `PI` event
-    pub fn read_question_mark<'b>(&mut self, buf: &'b [u8]) -> Result<Event<'b>> {
+    pub fn read_question_mark<'b>(&mut self, buf: &'b [u8], position: usize) -> Result<Event<'b>> {
         let len = buf.len();
+        let end = position + len;
         if len > 2 && buf[len - 1] == b'?' {
             if len > 5 && &buf[1..4] == b"xml" && is_whitespace(buf[4]) {
-                let event = BytesDecl::from_start(BytesStart::wrap(&buf[1..len - 1], 3));
+                let event =
+                    BytesDecl::from_start(BytesStart::wrap(&buf[1..len - 1], 3, position..end));
 
                 // Try getting encoding from the declaration event
                 #[cfg(feature = "encoding")]
@@ -206,27 +208,36 @@ impl Parser {
 
     /// reads `BytesElement` starting with any character except `/`, `!` or ``?`
     /// return `Start` or `Empty` event
-    pub fn read_start<'b>(&mut self, buf: &'b [u8]) -> Result<Event<'b>> {
+    pub fn read_start<'b>(&mut self, buf: &'b [u8], position: usize) -> Result<Event<'b>> {
         // TODO: do this directly when reading bufreader ...
         let len = buf.len();
+        let end = position + len;
         let name_end = buf.iter().position(|&b| is_whitespace(b)).unwrap_or(len);
         if let Some(&b'/') = buf.last() {
             let end = if name_end < len { name_end } else { len - 1 };
             if self.expand_empty_elements {
                 self.state = ParseState::Empty;
                 self.opened_starts.push(self.opened_buffer.len());
                 self.opened_buffer.extend(&buf[..end]);
-                Ok(Event::Start(BytesStart::wrap(&buf[..len - 1], end)))
+                Ok(Event::Start(BytesStart::wrap(
+                    &buf[..len - 1],
+                    end,
+                    position..end,
+                )))
             } else {
-                Ok(Event::Empty(BytesStart::wrap(&buf[..len - 1], end)))
+                Ok(Event::Empty(BytesStart::wrap(
+                    &buf[..len - 1],
+                    end,
+                    position..end,
+                )))
             }
         } else {
             // #514: Always store names event when .check_end_names == false,
             // because checks can be temporary disabled and when they would be
             // enabled, we should have that information
             self.opened_starts.push(self.opened_buffer.len());
             self.opened_buffer.extend(&buf[..name_end]);
-            Ok(Event::Start(BytesStart::wrap(buf, name_end)))
+            Ok(Event::Start(BytesStart::wrap(buf, name_end, position..end)))
         }
     }