typst_template_derive/
lib.rs1#![forbid(unsafe_code)]
10
11use darling::ast::Data;
12use darling::util::Ignored;
13use darling::{FromDeriveInput, FromField, FromMeta};
14use proc_macro::TokenStream;
15use quote::quote;
16use syn::{DeriveInput, Generics, Ident, Path, Type, parse_macro_input, parse_quote};
17
18#[proc_macro_derive(ToDict, attributes(typst))]
43pub fn derive_into_dict(input: TokenStream) -> TokenStream {
44 let parsed = parse_macro_input!(input as DeriveInput);
45 match ToDictInput::from_derive_input(&parsed) {
46 Ok(receiver) => receiver.expand().into(),
47 Err(err) => err.write_errors().into(),
48 }
49}
50
51#[derive(FromDeriveInput)]
52#[darling(attributes(typst), supports(struct_named))]
53struct ToDictInput {
54 ident: Ident,
55 generics: Generics,
56 data: Data<Ignored, ToDictField>,
57 #[darling(default)]
58 rename_all: Option<RenameRule>,
59}
60
61#[derive(FromField)]
62#[darling(attributes(typst))]
63struct ToDictField {
64 ident: Option<Ident>,
65 ty: Type,
66 #[darling(default)]
67 rename: Option<String>,
68 #[darling(default)]
69 skip: bool,
70 #[darling(default)]
71 with: Option<Path>,
72 #[darling(default)]
73 flatten: bool,
74}
75
76impl ToDictInput {
77 fn expand(&self) -> proc_macro2::TokenStream {
78 let ident = &self.ident;
79 let data = self
80 .data
81 .as_ref()
82 .take_struct()
83 .expect("supports(struct_named)");
84 let fields: Vec<&ToDictField> = data.fields.into_iter().filter(|f| !f.skip).collect();
85
86 let inserts = fields.iter().map(|f| {
89 let field = f.ident.as_ref().expect("named struct field");
90 if f.flatten {
91 return quote! {
92 ::typst_template::__private::merge_dict(
93 &mut __dict,
94 ::typst_template::ToDict::into_dict(self.#field),
95 );
96 };
97 }
98 let key = self.key_for(f, field);
99 let value = match &f.with {
100 Some(path) => quote!(#path(self.#field)),
101 None => quote!(::typst_template::ToValue::into_value(self.#field)),
102 };
103 quote!(__dict.insert(::typst_template::Str::from(#key), #value);)
104 });
105
106 let mut generics = self.generics.clone();
109 let where_clause = generics.make_where_clause();
110 for f in &fields {
111 let ty = &f.ty;
112 if f.flatten {
113 where_clause
114 .predicates
115 .push(parse_quote!(#ty: ::typst_template::ToDict));
116 } else if f.with.is_none() {
117 where_clause
118 .predicates
119 .push(parse_quote!(#ty: ::typst_template::ToValue));
120 }
121 }
122 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
123
124 quote! {
125 impl #impl_generics ::typst_template::ToDict for #ident #ty_generics #where_clause {
126 fn into_dict(self) -> ::typst_template::Dict {
127 let mut __dict = ::typst_template::Dict::new();
128 #(#inserts)*
129 __dict
130 }
131 }
132
133 impl #impl_generics ::typst_template::ToValue for #ident #ty_generics #where_clause {
134 fn into_value(self) -> ::typst_template::Value {
135 ::typst_template::Value::Dict(::typst_template::ToDict::into_dict(self))
136 }
137 }
138 }
139 }
140
141 fn key_for(&self, field: &ToDictField, ident: &Ident) -> String {
144 if let Some(name) = &field.rename {
145 return name.clone();
146 }
147 let raw = ident.to_string();
148 let name = raw.strip_prefix("r#").unwrap_or(&raw);
149 match self.rename_all {
150 Some(rule) => rule.apply(name),
151 None => name.to_owned(),
152 }
153 }
154}
155
156#[derive(Clone, Copy)]
158enum RenameRule {
159 Lower,
160 Upper,
161 Pascal,
162 Camel,
163 Snake,
164 ScreamingSnake,
165 Kebab,
166 ScreamingKebab,
167}
168
169impl FromMeta for RenameRule {
170 fn from_string(value: &str) -> darling::Result<Self> {
171 Ok(match value {
172 "lowercase" => Self::Lower,
173 "UPPERCASE" => Self::Upper,
174 "PascalCase" => Self::Pascal,
175 "camelCase" => Self::Camel,
176 "snake_case" => Self::Snake,
177 "SCREAMING_SNAKE_CASE" => Self::ScreamingSnake,
178 "kebab-case" => Self::Kebab,
179 "SCREAMING-KEBAB-CASE" => Self::ScreamingKebab,
180 other => return Err(darling::Error::unknown_value(other)),
181 })
182 }
183}
184
185impl RenameRule {
186 fn apply(self, field: &str) -> String {
188 let words: Vec<&str> = field.split('_').filter(|w| !w.is_empty()).collect();
189 match self {
190 Self::Snake => field.to_owned(),
191 Self::Lower => words.concat(),
192 Self::Upper => words.concat().to_uppercase(),
193 Self::ScreamingSnake => join(&words, "_", str::to_uppercase),
194 Self::Kebab => words.join("-"),
195 Self::ScreamingKebab => join(&words, "-", str::to_uppercase),
196 Self::Pascal => words.iter().map(|w| capitalize(w)).collect(),
197 Self::Camel => {
198 let mut out = String::new();
199 for (i, word) in words.iter().enumerate() {
200 if i == 0 {
201 out.push_str(word);
202 } else {
203 out.push_str(&capitalize(word));
204 }
205 }
206 out
207 }
208 }
209 }
210}
211
212fn join(words: &[&str], sep: &str, map: fn(&str) -> String) -> String {
213 words.iter().map(|w| map(w)).collect::<Vec<_>>().join(sep)
214}
215
216fn capitalize(word: &str) -> String {
217 let mut chars = word.chars();
218 match chars.next() {
219 Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
220 None => String::new(),
221 }
222}