Quick docs updates, Rust Edition 2024, bump version for release

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "quick-xml"
-version = "0.41.0"
+version = "0.42.0"
 description = "High performance xml reader and writer"
-edition = "2021"
+edition = "2024"
 
 documentation = "https://docs.rs/quick-xml"
 repository = "https://github.com/tafia/quick-xml"

Changelog.md

@@ -14,12 +14,24 @@
 
 ## Unreleased
 
+### Breaking Changes
+
+### New Features
+
+### Bug Fixes
+
+### Misc Changes
+
+
+## 0.42.0 -- 2026-08-22
+
 This is a large release. The primary change is an ergonomic improvement across the entire API -
 quick_xml now makes use of `&str` and `String` types where possible instead of
 `&[u8]` and `Vec<u8>`. This requires significant refactoring of downstream code,
-but should result in a net simplification as well as potential performance improvements.
+but should result in a net simplification as well as potential performance improvements,
+and opens up additional opportunities in future releases.
 
-The MSRV has been raised to 1.86.
+The MSRV has been raised to 1.86. We now use Rust 2024 Edition.
 
 ### Breaking Changes
 

benches/encoding.rs

@@ -1,4 +1,4 @@
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use pretty_assertions::assert_eq;
 
 use std::io::{BufReader, Read};

benches/issue971.rs

@@ -14,7 +14,7 @@
 //! [#969]: https://github.com/tafia/quick-xml/issues/969
 //! [#971]: https://github.com/tafia/quick-xml/pull/971
 
-use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
+use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
 use quick_xml::events::Event;
 use quick_xml::reader::Reader;
 

benches/macrobenches.rs

@@ -1,4 +1,4 @@
-use criterion::{self, criterion_group, criterion_main, Criterion, Throughput};
+use criterion::{self, Criterion, Throughput, criterion_group, criterion_main};
 use quick_xml::events::Event;
 use quick_xml::reader::{NsReader, Reader};
 use quick_xml::{Result as XmlResult, XmlVersion};

benches/microbenches.rs

@@ -1,4 +1,4 @@
-use criterion::{self, criterion_group, criterion_main, Criterion};
+use criterion::{self, Criterion, criterion_group, criterion_main};
 use pretty_assertions::assert_eq;
 use quick_xml::escape::{escape, unescape};
 use quick_xml::events::Event;
@@ -231,10 +231,11 @@ fn attributes(c: &mut Criterion) {
                                 count += 1
                             }
                         }
-                        assert!(e
-                            .try_get_attribute("attribute-that-doesn't-exist")
-                            .unwrap()
-                            .is_none());
+                        assert!(
+                            e.try_get_attribute("attribute-that-doesn't-exist")
+                                .unwrap()
+                                .is_none()
+                        );
                     }
                     Ok(Event::Eof) => break,
                     _ => (),

examples/custom_entities.rs

@@ -13,12 +13,12 @@
 use std::borrow::Cow;
 use std::collections::{HashMap, VecDeque};
 
+use quick_xml::XmlVersion;
 use quick_xml::errors::Error;
 use quick_xml::escape::EscapeError;
 use quick_xml::events::{BytesEnd, BytesStart, BytesText, Event};
 use quick_xml::name::QName;
 use quick_xml::reader::Reader;
-use quick_xml::XmlVersion;
 use regex::Regex;
 
 use pretty_assertions::assert_eq;

examples/getting_started.rs

@@ -26,9 +26,9 @@
 //! - `writer.rs` for producing XML
 //! - `examples/README.md` for a guide on which approach to choose
 
+use quick_xml::XmlVersion;
 use quick_xml::events::Event;
 use quick_xml::reader::Reader;
-use quick_xml::XmlVersion;
 
 const XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
 <catalog>

examples/read_nodes.rs

@@ -2,12 +2,12 @@
 // Note: for this specific data set using serde feature would simplify
 //       this simple data is purely to make it easier to understand the code
 
+use quick_xml::XmlVersion;
 use quick_xml::encoding::EncodingError;
 use quick_xml::events::attributes::AttrError;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::name::QName;
 use quick_xml::reader::Reader;
