aboutsummaryrefslogtreecommitdiffstats
path: root/src/components/script/dom/htmlserializer.rs
diff options
context:
space:
mode:
Diffstat (limited to 'src/components/script/dom/htmlserializer.rs')
-rw-r--r--src/components/script/dom/htmlserializer.rs102
1 files changed, 53 insertions, 49 deletions
diff --git a/src/components/script/dom/htmlserializer.rs b/src/components/script/dom/htmlserializer.rs
index 8bd5beb6cf8..3a2148547ee 100644
--- a/src/components/script/dom/htmlserializer.rs
+++ b/src/components/script/dom/htmlserializer.rs
@@ -4,15 +4,15 @@
use servo_util::namespace;
use dom::attr::Attr;
-use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast};
+use dom::bindings::codegen::InheritTypes::{ElementCast, TextCast, CommentCast, NodeCast};
use dom::bindings::codegen::InheritTypes::{DocumentTypeCast, CharacterDataCast};
use dom::bindings::codegen::InheritTypes::ProcessingInstructionCast;
-use dom::bindings::js::JS;
+use dom::bindings::js::JSRef;
use dom::characterdata::CharacterData;
use dom::comment::Comment;
use dom::documenttype::DocumentType;
use dom::element::Element;
-use dom::node::NodeIterator;
+use dom::node::{Node, NodeIterator};
use dom::node::{DoctypeNodeTypeId, DocumentFragmentNodeTypeId, CommentNodeTypeId};
use dom::node::{DocumentNodeTypeId, ElementNodeTypeId, ProcessingInstructionNodeTypeId};
use dom::node::{TextNodeTypeId, NodeHelpers};
@@ -30,24 +30,25 @@ pub fn serialize(iterator: &mut NodeIterator) -> ~str {
html.push_str(
match node.type_id() {
ElementNodeTypeId(..) => {
- let elem: JS<Element> = ElementCast::to(&node).unwrap();
- serialize_elem(&elem, &mut open_elements)
+ let elem: &JSRef<Element> = ElementCast::to_ref(&node).unwrap();
+ serialize_elem(elem, &mut open_elements)
}
CommentNodeTypeId => {
- let comment: JS<Comment> = CommentCast::to(&node).unwrap();
- serialize_comment(&comment)
+ let comment: &JSRef<Comment> = CommentCast::to_ref(&node).unwrap();
+ serialize_comment(comment)
}
TextNodeTypeId => {
- let text: JS<Text> = TextCast::to(&node).unwrap();
- serialize_text(&text)
+ let text: &JSRef<Text> = TextCast::to_ref(&node).unwrap();
+ serialize_text(text)
}
DoctypeNodeTypeId => {
- let doctype: JS<DocumentType> = DocumentTypeCast::to(&node).unwrap();
- serialize_doctype(&doctype)
+ let doctype: &JSRef<DocumentType> = DocumentTypeCast::to_ref(&node).unwrap();
+ serialize_doctype(doctype)
}
ProcessingInstructionNodeTypeId => {
- let processing_instruction: JS<ProcessingInstruction> = ProcessingInstructionCast::to(&node).unwrap();
- serialize_processing_instruction(&processing_instruction)
+ let processing_instruction: &JSRef<ProcessingInstruction> =
+ ProcessingInstructionCast::to_ref(&node).unwrap();
+ serialize_processing_instruction(processing_instruction)
}
DocumentFragmentNodeTypeId => {
~""
@@ -64,47 +65,50 @@ pub fn serialize(iterator: &mut NodeIterator) -> ~str {
html
}
-fn serialize_comment(comment: &JS<Comment>) -> ~str {
- ~"<!--" + comment.get().characterdata.data + "-->"
+fn serialize_comment(comment: &JSRef<Comment>) -> ~str {
+ ~"<!--" + comment.deref().characterdata.data + "-->"
}
-fn serialize_text(text: &JS<Text>) -> ~str {
- match text.get().characterdata.node.parent_node {
+fn serialize_text(text: &JSRef<Text>) -> ~str {
+ let text_node: &JSRef<Node> = NodeCast::from_ref(text);
+ match text_node.parent_node().map(|node| node.root()) {
Some(ref parent) if parent.is_element() => {
- let elem: JS<Element> = ElementCast::to(parent).unwrap();
- match elem.get().local_name.as_slice() {
+ let elem: &JSRef<Element> = ElementCast::to_ref(&**parent).unwrap();
+ match elem.deref().local_name.as_slice() {
"style" | "script" | "xmp" | "iframe" |
"noembed" | "noframes" | "plaintext" |
- "noscript" if elem.get().namespace == namespace::HTML => {
- text.get().characterdata.data.clone()
+ "noscript" if elem.deref().namespace == namespace::HTML => {
+ text.deref().characterdata.data.clone()
},
- _ => escape(text.get().characterdata.data, false)
+ _ => escape(text.deref().characterdata.data, false)
}
}
- _ => escape(text.get().characterdata.data, false)
+ _ => escape(text.deref().characterdata.data, false)
}
}
-fn serialize_processing_instruction(processing_instruction: &JS<ProcessingInstruction>) -> ~str {
- ~"<?" + processing_instruction.get().target + " " + processing_instruction.get().characterdata.data + "?>"
+fn serialize_processing_instruction(processing_instruction: &JSRef<ProcessingInstruction>) -> ~str {
+ ~"<?" + processing_instruction.deref().target + " " + processing_instruction.deref().characterdata.data + "?>"
}
-fn serialize_doctype(doctype: &JS<DocumentType>) -> ~str {
- ~"<!DOCTYPE" + doctype.get().name + ">"
+fn serialize_doctype(doctype: &JSRef<DocumentType>) -> ~str {
+ ~"<!DOCTYPE" + doctype.deref().name + ">"
}
-fn serialize_elem(elem: &JS<Element>, open_elements: &mut Vec<~str>) -> ~str {
- let mut rv = ~"<" + elem.get().local_name;
- for attr in elem.get().attrs.iter() {
- rv.push_str(serialize_attr(attr));
+fn serialize_elem(elem: &JSRef<Element>, open_elements: &mut Vec<~str>) -> ~str {
+ let mut rv = ~"<" + elem.deref().local_name;
+ for attr in elem.deref().attrs.iter() {
+ let attr = attr.root();
+ rv.push_str(serialize_attr(&*attr));
};
rv.push_str(">");
- match elem.get().local_name.as_slice() {
- "pre" | "listing" | "textarea" if elem.get().namespace == namespace::HTML => {
- match elem.get().node.first_child {
+ match elem.deref().local_name.as_slice() {
+ "pre" | "listing" | "textarea" if elem.deref().namespace == namespace::HTML => {
+ let node: &JSRef<Node> = NodeCast::from_ref(elem);
+ match node.first_child().map(|child| child.root()) {
Some(ref child) if child.is_text() => {
- let text: JS<CharacterData> = CharacterDataCast::to(child).unwrap();
- if text.get().data.len() > 0 && text.get().data[0] == 0x0A as u8 {
+ let text: &JSRef<CharacterData> = CharacterDataCast::to_ref(&**child).unwrap();
+ if text.deref().data.len() > 0 && text.deref().data[0] == 0x0A as u8 {
rv.push_str("\x0A");
}
},
@@ -113,26 +117,26 @@ fn serialize_elem(elem: &JS<Element>, open_elements: &mut Vec<~str>) -> ~str {
},
_ => {}
}
- if !elem.get().is_void() {
- open_elements.push(elem.get().local_name.clone());
+ if !elem.deref().is_void() {
+ open_elements.push(elem.deref().local_name.clone());
}
rv
}
-fn serialize_attr(attr: &JS<Attr>) -> ~str {
- let attr_name = if attr.get().namespace == namespace::XML {
- ~"xml:" + attr.get().local_name.clone()
- } else if attr.get().namespace == namespace::XMLNS &&
- attr.get().local_name.as_slice() == "xmlns" {
+fn serialize_attr(attr: &JSRef<Attr>) -> ~str {
+ let attr_name = if attr.deref().namespace == namespace::XML {
+ ~"xml:" + attr.deref().local_name.clone()
+ } else if attr.deref().namespace == namespace::XMLNS &&
+ attr.deref().local_name.as_slice() == "xmlns" {
~"xmlns"
- } else if attr.get().namespace == namespace::XMLNS {
- ~"xmlns:" + attr.get().local_name.clone()
- } else if attr.get().namespace == namespace::XLink {
- ~"xlink:" + attr.get().local_name.clone()
+ } else if attr.deref().namespace == namespace::XMLNS {
+ ~"xmlns:" + attr.deref().local_name.clone()
+ } else if attr.deref().namespace == namespace::XLink {
+ ~"xlink:" + attr.deref().local_name.clone()
} else {
- attr.get().name.clone()
+ attr.deref().name.clone()
};
- ~" " + attr_name + "=\"" + escape(attr.get().value, true) + "\""
+ ~" " + attr_name + "=\"" + escape(attr.deref().value, true) + "\""
}
fn escape(string: &str, attr_mode: bool) -> ~str {
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-30 07:31:26 +0000