entid-derive 0.4.3

Derive macros for the entid crate
Documentation 
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

/* Copyright © 2025, CosmicMind, Inc. */

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput, Expr, Lit};

/// Attribute for setting the prefix for an entity
#[proc_macro_attribute]
pub fn prefix(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // This is just a marker attribute, so we return the item unchanged
    item
}

/// Attribute for setting the delimiter for an entity
#[proc_macro_attribute]
pub fn delimiter(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // This is just a marker attribute, so we return the item unchanged
    item
}

/// Derive macro for implementing the `Prefix` trait
///
/// # Attributes
///
/// - `#[entid(prefix = "...")]` - Sets the prefix for the entity (required)
/// - `#[entid(delimiter = "...")]` - Sets the delimiter for the entity (optional, defaults to "_")
///
/// # Example
///
/// ```rust
/// use entid::Prefix;
///
/// #[derive(Prefix)]
/// #[entid(prefix = "user", delimiter = "_")]
/// struct User;
///
/// #[derive(Prefix)]
/// #[entid(prefix = "post", delimiter = "-")]
/// struct Post;
///
/// // The delimiter is optional and defaults to "_"
/// #[derive(Prefix)]
/// #[entid(prefix = "comment")]
/// struct Comment;
/// ```
#[proc_macro_derive(Prefix, attributes(entid))]
pub fn derive_prefix(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = &input.ident;

    // Default values
    let mut prefix = format!("{}_", name).to_lowercase();
    let mut delimiter = String::from("_");

    // Parse attributes
    for attr in &input.attrs {
        if attr.path().is_ident("entid") {
            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("prefix") {
                    let value = meta.value()?;
                    let expr: Expr = value.parse()?;
                    if let Expr::Lit(expr_lit) = expr {
                        if let Lit::Str(lit_str) = expr_lit.lit {
                            prefix = lit_str.value();
                        }
                    }
                } else if meta.path.is_ident("delimiter") {
                    let value = meta.value()?;
                    let expr: Expr = value.parse()?;
                    if let Expr::Lit(expr_lit) = expr {
                        if let Lit::Str(lit_str) = expr_lit.lit {
                            delimiter = lit_str.value();
                        }
                    }
                }
                Ok(())
            })
            .ok();
        }
    }

    let gen = quote! {
        impl entid::Prefix for #name {
            fn prefix() -> &'static str {
                #prefix
            }

            fn delimiter() -> &'static str {
                #delimiter
            }
        }
    };

    gen.into()
}