autoargs 0.1.1

A proc macro for generating argument structs with defaults
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use autoargs::{autoargs, impl_autoargs, default};

// Define a simple struct with methods
struct Canvas {
    name: String,
    width: u32,
    height: u32,
}

// First, generate the method macros
#[impl_autoargs]
impl Canvas {
    fn new(name: &str, width: u32, height: u32) -> Self {
        Self {
            name: name.to_string(),
            width,
            height,
        }
    }
    
    // Use autoargs on a method
    #[autoargs]
    fn draw_rectangle(
        &self,
        #[default = "0"]
        x: u32,
        #[default = "0"]
        y: u32,
        #[default = "100"]
        width: u32,
        #[default = "50"]
        height: u32,
        #[default = "\"blue\".to_string()"]
        color: String,
    ) -> String {
        format!(
            "Drawing a {} rectangle at ({}, {}) with size {}x{} on canvas \"{}\" ({}x{})",
            color, x, y, width, height, self.name, self.width, self.height
        )
    }
    
    // Use autoargs on a mutable method
    #[autoargs]
    fn resize(
        &mut self,
        #[default = "800"]
        width: u32,
        #[default = "600"]
        height: u32,
    ) -> String {
        self.width = width;
        self.height = height;
        format!("Resized canvas to {}x{}", width, height)
    }
}

// A different struct with a method that takes a value parameter
struct Shape {
    name: String,
}

#[impl_autoargs]
impl Shape {
    fn new(name: &str) -> Self {
        Self { name: name.to_string() }
    }
    
    #[autoargs]
    fn scale(
        self, // Takes ownership of self
        #[default = "2.0"]
        factor: f64,
        #[default = "true"]
        uniform: bool,
    ) -> String {
        format!("Scaling {} by factor {} (uniform: {})", self.name, factor, uniform)
    }
}

fn main() {
    // Create a canvas
    let mut canvas = Canvas::new("My Canvas", 1024, 768);
    
    // Call a method with default parameters
    let result1 = draw_rectangle!(&canvas);
    println!("Default: {}", result1);
    
    // Call a method specifying some parameters
    let result2 = draw_rectangle!(&canvas, x = 10, y = 20, color = "red".to_string());
    println!("Custom position and color: {}", result2);
    
    // Call a method with custom args struct
    let args = DrawRectangleArgs {
        x: 30,
        y: 40,
        width: 200,
        height: 100,
        color: "green".to_string(),
    };
    let result3 = draw_rectangle!(&canvas, args);
    println!("Custom args struct: {}", result3);
    
    // Call a mutable method
    let result4 = resize!(&mut canvas);
    println!("Default resize: {}", result4);
    
    // Call a mutable method with custom values
    let result5 = resize!(&mut canvas, width = 1200, height = 900);
    println!("Custom resize: {}", result5);
    
    // Call a method that takes ownership of self
    let shape = Shape::new("Circle");
    let result6 = scale!(shape);
    println!("Default scale: {}", result6);
    
    // Call a method with a single parameter
    let shape2 = Shape::new("Square");
    let result7 = scale!(shape2, factor = 3.5);
    println!("Custom scale: {}", result7);
}