Merge tag '0.8.19'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "xml-rs"
-version = "0.8.18"
+version = "0.8.19"
 authors = ["Vladimir Matveev <vmatveev@citrine.cc>"]
 license = "MIT"
 description = "An XML library in pure Rust"

examples/print_events.rs

@@ -1,7 +1,7 @@
 use std::fs::File;
 use std::io::BufReader;
 use xml::common::Position;
-use xml::reader::*;
+use xml::reader::{ParserConfig, XmlEvent};
 
 fn main() {
  let file_path = std::env::args_os().nth(1).expect("Please specify a path to an XML file");

examples/rewrite.rs

@@ -0,0 +1,68 @@
+//! See <https://lib.rs/crates/svg-hush> for a real-world example.
+
+use xml::EmitterConfig;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::Path;
+use xml::reader::{ParserConfig, Result};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+ let arg = std::env::args_os().nth(1);
+ let file_path = Path::new(arg.as_deref().unwrap_or("tests/documents/sample_1.xml".as_ref()));
+ let file = BufReader::new(File::open(file_path)
+ .map_err(|e| format!("Can't open {}: {e}", file_path.display()))?);
+
+ let mut reader = ParserConfig::default()
+ .ignore_root_level_whitespace(true)
+ .ignore_comments(false)
+ .cdata_to_characters(true)
+ .coalesce_characters(true)
+ .create_reader(file);
+
+ let stdout = std::io::stdout().lock();
+
+ let mut writer = EmitterConfig::default()
+ .create_writer(stdout);
+
+ loop {
+ let reader_event = reader.next()?;
+
+ match reader_event {
+ xml::reader::XmlEvent::EndDocument => break,
+ xml::reader::XmlEvent::StartElement { name, mut attributes, namespace } => {
+ let event = xml::writer::XmlEvent::StartElement {
+ name: name.borrow(),
+ namespace: namespace.borrow(),
+ attributes: attributes.iter_mut().map(|attr| {
+ attr.value = alternating_caps(&attr.value);
+ attr.borrow()
+ }).collect(),
+ };
+ writer.write(event)?;
+ },
+ xml::reader::XmlEvent::Characters(text) => {
+ let text = alternating_caps(&text);
+ let event = xml::writer::XmlEvent::Characters(&text);
+ writer.write(event)?;
+ },
+ xml::reader::XmlEvent::Comment(text) => {
+ let text = alternating_caps(&text);
+ let event = xml::writer::XmlEvent::Comment(&text);
+ writer.write(event)?;
+ },
+ other => {
+ if let Some(writer_event) = other.as_writer_event() {
+ writer.write(writer_event)?;
+ }
+ }
+ }
+
+ }
+ Ok(())
+}
+
+fn alternating_caps(text: &str) -> String {
+ text.chars().enumerate()
+ .map(|(i, ch)| if i&1==0 { ch.to_ascii_uppercase() } else { ch.to_ascii_lowercase() })
+ .collect()
+}

src/attribute.rs

@@ -3,7 +3,7 @@
 
 use std::fmt;
 
-use crate::escape::{Escaped, AttributeEscapes};
+use crate::escape::{AttributeEscapes, Escaped};
 use crate::name::{Name, OwnedName};
 
 /// A borrowed version of an XML attribute.

src/common.rs

@@ -112,15 +112,15 @@ pub fn is_whitespace_str(s: &str) -> bool {
  s.chars().all(is_whitespace_char)
 }
 
-pub fn is_xml10_char(c: char) -> bool {
+#[must_use] pub fn is_xml10_char(c: char) -> bool {
  matches!(c, '\u{09}' | '\u{0A}' | '\u{0D}' | '\u{20}'..='\u{D7FF}' | '\u{E000}'..='\u{FFFD}' | '\u{10000}'..)
 }
 
-pub fn is_xml11_char(c: char) -> bool {
+#[must_use] pub fn is_xml11_char(c: char) -> bool {
  matches!(c, '\u{01}'..='\u{D7FF}' | '\u{E000}'..='\u{FFFD}' | '\u{10000}'..)
 }
 
-pub fn is_xml11_char_not_restricted(c: char) -> bool {
+#[must_use] pub fn is_xml11_char_not_restricted(c: char) -> bool {
  is_xml11_char(c) && !matches!(c, '\u{01}'..='\u{08}' | '\u{0B}'..='\u{0C}' | '\u{0E}'..='\u{1F}' | '\u{7F}'..='\u{84}' | '\u{86}'..='\u{9F}')
 }
 

