xmppftw/xmpp-rs
Watch
1
0
Fork
You've already forked xmpp-rs
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

minidom: breaking: Allow getting Element attributes by namespace

Browse source 
- Move Element.attributes to `AttrMap`, slowly using rxml's features and
  unrolling our own.
- Add Element::attr_ns that requires the attribute namespace.
  Element:attr defaults to rxml::Namespace::none() but the interface
  changes nonetheless for a &NcNameStr. Similar changes on
  `ElementBuilder` methods.
- Remove iterator structs for attributes, return a ref on the AttrMap
  directly as we don't need to keep attributes' internals hidden
  anymore.
- Enable rxml's `macros` feature within tests to access the `xml_ncname`
  macro.

Signed-off-by: pep <pep@bouah.net>
This commit is contained in:
Maxime “pep” Buquet 2025-09-27 16:49:42 +02:00 • committed by pep
commit 19865e5f1e
14 changed files with 272 additions and 236 deletions
Download patch file Download diff file Expand all files Collapse all files

138
minidom/src/element.rs
View file

@ -20,7 +20,6 @@ use crate::prefixes::{Namespace, Prefix, Prefixes};
use crate::tree_builder::TreeBuilder;
use alloc::borrow::Cow;
use alloc::collections::btree_map::{self, BTreeMap};
use alloc::string::String;
use alloc::vec::Vec;
@ -30,7 +29,7 @@ use core::str::FromStr;
use std::io;
use rxml::writer::{Encoder, Item, TrackNamespace};
use rxml::{Namespace as RxmlNamespace, RawReader, XmlVersion};
use rxml::{AttrMap, Namespace as RxmlNamespace, NcName, NcNameStr, RawReader, XmlVersion};
fn encode_and_write<W: io::Write, T: rxml::writer::TrackNamespace>(
item: Item<'_>,
@ -121,7 +120,7 @@ pub struct Element {
namespace: String,
/// Namespace declarations
pub prefixes: Prefixes,
attributes: BTreeMap<String, String>,
attributes: AttrMap,
children: Vec<Node>,
}
@ -162,7 +161,7 @@ impl Element {
name: String,
namespace: String,
prefixes: P,
attributes: BTreeMap<String, String>,
attributes: AttrMap,
children: Vec<Node>,
) -> Element {
Element {
@ -180,16 +179,17 @@ impl Element {
///
/// ```rust
/// use minidom::Element;
/// use rxml::{Namespace, xml_ncname};
///
/// let elem = Element::builder("name", "namespace")
/// .attr("name", "value")
/// .attr(xml_ncname!("name").to_owned(), "value")
/// .append("inner")
/// .build();
///
/// assert_eq!(elem.name(), "name");
/// assert_eq!(elem.ns(), "namespace".to_owned());
/// assert_eq!(elem.attr("name"), Some("value"));
/// assert_eq!(elem.attr("inexistent"), None);
/// assert_eq!(elem.attr(xml_ncname!("name")), Some("value"));
/// assert_eq!(elem.attr(xml_ncname!("inexistent")), None);
/// assert_eq!(elem.text(), "inner");
/// ```
pub fn builder<S: AsRef<str>, NS: Into<String>>(name: S, namespace: NS) -> ElementBuilder {
@ -198,7 +198,7 @@ impl Element {
name.as_ref().to_string(),
namespace.into(),
None,
BTreeMap::new(),
AttrMap::new(),
Vec::new(),
),
}
@ -210,12 +210,13 @@ impl Element {
///
/// ```rust
/// use minidom::Element;
/// use rxml::{Namespace, xml_ncname};
///
/// let bare = Element::bare("name", "namespace");
///
/// assert_eq!(bare.name(), "name");
/// assert_eq!(bare.ns(), "namespace");
/// assert_eq!(bare.attr("name"), None);
/// assert_eq!(bare.attr(xml_ncname!("name")), None);
/// assert_eq!(bare.text(), "");
/// ```
pub fn bare<S: Into<String>, NS: Into<String>>(name: S, namespace: NS) -> Element {
@ -223,7 +224,7 @@ impl Element {
name.into(),
namespace.into(),
None,
BTreeMap::new(),
AttrMap::new(),
Vec::new(),
)
}
@ -242,8 +243,17 @@ impl Element {
/// Returns a reference to the value of the given attribute, if it exists, else `None`.
#[must_use]
pub fn attr(&self, name: &str) -> Option<&str> {
if let Some(value) = self.attributes.get(name) {
pub fn attr<'a>(&'a self, name: &'a NcNameStr) -> Option<&'a str> {
if let Some(value) = self.attributes.get(&RxmlNamespace::NONE, name) {
return Some(value);
}
None
}
/// Returns a reference to the value of the given namespaced attribute, if it exists, else `None`.
#[must_use]
pub fn attr_ns<'a>(&'a self, ns: &'a RxmlNamespace, name: &'a NcNameStr) -> Option<&'a str> {
if let Some(value) = self.attributes.get(ns, name) {
return Some(value);
}
None
@ -255,43 +265,39 @@ impl Element {
///
/// ```rust
/// use minidom::Element;
/// use rxml::{Namespace, xml_ncname};
///
/// let elm: Element = "<elem xmlns=\"ns1\" a=\"b\" />".parse().unwrap();
///
/// let mut iter = elm.attrs();
/// let mut iter = elm.attrs().iter();
///
/// assert_eq!(iter.next().unwrap(), ("a", "b"));
/// assert_eq!(iter.next().unwrap(), ((&Namespace::NONE, &xml_ncname!("a").to_owned()), &String::from("b")));
/// assert_eq!(iter.next(), None);
/// ```
#[must_use]
pub fn attrs(&self) -> Attrs<'_> {
Attrs {
iter: self.attributes.iter(),
}
pub fn attrs(&self) -> &AttrMap {
&self.attributes
}
/// Returns an iterator over the attributes of this element, with the value being a mutable
/// reference.
#[must_use]
pub fn attrs_mut(&mut self) -> AttrsMut<'_> {
AttrsMut {
iter: self.attributes.iter_mut(),
}
pub fn attrs_mut(&mut self) -> &mut AttrMap {
&mut self.attributes
}
/// Modifies the value of an attribute.
pub fn set_attr<S: Into<String>, V: IntoAttributeValue>(&mut self, name: S, val: V) {
let name = name.into();
pub fn set_attr<V: IntoAttributeValue>(&mut self, ns: RxmlNamespace, name: NcName, val: V) {
let val = val.into_attribute_value();
if let Some(value) = self.attributes.get_mut(&name) {
if let Some(value) = self.attributes.get_mut(&ns, &name) {
*value = val
.expect("removing existing value via set_attr, this is not yet supported (TODO)"); // TODO
return;
}
if let Some(val) = val {
self.attributes.insert(name, val);
self.attributes.insert(ns.clone(), name, val);
}
}
@ -405,19 +411,8 @@ impl Element {
let namespace: RxmlNamespace = self.namespace.clone().into();
writer.write(Item::ElementHeadStart(&namespace, (*self.name).try_into()?))?;
for (key, value) in &self.attributes {
let (prefix, name) = <&rxml::NameStr>::try_from(&**key)
.unwrap()
.split_name()
.unwrap();
let namespace = match prefix {
Some(prefix) => match writer.encoder.ns_tracker().lookup_prefix(Some(prefix)) {
Ok(v) => v,
Err(rxml::writer::PrefixError::Undeclared) => return Err(Error::InvalidPrefix),
},
None => RxmlNamespace::NONE,
};
writer.write(Item::Attribute(&namespace, name, value))?;
for ((ns, key), value) in &self.attributes {
writer.write(Item::Attribute(&ns, key, value))?;
}
if !self.children.is_empty() {
@ -870,32 +865,6 @@ pub type Nodes<'a> = slice::Iter<'a, Node>;
/// An iterator over mutable references to all child nodes of an `Element`.
pub type NodesMut<'a> = slice::IterMut<'a, Node>;
/// An iterator over the attributes of an `Element`.
pub struct Attrs<'a> {
iter: btree_map::Iter<'a, String, String>,
}
impl<'a> Iterator for Attrs<'a> {
type Item = (&'a str, &'a str);
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(x, y)| (x.as_ref(), y.as_ref()))
}
}
/// An iterator over the attributes of an `Element`, with the values mutable.
pub struct AttrsMut<'a> {
iter: btree_map::IterMut<'a, String, String>,
}
impl<'a> Iterator for AttrsMut<'a> {
type Item = (&'a str, &'a mut String);
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|(x, y)| (x.as_ref(), y))
}
}
/// A builder for `Element`s.
pub struct ElementBuilder {
root: Element,
@ -917,12 +886,20 @@ impl ElementBuilder {
/// Sets an attribute.
#[must_use]
pub fn attr<S: Into<String>, V: IntoAttributeValue>(
pub fn attr<V: IntoAttributeValue>(mut self, name: NcName, value: V) -> ElementBuilder {
self.root.set_attr(RxmlNamespace::NONE, name, value);
self
}
/// Sets an attribute.
#[must_use]
pub fn attr_ns<V: IntoAttributeValue>(
mut self,
name: S,
ns: RxmlNamespace,
name: NcName,
value: V,
) -> ElementBuilder {
self.root.set_attr(name, value);
self.root.set_attr(ns, name, value);
self
}
@ -955,21 +932,32 @@ impl ElementBuilder {
#[cfg(test)]
mod tests {
use super::*;
use rxml::xml_ncname;
use std::collections::BTreeMap;
#[test]
fn test_element_new() {
let mut attrs = AttrMap::new();
attrs.insert(
String::from("namespace").into(),
xml_ncname!("name").to_owned(),
"value".to_string(),
);
let elem = Element::new(
"name".to_owned(),
"namespace".to_owned(),
(None, "namespace".to_owned()),
BTreeMap::from_iter([("name".to_string(), "value".to_string())].into_iter()),
attrs,
Vec::new(),
);
assert_eq!(elem.name(), "name");
assert_eq!(elem.ns(), "namespace".to_owned());
assert_eq!(elem.attr("name"), Some("value"));
assert_eq!(elem.attr("inexistent"), None);
assert_eq!(
elem.attr_ns(&String::from("namespace").into(), xml_ncname!("name")),
Some("value")
);
assert_eq!(elem.attr(xml_ncname!("inexistent")), None);
}
#[test]
@ -987,7 +975,9 @@ mod tests {
let xml = b"<foo xmlns='ns1'><bar xmlns='ns1' baz='qxx' /></foo>";
let elem = Element::from_reader(&xml[..]);
let nested = Element::builder("bar", "ns1").attr("baz", "qxx").build();
let nested = Element::builder("bar", "ns1")
.attr(xml_ncname!("baz").to_owned(), "qxx")
.build();
let elem2 = Element::builder("foo", "ns1").append(nested).build();
assert_eq!(elem.unwrap(), elem2);
@ -998,7 +988,9 @@ mod tests {
let xml = b"<foo xmlns='ns1'><prefix:bar xmlns:prefix='ns1' baz='qxx' /></foo>";
let elem = Element::from_reader(&xml[..]);
let nested = Element::builder("bar", "ns1").attr("baz", "qxx").build();
let nested = Element::builder("bar", "ns1")
.attr(xml_ncname!("baz").to_owned(), "qxx")
.build();
let elem2 = Element::builder("foo", "ns1").append(nested).build();
assert_eq!(elem.unwrap(), elem2);

37
minidom/src/tests.rs
View file

@ -16,19 +16,23 @@ use alloc::format;
use alloc::string::String;
use alloc::vec::Vec;
use rxml::{xml_ncname, Namespace as RxmlNamespace};
const TEST_STRING: &'static [u8] = br#"<root xmlns='root_ns' a='b' xml:lang='en'>meow<child c='d'/><child xmlns='child_ns' d='e' xml:lang='fr'/>nya</root>"#;
fn build_test_tree() -> Element {
let mut root = Element::builder("root", "root_ns")
.attr("xml:lang", "en")
.attr("a", "b")
.attr_ns(RxmlNamespace::XML, xml_ncname!("lang").to_owned(), "en")
.attr(xml_ncname!("a").to_owned(), "b")
.build();
root.append_text_node("meow");
let child = Element::builder("child", "root_ns").attr("c", "d").build();
let child = Element::builder("child", "root_ns")
.attr(xml_ncname!("c").to_owned(), "d")
.build();
root.append_child(child);
let other_child = Element::builder("child", "child_ns")
.attr("d", "e")
.attr("xml:lang", "fr")
.attr(xml_ncname!("d").to_owned(), "e")
.attr_ns(RxmlNamespace::XML, xml_ncname!("lang").to_owned(), "fr")
.build();
root.append_child(other_child);
root.append_text_node("nya");
@ -243,7 +247,7 @@ fn writer_with_prefix_deduplicate() {
#[test]
fn writer_escapes_attributes() {
let root = Element::builder("root", "ns1")
.attr("a", "\"Air\" quotes")
.attr(xml_ncname!("a").to_owned(), "\"Air\" quotes")
.build();
let mut writer = Vec::new();
{
@ -271,14 +275,14 @@ fn writer_escapes_text() {
#[test]
fn builder_works() {
let elem = Element::builder("a", "b")
.attr("c", "d")
.attr(xml_ncname!("c").to_owned(), "d")
.append(Element::builder("child", "b"))
.append("e")
.build();
assert_eq!(elem.name(), "a");
assert_eq!(elem.ns(), "b".to_owned());
assert_eq!(elem.attr("c"), Some("d"));
assert_eq!(elem.attr("x"), None);
assert_eq!(elem.attr(xml_ncname!("c")), Some("d"));
assert_eq!(elem.attr(xml_ncname!("x")), None);
assert_eq!(elem.text(), "e");
assert!(elem.has_child("child", "b"));
assert!(elem.is("a", "b"));
@ -307,11 +311,15 @@ fn get_child_works() {
.unwrap()
.is("child", "child_ns"));
assert_eq!(
root.get_child("child", "root_ns").unwrap().attr("c"),
root.get_child("child", "root_ns")
.unwrap()
.attr(xml_ncname!("c")),
Some("d")
);
assert_eq!(
root.get_child("child", "child_ns").unwrap().attr("d"),
root.get_child("child", "child_ns")
.unwrap()
.attr(xml_ncname!("d")),
Some("e")
);
}
@ -349,12 +357,15 @@ fn two_elements_with_same_arguments_different_order_are_equal() {
#[test]
fn namespace_attributes_works() {
let root = Element::from_reader(TEST_STRING).unwrap();
assert_eq!("en", root.attr("xml:lang").unwrap());
assert_eq!(
Some("en"),
root.attr_ns(RxmlNamespace::xml(), xml_ncname!("lang"))
);
assert_eq!(
"fr",
root.get_child("child", "child_ns")
.unwrap()
.attr("xml:lang")
.attr_ns(RxmlNamespace::xml(), xml_ncname!("lang"))
.unwrap()
);
}

56
minidom/src/tree_builder.rs
View file

@ -1,4 +1,5 @@
// Copyright (c) 2022 Astro <astro@spaceboyz.net>
// Copyright (c) 2025 pep <pep@bouah.net>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
@ -8,19 +9,18 @@
use crate::prefixes::{Prefix, Prefixes};
use crate::{Element, Error};
use alloc::collections::BTreeMap;
use alloc::format;
use alloc::string::String;
use alloc::vec::Vec;
use rxml::RawEvent;
use rxml::{AttrMap, Namespace, RawEvent};
/// Tree-building parser state
pub struct TreeBuilder {
next_tag: Option<(Prefix, String, Prefixes, BTreeMap<String, String>)>,
next_tag: Option<(Prefix, String, Prefixes, AttrMap)>,
/// Parsing stack
stack: Vec<Element>,
/// Namespace set stack by prefix
prefixes_stack: Vec<Prefixes>,
attrs_stack: Vec<(String, String, String)>,
/// Document root element if finished
pub root: Option<Element>,
}
@ -39,6 +39,7 @@ impl TreeBuilder {
next_tag: None,
stack: Vec::new(),
prefixes_stack: Vec::new(),
attrs_stack: Vec::new(),
root: None,
}
}
@ -83,8 +84,11 @@ impl TreeBuilder {
/// Lookup XML namespace declaration for given prefix (or no prefix)
#[must_use]
fn lookup_prefix(&self, prefix: &Option<String>) -> Option<&str> {
for nss in self.prefixes_stack.iter().rev() {
fn lookup_prefix<'a>(
prefixes_stack: &'a Vec<Prefixes>,
prefix: &'a Option<String>,
) -> Option<&'a str> {
for nss in prefixes_stack.iter().rev() {
if let Some(ns) = nss.get(prefix) {
return Some(ns);
}
@ -129,7 +133,7 @@ impl TreeBuilder {
prefix.map(|prefix| prefix.as_str().to_owned()),
name.as_str().to_owned(),
prefixes,
BTreeMap::new(),
AttrMap::new(),
));
}
@ -141,23 +145,47 @@ impl TreeBuilder {
prefixes.insert(Some(prefix.as_str().to_owned()), value);
}
(Some(prefix), name) => {
attrs.insert(format!("{prefix}:{name}"), value.as_str().to_owned());
self.attrs_stack
.push((prefix.to_string(), name.to_string(), value));
}
(None, name) => {
attrs.insert(name.as_str().to_owned(), value.as_str().to_owned());
attrs.insert(
Namespace::NONE,
name.try_into().unwrap(),
value.as_str().to_owned(),
);
}
}
}
}
RawEvent::ElementHeadClose(_) => {
if let Some((prefix, name, prefixes, attrs)) = self.next_tag.take() {
if let Some((prefix, name, prefixes, mut attrs)) = self.next_tag.take() {
self.prefixes_stack.push(prefixes.clone());
let namespace = self
.lookup_prefix(&prefix.map(|prefix| prefix.as_str().to_owned()))
.ok_or(Error::MissingNamespace)?
.to_owned();
let namespace = TreeBuilder::lookup_prefix(
&self.prefixes_stack,
&prefix.map(|prefix| prefix.as_str().to_owned()),
)
.ok_or(Error::MissingNamespace)?
.to_owned();
for (prefix, attr, value) in self.attrs_stack.drain(..) {
let ns = if prefix == "xml" {
rxml::Namespace::xml()
} else {
&TreeBuilder::lookup_prefix(
&self.prefixes_stack,
&Some(prefix.to_string()),
)
.map(String::from)
.map(|s| TryInto::<Namespace>::try_into(s).unwrap())
.ok_or(Error::MissingNamespace)?
.to_owned()
};
attrs.insert(ns.clone(), attr.try_into().unwrap(), value.to_string());
}
let el = Element::new(name.to_owned(), namespace, prefixes, attrs, Vec::new());
self.stack.push(el);
}