#![forbid(unsafe_code)]
use darling::ast::Data;
use darling::util::Ignored;
use darling::{FromDeriveInput, FromField, FromMeta};
use proc_macro::TokenStream;
use quote::quote;
use syn::{DeriveInput, Generics, Ident, Path, Type, parse_macro_input, parse_quote};
#[proc_macro_derive(ToDict, attributes(typst))]
pub fn derive_into_dict(input: TokenStream) -> TokenStream {
let parsed = parse_macro_input!(input as DeriveInput);
match ToDictInput::from_derive_input(&parsed) {
Ok(receiver) => receiver.expand().into(),
Err(err) => err.write_errors().into(),
}
}
#[derive(FromDeriveInput)]
#[darling(attributes(typst), supports(struct_named))]
struct ToDictInput {
ident: Ident,
generics: Generics,
data: Data<Ignored, ToDictField>,
#[darling(default)]
rename_all: Option<RenameRule>,
}
#[derive(FromField)]
#[darling(attributes(typst))]
struct ToDictField {
ident: Option<Ident>,
ty: Type,
#[darling(default)]
rename: Option<String>,
#[darling(default)]
skip: bool,
#[darling(default)]
with: Option<Path>,
#[darling(default)]
flatten: bool,
}
impl ToDictInput {
fn expand(&self) -> proc_macro2::TokenStream {
let ident = &self.ident;
let data = self
.data
.as_ref()
.take_struct()
.expect("supports(struct_named)");
let fields: Vec<&ToDictField> = data.fields.into_iter().filter(|f| !f.skip).collect();
let inserts = fields.iter().map(|f| {
let field = f.ident.as_ref().expect("named struct field");
if f.flatten {
return quote! {
::typst_template::__private::merge_dict(
&mut __dict,
::typst_template::ToDict::into_dict(self.#field),
);
};
}
let key = self.key_for(f, field);
let value = match &f.with {
Some(path) => quote!(#path(self.#field)),
None => quote!(::typst_template::ToValue::into_value(self.#field)),
};
quote!(__dict.insert(::typst_template::Str::from(#key), #value);)
});
let mut generics = self.generics.clone();
let where_clause = generics.make_where_clause();
for f in &fields {
let ty = &f.ty;
if f.flatten {
where_clause
.predicates
.push(parse_quote!(#ty: ::typst_template::ToDict));
} else if f.with.is_none() {
where_clause
.predicates
.push(parse_quote!(#ty: ::typst_template::ToValue));
}
}
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
quote! {
impl #impl_generics ::typst_template::ToDict for #ident #ty_generics #where_clause {
fn into_dict(self) -> ::typst_template::Dict {
let mut __dict = ::typst_template::Dict::new();
#(#inserts)*
__dict
}
}
impl #impl_generics ::typst_template::ToValue for #ident #ty_generics #where_clause {
fn into_value(self) -> ::typst_template::Value {
::typst_template::Value::Dict(::typst_template::ToDict::into_dict(self))
}
}
}
}
fn key_for(&self, field: &ToDictField, ident: &Ident) -> String {
if let Some(name) = &field.rename {
return name.clone();
}
let raw = ident.to_string();
let name = raw.strip_prefix("r#").unwrap_or(&raw);
match self.rename_all {
Some(rule) => rule.apply(name),
None => name.to_owned(),
}
}
}
#[derive(Clone, Copy)]
enum RenameRule {
Lower,
Upper,
Pascal,
Camel,
Snake,
ScreamingSnake,
Kebab,
ScreamingKebab,
}
impl FromMeta for RenameRule {
fn from_string(value: &str) -> darling::Result<Self> {
Ok(match value {
"lowercase" => Self::Lower,
"UPPERCASE" => Self::Upper,
"PascalCase" => Self::Pascal,
"camelCase" => Self::Camel,
"snake_case" => Self::Snake,
"SCREAMING_SNAKE_CASE" => Self::ScreamingSnake,
"kebab-case" => Self::Kebab,
"SCREAMING-KEBAB-CASE" => Self::ScreamingKebab,
other => return Err(darling::Error::unknown_value(other)),
})
}
}
impl RenameRule {
fn apply(self, field: &str) -> String {
let words: Vec<&str> = field.split('_').filter(|w| !w.is_empty()).collect();
match self {
Self::Snake => field.to_owned(),
Self::Lower => words.concat(),
Self::Upper => words.concat().to_uppercase(),
Self::ScreamingSnake => join(&words, "_", str::to_uppercase),
Self::Kebab => words.join("-"),
Self::ScreamingKebab => join(&words, "-", str::to_uppercase),
Self::Pascal => words.iter().map(|w| capitalize(w)).collect(),
Self::Camel => {
let mut out = String::new();
for (i, word) in words.iter().enumerate() {
if i == 0 {
out.push_str(word);
} else {
out.push_str(&capitalize(word));
}
}
out
}
}
}
}
fn join(words: &[&str], sep: &str, map: fn(&str) -> String) -> String {
words.iter().map(|w| map(w)).collect::<Vec<_>>().join(sep)
}
fn capitalize(word: &str) -> String {
let mut chars = word.chars();
match chars.next() {
Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
None => String::new(),
}
}