tomlmenu_derive/

lib.rs

//! `Schema` derive — emits a static `MenuNode` tree describing the
//! annotated type's editable surface.
//!
//! Output paths resolve as `::tomlmenu::*`. The derive is therefore valid
//! in any crate whose dependency graph includes `tomlmenu`.
//!
//! Attribute vocabulary:
//!
//! * `#[tomlmenu(label = "...")]` — display name; optional, defaults to the
//!   serde-resolved field name.
//! * `#[tomlmenu(help = "...")]`  — help-pane text; optional, defaults to
//!   `"<no help>"`.
//! * `#[tomlmenu(skip)]`          — exclude from menu; serde behaviour
//!   unchanged.
//!
//! Field type classification:
//!
//! * `bool` / `Option<bool>` → `LeafKind::Bool`.
//! * Primitive unsigned int (u8..u64) or its `Option<...>` wrapper →
//!   `LeafKind::UInt { min: 0, max: T::MAX as u64 }`.
//! * `String` / `Option<String>` → `LeafKind::Text`.
//! * Enum-typed field → recurses into the enum's own `Schema` impl,
//!   yielding `LeafKind::Choice(&[variants...])` at emission.
//! * `Vec<...>` (outer) and `Option<Vec<...>>` (inner) → reject with
//!   `compile_error!` unless `#[tomlmenu(skip)]` is set.

use proc_macro::TokenStream;
use proc_macro2::TokenStream as TokenStream2;
use quote::quote;
use syn::{
    Attribute, Data, DataEnum, DataStruct, DeriveInput, Expr, ExprLit, Field, Fields,
    GenericArgument, Lit, LitStr, Meta, PathArguments, Type, TypePath, parse_macro_input,
    spanned::Spanned,
};

#[proc_macro_derive(Schema, attributes(tomlmenu))]
pub fn derive_schema(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    expand(&input)
        .unwrap_or_else(|err| err.to_compile_error())
        .into()
}

fn expand(input: &DeriveInput) -> syn::Result<TokenStream2> {
    let ty = &input.ident;
    let serde_rename_all = read_serde_rename_all(&input.attrs)?;

    match &input.data {
        Data::Struct(s) => expand_struct(s, ty, serde_rename_all.as_deref()),
        Data::Enum(e) => expand_enum(e, ty, serde_rename_all.as_deref()),
        Data::Union(u) => Err(syn::Error::new(
            u.union_token.span,
            "Schema cannot be derived on a union",
        )),
    }
}

fn expand_struct(
    s: &DataStruct,
    ty: &syn::Ident,
    _rename_all: Option<&str>,
) -> syn::Result<TokenStream2> {
    let Fields::Named(named) = &s.fields else {
        return Err(syn::Error::new(
            s.fields.span(),
            "Schema requires named struct fields",
        ));
    };

    let mut child_inits: Vec<TokenStream2> = Vec::new();
    for field in &named.named {
        let attrs = read_attrs(&field.attrs)?;
        if attrs.skip {
            continue;
        }

        let field_ident = field.ident.as_ref().expect("named field");
        let serde_field_key =
            read_serde_rename(&field.attrs)?.unwrap_or_else(|| field_ident.to_string());

        let leaf_classification = classify_leaf(&field.ty, &attrs, field)?;

        let label = attrs
            .label
            .clone()
            .unwrap_or_else(|| serde_field_key.clone());
        let help = attrs
            .help
            .clone()
            .unwrap_or_else(|| "<no help>".to_string());
        let key = serde_field_key;

        let body_tokens: TokenStream2 = match leaf_classification {
            LeafClass::Bool => quote! {
                ::tomlmenu::MenuBody::Leaf(
                    ::tomlmenu::LeafKind::Bool,
                )
            },
            LeafClass::UInt(uint_ty) => {
                let primitive: syn::Ident = syn::Ident::new(&uint_ty, field.ty.span());
                quote! {
                    ::tomlmenu::MenuBody::Leaf(
                        ::tomlmenu::LeafKind::UInt {
                            min: 0,
                            max: <#primitive>::MAX as u64,
                        },
                    )
                }
            }
            LeafClass::Text => quote! {
                ::tomlmenu::MenuBody::Leaf(
                    ::tomlmenu::LeafKind::Text,
                )
            },
            LeafClass::Nested(ty_tokens) => {
                quote! {
                    *<#ty_tokens as ::tomlmenu::Schema>::SCHEMA_BODY
                }
            }
        };

        child_inits.push(quote! {
            ::tomlmenu::MenuNode {
                label: #label,
                help: #help,
                key: #key,
                body: #body_tokens,
            }
        });
    }

    let children_static = syn::Ident::new(&format!("__TOMLMENU_SCHEMA_CHILDREN_{}", ty), ty.span());
    let body_static = syn::Ident::new(&format!("__TOMLMENU_SCHEMA_BODY_{}", ty), ty.span());

    Ok(quote! {
        #[allow(non_upper_case_globals)]
        static #children_static: &[::tomlmenu::MenuNode] = &[
            #(#child_inits,)*
        ];

        #[allow(non_upper_case_globals)]
        static #body_static: ::tomlmenu::MenuBody =
            ::tomlmenu::MenuBody::Section(#children_static);

        impl ::tomlmenu::Schema for #ty {
            const SCHEMA_BODY: &'static ::tomlmenu::MenuBody = &#body_static;

            fn menu_schema() -> ::tomlmenu::MenuNode {
                ::tomlmenu::MenuNode {
                    label: "",
                    help: "",
                    key: "",
                    body: ::tomlmenu::MenuBody::Section(#children_static),
                }
            }
        }
    })
}

