Rustfmt

3 files changed, 412 insertions, 387 deletions

diff --git a/src/xml/mod.rs b/src/xml/mod.rs
index b82450a..0400e13 100644
--- a/src/xml/mod.rs
+++ b/src/xml/mod.rs
@@ -2,4 +2,4 @@ mod reader;
 mod writer;
 
 pub use self::reader::EventReader;
-pub use self::writer::EventWriter;
\ No newline at end of file
+pub use self::writer::EventWriter;
diff --git a/src/xml/reader.rs b/src/xml/reader.rs
index b8def8f..90422c2 100644
--- a/src/xml/reader.rs
+++ b/src/xml/reader.rs
@@ -7,190 +7,200 @@ use xml_rs::reader::{EventReader as XmlEventReader, ParserConfig, XmlEvent};
 use super::super::{ReadError, ReadResult, PlistEvent};
 
 pub struct EventReader<R: Read> {
-	xml_reader: XmlEventReader<R>,
-	queued_event: Option<XmlEvent>,
-	element_stack: Vec<String>,
-	finished: bool
+    xml_reader: XmlEventReader<R>,
+    queued_event: Option<XmlEvent>,
+    element_stack: Vec<String>,
+    finished: bool,
 }
 
 impl<R: Read> EventReader<R> {
-	pub fn new(reader: R) -> EventReader<R> {
-		let config = ParserConfig {
-			trim_whitespace: false,
-			whitespace_to_characters: true,
-			cdata_to_characters: true,
-			ignore_comments: true,
-			coalesce_characters: true,
-		};
-
-		EventReader {
-			xml_reader: XmlEventReader::new_with_config(reader, config),
-			queued_event: None,
-			element_stack: Vec::new(),
-			finished: false
-		}
-	}
-
-	fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent> where F:FnOnce(String) -> ReadResult<PlistEvent> {
-		match self.xml_reader.next() {
-			Ok(XmlEvent::Characters(s)) => f(s),
-			Ok(event @ XmlEvent::EndElement{..}) => {
-				self.queued_event = Some(event);
-				f("".to_owned())
-			},
-			_ => Err(ReadError::InvalidData)
-		}
-	}
-
-	fn next_event(&mut self) -> Result<XmlEvent, ()> {
-		if let Some(event) = self.queued_event.take() {
-			Ok(event)
-		} else {
-			self.xml_reader.next().map_err(|_| ())
-		}
-	}
-
-	fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
-		loop {
-			match self.next_event() {
-				Ok(XmlEvent::StartElement { name, .. }) => {
-					// Add the current element to the element stack
-					self.element_stack.push(name.local_name.clone());
-					
-					match &name.local_name[..] {
-						"plist" => return Some(Ok(PlistEvent::StartPlist)),
-						"array" => return Some(Ok(PlistEvent::StartArray(None))),
-						"dict" => return Some(Ok(PlistEvent::StartDictionary(None))),
-						"key" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
-						"true" => return Some(Ok(PlistEvent::BooleanValue(true))),
-						"false" => return Some(Ok(PlistEvent::BooleanValue(false))),
-						"data" => return Some(self.read_content(|s| {
-							let s: String = s.replace(" ", "").replace("\t", "");
-							match FromBase64::from_base64(&s[..]) {
-								Ok(b) => Ok(PlistEvent::DataValue(b)),
-								Err(_) => Err(ReadError::InvalidData)
-							}
-						})),
-						"date" => return Some(self.read_content(|s| {
-							let date = try!(DateTime::parse_from_rfc3339(&s));
-							Ok(PlistEvent::DateValue(date.with_timezone(&UTC)))
-						})),
-						"integer" => return Some(self.read_content(|s| {
-							match FromStr::from_str(&s)	{
-								Ok(i) => Ok(PlistEvent::IntegerValue(i)),
-								Err(_) => Err(ReadError::InvalidData)
-							}
-						})),
-						"real" => return Some(self.read_content(|s| {
-							match FromStr::from_str(&s)	{
-								Ok(f) => Ok(PlistEvent::RealValue(f)),
-								Err(_) => Err(ReadError::InvalidData)
-							}
-						})),
-						"string" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
-						_ => return Some(Err(ReadError::InvalidData))
-					}
-				},
-				Ok(XmlEvent::EndElement { name, .. }) => {
-					// Check the corrent element is being closed
-					match self.element_stack.pop() {
-						Some(ref open_name) if &name.local_name == open_name => (),
-						Some(ref _open_name) => return Some(Err(ReadError::InvalidData)),
-						None => return Some(Err(ReadError::InvalidData))
-					}
-
-					match &name.local_name[..] {
-						"array" => return Some(Ok(PlistEvent::EndArray)),
-						"dict" => return Some(Ok(PlistEvent::EndDictionary)),
-						"plist" => return Some(Ok(PlistEvent::EndPlist)),
-						_ => ()
-					}
-				},
-				Ok(XmlEvent::EndDocument) => {
-					match self.element_stack.is_empty() {
-						true => return None,
-						false => return Some(Err(ReadError::UnexpectedEof))
-					}
-				},
-				Err(_) => return Some(Err(ReadError::InvalidData)),
-				_ => ()
-			}
-		}
-	}
+    pub fn new(reader: R) -> EventReader<R> {
+        let config = ParserConfig {
+            trim_whitespace: false,
+            whitespace_to_characters: true,
+            cdata_to_characters: true,
+            ignore_comments: true,
+            coalesce_characters: true,
+        };
+
+        EventReader {
+            xml_reader: XmlEventReader::new_with_config(reader, config),
+            queued_event: None,
+            element_stack: Vec::new(),
+            finished: false,
+        }
+    }
+
+    fn read_content<F>(&mut self, f: F) -> ReadResult<PlistEvent>
+        where F: FnOnce(String) -> ReadResult<PlistEvent>
+    {
+        match self.xml_reader.next() {
+            Ok(XmlEvent::Characters(s)) => f(s),
+            Ok(event @ XmlEvent::EndElement{..}) => {
+                self.queued_event = Some(event);
+                f("".to_owned())
+            }
+            _ => Err(ReadError::InvalidData),
+        }
+    }
+
+    fn next_event(&mut self) -> Result<XmlEvent, ()> {
+        if let Some(event) = self.queued_event.take() {
+            Ok(event)
+        } else {
+            self.xml_reader.next().map_err(|_| ())
+        }
+    }
+
+    fn read_next(&mut self) -> Option<ReadResult<PlistEvent>> {
+        loop {
+            match self.next_event() {
+                Ok(XmlEvent::StartElement { name, .. }) => {
+                    // Add the current element to the element stack
+                    self.element_stack.push(name.local_name.clone());
+
+                    match &name.local_name[..] {
+                        "plist" => return Some(Ok(PlistEvent::StartPlist)),
+                        "array" => return Some(Ok(PlistEvent::StartArray(None))),
+                        "dict" => return Some(Ok(PlistEvent::StartDictionary(None))),
+                        "key" => return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s)))),
+                        "true" => return Some(Ok(PlistEvent::BooleanValue(true))),
+                        "false" => return Some(Ok(PlistEvent::BooleanValue(false))),
+                        "data" => {
+                            return Some(self.read_content(|s| {
+                                let s: String = s.replace(" ", "").replace("\t", "");
+                                match FromBase64::from_base64(&s[..]) {
+                                    Ok(b) => Ok(PlistEvent::DataValue(b)),
+                                    Err(_) => Err(ReadError::InvalidData),
+                                }
+                            }))
+                        }
+                        "date" => {
+                            return Some(self.read_content(|s| {
+                                let date = try!(DateTime::parse_from_rfc3339(&s));
+                                Ok(PlistEvent::DateValue(date.with_timezone(&UTC)))
+                            }))
+                        }
+                        "integer" => {
+                            return Some(self.read_content(|s| {
+                                match FromStr::from_str(&s) {
+                                    Ok(i) => Ok(PlistEvent::IntegerValue(i)),
+                                    Err(_) => Err(ReadError::InvalidData),
+                                }
+                            }))
+                        }
+                        "real" => {
+                            return Some(self.read_content(|s| {
+                                match FromStr::from_str(&s) {
+                                    Ok(f) => Ok(PlistEvent::RealValue(f)),
+                                    Err(_) => Err(ReadError::InvalidData),
+                                }
+                            }))
+                        }
+                        "string" => {
+                            return Some(self.read_content(|s| Ok(PlistEvent::StringValue(s))))
+                        }
+                        _ => return Some(Err(ReadError::InvalidData)),
+                    }
+                }
+                Ok(XmlEvent::EndElement { name, .. }) => {
+                    // Check the corrent element is being closed
+                    match self.element_stack.pop() {
+                        Some(ref open_name) if &name.local_name == open_name => (),
+                        Some(ref _open_name) => return Some(Err(ReadError::InvalidData)),
+                        None => return Some(Err(ReadError::InvalidData)),
+                    }
+
+                    match &name.local_name[..] {
+                        "array" => return Some(Ok(PlistEvent::EndArray)),
+                        "dict" => return Some(Ok(PlistEvent::EndDictionary)),
+                        "plist" => return Some(Ok(PlistEvent::EndPlist)),
+                        _ => (),
+                    }
+                }
+                Ok(XmlEvent::EndDocument) => {
+                    match self.element_stack.is_empty() {
+                        true => return None,
+                        false => return Some(Err(ReadError::UnexpectedEof)),
+                    }
+                }
+                Err(_) => return Some(Err(ReadError::InvalidData)),
+                _ => (),
+            }
+        }
+    }
 }
 
 impl<R: Read> Iterator for EventReader<R> {
-	type Item = ReadResult<PlistEvent>;
-
-	fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
-		if self.finished {
-			None
-		} else {
-			match self.read_next() {
-				Some(Ok(event)) => Some(Ok(event)),
-				Some(Err(err)) => {
-					self.finished = true;
-					Some(Err(err))
-				},
-				None => {
-					self.finished = true;
-					None
-				}
-			}
-		}
-	}
+    type Item = ReadResult<PlistEvent>;
+
+    fn next(&mut self) -> Option<ReadResult<PlistEvent>> {
+        if self.finished {
+            None
+        } else {
+            match self.read_next() {
+                Some(Ok(event)) => Some(Ok(event)),
+                Some(Err(err)) => {
+                    self.finished = true;
+                    Some(Err(err))
+                }
+                None => {
+                    self.finished = true;
+                    None
+                }
+            }
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
-	use chrono::{TimeZone, UTC};
-	use std::fs::File;
-	use std::path::Path;
-
-	use super::*;
-	use PlistEvent;
-
-	#[test]
-	fn streaming_parser() {
-		use PlistEvent::*;
-
-		let reader = File::open(&Path::new("./tests/data/xml.plist")).unwrap();
-		let streaming_parser = EventReader::new(reader);
-		let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
-
-		let comparison = &[
-			StartPlist,
-			StartDictionary(None),
-			StringValue("Author".to_owned()),
-			StringValue("William Shakespeare".to_owned()),
-			StringValue("Lines".to_owned()),
-			StartArray(None),
-			StringValue("It is a tale told by an idiot,".to_owned()),
-			StringValue("Full of sound and fury, signifying nothing.".to_owned()),
-			EndArray,
-			StringValue("Death".to_owned()),
-			IntegerValue(1564),
-			StringValue("Height".to_owned()),
-			RealValue(1.60),
-			StringValue("Data".to_owned()),
-			DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
-			StringValue("Birthdate".to_owned()),
-			DateValue(UTC.ymd(1981, 05, 16).and_hms(11, 32, 06)),
-			StringValue("Blank".to_owned()),
-			StringValue("".to_owned()),
-			EndDictionary,
-			EndPlist
-		];
-
-		assert_eq!(events, comparison);
-	}
-
-	#[test]
-	fn bad_data() {
-		let reader = File::open(&Path::new("./tests/data/xml_error.plist")).unwrap();
-		let streaming_parser = EventReader::new(reader);
-		let events: Vec<_> = streaming_parser.collect();
-
-		assert!(events.last().unwrap().is_err());
-	}
-}
\ No newline at end of file
+    use chrono::{TimeZone, UTC};
+    use std::fs::File;
+    use std::path::Path;
+
+    use super::*;
+    use PlistEvent;
+
+    #[test]
+    fn streaming_parser() {
+        use PlistEvent::*;
+
+        let reader = File::open(&Path::new("./tests/data/xml.plist")).unwrap();
+        let streaming_parser = EventReader::new(reader);
+        let events: Vec<PlistEvent> = streaming_parser.map(|e| e.unwrap()).collect();
+
+        let comparison = &[StartPlist,
+                           StartDictionary(None),
+                           StringValue("Author".to_owned()),
+                           StringValue("William Shakespeare".to_owned()),
+                           StringValue("Lines".to_owned()),
+                           StartArray(None),
+                           StringValue("It is a tale told by an idiot,".to_owned()),
+                           StringValue("Full of sound and fury, signifying nothing.".to_owned()),
+                           EndArray,
+                           StringValue("Death".to_owned()),
+                           IntegerValue(1564),
+                           StringValue("Height".to_owned()),
+                           RealValue(1.60),
+                           StringValue("Data".to_owned()),
+                           DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
+                           StringValue("Birthdate".to_owned()),
+                           DateValue(UTC.ymd(1981, 05, 16).and_hms(11, 32, 06)),
+                           StringValue("Blank".to_owned()),
+                           StringValue("".to_owned()),
+                           EndDictionary,
+                           EndPlist];
+
+        assert_eq!(events, comparison);
+    }
+
+    #[test]
+    fn bad_data() {
+        let reader = File::open(&Path::new("./tests/data/xml_error.plist")).unwrap();
+        let streaming_parser = EventReader::new(reader);
+        let events: Vec<_> = streaming_parser.collect();
+
+        assert!(events.last().unwrap().is_err());
+    }
+}
diff --git a/src/xml/writer.rs b/src/xml/writer.rs
index ec2d9db..efca29e 100644
--- a/src/xml/writer.rs
+++ b/src/xml/writer.rs
@@ -7,241 +7,256 @@ use xml_rs::namespace::Namespace;
 use xml_rs::writer::{EventWriter as XmlEventWriter, EmitterConfig};
 use xml_rs::writer::events::XmlEvent as WriteXmlEvent;
 
