fac9ee5f86
This PR adds the `ui_macros` crate to allow building supporting macros
for the `ui` crate.
Additionally, it implements the `DerivePathStr` derive macro and the
`path_str` attribute macro. These macros work together to generate a
`path` method for enum variants, which is useful for creating
standardized string representations of enum variants.
The `DerivePathStr` macro provides the following functionality:
- Generates a `path` method for each enum variant.
- Allows specifying a prefix (required) and suffix (optional) for all
paths.
- Supports `strum` attributes for case conversion (e.g., snake_case,
lowercase).
Usage example:
```rust
#[derive(DerivePathStr)]
#[path_str(prefix = "my_prefix", suffix = ".txt")]
#[strum(serialize_all = "snake_case")]
enum MyEnum {
VariantOne,
VariantTwo,
}
// Generated paths:
// MyEnum::VariantOne.path() -> "my_prefix/variant_one.txt"
// MyEnum::VariantTwo.path() -> "my_prefix/variant_two.txt"
```
In a later PR this will be used to automate the creation of icon & image
paths in the `ui` crate.
This gives the following benefits:
1. Ensures standard naming of assets as paths are not manually
specified.
2. Makes adding new enum variants less tedious and error-prone.
3. Quickly catches missing or incorrect paths during compilation.
3. Adds a building block towards being able to lint for unused assets in
the future.
Release Notes:
- N/A
105 lines
3.5 KiB
Rust
105 lines
3.5 KiB
Rust
use convert_case::{Case, Casing};
|
|
use proc_macro::TokenStream;
|
|
use quote::quote;
|
|
use syn::{parse_macro_input, Attribute, Data, DeriveInput, Lit, Meta, NestedMeta};
|
|
|
|
pub fn derive_path_str(input: TokenStream) -> TokenStream {
|
|
let input = parse_macro_input!(input as DeriveInput);
|
|
let name = &input.ident;
|
|
|
|
let prefix = get_attr_value(&input.attrs, "prefix").expect("prefix attribute is required");
|
|
let suffix = get_attr_value(&input.attrs, "suffix").unwrap_or_else(|| "".to_string());
|
|
|
|
let serialize_all = get_strum_serialize_all(&input.attrs);
|
|
let path_str_impl = impl_path_str(name, &input.data, &prefix, &suffix, serialize_all);
|
|
|
|
let expanded = quote! {
|
|
impl #name {
|
|
pub fn path(&self) -> &'static str {
|
|
#path_str_impl
|
|
}
|
|
}
|
|
};
|
|
|
|
TokenStream::from(expanded)
|
|
}
|
|
|
|
fn impl_path_str(
|
|
name: &syn::Ident,
|
|
data: &Data,
|
|
prefix: &str,
|
|
suffix: &str,
|
|
serialize_all: Option<String>,
|
|
) -> proc_macro2::TokenStream {
|
|
match *data {
|
|
Data::Enum(ref data) => {
|
|
let match_arms = data.variants.iter().map(|variant| {
|
|
let ident = &variant.ident;
|
|
let variant_name = if let Some(ref case) = serialize_all {
|
|
match case.as_str() {
|
|
"snake_case" => ident.to_string().to_case(Case::Snake),
|
|
"lowercase" => ident.to_string().to_lowercase(),
|
|
_ => ident.to_string(),
|
|
}
|
|
} else {
|
|
ident.to_string()
|
|
};
|
|
let path = format!("{}/{}{}", prefix, variant_name, suffix);
|
|
quote! {
|
|
#name::#ident => #path,
|
|
}
|
|
});
|
|
|
|
quote! {
|
|
match self {
|
|
#(#match_arms)*
|
|
}
|
|
}
|
|
}
|
|
_ => panic!("DerivePathStr only supports enums"),
|
|
}
|
|
}
|
|
|
|
fn get_strum_serialize_all(attrs: &[Attribute]) -> Option<String> {
|
|
attrs
|
|
.iter()
|
|
.filter(|attr| attr.path.is_ident("strum"))
|
|
.find_map(|attr| {
|
|
if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
|
|
meta_list.nested.iter().find_map(|nested_meta| {
|
|
if let NestedMeta::Meta(Meta::NameValue(name_value)) = nested_meta {
|
|
if name_value.path.is_ident("serialize_all") {
|
|
if let Lit::Str(lit_str) = &name_value.lit {
|
|
return Some(lit_str.value());
|
|
}
|
|
}
|
|
}
|
|
None
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|
|
|
|
fn get_attr_value(attrs: &[Attribute], key: &str) -> Option<String> {
|
|
attrs
|
|
.iter()
|
|
.filter(|attr| attr.path.is_ident("path_str"))
|
|
.find_map(|attr| {
|
|
if let Ok(Meta::List(meta_list)) = attr.parse_meta() {
|
|
meta_list.nested.iter().find_map(|nested_meta| {
|
|
if let NestedMeta::Meta(Meta::NameValue(name_value)) = nested_meta {
|
|
if name_value.path.is_ident(key) {
|
|
if let Lit::Str(lit_str) = &name_value.lit {
|
|
return Some(lit_str.value());
|
|
}
|
|
}
|
|
}
|
|
None
|
|
})
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
}
|