ns: Add API to get namespace prefixes from QNames and fix reserved name test

Co-authored-by: Daniel Alley <[email protected]>

Author: Mingun

Changelog.md

@@ -14,9 +14,9 @@
 
 - [#387]: Allow overlapping between elements of sequence and other elements
   (using new feature `overlapped-lists`)
-- [#393]: New module `name` with `QName`, `LocalName`, `Namespace`, and `Prefix`
-  wrappers around byte arrays and `ResolveResult` with the result of prefix
-  resolution to namespace
+- [#393]: New module `name` with `QName`, `LocalName`, `Namespace`, `Prefix`
+  and `PrefixDeclaration` wrappers around byte arrays and `ResolveResult` with
+  the result of namespace resolution
 
 ### Bug Fixes
 
@@ -28,6 +28,7 @@
   another sequence. This error affects only users with the `serialize` feature enabled
 - [#393]: Now `event_namespace`, `attribute_namespace` and `read_event_namespaced`
   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")
 
 ### Misc Changes
 

src/name.rs

@@ -71,6 +71,41 @@ impl<'a> QName<'a> {
         }
     }
 
+    /// If that `QName` represents `"xmlns"` series of names, returns `Some`,
+    /// otherwise `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use quick_xml::name::{QName, PrefixDeclaration};
+    /// let qname = QName(b"xmlns");
+    /// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Default));
+    ///
+    /// let qname = QName(b"xmlns:prefix");
+    /// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Named(b"prefix")));
+    ///
+    /// // Be aware that this method does not check the validity of the prefix - it can be empty!
+    /// let qname = QName(b"xmlns:");
+    /// assert_eq!(qname.as_namespace_binding(), Some(PrefixDeclaration::Named(b"")));
+    ///
+    /// let qname = QName(b"other-name");
+    /// assert_eq!(qname.as_namespace_binding(), None);
+    ///
+    /// // https://www.w3.org/TR/xml-names11/#xmlReserved
+    /// let qname = QName(b"xmlns-reserved-name");
+    /// assert_eq!(qname.as_namespace_binding(), None);
+    /// ```
+    pub fn as_namespace_binding(&self) -> Option<PrefixDeclaration<'a>> {
+        if self.0.starts_with(b"xmlns") {
+            return match self.0.get(5) {
+                None => Some(PrefixDeclaration::Default),
+                Some(&b':') => Some(PrefixDeclaration::Named(&self.0[6..])),
+                _ => None,
+            };
+        }
+        None
+    }
+
     /// Returns the index in the name where prefix ended
     #[inline(always)]
     fn index(&self) -> Option<usize> {
@@ -173,6 +208,19 @@ impl<'a> AsRef<[u8]> for Prefix<'a> {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/// A namespace prefix declaration, `xmlns` or `xmlns:<name>`, as defined in
+/// [XML Schema specification](https://www.w3.org/TR/xml-names/#ns-decl)
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum PrefixDeclaration<'a> {
+    /// XML attribute binds a default namespace. Corresponds to `xmlns` in in `xmlns="..."`
+    Default,
+    /// XML attribute binds a specified prefix to a namespace. Corresponds to a
+    /// `prefix` in `xmlns:prefix="..."`, which is stored as payload of this variant.
+    Named(&'a [u8]),
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// A [namespace name] that is declared in a `xmlns[:prefix]="namespace name"`.
 ///
 /// [namespace name]: https://www.w3.org/TR/xml-names11/#dt-NSName
@@ -361,32 +409,29 @@ impl NamespaceResolver {
         // (default namespace) attribute.
         for a in start.attributes().with_checks(false) {
             if let Ok(Attribute { key: k, value: v }) = a {
-                let k = k.as_ref(); //TODO: Use QName API
-                if k.starts_with(b"xmlns") {
-                    match k.get(5) {
-                        None => {
-                            let start = buffer.len();
-                            buffer.extend_from_slice(&*v);
-                            self.bindings.push(NamespaceEntry {
-                                start,
-                                prefix_len: 0,
-                                value_len: v.len(),
-                                level,
-                            });
-                        }
-                        Some(&b':') => {
-                            let start = buffer.len();
-                            buffer.extend_from_slice(&k[6..]);
-                            buffer.extend_from_slice(&*v);
-                            self.bindings.push(NamespaceEntry {
-                                start,
-                                prefix_len: k.len() - 6,
-                                value_len: v.len(),
-                                level,
-                            });
-                        }
-                        _ => break,
+                match k.as_namespace_binding() {
+                    Some(PrefixDeclaration::Default) => {
+                        let start = buffer.len();
+                        buffer.extend_from_slice(&*v);
+                        self.bindings.push(NamespaceEntry {
+                            start,
+                            prefix_len: 0,
+                            value_len: v.len(),
+                            level,
+                        });
+                    }
+                    Some(PrefixDeclaration::Named(prefix)) => {
+                        let start = buffer.len();
+                        buffer.extend_from_slice(prefix);
+                        buffer.extend_from_slice(&*v);
+                        self.bindings.push(NamespaceEntry {
+                            start,
+                            prefix_len: prefix.len(),
+                            value_len: v.len(),
+                            level,
+                        });
                     }
+                    None => {}
                 }
             } else {
                 break;

tests/namespaces.rs

@@ -157,7 +157,7 @@ fn attributes_empty_ns() {
         .attributes()
         .map(|ar| ar.expect("Expecting attribute parsing to succeed."))
         // we don't care about xmlns attributes for this test
-        .filter(|kv| !kv.key.as_ref().starts_with(b"xmlns"))
+        .filter(|kv| kv.key.as_namespace_binding().is_none())
         .map(|Attribute { key: name, value }| {
             let (opt_ns, local_name) = r.attribute_namespace(name, &ns_buf);
             (opt_ns, local_name.into_inner(), value)
@@ -198,7 +198,7 @@ fn attributes_empty_ns_expanded() {
             .attributes()
             .map(|ar| ar.expect("Expecting attribute parsing to succeed."))
             // we don't care about xmlns attributes for this test
-            .filter(|kv| !kv.key.as_ref().starts_with(b"xmlns"))
+            .filter(|kv| kv.key.as_namespace_binding().is_none())
             .map(|Attribute { key: name, value }| {
                 let (opt_ns, local_name) = r.attribute_namespace(name, &ns_buf);
                 (opt_ns, local_name.into_inner(), value)
@@ -259,7 +259,7 @@ fn default_ns_shadowing_empty() {
             .attributes()
             .map(|ar| ar.expect("Expecting attribute parsing to succeed."))
             // we don't care about xmlns attributes for this test
-            .filter(|kv| !kv.key.as_ref().starts_with(b"xmlns"))
+            .filter(|kv| kv.key.as_namespace_binding().is_none())
             .map(|Attribute { key: name, value }| {
                 let (opt_ns, local_name) = r.attribute_namespace(name, &ns_buf);
                 (opt_ns, local_name.into_inner(), value)
@@ -318,7 +318,7 @@ fn default_ns_shadowing_expanded() {
             .attributes()
             .map(|ar| ar.expect("Expecting attribute parsing to succeed."))
             // we don't care about xmlns attributes for this test
-            .filter(|kv| !kv.key.as_ref().starts_with(b"xmlns"))
+            .filter(|kv| kv.key.as_namespace_binding().is_none())
             .map(|Attribute { key: name, value }| {
                 let (opt_ns, local_name) = r.attribute_namespace(name, &ns_buf);
                 (opt_ns, local_name.into_inner(), value)

tests/xmlrs_reader_tests.rs

@@ -444,11 +444,10 @@ fn make_attrs(e: &BytesStart) -> ::std::result::Result<String, String> {
     for a in e.attributes() {
         match a {
             Ok(a) => {
-                let key = a.key.as_ref();
-                if !key.starts_with(b"xmlns") {
+                if a.key.as_namespace_binding().is_none() {
                     atts.push(format!(
                         "{}=\"{}\"",
-                        from_utf8(key).unwrap(),
+                        from_utf8(a.key.as_ref()).unwrap(),
                         from_utf8(&*a.unescaped_value().unwrap()).unwrap()
                     ));
                 }