update code format

yaserde/src/de/mod.rs

@@ -1,4 +1,3 @@
-
 use std::io::Read;
 use xml::reader::{EventReader, ParserConfig, XmlEvent};
 use xml::name::OwnedName;
@@ -56,9 +55,9 @@ impl<'de, R: Read> Deserializer<R> {
     loop {
       if let Ok(next) = self.reader.next() {
         match next {
-          XmlEvent::StartDocument { .. } |
+          XmlEvent::StartDocument { .. }
-          XmlEvent::ProcessingInstruction { .. } |
+          | XmlEvent::ProcessingInstruction { .. }
-          XmlEvent::Comment(_) => { /* skip */ },
+          | XmlEvent::Comment(_) => { /* skip */ }
           other => return Ok(other),
         }
       } else {
@@ -77,11 +76,11 @@ impl<'de, R: Read> Deserializer<R> {
     match next {
       XmlEvent::StartElement { .. } => {
         self.depth += 1;
-      },
+      }
       XmlEvent::EndElement { .. } => {
         self.depth -= 1;
-      },
+      }
-      _ => {},
+      _ => {}
     }
     debug!("Fetched {:?}", next);
     Ok(next)
@@ -113,14 +112,13 @@ impl<'de, R: Read> Deserializer<R> {
   }
 
   pub fn expect_end_element(&mut self, start_name: OwnedName) -> Result<(), String> {
-    if let XmlEvent::EndElement{ name, .. } = self.next()? {
+    if let XmlEvent::EndElement { name, .. } = self.next()? {
       if name == start_name {
         Ok(())
       } else {
         Err(format!(
           "End tag </{}> didn't match the start tag <{}>",
-          name.local_name,
+          name.local_name, start_name.local_name
-          start_name.local_name
         ))
       }
     } else {

yaserde/src/lib.rs

@@ -1,4 +1,3 @@
-
 #[macro_use]
 extern crate log;
 extern crate xml;
@@ -13,11 +12,11 @@ use xml::writer::XmlEvent;
 pub mod de;
 pub mod ser;
 
-pub trait YaDeserialize : Sized {
+pub trait YaDeserialize: Sized {
   fn deserialize<R: Read>(reader: &mut de::Deserializer<R>) -> Result<Self, String>;
 }
 
-pub trait YaSerialize : Sized {
+pub trait YaSerialize: Sized {
   fn serialize<W: Write>(&self, writer: &mut ser::Serializer<W>) -> Result<(), String>;
 }
 
@@ -25,60 +24,49 @@ pub trait Visitor<'de>: Sized {
   /// The value produced by this visitor.
   type Value;
 
-  fn visit_bool(self, v: &str) -> Result<Self::Value, String>
+  fn visit_bool(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected bool {}", v))
   }
 
-  fn visit_i8(self, v: &str) -> Result<Self::Value, String>
+  fn visit_i8(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected i8 {}", v))
   }
 
-  fn visit_u8(self, v: &str) -> Result<Self::Value, String>
+  fn visit_u8(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected u8 {}", v))
   }
 
-  fn visit_i16(self, v: &str) -> Result<Self::Value, String>
+  fn visit_i16(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected i16 {}", v))
   }
 
-  fn visit_u16(self, v: &str) -> Result<Self::Value, String>
+  fn visit_u16(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected u16 {}", v))
   }
 
-  fn visit_i32(self, v: &str) -> Result<Self::Value, String>
+  fn visit_i32(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected i32 {}", v))
   }
 
-  fn visit_u32(self, v: &str) -> Result<Self::Value, String>
+  fn visit_u32(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected u32 {}", v))
   }
 
-  fn visit_i64(self, v: &str) -> Result<Self::Value, String>
+  fn visit_i64(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected i64 {}", v))
   }
 
-  fn visit_u64(self, v: &str) -> Result<Self::Value, String>
+  fn visit_u64(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected u64 {}", v))
   }
 
-  fn visit_str(self, v: &str) -> Result<Self::Value, String>
+  fn visit_str(self, v: &str) -> Result<Self::Value, String> {
-  {
     Err(format!("Unexpected str {}", v))
   }
 
   #[inline]
   #[cfg(any(feature = "std", feature = "alloc"))]
-  fn visit_string<String>(self, v: String) -> Result<Self::Value, String>
+  fn visit_string<String>(self, v: String) -> Result<Self::Value, String> {
-  {
     self.visit_str(&v)
   }
 }

yaserde/src/ser/mod.rs

@@ -1,4 +1,3 @@
-
 use std::str;
 use std::io::{Cursor, Write};
 use xml::{EmitterConfig, EventWriter};
@@ -28,7 +27,10 @@ pub fn to_string_content<T: YaSerialize>(model: &T) -> Result<String, String> {
   Ok(String::from(data))
 }
 
-pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(model: &T, writer: W) -> Result<W, String> {
+pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(
+  model: &T,
+  writer: W,
+) -> Result<W, String> {
   let mut serializer = Serializer::new_for_inner(writer);
   serializer.set_skip_start_end(true);
   match model.serialize(&mut serializer) {
@@ -39,27 +41,25 @@ pub fn serialize_with_writer_content<W: Write, T: YaSerialize>(model: &T, writer
 
 pub struct Serializer<W: Write> {
   writer: EventWriter<W>,
-  skip_start_end: bool
+  skip_start_end: bool,
 }
 
 impl<'de, W: Write> Serializer<W> {
   pub fn new(writer: EventWriter<W>) -> Self {
     Serializer {
       writer: writer,
-      skip_start_end: false
+      skip_start_end: false,
     }
   }
 
   pub fn new_from_writer(writer: W) -> Self {
-    let config = EmitterConfig::new()
+    let config = EmitterConfig::new().cdata_to_characters(true);
-      .cdata_to_characters(true);
 
     Self::new(EventWriter::new_with_config(writer, config))
   }
 
   pub fn new_for_inner(writer: W) -> Self {
-    let config = EmitterConfig::new()
+    let config = EmitterConfig::new().write_document_declaration(false);
-      .write_document_declaration(false);
 
     Self::new(EventWriter::new_with_config(writer, config))
   }
@@ -77,7 +77,9 @@ impl<'de, W: Write> Serializer<W> {
   }
 
   pub fn write<'a, E>(&mut self, event: E) -> xml::writer::Result<()>
-    where E: Into<XmlEvent<'a>> {
+  where
+    E: Into<XmlEvent<'a>>,
+  {
     self.writer.write(event)
   }
 }

yaserde/tests/der_namespace.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Read;
 use yaserde::YaDeserialize;
@@ -20,32 +19,33 @@ macro_rules! convert_and_validate {
 #[test]
 fn de_struct_namespace() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="book", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
+  #[yaserde(root = "book", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
   pub struct Book {
-    #[yaserde(prefix="ns")]
+    #[yaserde(prefix = "ns")] author: String,
-    author: String,
+    #[yaserde(prefix = "ns")] title: String,
-    #[yaserde(prefix="ns")]
-    title: String,
   }
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:book xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:author>Antoine de Saint-Exupéry</ns:author><ns:title>Little prince</ns:title></ns:book>";
-  convert_and_validate!(content, Book, Book{
+  convert_and_validate!(
-    author: String::from("Antoine de Saint-Exupéry"),
+    content,
-    title: String::from("Little prince")
+    Book,
-  });
+    Book {
+      author: String::from("Antoine de Saint-Exupéry"),
+      title: String::from("Little prince"),
+    }
+  );
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:book xmlns:ns=\"http://www.sample.com/ns/domain2\"><ns:author>Antoine de Saint-Exupéry</ns:author><ns:title>Little prince</ns:title></ns:book>";
-  let loaded : Result<Book, String> = from_str(content);
+  let loaded: Result<Book, String> = from_str(content);
   assert_eq!(loaded, Err("bad namespace".to_string()));
 }
 
 #[test]
 fn de_enum_namespace() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
+  #[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
   pub enum XmlStruct {
-    #[yaserde(prefix="ns")]
+    #[yaserde(prefix = "ns")] Item,
-    Item
   }
 
   impl Default for XmlStruct {

yaserde/tests/der_type.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Read;
 use yaserde::YaDeserialize;

yaserde/tests/deserializer.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Read;
 use yaserde::YaDeserialize;
@@ -20,188 +19,203 @@ macro_rules! convert_and_validate {
 #[test]
 fn de_basic() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="book")]
+  #[yaserde(root = "book")]
   pub struct Book {
     author: String,
     title: String,
   }
 
-  let content = "<book><author>Antoine de Saint-Exupéry</author><title>Little prince</title></book>";
+  let content =
-  convert_and_validate!(content, Book, Book{
+    "<book><author>Antoine de Saint-Exupéry</author><title>Little prince</title></book>";
-    author: String::from("Antoine de Saint-Exupéry"),
+  convert_and_validate!(
-    title: String::from("Little prince")
+    content,
-  });
+    Book,
+    Book {
+      author: String::from("Antoine de Saint-Exupéry"),
+      title: String::from("Little prince"),
+    }
+  );
 
-  let content = "<book><title>Little prince</title><author>Antoine de Saint-Exupéry</author></book>";
+  let content =
-  convert_and_validate!(content, Book, Book{
+    "<book><title>Little prince</title><author>Antoine de Saint-Exupéry</author></book>";
-    author: String::from("Antoine de Saint-Exupéry"),
+  convert_and_validate!(
-    title: String::from("Little prince")
+    content,
-  });
+    Book,
+    Book {
+      author: String::from("Antoine de Saint-Exupéry"),
+      title: String::from("Little prince"),
+    }
+  );
 }
 
 #[test]
 fn de_list_of_items() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="library")]
+  #[yaserde(root = "library")]
   pub struct Library {
-    books: Vec<String>
+    books: Vec<String>,
   }
 
   let content = "<library><books>Little Prince</books><books>Harry Potter</books></library>";
-  convert_and_validate!(content, Library, Library{
+  convert_and_validate!(
-    books: vec![
+    content,
-      String::from("Little Prince"),
+    Library,
-      String::from("Harry Potter")
+    Library {
-    ]
+      books: vec![String::from("Little Prince"), String::from("Harry Potter")],
-  });
+    }
+  );
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="libraries")]
+  #[yaserde(root = "libraries")]
   pub struct Libraries {
-    library: Vec<Library>
+    library: Vec<Library>,
   }
 
   let content = "<libraries><library><books>Little Prince</books></library><library><books>Harry Potter</books></library></libraries>";
-  convert_and_validate!(content, Libraries, Libraries{
+  convert_and_validate!(
-    library: vec![
+    content,
-      Library{
+    Libraries,
-        books: vec![
+    Libraries {
-          String::from("Little Prince")
+      library: vec![
-        ]
+        Library {
-      },
+          books: vec![String::from("Little Prince")],
-      Library{
+        },
-        books: vec![
+        Library {
-          String::from("Harry Potter")
+          books: vec![String::from("Harry Potter")],
-        ]
+        },
-      }
+      ],
-    ]
+    }
-  });
+  );
 }
 
 #[test]
 fn de_attributes() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] item: String,
-    item: String,
+    sub: SubStruct,
-    sub: SubStruct
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] subitem: String,
-    subitem: String
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
-        subitem: "".to_string()
+        subitem: "".to_string(),
       }
     }
   }
 
   let content = "<base item=\"something\"><sub subitem=\"sub-something\"></sub></base>";
