feat: allow keeping templates as they are

ctron · ctron · commit aed7ca4db869 · 2024-03-20T09:05:06.000+01:00
In some cases the <template> tags should not be replaced, but kept as they are. This allows Closes: trunk-rs/trunk#742
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,5 @@
 /target
 **/*.rs.bk
 Cargo.lock
-*.go
+*.go
+/.idea
diff --git a/src/document.rs b/src/document.rs
@@ -15,6 +15,21 @@ use std::collections::HashSet;
 use tendril::StrTendril;
 use tendril::TendrilSink;
 
+#[derive(Clone, Debug, Default)]
+#[non_exhaustive]
+/// Parser options
+pub struct ParseOptions {
+    /// Keep the content of `<template>` tags in place.
+    pub keep_templates: bool,
+}
+
+impl ParseOptions {
+    pub fn keep_templates(mut self, keep_templates: bool) -> Self {
+        self.keep_templates = keep_templates;
+        self
+    }
+}
+
 /// Document represents an HTML document to be manipulated.
 pub struct Document {
     /// The document's dom tree.
@@ -25,6 +40,9 @@ pub struct Document {
 
     /// The document's quirks mode.
     pub quirks_mode: QuirksMode,
+
+    /// Keep content of templates
+    pub keep_templates: bool,
 }
 
 impl Default for Document {
@@ -33,6 +51,7 @@ impl Default for Document {
             tree: Tree::new(NodeData::Document),
             errors: vec![],
             quirks_mode: tree_builder::NoQuirks,
+            keep_templates: false,
         }
     }
 }
@@ -60,6 +79,23 @@ impl Document {
     pub fn root(&self) -> NodeRef<NodeData> {
         self.tree.root()
     }
+
+    /// Parse a document allowing to provide additional options
+    pub fn parse<S>(options: ParseOptions, html: S) -> Self
+    where
+        S: AsRef<str>,
+    {
+        let ParseOptions { keep_templates } = options;
+
+        parse_document(
+            Document {
+                keep_templates,
+                ..Document::default()
+            },
+            Default::default(),
+        )
+        .one(html.as_ref())
+    }
 }
 
 impl TreeSink for Document {
@@ -87,14 +123,19 @@ impl TreeSink for Document {
 
     // Get a handle to a template's template contents. The tree builder promises this will never be called with
     // something else than a template element.
+    // If templates are kept in place, return the actual node id.
     fn get_template_contents(&mut self, target: &NodeId) -> NodeId {
-        self.tree.query_node(target, |node| match node.data {
-            NodeData::Element(Element {
-                template_contents: Some(ref contents),
-                ..
-            }) => contents.clone(),
-            _ => panic!("not a template element!"),
-        })
+        if self.keep_templates {
+            target.clone()
+        } else {
+            self.tree.query_node(target, |node| match node.data {
+                NodeData::Element(Element {
+                    template_contents: Some(ref contents),
+                    ..
+                }) => contents.clone(),
+                _ => panic!("not a template element!"),
+            })
+        }
     }
 
     // Set the document's quirks mode.
@@ -126,7 +167,7 @@ impl TreeSink for Document {
         attrs: Vec<Attribute>,
         flags: ElementFlags,
     ) -> NodeId {
-        let template_contents = if flags.template {
+        let template_contents = if !self.keep_templates && flags.template {
             Some(self.tree.create_node(NodeData::Document))
         } else {
             None
@@ -282,6 +323,12 @@ impl TreeSink for Document {
     }
 }
 
+impl Document {
+    pub fn get_node(&self, id: &NodeId) -> NodeData {
+        self.tree.query_node(id, |node| node.data.clone())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/src/lib.rs b/src/lib.rs
@@ -38,6 +38,7 @@ mod selection;
 mod traversal;
 
 pub use document::Document;
+pub use document::ParseOptions;
 pub use dom_tree::Node;
 #[doc(hidden)]
 pub use dom_tree::NodeId;
diff --git a/tests/templates.rs b/tests/templates.rs
@@ -0,0 +1,45 @@
+use markup5ever::interface::TreeSink;
+use nipper::{Document, ParseOptions};
+
+#[test]
+fn test_templates() {
+    let mut doc = Document::parse(
+        ParseOptions {
+            keep_templates: true,
+        },
+        r#"
+<html>
+    <body>
+        <template>
+            <p>Hello world!</p>
+        </template>
+    </body>
+</html>
+"#,
+    );
+
+    let nodes = doc
+        .select("template")
+        .nodes()
+        .iter()
+        .map(|n| n.id)
+        .collect::<Vec<_>>();
+    for node in nodes {
+        let c = doc.get_template_contents(&node);
+        println!("Node: {c:?}");
+        let data = doc.get_node(&node);
+        println!("Data: {data:?}");
+    }
+
+    let result = doc.html().to_string();
+    assert_eq!(
+        result,
+        r#"<html><head></head><body>
+        <template>
+            <p>Hello world!</p>
+        </template>
+    
+
+</body></html>"#
+    );
+}