fn expand_enum(
    e: &DataEnum,
    ty: &syn::Ident,
    rename_all: Option<&str>,
) -> syn::Result<TokenStream2> {
    let mut variant_names: Vec<String> = Vec::new();
    for v in &e.variants {
        if !matches!(v.fields, Fields::Unit) {
            return Err(syn::Error::new(
                v.span(),
                "Schema enum variants must be unit-style",
            ));
        }
        let variant_rename = read_serde_rename(&v.attrs)?;
        let resolved = match variant_rename {
            Some(name) => name,
            None => apply_rename_all(&v.ident.to_string(), rename_all),
        };
        variant_names.push(resolved);
    }

    let lit_names_for_variants: Vec<TokenStream2> =
        variant_names.iter().map(|n| quote! { #n }).collect();
    let lit_names_for_method: Vec<TokenStream2> =
        variant_names.iter().map(|n| quote! { #n }).collect();

    let variants_static = syn::Ident::new(&format!("__TOMLMENU_SCHEMA_VARIANTS_{}", ty), ty.span());
    let body_static = syn::Ident::new(&format!("__TOMLMENU_SCHEMA_BODY_{}", ty), ty.span());

    Ok(quote! {
        #[allow(non_upper_case_globals)]
        static #variants_static: &[&'static str] = &[
            #(#lit_names_for_variants,)*
        ];

        #[allow(non_upper_case_globals)]
        static #body_static: ::tomlmenu::MenuBody =
            ::tomlmenu::MenuBody::Leaf(
                ::tomlmenu::LeafKind::Choice(#variants_static),
            );

        impl ::tomlmenu::Schema for #ty {
            const SCHEMA_BODY: &'static ::tomlmenu::MenuBody = &#body_static;

            fn menu_schema() -> ::tomlmenu::MenuNode {
                ::tomlmenu::MenuNode {
                    label: "",
                    help: "",
                    key: "",
                    body: ::tomlmenu::MenuBody::Leaf(
                        ::tomlmenu::LeafKind::Choice(&[
                            #(#lit_names_for_method,)*
                        ]),
                    ),
                }
            }
        }
    })
}

#[derive(Default)]
struct TomlmenuAttrs {
    label: Option<String>,
    help: Option<String>,
    skip: bool,
}

fn read_attrs(attrs: &[Attribute]) -> syn::Result<TomlmenuAttrs> {
    let mut out = TomlmenuAttrs::default();
    for attr in attrs {
        if !attr.path().is_ident("tomlmenu") {
            continue;
        }
        attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("skip") {
                out.skip = true;
                return Ok(());
            }
            if meta.path.is_ident("label") {
                let value: LitStr = meta.value()?.parse()?;
                out.label = Some(value.value());
                return Ok(());
            }
            if meta.path.is_ident("help") {
                let value: LitStr = meta.value()?.parse()?;
                out.help = Some(value.value());
                return Ok(());
            }
            let ident = meta
                .path
                .get_ident()
                .map(|i| i.to_string())
                .unwrap_or_else(|| "<unknown>".to_string());
            Err(meta.error(format!("unknown #[tomlmenu(...)] key `{ident}`")))
        })?;
    }
    Ok(out)
}

fn read_serde_rename(attrs: &[Attribute]) -> syn::Result<Option<String>> {
    for attr in attrs {
        if !attr.path().is_ident("serde") {
            continue;
        }
        let mut found = None;
        let _ = attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("rename") {
                let value: LitStr = meta.value()?.parse()?;
                found = Some(value.value());
            }
            Ok(())
        });
        if found.is_some() {
            return Ok(found);
        }
    }
    Ok(None)
}

