switch to Cow

this allows, thanks to the ownable crate, deep copies
while only referencing the original (and other stuff)

Author: alexkazik

Cargo.lock

@@ -16,6 +16,7 @@ pest_derive = "2.5.7"
 thiserror = "1.0.40"
 serde = { version = "1.0.159", features = ["derive"] }
 serde_json = "1.0.95"
+ownable = "1.0.0"
 
 [features]
 default = ["source-span"]

Cargo.toml

@@ -1,4 +1,6 @@
 use html_parser::{Dom, Node, Result};
+use ownable::traits::ToBorrowed;
+use std::ops::Deref;
 
 // This example illustrates how to use the library to get all of the anchor-hrefs from a document.
 
@@ -8,13 +10,13 @@ fn main() -> Result<()> {
     let iter = dom.children.first().unwrap().into_iter();
 
     let hrefs = iter.filter_map(|item| match item {
-        Node::Element(element) if element.name == "a" => element.attributes["href"].clone(),
+        Node::Element(element) if element.name == "a" => element.attributes["href"].to_borrowed(),
         _ => None,
     });
 
     println!("\nThe following links where found:");
     for (index, href) in hrefs.enumerate() {
-        println!("{}: {}", index + 1, href)
+        println!("{}: {}", index + 1, href.deref())
     }
 
     Ok(())

examples/get_all_href/main.rs

@@ -1,9 +1,11 @@
 use super::node::Node;
 #[cfg(feature = "source-span")]
 use super::span::SourceSpan;
-use crate::VecSet;
 use crate::dom::vecmap::VecMap;
+use crate::{Attribute, VecSet};
+use ownable::{IntoOwned, ToBorrowed, ToOwned};
 use serde::Serialize;
+use std::borrow::Cow;
 use std::default::Default;
 
 /// Normal: `<div></div>` or Void: `<meta/>`and `<meta>`
@@ -17,48 +19,49 @@ pub enum ElementVariant {
     Void,
 }
 
-pub type Attributes = VecMap<String, Option<String>>;
+pub type Attributes<'a> = VecMap<Cow<'a, str>, Option<Attribute<'a>>>;
 
 /// Most of the parsed html nodes are elements, except for text
-#[derive(Debug, Clone, Serialize, PartialEq)]
+#[derive(Debug, Serialize, PartialEq, IntoOwned, ToBorrowed, ToOwned)]
 #[serde(rename_all = "camelCase")]
-pub struct Element {
+pub struct Element<'a> {
     /// The id of the element
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub id: Option<String>,
+    pub id: Option<Attribute<'a>>,
 
     /// The name / tag of the element
-    pub name: String,
+    pub name: Cow<'a, str>,
 
     /// The element variant, if it is of type void or not
+    #[ownable(clone)]
     pub variant: ElementVariant,
 
     /// All of the elements attributes, except id and class
     #[serde(skip_serializing_if = "VecMap::is_empty")]
-    pub attributes: Attributes,
+    pub attributes: Attributes<'a>,
 
     /// All of the elements classes
     #[serde(skip_serializing_if = "VecSet::is_empty")]
-    pub classes: VecSet<String>,
+    pub classes: VecSet<Attribute<'a>>,
 
     /// All of the elements child nodes
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub children: Vec<Node>,
+    pub children: Vec<Node<'a>>,
 
     #[cfg(feature = "source-span")]
     /// Span of the element in the parsed source
     #[serde(skip)]
-    pub source_span: SourceSpan,
+    pub source_span: SourceSpan<'a>,
 }
 
-impl Default for Element {
+impl Default for Element<'static> {
     fn default() -> Self {
         Self {
             id: None,
-            name: "".to_string(),
+            name: "".into(),
             variant: ElementVariant::Void,
-            classes: VecSet::default(),
-            attributes: VecMap::default(),
+            classes: Default::default(),
+            attributes: Default::default(),
             children: vec![],
             #[cfg(feature = "source-span")]
             source_span: SourceSpan::default(),

src/dom/element.rs

@@ -5,7 +5,7 @@ use pest::error::Error as PestError;
 
 /// This function abstracts the formatting of errors away from the core logic inside parser,
 /// so that the file is easier to read.
-pub fn error_msg(error: PestError<Rule>) -> Result<super::Dom> {
+pub fn error_msg(error: PestError<Rule>) -> Result<super::Dom<'static>> {
     let message = error.renamed_rules(|rule| match *rule {
         Rule::EOI => "end of input".to_string(),
         Rule::doctype => "doctype element".to_string(),

src/dom/formatting.rs

@@ -0,0 +1,95 @@
+use ownable::{IntoOwned, ToBorrowed, ToOwned};
+use serde::Serialize;
+use std::borrow::{Borrow, Cow};
+use std::fmt::{Debug, Formatter};
+use std::ops::Deref;
+
+#[derive(Default, Debug, Serialize, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
+#[serde(transparent)]
+pub struct Attribute<'a>(pub Cow<'a, str>);
+
+impl<'a> Attribute<'a> {
+    pub fn as_str(&self) -> &str {
+        self.0.borrow()
+    }
+}
+
+impl<S: Into<Cow<'static, str>>> From<S> for Attribute<'static> {
+    fn from(value: S) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<'a> Deref for Attribute<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl<'a> PartialEq<str> for Attribute<'a> {
+    fn eq(&self, other: &str) -> bool {
+        self.deref().eq(other)
+    }
+}
+
+impl<'a> PartialEq<&str> for Attribute<'a> {
+    fn eq(&self, other: &&str) -> bool {
+        self.deref().eq(*other)
+    }
+}
+
+impl<'a> PartialEq<str> for &Attribute<'a> {
+    fn eq(&self, other: &str) -> bool {
+        (*self).deref().eq(other)
+    }
+}
+
+#[derive(Default, Serialize, PartialEq, Eq, IntoOwned, ToBorrowed, ToOwned)]
+#[serde(transparent)]
+pub struct Text<'a>(pub Cow<'a, str>);
+
+impl<'a> Text<'a> {
+    pub fn as_str(&self) -> &str {
+        self.0.borrow()
+    }
+}
+
+impl Debug for Text<'_> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.as_str().fmt(f)
+    }
+}
+
+impl<S: Into<Cow<'static, str>>> From<S> for Text<'static> {
+    fn from(value: S) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<'a> Deref for Text<'a> {
+    type Target = str;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
+    }
+}
+
+impl<'a> PartialEq<str> for Text<'a> {
+    fn eq(&self, other: &str) -> bool {
+        self.deref().eq(other)
+    }
+}
+
+impl<'a> PartialEq<&str> for Text<'a> {
+    fn eq(&self, other: &&str) -> bool {
+        self.deref().eq(*other)
+    }
+}
+
+impl<'a> PartialEq<str> for &Text<'a> {
+    fn eq(&self, other: &str) -> bool {
+        (*self).deref().eq(other)
+    }
+}