1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
use darling::FromField;
use proc_macro2::Span;
use quote::quote;
use syn::{self, parse_macro_input};
#[derive(Debug, FromField)]
#[darling(attributes(setter))]
pub struct SetterField {
ident: Option<syn::Ident>,
#[darling(default)]
skip: bool,
#[darling(default)]
/// name for the variable
/// mainly to show up in the docs
/// by default using the last word of the name
var_name: Option<syn::Ident>,
}
impl SetterField {
pub fn parse(input: &syn::DeriveInput) -> Vec<SetterField> {
match &input.data {
syn::Data::Struct(data) => match &data.fields {
syn::Fields::Named(fields) => fields
.named
.iter()
.map(|field| {
SetterField::from_field(field).expect("Could not parse setter field")
})
.collect(),
_ => panic!("setter: not a named field"),
},
_ => panic!("setter: not a Struct"),
}
}
}
pub fn setters(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input = parse_macro_input!(input as syn::DeriveInput);
let setter_fields = SetterField::parse(&input);
let quassel_fields = super::QuasselField::parse(&input);
let generated: Vec<proc_macro2::TokenStream> = setter_fields
.iter()
.zip(quassel_fields)
.filter(|(setter_field, _)| !setter_field.skip)
.map(|(setter_field, quassel_field)| {
let raw_name = if let Some(name) = &quassel_field.name {
name.clone()
} else {
setter_field.ident.as_ref().unwrap().to_string()
};
let name: String = {
let mut name = raw_name.chars();
format!(
"set{}{}",
name.next().unwrap().to_ascii_uppercase(),
name.as_str()
)
};
let var_name = syn::Ident::new(
&setter_field
.var_name
.as_ref()
.map(|v| v.to_string())
.unwrap_or({
let mut res = String::new();
for c in raw_name.chars().rev() {
if c <= 'Z' && c >= 'A' {
res.push(c.to_ascii_lowercase());
break;
} else {
res.push(c);
}
}
res.chars().rev().collect()
}),
Span::call_site(),
);
let ident = quassel_field
.ident
.as_ref()
.expect("failed to get quassel field ident");
let ty = &quassel_field.ty;
let fn_name = syn::Ident::new(&format!("set_{}", ident), Span::call_site());
quote! {
pub fn #fn_name(&mut self, #var_name: #ty) {
#[cfg(feature = "server")]
self.send_sync(#name, vec![#var_name.clone().into()]);
self.#ident = #var_name;
}
}
})
.collect();
let struct_name = &input.ident;
let gen = quote! {
impl #struct_name {
#(#generated)*
}
};
return gen.into();
}
|
