use crate::dom::{Attr, AttrNs, Data, Document, Element, NONE, Name, NodeId, Ns, Span};
use crate::tags::Tag;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EditError {
Cycle,
NotAParent,
NotAChild,
NotInsertable,
Removed,
NotAShadowHost,
}
impl std::fmt::Display for EditError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(match self {
EditError::Cycle => "a node can't be inserted into itself or its descendants",
EditError::NotAParent => "only an element, a document or a fragment can have children",
EditError::NotAChild => "the node to insert before isn't a child of the parent",
EditError::NotInsertable => {
"a document, fragment or shadow root can't be inserted, only its children"
}
EditError::Removed => {
"the node was removed from its document, so it can't be used again"
}
EditError::NotAShadowHost => "the element can't have a shadow root, or has one",
})
}
}
impl std::error::Error for EditError {}
impl Document {
pub fn create_element(&mut self, ns: Ns, name: &str) -> NodeId {
let (tag, name) = self.name_element(ns, name);
let at = self.attrs.len() as u32;
let contents = if ns == Ns::Html && tag == Tag::Template {
self.add(Data::Fragment)
} else {
NONE
};
let id = self.add(Data::Element(Element {
ns,
tag,
name,
attrs: Span { start: at, end: at },
contents,
html_integration: false,
}));
if contents != NONE
&& let Some(hosts) = &mut self.hosts
{
hosts.insert(contents, id);
}
id
}
pub fn create_text(&mut self, text: &str) -> NodeId {
let span = self.push_stable(text);
self.add(Data::Text(span))
}
pub fn create_cdata(&mut self, text: &str) -> NodeId {
let span = self.push_stable(text);
self.add(Data::Cdata(span))
}
pub fn create_comment(&mut self, text: &str) -> NodeId {
let span = self.push_stable(text);
self.add(Data::Comment(span))
}
pub fn create_processing_instruction(&mut self, target: &str, data: &str) -> NodeId {
let target = self.push_stable(target);
let data = self.push_stable(data);
self.add(Data::ProcessingInstruction { target, data })
}
pub fn create_doctype(&mut self, name: &str, public_id: &str, system_id: &str) -> NodeId {
let name = self.push_stable(name);
let public_id = self.push_stable(public_id);
let system_id = self.push_stable(system_id);
self.add(Data::Doctype {
name,
public_id,
system_id,
})
}
pub fn append(&mut self, parent: NodeId, child: NodeId) -> Result<(), EditError> {
self.insert_before(parent, child, None)
}
pub fn insert_before(
&mut self,
parent: NodeId,
child: NodeId,
before: Option<NodeId>,
) -> Result<(), EditError> {
if self.is_removed(parent)
|| self.is_removed(child)
|| before.is_some_and(|b| self.is_removed(b))
{
return Err(EditError::Removed);
}
if !matches!(
self.nodes[parent as usize].data,
Data::Element(_) | Data::Document | Data::Fragment | Data::ShadowRoot { .. }
) {
return Err(EditError::NotAParent);
}
if matches!(
self.nodes[child as usize].data,
Data::Document | Data::Fragment | Data::ShadowRoot { .. }
) {
return Err(EditError::NotInsertable);
}
if let Some(b) = before
&& self.parent(b) != Some(parent)
{
return Err(EditError::NotAChild);
}
let mut at = Some(parent);
while let Some(a) = at {
if a == child {
return Err(EditError::Cycle);
}
at = self.parent(a).or_else(|| self.host(a));
}
if before == Some(child) {
return Ok(());
}
self.detach(child);
self.insert(parent, child, before.unwrap_or(NONE));
Ok(())
}
fn host(&mut self, fragment: NodeId) -> Option<NodeId> {
if let Data::ShadowRoot { host, .. } = self.nodes[fragment as usize].data {
return Some(host);
}
if !matches!(self.nodes[fragment as usize].data, Data::Fragment) {
return None;
}
let nodes = &self.nodes;
self.hosts
.get_or_insert_with(|| {
(0..nodes.len() as NodeId)
.filter_map(|id| match nodes[id as usize].data {
Data::Element(e) if e.contents != NONE => Some((e.contents, id)),
_ => None,
})
.collect()
})
.get(&fragment)
.copied()
.inspect(|&t| {
debug_assert!(
self.element(t).is_some_and(|e| e.contents == fragment),
"the hosts map says {t} holds {fragment}, which it doesn't"
)
})
}
pub fn adopt_template_contents(&mut self) {
for id in 0..self.nodes.len() as NodeId {
let Data::Element(e) = self.nodes[id as usize].data else {
continue;
};
if e.ns != Ns::Html || e.tag != Tag::Template || e.contents == NONE {
continue;
}
if self.is_removed(id) {
continue;
}
while let Some(child) = self.first_child(e.contents) {
self.detach(child);
self.insert(id, child, NONE);
}
}
}
pub fn remove(&mut self, id: NodeId) {
if matches!(
self.nodes[id as usize].data,
Data::Document | Data::Fragment | Data::ShadowRoot { .. }
) || self.is_removed(id)
{
return;
}
self.detach(id);
let mut stack = vec![id];
while let Some(n) = stack.pop() {
self.mark_removed(n);
let node = &self.nodes[n as usize];
if let Data::Element(e) = &node.data
&& e.contents != NONE
{
stack.push(e.contents);
}
if let Some(&shadow) = self.shadow_roots.get(&n) {
stack.push(shadow);
}
let mut c = node.first_child;
while c != NONE {
stack.push(c);
c = self.nodes[c as usize].next;
}
}
}
pub fn set_attr(&mut self, id: NodeId, name: &str, value: &str) {
if self.is_removed(id) {
return;
}
let Some(e) = self.element(id) else { return };
let ns = e.ns;
let given = name;
let name = stored_attr_name(ns, given);
let value = self.push_stable(value);
let name_span = self.push_stable(&name);
self.rewrite_attrs(id, |doc, attrs| {
match attrs.iter_mut().find(|a| doc.is_attr(ns, a, &name, given)) {
Some(a) => a.value = value,
None => attrs.push(Attr {
ns: AttrNs::None,
name: name_span,
value,
}),
}
true
});
}
pub fn add_attr(&mut self, id: NodeId, ns: AttrNs, name: &str, value: &str) {
if self.is_removed(id) {
return;
}
let name = self.push_stable(name);
let value = self.push_stable(value);
let attr = Attr { ns, name, value };
let len = self.attrs.len() as u32;
if let Data::Element(e) = &mut self.nodes[id as usize].data
&& e.attrs.end == len
{
e.attrs.end += 1;
self.attrs.push(attr);
return;
}
self.rewrite_attrs(id, |_, attrs| {
attrs.push(attr);
true
});
}
pub fn set_attrs(&mut self, id: NodeId, attrs: &[(AttrNs, &str, &str)]) {
if self.is_removed(id) {
return;
}
if self.element(id).is_none() {
return;
}
let start = self.attrs.len() as u32;
for &(ns, name, value) in attrs {
let name = self.push_stable(name);
let value = self.push_stable(value);
self.attrs.push(Attr { ns, name, value });
}
let end = self.attrs.len() as u32;
if let Data::Element(e) = &mut self.nodes[id as usize].data {
e.attrs = Span { start, end };
}
}
pub fn rename(&mut self, id: NodeId, name: &str) {
if self.is_removed(id) {
return;
}
let Some(e) = self.element(id).copied() else {
return;
};
let (tag, new) = self.name_element(e.ns, name);
let template = e.ns == Ns::Html && tag == Tag::Template;
let contents = if template && e.contents == NONE {
let contents = self.add(Data::Fragment);
if let Some(hosts) = &mut self.hosts {
hosts.insert(contents, id);
}
contents
} else if !template && e.contents != NONE {
let first = self.first_child(id).unwrap_or(NONE);
while let Some(child) = self.first_child(e.contents) {
self.detach(child);
self.insert(id, child, first);
}
if let Some(hosts) = &mut self.hosts {
hosts.remove(&e.contents);
}
NONE
} else {
e.contents
};
if let Data::Element(e) = &mut self.nodes[id as usize].data {
e.tag = tag;
e.name = new;
e.contents = contents;
}
}
fn name_element(&mut self, ns: Ns, name: &str) -> (Tag, Name) {
let lower = name.to_ascii_lowercase();
match ns {
Ns::Html => {
let tag = Tag::from_name(&lower);
let name = if tag == Tag::Other {
Name::Span(self.push_stable(&lower))
} else {
Name::Tag
};
(tag, name)
}
Ns::Xml => (Tag::Other, Name::Span(self.push_stable(name))),
_ => {
let tag = Tag::from_name(&lower);
if ns == Ns::Svg
&& let Some(i) = crate::tree::svg_tag_name(&lower)
&& crate::tree::SVG_TAG_NAMES[i as usize].1 == name
{
return (tag, Name::Svg(i));
}
let name = if tag != Tag::Other && tag.name() == name {
Name::Tag
} else {
Name::Span(self.push_stable(name))
};
(tag, name)
}
}
}
pub fn rename_attr(&mut self, id: NodeId, index: usize, ns: AttrNs, name: &str) {
if self.is_removed(id) {
return;
}
let name = self.push_stable(name);
self.rewrite_attrs(id, |_, attrs| match attrs.get_mut(index) {
Some(a) => {
a.ns = ns;
a.name = name;
true
}
None => false,
});
}
pub fn remove_attr_at(&mut self, id: NodeId, index: usize) -> bool {
if self.is_removed(id) {
return false;
}
self.rewrite_attrs(id, |_, attrs| {
if index < attrs.len() {
attrs.remove(index);
true
} else {
false
}
})
}
pub fn remove_attr(&mut self, id: NodeId, name: &str) -> bool {
if self.is_removed(id) {
return false;
}
let Some(e) = self.element(id) else {
return false;
};
let (ns, given) = (e.ns, name);
let name = stored_attr_name(ns, given);
self.rewrite_attrs(id, |doc, attrs| {
let before = attrs.len();
attrs.retain(|a| !doc.is_attr(ns, a, &name, given));
attrs.len() != before
})
}
fn is_attr(&self, ns: Ns, a: &Attr, stored: &str, given: &str) -> bool {
(a.ns == AttrNs::None && self.str(a.name) == stored)
|| (ns != Ns::Html && self.written_name(ns, a) == given)
}
fn rewrite_attrs(
&mut self,
id: NodeId,
change: impl FnOnce(&Document, &mut Vec<Attr>) -> bool,
) -> bool {
let Some(e) = self.element(id) else {
return false;
};
let mut attrs = self.attrs[e.attrs.start as usize..e.attrs.end as usize].to_vec();
if !change(self, &mut attrs) {
return false;
}
let start = self.attrs.len() as u32;
self.attrs.extend(attrs);
let end = self.attrs.len() as u32;
if let Data::Element(e) = &mut self.nodes[id as usize].data {
e.attrs = Span { start, end };
}
true
}
}
fn stored_attr_name(ns: Ns, given: &str) -> String {
let lower = given.to_ascii_lowercase();
let restored = match ns {
Ns::Html => true,
Ns::Svg => crate::tree::svg_attr_name(&lower) == Some(given),
Ns::MathMl => lower == "definitionurl" && given == "definitionURL",
Ns::Xml => false,
};
if restored { lower } else { given.to_string() }
}
#[cfg(test)]
mod tests {
use super::EditError;
use crate::{NodeId, Ns, parse, parse_fragment};
#[test]
fn nodes_can_be_made_moved_and_removed() {
let mut doc = parse_fragment("<p>a</p><p>b</p>", Ns::Html, "div", false);
let (first, second) = {
let mut c = doc.children(0);
(c.next().unwrap(), c.next().unwrap())
};
let em = doc.create_element(Ns::Html, "EM");
let t = doc.create_text("x & y");
doc.append(em, t).unwrap();
doc.insert_before(first, em, doc.first_child(first))
.unwrap();
assert_eq!(doc.inner_html(0), "<p><em>x & y</em>a</p><p>b</p>");
doc.append(second, em).unwrap();
assert_eq!(doc.inner_html(0), "<p>a</p><p>b<em>x & y</em></p>");
doc.detach(second);
assert_eq!(doc.inner_html(0), "<p>a</p>");
doc.append(0, second).unwrap();
assert_eq!(doc.inner_html(0), "<p>a</p><p>b<em>x & y</em></p>");
}
#[cfg(debug_assertions)]
#[test]
fn edits_keep_every_invariant() {
let mut doc = parse(
"<div><p>a<b>b</b></p><template><i>c</i></template><ul><li>d</ul></div>",
false,
);
let mut seed: u32 = 0x2545_f491;
let mut next = move |n: usize| {
seed ^= seed << 13;
seed ^= seed >> 17;
seed ^= seed << 5;
seed as usize % n
};
for i in 0..2000 {
let n = doc.len();
let (a, b) = (next(n) as NodeId, next(n) as NodeId);
match next(6) {
0 => {
let _ = doc.append(a, b);
}
1 => {
let before = doc.first_child(a);
let _ = doc.insert_before(a, b, before);
}
2 if i % 2 == 0 => doc.remove(b),
2 => doc.detach(b),
3 => doc.rename(a, if i % 2 == 0 { "template" } else { "span" }),
4 => {
let t = doc.create_element(Ns::Html, "template");
let _ = doc.append(a, t);
}
_ => {
let t = doc.create_text("t");
let _ = doc.append(a, t);
}
}
doc.check_tree();
}
}
#[test]
fn a_created_svg_element_is_named_as_a_parsed_one() {
let parsed = parse_fragment("<svg><linearGradient/></svg>", Ns::Html, "div", false);
let svg = parsed.children(parsed.root()).next().unwrap();
let parsed_gradient = parsed.children(svg).next().unwrap();
let mut doc = parse_fragment("", Ns::Html, "div", false);
let made = doc.create_element(Ns::Svg, "linearGradient");
assert_eq!(doc.lower_name(made), Some("lineargradient"));
assert_eq!(doc.lower_name(made), parsed.lower_name(parsed_gradient));
assert_eq!(doc.outer_html(made), parsed.outer_html(parsed_gradient));
let shouting = doc.create_element(Ns::Svg, "LINEARGRADIENT");
assert_eq!(
doc.outer_html(shouting),
"<LINEARGRADIENT></LINEARGRADIENT>"
);
}
#[test]
fn a_document_or_fragment_is_never_inserted() {
let mut doc = parse("<template><b>x</b></template><p>y</p>", false);
let root = doc.root();
let contents = (0..doc.len() as NodeId)
.find_map(|n| doc.template_contents(n))
.unwrap();
let loose = doc.create_element(Ns::Html, "div");
let before = doc.inner_html(root);
assert_eq!(doc.append(loose, root), Err(EditError::NotInsertable));
assert_eq!(doc.append(loose, contents), Err(EditError::NotInsertable));
assert_eq!(
doc.insert_before(loose, root, None),
Err(EditError::NotInsertable)
);
assert_eq!(doc.inner_html(root), before);
assert_eq!(doc.inner_html(loose), "");
let b = doc.first_child(contents).unwrap();
assert_eq!(doc.append(loose, b), Ok(()));
assert_eq!(doc.inner_html(loose), "<b>x</b>");
}
#[test]
fn set_attr_replaces_a_namespaced_attribute_of_the_same_name() {
let mut doc = parse_fragment(
"<svg><use xlink:href=\"#a\"></use></svg>",
Ns::Html,
"div",
false,
);
let svg = doc.children(doc.root()).next().unwrap();
let used = doc.children(svg).next().unwrap();
doc.set_attr(used, "xlink:href", "#b");
assert_eq!(doc.outer_html(used), "<use xlink:href=\"#b\"></use>");
let attrs: Vec<_> = doc.attrs(used).collect();
assert_eq!(attrs, [(crate::AttrNs::XLink, "href", "#b")]);
assert!(!doc.remove_attr(used, "href"));
doc.set_attr(used, "href", "#c");
let attrs: Vec<_> = doc.attrs(used).collect();
assert_eq!(
attrs,
[
(crate::AttrNs::XLink, "href", "#b"),
(crate::AttrNs::None, "href", "#c")
]
);
assert!(doc.remove_attr(used, "href"));
let attrs: Vec<_> = doc.attrs(used).collect();
assert_eq!(attrs, [(crate::AttrNs::XLink, "href", "#b")]);
}
#[test]
fn set_attr_keeps_the_case_of_foreign_names() {
let mut doc = parse_fragment(
"<svg viewBox=\"0 0 1 1\"></svg><math definitionURL=\"a\"></math><p></p>",
Ns::Html,
"div",
false,
);
let kids: Vec<_> = doc.children(doc.root()).collect();
let (svg, math, p) = (kids[0], kids[1], kids[2]);
doc.set_attr(svg, "dataFoo", "x");
doc.set_attr(svg, "viewBox", "0 0 2 2");
doc.set_attr(math, "mathVariant", "bold");
doc.set_attr(math, "definitionURL", "b");
doc.set_attr(p, "DATA-X", "y");
assert_eq!(
doc.outer_html(svg),
"<svg viewBox=\"0 0 2 2\" dataFoo=\"x\"></svg>"
);
assert_eq!(
doc.outer_html(math),
"<math definitionURL=\"b\" mathVariant=\"bold\"></math>"
);
assert_eq!(doc.outer_html(p), "<p data-x=\"y\"></p>");
doc.set_attr(svg, "viewbox", "0 0 3 3");
assert_eq!(
doc.outer_html(svg),
"<svg viewBox=\"0 0 3 3\" dataFoo=\"x\"></svg>"
);
doc.set_attr(svg, "dataFoo", "z");
assert_eq!(
doc.outer_html(svg),
"<svg viewBox=\"0 0 3 3\" dataFoo=\"z\"></svg>"
);
assert!(doc.remove_attr(svg, "dataFoo"));
assert!(doc.remove_attr(svg, "viewBox"));
assert!(doc.remove_attr(math, "mathVariant"));
assert!(!doc.remove_attr(svg, "dataFoo"));
assert_eq!(doc.outer_html(svg), "<svg></svg>");
assert_eq!(doc.outer_html(math), "<math definitionURL=\"b\"></math>");
}
#[test]
fn renaming_to_or_from_template_adds_or_gives_up_its_contents() {
let mut doc = parse_fragment("<template><b>x</b>y</template>", Ns::Html, "div", false);
let t = doc.first_child(doc.root()).unwrap();
doc.rename(t, "div");
assert_eq!(doc.template_contents(t), None);
assert_eq!(doc.outer_html(t), "<div><b>x</b>y</div>");
doc.rename(t, "template");
let contents = doc.template_contents(t).expect("new contents");
assert_eq!(doc.first_child(contents), None);
assert_eq!(doc.outer_html(t), "<template><b>x</b>y</template>");
let p = doc.create_element(Ns::Html, "p");
doc.append(contents, p).unwrap();
doc.rename(t, "section");
assert_eq!(doc.outer_html(t), "<section><p></p><b>x</b>y</section>");
let u = doc.create_element(Ns::Html, "template");
let kept = doc.template_contents(u);
doc.rename(u, "TEMPLATE");
assert_eq!(doc.template_contents(u), kept);
}
#[test]
fn a_renamed_foreign_element_takes_its_new_names_tag() {
let mut doc = parse_fragment("", Ns::Html, "div", false);
let svg_title = doc.create_element(Ns::Svg, "title");
let title_tag = doc.known_tag(svg_title);
assert!(title_tag.is_some());
let n = doc.create_element(Ns::Svg, "rect");
doc.rename(n, "title");
assert_eq!(doc.known_tag(n), title_tag);
doc.rename(n, "rect");
assert_eq!(doc.known_tag(n), None);
}
#[test]
fn template_contents_can_become_children() {
let mut doc = parse_fragment("<template><b>x</b></template>", Ns::Html, "div", false);
let t = doc.first_child(0).unwrap();
assert_eq!(doc.first_child(t), None);
doc.adopt_template_contents();
let b = doc.first_child(t).unwrap();
assert_eq!(doc.outer_html(b), "<b>x</b>");
assert_eq!(doc.inner_html(0), "<template><b>x</b></template>");
}
#[test]
fn edits_never_move_strings_already_read() {
let mut doc = parse_fragment("<a href='x&y'>t&u</a>", Ns::Html, "div", false);
let a = doc.first_child(0).unwrap();
let text = doc.first_child(a).unwrap();
let href = doc.attrs(a).next().unwrap().2.as_ptr();
let data = match doc.kind(text) {
crate::Kind::Text(t) => t.as_ptr(),
_ => unreachable!(),
};
for i in 0..10_000 {
let n = doc.create_element(Ns::Html, &format!("custom-{i}"));
doc.set_attr(n, "data-long", &"y".repeat(100));
let t = doc.create_text(&"z".repeat(100));
doc.append(n, t).unwrap();
doc.append(0, n).unwrap();
}
doc.set_attr(a, "title", "new");
assert_eq!(doc.attrs(a).next().unwrap().2.as_ptr(), href);
assert!(matches!(doc.kind(text), crate::Kind::Text(t) if t.as_ptr() == data));
}
#[test]
fn xml_is_built_as_written_and_matched_as_netweir_did() {
use crate::css::SelectorList;
use crate::{AttrNs, Document};
let mut doc = Document::empty();
let feed = doc.create_element(Ns::Xml, "Feed");
doc.append(0, feed).unwrap();
let entry = doc.create_element(Ns::Xml, "dc:Creator");
doc.add_attr(entry, AttrNs::None, "ID", "up");
doc.add_attr(entry, AttrNs::None, "id", "lo");
doc.add_attr(entry, AttrNs::Host(3), "x:href", "/p");
doc.append(feed, entry).unwrap();
let cdata = doc.create_cdata("<raw>");
doc.append(entry, cdata).unwrap();
let found = |css: &str| SelectorList::parse(css).unwrap().select(&doc, 0).len();
assert_eq!(found("feed creator"), 1);
assert_eq!(found("[id=lo]"), 1);
assert_eq!(found("[id=up]"), 0);
assert_eq!(found("#lo"), 1);
assert_eq!(found("#up"), 0);
assert_eq!(found("[href^='/']"), 1);
assert_eq!(
doc.outer_html(entry),
"<dc:Creator ID=\"up\" id=\"lo\" x:href=\"/p\"><![CDATA[<raw>]]></dc:Creator>"
);
doc.rename(entry, "Creator");
doc.rename_attr(entry, 2, AttrNs::None, "href");
assert!(doc.remove_attr_at(entry, 0));
assert_eq!(
doc.outer_html(entry),
"<Creator id=\"lo\" href=\"/p\"><![CDATA[<raw>]]></Creator>"
);
}
#[test]
fn a_node_cant_go_inside_itself() {
let mut doc = parse_fragment("<div><span></span></div>", Ns::Html, "body", false);
let div = doc.first_child(0).unwrap();
let span = doc.first_child(div).unwrap();
assert_eq!(doc.append(span, div), Err(EditError::Cycle));
assert_eq!(doc.append(div, div), Err(EditError::Cycle));
let text = doc.create_text("t");
assert_eq!(doc.append(text, span), Err(EditError::NotAParent));
assert_eq!(
doc.insert_before(span, text, Some(div)),
Err(EditError::NotAChild)
);
}
#[test]
fn a_template_cant_go_inside_its_own_contents() {
let mut doc = parse_fragment(
"<div><template><p></p></template></div>",
Ns::Html,
"body",
false,
);
let div = doc.first_child(0).unwrap();
let template = doc.first_child(div).unwrap();
let contents = doc.template_contents(template).unwrap();
let p = doc.first_child(contents).unwrap();
assert_eq!(doc.append(contents, template), Err(EditError::Cycle));
assert_eq!(doc.append(contents, div), Err(EditError::Cycle));
assert_eq!(doc.insert_before(p, div, None), Err(EditError::Cycle));
let made = doc.create_element(Ns::Html, "template");
doc.append(p, made).unwrap();
let made_contents = doc.template_contents(made).unwrap();
assert_eq!(doc.append(made_contents, div), Err(EditError::Cycle));
let span = doc.create_element(Ns::Html, "span");
doc.append(made_contents, span).unwrap();
doc.rename(span, "template");
let span_contents = doc.template_contents(span).unwrap();
assert_eq!(doc.append(span_contents, template), Err(EditError::Cycle));
doc.rename(span, "section");
doc.append(span_contents, template).unwrap();
assert_eq!(doc.inner_html(0), "<div></div>");
doc.append(div, template).unwrap();
assert_eq!(
doc.inner_html(0),
"<div><template><p><template><section></section></template></p></template></div>"
);
}
#[test]
fn attributes_can_be_set_replaced_and_removed() {
let mut doc = parse_fragment("<a href=x>a</a><a href=x>b</a>", Ns::Html, "div", false);
let a = doc.first_child(0).unwrap();
doc.set_attr(a, "HREF", "y");
doc.set_attr(a, "title", "t");
assert_eq!(doc.outer_html(a), "<a href=\"y\" title=\"t\">a</a>");
assert!(doc.remove_attr(a, "href"));
assert!(!doc.remove_attr(a, "href"));
assert_eq!(doc.outer_html(a), "<a title=\"t\">a</a>");
let b = doc.next_sibling(a).unwrap();
assert_eq!(doc.outer_html(b), "<a href=\"x\">b</a>");
}
#[test]
fn changing_a_reconstructed_clone_leaves_the_original_alone() {
let mut doc = parse_fragment("<p><b class=x>a</p>t", Ns::Html, "body", false);
let p = doc.first_child(0).unwrap();
let original = doc.first_child(p).unwrap();
let clone = doc.next_sibling(p).unwrap();
assert_eq!(doc.outer_html(clone), "<b class=\"x\">t</b>");
doc.set_attr(clone, "class", "y");
assert_eq!(doc.outer_html(original), "<b class=\"x\">a</b>");
assert_eq!(doc.outer_html(clone), "<b class=\"y\">t</b>");
}
#[test]
fn foreign_names_keep_their_case() {
let mut doc = parse_fragment("<svg></svg>", Ns::Svg, "svg", false);
let g = doc.create_element(Ns::Svg, "linearGradient");
doc.set_attr(g, "gradientUnits", "u");
doc.append(0, g).unwrap();
assert!(
doc.inner_html(0)
.contains("<linearGradient gradientUnits=\"u\"></linearGradient>")
);
}
fn removable() -> (crate::Document, NodeId, NodeId, NodeId) {
let doc = parse(
"<div><p id=a>one <b>two</b></p><p id=b>three</p></div>",
false,
);
let id = |name: &str| {
(0..doc.len() as NodeId)
.find(|&n| doc.lower_name(n) == Some(name))
.unwrap()
};
let (p, b) = (id("p"), id("b"));
let text = doc.first_child(b).unwrap();
(doc, p, b, text)
}
#[test]
fn a_removed_node_reads_as_nothing() {
let (mut doc, p, _, _) = removable();
let div = doc.parent(p).unwrap();
doc.remove(p);
assert!(doc.is_removed(p));
assert_eq!(doc.outer_html(div), "<div><p id=\"b\">three</p></div>");
assert_eq!(doc.parent(p), None);
assert_eq!(doc.first_child(p), None);
assert_eq!(doc.children(p).count(), 0);
assert_eq!(doc.attrs(p).count(), 0);
assert_eq!(doc.attrs_written(p).count(), 0);
assert_eq!(doc.lower_name(p), None);
assert_eq!(doc.known_tag(p), None);
assert_eq!(doc.outer_html(p), "");
assert_eq!(doc.inner_html(p), "");
assert_eq!(doc.html_alone(p), "");
assert_eq!(doc.text(p), "");
assert!(matches!(
doc.kind(p),
crate::Kind::Element { name: "p", .. }
));
doc.remove(p);
doc.remove(doc.root());
assert!(!doc.is_removed(doc.root()));
}
#[test]
fn a_removed_node_cant_be_edited_or_inserted() {
let (mut doc, p, _, _) = removable();
let div = doc.parent(p).unwrap();
let other = doc.next_sibling(p).unwrap();
doc.remove(p);
assert_eq!(doc.append(div, p), Err(EditError::Removed));
let fresh = doc.create_element(Ns::Html, "span");
assert_eq!(doc.append(p, fresh), Err(EditError::Removed));
assert_eq!(
doc.insert_before(div, fresh, Some(p)),
Err(EditError::Removed)
);
doc.set_attr(p, "class", "x");
doc.rename(p, "section");
assert!(!doc.remove_attr(p, "id"));
assert_eq!(doc.attrs(p).count(), 0);
assert!(matches!(
doc.kind(p),
crate::Kind::Element { name: "p", .. }
));
doc.append(div, fresh).unwrap();
assert_eq!(
doc.outer_html(div),
"<div><p id=\"b\">three</p><span></span></div>"
);
assert_eq!(doc.text(other), "three");
}
#[test]
fn removing_a_parent_removes_what_it_holds() {
let (mut doc, p, b, text) = removable();
doc.remove(p);
for n in [b, text] {
assert!(doc.is_removed(n), "node {n}");
assert_eq!(doc.parent(n), None);
assert_eq!(doc.outer_html(n), "");
}
assert!(matches!(doc.kind(text), crate::Kind::Text("")));
assert_eq!(doc.append(doc.root(), b), Err(EditError::Removed));
}
#[test]
fn a_detached_node_can_be_inserted_again() {
let (mut doc, p, b, _) = removable();
let div = doc.parent(p).unwrap();
doc.detach(p);
assert!(!doc.is_removed(p));
assert_eq!(doc.outer_html(div), "<div><p id=\"b\">three</p></div>");
assert_eq!(doc.outer_html(p), "<p id=\"a\">one <b>two</b></p>");
assert_eq!(doc.parent(b), Some(p));
doc.append(div, p).unwrap();
assert_eq!(
doc.outer_html(div),
"<div><p id=\"b\">three</p><p id=\"a\">one <b>two</b></p></div>"
);
}
#[test]
fn a_removed_templates_contents_go_with_it() {
let mut doc = parse("<template><i>x</i></template>", false);
let template = (0..doc.len() as NodeId)
.find(|&n| doc.lower_name(n) == Some("template"))
.unwrap();
let contents = doc.template_contents(template).unwrap();
let i = doc.first_child(contents).unwrap();
doc.remove(template);
assert!(doc.is_removed(contents) && doc.is_removed(i));
assert_eq!(doc.template_contents(template), None);
#[cfg(debug_assertions)]
doc.check_tree();
}
#[test]
fn a_removed_node_matches_no_selector() {
let (mut doc, p, b, _) = removable();
let list = crate::css::SelectorList::parse("p, b, #a").unwrap();
assert!(list.matches(&doc, p, None));
doc.remove(p);
assert!(!list.matches(&doc, p, None));
assert!(!list.matches(&doc, b, None));
assert_eq!(list.select(&doc, p), Vec::<NodeId>::new());
let left = list.select(&doc, doc.root());
assert_eq!(left.len(), 1);
assert_eq!(doc.outer_html(left[0]), "<p id=\"b\">three</p>");
}
#[test]
fn a_removed_hosts_shadow_tree_goes_with_it() {
let mut doc = parse("<div id=host><span>light</span></div>", false);
let host = (0..doc.len() as NodeId)
.find(|&n| doc.lower_name(n) == Some("div"))
.unwrap();
let light = doc.first_child(host).unwrap();
let shadow = doc.attach_shadow(host, crate::ShadowRoot::open()).unwrap();
let slot = doc.create_element(Ns::Html, "slot");
doc.append(shadow, slot).unwrap();
assert_eq!(doc.assigned_nodes(slot), [light]);
doc.remove(host);
for n in [shadow, slot, light] {
assert!(doc.is_removed(n), "node {n}");
}
assert_eq!(doc.shadow_root(host), None);
assert_eq!(doc.shadow_host(shadow), None);
assert_eq!(doc.assigned_nodes(slot), Vec::<NodeId>::new());
assert_eq!(doc.flat_tree(host).count(), 0);
assert_eq!(
doc.attach_shadow(host, crate::ShadowRoot::open()),
Err(EditError::Removed)
);
let mut doc = parse("<div></div>", false);
let host = (0..doc.len() as NodeId)
.find(|&n| doc.lower_name(n) == Some("div"))
.unwrap();
let shadow = doc.attach_shadow(host, crate::ShadowRoot::open()).unwrap();
doc.remove(shadow);
assert!(!doc.is_removed(shadow));
assert_eq!(doc.shadow_root(host), Some(shadow));
#[cfg(debug_assertions)]
doc.check_tree();
}
}