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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
//! Mingling Macros Crate
//!
//! This crate provides procedural macros for the Mingling framework.
//! Macros are implemented in separate modules and re-exported here.
use proc_macro::TokenStream;
mod chain;
mod chain_struct;
mod dispatcher;
mod node;
mod render;
mod renderer;
/// Creates a command node from a dot-separated path string.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::node;
///
/// let node = node!("root.subcommand.action");
/// ```
#[proc_macro]
pub fn node(input: TokenStream) -> TokenStream {
node::node(input)
}
/// Derive macro for automatically implementing the `Dispatcher` trait.
///
/// This macro generates an implementation of `mingling::Dispatcher` for a struct.
/// By default, it uses the struct name converted to snake_case as the command path.
/// You can also specify a custom path using the `#[dispatcher("path")]` attribute.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::Dispatcher;
///
/// // Uses default path: "remote.add"
/// #[derive(Dispatcher)]
/// pub struct RemoteAdd;
///
/// // Uses custom path: "remote.rm"
/// #[derive(Dispatcher)]
/// #[dispatcher("remote.rm")]
/// pub struct MyCommand;
/// ```
#[proc_macro_derive(Dispatcher, attributes(dispatcher))]
pub fn dispatcher_derive(input: TokenStream) -> TokenStream {
dispatcher::dispatcher_derive(input)
}
/// Macro for creating wrapper types with automatic trait implementations.
///
/// This macro creates a new struct that wraps an inner type and automatically
/// implements common traits:
/// - `From<InnerType>` and `Into<InnerType>`
/// - `new()` constructor
/// - `Default` (if inner type implements Default)
/// - `AsRef<InnerType>` and `AsMut<InnerType>`
/// - `Deref` and `DerefMut` to inner type
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::chain_struct;
///
/// // Creates a wrapper type around String
/// chain_struct!(NameString = String);
///
/// // Usage:
/// let name = NameString::new("Hello".to_string());
/// let inner: String = name.into(); // Into conversion
/// let name2 = NameString::from("World".to_string()); // From conversion
/// let ref_str: &String = name2.as_ref(); // AsRef
/// ```
#[proc_macro]
pub fn chain_struct(input: TokenStream) -> TokenStream {
chain_struct::chain_struct(input)
}
/// Macro for printing to a RenderResult without newline.
///
/// This macro expands to a call to `RenderResult::print` with formatted arguments.
/// It expects a mutable reference to a `RenderResult` named `r` to be in scope.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::r_print;
///
/// let mut r = RenderResult::default();
/// r_print!("Hello, {}!", "world");
/// ```
#[proc_macro]
pub fn r_print(input: TokenStream) -> TokenStream {
render::r_print(input)
}
/// Macro for printing to a RenderResult with newline.
///
/// This macro expands to a call to `RenderResult::println` with formatted arguments.
/// It expects a mutable reference to a `RenderResult` named `r` to be in scope.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::r_println;
///
/// let mut r = RenderResult::default();
/// r_println!("Hello, {}!", "world");
/// ```
#[proc_macro]
pub fn r_println(input: TokenStream) -> TokenStream {
render::r_println(input)
}
/// Attribute macro for automatically generating structs that implement the `Chain` trait.
///
/// This macro transforms an async function into a struct that implements
/// the `Chain` trait. The struct name is specified in the attribute.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::chain;
///
/// #[chain(InitEntry)]
/// pub async fn proc(_: InitBegin) -> mingling::AnyOutput {
/// AnyOutput::new::<InitResult>("初始化成功！".to_string().into())
/// }
/// ```
///
/// This generates:
/// ```ignore
/// pub struct InitEntry;
/// impl Chain for InitEntry {
/// type Previous = InitBegin;
/// async fn proc(_: Self::Previous) -> mingling::AnyOutput {
/// AnyOutput::new::<InitResult>("初始化成功！".to_string().into())
/// }
/// }
/// ```
#[proc_macro_attribute]
pub fn chain(attr: TokenStream, item: TokenStream) -> TokenStream {
chain::chain_attr(attr, item)
}
/// Attribute macro for automatically generating structs that implement the `Renderer` trait.
///
/// This macro transforms a function into a struct that implements
/// the `Renderer` trait. The struct name is specified in the attribute.
///
/// # Examples
///
/// ```ignore
/// use mingling_macros::renderer;
///
/// #[renderer(InitResultRenderer)]
/// fn render(p: InitResult, r: &mut RenderResult) {
/// let str: String = p.into();
/// r_println!("{}", str);
/// }
/// ```
///
/// This generates:
/// ```ignore
/// pub struct InitResultRenderer;
/// impl Renderer for InitResultRenderer {
/// type Previous = InitResult;
///
/// fn render(p: Self::Previous, r: &mut RenderResult) {
/// let str: String = p.into();
/// r_println!("{}", str);
/// }
/// }
/// ```
#[proc_macro_attribute]
pub fn renderer(attr: TokenStream, item: TokenStream) -> TokenStream {
renderer::renderer_attr(attr, item)
}
|
