1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
use html5ever::serialize::TraversalScope::*;
use html5ever::serialize::{serialize, Serialize, SerializeOpts, Serializer, TraversalScope};
use html5ever::QualName;
use std::fs::File;
use std::io::{Result, Write};
use std::path::Path;
use std::string::ToString;
use crate::tree::{NodeData, NodeRef};
impl Serialize for NodeRef {
fn serialize<S: Serializer>(
&self,
serializer: &mut S,
traversal_scope: TraversalScope,
) -> Result<()> {
match (traversal_scope, self.data()) {
(ref scope, &NodeData::Element(ref element)) => {
if *scope == IncludeNode {
let attrs = element.attributes.borrow();
let attrs = attrs
.map
.iter()
.map(|(name, attr)| {
(
QualName::new(
attr.prefix.clone(),
name.ns.clone(),
name.local.clone(),
),
&attr.value,
)
})
.collect::<Vec<_>>();
serializer.start_elem(
element.name.clone(),
attrs.iter().map(|&(ref name, value)| (name, &**value)),
)?
}
for child in self.children() {
Serialize::serialize(&child, serializer, IncludeNode)?
}
if *scope == IncludeNode {
serializer.end_elem(element.name.clone())?
}
Ok(())
}
(_, &NodeData::DocumentFragment) | (_, &NodeData::Document(_)) => {
for child in self.children() {
Serialize::serialize(&child, serializer, IncludeNode)?
}
Ok(())
}
(ChildrenOnly(_), _) => Ok(()),
(IncludeNode, &NodeData::Doctype(ref doctype)) => {
serializer.write_doctype(&doctype.name)
}
(IncludeNode, &NodeData::Text(ref text)) => serializer.write_text(&text.borrow()),
(IncludeNode, &NodeData::Comment(ref text)) => serializer.write_comment(&text.borrow()),
(IncludeNode, &NodeData::ProcessingInstruction(ref contents)) => {
let contents = contents.borrow();
serializer.write_processing_instruction(&contents.0, &contents.1)
}
}
}
}
impl ToString for NodeRef {
#[inline]
fn to_string(&self) -> String {
let mut u8_vec = Vec::new();
self.serialize(&mut u8_vec).unwrap();
String::from_utf8(u8_vec).unwrap()
}
}
impl NodeRef {
#[inline]
pub fn serialize<W: Write>(&self, writer: &mut W) -> Result<()> {
serialize(
writer,
self,
SerializeOpts {
traversal_scope: IncludeNode,
..Default::default()
},
)
}
#[inline]
pub fn serialize_to_file<P: AsRef<Path>>(&self, path: P) -> Result<()> {
let mut file = File::create(&path)?;
self.serialize(&mut file)
}
}