NationTech/yaserde
6
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update dependencies

Browse Source
This commit is contained in:
Marc-Antoine Arnaud 2018-05-25 09:43:15 +02:00
parent cb37689656
commit e691fba686
10 changed files with 145 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
yaserde/Cargo.toml
View File

@ -13,7 +13,7 @@ readme = "../README.md"
[dependencies] [dependencies]
yaserde_derive = { version = "0.2", path = "../yaserde_derive", optional = true } yaserde_derive = { version = "0.2", path = "../yaserde_derive", optional = true }
regex = "0.2" regex = "0.2"
xml-rs = "0.7.0" xml-rs = "0.8.0"
log = "0.4.1" log = "0.4.1"
[dev-dependencies] [dev-dependencies]

6
yaserde_derive/Cargo.toml
View File

@ -11,9 +11,9 @@ documentation = "https://docs.rs/yaserde"
readme = "../README.md" readme = "../README.md"
[dependencies] [dependencies]
syn = { version = "0.12.14", features = ["visit", "extra-traits"] } syn = { version = "0.14.0", features = ["visit", "extra-traits"] }
proc-macro2 = "0.2.3" proc-macro2 = "0.4.3"
quote = "0.4.2" quote = "0.6.2"
[lib] [lib]
name = "yaserde_derive" name = "yaserde_derive"

84
yaserde_derive/src/attribute.rs
View File