-  convert_and_validate!(content, XmlStruct, XmlStruct{
+  convert_and_validate!(
-    item: "something".to_string(),
+    content,
-    sub: SubStruct{
+    XmlStruct,
-      subitem: "sub-something".to_string()
+    XmlStruct {
+      item: "something".to_string(),
+      sub: SubStruct {
+        subitem: "sub-something".to_string(),
+      },
     }
-  });
+  );
 }
 
 #[test]
 fn de_rename() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute, rename="Item")]
+    #[yaserde(attribute, rename = "Item")] item: String,
-    item: String,
+    #[yaserde(rename = "sub")] sub_struct: SubStruct,
-    #[yaserde(rename="sub")]
-    sub_struct: SubStruct
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute, rename="sub_item")]
+    #[yaserde(attribute, rename = "sub_item")] subitem: String,
-    subitem: String,
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
-        subitem: "".to_string()
+        subitem: "".to_string(),
       }
     }
   }
 
   let content = "<base Item=\"something\"><sub sub_item=\"sub_something\"></sub></base>";
-  convert_and_validate!(content, XmlStruct, XmlStruct{
+  convert_and_validate!(
-    item: "something".to_string(),
+    content,
-    sub_struct: SubStruct{
+    XmlStruct,
-      subitem: "sub_something".to_string()
+    XmlStruct {
+      item: "something".to_string(),
+      sub_struct: SubStruct {
+        subitem: "sub_something".to_string(),
+      },
     }
-  });
+  );
 }
 
 #[test]
 fn de_text_content_with_attributes() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute, rename="Item")]
+    #[yaserde(attribute, rename = "Item")] item: String,
-    item: String,
+    #[yaserde(rename = "sub")] sub_struct: SubStruct,
-    #[yaserde(rename="sub")]
-    sub_struct: SubStruct
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute, rename="sub_item")]
+    #[yaserde(attribute, rename = "sub_item")] subitem: String,
-    subitem: String,
+    #[yaserde(text)] text: String,
-    #[yaserde(text)]
-    text: String
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
         subitem: "".to_string(),
         text: "".to_string(),
       }
     }
   }
 
-  let content = "<base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
+  let content =
-  convert_and_validate!(content, XmlStruct, XmlStruct{
+    "<base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
-    item: "something".to_string(),
+  convert_and_validate!(
-    sub_struct: SubStruct{
+    content,
-      subitem: "sub_something".to_string(),
+    XmlStruct,
-      text: "text_content".to_string()
+    XmlStruct {
+      item: "something".to_string(),
+      sub_struct: SubStruct {
+        subitem: "sub_something".to_string(),
+        text: "text_content".to_string(),
+      },
     }
-  });
+  );
 }
 
 #[test]
 fn de_enum() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    background: Color
+    background: Color,
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct Colors {
-    items: Vec<Color>
+    items: Vec<Color>,
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="color")]
+  #[yaserde(root = "color")]
   pub enum Color {
     White,
     Black,
@@ -222,7 +236,7 @@ fn de_enum() {
 
   impl Default for RGBColor {
     fn default() -> RGBColor {
-      RGBColor{
+      RGBColor {
         red: "0".to_string(),
         green: "0".to_string(),
         blue: "0".to_string(),
@@ -230,28 +244,36 @@ fn de_enum() {
     }
   }
 
-  let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
+  let content =
-  convert_and_validate!(content, XmlStruct, XmlStruct{
+    "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><background>Black</background></base>";
-    background: Color::Black
+  convert_and_validate!(
-  });
+    content,
+    XmlStruct,
+    XmlStruct {
+      background: Color::Black,
+    }
+  );
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>Black</items><items>White</items></base>";
-  convert_and_validate!(content, Colors, Colors{
+  convert_and_validate!(
-    items: vec![Color::Black, Color::White]
+    content,
-  });
+    Colors,
+    Colors {
+      items: vec![Color::Black, Color::White],
+    }
+  );
 }
 
 #[test]
 fn de_attribute_enum() {
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] background: Color,
-    background: Color
   }
 
   #[derive(YaDeserialize, PartialEq, Debug)]
-  #[yaserde(root="color")]
+  #[yaserde(root = "color")]
   pub enum Color {
     White,
     Black,
@@ -264,7 +286,11 @@ fn de_attribute_enum() {
   }
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base background=\"Black\" />";
-  convert_and_validate!(content, XmlStruct, XmlStruct{
+  convert_and_validate!(
-    background: Color::Black
+    content,
-  });
+    XmlStruct,
+    XmlStruct {
+      background: Color::Black,
+    }
+  );
 }

yaserde/tests/se_namespace.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Write;
 use yaserde::YaSerialize;
@@ -20,14 +19,13 @@ macro_rules! convert_and_validate {
 #[test]
 fn ser_struct_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
+  #[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
   pub struct XmlStruct {
-    #[yaserde(prefix="ns")]
+    #[yaserde(prefix = "ns")] item: String,
-    item: String
   }
 
   let model = XmlStruct {
-    item: "something".to_string()
+    item: "something".to_string(),
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><ns:root xmlns:ns=\"http://www.sample.com/ns/domain\"><ns:item>something</ns:item></ns:root>";
@@ -37,10 +35,9 @@ fn ser_struct_namespace() {
 #[test]
 fn ser_enum_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="root", prefix="ns", namespace="ns: http://www.sample.com/ns/domain")]
+  #[yaserde(root = "root", prefix = "ns", namespace = "ns: http://www.sample.com/ns/domain")]
   pub enum XmlStruct {
-    #[yaserde(prefix="ns")]
+    #[yaserde(prefix = "ns")] Item,
-    Item
   }
 
   let model = XmlStruct::Item;
@@ -52,12 +49,11 @@ fn ser_enum_namespace() {
 #[test]
 fn ser_struct_multi_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
+  #[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
+            namespace = "ns2: http://www.sample.com/ns/domain2")]
   pub struct XmlStruct {
-    #[yaserde(prefix="ns1")]
+    #[yaserde(prefix = "ns1")] item_1: String,
-    item_1: String,
+    #[yaserde(prefix = "ns2")] item_2: String,
-    #[yaserde(prefix="ns2")]
-    item_2: String,
   }
 
   let model = XmlStruct {
@@ -69,16 +65,14 @@ fn ser_struct_multi_namespace() {
   convert_and_validate!(model, content);
 }
 
-
 #[test]
 fn ser_enum_multi_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
+  #[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
+            namespace = "ns2: http://www.sample.com/ns/domain2")]
   pub enum XmlStruct {
-    #[yaserde(prefix="ns1")]
+    #[yaserde(prefix = "ns1")] Item1,
-    Item1,
+    #[yaserde(prefix = "ns2")] Item2,
-    #[yaserde(prefix="ns2")]
-    Item2,
   }
 
   let model1 = XmlStruct::Item1;
@@ -89,16 +83,14 @@ fn ser_enum_multi_namespace() {
   convert_and_validate!(model2, content);
 }
 
-
 #[test]
 fn ser_struct_attribute_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="root", namespace="ns1: http://www.sample.com/ns/domain1", namespace="ns2: http://www.sample.com/ns/domain2")]
+  #[yaserde(root = "root", namespace = "ns1: http://www.sample.com/ns/domain1",
+            namespace = "ns2: http://www.sample.com/ns/domain2")]
   pub struct XmlStruct {
-    #[yaserde(prefix="ns1")]
+    #[yaserde(prefix = "ns1")] item_1: String,
-    item_1: String,
+    #[yaserde(attribute, prefix = "ns2")] item_2: String,
-    #[yaserde(attribute, prefix="ns2")]
-    item_2: String,
   }
 
   let model = XmlStruct {
@@ -113,13 +105,14 @@ fn ser_struct_attribute_namespace() {
 #[test]
 fn ser_struct_default_namespace() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="tt", namespace="http://www.w3.org/ns/ttml", namespace="ttm: http://www.w3.org/ns/ttml#metadata")]
+  #[yaserde(root = "tt", namespace = "http://www.w3.org/ns/ttml",
+            namespace = "ttm: http://www.w3.org/ns/ttml#metadata")]
   pub struct XmlStruct {
-    item: String
+    item: String,
   }
 
   let model = XmlStruct {
-    item: "something".to_string()
+    item: "something".to_string(),
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\"><item>something</item></tt>";

yaserde/tests/se_type.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Write;
 use yaserde::YaSerialize;

yaserde/tests/serializer.rs

@@ -1,10 +1,9 @@
-
+#[macro_use]
+extern crate log;
+extern crate xml;
 extern crate yaserde;
 #[macro_use]
 extern crate yaserde_derive;
-extern crate xml;
-#[macro_use]
-extern crate log;
 
 use std::io::Write;
 use yaserde::YaSerialize;
@@ -20,13 +19,13 @@ macro_rules! convert_and_validate {
 #[test]
 fn ser_basic() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    item: String
+    item: String,
   }
 
   let model = XmlStruct {
-    item: "something".to_string()
+    item: "something".to_string(),
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><item>something</item></base>";
@@ -36,44 +35,39 @@ fn ser_basic() {
 #[test]
 fn ser_list_of_items() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    items: Vec<String>
+    items: Vec<String>,
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct {
-    items: vec![
+    items: vec!["something1".to_string(), "something2".to_string()],
-      "something1".to_string(),
-      "something2".to_string()
-    ]
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items>something1</items><items>something2</items></base>";
   convert_and_validate!(model, content);
 
-
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStructOfStruct {
-    items: Vec<SubStruct>
+    items: Vec<SubStruct>,
   }
 
-
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="items")]
+  #[yaserde(root = "items")]
   pub struct SubStruct {
-    field: String
+    field: String,
   }
 
-  let model2 = XmlStructOfStruct{
+  let model2 = XmlStructOfStruct {
     items: vec![
-      SubStruct{
+      SubStruct {
-        field: "something1".to_string()
+        field: "something1".to_string(),
       },
-      SubStruct{
+      SubStruct {
-        field: "something2".to_string()
+        field: "something2".to_string(),
-      }
+      },
-    ]
+    ],
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><items><field>something1</field></items><items><field>something2</field></items></base>";
@@ -83,33 +77,31 @@ fn ser_list_of_items() {
 #[test]
 fn se_attributes() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] item: String,
-    item: String,
+    sub: SubStruct,
-    sub: SubStruct
   }
 
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] subitem: String,
-    subitem: String
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
-        subitem: "".to_string()
+        subitem: "".to_string(),
       }
     }
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct {
     item: "something".to_string(),
-    sub: SubStruct{
+    sub: SubStruct {
-      subitem: "sub-something".to_string()
+      subitem: "sub-something".to_string(),
-    }
+    },
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base item=\"something\"><sub subitem=\"sub-something\" /></base>";
@@ -119,34 +111,31 @@ fn se_attributes() {
 #[test]
 fn ser_rename() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute, rename="Item")]
