tron 2.1.0

//! Compile-time template generation macros.
//!
//! This module provides procedural macros for embedding Tron templates directly
//! into Rust code at compile time, enabling zero-runtime-cost template usage.

/// Include a Tron template file at compile time and create a template instance.
///
/// This macro reads a template file during compilation and embeds its contents
/// as a `TronTemplate` in the resulting binary. The template is parsed and
/// validated at compile time.
///
/// # Examples
///
/// ```ignore
/// use tron::include_template;
///
/// // Include template from file
/// let template = include_template!("templates/function.tron");
///
/// // Use the template normally
/// let mut template = template.clone();
/// template.set("name", "example").unwrap();
/// template.set("body", "println!(\"Hello!\");").unwrap();
/// let result = template.render().unwrap();
/// ```
///
/// # Compile-time Validation
///
/// The macro validates template syntax at compile time:
///
/// ```compile_fail
/// // This would cause a compilation error if the template has invalid syntax
/// let template = include_template!("templates/invalid.tron");
/// ```
///
/// # Path Resolution
///
/// Template paths are resolved relative to the crate root or `CARGO_MANIFEST_DIR`.
/// You can use absolute paths or paths relative to the current file using
/// `include_template!(concat!(env!("CARGO_MANIFEST_DIR"), "/templates/file.tron"))`.
#[macro_export]
macro_rules! include_template {
    ($file:expr) => {{
        const CONTENT: &str = include_str!($file);
        let template = $crate::TronTemplate::new(CONTENT)
            .expect(concat!("Failed to parse template: ", $file));
        // Run validator at compile time (will panic if invalid)
        let validator = $crate::validation::TemplateValidator::new();
        let report = validator.validate(&template)
            .expect("Template validation failed unexpectedly");
        if report.has_errors() {
            panic!("Template validation errors: {}", report);
        }
        template
    }};
}

/// Create a template from a string literal at compile time.
///
/// This macro creates a `TronTemplate` from a string literal, with compile-time
/// syntax validation. It's useful for small templates that don't warrant
/// separate files.
///
/// # Examples
///
/// ```
/// use tron::template;
///
/// let template = template!("fn @[name]@() { @[body]@ }");
/// ```
#[macro_export]
macro_rules! template {
    ($template:literal) => {{
        let template = $crate::TronTemplate::new($template)
            .expect(concat!("Failed to parse template: ", $template));
        let validator = $crate::validation::TemplateValidator::new();
        let report = validator.validate(&template)
            .expect("Template validation failed unexpectedly");
        if report.has_errors() {
            panic!("Template validation errors: {}", report);
        }
        template
    }};
}

/// Create a template reference with dependencies at compile time.
///
/// This macro creates a `TronRef` from a template string and a list of dependencies.
/// Both template syntax and dependency format are validated at compile time.
///
/// # Examples
///
/// ```
/// use tron::template_ref;
///
/// let template_ref = template_ref!(
///     "use serde::Serialize;\n#[derive(Serialize)]\nstruct @[name]@ { @[fields]@ }",
///     dependencies = ["serde = \"1.0\""]
/// );
/// ```
///
/// # With Multiple Dependencies
///
/// ```
/// use tron::template_ref;
///
/// let template_ref = template_ref!(
///     "async fn @[name]@() -> Result<@[return_type]@, @[error_type]@> { @[body]@ }",
///     dependencies = [
///         "tokio = \"1.0\"",
///         "serde = \"1.0\"",
///         "anyhow = \"1.0\""
///     ]
/// );
/// ```
#[macro_export]
macro_rules! template_ref {
    ($template:literal, dependencies = [$($dep:literal),* $(,)?]) => {
        {
            let template = $crate::TronTemplate::new($template)
                .expect(concat!("Failed to parse template: ", $template));
            let mut template_ref = $crate::TronRef::new(template);
            $(
                template_ref = template_ref.with_dependency($dep);
            )*
            template_ref
        }
    };
    ($template:literal) => {
        {
            let template = $crate::TronTemplate::new($template)
                .expect(concat!("Failed to parse template: ", $template));
            $crate::TronRef::new(template)
        }
    };
}

