feat: impl IntoIterator for AttributeMap

Making this change made me realize that adding an
`impl IntoIterator for T` can be a breaking change if
`impl IntoIterator for &T` already exists.

See also the cargo-semver-checks issue[1] I filed about that.

[1]: https://github.com/obi1kenobi/cargo-semver-checks/issues/518

2 files changed, 41 insertions, 1 deletions

diff --git a/integration_tests/tests/test_html5lib.rs b/integration_tests/tests/test_html5lib.rs
index a624c30..a0e934f 100644
--- a/integration_tests/tests/test_html5lib.rs
+++ b/integration_tests/tests/test_html5lib.rs
@@ -129,7 +129,7 @@ fn run_test_inner<R: Reader>(
                 attributes: tag
                     .attributes
                     .into_iter()
-                    .map(|attr| (attr.name().to_owned(), attr.value().to_owned()))
+                    .map(|attr| (attr.name, attr.value))
                     .collect(),
                 self_closing: tag.self_closing,
             }),
diff --git a/src/attr.rs b/src/attr.rs
index 9e4c984..a56eb95 100644
--- a/src/attr.rs
+++ b/src/attr.rs
@@ -41,6 +41,19 @@ pub struct Attribute<'a, O> {
     map_val: &'a AttrInternal<O>,
 }
 
+/// An owned HTML attribute.
+#[derive(Debug, PartialEq, Eq)]
+pub struct AttributeOwned<O> {
+    /// The attribute name.
+    pub name: String,
+    /// The attribute value.
+    pub value: String,
+    /// The start offset of the attribute name.
+    pub name_offset: O,
+    /// The start offset of the attribute value.
+    pub value_offset: O, // TODO: wrap this in an Option once we can recognize the empty attribute syntax
+}
+
 impl<O> AttributeMap<O> {
     /// Returns the attribute with the given name.
     pub fn get(&self, name: &str) -> Option<Attribute<O>> {
@@ -82,6 +95,33 @@ impl<O> Index<&str> for AttributeMap<O> {
     }
 }
 
+impl<O> IntoIterator for AttributeMap<O> {
+    type Item = AttributeOwned<O>;
+
+    type IntoIter = AttrIntoIter<O>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        AttrIntoIter(self.inner.into_iter())
+    }
+}
+
+/// A consuming iterator over the attributes of an [`AttributeMap`].
+pub struct AttrIntoIter<O>(btree_map::IntoIter<String, AttrInternal<O>>);
+
+impl<O> Iterator for AttrIntoIter<O> {
+    type Item = AttributeOwned<O>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let (name, map_val) = self.0.next()?;
+        Some(AttributeOwned {
+            name,
+            value: map_val.value,
+            name_offset: map_val.name_offset,
+            value_offset: map_val.value_offset,
+        })
+    }
+}
+
 impl<'a, O> IntoIterator for &'a AttributeMap<O> {
     type Item = Attribute<'a, O>;