1extern crate xml;
2
3pub mod error;
4
5use std::io::prelude::*;
6
7use std::convert::From;
8
9use std::fmt;
10
11use xml::name::{OwnedName, Name};
12use xml::reader::{XmlEvent as ReaderEvent, EventReader};
13use xml::writer::{XmlEvent as WriterEvent, EventWriter};
14use xml::attribute::OwnedAttribute;
15
16use error::Error;
17
18#[derive(Clone, PartialEq, Eq)]
19pub struct Element {
20 name: OwnedName,
21 attributes: Vec<OwnedAttribute>,
22 children: Vec<Fork>,
23}
24
25impl fmt::Debug for Element {
26 fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
27 write!(fmt, "<{}", self.name)?;
28 for attr in &self.attributes {
29 write!(fmt, " {}", attr)?;
30 }
31 write!(fmt, ">")?;
32 for child in &self.children {
33 match *child {
34 Fork::Element(ref e) => {
35 write!(fmt, "{:?}", e)?;
36 },
37 Fork::Text(ref s) => {
38 write!(fmt, "{}", s)?;
39 },
40 }
41 }
42 write!(fmt, "</{}>", self.name)?;
43 Ok(())
44 }
45}
46
47#[derive(Clone, Debug, PartialEq, Eq)]
48pub enum Fork {
49 Element(Element),
50 Text(String),
51}
52
53impl Element {
54 pub fn new(name: OwnedName, attributes: Vec<OwnedAttribute>) -> Element {
55 Element {
56 name: name,
57 attributes: attributes,
58 children: Vec::new(),
59 }
60 }
61
62 pub fn builder<S: Into<String>>(name: S) -> ElementBuilder {
63 ElementBuilder {
64 name: OwnedName::local(name),
65 attributes: Vec::new(),
66 }
67 }
68
69 pub fn tag(&self) -> &str {
70 &self.name.local_name
71 }
72
73 pub fn ns(&self) -> Option<&str> {
74 self.name.namespace.as_ref()
75 .map(String::as_ref)
76 }
77
78 pub fn attr(&self, key: &str) -> Option<&str> {
79 for attr in &self.attributes {
80 if attr.name.local_name == key {
81 return Some(&attr.value);
82 }
83 }
84 None
85 }
86
87 pub fn from_reader<R: Read>(reader: &mut EventReader<R>) -> Result<Element, Error> {
88 loop {
89 let e = reader.next()?;
90 match e {
91 ReaderEvent::StartElement { name, attributes, .. } => {
92 let mut root = Element::new(name, attributes);
93 root.from_reader_inner(reader);
94 return Ok(root);
95 },
96 ReaderEvent::EndDocument => {
97 return Err(Error::EndOfDocument);
98 },
99 _ => () // TODO: may need more errors
100 }
101 }
102 }
103
104 fn from_reader_inner<R: Read>(&mut self, reader: &mut EventReader<R>) -> Result<(), Error> {
105 loop {
106 let e = reader.next()?;
107 match e {
108 ReaderEvent::StartElement { name, attributes, .. } => {
109 let elem = Element::new(name, attributes);
110 let elem_ref = self.append_child(elem);
111 elem_ref.from_reader_inner(reader);
112 },
113 ReaderEvent::EndElement { .. } => {
114 // TODO: may want to check whether we're closing the correct element
115 return Ok(());
116 },
117 ReaderEvent::Characters(s) => {
118 self.append_text_node(s);
119 },
120 ReaderEvent::CData(s) => {
121 self.append_text_node(s);
122 },
123 ReaderEvent::EndDocument => {
124 return Err(Error::EndOfDocument);
125 },
126 _ => (), // TODO: may need to implement more
127 }
128 }
129 }
130
131 pub fn write_to<W: Write>(&self, writer: &mut EventWriter<W>) -> Result<(), Error> {
132 let mut start = WriterEvent::start_element(self.name.borrow());
133 if let Some(ref ns) = self.name.namespace {
134 start = start.default_ns(ns.as_ref());
135 }
136 for attr in &self.attributes { // TODO: I think this could be done a lot more efficiently
137 start = start.attr(attr.name.borrow(), &attr.value);
138 }
139 writer.write(start)?;
140 for child in &self.children {
141 match *child {
142 Fork::Element(ref e) => {
143 e.write_to(writer)?;
144 },
145 Fork::Text(ref s) => {
146 writer.write(WriterEvent::characters(s))?;
147 },
148 }
149 }
150 writer.write(WriterEvent::end_element())?;
151 Ok(())
152 }
153
154 pub fn children<'a>(&'a self) -> Children<'a> {
155 unimplemented!();
156 }
157
158 pub fn children_mut<'a>(&'a mut self) -> ChildrenMut<'a> {
159 unimplemented!();
160 }
161
162 pub fn append_child(&mut self, child: Element) -> &mut Element {
163 self.children.push(Fork::Element(child));
164 if let Fork::Element(ref mut cld) = *self.children.last_mut().unwrap() {
165 cld
166 }
167 else {
168 unreachable!()
169 }
170 }
171
172 pub fn append_text_node<S: Into<String>>(&mut self, child: S) {
173 self.children.push(Fork::Text(child.into()));
174 }
175
176 pub fn text(&self) -> &str {
177 unimplemented!()
178 }
179
180 pub fn get_child<'a, N: Into<Name<'a>>>(&self, name: N) -> Option<&Element> {
181 unimplemented!()
182 }
183
184 pub fn get_child_mut<'a, N: Into<Name<'a>>>(&mut self, name: N) -> Option<&mut Element> {
185 unimplemented!()
186 }
187
188 pub fn into_child<'a, N: Into<Name<'a>>>(self, name: N) -> Option<Element> {
189 unimplemented!()
190 }
191}
192
193pub struct Children<'a> {
194 elem: &'a Element,
195}
196
197pub struct ChildrenMut<'a> {
198 elem: &'a mut Element,
199}
200
201pub struct ElementBuilder {
202 name: OwnedName,
203 attributes: Vec<OwnedAttribute>,
204}
205
206impl ElementBuilder {
207 pub fn ns<S: Into<String>>(mut self, namespace: S) -> ElementBuilder {
208 self.name.namespace = Some(namespace.into());
209 self
210 }
211
212 pub fn attr<S: Into<String>, V: Into<String>>(mut self, name: S, value: V) -> ElementBuilder {
213 self.attributes.push(OwnedAttribute::new(OwnedName::local(name), value));
214 self
215 }
216
217 pub fn attr_ns<S: Into<String>, N: Into<String>, V: Into<String>>(mut self, name: S, namespace: N, value: V) -> ElementBuilder {
218 self.attributes.push(OwnedAttribute::new(OwnedName::qualified::<_, _, &'static str>(name, namespace, None), value));
219 self
220 }
221
222 pub fn build(self) -> Element {
223 Element::new(self.name, self.attributes)
224 }
225}
226
227#[cfg(test)]
228mod tests {
229 use super::*;
230
231 const TEST_STRING: &'static str = r#"<?xml version="1.0" encoding="utf-8"?><root xmlns="root_ns" a="b">meow<child c="d" /><child xmlns="child_ns" d="e" />nya</root>"#;
232
233 fn build_test_tree() -> Element {
234 let mut root = Element::builder("root")
235 .ns("root_ns")
236 .attr("a", "b")
237 .build();
238 root.append_text_node("meow");
239 let child = Element::builder("child")
240 .attr("c", "d")
241 .build();
242 root.append_child(child);
243 let other_child = Element::builder("child")
244 .ns("child_ns")
245 .attr("d", "e")
246 .build();
247 root.append_child(other_child);
248 root.append_text_node("nya");
249 root
250 }
251
252 #[test]
253 fn reader_works() {
254 use std::io::Cursor;
255 let mut reader = EventReader::new(Cursor::new(TEST_STRING));
256 // TODO: fix a bunch of namespace stuff so this test passes
257 assert_eq!(Element::from_reader(&mut reader).unwrap(), build_test_tree());
258 }
259
260 #[test]
261 fn writer_works() {
262 let root = build_test_tree();
263 let mut out = Vec::new();
264 {
265 let mut writer = EventWriter::new(&mut out);
266 root.write_to(&mut writer);
267 }
268 assert_eq!(String::from_utf8(out).unwrap(), TEST_STRING);
269 }
270
271 #[test]
272 fn builder_works() {
273 let elem = Element::builder("a")
274 .ns("b")
275 .attr("c", "d")
276 .build();
277 assert_eq!(elem.tag(), "a");
278 assert_eq!(elem.ns(), Some("b"));
279 assert_eq!(elem.attr("c"), Some("d"));
280 }
281}