/// Create a template assembler with multiple templates at compile time.
///
/// This macro creates a `TronAssembler` with multiple templates, useful for
/// building complex code generation workflows.
///
/// # Examples
///
/// ```
/// use tron::assemble_templates;
///
/// let assembler = assemble_templates![
///     "// File header\nuse std::collections::HashMap;",
///     "pub struct @[struct_name]@ { @[fields]@ }",
///     "impl @[struct_name]@ { @[methods]@ }"
/// ];
/// ```
///
/// # With Custom Separator
///
/// ```
/// use tron::assemble_templates;
///
/// let assembler = assemble_templates![
///     separator = "\n\n",
///     "mod @[module_name]@ {",
///     "    @[module_content]@",
///     "}"
/// ];
/// ```
#[macro_export]
macro_rules! assemble_templates {
    (separator = $sep:literal, $($template:literal),+ $(,)?) => {
        {
            let mut assembler = $crate::TronAssembler::with_separator($sep);
            $(
                let template = $crate::TronTemplate::new($template)
                    .expect(concat!("Failed to parse template: ", $template));
                assembler.add_template($crate::TronRef::new(template));
            )+
            assembler
        }
    };
    ($($template:literal),+ $(,)?) => {
        {
            let mut assembler = $crate::TronAssembler::new();
            $(
                let template = $crate::TronTemplate::new($template)
                    .expect(concat!("Failed to parse template: ", $template));
                assembler.add_template($crate::TronRef::new(template));
            )+
            assembler
        }
    };
}

/// Generate code using a template at compile time.
///
/// This is an advanced macro that allows you to specify placeholder values
/// and generate code directly at compile time. The generated code is inlined
/// into your program.
///
/// **Note:** This macro requires the template to be fully resolved at compile time,
/// so all placeholder values must be string literals.
///
/// # Examples
///
/// ```
/// use tron::generate_code;
///
/// // Generate a simple function
/// generate_code!(
///     template = "fn @[name]@() -> @[return_type]@ { @[body]@ }",
///     placeholders = {
///         "name" => "hello_world",
///         "return_type" => "&'static str", 
///         "body" => "\"Hello, World!\""
///     }
/// );
/// 
/// // The above generates:
/// // fn hello_world() -> &'static str { "Hello, World!" }
/// ```
///
/// # Complex Example
///
/// ```
/// use tron::generate_code;
///
/// generate_code!(
///     template = r#"
///         #[derive(@[derives]@)]
///         pub struct @[name]@ {
///             @[fields]@
///         }
///     "#,
///     placeholders = {
///         "derives" => "Debug, Clone, PartialEq",
///         "name" => "Person",
///         "fields" => "pub name: String,\n    pub age: u32"
///     }
/// );
/// ```
#[macro_export]
macro_rules! generate_code {
    (
        template = $template:literal,
        placeholders = { $($key:literal => $value:literal),* $(,)? }
    ) => {
        {
            // This is a compile-time code generation macro
            // At runtime, this evaluates to the generated code string
            let mut content = String::from($template);
            $(
                content = content.replace(
                    &format!("@[{}]@", $key),
                    $value
                );
            )*
            content
        }
    };
}

