update code format

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 {
-  let write_enum_content : Tokens = data_enum.variants.iter().map(|ref variant|
-    {
+pub fn serialize(
+  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 =
-        match variant_attrs.rename {
-          Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
-          None => variant.ident
-        };
+      let renamed_label = match variant_attrs.rename {
+        Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
+        None => variant.ident,
+      };
       let label = variant.ident;
-      let label_name =
-        if let Some(prefix) = variant_attrs.prefix {
-          prefix + ":" + renamed_label.to_string().as_ref()
-        } else {
-          renamed_label.to_string()
-        };
+      let label_name = if let Some(prefix) = variant_attrs.prefix {
+        prefix + ":" + renamed_label.to_string().as_ref()
+      } else {
+        renamed_label.to_string()
+      };
 
       match variant.fields {
-        Fields::Unit => {
-          Some(quote!{
-            &#name::#label => {
-              let data_event = XmlEvent::characters(#label_name);
-              let _ret = writer.write(data_event);
-            }
-          })
-        },
+        Fields::Unit => Some(quote!{
+          &#name::#label => {
+            let data_event = XmlEvent::characters(#label_name);
+            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);
-            if field_attrs.attribute == true {
-              return None;
-            }
-
-            let field_label = field.ident;
-            if field_attrs.text == true {
-              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 =
-              match field_attrs.rename {
+              let renamed_field_label = 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) {
-              Some(FieldType::FieldTypeString) =>
-                Some(quote!{
+              match get_field_type(field) {
+                Some(FieldType::FieldTypeString) => 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(quote!{
+                Some(FieldType::FieldTypeStruct { .. }) => 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(quote!{
+                Some(FieldType::FieldTypeVec { .. }) => 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
-            }
-          })
-          .filter(|x| x.is_some())
-          .map(|x| x.unwrap())
-          .fold(Tokens::new(), |mut tokens, token| {tokens.append_all(token); tokens});
+                _ => None,
+              }
+            })
+            .filter(|x| x.is_some())
+            .map(|x| x.unwrap())
+            .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) => {
-          unimplemented!()
-        },
+        }
+        Fields::Unnamed(ref _fields) => 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 {
-  let build_attributes : Tokens = data_struct.fields.iter().map(|ref field|
-    {
+pub fn serialize(
+  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 =
-        match field_attrs.rename {
-          Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
-          None => field.ident
-        };
+      let renamed_label = match field_attrs.rename {
+        Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
+        None => field.ident,
+      };
       let label = field.ident;
-      let label_name =
-        if let Some(prefix) = field_attrs.prefix {
-          prefix + ":" + renamed_label.unwrap().to_string().as_ref()
-        } else {
-          renamed_label.unwrap().to_string()
-        };
+      let label_name = if let Some(prefix) = field_attrs.prefix {
+        prefix + ":" + renamed_label.unwrap().to_string().as_ref()
+      } else {
+        renamed_label.unwrap().to_string()
+      };
 
       match get_field_type(field) {
-        Some(FieldType::FieldTypeString) |
-        Some(FieldType::FieldTypeBool) |
-        Some(FieldType::FieldTypeI8) |
-        Some(FieldType::FieldTypeU8) |
-        Some(FieldType::FieldTypeI16) |
-        Some(FieldType::FieldTypeU16) |
-        Some(FieldType::FieldTypeI32) |
-        Some(FieldType::FieldTypeU32) |
-        Some(FieldType::FieldTypeI64) |
-        Some(FieldType::FieldTypeU64) =>
-          Some(quote!{
-            .attr(#label_name, &self.#label)
-          }),
-        Some(FieldType::FieldTypeStruct{..}) =>
-          Some(quote!{
-            .attr(#label_name, &*{
-              use std::mem;
-              match yaserde::ser::to_string_content(&self.#label) {
-                Ok(value) => {
-                  unsafe {
-                    let ret : &'static str = mem::transmute(&value as &str);
-                    mem::forget(value);
-                    ret
-                  }
-                },
-                Err(msg) => return Err("Unable to serialize content".to_owned()),
-              }
-            })
-          }),
-        _ => {
-          None
-        }
+        Some(FieldType::FieldTypeString)
+        | Some(FieldType::FieldTypeBool)
+        | Some(FieldType::FieldTypeI8)
+        | Some(FieldType::FieldTypeU8)
+        | Some(FieldType::FieldTypeI16)
+        | Some(FieldType::FieldTypeU16)
+        | Some(FieldType::FieldTypeI32)
+        | Some(FieldType::FieldTypeU32)
+        | Some(FieldType::FieldTypeI64)
+        | Some(FieldType::FieldTypeU64) => Some(quote!{
+          .attr(#label_name, &self.#label)
+        }),
+        Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
+          .attr(#label_name, &*{
+            use std::mem;
+            match yaserde::ser::to_string_content(&self.#label) {
+              Ok(value) => {
+                unsafe {
+                  let ret : &'static str = mem::transmute(&value as &str);
+                  mem::forget(value);
+                  ret
+                }
+              },
+              Err(msg) => return Err("Unable to serialize content".to_owned()),
+            }
+          })
+        }),
+        _ => 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 =
-        match field_attrs.rename {
-          Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
-          None => field.ident
-        };
+      let renamed_label = match field_attrs.rename {
+        Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
+        None => field.ident,
+      };
 
-      let label_name =
-        if let Some(prefix) = field_attrs.prefix {
-          prefix + ":" + renamed_label.unwrap().to_string().as_ref()
-        } else {
-          renamed_label.unwrap().to_string()
-        };
+      let label_name = if let Some(prefix) = field_attrs.prefix {
+        prefix + ":" + renamed_label.unwrap().to_string().as_ref()
+      } else {
+        renamed_label.unwrap().to_string()
+      };
 
       match get_field_type(field) {
-        Some(FieldType::FieldTypeString) =>
-          Some(quote!{
-            let start_event = XmlEvent::start_element(#label_name);
-            let _ret = writer.write(start_event);
+        Some(FieldType::FieldTypeString) => Some(quote!{
+          let start_event = XmlEvent::start_element(#label_name);
+          let _ret = writer.write(start_event);
 
-            let data_event = XmlEvent::characters(&self.#label);
-            let _ret = writer.write(data_event);
+          let data_event = XmlEvent::characters(&self.#label);
+          let _ret = writer.write(data_event);
 
-            let end_event = XmlEvent::end_element();
-            let _ret = writer.write(end_event);
-          }),
-        Some(FieldType::FieldTypeBool) |
-        Some(FieldType::FieldTypeI8) |
-        Some(FieldType::FieldTypeU8) |
-        Some(FieldType::FieldTypeI16) |
-        Some(FieldType::FieldTypeU16) |
-        Some(FieldType::FieldTypeI32) |
-        Some(FieldType::FieldTypeU32) |
-        Some(FieldType::FieldTypeI64) |
-        Some(FieldType::FieldTypeU64) =>
-          Some(quote!{
-            let start_event = XmlEvent::start_element(#label_name);
-            let _ret = writer.write(start_event);
+          let end_event = XmlEvent::end_element();
+          let _ret = writer.write(end_event);
+        }),
+        Some(FieldType::FieldTypeBool)
+        | Some(FieldType::FieldTypeI8)
+        | Some(FieldType::FieldTypeU8)
+        | Some(FieldType::FieldTypeI16)
+        | Some(FieldType::FieldTypeU16)
+        | Some(FieldType::FieldTypeI32)
+        | Some(FieldType::FieldTypeU32)
+        | Some(FieldType::FieldTypeI64)
+        | Some(FieldType::FieldTypeU64) => Some(quote!{
+          let start_event = XmlEvent::start_element(#label_name);
+          let _ret = writer.write(start_event);
 
-            let content = format!("{}", &self.#label);
-            let data_event = XmlEvent::characters(&content);
-            let _ret = writer.write(data_event);
+          let content = format!("{}", &self.#label);
+          let data_event = XmlEvent::characters(&content);
+          let _ret = writer.write(data_event);
 
-            let end_event = XmlEvent::end_element();
-            let _ret = writer.write(end_event);
-          }),
-        Some(FieldType::FieldTypeStruct{..}) =>
-          Some(quote!{
-            writer.set_skip_start_end(false);
-            match self.#label.serialize(writer) {
-              Ok(()) => {},
-              Err(msg) => {
-                return Err(msg);
-              },
-            };
-          }),
-        Some(FieldType::FieldTypeVec{data_type}) => {
+          let end_event = XmlEvent::end_element();
+          let _ret = writer.write(end_event);
+        }),
+        Some(FieldType::FieldTypeStruct { .. }) => Some(quote!{
+          writer.set_skip_start_end(false);
+          match self.#label.serialize(writer) {
+            Ok(()) => {},
+            Err(msg) => {
+              return Err(msg);
+            },
+          };
+        }),
+        Some(FieldType::FieldTypeVec { data_type }) => {
           let dt = Box::into_raw(data_type);
-          match unsafe{dt.as_ref()} {
-            Some(&FieldType::FieldTypeString) => {
-              Some(quote!{
-                for item in &self.#label {
-                  let start_event = XmlEvent::start_element(#label_name);
-                  let _ret = writer.write(start_event);
+          match unsafe { dt.as_ref() } {
+            Some(&FieldType::FieldTypeString) => Some(quote!{
+              for item in &self.#label {
+                let start_event = XmlEvent::start_element(#label_name);
+                let _ret = writer.write(start_event);
 
-                  let data_event = XmlEvent::characters(item);
-                  let _ret = writer.write(data_event);
+                let data_event = XmlEvent::characters(item);
+                let _ret = writer.write(data_event);
 
-                  let end_event = XmlEvent::end_element();
-                  let _ret = writer.write(end_event);
-                }
-              })
-            },
-            Some(&FieldType::FieldTypeBool) |
-            Some(&FieldType::FieldTypeI8) |
-            Some(&FieldType::FieldTypeU8) |
-            Some(&FieldType::FieldTypeI16) |
-            Some(&FieldType::FieldTypeU16) |
-            Some(&FieldType::FieldTypeI32) |
-            Some(&FieldType::FieldTypeU32) |
-            Some(&FieldType::FieldTypeI64) |
-            Some(&FieldType::FieldTypeU64) => {
-              Some(quote!{
-                for item in &self.#label {
-                  let start_event = XmlEvent::start_element(#label_name);
-                  let _ret = writer.write(start_event);
+                let end_event = XmlEvent::end_element();
+                let _ret = writer.write(end_event);
+              }
+            }),
+            Some(&FieldType::FieldTypeBool)
+            | Some(&FieldType::FieldTypeI8)
+            | Some(&FieldType::FieldTypeU8)
+            | Some(&FieldType::FieldTypeI16)
+            | Some(&FieldType::FieldTypeU16)
+            | Some(&FieldType::FieldTypeI32)
+            | Some(&FieldType::FieldTypeU32)
+            | Some(&FieldType::FieldTypeI64)
+            | Some(&FieldType::FieldTypeU64) => Some(quote!{
+              for item in &self.#label {
+                let start_event = XmlEvent::start_element(#label_name);
+                let _ret = writer.write(start_event);
 
-                  let data_event = XmlEvent::characters(format!("{}", item));
-                  let _ret = writer.write(data_event);
+                let data_event = XmlEvent::characters(format!("{}", item));
+                let _ret = writer.write(data_event);
 
-                  let end_event = XmlEvent::end_element();
-                  let _ret = writer.write(end_event);
-                }
-              })
-            },
-            Some(&FieldType::FieldTypeStruct{..}) => {
-              Some(quote!{
-                for item in &self.#label {
-                  writer.set_skip_start_end(false);
-                  match item.serialize(writer) {
-                    Ok(()) => {},
-                    Err(msg) => {
-                      return Err(msg);
-                    },
-                  };
-                }
-              })
-            },
-            Some(&FieldType::FieldTypeVec{..}) => {unimplemented!();},
-            None => {unimplemented!();},
+                let end_event = XmlEvent::end_element();
+                let _ret = writer.write(end_event);
+              }
+            }),
+            Some(&FieldType::FieldTypeStruct { .. }) => Some(quote!{
+              for item in &self.#label {
+                writer.set_skip_start_end(false);
+                match item.serialize(writer) {
+                  Ok(()) => {},
+                  Err(msg) => {
+                    return Err(msg);
+                  },
+                };
+              }
+            }),
+            Some(&FieldType::FieldTypeVec { .. }) => {
+              unimplemented!();
+            }
+            None => {
+              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 =
-    if let Some(prefix) = root_attrs.prefix {
-      prefix + ":" + &root
-    } else {
-      root
-    };
+  let root = if let Some(prefix) = root_attrs.prefix {
+    prefix + ":" + &root
+  } else {
+    root
+  };
 
-  let impl_block =
-    match data {
-      &syn::Data::Struct(ref data_struct) => {
-        expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
-      },
-      &syn::Data::Enum(ref data_enum) => {
-        expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
-      },
-      &syn::Data::Union(ref _data_union) => {
-        unimplemented!()
-      },
-    };
+  let impl_block = match data {
+    &syn::Data::Struct(ref data_struct) => {
+      expand_struct::serialize(data_struct, &name, &root, &root_attrs.namespaces)
+    }
+    &syn::Data::Enum(ref data_enum) => {
+      expand_enum::serialize(data_enum, &name, &root, &root_attrs.namespaces)
+    }
+    &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)]