@ -1,7 +1,7 @@
use proc_macro2::TokenTreeIter;
use proc_macro2::TokenNode::*; use proc_macro2::TokenTree;
use proc_macro2::Spacing; use proc_macro2::Delimiter;
use proc_macro2::Delimiter::Parenthesis; use proc_macro2::token_stream::IntoIter;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use syn::Attribute; use syn::Attribute;
@ -15,13 +15,15 @@ pub struct YaSerdeAttribute {
pub text: bool, pub text: bool,
} }
fn get_value(iter: &mut TokenTreeIter) -> Option<String> { fn get_value(iter: &mut IntoIter) -> Option<String> {
match (iter.next(), iter.next()) { if let (Some(TokenTree::Punct(operator)), Some(TokenTree::Literal(value))) = (iter.next(), iter.next()) {
(Some(operator), Some(value)) => match (operator.kind, value.kind) { if operator.as_char() == '=' {
(Op('=', Spacing::Alone), Literal(l)) => Some(l.to_string().replace("\"", "")), Some(value.to_string().replace("\"", ""))
_ => None, } else {
}, None
_ => None, }
} else {
None
} }
} }
@ -37,39 +39,41 @@ impl YaSerdeAttribute {
for attr in attrs.iter() { for attr in attrs.iter() {
let mut attr_iter = attr.clone().tts.into_iter(); let mut attr_iter = attr.clone().tts.into_iter();
if let Some(token) = attr_iter.next() { if let Some(token) = attr_iter.next() {
if let Group(Parenthesis, token_stream) = token.kind { if let TokenTree::Group(group) = token {
let mut attr_iter = token_stream.into_iter(); if group.delimiter() == Delimiter::Parenthesis {
let mut attr_iter = group.stream().into_iter();
while let Some(item) = attr_iter.next() { while let Some(item) = attr_iter.next() {
if let Term(term) = item.kind { if let TokenTree::Ident(ident) = item {
match term.as_str() { match ident.to_string().as_str() {
"attribute" => { "attribute" => {
attribute = true; attribute = true;
} }
"namespace" => { "namespace" => {
if let Some(namespace) = get_value(&mut attr_iter) { if let Some(namespace) = get_value(&mut attr_iter) {
let splitted: Vec<&str> = namespace.split(": ").collect(); let splitted: Vec<&str> = namespace.split(": ").collect();
if splitted.len() == 2 { if splitted.len() == 2 {
namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned()); namespaces.insert(splitted[0].to_owned(), splitted[1].to_owned());
} }
if splitted.len() == 1 { if splitted.len() == 1 {
namespaces.insert("".to_owned(), splitted[0].to_owned()); 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;
}
_ => {}
} }
"prefix" => {
prefix = get_value(&mut attr_iter);
}
"rename" => {
rename = get_value(&mut attr_iter);
}
"root" => {
root = get_value(&mut attr_iter);
}
"text" => {
text = true;
}
_ => {}
} }
} }
} }

36
yaserde_derive/src/de/expand_enum.rs
View File

@ -1,19 +1,19 @@
use attribute::*; use attribute::*;
use field_type::*; use field_type::*;
use quote::Tokens; use quote::TokenStreamExt;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use syn::Fields; use syn::Fields;
use syn::Ident; use syn::Ident;
use syn::DataEnum; use syn::DataEnum;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
pub fn parse( pub fn parse(
data_enum: &DataEnum, data_enum: &DataEnum,
name: &Ident, name: &Ident,
root: &str, root: &str,
_namespaces: &BTreeMap<String, String>, _namespaces: &BTreeMap<String, String>,
) -> Tokens { ) -> TokenStream {
let variables: Tokens = data_enum let variables: TokenStream = data_enum
.variants .variants
.iter() .iter()
.map(|variant| match variant.fields { .map(|variant| match variant.fields {
@ -23,7 +23,7 @@ pub fn parse(
.named .named
.iter() .iter()
.map(|field| { .map(|field| {
let field_label = field.ident; let field_label = &field.ident;
match get_field_type(field) { match get_field_type(field) {
Some(FieldType::FieldTypeString) => { Some(FieldType::FieldTypeString) => {
@ -93,7 +93,7 @@ pub fn parse(
Some(&FieldType::FieldTypeU64) => { Some(&FieldType::FieldTypeU64) => {
build_default_value(&field_label, &quote!{Vec<u64>}, &quote!{vec![]}) build_default_value(&field_label, &quote!{Vec<u64>}, &quote!{vec![]})
} }
Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{ Some(&FieldType::FieldTypeStruct { ref struct_name }) => Some(quote!{
#[allow(unused_mut)] #[allow(unused_mut)]
let mut #field_label : Vec<#struct_name> = vec![]; let mut #field_label : Vec<#struct_name> = vec![];
}), }),
@ -110,7 +110,7 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
@ -123,12 +123,12 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let enum_visitors: Tokens = data_enum let enum_visitors: TokenStream = data_enum
.variants .variants
.iter() .iter()
.map(|variant| { .map(|variant| {
@ -164,7 +164,7 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
@ -178,21 +178,21 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let match_to_enum: Tokens = data_enum let match_to_enum: TokenStream = data_enum
.variants .variants
.iter() .iter()
.map(|variant| { .map(|variant| {
let field_attrs = YaSerdeAttribute::parse(&variant.attrs); let field_attrs = YaSerdeAttribute::parse(&variant.attrs);
let renamed_label = match field_attrs.rename { let renamed_label = match field_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()), Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident, None => variant.ident.clone(),
}; };
let label = variant.ident; let label = &variant.ident;
let label_name = renamed_label.to_string(); let label_name = renamed_label.to_string();
match variant.fields { match variant.fields {
@ -206,7 +206,7 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
@ -274,9 +274,9 @@ pub fn parse(
fn build_default_value( fn build_default_value(
label: &Option<Ident>, label: &Option<Ident>,
field_type: &Tokens, field_type: &TokenStream,
default: &Tokens, default: &TokenStream,
) -> Option<Tokens> { ) -> Option<TokenStream> {
Some(quote!{ Some(quote!{
#[allow(unused_mut)] #[allow(unused_mut)]
let mut #label : #field_type = #default; let mut #label : #field_type = #default;

88
yaserde_derive/src/de/expand_struct.rs
View File

@ -1,24 +1,26 @@
use attribute::*; use attribute::*;
use field_type::*; use field_type::*;
use quote::Tokens; use quote::TokenStreamExt;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use syn::Ident; use syn::Ident;
use syn::DataStruct; use syn::DataStruct;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
pub fn parse( pub fn parse(
data_struct: &DataStruct, data_struct: &DataStruct,
name: &Ident, name: &Ident,
root: &str, root: &str,
namespaces: &BTreeMap<String, String>, namespaces: &BTreeMap<String, String>,
) -> Tokens { ) -> TokenStream {
let validate_namespace: Tokens = namespaces let validate_namespace: TokenStream = namespaces
.iter() .iter()
.map(|(_prefix, namespace)| { .map(|(_prefix, namespace)| {
Some(quote!( Some(quote!(
let mut found = false; let mut found = false;
println!("{:?}", namespace);
for (key, value) in namespace { for (key, value) in namespace {
println!("{:?}", value);
if #namespace == value { if #namespace == value {
found = true; found = true;
} }
@ -31,16 +33,16 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
let variables: Tokens = data_struct let variables: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
let label = field.ident; let label = &field.ident;
match get_field_type(field) { match get_field_type(field) {
Some(FieldType::FieldTypeString) => { Some(FieldType::FieldTypeString) => {
build_default_value(&label, &quote!{String}, &quote!{"".to_string()}) build_default_value(&label, &quote!{String}, &quote!{"".to_string()})
@ -93,7 +95,7 @@ pub fn parse(
Some(&FieldType::FieldTypeU64) => { Some(&FieldType::FieldTypeU64) => {
build_default_value(&label, &quote!{Vec<u64>}, &quote!{vec![]}) build_default_value(&label, &quote!{Vec<u64>}, &quote!{vec![]})
} }
Some(&FieldType::FieldTypeStruct { struct_name }) => Some(quote!{ Some(&FieldType::FieldTypeStruct { ref struct_name }) => Some(quote!{
#[allow(unused_mut)] #[allow(unused_mut)]
let mut #label : Vec<#struct_name> = vec![]; let mut #label : Vec<#struct_name> = vec![];
}), }),
@ -110,12 +112,12 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let field_visitors: Tokens = data_struct let field_visitors: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
@ -123,7 +125,7 @@ pub fn parse(
let label_name = if let Some(value) = field_attrs.rename { let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string() Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else { } else {
field.ident.unwrap().to_string() field.ident.clone().unwrap().to_string()
}; };
let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site()); let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
@ -213,8 +215,8 @@ pub fn parse(
Some(&FieldType::FieldTypeU64) => { Some(&FieldType::FieldTypeU64) => {
build_declare_visitor(&quote!{u64}, &quote!{visit_u64}, &visitor_label) build_declare_visitor(&quote!{u64}, &quote!{visit_u64}, &visitor_label)
} }
Some(&FieldType::FieldTypeStruct { struct_name }) => { Some(&FieldType::FieldTypeStruct { ref struct_name }) => {
let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site()); let struct_ident = Ident::new(&format!("{}", struct_name), Span::call_site());
Some(quote!{ Some(quote!{
#[allow(non_snake_case, non_camel_case_types)] #[allow(non_snake_case, non_camel_case_types)]
struct #visitor_label; struct #visitor_label;
@ -231,17 +233,17 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let call_visitors: Tokens = data_struct let call_visitors: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
let field_attrs = YaSerdeAttribute::parse(&field.attrs); let field_attrs = YaSerdeAttribute::parse(&field.attrs);
let label = field.ident; let label = &field.ident;
if field_attrs.attribute { if field_attrs.attribute {
return None; return None;
@ -250,7 +252,7 @@ pub fn parse(
let label_name = if let Some(value) = field_attrs.rename { let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string() Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else { } else {
field.ident.unwrap().to_string() field.ident.clone().unwrap().to_string()
}; };
let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site()); let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
@ -493,8 +495,8 @@ pub fn parse(
&label_name, &label_name,
) )
} }
Some(&FieldType::FieldTypeStruct { struct_name }) => { Some(&FieldType::FieldTypeStruct { ref struct_name }) => {
let struct_ident = Ident::new(&format!("{}", struct_name), Span::def_site()); let struct_ident = Ident::new(&format!("{}", struct_name), Span::call_site());
Some(quote!{ Some(quote!{
#label_name => { #label_name => {
reader.set_map_value(); reader.set_map_value();
@ -518,12 +520,12 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let attributes_loading: Tokens = data_struct let attributes_loading: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
@ -532,11 +534,11 @@ pub fn parse(
return None; return None;
} }
let label = field.ident; let label = &field.ident;
let label_name = if let Some(value) = field_attrs.rename { let label_name = if let Some(value) = field_attrs.rename {
Ident::new(&format!("{}", value), Span::call_site()).to_string() Ident::new(&format!("{}", value), Span::call_site()).to_string()
} else { } else {
field.ident.unwrap().to_string() field.ident.clone().unwrap().to_string()
}; };
let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site()); let visitor_label = Ident::new(&format!("__Visitor{}", label_name), Span::call_site());
@ -600,16 +602,16 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut sum, val| { .fold(TokenStream::empty(), |mut sum, val| {
sum.append_all(val); sum.append_all(val);
sum sum
}); });
let set_text: Tokens = data_struct let set_text: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
let label = field.ident; let label = &field.ident;
let field_attrs = YaSerdeAttribute::parse(&field.attrs); let field_attrs = YaSerdeAttribute::parse(&field.attrs);
match get_field_type(field) { match get_field_type(field) {
@ -669,16 +671,16 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
let struct_builder: Tokens = data_struct let struct_builder: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
let label = field.ident; let label = &field.ident;
if get_field_type(field).is_some() { if get_field_type(field).is_some() {
Some(quote!{ Some(quote!{
@ -690,7 +692,7 @@ pub fn parse(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
@ -755,9 +757,9 @@ pub fn parse(
fn build_default_value( fn build_default_value(
label: &Option<Ident>, label: &Option<Ident>,
field_type: &Tokens, field_type: &TokenStream,
default: &Tokens, default: &TokenStream,
) -> Option<Tokens> { ) -> Option<TokenStream> {
Some(quote!{ Some(quote!{
#[allow(unused_mut)] #[allow(unused_mut)]
let mut #label : #field_type = #default; let mut #label : #field_type = #default;
@ -765,10 +767,10 @@ fn build_default_value(
} }
fn build_declare_visitor( fn build_declare_visitor(
field_type: &Tokens, field_type: &TokenStream,
visitor: &Tokens, visitor: &TokenStream,
visitor_label: &Ident, visitor_label: &Ident,
) -> Option<Tokens> { ) -> Option<TokenStream> {
Some(quote!{ Some(quote!{
#[allow(non_snake_case, non_camel_case_types)] #[allow(non_snake_case, non_camel_case_types)]
struct #visitor_label; struct #visitor_label;
@ -783,13 +785,13 @@ fn build_declare_visitor(
} }
fn build_call_visitor( fn build_call_visitor(
field_type: &Tokens, field_type: &TokenStream,
visitor: &Ident, visitor: &Ident,
action: &Tokens, action: &TokenStream,
visitor_label: &Ident, visitor_label: &Ident,
label: &Option<Ident>, label: &Option<Ident>,
label_name: &str, label_name: &str,
) -> Option<Tokens> { ) -> Option<TokenStream> {
Some(quote!{ Some(quote!{
#label_name => { #label_name => {
let visitor = #visitor_label{}; let visitor = #visitor_label{};
@ -820,9 +822,9 @@ fn build_call_visitor(
fn build_call_visitor_for_attribute( fn build_call_visitor_for_attribute(
label: &Option<Ident>, label: &Option<Ident>,
label_name: &str, label_name: &str,
visitor: &Tokens, visitor: &TokenStream,
visitor_label: &Ident, visitor_label: &Ident,
) -> Option<Tokens> { ) -> Option<TokenStream> {
Some(quote!{ Some(quote!{
for attr in attributes { for attr in attributes {
if attr.name.local_name == #label_name { if attr.name.local_name == #label_name {
@ -839,8 +841,8 @@ fn build_call_visitor_for_attribute(
fn build_set_text_to_value( fn build_set_text_to_value(
field_attrs: &YaSerdeAttribute, field_attrs: &YaSerdeAttribute,
label: &Option<Ident>, label: &Option<Ident>,
action: &Tokens, action: &TokenStream,
) -> Option<Tokens> { ) -> Option<TokenStream> {
if field_attrs.text { if field_attrs.text {
Some(quote!{ Some(quote!{
#label = #action; #label = #action;

7
yaserde_derive/src/de/mod.rs
View File

@ -2,12 +2,11 @@ pub mod expand_enum;
pub mod expand_struct; pub mod expand_struct;
use attribute; use attribute;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
use quote;
use syn; use syn;
use syn::Ident; use syn::Ident;
pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<quote::Tokens, String> { pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<TokenStream, String> {
let name = &ast.ident; let name = &ast.ident;
let attrs = &ast.attrs; let attrs = &ast.attrs;
let data = &ast.data; let data = &ast.data;
@ -27,7 +26,7 @@ pub fn expand_derive_deserialize(ast: &syn::DeriveInput) -> Result<quote::Tokens
let dummy_const = Ident::new( let dummy_const = Ident::new(
&format!("_IMPL_YA_DESERIALIZE_FOR_{}", name), &format!("_IMPL_YA_DESERIALIZE_FOR_{}", name),
Span::def_site(), Span::call_site(),
); );
let generated = quote! { let generated = quote! {

6
yaserde_derive/src/field_type.rs
View File

@ -20,7 +20,7 @@ pub enum FieldType {
impl FieldType { impl FieldType {
fn from_ident(t: &syn::PathSegment) -> Option<FieldType> { fn from_ident(t: &syn::PathSegment) -> Option<FieldType> {
match t.ident.as_ref() { match t.ident.to_string().as_str() {
"String" => Some(FieldType::FieldTypeString), "String" => Some(FieldType::FieldTypeString),
"bool" => Some(FieldType::FieldTypeBool), "bool" => Some(FieldType::FieldTypeBool),
"i8" => Some(FieldType::FieldTypeI8), "i8" => Some(FieldType::FieldTypeI8),
@ -42,7 +42,7 @@ impl FieldType {
} }
}), }),
_struct_name => Some(FieldType::FieldTypeStruct { _struct_name => Some(FieldType::FieldTypeStruct {
struct_name: t.ident, struct_name: t.ident.clone(),
}), }),
} }
} }
@ -64,7 +64,7 @@ fn get_vec_type(t: &syn::PathSegment) -> Option<syn::Ident> {
if let syn::GenericArgument::Type(ref argument) = *tt { if let syn::GenericArgument::Type(ref argument) = *tt {
if let Path(ref path2) = *argument { if let Path(ref path2) = *argument {
if let Some(Pair::End(ttt)) = path2.path.segments.first() { if let Some(Pair::End(ttt)) = path2.path.segments.first() {
return Some(ttt.ident); return Some(ttt.ident.clone());
} }
} }
} }

24
yaserde_derive/src/ser/expand_enum.rs
View File

@ -1,28 +1,28 @@
use attribute::*; use attribute::*;
use field_type::*; use field_type::*;
use quote::Tokens; use quote::TokenStreamExt;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use syn::Fields; use syn::Fields;
use syn::Ident; use syn::Ident;
use syn::DataEnum; use syn::DataEnum;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
pub fn serialize( pub fn serialize(
data_enum: &DataEnum, data_enum: &DataEnum,
name: &Ident, name: &Ident,
root: &str, root: &str,
namespaces: &BTreeMap<String, String>, namespaces: &BTreeMap<String, String>,
) -> Tokens { ) -> TokenStream {
let write_enum_content: Tokens = data_enum let write_enum_content: TokenStream = data_enum
.variants .variants
.iter() .iter()
.map(|variant| { .map(|variant| {
let variant_attrs = YaSerdeAttribute::parse(&variant.attrs); let variant_attrs = YaSerdeAttribute::parse(&variant.attrs);
let renamed_label = match variant_attrs.rename { let renamed_label = match variant_attrs.rename {
Some(value) => Ident::new(&format!("{}", value), Span::call_site()), Some(value) => Ident::new(&format!("{}", value), Span::call_site()),
None => variant.ident, None => variant.ident.clone(),
}; };
let label = variant.ident; let label = &variant.ident;
let label_name = if let Some(prefix) = variant_attrs.prefix { let label_name = if let Some(prefix) = variant_attrs.prefix {
prefix + ":" + renamed_label.to_string().as_ref() prefix + ":" + renamed_label.to_string().as_ref()
} else { } else {
@ -46,7 +46,7 @@ pub fn serialize(
return None; return None;
} }
let field_label = field.ident; let field_label = &field.ident;
if field_attrs.text { if field_attrs.text {
return Some(quote!( return Some(quote!(
let data_event = XmlEvent::characters(&self.#field_label); let data_event = XmlEvent::characters(&self.#field_label);
@ -56,7 +56,7 @@ pub fn serialize(
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())), Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident, None => field.ident.clone(),
}; };
let field_label_name = renamed_field_label.unwrap().to_string(); let field_label_name = renamed_field_label.unwrap().to_string();
@ -116,7 +116,7 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
@ -138,12 +138,12 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
let add_namespaces: Tokens = namespaces let add_namespaces: TokenStream = namespaces
.iter() .iter()
.map(|(prefix, namespace)| { .map(|(prefix, namespace)| {
Some(quote!( Some(quote!(
@ -152,7 +152,7 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });

26
yaserde_derive/src/ser/expand_struct.rs
View File

@ -1,10 +1,10 @@
use attribute::*; use attribute::*;
use field_type::*; use field_type::*;
use quote::Tokens; use quote::TokenStreamExt;
use std::collections::BTreeMap; use std::collections::BTreeMap;
use syn::Ident; use syn::Ident;
use syn::DataStruct; use syn::DataStruct;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
use std::string::ToString; use std::string::ToString;
pub fn serialize( pub fn serialize(
@ -12,8 +12,8 @@ pub fn serialize(
name: &Ident, name: &Ident,
root: &str, root: &str,
namespaces: &BTreeMap<String, String>, namespaces: &BTreeMap<String, String>,
) -> Tokens { ) -> TokenStream {
let build_attributes: Tokens = data_struct let build_attributes: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
@ -24,9 +24,9 @@ pub fn serialize(
let renamed_label = match field_attrs.rename { let renamed_label = match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())), Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident, None => field.ident.clone(),
}; };
let label = field.ident; let label = &field.ident;
let label_name = if let Some(prefix) = field_attrs.prefix { let label_name = if let Some(prefix) = field_attrs.prefix {
prefix + ":" + renamed_label.unwrap().to_string().as_ref() prefix + ":" + renamed_label.unwrap().to_string().as_ref()
} else { } else {
@ -75,12 +75,12 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
let add_namespaces: Tokens = namespaces let add_namespaces: TokenStream = namespaces
.iter() .iter()
.map(|(prefix, namespace)| { .map(|(prefix, namespace)| {
Some(quote!( Some(quote!(
@ -89,12 +89,12 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });
let struct_inspector: Tokens = data_struct let struct_inspector: TokenStream = data_struct
.fields .fields
.iter() .iter()
.map(|field| { .map(|field| {
@ -103,7 +103,7 @@ pub fn serialize(
return None; return None;
} }
let label = field.ident; let label = &field.ident;
if field_attrs.text { if field_attrs.text {
return Some(quote!( return Some(quote!(
let data_event = XmlEvent::characters(&self.#label); let data_event = XmlEvent::characters(&self.#label);
@ -113,7 +113,7 @@ pub fn serialize(
let renamed_label = match field_attrs.rename { let renamed_label = match field_attrs.rename {
Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())), Some(value) => Some(Ident::new(&format!("{}", value), Span::call_site())),
None => field.ident, None => field.ident.clone(),
}; };
let label_name = if let Some(prefix) = field_attrs.prefix { let label_name = if let Some(prefix) = field_attrs.prefix {
@ -220,7 +220,7 @@ pub fn serialize(
}) })
.filter(|x| x.is_some()) .filter(|x| x.is_some())
.map(|x| x.unwrap()) .map(|x| x.unwrap())
.fold(Tokens::new(), |mut tokens, token| { .fold(TokenStream::empty(), |mut tokens, token| {
tokens.append_all(token); tokens.append_all(token);
tokens tokens
}); });

7
yaserde_derive/src/ser/mod.rs
View File

@ -2,12 +2,11 @@ pub mod expand_enum;
pub mod expand_struct; pub mod expand_struct;
use attribute; use attribute;
use proc_macro2::Span; use proc_macro2::{TokenStream, Span};
use quote;
use syn; use syn;
use syn::Ident; use syn::Ident;
pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<quote::Tokens, String> { pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<TokenStream, String> {
let name = &ast.ident; let name = &ast.ident;
let attrs = &ast.attrs; let attrs = &ast.attrs;
let data = &ast.data; let data = &ast.data;
@ -33,7 +32,7 @@ pub fn expand_derive_serialize(ast: &syn::DeriveInput) -> Result<quote::Tokens,
let dummy_const = Ident::new( let dummy_const = Ident::new(
&format!("_IMPL_YA_SERIALIZE_FOR_{}", name), &format!("_IMPL_YA_SERIALIZE_FOR_{}", name),
Span::def_site(), Span::call_site(),
); );
let generated = quote! { let generated = quote! {