spark_signals_derive/

lib.rs

// ============================================================================
// spark-signals-derive
// Proc macro for deep reactivity via #[derive(Reactive)]
// ============================================================================

use proc_macro::TokenStream;
use quote::{quote, format_ident};
use syn::{parse_macro_input, DeriveInput, Data, Fields};

/// Derive macro for creating reactive versions of structs.
///
/// This generates a new struct with `Reactive` prefix where each field
/// is wrapped in a `Signal<T>`, enabling fine-grained reactivity.
///
/// # Example
///
/// ```ignore
/// use spark_signals::Reactive;
///
/// #[derive(Reactive)]
/// struct User {
///     name: String,
///     age: i32,
/// }
///
/// // Generated: ReactiveUser with Signal<String> and Signal<i32> fields
///
/// let user = ReactiveUser::new("Alice".to_string(), 30);
///
/// // Each field is a Signal - changes trigger effects!
/// effect(move || {
///     println!("Name: {}", user.name.get());
/// });
///
/// user.name.set("Bob".to_string()); // Effect re-runs!
/// ```
///
/// # What Gets Generated
///
/// For a struct like:
/// ```ignore
/// #[derive(Reactive)]
/// struct User {
///     name: String,
///     age: i32,
/// }
/// ```
///
/// The macro generates:
/// ```ignore
/// pub struct ReactiveUser {
///     pub name: Signal<String>,
///     pub age: Signal<i32>,
/// }
///
/// impl ReactiveUser {
///     pub fn new(name: String, age: i32) -> Self { ... }
///     pub fn from_user(user: User) -> Self { ... }
///     pub fn to_snapshot(&self) -> User { ... }
/// }
///
/// impl Clone for ReactiveUser { ... }
///
/// pub fn reactive_user(name: String, age: i32) -> ReactiveUser { ... }
/// ```
#[proc_macro_derive(Reactive)]
pub fn derive_reactive(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let name = &input.ident;
    let reactive_name = format_ident!("Reactive{}", name);
    let fn_name = format!("reactive_{}", to_snake_case(&name.to_string()));
    let fn_ident = format_ident!("{}", fn_name);

    // Only works on structs with named fields
    let fields = match &input.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(fields) => &fields.named,
            _ => {
                return syn::Error::new_spanned(
                    &input,
                    "Reactive can only be derived for structs with named fields",
                )
                .to_compile_error()
                .into();
            }
        },
        _ => {
            return syn::Error::new_spanned(
                &input,
                "Reactive can only be derived for structs",
            )
            .to_compile_error()
            .into();
        }
    };

    // Collect field info
    let field_names: Vec<_> = fields.iter().map(|f| &f.ident).collect();
    let field_types: Vec<_> = fields.iter().map(|f| &f.ty).collect();

    // Generate the reactive struct fields
    let reactive_fields = field_names.iter().zip(field_types.iter()).map(|(name, ty)| {
        quote! {
            pub #name: spark_signals::Signal<#ty>
        }
    });

    // Generate constructor arguments
    let constructor_args = field_names.iter().zip(field_types.iter()).map(|(name, ty)| {
        quote! { #name: #ty }
    });

    // Generate constructor body
    let constructor_body = field_names.iter().map(|name| {
        quote! { #name: spark_signals::signal(#name) }
    });

    // Generate from_original body
    let from_original_body = field_names.iter().map(|name| {
        quote! { #name: spark_signals::signal(original.#name) }
    });

    // Generate to_snapshot body
    let to_snapshot_body = field_names.iter().map(|name| {
        quote! { #name: self.#name.peek() }
    });

    // Generate clone body
    let clone_body = field_names.iter().map(|name| {
        quote! { #name: self.#name.clone() }
    });

    // Generate convenience function args (same as constructor)
    let fn_args = field_names.iter().zip(field_types.iter()).map(|(name, ty)| {
        quote! { #name: #ty }
    });

    // Generate convenience function call args
    let fn_call_args = field_names.iter().map(|name| {
        quote! { #name }
    });

    // Get generics from original struct
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    let expanded = quote! {
        /// Reactive version of #name with Signal-wrapped fields.
        ///
        /// Each field is a `Signal<T>` that can be read with `.get()` and
        /// written with `.set()`. Reading inside an effect automatically
        /// tracks that field as a dependency.
        pub struct #reactive_name #ty_generics #where_clause {
            #(#reactive_fields),*
        }

        impl #impl_generics #reactive_name #ty_generics #where_clause {
            /// Create a new reactive instance with the given values.
            pub fn new(#(#constructor_args),*) -> Self {
                Self {
                    #(#constructor_body),*
                }
            }

            /// Create a reactive instance from an existing non-reactive instance.
            pub fn from_original(original: #name #ty_generics) -> Self {
                Self {
                    #(#from_original_body),*
                }
            }

            /// Get a snapshot of the current values (using peek, no tracking).
            pub fn to_snapshot(&self) -> #name #ty_generics {
                #name {
                    #(#to_snapshot_body),*
                }
            }
        }

        impl #impl_generics Clone for #reactive_name #ty_generics #where_clause {
            fn clone(&self) -> Self {
                Self {
                    #(#clone_body),*
                }
            }
        }

        /// Create a new reactive #name.
        pub fn #fn_ident #impl_generics (#(#fn_args),*) -> #reactive_name #ty_generics #where_clause {
            #reactive_name::new(#(#fn_call_args),*)
        }
    };

    TokenStream::from(expanded)
}

/// Convert PascalCase to snake_case
fn to_snake_case(s: &str) -> String {
    let mut result = String::new();
    for (i, c) in s.chars().enumerate() {
        if c.is_uppercase() {
            if i > 0 {
                result.push('_');
            }
            result.push(c.to_lowercase().next().unwrap());
        } else {
            result.push(c);
        }
    }
    result
}