359 lines
17 KiB
Rust
359 lines
17 KiB
Rust
use proc_macro2::{Delimiter, Group, Span, TokenStream};
|
|
use quote::{quote, ToTokens, TokenStreamExt};
|
|
use syn::{parse_macro_input, Attribute, DeriveInput, Ident};
|
|
|
|
#[proc_macro_derive(CharacterSheet, attributes(Input, InputExpr, Field, FieldExpr, Seperator, Access, AccessSet))]
|
|
pub fn derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
|
|
let DeriveInput { ident, data, .. } = parse_macro_input!(input as DeriveInput);
|
|
let mut output = quote! {
|
|
impl CharacterSheet for #ident
|
|
};
|
|
|
|
// Create inputs impl
|
|
let mut impls = impl_inputs(&data);
|
|
impls.extend(impl_fields(&data));
|
|
impls.extend(impl_display(&data));
|
|
impls.extend(impl_get(&data));
|
|
impls.extend(impl_set(&data));
|
|
output.append(Group::new(Delimiter::Brace, impls));
|
|
|
|
|
|
output.into()
|
|
}
|
|
|
|
fn get_type_ident(ty: &syn::Type) -> Option<Ident> {
|
|
match ty {
|
|
syn::Type::Path(p) => {
|
|
if p.path.is_ident("String") {
|
|
Some(Ident::new("Text", Span::call_site()))
|
|
} else if p.path.is_ident("i32") {
|
|
Some(Ident::new("Number", Span::call_site()))
|
|
} else if p.path.is_ident("bool") {
|
|
Some(Ident::new("Bool", Span::call_site()))
|
|
} else { None }
|
|
}
|
|
_ => panic!("Invalid data type"),
|
|
}
|
|
}
|
|
fn get_type_ident_set(ty: &syn::Type) -> Option<Ident> {
|
|
match ty {
|
|
syn::Type::Path(p) => {
|
|
if p.path.is_ident("String") {
|
|
Some(Ident::new("as_text", Span::call_site()))
|
|
} else if p.path.is_ident("i32") {
|
|
Some(Ident::new("as_num", Span::call_site()))
|
|
} else if p.path.is_ident("bool") {
|
|
Some(Ident::new("as_bool", Span::call_site()))
|
|
} else { None }
|
|
}
|
|
_ => panic!("Invalid data type"),
|
|
}
|
|
}
|
|
fn get_access_level(attrs: &Vec<Attribute>, ident: &str) -> Ident {
|
|
attrs.iter()
|
|
.find(|a| a.path.is_ident(ident))
|
|
.map(|a| a.parse_args().unwrap_or(None))
|
|
.flatten()
|
|
.unwrap_or(Ident::new(&"Owner", Span::call_site()))
|
|
}
|
|
|
|
fn impl_inputs(data: &syn::Data) -> TokenStream {
|
|
let mut output = TokenStream::new();
|
|
output.extend(quote! {
|
|
fn inputs(&self, access: AccessLevel) -> Vec<(String, EntryType)>
|
|
});
|
|
let mut items = TokenStream::new();
|
|
let mut count = 0_usize;
|
|
if let syn::Data::Struct(ds) = data {
|
|
if let syn::Fields::Named(fs) = &ds.fields {
|
|
for f in &fs.named {
|
|
let name = f.ident.clone().unwrap();
|
|
let attr = f.attrs.iter().find(|a| a.path.is_ident("Input"));
|
|
if let Some(attr) = attr {
|
|
let arg: syn::LitStr = attr.parse_args().expect("No arguments supplied for Input attribute, usage: `Input(\"Name\")`");
|
|
let exp: Option<&syn::Attribute> = f.attrs.iter().find(|a| a.path.is_ident("InputExpr"));
|
|
let access = get_access_level(&f.attrs, "AccessSet");
|
|
count += 1;
|
|
if let Some(attr) = exp {
|
|
let exp: syn::Meta = attr.parse_meta().expect("Failed to parse MetaList!");
|
|
if let syn::Meta::List(l) = exp {
|
|
let from_input = &l.nested[1];
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
v.push((#arg.to_string(), self.#from_input()));
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
panic!("Failed parsing InputExpr attribute, expected `(&mut self, EntryType), (&self) -> EntryType`");
|
|
}
|
|
}
|
|
else {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for input: {}", name));
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
v.push((#arg.to_string(), EntryType::#t(self.#name.clone())));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let mut vec = quote! { let mut v = Vec::with_capacity(#count); };
|
|
vec.extend(items);
|
|
vec.extend(quote! { v });
|
|
output.append(Group::new(Delimiter::Brace, vec));
|
|
|
|
output
|
|
}
|
|
|
|
fn impl_fields(data: &syn::Data) -> TokenStream {
|
|
let mut output = TokenStream::new();
|
|
output.extend(quote! {
|
|
fn fields(&self) -> Vec<(String, EntryType)>
|
|
});
|
|
|
|
let mut items = TokenStream::new();
|
|
if let syn::Data::Struct(ds) = data {
|
|
if let syn::Fields::Named(fs) = &ds.fields {
|
|
for f in &fs.named {
|
|
let name = f.ident.clone().unwrap();
|
|
let input_attr = f.attrs.iter().find(|a| a.path.is_ident("Input"));
|
|
if let Some(attr) = input_attr {
|
|
let arg: syn::LitStr = attr.parse_args().expect("No arguments supplied for Input attribute, usage: `Input(\"Name\")`");
|
|
let exp = f.attrs.iter().find(|a| a.path.is_ident("InputExpr"));
|
|
if let Some(attr) = exp {
|
|
let exp: syn::Meta = attr.parse_meta().expect("Failed to parse MetaList!");
|
|
if let syn::Meta::List(l) = exp {
|
|
let from_input = &l.nested[1];
|
|
items.extend(quote! {
|
|
(#arg.to_string(), self.#from_input()),
|
|
})
|
|
}
|
|
else {
|
|
panic!("Failed parsing InputExpr attribute, expected `(&mut self, EntryType), (&self) -> EntryType`");
|
|
}
|
|
}
|
|
else {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for input: {}", name));
|
|
items.extend(quote! {
|
|
(#arg.to_string(), EntryType::#t(self.#name.clone())),
|
|
});
|
|
}
|
|
}
|
|
let field_attr = f.attrs.iter().find(|a| a.path.is_ident("Field"));
|
|
if let Some(attr) = field_attr {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for field: {}", name));
|
|
let arg: syn::LitStr = attr.parse_args().expect("Invalid arguments for Field attribute");
|
|
let field_expr = f.attrs.iter().find(|a| a.path.is_ident("FieldExpr"));
|
|
if let Some(exp) = field_expr {
|
|
let exp: syn::Expr = exp.parse_args().expect("Invalid expression");
|
|
items.extend(quote! {
|
|
(#arg.to_string(), EntryType::Number(#exp)),
|
|
})
|
|
}
|
|
else {
|
|
// No expression, guess we just push this and nothing special (should prob be an input but mehhh)
|
|
items.extend(quote! {
|
|
(#arg.to_string(), EntryType::#t(self.#name.clone())),
|
|
});
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let mut vec = quote! { Vec::from };
|
|
vec.append(Group::new(Delimiter::Parenthesis, Group::new(Delimiter::Bracket, items).to_token_stream()));
|
|
output.append(Group::new(Delimiter::Brace, vec));
|
|
|
|
output
|
|
}
|
|
|
|
fn impl_get(data: &syn::Data) -> TokenStream {
|
|
let mut output = TokenStream::new();
|
|
output.extend(quote! {
|
|
fn get(&self, entry: &str, access: AccessLevel) -> Option<EntryType>
|
|
});
|
|
let mut match_hands = TokenStream::new();
|
|
if let syn::Data::Struct(ds) = data {
|
|
if let syn::Fields::Named(fs) = &ds.fields {
|
|
for f in &fs.named {
|
|
let name = f.ident.clone().unwrap();
|
|
let access = get_access_level(&f.attrs, "Access");
|
|
let input_attr = f.attrs.iter().find(|a| a.path.is_ident("Input"));
|
|
if let Some(attr) = input_attr {
|
|
let arg: syn::LitStr = attr.parse_args().expect("No arguments supplied for Input attribute, usage: `Input(\"Name\")`");
|
|
let exp: Option<&syn::Attribute> = f.attrs.iter().find(|a| a.path.is_ident("InputExpr"));
|
|
if let Some(attr) = exp {
|
|
let exp: syn::Meta = attr.parse_meta().expect("Failed to parse MetaList!");
|
|
if let syn::Meta::List(l) = exp {
|
|
let from_input = &l.nested[1];
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { Some(self.#from_input()) } else { None },
|
|
});
|
|
}
|
|
else {
|
|
panic!("Failed parsing InputExpr attribute, expected `(&mut self, EntryType), (&self) -> EntryType`");
|
|
}
|
|
}
|
|
else {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for input: {}", name));
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { Some(EntryType::#t(self.#name.clone())) } else { None },
|
|
});
|
|
}
|
|
}
|
|
let field_attr = f.attrs.iter().find(|a| a.path.is_ident("Field"));
|
|
if let Some(attr) = field_attr {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for field: {}", name));
|
|
let arg: syn::LitStr = attr.parse_args().expect("Invalid arguments for Field attribute");
|
|
let field_expr = f.attrs.iter().find(|a| a.path.is_ident("FieldExpr"));
|
|
if let Some(exp) = field_expr {
|
|
let exp: syn::Expr = exp.parse_args().expect("Invalid expression");
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { Some(EntryType::Number(#exp)) } else { None },
|
|
})
|
|
}
|
|
else {
|
|
// No expression, guess we just push this and nothing special (should prob be an input but mehhh)
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { Some(EntryType::#t(self.#name.clone())) } else { None },
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
match_hands.extend(quote! { _ => None, });
|
|
let mut vec = quote! { match(entry) };
|
|
vec.append(Group::new(Delimiter::Brace, match_hands));
|
|
output.append(Group::new(Delimiter::Brace, vec));
|
|
|
|
output
|
|
}
|
|
|
|
fn impl_set(data: &syn::Data) -> TokenStream {
|
|
let mut output = TokenStream::new();
|
|
output.extend(quote! {
|
|
fn set(&mut self, entry: &str, value: EntryType, access: AccessLevel)
|
|
});
|
|
|
|
let mut match_hands = TokenStream::new();
|
|
if let syn::Data::Struct(ds) = data {
|
|
if let syn::Fields::Named(fs) = &ds.fields {
|
|
for f in &fs.named {
|
|
let name = f.ident.clone().unwrap();
|
|
let input_attr = f.attrs.iter().find(|a| a.path.is_ident("Input"));
|
|
let access = get_access_level(&f.attrs, "AccessSet");
|
|
if let Some(attr) = input_attr {
|
|
let arg: syn::LitStr = attr.parse_args().expect("No arguments supplied for Input attribute, usage: `Input(\"Name\")`");
|
|
let exp = f.attrs.iter().find(|a| a.path.is_ident("InputExpr"));
|
|
if let Some(attr) = exp {
|
|
let exp: syn::Meta = attr.parse_meta().expect("Failed to parse MetaList!");
|
|
if let syn::Meta::List(l) = exp {
|
|
let to_input = &l.nested[0];
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { self.#to_input(value) },
|
|
});
|
|
}
|
|
else {
|
|
panic!("Failed parsing InputExpr attribute, expected `(&mut self, EntryType), (&self) -> EntryType`");
|
|
}
|
|
}
|
|
else {
|
|
let t = get_type_ident_set(&f.ty).expect(&format!("Invalid type for input: {}", name));
|
|
match_hands.extend(quote! {
|
|
#arg => if AccessLevel::#access.has_access(access) { self.#name = value.#t() },
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
match_hands.extend(quote! { _ => {} });
|
|
let mut vec = quote! { match(entry) };
|
|
vec.append(Group::new(Delimiter::Brace, match_hands));
|
|
output.append(Group::new(Delimiter::Brace, vec));
|
|
|
|
output
|
|
}
|
|
|
|
fn impl_display(data: &syn::Data) -> TokenStream {
|
|
let mut output = TokenStream::new();
|
|
output.extend(quote! {
|
|
fn display(&self, access: AccessLevel) -> Vec<Option<(String, EntryType)>>
|
|
});
|
|
|
|
let mut items = TokenStream::new();
|
|
let mut count = 0_usize;
|
|
if let syn::Data::Struct(ds) = data {
|
|
if let syn::Fields::Named(fs) = &ds.fields {
|
|
for f in &fs.named {
|
|
let name = f.ident.clone().unwrap();
|
|
if f.attrs.iter().any(|a| a.path.is_ident("Seperator")) {
|
|
items.extend(quote! { v.push(None); })
|
|
}
|
|
let access = get_access_level(&f.attrs, "Access");
|
|
count += 1;
|
|
let input_attr = f.attrs.iter().find(|a| a.path.is_ident("Input"));
|
|
if let Some(attr) = input_attr {
|
|
let arg: syn::LitStr = attr.parse_args().expect("No arguments supplied for Input attribute, usage: `Input(\"Name\")`");
|
|
let exp = f.attrs.iter().find(|a| a.path.is_ident("InputExpr"));
|
|
if let Some(attr) = exp {
|
|
let exp: syn::Meta = attr.parse_meta().expect("Failed to parse MetaList!");
|
|
if let syn::Meta::List(l) = exp {
|
|
let from_input = &l.nested[1];
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
v.push(Some((#arg.to_string(), self.#from_input())));
|
|
}
|
|
})
|
|
}
|
|
else {
|
|
panic!("Failed parsing InputExpr attribute, expected `(&mut self, EntryType), (&self) -> EntryType`");
|
|
}
|
|
}
|
|
else {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for input: {}", name));
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
Some((#arg.to_string(), EntryType::#t(self.#name.clone())));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
let field_attr = f.attrs.iter().find(|a| a.path.is_ident("Field"));
|
|
if let Some(attr) = field_attr {
|
|
let t = get_type_ident(&f.ty).expect(&format!("Invalid type for field: {}", name));
|
|
let arg: syn::LitStr = attr.parse_args().expect("Invalid arguments for Field attribute");
|
|
let field_expr = f.attrs.iter().find(|a| a.path.is_ident("FieldExpr"));
|
|
if let Some(exp) = field_expr {
|
|
let exp: syn::Expr = exp.parse_args().expect("Invalid expression");
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
Some((#arg.to_string(), EntryType::Number(#exp)));
|
|
}
|
|
})
|
|
}
|
|
else {
|
|
// No expression, guess we just push this and nothing special (should prob be an input but mehhh)
|
|
items.extend(quote! {
|
|
if AccessLevel::#access.has_access(access) {
|
|
Some((#arg.to_string(), EntryType::#t(self.#name.clone())));
|
|
}
|
|
});
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let mut vec = quote! { let mut v = Vec::with_capacity(#count); };
|
|
vec.extend( items);
|
|
vec.extend(quote! { v });
|
|
output.append(Group::new(Delimiter::Brace, vec));
|
|
|
|
output
|
|
}
|