src/escape.rs

@@ -5,11 +5,11 @@ use std::{borrow::Cow, marker::PhantomData, fmt::{Display, Result, Formatter}};
 pub(crate) trait Escapes {
  fn escape(c: u8) -> Option<&'static str>;
 
- fn byte_needs_escaping(c: u8) -> bool{
+ fn byte_needs_escaping(c: u8) -> bool {
  Self::escape(c).is_some()
  }
 
- fn str_needs_escaping(s: &str) -> bool{
+ fn str_needs_escaping(s: &str) -> bool {
  s.bytes().any(|c| Self::escape(c).is_some())
  }
 }
@@ -22,13 +22,12 @@ pub(crate) struct Escaped<'a, E: Escapes> {
 impl<'a, E: Escapes> Escaped<'a, E> {
  pub fn new(s: &'a str) -> Self {
  Escaped {
- _escape_phantom: PhantomData, 
+ _escape_phantom: PhantomData,
  to_escape: s,
  }
  }
 }
 
-
 impl<'a, E: Escapes> Display for Escaped<'a, E> {
  fn fmt(&self, f: &mut Formatter<'_>) -> Result {
  let mut total_remaining = self.to_escape;
@@ -49,7 +48,7 @@ impl<'a, E: Escapes> Display for Escaped<'a, E> {
 
  total_remaining = &remaining[1..];
  }
- 
+
  f.write_str(total_remaining)
  }
 }
@@ -107,7 +106,7 @@ escapes!(
 /// * `"` → `&quot;`
 /// * `'` → `&apos;`
 /// * `&` → `&amp;`
-/// 
+///
 /// The following characters are escaped so that attributes are printed on
 /// a single line:
 /// * `\n` → `&#xA;`
@@ -117,7 +116,8 @@ escapes!(
 ///
 /// Does not perform allocations if the given string does not contain escapable characters.
 #[inline]
-#[must_use] pub fn escape_str_attribute(s: &str) -> Cow<'_, str> {
+#[must_use]
+pub fn escape_str_attribute(s: &str) -> Cow<'_, str> {
  escape_str::<AttributeEscapes>(s)
 }
 
@@ -133,7 +133,8 @@ escapes!(
 ///
 /// Does not perform allocations if the given string does not contain escapable characters.
 #[inline]
-#[must_use] pub fn escape_str_pcdata(s: &str) -> Cow<'_, str> {
+#[must_use]
+pub fn escape_str_pcdata(s: &str) -> Cow<'_, str> {
  escape_str::<PcDataEscapes>(s)
 }
 

src/macros.rs

@@ -19,7 +19,7 @@ macro_rules! gen_setter {
  ///
  /// <small>See [`ParserConfig`][crate::ParserConfig] fields docs for details</small>
  #[inline]
- pub fn $field(mut self, value: $t) -> Self {
+ #[must_use] pub fn $field(mut self, value: $t) -> Self {
  self.$field = value;
  self
  }
@@ -29,7 +29,7 @@ macro_rules! gen_setter {
  ///
  /// <small>See [`ParserConfig`][crate::ParserConfig] fields docs for details</small>
  #[inline]
- pub fn $field(mut self, value: $t) -> Self {
+ #[must_use] pub fn $field(mut self, value: $t) -> Self {
  self.c.$field = value;
  self
  }

src/namespace.rs

@@ -1,5 +1,6 @@
 //! Contains namespace manipulation types and functions.
 
+use std::borrow::Cow;
 use std::collections::btree_map::Iter as Entries;
 use std::collections::btree_map::{BTreeMap, Entry};
 use std::collections::HashSet;
@@ -165,6 +166,12 @@ impl Namespace {
  pub fn get<'a, P: ?Sized + AsRef<str>>(&'a self, prefix: &P) -> Option<&'a str> {
  self.0.get(prefix.as_ref()).map(|s| &**s)
  }
+
+ /// Borrowed namespace for the writer
+ #[must_use]
+ pub fn borrow(&self) -> Cow<'_, Self> {
+ Cow::Borrowed(self)
+ }
 }
 
 /// An alias for iterator type for namespace mappings contained in a namespace.

src/reader/events.rs

@@ -1,8 +1,6 @@
 //! Contains `XmlEvent` datatype, instances of which are emitted by the parser.
 
-use std::borrow::Cow;
 use std::fmt;
-
 use crate::attribute::OwnedAttribute;
 use crate::common::XmlVersion;
 use crate::name::OwnedName;
@@ -207,7 +205,7 @@ impl XmlEvent {
  Some(crate::writer::events::XmlEvent::StartElement {
  name: name.borrow(),
  attributes: attributes.iter().map(|a| a.borrow()).collect(),
- namespace: Cow::Borrowed(namespace)
+ namespace: namespace.borrow(),
  }),
  XmlEvent::EndElement { ref name } =>
  Some(crate::writer::events::XmlEvent::EndElement { name: Some(name.borrow()) }),

src/reader/indexset.rs

@@ -84,13 +84,13 @@ fn indexset() {
  }
 
  assert!(s.contains(&OwnedName {
- local_name: format!("attr1234"), namespace: None, prefix: None,
+ local_name: "attr1234".into(), namespace: None, prefix: None,
  }));
  assert!(s.contains(&OwnedName {
- local_name: format!("attr0"), namespace: None, prefix: None,
+ local_name: "attr0".into(), namespace: None, prefix: None,
  }));
  assert!(s.contains(&OwnedName {
- local_name: format!("attr49999"), namespace: None, prefix: None,
+ local_name: "attr49999".into(), namespace: None, prefix: None,
  }));
 }
 
@@ -100,7 +100,7 @@ struct U64Hasher(u64);
 impl Hasher for U64Hasher {
  fn finish(&self) -> u64 { self.0 }
  fn write(&mut self, slice: &[u8]) {
- for &v in slice { self.0 ^= v as u64 } // unused in practice
+ for &v in slice { self.0 ^= u64::from(v) } // unused in practice
  }
  fn write_u64(&mut self, i: u64) {
  self.0 ^= i;

src/reader/parser.rs

@@ -396,7 +396,7 @@ impl PullParser {
  fn next_pos(&mut self) {
  // unfortunately calls to next_pos will never be perfectly balanced with push_pos,
  // at very least because parse errors and EOF can happen unexpectedly without a prior push.
- if self.pos.len() > 0 {
+ if !self.pos.is_empty() {
  if self.pos.len() > 1 {
  self.pos.remove(0);
  } else {
@@ -485,7 +485,7 @@ impl PullParser {
  let name = this.take_buf();
  match name.parse() {
  Ok(name) => on_name(this, t, name),
- Err(_) => Some(this.error(SyntaxError::InvalidQualifiedName(name.into())))
+ Err(_) => Some(this.error(SyntaxError::InvalidQualifiedName(name.into()))),
  }
  };
 
@@ -515,7 +515,7 @@ impl PullParser {
 
  Token::Character(c) if is_whitespace_char(c) => invoke_callback(self, t),
 
- _ => Some(self.error(SyntaxError::UnexpectedQualifiedName(t)))
+ _ => Some(self.error(SyntaxError::UnexpectedQualifiedName(t))),
  }
  }
 
@@ -527,7 +527,7 @@ impl PullParser {
  fn read_attribute_value<F>(&mut self, t: Token, on_value: F) -> Option<Result>
  where F: Fn(&mut PullParser, String) -> Option<Result> {
  match t {
- Token::Character(c) if self.data.quote.is_none() && is_whitespace_char(c) => None,  // skip leading whitespace
+ Token::Character(c) if self.data.quote.is_none() && is_whitespace_char(c) => None, // skip leading whitespace
 
  Token::DoubleQuote | Token::SingleQuote => match self.data.quote {
  None => { // Entered attribute value
@@ -558,8 +558,7 @@ impl PullParser {
  self.into_state_continue(State::InsideReference)
  },
 
- Token::OpeningTagStart =>
- Some(self.error(SyntaxError::UnexpectedOpeningTag)),
+ Token::OpeningTagStart => Some(self.error(SyntaxError::UnexpectedOpeningTag)),
 
  Token::Character(c) if !self.is_valid_xml_char_not_restricted(c) => {
  Some(self.error(SyntaxError::InvalidCharacterEntity(c as u32)))
@@ -584,7 +583,7 @@ impl PullParser {
 
  // check whether the name prefix is bound and fix its namespace
  match self.nst.get(name.borrow().prefix_repr()) {
- Some("") => name.namespace = None,  // default namespace
+ Some("") => name.namespace = None, // default namespace
  Some(ns) => name.namespace = Some(ns.into()),
  None => return Some(self.error(SyntaxError::UnboundElementPrefix(name.to_string().into())))
  }

src/reader/parser/inside_doctype.rs

@@ -31,8 +31,8 @@ impl PullParser {
  _ => None,
  },
  DoctypeSubstate::String => match t {
- Token::SingleQuote if self.data.quote != Some(QuoteToken::SingleQuoteToken) => { None },
- Token::DoubleQuote if self.data.quote != Some(QuoteToken::DoubleQuoteToken) => { None },
+ Token::SingleQuote if self.data.quote != Some(QuoteToken::SingleQuoteToken) => None,
+ Token::DoubleQuote if self.data.quote != Some(QuoteToken::DoubleQuoteToken) => None,
  Token::SingleQuote | Token::DoubleQuote => {
  self.data.quote = None;
  self.into_state_continue(State::InsideDoctype(DoctypeSubstate::Outside))
@@ -51,12 +51,12 @@ impl PullParser {
  None
  },
  Token::Character(c) if is_whitespace_char(c) => {
- match self.buf.as_str() {
+ let buf = self.take_buf();
+ match buf.as_str() {
  "ENTITY" => self.into_state_continue(State::InsideDoctype(DoctypeSubstate::BeforeEntityName)),
  "NOTATION" | "ELEMENT" | "ATTLIST" => self.into_state_continue(State::InsideDoctype(DoctypeSubstate::SkipDeclaration)),
- s => Some(self.error(SyntaxError::UnknownMarkupDeclaration(s.into()))),
+ _ => Some(self.error(SyntaxError::UnknownMarkupDeclaration(buf.into()))),
  }
-
  },
  _ => Some(self.error(SyntaxError::UnexpectedToken(t))),
  },

src/reader/parser/inside_opening_tag.rs

@@ -31,15 +31,15 @@ impl PullParser {
  OpeningTagSubstate::InsideTag => match t {
  Token::TagEnd => self.emit_start_element(false),
  Token::EmptyTagEnd => self.emit_start_element(true),
- Token::Character(c) if is_whitespace_char(c) => None,  // skip whitespace
+ Token::Character(c) if is_whitespace_char(c) => None, // skip whitespace
  Token::Character(c) if is_name_start_char(c) => {
  if self.buf.len() > self.config.max_name_length {
  return Some(self.error(SyntaxError::ExceededConfiguredLimit));
  }
  self.buf.push(c);
  self.into_state_continue(State::InsideOpeningTag(OpeningTagSubstate::InsideAttributeName))
  }
- _ => Some(self.error(SyntaxError::UnexpectedTokenInOpeningTag(t)))
+ _ => Some(self.error(SyntaxError::UnexpectedTokenInOpeningTag(t))),
  },
 
  OpeningTagSubstate::InsideAttributeName => self.read_qualified_name(t, QualifiedNameTarget::AttributeNameTarget, |this, token, name| {
@@ -108,10 +108,12 @@ impl PullParser {
  }),
 
  OpeningTagSubstate::AfterAttributeValue => match t {
- Token::Character(c) if is_whitespace_char(c) => self.into_state_continue(State::InsideOpeningTag(OpeningTagSubstate::InsideTag)),
+ Token::Character(c) if is_whitespace_char(c) => {
+ self.into_state_continue(State::InsideOpeningTag(OpeningTagSubstate::InsideTag))
+ },
  Token::TagEnd => self.emit_start_element(false),
  Token::EmptyTagEnd => self.emit_start_element(true),
- _ => Some(self.error(SyntaxError::UnexpectedTokenInOpeningTag(t)))
+ _ => Some(self.error(SyntaxError::UnexpectedTokenInOpeningTag(t))),
  },
  }
  }

src/reader/parser/outside_tag.rs

@@ -93,6 +93,7 @@ impl PullParser {
  if self.inside_whitespace && self.config.c.trim_whitespace {
  None
  } else if self.inside_whitespace && !self.config.c.whitespace_to_characters {
+ debug_assert!(buf.chars().all(|ch| ch.is_whitespace()), "ws={buf:?}");
  Some(Ok(XmlEvent::Whitespace(buf)))
  } else if self.config.c.trim_whitespace {
  Some(Ok(XmlEvent::Characters(buf.trim_matches(is_whitespace_char).into())))
@@ -174,7 +175,7 @@ impl PullParser {
  self.into_state(State::OutsideTag, next_event)
  },
 
- Token::CommentStart  => {
+ Token::CommentStart => {
  let next_event = self.set_encountered(Encountered::Comment);
  self.into_state(State::InsideComment, next_event)
  }