-use quick_xml::XmlVersion;
 use std::borrow::Cow;
 use std::collections::HashMap;
 use std::convert::Infallible;

examples/read_utf16.rs

@@ -6,10 +6,10 @@ fn main() -> Result<(), quick_xml::Error> {
     use std::fs::File;
     use std::io::BufReader;
 
+    use quick_xml::XmlVersion;
     use quick_xml::encoding::DecodingReader;
     use quick_xml::events::Event;
     use quick_xml::reader::Reader;
-    use quick_xml::XmlVersion;
 
     let file = File::open("tests/documents/encoding/utf16le-bom.xml")?;
     let transcoder = DecodingReader::new(BufReader::new(file));

examples/reader_patterns.rs

@@ -33,9 +33,9 @@
 //! cargo run --example reader_patterns
 //! ```
 
+use quick_xml::XmlVersion;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::reader::Reader;
-use quick_xml::XmlVersion;
 
 const XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
 <catalog>

examples/serde_roundtrip.rs

@@ -15,11 +15,14 @@
 //! |------------------------------|----------------------------------------------|
 //! | attribute `id="..."`         | `#[serde(rename = "@id")]`                    |
 //! | text inside an element       | `#[serde(rename = "$text")]`                  |
+//! | xs:choice as Rust enum       | `#[serde(rename = "$value")]`                 |
 //! | fields shared across types   | `#[serde(flatten)]` on a sub-struct           |
 //! | child element `<title>`      | a field named `title` (no prefix)             |
 //! | repeated child elements      | a `Vec<T>` field                              |
 //! | the element's own tag name   | chosen by the parent field / root, see below  |
 //!
+//! See [`Mapping XML to Rust types`] for more info.
+//!
 //! Types are converted for you: `available="true"` becomes a `bool`,
 //! `<price>39.95</price>` becomes an `f64`, and so on.
 //!
@@ -28,6 +31,8 @@
 //! ```console
 //! cargo run --example serde_roundtrip --features serialize
 //! ```
+//!
+//! [`Mapping XML to Rust types`]: https://docs.rs/quick-xml/latest/quick_xml/de/index.html#mapping-xml-to-rust-types
 
 use quick_xml::de::from_str;
 use quick_xml::events::{BytesEnd, BytesStart, Event};

examples/visitor.rs

@@ -35,9 +35,9 @@
 //! cargo run --example visitor
 //! ```
 
+use quick_xml::XmlVersion;
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::reader::Reader;
-use quick_xml::XmlVersion;
 
 const XML: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
 <catalog>

fuzz/Cargo.toml

@@ -3,7 +3,7 @@ name = "quick-xml-fuzz"
 version = "0.0.0"
 authors = ["Automatically generated"]
 publish = false
-edition = "2021"
+edition = "2024"
 
 [package.metadata]
 cargo-fuzz = true

src/de/attributes.rs

@@ -5,11 +5,11 @@ use std::borrow::Cow;
 use serde::de::{DeserializeSeed, Deserializer, Error, MapAccess, Visitor};
 use serde::forward_to_deserialize_any;
 
-use crate::de::key::QNameDeserializer;
+use crate::XmlVersion;
 use crate::de::SimpleTypeDeserializer;
+use crate::de::key::QNameDeserializer;
 use crate::errors::serialize::DeError;
 use crate::events::attributes::Attributes;
-use crate::XmlVersion;
 
 impl<'i> Attributes<'i> {
     /// Converts this iterator into a serde's [`MapAccess`] trait to use with serde.

src/de/map.rs

@@ -5,11 +5,11 @@ use crate::{
     de::resolver::EntityResolver,
     de::simple_type::SimpleTypeDeserializer,
     de::text::TextDeserializer,
-    de::{DeEvent, Deserializer, XmlRead, TEXT_KEY, VALUE_KEY},
-    errors::serialize::DeError,
+    de::{DeEvent, Deserializer, TEXT_KEY, VALUE_KEY, XmlRead},
     errors::Error,
-    events::attributes::IterState,
+    errors::serialize::DeError,
     events::BytesStart,
+    events::attributes::IterState,
     name::QName,
 };
 use serde::de::value::BorrowedStrDeserializer;

src/de/mod.rs

@@ -2106,13 +2106,13 @@ mod var;
 pub use self::attributes::AttributesDeserializer;
 pub use self::resolver::{EntityResolver, PredefinedEntityResolver};
 pub use self::simple_type::SimpleTypeDeserializer;
-pub use crate::errors::serialize::DeError;
 use crate::XmlVersion;
+pub use crate::errors::serialize::DeError;
 
 use crate::{
     de::map::ElementMapAccess,
     errors::Error,
-    escape::{parse_number, EscapeError},
+    escape::{EscapeError, parse_number},
     events::{BytesCData, BytesEnd, BytesRef, BytesStart, BytesText, Event},
     name::{NamespaceResolver, QName},
     reader::{NsReader, Reader},

src/de/simple_type.rs

@@ -3,11 +3,11 @@
 //! [simple types]: https://www.w3schools.com/xml/el_simpletype.asp
 //! [as defined]: https://www.w3.org/TR/xmlschema11-1/#Simple_Type_Definition
 
+use crate::XmlVersion;
 use crate::de::Text;
 use crate::errors::serialize::DeError;
 use crate::escape::resolve_predefined_entity;
-use crate::utils::{trim_xml_spaces, CowRef};
-use crate::XmlVersion;
+use crate::utils::{CowRef, trim_xml_spaces};
 use memchr::memchr;
 use serde::de::value::UnitDeserializer;
 use serde::de::{
@@ -741,8 +741,8 @@ impl<'de, 'a> IntoDeserializer<'de, DeError> for SimpleTypeDeserializer<'de, 'a>
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::se::simple_type::{QuoteTarget, SimpleTypeSerializer};
     use crate::se::QuoteLevel;
+    use crate::se::simple_type::{QuoteTarget, SimpleTypeSerializer};
     use crate::utils::{ByteBuf, Bytes};
     use serde::de::IgnoredAny;
     use serde::{Deserialize, Serialize};

src/de/text.rs

@@ -1,6 +1,6 @@
 use crate::{
     de::simple_type::SimpleTypeDeserializer,
-    de::{Text, TEXT_KEY},
+    de::{TEXT_KEY, Text},
     errors::serialize::DeError,
 };
 use serde::de::value::BorrowedStrDeserializer;

src/de/var.rs

@@ -3,7 +3,7 @@ use crate::{
     de::map::ElementMapAccess,
     de::resolver::EntityResolver,
     de::simple_type::SimpleTypeDeserializer,
-    de::{DeEvent, Deserializer, XmlRead, TEXT_KEY},
+    de::{DeEvent, Deserializer, TEXT_KEY, XmlRead},
     errors::serialize::DeError,
 };
 use serde::de::value::BorrowedStrDeserializer;

src/errors.rs

@@ -152,7 +152,11 @@ impl fmt::Display for IllFormedError {
                 f.write_str("an XML declaration does not contain `version` attribute")
             }
             Self::MissingDeclVersion(Some(attr)) => {
-                write!(f, "an XML declaration must start with `version` attribute, but in starts with `{}`", attr)
+                write!(
+                    f,
+                    "an XML declaration must start with `version` attribute, but in starts with `{}`",
+                    attr
+                )
             }
             Self::UnknownVersion => {
                 f.write_str("unknown XML version: either 1.0 or 1.1 is expected")

src/events/attributes.rs

@@ -2,12 +2,12 @@
 //!
 //! Provides an iterator over attributes key/value pairs
 
+use crate::XmlVersion;
 use crate::encoding::Decoder;
 use crate::errors::Result as XmlResult;
 use crate::escape::{escape_attribute, resolve_predefined_entity};
 use crate::name::{LocalName, Namespace, NamespaceResolver, QName};
 use crate::utils::is_whitespace;
-use crate::XmlVersion;
 
 use std::collections::HashSet;
 use std::fmt::{self, Debug, Display, Formatter};
@@ -967,7 +967,7 @@ impl IterState {
     fn skip_value(&self, slice: &[u8], offset: usize) -> Option<usize> {
         let mut iter = (offset..).zip(slice[offset..].iter());
 
-        match iter.find(|(_, &b)| is_whitespace(b)) {
+        match iter.find(|&(_, &b)| is_whitespace(b)) {
             // Input: `    key  =  value `
             //                     |    ^
             //                offset    e
@@ -985,7 +985,7 @@ impl IterState {
         let mut iter = (offset..).zip(slice[offset..].iter());
 
         // Skip all up to the quote and get the quote type
-        let quote = match iter.find(|(_, &b)| !is_whitespace(b)) {
+        let quote = match iter.find(|&(_, &b)| !is_whitespace(b)) {
             // Input: `    key  =  "`
             //                  |  ^
             //             offset
@@ -1005,7 +1005,7 @@ impl IterState {
             None => return None,
         };
 
-        match iter.find(|(_, &b)| b == quote) {
+        match iter.find(|&(_, &b)| b == quote) {
             // Input: `    key  =  "   "`
             //                         ^
             Some((e, b'"')) => Some(e),
@@ -1127,7 +1127,7 @@ impl IterState {
         };
 
         // Index where next key started
-        let start_key = match iter.find(|(_, &b)| !is_whitespace(b)) {
+        let start_key = match iter.find(|&(_, &b)| !is_whitespace(b)) {
             // Input: `    key`
             //             ^
             Some((s, _)) => s,
@@ -1140,15 +1140,15 @@ impl IterState {
             }
         };
         // Span of a key
-        let (key, offset) = match iter.find(|(_, &b)| b == b'=' || is_whitespace(b)) {
+        let (key, offset) = match iter.find(|&(_, &b)| b == b'=' || is_whitespace(b)) {
             // Input: `    key=`
             //             |  ^
             //             s  e
             Some((e, b'=')) => (start_key..e, e),
 
             // Input: `    key `
             //                ^
-            Some((e, _)) => match iter.find(|(_, &b)| !is_whitespace(b)) {
+            Some((e, _)) => match iter.find(|&(_, &b)| !is_whitespace(b)) {
                 // Input: `    key  =`
                 //             |  | ^
                 //     start_key  e
@@ -1196,7 +1196,7 @@ impl IterState {
         ////////////////////////////////////////////////////////////////////////
 
         // Gets the position of quote and quote type
-        let (start_value, quote) = match iter.find(|(_, &b)| !is_whitespace(b)) {
+        let (start_value, quote) = match iter.find(|&(_, &b)| !is_whitespace(b)) {
             // Input: `    key  =  "`
             //                     ^
             Some((s, b'"')) => (s + 1, b'"'),
@@ -1211,7 +1211,7 @@ impl IterState {
                 // We do not check validity of attribute value characters as required
                 // according to https://html.spec.whatwg.org/#unquoted. It can be done
                 // during validation phase
-                let end = match iter.find(|(_, &b)| is_whitespace(b)) {
+                let end = match iter.find(|&(_, &b)| is_whitespace(b)) {
                     // Input: `    key  =  value `
                     //                     |    ^
                     //                     s    e
@@ -1240,7 +1240,7 @@ impl IterState {
             }
         };
 
-        match iter.find(|(_, &b)| b == quote) {
+        match iter.find(|&(_, &b)| b == quote) {
             // Input: `    key  =  "   "`
             //                         ^
             Some((e, b'"')) => self.double_q(key, start_value..e),
@@ -1296,9 +1296,9 @@ mod xml {
 
     mod attribute_value_normalization {
         use super::*;
+        use crate::XmlVersion::*;
         use crate::errors::Error;
         use crate::escape::EscapeError::*;
-        use crate::XmlVersion::*;
         use pretty_assertions::assert_eq;
 
         /// Empty values returned are unchanged