+    #[yaserde(attribute, rename = "Item")] item: String,
-    item: String,
+    #[yaserde(rename = "sub")] sub_struct: SubStruct,
-    #[yaserde(rename="sub")]
-    sub_struct: SubStruct
   }
 
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute, rename="sub_item")]
+    #[yaserde(attribute, rename = "sub_item")] subitem: String,
-    subitem: String,
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
-        subitem: "".to_string()
+        subitem: "".to_string(),
       }
     }
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct {
     item: "something".to_string(),
-    sub_struct: SubStruct{
+    sub_struct: SubStruct {
-      subitem: "sub_something".to_string()
+      subitem: "sub_something".to_string(),
-    }
+    },
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\" /></base>";
@@ -156,38 +145,34 @@ fn ser_rename() {
 #[test]
 fn ser_text_content_with_attributes() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute, rename="Item")]
+    #[yaserde(attribute, rename = "Item")] item: String,
-    item: String,
+    #[yaserde(rename = "sub")] sub_struct: SubStruct,
-    #[yaserde(rename="sub")]
-    sub_struct: SubStruct
   }
 
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="sub")]
+  #[yaserde(root = "sub")]
   pub struct SubStruct {
-    #[yaserde(attribute, rename="sub_item")]
+    #[yaserde(attribute, rename = "sub_item")] subitem: String,
-    subitem: String,
+    #[yaserde(text)] text: String,
-    #[yaserde(text)]
-    text: String,
   }
 
   impl Default for SubStruct {
     fn default() -> SubStruct {
-      SubStruct{
+      SubStruct {
         subitem: "".to_string(),
         text: "".to_string(),
       }
     }
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct {
     item: "something".to_string(),
-    sub_struct: SubStruct{
+    sub_struct: SubStruct {
       subitem: "sub_something".to_string(),
-      text: "text_content".to_string()
+      text: "text_content".to_string(),
-    }
+    },
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base Item=\"something\"><sub sub_item=\"sub_something\">text_content</sub></base>";
@@ -197,23 +182,23 @@ fn ser_text_content_with_attributes() {
 #[test]
 fn ser_enum() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    color: Color
+    color: Color,
   }
 
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="color")]
+  #[yaserde(root = "color")]
   pub enum Color {
     White,
     Black,
-    #[yaserde(rename="custom")]
+    #[yaserde(rename = "custom")]
     Custom {
       enabled: String,
       color: RGBColor,
       alpha: Alpha,
       alphas: Vec<Alpha>,
-    }
+    },
   }
 
   impl Default for Color {
@@ -235,50 +220,45 @@ fn ser_enum() {
     Opaque,
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct {
-    color: Color::Black
+    color: Color::Black,
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><color>Black</color></base>";
   convert_and_validate!(model, content);
 
-  let model = XmlStruct{
+  let model = XmlStruct {
-    color: Color::Custom{
+    color: Color::Custom {
       enabled: "true".to_string(),
-      color: RGBColor{
+      color: RGBColor {
         red: "0".to_string(),
         green: "128".to_string(),
         blue: "255".to_string(),
       },
       alpha: Alpha::Opaque,
-      alphas: vec![Alpha::Opaque, Alpha::Transparent]
+      alphas: vec![Alpha::Opaque, Alpha::Transparent],
-    }
+    },
   };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base><color><custom><enabled>true</enabled><color><red>0</red><green>128</green><blue>255</blue></color><alpha>Opaque</alpha><alphas>Opaque</alphas><alphas>Transparent</alphas></custom></color></base>";
   convert_and_validate!(model, content);
 }
 
-
 #[test]
 fn ser_attribute_enum() {
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="base")]
+  #[yaserde(root = "base")]
   pub struct XmlStruct {
-    #[yaserde(attribute)]
+    #[yaserde(attribute)] color: Color,
-    color: Color
   }
 
   #[derive(YaSerialize, PartialEq, Debug)]
-  #[yaserde(root="color")]
+  #[yaserde(root = "color")]
   pub enum Color {
-    #[yaserde(rename="pink")]
+    #[yaserde(rename = "pink")] Pink,
-    Pink,
   }
 
-  let model = XmlStruct{
+  let model = XmlStruct { color: Color::Pink };
-    color: Color::Pink
-  };
 
   let content = "<?xml version=\"1.0\" encoding=\"utf-8\"?><base color=\"pink\" />";
   convert_and_validate!(model, content);

yaserde_derive/src/attribute.rs

@@ -1,4 +1,3 @@
-
 use proc_macro2::TokenTreeIter;
 use proc_macro2::TokenNode::*;
 use proc_macro2::Spacing;
@@ -18,13 +17,9 @@ pub struct YaSerdeAttribute {
 
 fn get_value(iter: &mut TokenTreeIter) -> Option<String> {
   match (iter.next(), iter.next()) {
-    (Some(operator), Some(value)) => {
+    (Some(operator), Some(value)) => match (operator.kind, value.kind) {
-      match (operator.kind, value.kind) {
+      (Op('=', Spacing::Alone), Literal(l)) => Some(l.to_string().replace("\"", "")),
-        (Op('=', Spacing::Alone), Literal(l)) => {
+      _ => None,
-          Some(l.to_string().replace("\"", ""))
-        },
-        _ => None,
-      }
     },
     _ => None,
   }
@@ -42,54 +37,48 @@ impl YaSerdeAttribute {
     for attr in attrs.iter() {
       let mut attr_iter = attr.clone().tts.into_iter();
       match attr_iter.next() {
-        Some(token) => {
+        Some(token) => match token.kind {
-          match token.kind {
+          Group(Parenthesis, token_stream) => {
-            Group(Parenthesis, token_stream) => {
+            let mut attr_iter = token_stream.into_iter();
-              let mut attr_iter = token_stream.into_iter();
 
-              while let Some(item) = attr_iter.next() {
+            while let Some(item) = attr_iter.next() {
-                match item.kind {
+              match item.kind {
-                  Term(t) => {
+                Term(t) => match t.as_str() {
-                    match t.as_str() {
+                  "attribute" => {
-                      "attribute" => {
+                    attribute = true;
-                        attribute = true;
+                  }
-                      },
+                  "namespace" => {
-                      "namespace" => {
+                    if let Some(namespace) = get_value(&mut attr_iter) {
-                        if let Some(namespace) = get_value(&mut attr_iter) {
+                      let splitted: Vec<&str> = namespace.split(": ").collect();
-
+                      if splitted.len() == 2 {
-                          let splitted : Vec<&str> = namespace.split(": ").collect();
+                        namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned());
-                          if splitted.len() == 2 {
-                            namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned());
-                          }
-                          if splitted.len() == 1 {
-                            namespaces.insert("".to_owned(), splitted[0].to_owned());
-                          }
-                          
-                        }
-                      },
-                      "prefix" => {
-                        prefix = get_value(&mut attr_iter);
                       }
-                      "rename" => {
+                      if splitted.len() == 1 {
-                        rename = get_value(&mut attr_iter);
+                        namespaces.insert("".to_owned(), splitted[0].to_owned());
-                      },
-                      "root" => {
-                        root = get_value(&mut attr_iter);
-                      },
-                      "text" => {
-                        text = true;
                       }
-                      _ => {},
                     }
-                  },
+                  }
+                  "prefix" => {
+                    prefix = get_value(&mut attr_iter);
+                  }
+                  "rename" => {
+                    rename = get_value(&mut attr_iter);
+                  }
+                  "root" => {
+                    root = get_value(&mut attr_iter);
+                  }
+                  "text" => {
+                    text = true;
+                  }
                   _ => {}
-                }
+                },
+                _ => {}
               }
-            },
+            }
-            _ => {},
           }
+          _ => {}
         },
-        None => {},
+        None => {}
       }
     }
 

yaserde_derive/src/de/expand_enum.rs

@@ -1,4 +1,3 @@
-
 use attribute::*;
 use field_type::*;
 use quote::Tokens;
@@ -8,125 +7,167 @@ use syn::Ident;
 use syn::DataEnum;
 use proc_macro2::Span;
 
-pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BTreeMap<String, String>) -> Tokens {
+pub fn parse(
-  let variables : Tokens = data_enum.variants.iter().map(|ref variant|
+  data_enum: &DataEnum,
-    {
+  name: &Ident,
-      match variant.fields {
+  root: &String,
-        Fields::Unit => None,
+  _namespaces: &BTreeMap<String, String>,
-        Fields::Named(ref fields) => {
+) -> Tokens {
-          let enum_fields = fields.named.iter().map(|ref field| {
+  let variables: Tokens = data_enum
+    .variants
+    .iter()
+    .map(|ref variant| match variant.fields {
+      Fields::Unit => None,
+      Fields::Named(ref fields) => {
+        let enum_fields = fields
+          .named
+          .iter()
+          .map(|ref field| {
             let field_label = field.ident;
 
             match get_field_type(field) {
-              Some(FieldType::FieldTypeString) =>
+              Some(FieldType::FieldTypeString) => {
-                build_default_value(&field_label, quote!{String}, quote!{"".to_string()}),
+                build_default_value(&field_label, quote!{String}, quote!{"".to_string()})
-              Some(FieldType::FieldTypeBool) =>
+              }
-                build_default_value(&field_label, quote!{bool}, quote!{false}),
+              Some(FieldType::FieldTypeBool) => {
-              Some(FieldType::FieldTypeI8) =>
+                build_default_value(&field_label, quote!{bool}, quote!{false})
-                build_default_value(&field_label, quote!{i8}, quote!{0}),
+              }
-              Some(FieldType::FieldTypeU8) =>
+              Some(FieldType::FieldTypeI8) => {
-                build_default_value(&field_label, quote!{u8}, quote!{0}),
+                build_default_value(&field_label, quote!{i8}, quote!{0})
-              Some(FieldType::FieldTypeI16) =>
+              }
-                build_default_value(&field_label, quote!{i16}, quote!{0}),
+              Some(FieldType::FieldTypeU8) => {
-              Some(FieldType::FieldTypeU16) =>
+                build_default_value(&field_label, quote!{u8}, quote!{0})
-                build_default_value(&field_label, quote!{u16}, quote!{0}),
+              }
-              Some(FieldType::FieldTypeI32) =>
+              Some(FieldType::FieldTypeI16) => {
-                build_default_value(&field_label, quote!{i32}, quote!{0}),
+                build_default_value(&field_label, quote!{i16}, quote!{0})
-              Some(FieldType::FieldTypeU32) =>
+              }
-                build_default_value(&field_label, quote!{u32}, quote!{0}),
+              Some(FieldType::FieldTypeU16) => {
-              Some(FieldType::FieldTypeI64) =>
+                build_default_value(&field_label, quote!{u16}, quote!{0})
-                build_default_value(&field_label, quote!{i64}, quote!{0}),
+              }
-              Some(FieldType::FieldTypeU64) =>
+              Some(FieldType::FieldTypeI32) => {
-                build_default_value(&field_label, quote!{u64}, quote!{0}),
+                build_default_value(&field_label, quote!{i32}, quote!{0})
-              Some(FieldType::FieldTypeStruct{struct_name}) => {
+              }
-                Some(quote!{
+              Some(FieldType::FieldTypeU32) => {
-                  #[allow(unused_mut)]
+                build_default_value(&field_label, quote!{u32}, quote!{0})
-                  let mut #field_label : #struct_name = #struct_name::default();
+              }
-                })
+              Some(FieldType::FieldTypeI64) => {
-              },
+                build_default_value(&field_label, quote!{i64}, quote!{0})
-              Some(FieldType::FieldTypeVec{data_type}) => {
+              }
+              Some(FieldType::FieldTypeU64) => {
+                build_default_value(&field_label, quote!{u64}, quote!{0})
+              }
+              Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
+                #[allow(unused_mut)]
+                let mut #field_label : #struct_name = #struct_name::default();
+              }),
+              Some(FieldType::FieldTypeVec { data_type }) => {
                 let dt = Box::into_raw(data_type);
-                match unsafe{dt.as_ref()} {
+                match unsafe { dt.as_ref() } {
-                  Some(&FieldType::FieldTypeString) =>
+                  Some(&FieldType::FieldTypeString) => {
-                    build_default_value(&field_label, quote!{Vec<String>}, quote!{vec![]}),
+                    build_default_value(&field_label, quote!{Vec<String>}, quote!{vec![]})
-                  Some(&FieldType::FieldTypeBool) =>
+                  }
-                    build_default_value(&field_label, quote!{Vec<bool>}, quote!{vec![]}),
+                  Some(&FieldType::FieldTypeBool) => {
-                  Some(&FieldType::FieldTypeI8) =>
+                    build_default_value(&field_label, quote!{Vec<bool>}, quote!{vec![]})
-                    build_default_value(&field_label, quote!{Vec<i8>}, quote!{vec![]}),
+                  }
-                  Some(&FieldType::FieldTypeU8) =>
+                  Some(&FieldType::FieldTypeI8) => {
-                    build_default_value(&field_label, quote!{Vec<u8>}, quote!{vec![]}),
+                    build_default_value(&field_label, quote!{Vec<i8>}, quote!{vec![]})
-                  Some(&FieldType::FieldTypeI16) =>
+                  }
-                    build_default_value(&field_label, quote!{Vec<i16>}, quote!{vec![]}),
+                  Some(&FieldType::FieldTypeU8) => {
-                  Some(&FieldType::FieldTypeU16) =>
+                    build_default_value(&field_label, quote!{Vec<u8>}, quote!{vec![]})
-                    build_default_value(&field_label, quote!{Vec<u16>}, quote!{vec![]}),
+                  }
-                  Some(&FieldType::FieldTypeI32) =>
+                  Some(&FieldType::FieldTypeI16) => {
-                    build_default_value(&field_label, quote!{Vec<i32>}, quote!{vec![]}),
+                    build_default_value(&field_label, quote!{Vec<i16>}, quote!{vec![]})
-                  Some(&FieldType::FieldTypeU32) =>
+                  }
-                    build_default_value(&field_label, quote!{Vec<u32>}, quote!{vec![]}),
+                  Some(&FieldType::FieldTypeU16) => {
-                  Some(&FieldType::FieldTypeI64) =>
+                    build_default_value(&field_label, quote!{Vec<u16>}, quote!{vec![]})
-                    build_default_value(&field_label, quote!{Vec<i64>}, quote!{vec![]}),
+                  }
-                  Some(&FieldType::FieldTypeU64) =>
+                  Some(&FieldType::FieldTypeI32) => {
-                    build_default_value(&field_label, quote!{Vec<u64>}, quote!{vec![]}),
+                    build_default_value(&field_label, quote!{Vec<i32>}, quote!{vec![]})
-                  Some(&FieldType::FieldTypeStruct{struct_name}) => {
+                  }
-                    Some(quote!{
+                  Some(&FieldType::FieldTypeU32) => {
-                      #[allow(unused_mut)]
+                    build_default_value(&field_label, quote!{Vec<u32>}, quote!{vec![]})
-                      let mut #field_label : Vec<#struct_name> = vec![];
+                  }
-                    })
+                  Some(&FieldType::FieldTypeI64) => {
-                  },
+                    build_default_value(&field_label, quote!{Vec<i64>}, quote!{vec![]})
-                  Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
+                  }
-                  None => {unimplemented!();},
+                  Some(&FieldType::FieldTypeU64) => {
+                    build_default_value(&field_label, quote!{Vec<u64>}, quote!{vec![]})
+                  }
+                  Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
+                    #[allow(unused_mut)]
+                    let mut #field_label : Vec<#struct_name> = vec![];
+                  }),
+                  Some(&FieldType::FieldTypeVec { .. }) => {
+                    unimplemented!();
+                  }
+                  None => {
+                    unimplemented!();
+                  }
                 }
-              },
+              }
-              None => None
+              None => None,
             }
-
           })
           .filter(|x| x.is_some())
           .map(|x| x.unwrap())
-          .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+          .fold(Tokens::new(), |mut sum, val| {
+            sum.append_all(val);
+            sum
+          });
 
-          Some(enum_fields)
+        Some(enum_fields)
-        }
+      }
-        Fields::Unnamed(ref _fields) => {
+      Fields::Unnamed(ref _fields) => {
-          unimplemented!();
+        unimplemented!();
-        }
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let enum_visitors: Tokens = data_enum.variants.iter().map(|ref variant| {
+  let enum_visitors: Tokens = data_enum
+    .variants
+    .iter()
+    .map(|ref variant| {
       match variant.fields {
         Fields::Unit => None,
         Fields::Named(ref fields) => {
-          let enum_fields = fields.named.iter().map(|ref field| {
+          let enum_fields = fields
-            // let label = field.ident;
+            .named
-            // let label_name = label.unwrap().to_string();
+            .iter()
-            // let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
+            .map(|ref field| {
+              // let label = field.ident;
+              // let label_name = label.unwrap().to_string();
+              // let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
 
-            match get_field_type(field) {
+              match get_field_type(field) {
-              Some(FieldType::FieldTypeString) => {
+                Some(FieldType::FieldTypeString) => {
-                Some(quote!{
+                  Some(quote!{
-                  // struct #visitor_label;
+                    // struct #visitor_label;
-                  // impl<'de> Visitor<'de> for #visitor_label {
+                    // impl<'de> Visitor<'de> for #visitor_label {
-                  //   type Value = String;
+                    //   type Value = String;
 
-                  //   fn visit_str(self, v: &str) -> Result<Self::Value, String> {
+                    //   fn visit_str(self, v: &str) -> Result<Self::Value, String> {
-                  //     match v {
+                    //     match v {
-                  //       _ => Err("unable to match \"{}\" with enum {}", v, #label_name)
+                    //       _ => Err("unable to match \"{}\" with enum {}", v, #label_name)
-                  //     }
+                    //     }
-                  //     Ok(String::from(v))
+                    //     Ok(String::from(v))
-                  //   }
+                    //   }
-                  // }
+                    // }
-                })
+                  })
-              },
+                }
-              _ => None
+                _ => None,
-            }
+              }
-          })
+            })
-          .filter(|x| x.is_some())
+            .filter(|x| x.is_some())
-          .map(|x| x.unwrap())
+            .map(|x| x.unwrap())
-          .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+            .fold(Tokens::new(), |mut sum, val| {
+              sum.append_all(val);
+              sum
+            });
 
           Some(enum_fields)
         }
@@ -137,35 +178,38 @@ pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BT
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let match_to_enum : Tokens = data_enum.variants.iter().map(|ref variant|
+  let match_to_enum: Tokens = data_enum
-    {
+    .variants
+    .iter()
+    .map(|ref variant| {
       let field_attrs = YaSerdeAttribute::parse(&variant.attrs);
-      let renamed_label =
+      let renamed_label = match field_attrs.rename {
-        match field_attrs.rename {
+        Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
-          Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
+        None => variant.ident,
-          None => variant.ident
+      };
-        };
       let label = variant.ident;
       let label_name = renamed_label.to_string();
 
       match variant.fields {
-        Fields::Unit => {
+        Fields::Unit => Some(quote!{
-          Some(quote!{
+          #label_name => {
-            #label_name => {
+            simple_enum_value = Some(#name::#label);
-              simple_enum_value = Some(#name::#label);
+          }
-            }
+        }),
-          })
+        _ => None,
-        },
-        _ => {
-          None
-        }
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
   quote!{
     use xml::reader::XmlEvent;
@@ -228,7 +272,11 @@ pub fn parse(data_enum: &DataEnum, name: &Ident, root: &String, _namespaces: &BT
   }
 }
 
-fn build_default_value(label: &Option<Ident>, field_type: Tokens, default: Tokens) -> Option<Tokens> {
+fn build_default_value(
+  label: &Option<Ident>,
+  field_type: Tokens,
+  default: Tokens,
+) -> Option<Tokens> {
   Some(quote!{
     #[allow(unused_mut)]
     let mut #label : #field_type = #default;

yaserde_derive/src/de/expand_struct.rs

@@ -1,4 +1,3 @@
-
 use attribute::*;
 use field_type::*;
 use quote::Tokens;
@@ -7,9 +6,15 @@ use syn::Ident;
 use syn::DataStruct;
 use proc_macro2::Span;
 
-pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
+pub fn parse(
-
+  data_struct: &DataStruct,
-  let validate_namespace : Tokens = namespaces.iter().map(|(ref _prefix, ref namespace)| {
+  name: &Ident,
+  root: &String,
+  namespaces: &BTreeMap<String, String>,
+) -> Tokens {
+  let validate_namespace: Tokens = namespaces
+    .iter()
+    .map(|(ref _prefix, ref namespace)| {
       Some(quote!(
 
         let mut found = false;
@@ -26,88 +31,98 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
-
+  let variables: Tokens = data_struct
-  let variables: Tokens = data_struct.fields.iter().map(|ref field|
+    .fields
-    {
+    .iter()
+    .map(|ref field| {
       let label = field.ident;
       match get_field_type(field) {
-        Some(FieldType::FieldTypeString) =>
+        Some(FieldType::FieldTypeString) => {
-          build_default_value(&label, quote!{String}, quote!{"".to_string()}),
+          build_default_value(&label, quote!{String}, quote!{"".to_string()})
-        Some(FieldType::FieldTypeBool) =>
+        }
-          build_default_value(&label, quote!{bool}, quote!{false}),
+        Some(FieldType::FieldTypeBool) => build_default_value(&label, quote!{bool}, quote!{false}),
-        Some(FieldType::FieldTypeI8) =>
+        Some(FieldType::FieldTypeI8) => build_default_value(&label, quote!{i8}, quote!{0}),
-          build_default_value(&label, quote!{i8}, quote!{0}),
+        Some(FieldType::FieldTypeU8) => build_default_value(&label, quote!{u8}, quote!{0}),
-        Some(FieldType::FieldTypeU8) =>
+        Some(FieldType::FieldTypeI16) => build_default_value(&label, quote!{i16}, quote!{0}),
-          build_default_value(&label, quote!{u8}, quote!{0}),
+        Some(FieldType::FieldTypeU16) => build_default_value(&label, quote!{u16}, quote!{0}),
-        Some(FieldType::FieldTypeI16) =>
+        Some(FieldType::FieldTypeI32) => build_default_value(&label, quote!{i32}, quote!{0}),
-          build_default_value(&label, quote!{i16}, quote!{0}),
+        Some(FieldType::FieldTypeU32) => build_default_value(&label, quote!{u32}, quote!{0}),
-        Some(FieldType::FieldTypeU16) =>
+        Some(FieldType::FieldTypeI64) => build_default_value(&label, quote!{i64}, quote!{0}),
-          build_default_value(&label, quote!{u16}, quote!{0}),
+        Some(FieldType::FieldTypeU64) => build_default_value(&label, quote!{u64}, quote!{0}),
-        Some(FieldType::FieldTypeI32) =>
+        Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
-          build_default_value(&label, quote!{i32}, quote!{0}),
+          #[allow(unused_mut, non_snake_case, non_camel_case_types)]
-        Some(FieldType::FieldTypeU32) =>
+          let mut #label : #struct_name = #struct_name::default();
-          build_default_value(&label, quote!{u32}, quote!{0}),
+        }),
-        Some(FieldType::FieldTypeI64) =>
+        Some(FieldType::FieldTypeVec { data_type }) => {
-          build_default_value(&label, quote!{i64}, quote!{0}),
-        Some(FieldType::FieldTypeU64) =>
-          build_default_value(&label, quote!{u64}, quote!{0}),
-        Some(FieldType::FieldTypeStruct{struct_name}) => {
-          Some(quote!{
-            #[allow(unused_mut, non_snake_case, non_camel_case_types)]
-            let mut #label : #struct_name = #struct_name::default();
-          })
-        },
-        Some(FieldType::FieldTypeVec{data_type}) => {
           let dt = Box::into_raw(data_type);
-          match unsafe{dt.as_ref()} {
+          match unsafe { dt.as_ref() } {
-            Some(&FieldType::FieldTypeString) =>
+            Some(&FieldType::FieldTypeString) => {
-              build_default_value(&label, quote!{Vec<String>}, quote!{vec![]}),
+              build_default_value(&label, quote!{Vec<String>}, quote!{vec![]})
-            Some(&FieldType::FieldTypeBool) =>
+            }
-              build_default_value(&label, quote!{Vec<bool>}, quote!{vec![]}),
+            Some(&FieldType::FieldTypeBool) => {
-            Some(&FieldType::FieldTypeI8) =>
+              build_default_value(&label, quote!{Vec<bool>}, quote!{vec![]})
-              build_default_value(&label, quote!{Vec<i8>}, quote!{vec![]}),
+            }
-            Some(&FieldType::FieldTypeU8) =>
+            Some(&FieldType::FieldTypeI8) => {
-              build_default_value(&label, quote!{Vec<u8>}, quote!{vec![]}),
+              build_default_value(&label, quote!{Vec<i8>}, quote!{vec![]})
-            Some(&FieldType::FieldTypeI16) =>
+            }
-              build_default_value(&label, quote!{Vec<i16>}, quote!{vec![]}),
+            Some(&FieldType::FieldTypeU8) => {
-            Some(&FieldType::FieldTypeU16) =>
+              build_default_value(&label, quote!{Vec<u8>}, quote!{vec![]})
-              build_default_value(&label, quote!{Vec<u16>}, quote!{vec![]}),
+            }
-            Some(&FieldType::FieldTypeI32) =>
+            Some(&FieldType::FieldTypeI16) => {
-              build_default_value(&label, quote!{Vec<i32>}, quote!{vec![]}),
+              build_default_value(&label, quote!{Vec<i16>}, quote!{vec![]})
-            Some(&FieldType::FieldTypeU32) =>
+            }
-              build_default_value(&label, quote!{Vec<u32>}, quote!{vec![]}),
+            Some(&FieldType::FieldTypeU16) => {
-            Some(&FieldType::FieldTypeI64) =>
+              build_default_value(&label, quote!{Vec<u16>}, quote!{vec![]})
-              build_default_value(&label, quote!{Vec<i64>}, quote!{vec![]}),
+            }
-            Some(&FieldType::FieldTypeU64) =>
+            Some(&FieldType::FieldTypeI32) => {
-              build_default_value(&label, quote!{Vec<u64>}, quote!{vec![]}),
+              build_default_value(&label, quote!{Vec<i32>}, quote!{vec![]})
-            Some(&FieldType::FieldTypeStruct{struct_name}) => {
+            }
-              Some(quote!{
+            Some(&FieldType::FieldTypeU32) => {
-                #[allow(unused_mut)]
+              build_default_value(&label, quote!{Vec<u32>}, quote!{vec![]})
-                let mut #label : Vec<#struct_name> = vec![];
+            }
-              })
+            Some(&FieldType::FieldTypeI64) => {
-            },
+              build_default_value(&label, quote!{Vec<i64>}, quote!{vec![]})
-            Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
+            }
-            None => {unimplemented!();},
+            Some(&FieldType::FieldTypeU64) => {
+              build_default_value(&label, quote!{Vec<u64>}, quote!{vec![]})
+            }
+            Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
+              #[allow(unused_mut)]
+              let mut #label : Vec<#struct_name> = vec![];
+            }),
+            Some(&FieldType::FieldTypeVec { .. }) => {
+              unimplemented!();
+            }
+            None => {
+              unimplemented!();
+            }
           }
-        },
+        }
-        _ => None
+        _ => None,
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let field_visitors: Tokens = data_struct.fields.iter().map(|ref field|
+  let field_visitors: Tokens = data_struct
-    {
+    .fields
+    .iter()
+    .map(|ref field| {
       let field_attrs = YaSerdeAttribute::parse(&field.attrs);
-      let label_name = 
+      let label_name = if let Some(value) = field_attrs.rename {
-        if let Some(value) = field_attrs.rename {
+        Ident::new(&format!("{}", value), Span::call_site()).to_string()
-          Ident::new(&format!("{}", value), Span::call_site()).to_string()
+      } else {
-        } else {
+        field.ident.unwrap().to_string()
-          field.ident.unwrap().to_string()
+      };
-        };
 
       let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
 
@@ -115,46 +130,49 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
         Some(FieldType::FieldTypeString) => {
           let visitor = Ident::new("visit_str", Span::call_site());
           build_declare_visitor(quote!{String}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeBool) => {
           let visitor = Ident::new("visit_bool", Span::call_site());
           build_declare_visitor(quote!{bool}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeI8) => {
           let visitor = Ident::new("visit_i8", Span::call_site());
           build_declare_visitor(quote!{i8}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeU8) => {
           let visitor = Ident::new("visit_u8", Span::call_site());
           build_declare_visitor(quote!{u8}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeI16) => {
           let visitor = Ident::new("visit_i16", Span::call_site());
           build_declare_visitor(quote!{i16}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeU16) => {
           let visitor = Ident::new("visit_u16", Span::call_site());
           build_declare_visitor(quote!{u16}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeI32) => {
           let visitor = Ident::new("visit_i32", Span::call_site());
           build_declare_visitor(quote!{i32}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeU32) => {
           let visitor = Ident::new("visit_u32", Span::call_site());
           build_declare_visitor(quote!{u32}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeI64) => {
           let visitor = Ident::new("visit_i64", Span::call_site());
           build_declare_visitor(quote!{i64}, &visitor, &visitor_label)
-        },
+        }
         Some(FieldType::FieldTypeU64) => {
           let visitor = Ident::new("visit_u64", Span::call_site());
           build_declare_visitor(quote!{u64}, &visitor, &visitor_label)
-        },
+        }
-        Some(FieldType::FieldTypeStruct{struct_name}) => {
+        Some(FieldType::FieldTypeStruct { struct_name }) => {
           let struct_id = struct_name.to_string();
-          let struct_ident = Ident::new(&format!("__Visitor_{}_{}", label_name, struct_name), Span::call_site());
+          let struct_ident = Ident::new(
+            &format!("__Visitor_{}_{}", label_name, struct_name),
+            Span::call_site(),
+          );
 
           Some(quote!{
             #[allow(non_snake_case, non_camel_case_types)]
@@ -169,10 +187,10 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
               }
             }
           })
-        },
+        }
-        Some(FieldType::FieldTypeVec{data_type}) => {
+        Some(FieldType::FieldTypeVec { data_type }) => {
           let dt = Box::into_raw(data_type);
-          match unsafe{dt.as_ref()} {
+          match unsafe { dt.as_ref() } {
             Some(&FieldType::FieldTypeString) => {
               let visitor = Ident::new("visit_str", Span::call_site());
               build_declare_visitor(quote!{String}, &visitor, &visitor_label)
@@ -213,7 +231,7 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
               let visitor = Ident::new("visit_u64", Span::call_site());
               build_declare_visitor(quote!{u64}, &visitor, &visitor_label)
             }
-            Some(&FieldType::FieldTypeStruct{struct_name}) => {
+            Some(&FieldType::FieldTypeStruct { struct_name }) => {
               let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
               Some(quote!{
                 #[allow(non_snake_case, non_camel_case_types)]
@@ -223,20 +241,23 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
                 }
               })
             }
-            _ => {
+            _ => None,
-              None
-            }
           }
-        },
+        }
-        _ => None
+        _ => None,
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let call_visitors: Tokens = data_struct.fields.iter().map(|ref field|
+  let call_visitors: Tokens = data_struct
-    {
+    .fields
+    .iter()
+    .map(|ref field| {
       let field_attrs = YaSerdeAttribute::parse(&field.attrs);
       let label = field.ident;
 
@@ -244,116 +265,253 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
         return None;
       }
 
-      let label_name =
+      let label_name = if let Some(value) = field_attrs.rename {
-        if let Some(value) = field_attrs.rename {
+        Ident::new(&format!("{}", value), Span::call_site()).to_string()
-          Ident::new(&format!("{}", value), Span::call_site()).to_string()
+      } else {
-        } else {
+        field.ident.unwrap().to_string()
-          field.ident.unwrap().to_string()
+      };
-        };
 
       let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
 
       match get_field_type(field) {
         Some(FieldType::FieldTypeString) => {
           let visitor = Ident::new("visit_str", Span::call_site());
-          build_call_visitor(quote!{String}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{String},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeBool) => {
           let visitor = Ident::new("visit_bool", Span::call_site());
-          build_call_visitor(quote!{bool}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{bool},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeI8) => {
           let visitor = Ident::new("visit_i8", Span::call_site());
-          build_call_visitor(quote!{i8}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{i8},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeU8) => {
           let visitor = Ident::new("visit_u8", Span::call_site());
-          build_call_visitor(quote!{u8}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{u8},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeU16) => {
           let visitor = Ident::new("visit_u16", Span::call_site());
-          build_call_visitor(quote!{u16}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{u16},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeI16) => {
           let visitor = Ident::new("visit_i16", Span::call_site());
-          build_call_visitor(quote!{i16}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{i16},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeU32) => {
           let visitor = Ident::new("visit_u32", Span::call_site());
-          build_call_visitor(quote!{u32}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{u32},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeI32) => {
           let visitor = Ident::new("visit_i32", Span::call_site());
-          build_call_visitor(quote!{i32}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{i32},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeU64) => {
           let visitor = Ident::new("visit_u64", Span::call_site());
-          build_call_visitor(quote!{u64}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{u64},
+            &visitor,
+            quote!{= value},
+            &visitor_label,
+            &label,
+            &label_name,
+          )
+        }
         Some(FieldType::FieldTypeI64) => {
           let visitor = Ident::new("visit_i64", Span::call_site());
-          build_call_visitor(quote!{i64}, &visitor, quote!{= value}, &visitor_label, &label, &label_name)
+          build_call_visitor(
-        },
+            quote!{i64},
-        Some(FieldType::FieldTypeStruct{struct_name}) => {
+            &visitor,
-          Some(quote!{
+            quote!{= value},
-            #label_name => {
+            &visitor_label,
-              reader.set_map_value();
+            &label,
-              match #struct_name::deserialize(reader) {
+            &label_name,
-                Ok(parsed_item) => {
+          )
-                  #label = parsed_item;
+        }
-                  let _root = reader.next();
+        Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{
-                },
+          #label_name => {
-                Err(msg) => {
+            reader.set_map_value();
-                  return Err(msg);
+            match #struct_name::deserialize(reader) {
-                },
+              Ok(parsed_item) => {
-              }
+                #label = parsed_item;
+                let _root = reader.next();
+              },
+              Err(msg) => {
+                return Err(msg);
+              },
             }
-          })
+          }
-        },
+        }),
-        Some(FieldType::FieldTypeVec{data_type}) => {
+        Some(FieldType::FieldTypeVec { data_type }) => {
           let dt = Box::into_raw(data_type);
-          match unsafe{dt.as_ref()} {
+          match unsafe { dt.as_ref() } {
             Some(&FieldType::FieldTypeString) => {
               let visitor = Ident::new("visit_str", Span::call_site());
-              build_call_visitor(quote!{String}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{String},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeBool) => {
               let visitor = Ident::new("visit_bool", Span::call_site());
-              build_call_visitor(quote!{bool}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{bool},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeI8) => {
               let visitor = Ident::new("visit_i8", Span::call_site());
-              build_call_visitor(quote!{i8}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{i8},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeU8) => {
               let visitor = Ident::new("visit_u8", Span::call_site());
-              build_call_visitor(quote!{u8}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{u8},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeI16) => {
               let visitor = Ident::new("visit_i16", Span::call_site());
-              build_call_visitor(quote!{i16}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{i16},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeU16) => {
               let visitor = Ident::new("visit_u16", Span::call_site());
-              build_call_visitor(quote!{u16}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{u16},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeI32) => {
               let visitor = Ident::new("visit_i32", Span::call_site());
-              build_call_visitor(quote!{i32}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{i32},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeU32) => {
               let visitor = Ident::new("visit_u32", Span::call_site());
-              build_call_visitor(quote!{u32}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{u32},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeI64) => {
               let visitor = Ident::new("visit_i64", Span::call_site());
-              build_call_visitor(quote!{i64}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{i64},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
             Some(&FieldType::FieldTypeU64) => {
               let visitor = Ident::new("visit_u64", Span::call_site());
-              build_call_visitor(quote!{u64}, &visitor, quote!{.push(value)}, &visitor_label, &label, &label_name)
+              build_call_visitor(
+                quote!{u64},
+                &visitor,
+                quote!{.push(value)},
+                &visitor_label,
+                &label,
+                &label_name,
+              )
             }
-            Some(&FieldType::FieldTypeStruct{struct_name}) => {
+            Some(&FieldType::FieldTypeStruct { struct_name }) => {
               let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site());
               Some(quote!{
                 #label_name => {
@@ -370,101 +528,144 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
                 }
               })
             }
-            _ => unimplemented!()
+            _ => unimplemented!(),
           }
-        },
+        }
-        _ => None
+        _ => None,
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let attributes_loading: Tokens = data_struct.fields.iter().map(|ref field| {
+  let attributes_loading: Tokens = data_struct
-    let field_attrs = YaSerdeAttribute::parse(&field.attrs);
+    .fields
-    if !field_attrs.attribute {
+    .iter()
-      return None;
+    .map(|ref field| {
-    }
+      let field_attrs = YaSerdeAttribute::parse(&field.attrs);
+      if !field_attrs.attribute {
+        return None;
+      }
 
-    let label = field.ident;
+      let label = field.ident;
-    let label_name =
+      let label_name = if let Some(value) = field_attrs.rename {
-      if let Some(value) = field_attrs.rename {
         Ident::new(&format!("{}", value), Span::call_site()).to_string()
       } else {
         field.ident.unwrap().to_string()
       };
 
-    match get_field_type(field) {
+      match get_field_type(field) {
-      Some(FieldType::FieldTypeString) => {
+        Some(FieldType::FieldTypeString) => Some(quote!{
-        Some(quote!{
           for attr in attributes {
             if attr.name.local_name == #label_name {
               #label = attr.value.to_owned();
             }
           }
-        })
+        }),
-      }
+        Some(FieldType::FieldTypeStruct { struct_name }) => {
-      Some(FieldType::FieldTypeStruct{struct_name}) => {
+          let struct_ident = Ident::new(
-        let struct_ident = Ident::new(&format!("__Visitor_{}_{}", label_name, struct_name), Span::call_site());
+            &format!("__Visitor_{}_{}", label_name, struct_name),
+            Span::call_site(),
+          );
 
-        Some(quote!{
+          Some(quote!{
-          for attr in attributes {
+            for attr in attributes {
-            if attr.name.local_name == #label_name {
+              if attr.name.local_name == #label_name {
-              let visitor = #struct_ident{};
+                let visitor = #struct_ident{};
-              match visitor.visit_str(&attr.value) {
+                match visitor.visit_str(&attr.value) {
-                Ok(value) => {#label = value;}
+                  Ok(value) => {#label = value;}
-                Err(msg) => {return Err(msg);}
+                  Err(msg) => {return Err(msg);}
+                }
               }
             }
-          }
+          })
-        })
+        }
-      }
+        _ => None,
-      _ => {
-        None
-      }
-    }})
-    .filter(|x| x.is_some())
-    .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum});
-
-  let set_text: Tokens = data_struct.fields.iter().map(|ref field|
-    {
-      let label = field.ident;
-      let field_attrs = YaSerdeAttribute::parse(&field.attrs);
-
-      match get_field_type(field) {
-        Some(FieldType::FieldTypeString) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{text_content.to_owned()}),
-        Some(FieldType::FieldTypeBool) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{bool::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeI8) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{i8::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeU8) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{u8::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeI16) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{i16::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeU16) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{u16::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeI32) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{i32::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeU32) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{u32::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeI64) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{i64::from_str(text_content).unwrap()}),
-        Some(FieldType::FieldTypeU64) =>
-          build_set_text_to_value(&field_attrs, &label, quote!{u64::from_str(text_content).unwrap()}),
-
-        Some(FieldType::FieldTypeStruct{..}) |
-        Some(FieldType::FieldTypeVec{..})|
-        None => None,
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut sum, val| {
+      sum.append_all(val);
+      sum
+    });
 
-  let struct_builder: Tokens = data_struct.fields.iter().map(|ref field|
+  let set_text: Tokens = data_struct
-    {
+    .fields
+    .iter()
+    .map(|ref field| {
+      let label = field.ident;
+      let field_attrs = YaSerdeAttribute::parse(&field.attrs);
+
+      match get_field_type(field) {
+        Some(FieldType::FieldTypeString) => {
+          build_set_text_to_value(&field_attrs, &label, quote!{text_content.to_owned()})
+        }
+        Some(FieldType::FieldTypeBool) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{bool::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeI8) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{i8::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeU8) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{u8::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeI16) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{i16::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeU16) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{u16::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeI32) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{i32::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeU32) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{u32::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeI64) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{i64::from_str(text_content).unwrap()},
+        ),
+        Some(FieldType::FieldTypeU64) => build_set_text_to_value(
+          &field_attrs,
+          &label,
+          quote!{u64::from_str(text_content).unwrap()},
+        ),
+
+        Some(FieldType::FieldTypeStruct { .. }) | Some(FieldType::FieldTypeVec { .. }) | None => {
+          None
+        }
+      }
+    })
+    .filter(|x| x.is_some())
+    .map(|x| x.unwrap())
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
+
+  let struct_builder: Tokens = data_struct
+    .fields
+    .iter()
+    .map(|ref field| {
       let label = field.ident;
 
       if get_field_type(field).is_some() {
@@ -477,7 +678,10 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
   quote! {
     use xml::reader::XmlEvent;
@@ -537,14 +741,22 @@ pub fn parse(data_struct: &DataStruct, name: &Ident, root: &String, namespaces:
   }
 }
 
-fn build_default_value(label: &Option<Ident>, field_type: Tokens, default: Tokens) -> Option<Tokens> {
+fn build_default_value(
+  label: &Option<Ident>,
+  field_type: Tokens,
+  default: Tokens,
+) -> Option<Tokens> {
   Some(quote!{
     #[allow(unused_mut)]
     let mut #label : #field_type = #default;
   })
 }
 
-fn build_declare_visitor(field_type: Tokens, visitor: &Ident, visitor_label: &Ident) -> Option<Tokens> {
+fn build_declare_visitor(
+  field_type: Tokens,
+  visitor: &Ident,
+  visitor_label: &Ident,
+) -> Option<Tokens> {
   Some(quote!{
     #[allow(non_snake_case, non_camel_case_types)]
     struct #visitor_label;
@@ -558,7 +770,14 @@ fn build_declare_visitor(field_type: Tokens, visitor: &Ident, visitor_label: &Id
   })
 }
 
-fn build_call_visitor(field_type: Tokens, visitor: &Ident, action: Tokens, visitor_label: &Ident, label: &Option<Ident>, label_name: &String) -> Option<Tokens> {
+fn build_call_visitor(
+  field_type: Tokens,
+  visitor: &Ident,
+  action: Tokens,
+  visitor_label: &Ident,
+  label: &Option<Ident>,
+  label_name: &String,
+) -> Option<Tokens> {
   Some(quote!{
     #label_name => {
       let visitor = #visitor_label{};
@@ -587,8 +806,11 @@ fn build_call_visitor(field_type: Tokens, visitor: &Ident, action: Tokens, visit
   })
 }
 
-
+fn build_set_text_to_value(
-fn build_set_text_to_value(field_attrs: &YaSerdeAttribute, label: &Option<Ident>, action: Tokens) -> Option<Tokens> {
+  field_attrs: &YaSerdeAttribute,
+  label: &Option<Ident>,
+  action: Tokens,
+) -> Option<Tokens> {
   if field_attrs.text {
     Some(quote!{
       #label = #action;

yaserde_derive/src/de/mod.rs

@@ -1,4 +1,3 @@
-
 pub mod expand_enum;
 pub mod expand_struct;
 
@@ -16,20 +15,20 @@ pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<quote::Tokens
   let root_attrs = attribute::YaSerdeAttribute::parse(&attrs);
   let root = root_attrs.clone().root.unwrap_or(name.to_string());
 
-  let impl_block =
+  let impl_block = match data {
-    match data {
+    &syn::Data::Struct(ref data_struct) => {
-      &syn::Data::Struct(ref data_struct) => {
+      expand_struct::parse(data_struct, &name, &root, &root_attrs.namespaces)
-        expand_struct::parse(data_struct, &name, &root, &root_attrs.namespaces)
+    }
-      },
+    &syn::Data::Enum(ref data_enum) => {
-      &syn::Data::Enum(ref data_enum) => {
+      expand_enum::parse(data_enum, &name, &root, &root_attrs.namespaces)
-        expand_enum::parse(data_enum, &name, &root, &root_attrs.namespaces)
+    }
-      },
+    &syn::Data::Union(ref _data_union) => unimplemented!(),
-      &syn::Data::Union(ref _data_union) => {
+  };
-        unimplemented!()
-      },
-    };
 
-  let dummy_const = Ident::new(&format!("_IMPL_YA_DESERIALIZE_FOR_{}", name), Span::def_site());
+  let dummy_const = Ident::new(
+    &format!("_IMPL_YA_DESERIALIZE_FOR_{}", name),
+    Span::def_site(),
+  );
 
   let generated = quote! {
     #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]

yaserde_derive/src/field_type.rs

@@ -1,4 +1,3 @@
-
 use syn;
 use syn::punctuated::Pair;
 use syn::Type::Path;
@@ -15,8 +14,8 @@ pub enum FieldType {
   FieldTypeU32,
   FieldTypeI64,
   FieldTypeU64,
-  FieldTypeVec{data_type: Box<FieldType>},
+  FieldTypeVec { data_type: Box<FieldType> },
-  FieldTypeStruct{struct_name: syn::Ident},
+  FieldTypeStruct { struct_name: syn::Ident },
 }
 
 impl FieldType {
@@ -32,37 +31,28 @@ impl FieldType {
       "u32" => Some(FieldType::FieldTypeU32),
       "i64" => Some(FieldType::FieldTypeI64),
       "u64" => Some(FieldType::FieldTypeU64),
-      "Vec" => {
+      "Vec" => get_vec_type(t).map(|data_type| {
-        get_vec_type(t).map(|data_type| {
+        let p = syn::PathSegment {
-          let p = syn::PathSegment{
+          ident: data_type,
-            ident: data_type,
+          arguments: syn::PathArguments::None,
-            arguments: syn::PathArguments::None
+        };
-          };
 
-          FieldType::FieldTypeVec{
+        FieldType::FieldTypeVec {
-            data_type: Box::new(FieldType::from_ident(&p).unwrap())
+          data_type: Box::new(FieldType::from_ident(&p).unwrap()),
-          }
+        }
-        })
+      }),
-      },
+      _struct_name => Some(FieldType::FieldTypeStruct {
-      _struct_name =>
+        struct_name: t.ident,
-        Some(FieldType::FieldTypeStruct{
+      }),
-          struct_name: t.ident
-        }),
     }
   }
 }
 
 pub fn get_field_type(field: &syn::Field) -> Option<FieldType> {
   match field.ty {
-    Path(ref path) => {
+    Path(ref path) => match path.path.segments.first() {
-      match path.path.segments.first() {
+      Some(Pair::End(t)) => FieldType::from_ident(t),
-        Some(Pair::End(t)) => {
+      _ => None,
-          FieldType::from_ident(t)
-        },
-        _ => {
-          None
-        },
-      }
     },
     _ => None,
   }
@@ -74,7 +64,7 @@ fn get_vec_type(t: &syn::PathSegment) -> Option<syn::Ident> {
       if let &syn::GenericArgument::Type(ref argument) = tt {
         if let &Path(ref path2) = argument {
           if let Some(Pair::End(ttt)) = path2.path.segments.first() {
-            return Some(ttt.ident)
+            return Some(ttt.ident);
           }
         }
       }

yaserde_derive/src/lib.rs

@@ -1,7 +1,7 @@
-#![recursion_limit="256"]
+#![recursion_limit = "256"]
 
-extern crate proc_macro;
 extern crate proc_macro2;
+extern crate proc_macro;
 #[macro_use]
 extern crate quote;
 extern crate syn;

yaserde_derive/src/ser/expand_enum.rs

@@ -1,4 +1,3 @@
-
 use attribute::*;
 use field_type::*;
 use quote::Tokens;
@@ -8,58 +7,61 @@ use syn::Ident;
 use syn::DataEnum;
 use proc_macro2::Span;
 
-pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
+pub fn serialize(
-  let write_enum_content : Tokens = data_enum.variants.iter().map(|ref variant|
+  data_enum: &DataEnum,
-    {
+  name: &Ident,
+  root: &String,
+  namespaces: &BTreeMap<String, String>,
+) -> Tokens {
+  let write_enum_content: Tokens = data_enum
+    .variants
+    .iter()
+    .map(|ref variant| {
       let variant_attrs = YaSerdeAttribute::parse(&variant.attrs);
-      let renamed_label =
+      let renamed_label = match variant_attrs.rename {
-        match variant_attrs.rename {
+        Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
-          Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
+        None => variant.ident,
-          None => variant.ident
+      };
-        };
       let label = variant.ident;
-      let label_name =
+      let label_name = if let Some(prefix) = variant_attrs.prefix {
-        if let Some(prefix) = variant_attrs.prefix {
+        prefix + ":" + renamed_label.to_string().as_ref()
-          prefix + ":" + renamed_label.to_string().as_ref()
+      } else {
-        } else {
+        renamed_label.to_string()
-          renamed_label.to_string()
+      };
-        };
 
       match variant.fields {
-        Fields::Unit => {
+        Fields::Unit => Some(quote!{
-          Some(quote!{
+          &#name::#label => {
-            &#name::#label => {
+            let data_event = XmlEvent::characters(#label_name);
-              let data_event = XmlEvent::characters(#label_name);
+            let _ret = writer.write(data_event);
-              let _ret = writer.write(data_event);
+          }
-            }
+        }),
-          })
-        },
         Fields::Named(ref fields) => {
-          let enum_fields = fields.named.iter().map(|ref field| {
+          let enum_fields = fields
+            .named
+            .iter()
+            .map(|ref field| {
+              let field_attrs = YaSerdeAttribute::parse(&field.attrs);
+              if field_attrs.attribute == true {
+                return None;
+              }
 
-            let field_attrs = YaSerdeAttribute::parse(&field.attrs);
+              let field_label = field.ident;
-            if field_attrs.attribute == true {
+              if field_attrs.text == true {
-              return None;
+                return Some(quote!(
-            }
-
-            let field_label = field.ident;
-            if field_attrs.text == true {
-              return Some(quote!(
                 let data_event = XmlEvent::characters(&self.#field_label);
                 let _ret = writer.write(data_event);
-              ))
+              ));
-            }
+              }
 
-            let renamed_field_label =
+              let renamed_field_label = match field_attrs.rename {
-              match field_attrs.rename {
                 Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
-                None => field.ident
+                None => field.ident,
               };
-            let field_label_name = renamed_field_label.unwrap().to_string();
+              let field_label_name = renamed_field_label.unwrap().to_string();
 
-            match get_field_type(field) {
+              match get_field_type(field) {
-              Some(FieldType::FieldTypeString) =>
+                Some(FieldType::FieldTypeString) => Some(quote!{
-                Some(quote!{
                   match self {
                     &#name::#label{ref #field_label, ..} => {
                       let struct_start_event = XmlEvent::start_element(#field_label_name);
@@ -74,8 +76,7 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
                     _ => {},
                   }
                 }),
-              Some(FieldType::FieldTypeStruct{..}) =>
+                Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
-                Some(quote!{
                   let struct_start_event = XmlEvent::start_element(#field_label_name);
                   let _ret = writer.write(struct_start_event);
 
@@ -92,8 +93,7 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
                   let struct_end_event = XmlEvent::end_element();
                   let _ret = writer.write(struct_end_event);
                 }),
-              Some(FieldType::FieldTypeVec{..}) =>
+                Some(FieldType::FieldTypeVec { .. }) => Some(quote!{
-                Some(quote!{
                   match self {
                     &#name::#label{ref #field_label, ..} => {
                       for item in #field_label {
@@ -111,12 +111,15 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
                     _ => {}
                   }
                 }),
-              _ => None
+                _ => None,
-            }
+              }
-          })
+            })
-          .filter(|x| x.is_some())
+            .filter(|x| x.is_some())
-          .map(|x| x.unwrap())
+            .map(|x| x.unwrap())
-          .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+            .fold(Tokens::new(), |mut tokens, token| {
+              tokens.append_all(token);
+              tokens
+            });
 
           Some(quote!{
             &#name::#label{..} => {
@@ -129,31 +132,38 @@ pub fn serialize(data_enum: &DataEnum, name: &Ident, root: &String, namespaces:
               let _ret = writer.write(struct_end_event);
             }
           })
-        },
+        }
-        Fields::Unnamed(ref _fields) => {
+        Fields::Unnamed(ref _fields) => unimplemented!(),
-          unimplemented!()
-        },
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
-  let add_namespaces : Tokens = namespaces.iter().map(|(ref prefix, ref namespace)| {
+  let add_namespaces: Tokens = namespaces
+    .iter()
+    .map(|(ref prefix, ref namespace)| {
       Some(quote!(
         .ns(#prefix, #namespace)
       ))
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
   quote! {
     use xml::writer::XmlEvent;
 
     impl YaSerialize for #name {
       #[allow(unused_variables)]
-      fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
+      fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
+        -> Result<(), String> {
         error!("Enum: start to expand {:?}", #root);
 
         if !writer.skip_start_end() {

yaserde_derive/src/ser/expand_struct.rs

@@ -1,4 +1,3 @@
-
 use attribute::*;
 use field_type::*;
 use quote::Tokens;
@@ -8,77 +7,88 @@ use syn::DataStruct;
 use proc_macro2::Span;
 use std::string::ToString;
 
-pub fn serialize(data_struct: &DataStruct, name: &Ident, root: &String, namespaces: &BTreeMap<String, String>) -> Tokens {
+pub fn serialize(
-  let build_attributes : Tokens = data_struct.fields.iter().map(|ref field|
+  data_struct: &DataStruct,
-    {
+  name: &Ident,
+  root: &String,
+  namespaces: &BTreeMap<String, String>,
+) -> Tokens {
+  let build_attributes: Tokens = data_struct
+    .fields
+    .iter()
+    .map(|ref field| {
       let field_attrs = YaSerdeAttribute::parse(&field.attrs);
       if field_attrs.attribute == false {
         return None;
       }
 
-      let renamed_label =
+      let renamed_label = match field_attrs.rename {
-        match field_attrs.rename {
+        Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
-          Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
+        None => field.ident,
-          None => field.ident
+      };
-        };
       let label = field.ident;
-      let label_name =
+      let label_name = if let Some(prefix) = field_attrs.prefix {
-        if let Some(prefix) = field_attrs.prefix {
+        prefix + ":" + renamed_label.unwrap().to_string().as_ref()
-          prefix + ":" + renamed_label.unwrap().to_string().as_ref()
+      } else {
-        } else {
+        renamed_label.unwrap().to_string()
-          renamed_label.unwrap().to_string()
+      };
-        };
 
       match get_field_type(field) {
-        Some(FieldType::FieldTypeString) |
+        Some(FieldType::FieldTypeString)
-        Some(FieldType::FieldTypeBool) |
+        | Some(FieldType::FieldTypeBool)
-        Some(FieldType::FieldTypeI8) |
+        | Some(FieldType::FieldTypeI8)
-        Some(FieldType::FieldTypeU8) |
+        | Some(FieldType::FieldTypeU8)
-        Some(FieldType::FieldTypeI16) |
+        | Some(FieldType::FieldTypeI16)
-        Some(FieldType::FieldTypeU16) |
+        | Some(FieldType::FieldTypeU16)
-        Some(FieldType::FieldTypeI32) |
+        | Some(FieldType::FieldTypeI32)
-        Some(FieldType::FieldTypeU32) |
+        | Some(FieldType::FieldTypeU32)
-        Some(FieldType::FieldTypeI64) |
+        | Some(FieldType::FieldTypeI64)
-        Some(FieldType::FieldTypeU64) =>
+        | Some(FieldType::FieldTypeU64) => Some(quote!{
-          Some(quote!{
+          .attr(#label_name, &self.#label)
-            .attr(#label_name, &self.#label)
+        }),
-          }),
+        Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
-        Some(FieldType::FieldTypeStruct{..}) =>
+          .attr(#label_name, &*{
-          Some(quote!{
+            use std::mem;
-            .attr(#label_name, &*{
+            match yaserde::ser::to_string_content(&self.#label) {
-              use std::mem;
+              Ok(value) => {
-              match yaserde::ser::to_string_content(&self.#label) {
+                unsafe {
-                Ok(value) => {
+                  let ret : &'static str = mem::transmute(&value as &str);
-                  unsafe {
+                  mem::forget(value);
-                    let ret : &'static str = mem::transmute(&value as &str);
+                  ret
-                    mem::forget(value);
+                }
-                    ret
+              },
-                  }
+              Err(msg) => return Err("Unable to serialize content".to_owned()),
-                },
+            }
-                Err(msg) => return Err("Unable to serialize content".to_owned()),
+          })
-              }
+        }),
-            })
+        _ => None,
-          }),
-        _ => {
-          None
-        }
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
-  let add_namespaces : Tokens = namespaces.iter().map(|(ref prefix, ref namespace)| {
+  let add_namespaces: Tokens = namespaces
+    .iter()
+    .map(|(ref prefix, ref namespace)| {
       Some(quote!(
         .ns(#prefix, #namespace)
       ))
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
-  let struct_inspector : Tokens = data_struct.fields.iter().map(|ref field|
+  let struct_inspector: Tokens = data_struct
-    {
+    .fields
+    .iter()
+    .map(|ref field| {
       let field_attrs = YaSerdeAttribute::parse(&field.attrs);
       if field_attrs.attribute == true {
         return None;
@@ -89,133 +99,130 @@ pub fn serialize(data_struct: &DataStruct, name: &Ident, root: &String, namespac
         return Some(quote!(
           let data_event = XmlEvent::characters(&self.#label);
           let _ret = writer.write(data_event);
-        ))
+        ));
       }
 
-      let renamed_label =
+      let renamed_label = match field_attrs.rename {
-        match field_attrs.rename {
+        Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
-          Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
+        None => field.ident,
-          None => field.ident
+      };
-        };
 
-      let label_name =
+      let label_name = if let Some(prefix) = field_attrs.prefix {
-        if let Some(prefix) = field_attrs.prefix {
+        prefix + ":" + renamed_label.unwrap().to_string().as_ref()
-          prefix + ":" + renamed_label.unwrap().to_string().as_ref()
+      } else {
-        } else {
+        renamed_label.unwrap().to_string()
-          renamed_label.unwrap().to_string()
+      };
-        };
 
       match get_field_type(field) {
-        Some(FieldType::FieldTypeString) =>
+        Some(FieldType::FieldTypeString) => Some(quote!{
-          Some(quote!{
+          let start_event = XmlEvent::start_element(#label_name);
-            let start_event = XmlEvent::start_element(#label_name);
+          let _ret = writer.write(start_event);
-            let _ret = writer.write(start_event);
 
-            let data_event = XmlEvent::characters(&self.#label);
+          let data_event = XmlEvent::characters(&self.#label);
-            let _ret = writer.write(data_event);
+          let _ret = writer.write(data_event);
 
-            let end_event = XmlEvent::end_element();
+          let end_event = XmlEvent::end_element();
-            let _ret = writer.write(end_event);
+          let _ret = writer.write(end_event);
-          }),
+        }),
-        Some(FieldType::FieldTypeBool) |
+        Some(FieldType::FieldTypeBool)
-        Some(FieldType::FieldTypeI8) |
+        | Some(FieldType::FieldTypeI8)
-        Some(FieldType::FieldTypeU8) |
+        | Some(FieldType::FieldTypeU8)
-        Some(FieldType::FieldTypeI16) |
+        | Some(FieldType::FieldTypeI16)
-        Some(FieldType::FieldTypeU16) |
+        | Some(FieldType::FieldTypeU16)
-        Some(FieldType::FieldTypeI32) |
+        | Some(FieldType::FieldTypeI32)
-        Some(FieldType::FieldTypeU32) |
+        | Some(FieldType::FieldTypeU32)
-        Some(FieldType::FieldTypeI64) |
+        | Some(FieldType::FieldTypeI64)
-        Some(FieldType::FieldTypeU64) =>
+        | Some(FieldType::FieldTypeU64) => Some(quote!{
-          Some(quote!{
+          let start_event = XmlEvent::start_element(#label_name);
-            let start_event = XmlEvent::start_element(#label_name);
+          let _ret = writer.write(start_event);
-            let _ret = writer.write(start_event);
 
-            let content = format!("{}", &self.#label);
+          let content = format!("{}", &self.#label);
-            let data_event = XmlEvent::characters(&content);
+          let data_event = XmlEvent::characters(&content);
-            let _ret = writer.write(data_event);
+          let _ret = writer.write(data_event);
 
-            let end_event = XmlEvent::end_element();
+          let end_event = XmlEvent::end_element();
-            let _ret = writer.write(end_event);
+          let _ret = writer.write(end_event);
-          }),
+        }),
-        Some(FieldType::FieldTypeStruct{..}) =>
+        Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
-          Some(quote!{
+          writer.set_skip_start_end(false);
-            writer.set_skip_start_end(false);
+          match self.#label.serialize(writer) {
-            match self.#label.serialize(writer) {
+            Ok(()) => {},
-              Ok(()) => {},
+            Err(msg) => {
-              Err(msg) => {
+              return Err(msg);
-                return Err(msg);
+            },
-              },
+          };
-            };
+        }),
-          }),
+        Some(FieldType::FieldTypeVec { data_type }) => {
-        Some(FieldType::FieldTypeVec{data_type}) => {
           let dt = Box::into_raw(data_type);
-          match unsafe{dt.as_ref()} {
+          match unsafe { dt.as_ref() } {
-            Some(&FieldType::FieldTypeString) => {
+            Some(&FieldType::FieldTypeString) => Some(quote!{
-              Some(quote!{
+              for item in &self.#label {
-                for item in &self.#label {
+                let start_event = XmlEvent::start_element(#label_name);
-                  let start_event = XmlEvent::start_element(#label_name);
+                let _ret = writer.write(start_event);
-                  let _ret = writer.write(start_event);
 
-                  let data_event = XmlEvent::characters(item);
+                let data_event = XmlEvent::characters(item);
-                  let _ret = writer.write(data_event);
+                let _ret = writer.write(data_event);
 
-                  let end_event = XmlEvent::end_element();
+                let end_event = XmlEvent::end_element();
-                  let _ret = writer.write(end_event);
+                let _ret = writer.write(end_event);
-                }
+              }
-              })
+            }),
-            },
+            Some(&FieldType::FieldTypeBool)
-            Some(&FieldType::FieldTypeBool) |
+            | Some(&FieldType::FieldTypeI8)
-            Some(&FieldType::FieldTypeI8) |
+            | Some(&FieldType::FieldTypeU8)
-            Some(&FieldType::FieldTypeU8) |
+            | Some(&FieldType::FieldTypeI16)
-            Some(&FieldType::FieldTypeI16) |
+            | Some(&FieldType::FieldTypeU16)
-            Some(&FieldType::FieldTypeU16) |
+            | Some(&FieldType::FieldTypeI32)
-            Some(&FieldType::FieldTypeI32) |
+            | Some(&FieldType::FieldTypeU32)
-            Some(&FieldType::FieldTypeU32) |
+            | Some(&FieldType::FieldTypeI64)
-            Some(&FieldType::FieldTypeI64) |
+            | Some(&FieldType::FieldTypeU64) => Some(quote!{
-            Some(&FieldType::FieldTypeU64) => {
+              for item in &self.#label {
-              Some(quote!{
+                let start_event = XmlEvent::start_element(#label_name);
-                for item in &self.#label {
+                let _ret = writer.write(start_event);
-                  let start_event = XmlEvent::start_element(#label_name);
-                  let _ret = writer.write(start_event);
 
-                  let data_event = XmlEvent::characters(format!("{}", item));
+                let data_event = XmlEvent::characters(format!("{}", item));
-                  let _ret = writer.write(data_event);
+                let _ret = writer.write(data_event);
 
-                  let end_event = XmlEvent::end_element();
+                let end_event = XmlEvent::end_element();
-                  let _ret = writer.write(end_event);
+                let _ret = writer.write(end_event);
-                }
+              }
-              })
+            }),
-            },
+            Some(&FieldType::FieldTypeStruct { .. }) => Some(quote!{
-            Some(&FieldType::FieldTypeStruct{..}) => {
+              for item in &self.#label {
-              Some(quote!{
+                writer.set_skip_start_end(false);
-                for item in &self.#label {
+                match item.serialize(writer) {
-                  writer.set_skip_start_end(false);
+                  Ok(()) => {},
-                  match item.serialize(writer) {
+                  Err(msg) => {
-                    Ok(()) => {},
+                    return Err(msg);
-                    Err(msg) => {
+                  },
-                      return Err(msg);
+                };
-                    },
+              }
-                  };
+            }),
-                }
+            Some(&FieldType::FieldTypeVec { .. }) => {
-              })
+              unimplemented!();
-            },
+            }
-            Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
+            None => {
-            None => {unimplemented!();},
+              unimplemented!();
+            }
           }
-        },
+        }
         None => None,
       }
     })
     .filter(|x| x.is_some())
     .map(|x| x.unwrap())
-    .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+    .fold(Tokens::new(), |mut tokens, token| {
+      tokens.append_all(token);
+      tokens
+    });
 
   quote! {
     use xml::writer::XmlEvent;
 
     impl YaSerialize for #name {
       #[allow(unused_variables)]
-      fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>) -> Result<(), String> {
+      fn serialize<W: Write>(&self, writer: &mut yaserde::ser::Serializer<W>)
+        -> Result<(), String> {
         error!("Struct: start to expand {:?}", #root);
         let skip = writer.skip_start_end();
         if !skip {

yaserde_derive/src/ser/mod.rs

@@ -1,4 +1,3 @@
-
 pub mod expand_enum;
 pub mod expand_struct;
 
@@ -16,27 +15,26 @@ pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<quote::Tokens,
   let root_attrs = attribute::YaSerdeAttribute::parse(&attrs);
   let root = root_attrs.clone().root.unwrap_or(name.to_string());
 
-  let root =
+  let root = if let Some(prefix) = root_attrs.prefix {
-    if let Some(prefix) = root_attrs.prefix {
+    prefix + ":" + &root
-      prefix + ":" + &root
+  } else {
-    } else {
+    root
-      root
+  };
-    };
 
-  let impl_block =
+  let impl_block = match data {
-    match data {
+    &syn::Data::Struct(ref data_struct) => {
-      &syn::Data::Struct(ref data_struct) => {
+      expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
-        expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
+    }
-      },
+    &syn::Data::Enum(ref data_enum) => {
-      &syn::Data::Enum(ref data_enum) => {
+      expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
-        expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
+    }
-      },
+    &syn::Data::Union(ref _data_union) => unimplemented!(),
-      &syn::Data::Union(ref _data_union) => {
+  };
-        unimplemented!()
-      },
-    };
 
-  let dummy_const = Ident::new(&format!("_IMPL_YA_SERIALIZE_FOR_{}", name), Span::def_site());
+  let dummy_const = Ident::new(
+    &format!("_IMPL_YA_SERIALIZE_FOR_{}", name),
+    Span::def_site(),
+  );
 
   let generated = quote! {
     #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]