/// Create a template builder at compile time with predefined values.
///
/// This macro creates a `TronTemplateBuilder` with template content and
/// predefined placeholder values, useful for creating reusable template
/// configurations.
///
/// # Examples
///
/// ```
/// use tron::template_builder;
///
/// let builder = template_builder!(
///     template = "struct @[name]@ { @[field]@: @[type]@ }",
///     values = {
///         "name" => "Example",
///         "field" => "value"
///     }
/// );
/// 
/// let template = builder
///     .set("type", "String")
///     .build()
///     .unwrap();
/// ```
#[macro_export]
macro_rules! template_builder {
    (
        template = $template:literal,
        values = { $($key:literal => $value:literal),* $(,)? }
    ) => {
        {
            let mut builder = $crate::TronTemplateBuilder::new()
                .content($template);
            $(
                builder = builder.set($key, $value);
            )*
            builder
        }
    };
    (template = $template:literal) => {
        $crate::TronTemplateBuilder::new().content($template)
    };
}

#[cfg(test)]
mod tests {

    #[test]
    fn test_template_macro() {
        let template = template!("Hello @[name]@!");
        assert_eq!(template.placeholder_names().len(), 1);
        assert!(template.has_placeholder("name"));
    }

    #[test]
    fn test_template_ref_macro() {
        let template_ref = template_ref!(
            "use @[crate_name]@;\nfn @[name]@() { @[body]@ }",
            dependencies = ["serde = \"1.0\"", "tokio = \"1.0\""]
        );
        
        assert_eq!(template_ref.dependencies().len(), 2);
        assert!(template_ref.inner().has_placeholder("name"));
        assert!(template_ref.inner().has_placeholder("body"));
        assert!(template_ref.inner().has_placeholder("crate_name"));
    }

    #[test]
    fn test_template_ref_macro_no_deps() {
        let template_ref = template_ref!("fn @[name]@() {}");
        assert_eq!(template_ref.dependencies().len(), 0);
        assert!(template_ref.inner().has_placeholder("name"));
    }

    #[test]
    fn test_assemble_templates_macro() {
        let assembler = assemble_templates![
            "// Header comment",
            "fn @[name]@() {}",
            "// Footer comment"
        ];
        
        assert_eq!(assembler.len(), 3);
    }

    #[test]
    fn test_assemble_templates_macro_with_separator() {
        let assembler = assemble_templates![
            separator = "\n\n",
            "mod test {",
            "    @[content]@",
            "}"
        ];
        
        assert_eq!(assembler.separator(), "\n\n");
        assert_eq!(assembler.len(), 3);
    }

    #[test]
    fn test_generate_code_macro() {
        let code = generate_code!(
            template = "fn @[name]@() -> @[type]@ { @[body]@ }",
            placeholders = {
                "name" => "test_function",
                "type" => "i32",
                "body" => "42"
            }
        );
        
        assert_eq!(code, "fn test_function() -> i32 { 42 }");
    }

    #[test]
    fn test_template_builder_macro() {
        let builder = template_builder!(
            template = "@[greeting]@ @[name]@!",
            values = {
                "greeting" => "Hello"
            }
        );
        
        let template = builder
            .set("name", "World")
            .build()
            .unwrap();
            
        let result = template.render().unwrap();
        assert_eq!(result, "Hello World!");
    }

    #[test]
    fn test_template_builder_macro_no_values() {
        let builder = template_builder!(template = "Hello @[name]@!");
        let template = builder
            .set("name", "Macro")
            .build()
            .unwrap();
            
        assert_eq!(template.render().unwrap(), "Hello Macro!");
    }

    #[test] 
    fn test_macro_with_complex_template() {
        let template = template!(r#"
            #[derive(Debug)]
            pub struct @[name]@ {
                @[fields]@
            }
            
            impl @[name]@ {
                pub fn new(@[constructor_params]@) -> Self {
                    Self {
                        @[constructor_body]@
                    }
                }
            }
        "#);
        
        assert!(template.has_placeholder("name"));
        assert!(template.has_placeholder("fields"));
        assert!(template.has_placeholder("constructor_params"));
        assert!(template.has_placeholder("constructor_body"));
    }

    #[test]
    #[should_panic(expected = "Failed to parse template")]
    fn test_template_macro_invalid_syntax() {
        let _template = template!("Invalid @[bad name]@ template");
    }
}