|
| 1 | +use super::error::RendererError; |
| 2 | +use crate::custom_component_renderer::error::Result; |
| 3 | +use ego_tree::{NodeId, NodeMut, NodeRef, Tree}; |
| 4 | +use markup5ever::{namespace_url, ns, Attribute, LocalName, QualName}; |
| 5 | +use scraper::node::{Element, Text}; |
| 6 | +use scraper::Node; |
| 7 | + |
| 8 | +pub struct NodeManipulator<'a> { |
| 9 | + tree: &'a mut Tree<Node>, |
| 10 | + node_id: NodeId, |
| 11 | + append_children_builder: Option<AppendChildrenBuilder>, |
| 12 | +} |
| 13 | + |
| 14 | +impl<'a> NodeManipulator<'a> { |
| 15 | + pub fn new(tree: &'a mut Tree<Node>, node_id: NodeId) -> NodeManipulator<'a> { |
| 16 | + NodeManipulator { |
| 17 | + tree, |
| 18 | + node_id, |
| 19 | + append_children_builder: None, |
| 20 | + } |
| 21 | + } |
| 22 | + |
| 23 | + fn get_node(&'a self) -> Result<NodeRef<'a, Node>> { |
| 24 | + self.tree.get(self.node_id).ok_or_else(|| { |
| 25 | + RendererError::InternalError(format!("Node with id {:?} does not exist", self.node_id)) |
| 26 | + }) |
| 27 | + } |
| 28 | + |
| 29 | + fn get_node_mut(&mut self) -> Result<NodeMut<'_, Node>> { |
| 30 | + self.tree.get_mut(self.node_id).ok_or_else(|| { |
| 31 | + RendererError::InternalError(format!("Node with id {:?} does not exist", self.node_id)) |
| 32 | + }) |
| 33 | + } |
| 34 | + |
| 35 | + pub fn get_attribute(&self, attr: &str) -> Result<Option<&str>> { |
| 36 | + let node = self.get_node()?; |
| 37 | + match node.value() { |
| 38 | + Node::Element(element) => { |
| 39 | + let attr = element.attr(attr); |
| 40 | + Ok(attr) |
| 41 | + } |
| 42 | + _ => Err(RendererError::InternalError(format!( |
| 43 | + "Node with id {:?} is not an element", |
| 44 | + self.node_id |
| 45 | + ))), |
| 46 | + } |
| 47 | + } |
| 48 | + |
| 49 | + /// Appends a child node and returns the id of the inserted node id. |
| 50 | + pub fn append_child(&'a mut self, new_node: Node) -> Result<Self> { |
| 51 | + let mut node = self.get_node_mut()?; |
| 52 | + let inserted_id = node.append(new_node).id(); |
| 53 | + Ok(Self::new(self.tree, inserted_id)) |
| 54 | + } |
| 55 | + |
| 56 | + pub fn append_children(&mut self) -> &mut AppendChildrenBuilder { |
| 57 | + let builder = AppendChildrenBuilder::new(None); |
| 58 | + self.append_children_builder = Some(builder); |
| 59 | + self.append_children_builder.as_mut().unwrap() |
| 60 | + } |
| 61 | + |
| 62 | + fn build_children_impl(&mut self, builder: AppendChildrenBuilder) -> Result<()> { |
| 63 | + let mut node = self.get_node_mut()?; |
| 64 | + let mut builder_to_nodeid = Vec::new(); |
| 65 | + for mut child in builder.children { |
| 66 | + let inserted_id = node.append(child.value.take().unwrap()).id(); |
| 67 | + builder_to_nodeid.push((child, inserted_id)); |
| 68 | + } |
| 69 | + let original_node_id = self.node_id; |
| 70 | + for (child, inserted_id) in builder_to_nodeid { |
| 71 | + self.node_id = inserted_id; |
| 72 | + self.build_children_impl(child)?; |
| 73 | + } |
| 74 | + self.node_id = original_node_id; |
| 75 | + Ok(()) |
| 76 | + } |
| 77 | + |
| 78 | + pub fn build_children(&'a mut self) -> Result<()> { |
| 79 | + let builder = self.append_children_builder.take().ok_or_else(|| { |
| 80 | + RendererError::InternalError(String::from( |
| 81 | + "Missing children builder in build_children call", |
| 82 | + )) |
| 83 | + })?; |
| 84 | + self.build_children_impl(builder) |
| 85 | + } |
| 86 | + |
| 87 | + pub fn replace_with(mut self, new_node: Node) -> Result<Self> { |
| 88 | + let mut node = self.get_node_mut()?; |
| 89 | + let inserted_id = node.insert_after(new_node).id(); |
| 90 | + node.detach(); |
| 91 | + let Self { tree, .. } = self; |
| 92 | + Ok(Self::new(tree, inserted_id)) |
| 93 | + } |
| 94 | +} |
| 95 | + |
| 96 | +pub struct AppendChildrenBuilder { |
| 97 | + children: Vec<AppendChildrenBuilder>, |
| 98 | + value: Option<Node>, |
| 99 | +} |
| 100 | + |
| 101 | +impl AppendChildrenBuilder { |
| 102 | + fn new(value: Option<Node>) -> Self { |
| 103 | + Self { |
| 104 | + value, |
| 105 | + children: Vec::new(), |
| 106 | + } |
| 107 | + } |
| 108 | + |
| 109 | + pub fn append_child(&mut self, new_node: Node) -> &mut AppendChildrenBuilder { |
| 110 | + let new_builder = Self::new(Some(new_node)); |
| 111 | + self.children.push(new_builder); |
| 112 | + self.children.last_mut().unwrap() |
| 113 | + } |
| 114 | +} |
| 115 | + |
| 116 | +pub struct NodeAttribute { |
| 117 | + pub name: String, |
| 118 | + pub value: String, |
| 119 | +} |
| 120 | + |
| 121 | +impl NodeAttribute { |
| 122 | + pub fn new(name: &str, value: &str) -> Self { |
| 123 | + Self { |
| 124 | + name: String::from(name), |
| 125 | + value: String::from(value), |
| 126 | + } |
| 127 | + } |
| 128 | +} |
| 129 | + |
| 130 | +impl From<NodeAttribute> for Attribute { |
| 131 | + fn from(value: NodeAttribute) -> Self { |
| 132 | + Attribute { |
| 133 | + name: QualName::new(None, ns!(), LocalName::from(value.name)), |
| 134 | + value: value.value.into(), |
| 135 | + } |
| 136 | + } |
| 137 | +} |
| 138 | + |
| 139 | +pub fn create_node(name: &str, attributes: Vec<NodeAttribute>) -> Node { |
| 140 | + Node::Element(Element::new( |
| 141 | + QualName::new(None, ns!(), LocalName::from(name)), |
| 142 | + attributes.into_iter().map(Into::into).collect(), |
| 143 | + )) |
| 144 | +} |
| 145 | + |
| 146 | +pub fn create_text_node(text: &str) -> Node { |
| 147 | + Node::Text(Text { text: text.into() }) |
| 148 | +} |
0 commit comments