From d63e9d27d8e6d6f11ceb79897e4c9a89642daf0c Mon Sep 17 00:00:00 2001 From: Marc-Antoine Arnaud Date: Wed, 23 May 2018 17:14:53 +0200 Subject: [PATCH] update code format --- yaserde/src/de/mod.rs | 18 +- yaserde/src/lib.rs | 38 +- yaserde/src/ser/mod.rs | 20 +- yaserde/tests/der_namespace.rs | 34 +- yaserde/tests/der_type.rs | 7 +- yaserde/tests/deserializer.rs | 238 +++++---- yaserde/tests/se_namespace.rs | 55 +- yaserde/tests/se_type.rs | 7 +- yaserde/tests/serializer.rs | 162 +++--- yaserde_derive/src/attribute.rs | 85 ++- yaserde_derive/src/de/expand_enum.rs | 288 +++++----- yaserde_derive/src/de/expand_struct.rs | 680 ++++++++++++++++-------- yaserde_derive/src/de/mod.rs | 27 +- yaserde_derive/src/field_type.rs | 46 +- yaserde_derive/src/lib.rs | 4 +- yaserde_derive/src/ser/expand_enum.rs | 128 +++-- yaserde_derive/src/ser/expand_struct.rs | 313 +++++------ yaserde_derive/src/ser/mod.rs | 38 +- 18 files changed, 1218 insertions(+), 970 deletions(-) diff --git a/yaserde/src/de/mod.rs b/yaserde/src/de/mod.rs index fee2536..0783526 100644 --- a/yaserde/src/de/mod.rs +++ b/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 { loop { if let Ok(next) = self.reader.next() { match next { - XmlEvent::StartDocument { .. } | - XmlEvent::ProcessingInstruction { .. } | - XmlEvent::Comment(_) => { /* skip */ }, + XmlEvent::StartDocument { .. } + | XmlEvent::ProcessingInstruction { .. } + | XmlEvent::Comment(_) => { /* skip */ } other => return Ok(other), } } else { @@ -77,11 +76,11 @@ impl<'de, R: Read> Deserializer { 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 { } 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, - start_name.local_name + name.local_name, start_name.local_name )) } } else { diff --git a/yaserde/src/lib.rs b/yaserde/src/lib.rs index 68becda..361e26d 100644 --- a/yaserde/src/lib.rs +++ b/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(reader: &mut de::Deserializer) -> Result; } -pub trait YaSerialize : Sized { +pub trait YaSerialize: Sized { fn serialize(&self, writer: &mut ser::Serializer) -> 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 - { + fn visit_bool(self, v: &str) -> Result { Err(format!("Unexpected bool {}", v)) } - fn visit_i8(self, v: &str) -> Result - { + fn visit_i8(self, v: &str) -> Result { Err(format!("Unexpected i8 {}", v)) } - fn visit_u8(self, v: &str) -> Result - { + fn visit_u8(self, v: &str) -> Result { Err(format!("Unexpected u8 {}", v)) } - fn visit_i16(self, v: &str) -> Result - { + fn visit_i16(self, v: &str) -> Result { Err(format!("Unexpected i16 {}", v)) } - fn visit_u16(self, v: &str) -> Result - { + fn visit_u16(self, v: &str) -> Result { Err(format!("Unexpected u16 {}", v)) } - fn visit_i32(self, v: &str) -> Result - { + fn visit_i32(self, v: &str) -> Result { Err(format!("Unexpected i32 {}", v)) } - fn visit_u32(self, v: &str) -> Result - { + fn visit_u32(self, v: &str) -> Result { Err(format!("Unexpected u32 {}", v)) } - fn visit_i64(self, v: &str) -> Result - { + fn visit_i64(self, v: &str) -> Result { Err(format!("Unexpected i64 {}", v)) } - fn visit_u64(self, v: &str) -> Result - { + fn visit_u64(self, v: &str) -> Result { Err(format!("Unexpected u64 {}", v)) } - fn visit_str(self, v: &str) -> Result - { + fn visit_str(self, v: &str) -> Result { Err(format!("Unexpected str {}", v)) } #[inline] #[cfg(any(feature = "std", feature = "alloc"))] - fn visit_string(self, v: String) -> Result - { + fn visit_string(self, v: String) -> Result { self.visit_str(&v) } } diff --git a/yaserde/src/ser/mod.rs b/yaserde/src/ser/mod.rs index 9639cc7..3a93261 100644 --- a/yaserde/src/ser/mod.rs +++ b/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(model: &T) -> Result { Ok(String::from(data)) } -pub fn serialize_with_writer_content(model: &T, writer: W) -> Result { +pub fn serialize_with_writer_content( + model: &T, + writer: W, +) -> Result { 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(model: &T, writer pub struct Serializer { writer: EventWriter, - skip_start_end: bool + skip_start_end: bool, } impl<'de, W: Write> Serializer { pub fn new(writer: EventWriter) -> Self { Serializer { writer: writer, - skip_start_end: false + skip_start_end: false, } } pub fn new_from_writer(writer: W) -> Self { - let config = EmitterConfig::new() - .cdata_to_characters(true); + let config = EmitterConfig::new().cdata_to_characters(true); Self::new(EventWriter::new_with_config(writer, config)) } pub fn new_for_inner(writer: W) -> Self { - let config = EmitterConfig::new() - .write_document_declaration(false); + let config = EmitterConfig::new().write_document_declaration(false); Self::new(EventWriter::new_with_config(writer, config)) } @@ -77,7 +77,9 @@ impl<'de, W: Write> Serializer { } pub fn write<'a, E>(&mut self, event: E) -> xml::writer::Result<()> - where E: Into> { + where + E: Into>, + { self.writer.write(event) } } diff --git a/yaserde/tests/der_namespace.rs b/yaserde/tests/der_namespace.rs index d774e81..5ac96e5 100644 --- a/yaserde/tests/der_namespace.rs +++ b/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")] - author: String, - #[yaserde(prefix="ns")] - title: String, + #[yaserde(prefix = "ns")] author: String, + #[yaserde(prefix = "ns")] title: String, } let content = "Antoine de Saint-ExupéryLittle prince"; - convert_and_validate!(content, Book, Book{ - author: String::from("Antoine de Saint-Exupéry"), - title: String::from("Little prince") - }); + convert_and_validate!( + content, + Book, + Book { + author: String::from("Antoine de Saint-Exupéry"), + title: String::from("Little prince"), + } + ); let content = "Antoine de Saint-ExupéryLittle prince"; - let loaded : Result = from_str(content); + let loaded: Result = 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")] - Item + #[yaserde(prefix = "ns")] Item, } impl Default for XmlStruct { diff --git a/yaserde/tests/der_type.rs b/yaserde/tests/der_type.rs index d930986..7db05a2 100644 --- a/yaserde/tests/der_type.rs +++ b/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; diff --git a/yaserde/tests/deserializer.rs b/yaserde/tests/deserializer.rs index e1a8ef3..fc19d2f 100644 --- a/yaserde/tests/deserializer.rs +++ b/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 = "Antoine de Saint-ExupéryLittle prince"; - convert_and_validate!(content, Book, Book{ - author: String::from("Antoine de Saint-Exupéry"), - title: String::from("Little prince") - }); + let content = + "Antoine de Saint-ExupéryLittle prince"; + convert_and_validate!( + content, + Book, + Book { + author: String::from("Antoine de Saint-Exupéry"), + title: String::from("Little prince"), + } + ); - let content = "Little princeAntoine de Saint-Exupéry"; - convert_and_validate!(content, Book, Book{ - author: String::from("Antoine de Saint-Exupéry"), - title: String::from("Little prince") - }); + let content = + "Little princeAntoine de Saint-Exupéry"; + convert_and_validate!( + 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 + books: Vec, } let content = "Little PrinceHarry Potter"; - convert_and_validate!(content, Library, Library{ - books: vec![ - String::from("Little Prince"), - String::from("Harry Potter") - ] - }); + convert_and_validate!( + content, + Library, + 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: Vec, } let content = "Little PrinceHarry Potter"; - convert_and_validate!(content, Libraries, Libraries{ - library: vec![ - Library{ - books: vec![ - String::from("Little Prince") - ] - }, - Library{ - books: vec![ - String::from("Harry Potter") - ] - } - ] - }); + convert_and_validate!( + content, + Libraries, + Libraries { + library: vec![ + Library { + books: vec![String::from("Little Prince")], + }, + Library { + 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)] - item: String, - sub: SubStruct + #[yaserde(attribute)] item: String, + sub: SubStruct, } #[derive(YaDeserialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute)] - subitem: String + #[yaserde(attribute)] subitem: String, } impl Default for SubStruct { fn default() -> SubStruct { - SubStruct{ - subitem: "".to_string() + SubStruct { + subitem: "".to_string(), } } } let content = ""; - convert_and_validate!(content, XmlStruct, XmlStruct{ - item: "something".to_string(), - sub: SubStruct{ - subitem: "sub-something".to_string() + convert_and_validate!( + content, + XmlStruct, + 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")] - item: String, - #[yaserde(rename="sub")] - sub_struct: SubStruct + #[yaserde(attribute, rename = "Item")] item: String, + #[yaserde(rename = "sub")] sub_struct: SubStruct, } #[derive(YaDeserialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute, rename="sub_item")] - subitem: String, + #[yaserde(attribute, rename = "sub_item")] subitem: String, } impl Default for SubStruct { fn default() -> SubStruct { - SubStruct{ - subitem: "".to_string() + SubStruct { + subitem: "".to_string(), } } } let content = ""; - convert_and_validate!(content, XmlStruct, XmlStruct{ - item: "something".to_string(), - sub_struct: SubStruct{ - subitem: "sub_something".to_string() + convert_and_validate!( + content, + XmlStruct, + 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")] - item: String, - #[yaserde(rename="sub")] - sub_struct: SubStruct + #[yaserde(attribute, rename = "Item")] item: String, + #[yaserde(rename = "sub")] sub_struct: SubStruct, } #[derive(YaDeserialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute, rename="sub_item")] - subitem: String, - #[yaserde(text)] - text: String + #[yaserde(attribute, rename = "sub_item")] subitem: String, + #[yaserde(text)] text: String, } impl Default for SubStruct { fn default() -> SubStruct { - SubStruct{ + SubStruct { subitem: "".to_string(), text: "".to_string(), } } } - let content = "text_content"; - convert_and_validate!(content, XmlStruct, XmlStruct{ - item: "something".to_string(), - sub_struct: SubStruct{ - subitem: "sub_something".to_string(), - text: "text_content".to_string() + let content = + "text_content"; + convert_and_validate!( + content, + XmlStruct, + 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 + items: Vec, } #[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 = "Black"; - convert_and_validate!(content, XmlStruct, XmlStruct{ - background: Color::Black - }); + let content = + "Black"; + convert_and_validate!( + content, + XmlStruct, + XmlStruct { + background: Color::Black, + } + ); let content = "BlackWhite"; - convert_and_validate!(content, Colors, Colors{ - items: vec![Color::Black, Color::White] - }); + convert_and_validate!( + 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)] - background: Color + #[yaserde(attribute)] 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 = ""; - convert_and_validate!(content, XmlStruct, XmlStruct{ - background: Color::Black - }); + convert_and_validate!( + content, + XmlStruct, + XmlStruct { + background: Color::Black, + } + ); } diff --git a/yaserde/tests/se_namespace.rs b/yaserde/tests/se_namespace.rs index 1289ddd..899e40c 100644 --- a/yaserde/tests/se_namespace.rs +++ b/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")] - item: String + #[yaserde(prefix = "ns")] item: String, } let model = XmlStruct { - item: "something".to_string() + item: "something".to_string(), }; let content = "something"; @@ -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")] - Item + #[yaserde(prefix = "ns")] 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")] - item_1: String, - #[yaserde(prefix="ns2")] - item_2: String, + #[yaserde(prefix = "ns1")] item_1: 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")] - Item1, - #[yaserde(prefix="ns2")] - Item2, + #[yaserde(prefix = "ns1")] Item1, + #[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")] - item_1: String, - #[yaserde(attribute, prefix="ns2")] - item_2: String, + #[yaserde(prefix = "ns1")] item_1: 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 = "something"; diff --git a/yaserde/tests/se_type.rs b/yaserde/tests/se_type.rs index 29366a4..f690a0d 100644 --- a/yaserde/tests/se_type.rs +++ b/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; diff --git a/yaserde/tests/serializer.rs b/yaserde/tests/serializer.rs index 2a2e7d8..874fd9b 100644 --- a/yaserde/tests/serializer.rs +++ b/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 = "something"; @@ -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 + items: Vec, } - let model = XmlStruct{ - items: vec![ - "something1".to_string(), - "something2".to_string() - ] + let model = XmlStruct { + items: vec!["something1".to_string(), "something2".to_string()], }; let content = "something1something2"; convert_and_validate!(model, content); - #[derive(YaSerialize, PartialEq, Debug)] - #[yaserde(root="base")] + #[yaserde(root = "base")] pub struct XmlStructOfStruct { - items: Vec + items: Vec, } - #[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{ - field: "something1".to_string() + SubStruct { + field: "something1".to_string(), }, - SubStruct{ - field: "something2".to_string() - } - ] + SubStruct { + field: "something2".to_string(), + }, + ], }; let content = "something1something2"; @@ -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)] - item: String, - sub: SubStruct + #[yaserde(attribute)] item: String, + sub: SubStruct, } #[derive(YaSerialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute)] - subitem: String + #[yaserde(attribute)] subitem: String, } impl Default for SubStruct { fn default() -> SubStruct { - SubStruct{ - subitem: "".to_string() + SubStruct { + subitem: "".to_string(), } } } - let model = XmlStruct{ + let model = XmlStruct { item: "something".to_string(), - sub: SubStruct{ - subitem: "sub-something".to_string() - } + sub: SubStruct { + subitem: "sub-something".to_string(), + }, }; let content = ""; @@ -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")] - item: String, - #[yaserde(rename="sub")] - sub_struct: SubStruct + #[yaserde(attribute, rename = "Item")] item: String, + #[yaserde(rename = "sub")] sub_struct: SubStruct, } #[derive(YaSerialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute, rename="sub_item")] - subitem: String, + #[yaserde(attribute, rename = "sub_item")] subitem: String, } impl Default for SubStruct { fn default() -> SubStruct { - SubStruct{ - subitem: "".to_string() + SubStruct { + subitem: "".to_string(), } } } - let model = XmlStruct{ + let model = XmlStruct { item: "something".to_string(), - sub_struct: SubStruct{ - subitem: "sub_something".to_string() - } + sub_struct: SubStruct { + subitem: "sub_something".to_string(), + }, }; let content = ""; @@ -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")] - item: String, - #[yaserde(rename="sub")] - sub_struct: SubStruct + #[yaserde(attribute, rename = "Item")] item: String, + #[yaserde(rename = "sub")] sub_struct: SubStruct, } #[derive(YaSerialize, PartialEq, Debug)] - #[yaserde(root="sub")] + #[yaserde(root = "sub")] pub struct SubStruct { - #[yaserde(attribute, rename="sub_item")] - subitem: String, - #[yaserde(text)] - text: String, + #[yaserde(attribute, rename = "sub_item")] subitem: 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 = "text_content"; @@ -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, - } + }, } impl Default for Color { @@ -235,50 +220,45 @@ fn ser_enum() { Opaque, } - let model = XmlStruct{ - color: Color::Black + let model = XmlStruct { + color: Color::Black, }; let content = "Black"; convert_and_validate!(model, content); - let model = XmlStruct{ - color: Color::Custom{ + let model = XmlStruct { + 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 = "true0128255OpaqueOpaqueTransparent"; 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)] - color: Color + #[yaserde(attribute)] color: Color, } #[derive(YaSerialize, PartialEq, Debug)] - #[yaserde(root="color")] + #[yaserde(root = "color")] pub enum Color { - #[yaserde(rename="pink")] - Pink, + #[yaserde(rename = "pink")] Pink, } - let model = XmlStruct{ - color: Color::Pink - }; + let model = XmlStruct { color: Color::Pink }; let content = ""; convert_and_validate!(model, content); diff --git a/yaserde_derive/src/attribute.rs b/yaserde_derive/src/attribute.rs index 22df692..e8a3863 100644 --- a/yaserde_derive/src/attribute.rs +++ b/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 { match (iter.next(), iter.next()) { - (Some(operator), Some(value)) => { - match (operator.kind, value.kind) { - (Op('=', Spacing::Alone), Literal(l)) => { - Some(l.to_string().replace("\"", "")) - }, - _ => None, - } + (Some(operator), Some(value)) => match (operator.kind, value.kind) { + (Op('=', Spacing::Alone), Literal(l)) => 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) => { - match token.kind { - Group(Parenthesis, token_stream) => { - let mut attr_iter = token_stream.into_iter(); + Some(token) => match token.kind { + Group(Parenthesis, token_stream) => { + let mut attr_iter = token_stream.into_iter(); - while let Some(item) = attr_iter.next() { - match item.kind { - Term(t) => { - match t.as_str() { - "attribute" => { - attribute = true; - }, - "namespace" => { - if let Some(namespace) = get_value(&mut attr_iter) { - - let splitted : Vec<&str> = namespace.split(": ").collect(); - 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); + while let Some(item) = attr_iter.next() { + match item.kind { + Term(t) => match t.as_str() { + "attribute" => { + attribute = true; + } + "namespace" => { + if let Some(namespace) = get_value(&mut attr_iter) { + let splitted: Vec<&str> = namespace.split(": ").collect(); + if splitted.len() == 2 { + namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned()); } - "rename" => { - rename = get_value(&mut attr_iter); - }, - "root" => { - root = get_value(&mut attr_iter); - }, - "text" => { - text = true; + if splitted.len() == 1 { + namespaces.insert("".to_owned(), splitted[0].to_owned()); } - _ => {}, } - }, + } + "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 => {} } } diff --git a/yaserde_derive/src/de/expand_enum.rs b/yaserde_derive/src/de/expand_enum.rs index 0d84a08..0c42c7f 100644 --- a/yaserde_derive/src/de/expand_enum.rs +++ b/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) -> Tokens { - 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| { +pub fn parse( + data_enum: &DataEnum, + name: &Ident, + root: &String, + _namespaces: &BTreeMap, +) -> Tokens { + 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) => - build_default_value(&field_label, quote!{String}, quote!{"".to_string()}), - Some(FieldType::FieldTypeBool) => - build_default_value(&field_label, quote!{bool}, quote!{false}), - Some(FieldType::FieldTypeI8) => - build_default_value(&field_label, quote!{i8}, quote!{0}), - Some(FieldType::FieldTypeU8) => - build_default_value(&field_label, quote!{u8}, quote!{0}), - Some(FieldType::FieldTypeI16) => - build_default_value(&field_label, quote!{i16}, quote!{0}), - Some(FieldType::FieldTypeU16) => - build_default_value(&field_label, quote!{u16}, quote!{0}), - Some(FieldType::FieldTypeI32) => - build_default_value(&field_label, quote!{i32}, quote!{0}), - Some(FieldType::FieldTypeU32) => - build_default_value(&field_label, quote!{u32}, quote!{0}), - Some(FieldType::FieldTypeI64) => - build_default_value(&field_label, quote!{i64}, quote!{0}), - 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}) => { + Some(FieldType::FieldTypeString) => { + build_default_value(&field_label, quote!{String}, quote!{"".to_string()}) + } + Some(FieldType::FieldTypeBool) => { + build_default_value(&field_label, quote!{bool}, quote!{false}) + } + Some(FieldType::FieldTypeI8) => { + build_default_value(&field_label, quote!{i8}, quote!{0}) + } + Some(FieldType::FieldTypeU8) => { + build_default_value(&field_label, quote!{u8}, quote!{0}) + } + Some(FieldType::FieldTypeI16) => { + build_default_value(&field_label, quote!{i16}, quote!{0}) + } + Some(FieldType::FieldTypeU16) => { + build_default_value(&field_label, quote!{u16}, quote!{0}) + } + Some(FieldType::FieldTypeI32) => { + build_default_value(&field_label, quote!{i32}, quote!{0}) + } + Some(FieldType::FieldTypeU32) => { + build_default_value(&field_label, quote!{u32}, quote!{0}) + } + Some(FieldType::FieldTypeI64) => { + build_default_value(&field_label, quote!{i64}, quote!{0}) + } + 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()} { - Some(&FieldType::FieldTypeString) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeBool) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI8) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU8) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI16) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU16) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI32) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU32) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI64) => - build_default_value(&field_label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU64) => - build_default_value(&field_label, quote!{Vec}, 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!();}, + match unsafe { dt.as_ref() } { + Some(&FieldType::FieldTypeString) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeBool) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI8) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU8) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI16) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU16) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI32) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU32) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI64) => { + build_default_value(&field_label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU64) => { + build_default_value(&field_label, quote!{Vec}, 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) - } - Fields::Unnamed(ref _fields) => { - unimplemented!(); - } + Some(enum_fields) + } + Fields::Unnamed(ref _fields) => { + 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 label = field.ident; - // let label_name = label.unwrap().to_string(); - // let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site()); + let enum_fields = fields + .named + .iter() + .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) { - Some(FieldType::FieldTypeString) => { - Some(quote!{ - // struct #visitor_label; - // impl<'de> Visitor<'de> for #visitor_label { - // type Value = String; + match get_field_type(field) { + Some(FieldType::FieldTypeString) => { + Some(quote!{ + // struct #visitor_label; + // impl<'de> Visitor<'de> for #visitor_label { + // type Value = String; - // fn visit_str(self, v: &str) -> Result { - // match v { - // _ => Err("unable to match \"{}\" with enum {}", v, #label_name) - // } - // Ok(String::from(v)) - // } - // } - }) - }, - _ => None - } - }) - .filter(|x| x.is_some()) - .map(|x| x.unwrap()) - .fold(Tokens::new(), |mut sum, val| {sum.append_all(val); sum}); + // fn visit_str(self, v: &str) -> Result { + // match v { + // _ => Err("unable to match \"{}\" with enum {}", v, #label_name) + // } + // Ok(String::from(v)) + // } + // } + }) + } + _ => None, + } + }) + .filter(|x| x.is_some()) + .map(|x| x.unwrap()) + .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 = - match field_attrs.rename { - Some(value) => Ident::new(&format!("{}", value), Span::call_site()), - None => variant.ident - }; + let renamed_label = match field_attrs.rename { + Some(value) => Ident::new(&format!("{}", value), Span::call_site()), + None => variant.ident, + }; let label = variant.ident; let label_name = renamed_label.to_string(); match variant.fields { - Fields::Unit => { - Some(quote!{ - #label_name => { - simple_enum_value = Some(#name::#label); - } - }) - }, - _ => { - None - } + Fields::Unit => Some(quote!{ + #label_name => { + simple_enum_value = Some(#name::#label); + } + }), + _ => 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, field_type: Tokens, default: Tokens) -> Option { +fn build_default_value( + label: &Option, + field_type: Tokens, + default: Tokens, +) -> Option { Some(quote!{ #[allow(unused_mut)] let mut #label : #field_type = #default; diff --git a/yaserde_derive/src/de/expand_struct.rs b/yaserde_derive/src/de/expand_struct.rs index 7961047..e127585 100644 --- a/yaserde_derive/src/de/expand_struct.rs +++ b/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) -> Tokens { - - let validate_namespace : Tokens = namespaces.iter().map(|(ref _prefix, ref namespace)| { +pub fn parse( + data_struct: &DataStruct, + name: &Ident, + root: &String, + namespaces: &BTreeMap, +) -> 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.fields.iter().map(|ref field| - { + let variables: Tokens = data_struct + .fields + .iter() + .map(|ref field| { let label = field.ident; match get_field_type(field) { - Some(FieldType::FieldTypeString) => - build_default_value(&label, quote!{String}, quote!{"".to_string()}), - Some(FieldType::FieldTypeBool) => - build_default_value(&label, quote!{bool}, quote!{false}), - Some(FieldType::FieldTypeI8) => - build_default_value(&label, quote!{i8}, quote!{0}), - Some(FieldType::FieldTypeU8) => - build_default_value(&label, quote!{u8}, quote!{0}), - Some(FieldType::FieldTypeI16) => - build_default_value(&label, quote!{i16}, quote!{0}), - Some(FieldType::FieldTypeU16) => - build_default_value(&label, quote!{u16}, quote!{0}), - Some(FieldType::FieldTypeI32) => - build_default_value(&label, quote!{i32}, quote!{0}), - Some(FieldType::FieldTypeU32) => - build_default_value(&label, quote!{u32}, quote!{0}), - Some(FieldType::FieldTypeI64) => - 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}) => { + Some(FieldType::FieldTypeString) => { + build_default_value(&label, quote!{String}, quote!{"".to_string()}) + } + Some(FieldType::FieldTypeBool) => build_default_value(&label, quote!{bool}, quote!{false}), + Some(FieldType::FieldTypeI8) => build_default_value(&label, quote!{i8}, quote!{0}), + Some(FieldType::FieldTypeU8) => build_default_value(&label, quote!{u8}, quote!{0}), + Some(FieldType::FieldTypeI16) => build_default_value(&label, quote!{i16}, quote!{0}), + Some(FieldType::FieldTypeU16) => build_default_value(&label, quote!{u16}, quote!{0}), + Some(FieldType::FieldTypeI32) => build_default_value(&label, quote!{i32}, quote!{0}), + Some(FieldType::FieldTypeU32) => build_default_value(&label, quote!{u32}, quote!{0}), + Some(FieldType::FieldTypeI64) => 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()} { - Some(&FieldType::FieldTypeString) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeBool) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI8) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU8) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI16) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU16) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI32) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU32) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeI64) => - build_default_value(&label, quote!{Vec}, quote!{vec![]}), - Some(&FieldType::FieldTypeU64) => - build_default_value(&label, quote!{Vec}, 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!();}, + match unsafe { dt.as_ref() } { + Some(&FieldType::FieldTypeString) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeBool) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI8) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU8) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI16) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU16) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI32) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU32) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeI64) => { + build_default_value(&label, quote!{Vec}, quote!{vec![]}) + } + Some(&FieldType::FieldTypeU64) => { + build_default_value(&label, quote!{Vec}, 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 = - if let Some(value) = field_attrs.rename { - Ident::new(&format!("{}", value), Span::call_site()).to_string() - } else { - field.ident.unwrap().to_string() - }; + let label_name = if let Some(value) = field_attrs.rename { + Ident::new(&format!("{}", value), Span::call_site()).to_string() + } else { + 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 = - if let Some(value) = field_attrs.rename { - Ident::new(&format!("{}", value), Span::call_site()).to_string() - } else { - field.ident.unwrap().to_string() - }; + let label_name = if let Some(value) = field_attrs.rename { + Ident::new(&format!("{}", value), Span::call_site()).to_string() + } else { + 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) - }, - Some(FieldType::FieldTypeStruct{struct_name}) => { - Some(quote!{ - #label_name => { - reader.set_map_value(); - match #struct_name::deserialize(reader) { - Ok(parsed_item) => { - #label = parsed_item; - let _root = reader.next(); - }, - Err(msg) => { - return Err(msg); - }, - } + build_call_visitor( + quote!{i64}, + &visitor, + quote!{= value}, + &visitor_label, + &label, + &label_name, + ) + } + Some(FieldType::FieldTypeStruct { struct_name }) => Some(quote!{ + #label_name => { + reader.set_map_value(); + 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 field_attrs = YaSerdeAttribute::parse(&field.attrs); - if !field_attrs.attribute { - return None; - } + let attributes_loading: Tokens = data_struct + .fields + .iter() + .map(|ref field| { + let field_attrs = YaSerdeAttribute::parse(&field.attrs); + if !field_attrs.attribute { + return None; + } - let label = field.ident; - let label_name = - if let Some(value) = field_attrs.rename { + let label = field.ident; + let label_name = 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) { - Some(FieldType::FieldTypeString) => { - Some(quote!{ + match get_field_type(field) { + Some(FieldType::FieldTypeString) => Some(quote!{ for attr in attributes { if attr.name.local_name == #label_name { #label = attr.value.to_owned(); } } - }) - } - Some(FieldType::FieldTypeStruct{struct_name}) => { - let struct_ident = Ident::new(&format!("__Visitor_{}_{}", label_name, struct_name), Span::call_site()); + }), + Some(FieldType::FieldTypeStruct { struct_name }) => { + let struct_ident = Ident::new( + &format!("__Visitor_{}_{}", label_name, struct_name), + Span::call_site(), + ); - Some(quote!{ - for attr in attributes { - if attr.name.local_name == #label_name { - let visitor = #struct_ident{}; - match visitor.visit_str(&attr.value) { - Ok(value) => {#label = value;} - Err(msg) => {return Err(msg);} + Some(quote!{ + for attr in attributes { + if attr.name.local_name == #label_name { + let visitor = #struct_ident{}; + match visitor.visit_str(&attr.value) { + Ok(value) => {#label = value;} + Err(msg) => {return Err(msg);} + } } } - } - }) - } - _ => { - 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, + }) + } + _ => 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, field_type: Tokens, default: Tokens) -> Option { +fn build_default_value( + label: &Option, + field_type: Tokens, + default: Tokens, +) -> Option { Some(quote!{ #[allow(unused_mut)] let mut #label : #field_type = #default; }) } -fn build_declare_visitor(field_type: Tokens, visitor: &Ident, visitor_label: &Ident) -> Option { +fn build_declare_visitor( + field_type: Tokens, + visitor: &Ident, + visitor_label: &Ident, +) -> Option { 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, label_name: &String) -> Option { +fn build_call_visitor( + field_type: Tokens, + visitor: &Ident, + action: Tokens, + visitor_label: &Ident, + label: &Option, + label_name: &String, +) -> Option { 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(field_attrs: &YaSerdeAttribute, label: &Option, action: Tokens) -> Option { +fn build_set_text_to_value( + field_attrs: &YaSerdeAttribute, + label: &Option, + action: Tokens, +) -> Option { if field_attrs.text { Some(quote!{ #label = #action; diff --git a/yaserde_derive/src/de/mod.rs b/yaserde_derive/src/de/mod.rs index 098207b..e04bca5 100644 --- a/yaserde_derive/src/de/mod.rs +++ b/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 { - expand_struct::parse(data_struct, &name, &root, &root_attrs.namespaces) - }, - &syn::Data::Enum(ref data_enum) => { - expand_enum::parse(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::parse(data_struct, &name, &root, &root_attrs.namespaces) + } + &syn::Data::Enum(ref data_enum) => { + expand_enum::parse(data_enum, &name, &root, &root_attrs.namespaces) + } + &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)] diff --git a/yaserde_derive/src/field_type.rs b/yaserde_derive/src/field_type.rs index 73f6f9c..9b19aea 100644 --- a/yaserde_derive/src/field_type.rs +++ b/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}, - FieldTypeStruct{struct_name: syn::Ident}, + FieldTypeVec { data_type: Box }, + 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" => { - get_vec_type(t).map(|data_type| { - let p = syn::PathSegment{ - ident: data_type, - arguments: syn::PathArguments::None - }; + "Vec" => get_vec_type(t).map(|data_type| { + let p = syn::PathSegment { + ident: data_type, + arguments: syn::PathArguments::None, + }; - FieldType::FieldTypeVec{ - data_type: Box::new(FieldType::from_ident(&p).unwrap()) - } - }) - }, - _struct_name => - Some(FieldType::FieldTypeStruct{ - struct_name: t.ident - }), + FieldType::FieldTypeVec { + data_type: Box::new(FieldType::from_ident(&p).unwrap()), + } + }), + _struct_name => Some(FieldType::FieldTypeStruct { + struct_name: t.ident, + }), } } } pub fn get_field_type(field: &syn::Field) -> Option { match field.ty { - Path(ref path) => { - match path.path.segments.first() { - Some(Pair::End(t)) => { - FieldType::from_ident(t) - }, - _ => { - None - }, - } + Path(ref path) => match path.path.segments.first() { + Some(Pair::End(t)) => FieldType::from_ident(t), + _ => None, }, _ => None, } @@ -74,7 +64,7 @@ fn get_vec_type(t: &syn::PathSegment) -> Option { 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); } } } diff --git a/yaserde_derive/src/lib.rs b/yaserde_derive/src/lib.rs index c805912..71b9f03 100644 --- a/yaserde_derive/src/lib.rs +++ b/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; diff --git a/yaserde_derive/src/ser/expand_enum.rs b/yaserde_derive/src/ser/expand_enum.rs index b7edf4c..f473fa8 100644 --- a/yaserde_derive/src/ser/expand_enum.rs +++ b/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) -> 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, +) -> 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(&self, writer: &mut yaserde::ser::Serializer) -> Result<(), String> { + fn serialize(&self, writer: &mut yaserde::ser::Serializer) + -> Result<(), String> { error!("Enum: start to expand {:?}", #root); if !writer.skip_start_end() { diff --git a/yaserde_derive/src/ser/expand_struct.rs b/yaserde_derive/src/ser/expand_struct.rs index 261e673..6014cc6 100644 --- a/yaserde_derive/src/ser/expand_struct.rs +++ b/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) -> Tokens { - let build_attributes : Tokens = data_struct.fields.iter().map(|ref field| - { +pub fn serialize( + data_struct: &DataStruct, + name: &Ident, + root: &String, + namespaces: &BTreeMap, +) -> 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(&self, writer: &mut yaserde::ser::Serializer) -> Result<(), String> { + fn serialize(&self, writer: &mut yaserde::ser::Serializer) + -> Result<(), String> { error!("Struct: start to expand {:?}", #root); let skip = writer.skip_start_end(); if !skip { diff --git a/yaserde_derive/src/ser/mod.rs b/yaserde_derive/src/ser/mod.rs index 60c3157..f330b6b 100644 --- a/yaserde_derive/src/ser/mod.rs +++ b/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 { - 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)]