fn read_serde_rename_all(attrs: &[Attribute]) -> syn::Result<Option<String>> {
    for attr in attrs {
        if !attr.path().is_ident("serde") {
            continue;
        }
        let mut found = None;
        let _ = attr.parse_nested_meta(|meta| {
            if meta.path.is_ident("rename_all") {
                let value: LitStr = meta.value()?.parse()?;
                found = Some(value.value());
            }
            Ok(())
        });
        if found.is_some() {
            return Ok(found);
        }
        if let Meta::List(_) = &attr.meta {
            continue;
        }
        if let Meta::NameValue(nv) = &attr.meta
            && nv.path.is_ident("rename_all")
            && let Expr::Lit(ExprLit {
                lit: Lit::Str(s), ..
            }) = &nv.value
        {
            return Ok(Some(s.value()));
        }
    }
    Ok(None)
}

fn apply_rename_all(name: &str, rename_all: Option<&str>) -> String {
    match rename_all {
        Some("lowercase") => name.to_ascii_lowercase(),
        Some("UPPERCASE") => name.to_ascii_uppercase(),
        Some("snake_case") => camel_to_snake(name),
        Some("kebab-case") => camel_to_snake(name).replace('_', "-"),
        Some("SCREAMING_SNAKE_CASE") => camel_to_snake(name).to_ascii_uppercase(),
        _ => name.to_string(),
    }
}

fn camel_to_snake(name: &str) -> String {
    let mut out = String::with_capacity(name.len() + 4);
    for (i, ch) in name.chars().enumerate() {
        if ch.is_ascii_uppercase() {
            if i != 0 {
                out.push('_');
            }
            out.push(ch.to_ascii_lowercase());
        } else {
            out.push(ch);
        }
    }
    out
}

enum LeafClass {
    Bool,
    UInt(String),
    Text,
    Nested(TokenStream2),
}

