tree-type-proc-macro 0.4.5

//! Procedural macro for defining type-safe directory trees

use proc_macro::TokenStream;
use syn::parse_macro_input;

mod codegen;
mod core;
mod parser;
mod simple;
mod validation;

use crate::core::TreeDef;

/// Procedural macro for defining type-safe directory trees.
///
/// # Syntax
///
/// ```ignore
/// tree_type! {
///     RootName => {
///         file_name,
///         file_with_custom("custom.txt"),
///         dir_name/ => {
///             nested_file
///         },
///         [id: String] => DynamicDir => {
///             content
///         }
///     }
/// }
/// ```
///
/// # Attributes
///
/// - `#[required]` - Path must exist during validation
/// - `#[optional]` - Path is optional (default behavior)
/// - `#[default]` - Create with default content
/// - `#[validate(fn)]` - Custom validation function
/// - `#[pattern(regex)]` - Regex validation (requires `pattern-validation` feature)
/// - `#[symlink(target)]` - Create symlink to target
///
/// # Note
///
/// This macro generates code that references types from the `tree-type` crate.
/// Make sure to add both crates as dependencies:
///
/// ```toml
/// [dependencies]
/// tree-type = "0.1"
/// tree-type-proc-macro = "0.1"
/// ```
#[proc_macro]
pub fn tree_type(input: TokenStream) -> TokenStream {
    let tree_def = parse_macro_input!(input as TreeDef);

    // Validate the tree structure
    if let Err(err) = validation::validate_tree(&tree_def) {
        return TokenStream::from(err.to_compile_error());
    }

    // Generate code
    let expanded = codegen::generate_code(&tree_def);
    TokenStream::from(expanded)
}

/// Procedural macro for creating a simple file type.
///
/// Creates a type representing a single file with standard file operations.
/// Automatically includes serde derives when the serde feature is enabled.
///
/// # Example
///
/// ```ignore
/// file_type!(ConfigFile);
///
/// let config = ConfigFile::new("/etc/app/config.toml");
/// let contents = config.read_to_string()?;
/// ```
#[proc_macro]
pub fn file_type(input: TokenStream) -> TokenStream {
    let name = parse_macro_input!(input as syn::Ident);
    let expanded = simple::generate_file_type(&name);
    TokenStream::from(expanded)
}

/// Procedural macro for creating a simple directory type.
///
/// Creates a type representing a directory with standard directory operations.
/// Automatically includes serde derives when the serde feature is enabled.
///
/// # Example
///
/// ```ignore
/// dir_type!(CacheDir);
///
/// let cache = CacheDir::new("/var/cache/app");
/// cache.create_all()?;
/// ```
#[proc_macro]
pub fn dir_type(input: TokenStream) -> TokenStream {
    let name = parse_macro_input!(input as syn::Ident);
    let expanded = simple::generate_dir_type(&name);
    TokenStream::from(expanded)
}