derive-defs 0.0.8

Library for generating derive preset macros from TOML configuration
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

//! Code generation example: Generate proc-macro code.
//!
//! This example shows how to generate Rust proc-macro code from
//! TOML configuration.
//!
//! # Running the example
//!
//! ```bash
//! cargo run --example code_generation
//! ```

use std::fs;

fn main() {
    println!("Code Generation Example");
    println!("=======================");
    println!();

    // Create a comprehensive TOML configuration
    let config = r#"
# Serialization bundle for API types
[defs.serialization]
traits = ["Clone", "Serialize", "Deserialize"]
attrs = [
    '#[serde(rename_all = "camelCase")]',
]

# Model bundle for domain types
[defs.model]
traits = ["Debug", "Clone", "PartialEq"]

# Entity bundle for database types
[defs.entity]
extends = "model"
traits = ["Serialize", "Deserialize"]
attrs = [
    '#[serde(rename_all = "camelCase")]',
    '#[serde(default)]',
]

# Value object bundle (immutable, comparable)
[defs.value_object]
extends = "model"
traits = ["Eq", "Hash", "Copy"]

# Event bundle for domain events
[defs.event]
extends = "serialization"
traits = ["Debug", "Hash", "Eq"]
"#;

    let temp_dir = std::env::temp_dir();
    let config_path = temp_dir.join("derive_defs_codegen_example.toml");
    fs::write(&config_path, config).expect("Failed to write config");

    println!("Configuration:");
    println!("{config}");
    println!();

    // Parse and resolve
    let parsed = derive_defs::parser::parse_file(&config_path).expect("Failed to parse");
    let resolved = derive_defs::resolver::resolve(&parsed).expect("Failed to resolve");

    // Generate code
    let output_path = temp_dir.join("derive_defs_codegen_output.rs");
    derive_defs::generate_from_resolved(resolved, &output_path).expect("Failed to generate");

    println!("Generated proc-macro code:");
    println!("---");
    let generated = fs::read_to_string(&output_path).expect("Failed to read output");
    println!("{generated}");
    println!("---");
    println!();

    println!("This generated code can be used in a proc-macro crate.");
    println!("Each function is a proc_macro_attribute that applies");
    println!("the configured derives and attributes to the input item.");

    // Cleanup
    let _ = fs::remove_file(&config_path);
    let _ = fs::remove_file(&output_path);
}