fn classify_leaf(ty: &Type, attrs: &TomlmenuAttrs, field: &Field) -> syn::Result<LeafClass> {
    let (peeled, was_option) = match peel_option(ty) {
        Some(inner) => (inner, true),
        None => (ty, false),
    };

    if is_vec(peeled) {
        let span = if was_option { ty.span() } else { peeled.span() };
        return Err(syn::Error::new(
            span,
            "Schema: `Vec<...>` and `Option<Vec<...>>` fields must carry `#[tomlmenu(skip)]`",
        ));
    }
    let _ = attrs;
    let _ = field;

    if is_named_simple(peeled, "bool") {
        return Ok(LeafClass::Bool);
    }
    if let Some(uint_name) = match_uint_primitive(peeled) {
        return Ok(LeafClass::UInt(uint_name));
    }
    if is_named_simple(peeled, "String") {
        return Ok(LeafClass::Text);
    }
    let path = match peeled {
        Type::Path(TypePath { path, qself: None }) => path,
        _ => {
            return Err(syn::Error::new(
                peeled.span(),
                "Schema: unsupported field type",
            ));
        }
    };
    Ok(LeafClass::Nested(quote! { #path }))
}

fn peel_option(ty: &Type) -> Option<&Type> {
    let Type::Path(TypePath { path, qself: None }) = ty else {
        return None;
    };
    let seg = path.segments.last()?;
    if seg.ident != "Option" {
        return None;
    }
    let PathArguments::AngleBracketed(args) = &seg.arguments else {
        return None;
    };
    let arg = args.args.first()?;
    if let GenericArgument::Type(inner) = arg {
        Some(inner)
    } else {
        None
    }
}

fn is_vec(ty: &Type) -> bool {
    let Type::Path(TypePath { path, qself: None }) = ty else {
        return false;
    };
    path.segments
        .last()
        .map(|s| s.ident == "Vec")
        .unwrap_or(false)
}

fn is_named_simple(ty: &Type, name: &str) -> bool {
    let Type::Path(TypePath { path, qself: None }) = ty else {
        return false;
    };
    let Some(seg) = path.segments.last() else {
        return false;
    };
    seg.ident == name && matches!(seg.arguments, PathArguments::None)
}

fn match_uint_primitive(ty: &Type) -> Option<String> {
    const PRIMS: &[&str] = &["u8", "u16", "u32", "u64", "usize"];
    let Type::Path(TypePath { path, qself: None }) = ty else {
        return None;
    };
    let seg = path.segments.last()?;
    if !matches!(seg.arguments, PathArguments::None) {
        return None;
    }
    let name = seg.ident.to_string();
    PRIMS.iter().find(|p| **p == name).map(|s| s.to_string())
}

#[cfg(test)]
mod tests {
    use quote::quote;

    use super::*;

    fn parse(tokens: TokenStream2) -> DeriveInput {
        syn::parse2(tokens).expect("fixture parses as DeriveInput")
    }

    fn expand_ok(tokens: TokenStream2) -> String {
        expand(&parse(tokens))
            .expect("expand returns Ok for a valid input")
            .to_string()
    }

    fn expand_err(tokens: TokenStream2) -> String {
        match expand(&parse(tokens)) {
            Ok(_) => panic!("expected expand to error for this input"),
            Err(e) => e.to_string(),
        }
    }

    #[test]
    fn rejects_unknown_attribute_key() {
        let msg = expand_err(quote! {
            struct Bad {
                #[tomlmenu(bogus_key = "oops")]
                field: Option<bool>,
            }
        });
        assert!(
            msg.contains("unknown #[tomlmenu(...)] key `bogus_key`"),
            "unexpected error message: {msg}"
        );
    }

    #[test]
    fn rejects_bare_vec_field_without_skip() {
        let msg = expand_err(quote! {
            struct Bad {
                extras: Vec<String>,
            }
        });
        assert!(
            msg.contains("must carry `#[tomlmenu(skip)]`"),
            "unexpected error message: {msg}"
        );
    }

    #[test]
    fn rejects_option_vec_field_without_skip() {
        let msg = expand_err(quote! {
            struct Bad {
                extras: Option<Vec<String>>,
            }
        });
        assert!(
            msg.contains("must carry `#[tomlmenu(skip)]`"),
            "unexpected error message: {msg}"
        );
    }

    #[test]
    fn rejects_union() {
        let msg = expand_err(quote! {
            union Bad {
                a: u32,
                b: u64,
            }
        });
        assert!(msg.contains("union"), "unexpected error message: {msg}");
    }

    #[test]
    fn rejects_enum_with_non_unit_variant() {
        let msg = expand_err(quote! {
            enum Bad {
                Unit,
                Tuple(u32),
            }
        });
        assert!(
            msg.contains("unit-style"),
            "unexpected error message: {msg}"
        );
    }

    #[test]
    fn accepts_skipped_vec_field() {
        expand_ok(quote! {
            struct Ok {
                #[tomlmenu(skip)]
                extras: Vec<String>,
                name: Option<String>,
            }
        });
    }

    #[test]
    fn struct_expansion_targets_tomlmenu_path() {
        let out = expand_ok(quote! {
            struct Sample {
                name: Option<String>,
            }
        });
        assert!(
            out.contains(":: tomlmenu :: MenuNode"),
            "emitted path not absolute into tomlmenu: {out}"
        );
    }

    #[test]
    fn enum_expansion_lists_variants_in_choice() {
        let out = expand_ok(quote! {
            #[serde(rename_all = "lowercase")]
            enum Bus { Mmio, Pci }
        });
        assert!(out.contains("\"mmio\""), "missing mmio in: {out}");
        assert!(out.contains("\"pci\""), "missing pci in: {out}");
        assert!(out.contains("Choice"), "missing Choice variant: {out}");
    }

    #[test]
    fn struct_field_uses_serde_renamed_key() {
        let out = expand_ok(quote! {
            struct Sample {
                #[serde(rename = "kernel_base")]
                kernel_base: Option<String>,
            }
        });
        assert!(
            out.contains("\"kernel_base\""),
            "serde-renamed key not honoured: {out}"
        );
    }

    #[test]
    fn uint_field_emits_type_max_bound() {
        let out = expand_ok(quote! {
            struct Sample {
                port: Option<u16>,
            }
        });
        assert!(out.contains("u16"), "u16 primitive token missing: {out}");
        assert!(out.contains("MAX"), "MAX bound missing: {out}");
    }

    #[test]
    fn skipped_field_does_not_appear_in_output() {
        let out = expand_ok(quote! {
            struct Sample {
                #[tomlmenu(skip)]
                features: Option<Vec<String>>,
                name: Option<String>,
            }
        });
        assert!(
            !out.contains("\"features\""),
            "skipped field leaked into output: {out}"
        );
        assert!(out.contains("\"name\""), "non-skipped field missing: {out}");
    }
}