-use {PlistEvent};
+use PlistEvent;
 
 enum Element {
-	Dictionary(DictionaryState),
-	Array,
-	Root
+    Dictionary(DictionaryState),
+    Array,
+    Root,
 }
 
 enum DictionaryState {
-	ExpectKey,
-	ExpectValue
+    ExpectKey,
+    ExpectValue,
 }
 
 pub struct EventWriter<W: Write> {
-	xml_writer: XmlEventWriter<W>,
-	stack: Vec<Element>,
-	// Not very nice
-	empty_namespace: Namespace
+    xml_writer: XmlEventWriter<W>,
+    stack: Vec<Element>,
+    // Not very nice
+    empty_namespace: Namespace,
 }
 
 impl<W: Write> EventWriter<W> {
-	pub fn new(writer: W) -> EventWriter<W> {
-		let config = EmitterConfig {
-			line_separator: "\n".into(),
-			indent_string: "    ".into(),
-			perform_indent: true,
-			perform_escaping: true,
-			write_document_declaration: true,
-			normalize_empty_elements: true,
-			cdata_to_characters: true,
-			keep_element_names_stack: false,
-			autopad_comments: true
-		};
-
-		EventWriter {
-			xml_writer: XmlEventWriter::new_with_config(writer, config),
-			stack: Vec::new(),
-			empty_namespace: Namespace::empty()
-		}
-	}
-
-	fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<(), ()> {
-		try!(self.start_element(name));
-		try!(self.write_value(value));
-		try!(self.end_element(name));
-		Ok(())
-	}
-
-	fn start_element(&mut self, name: &str) -> Result<(), ()> {
-		let result = self.xml_writer.write(WriteXmlEvent::StartElement {
-			name: Name::local(name),
-			attributes: Cow::Borrowed(&[]),
-			namespace: Cow::Borrowed(&self.empty_namespace)
-		});
-
-		match result {
-			Ok(()) => Ok(()),
-			Err(_) => Err(())
-		}
-	}
-
-	fn end_element(&mut self, name: &str) -> Result<(), ()> {
-		let result = self.xml_writer.write(WriteXmlEvent::EndElement {
-			name: Some(Name::local(name))
-		});
-
-		match result {
-			Ok(()) => Ok(()),
-			Err(_) => Err(())
-		}
-	}
-
-	fn write_value(&mut self, value: &str) -> Result<(), ()> {
-		let result = self.xml_writer.write(WriteXmlEvent::Characters(value));
-
-		match result {
-			Ok(()) => Ok(()),
-			Err(_) => Err(())
-		}
-	}
-
-	pub fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
-		match self.stack.pop() {
-			Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
-				match *event {
-					PlistEvent::StringValue(ref value) => {
-						try!(self.write_element_and_value("key", &*value));
-						self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
-					}
-					PlistEvent::EndDictionary => try!(self.end_element("dict")),
-					_ => return Err(()) // Invalid event
-				};
-				return Ok(())
-			},
-			Some(Element::Dictionary(DictionaryState::ExpectValue)) => self.stack.push(Element::Dictionary(DictionaryState::ExpectKey)),
-			Some(other) => self.stack.push(other),
-			None => match *event {
-				PlistEvent::StartPlist => {
-					let version_name = Name::local("version");
-					let version_attr = Attribute::new(version_name, "1.0");
-
-					let result = self.xml_writer.write(WriteXmlEvent::StartElement {
-						name: Name::local("plist"),
-						attributes: Cow::Borrowed(&[version_attr]),
-						namespace: Cow::Borrowed(&self.empty_namespace)
-					});
-
-					match result {
-						Ok(()) => (),
-						Err(_) => return Err(())
-					}
-
-					self.stack.push(Element::Root);
-					return Ok(())
-				},
-				_ => return Err(()) // Invalid event
-			}
-		}
-
-		Ok(match *event {
-			PlistEvent::StartPlist => return Err(()), // Invalid event
-			PlistEvent::EndPlist => {
-				try!(self.end_element("plist"));
-				if let Some(Element::Root) = self.stack.pop() {} else {
-					return Err(()); // Invalid event
-				}
-			},
-
-			PlistEvent::StartArray(_) => {
-				try!(self.start_element("array"));
-				self.stack.push(Element::Array);
-			}
-			PlistEvent::EndArray => {
-				try!(self.end_element("array"));
-				if let Some(Element::Array) = self.stack.pop() {} else {
-					return Err(()); // Invalid event
-				}
-			}
-
-			PlistEvent::StartDictionary(_) => {
-				try!(self.start_element("dict"));
-				self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
-			}
-			PlistEvent::EndDictionary => return Err(()), // Invalid event
-
-			PlistEvent::BooleanValue(true) => {
-				try!(self.start_element("true"));
-				try!(self.end_element("true"));
-			},
-			PlistEvent::BooleanValue(false) => {
-				try!(self.start_element("false"));
-				try!(self.end_element("false"));
-			},
-			PlistEvent::DataValue(ref value) => {
-				let base64_data = value.to_base64(MIME);
-				try!(self.write_element_and_value("data", &base64_data));
-			}
-			PlistEvent::DateValue(ref value) => {
-				let date = value.to_rfc3339();
-				try!(self.write_element_and_value("date", &date));
-			},
-			PlistEvent::IntegerValue(ref value) => try!(self.write_element_and_value("integer", &value.to_string())),
-			PlistEvent::RealValue(ref value) => try!(self.write_element_and_value("real", &value.to_string())),
-			PlistEvent::StringValue(ref value) => try!(self.write_element_and_value("string", &*value)),
-		})
-	}
+    pub fn new(writer: W) -> EventWriter<W> {
+        let config = EmitterConfig {
+            line_separator: "\n".into(),
+            indent_string: "    ".into(),
+            perform_indent: true,
+            perform_escaping: true,
+            write_document_declaration: true,
+            normalize_empty_elements: true,
+            cdata_to_characters: true,
+            keep_element_names_stack: false,
+            autopad_comments: true,
+        };
+
+        EventWriter {
+            xml_writer: XmlEventWriter::new_with_config(writer, config),
+            stack: Vec::new(),
+            empty_namespace: Namespace::empty(),
+        }
+    }
+
+    fn write_element_and_value(&mut self, name: &str, value: &str) -> Result<(), ()> {
+        try!(self.start_element(name));
+        try!(self.write_value(value));
+        try!(self.end_element(name));
+        Ok(())
+    }
+
+    fn start_element(&mut self, name: &str) -> Result<(), ()> {
+        let result = self.xml_writer.write(WriteXmlEvent::StartElement {
+            name: Name::local(name),
+            attributes: Cow::Borrowed(&[]),
+            namespace: Cow::Borrowed(&self.empty_namespace),
+        });
+
+        match result {
+            Ok(()) => Ok(()),
+            Err(_) => Err(()),
+        }
+    }
+
+    fn end_element(&mut self, name: &str) -> Result<(), ()> {
+        let result = self.xml_writer
+                         .write(WriteXmlEvent::EndElement { name: Some(Name::local(name)) });
+
+        match result {
+            Ok(()) => Ok(()),
+            Err(_) => Err(()),
+        }
+    }
+
+    fn write_value(&mut self, value: &str) -> Result<(), ()> {
+        let result = self.xml_writer.write(WriteXmlEvent::Characters(value));
+
+        match result {
+            Ok(()) => Ok(()),
+            Err(_) => Err(()),
+        }
+    }
+
+    pub fn write(&mut self, event: &PlistEvent) -> Result<(), ()> {
+        match self.stack.pop() {
+            Some(Element::Dictionary(DictionaryState::ExpectKey)) => {
+                match *event {
+                    PlistEvent::StringValue(ref value) => {
+                        try!(self.write_element_and_value("key", &*value));
+                        self.stack.push(Element::Dictionary(DictionaryState::ExpectValue));
+                    }
+                    PlistEvent::EndDictionary => try!(self.end_element("dict")),
+                    _ => return Err(()), // Invalid event
+                };
+                return Ok(());
+            }
+            Some(Element::Dictionary(DictionaryState::ExpectValue)) => {
+                self.stack.push(Element::Dictionary(DictionaryState::ExpectKey))
+            }
+            Some(other) => self.stack.push(other),
+            None => {
+                match *event {
+                    PlistEvent::StartPlist => {
+                        let version_name = Name::local("version");
+                        let version_attr = Attribute::new(version_name, "1.0");
+
+                        let result = self.xml_writer.write(WriteXmlEvent::StartElement {
+                            name: Name::local("plist"),
+                            attributes: Cow::Borrowed(&[version_attr]),
+                            namespace: Cow::Borrowed(&self.empty_namespace),
+                        });
+
+                        match result {
+                            Ok(()) => (),
+                            Err(_) => return Err(()),
+                        }
+
+                        self.stack.push(Element::Root);
+                        return Ok(());
+                    }
+                    _ => return Err(()), // Invalid event
+                }
+            }
+        }
+
+        Ok(match *event {
+            PlistEvent::StartPlist => return Err(()), // Invalid event
+            PlistEvent::EndPlist => {
+                try!(self.end_element("plist"));
+                if let Some(Element::Root) = self.stack.pop() {} else {
+                    return Err(()); // Invalid event
+                }
+            }
+
+            PlistEvent::StartArray(_) => {
+                try!(self.start_element("array"));
+                self.stack.push(Element::Array);
+            }
+            PlistEvent::EndArray => {
+                try!(self.end_element("array"));
+                if let Some(Element::Array) = self.stack.pop() {} else {
+                    return Err(()); // Invalid event
+                }
+            }
+
+            PlistEvent::StartDictionary(_) => {
+                try!(self.start_element("dict"));
+                self.stack.push(Element::Dictionary(DictionaryState::ExpectKey));
+            }
+            PlistEvent::EndDictionary => return Err(()), // Invalid event
+
+            PlistEvent::BooleanValue(true) => {
+                try!(self.start_element("true"));
+                try!(self.end_element("true"));
+            }
+            PlistEvent::BooleanValue(false) => {
+                try!(self.start_element("false"));
+                try!(self.end_element("false"));
+            }
+            PlistEvent::DataValue(ref value) => {
+                let base64_data = value.to_base64(MIME);
+                try!(self.write_element_and_value("data", &base64_data));
+            }
+            PlistEvent::DateValue(ref value) => {
+                let date = value.to_rfc3339();
+                try!(self.write_element_and_value("date", &date));
+            }
+            PlistEvent::IntegerValue(ref value) => {
+                try!(self.write_element_and_value("integer", &value.to_string()))
+            }
+            PlistEvent::RealValue(ref value) => {
+                try!(self.write_element_and_value("real", &value.to_string()))
+            }
+            PlistEvent::StringValue(ref value) => {
+                try!(self.write_element_and_value("string", &*value))
+            }
+        })
+    }
 }
 
 #[cfg(test)]
 mod tests {
-	use chrono::{TimeZone, UTC};
-	use std::io::Cursor;
-
-	use super::*;
-
-	#[test]
-	fn streaming_parser() {
-		use PlistEvent::*;
-
-		let plist = &[
-			StartPlist,
-			StartDictionary(None),
-			StringValue("Author".to_owned()),
-			StringValue("William Shakespeare".to_owned()),
-			StringValue("Lines".to_owned()),
-			StartArray(None),
-			StringValue("It is a tale told by an idiot,".to_owned()),
-			StringValue("Full of sound and fury, signifying nothing.".to_owned()),
-			EndArray,
-			StringValue("Death".to_owned()),
-			IntegerValue(1564),
-			StringValue("Height".to_owned()),
-			RealValue(1.60),
-			StringValue("Data".to_owned()),
-			DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
-			StringValue("Birthdate".to_owned()),
-			DateValue(UTC.ymd(1981, 05, 16).and_hms(11, 32, 06)),
-			EndDictionary,
-			EndPlist
-		];
-
-		let mut cursor = Cursor::new(Vec::new());
-
-		{
-			let mut plist_w = EventWriter::new(&mut cursor);
-
-			for item in plist {
-				plist_w.write(item).unwrap();
-			}
-		}
-
-		let comparison = "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+    use chrono::{TimeZone, UTC};
+    use std::io::Cursor;
+
+    use super::*;
+
+    #[test]
+    fn streaming_parser() {
+        use PlistEvent::*;
+
+        let plist = &[StartPlist,
+                      StartDictionary(None),
+                      StringValue("Author".to_owned()),
+                      StringValue("William Shakespeare".to_owned()),
+                      StringValue("Lines".to_owned()),
+                      StartArray(None),
+                      StringValue("It is a tale told by an idiot,".to_owned()),
+                      StringValue("Full of sound and fury, signifying nothing.".to_owned()),
+                      EndArray,
+                      StringValue("Death".to_owned()),
+                      IntegerValue(1564),
+                      StringValue("Height".to_owned()),
+                      RealValue(1.60),
+                      StringValue("Data".to_owned()),
+                      DataValue(vec![0, 0, 0, 190, 0, 0, 0, 3, 0, 0, 0, 30, 0, 0, 0]),
+                      StringValue("Birthdate".to_owned()),
+                      DateValue(UTC.ymd(1981, 05, 16).and_hms(11, 32, 06)),
+                      EndDictionary,
+                      EndPlist];
+
+        let mut cursor = Cursor::new(Vec::new());
+
+        {
+            let mut plist_w = EventWriter::new(&mut cursor);
+
+            for item in plist {
+                plist_w.write(item).unwrap();
+            }
+        }
+
+        let comparison = "<?xml version=\"1.0\" encoding=\"utf-8\"?>
 <plist version=\"1.0\">
-    <dict>
+    \
+                          <dict>
         <key>Author</key>
-        <string>William Shakespeare</string>
+        <string>William \
+                          Shakespeare</string>
         <key>Lines</key>
         <array>
-            <string>It is a tale told by an idiot,</string>
-            <string>Full of sound and fury, signifying nothing.</string>
-        </array>
+            \
+                          <string>It is a tale told by an idiot,</string>
+            \
+                          <string>Full of sound and fury, signifying nothing.</string>
+        \
+                          </array>
         <key>Death</key>
         <integer>1564</integer>
-        <key>Height</key>
+        \
+                          <key>Height</key>
         <real>1.6</real>
         <key>Data</key>
-        <data>AAAAvgAAAAMAAAAeAAAA</data>
+        \
+                          <data>AAAAvgAAAAMAAAAeAAAA</data>
         <key>Birthdate</key>
-        <date>1981-05-16T11:32:06+00:00</date>
+        \
+                          <date>1981-05-16T11:32:06+00:00</date>
     </dict>
 </plist>";
 
 
-		let s = String::from_utf8(cursor.into_inner()).unwrap();
+        let s = String::from_utf8(cursor.into_inner()).unwrap();
 
-		assert_eq!(&s, comparison);
-	}
-}
\ No newline at end of file
+        assert_eq!(&s, comparison);
+    }
+}