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
183
184
185
186
187
188
189
190
|
#![deny(clippy::all)]
#![deny(clippy::pedantic)]
#![deny(missing_docs)]
//! Macros for the [Syrette](https://crates.io/crates/syrette) crate.
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse, parse_macro_input};
mod declare_interface_args;
mod dependency_type;
mod factory_type_alias;
mod injectable_impl;
mod injectable_macro_args;
mod libs;
mod util;
use declare_interface_args::DeclareInterfaceArgs;
use injectable_impl::InjectableImpl;
use injectable_macro_args::InjectableMacroArgs;
use libs::intertrait_macros::gen_caster::generate_caster;
/// Makes a struct injectable. Thereby usable with [`DIContainer`].
///
/// # Arguments
/// * (Optional) A interface trait the struct implements.
/// * (Zero or more) Flags wrapped in curly braces. Like `{ a = true, b = false }`
///
/// # Flags
/// - `no_doc_hidden` - Don't hide the impl of the [`Injectable`] trait from documentation.
///
/// # Panics
/// If the attributed item is not a impl.
///
/// # Important
/// If the interface trait argument is excluded, you should either manually
/// declare the interface with the [`declare_interface!`] macro or use
/// the [`di_container_bind`] macro to create a DI container binding.
///
/// # Example
/// ```
/// use syrette::injectable;
///
/// struct PasswordManager {}
///
/// #[injectable]
/// impl PasswordManager {
/// pub fn new() -> Self {
/// Self {}
/// }
/// }
/// ```
///
/// [`DIContainer`]: ../syrette/di_container/struct.DIContainer.html
/// [`Injectable`]: ../syrette/interfaces/injectable/trait.Injectable.html
/// [`di_container_bind`]: ../syrette/macro.di_container_bind.html
#[proc_macro_attribute]
pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenStream
{
let InjectableMacroArgs { interface, flags } = parse_macro_input!(args_stream);
let mut flags_iter = flags.iter();
let no_doc_hidden = flags_iter
.find(|flag| flag.flag.to_string().as_str() == "no_doc_hidden")
.map_or(false, |flag| flag.is_on.value);
let injectable_impl: InjectableImpl = parse(impl_stream).unwrap();
let expanded_injectable_impl = injectable_impl.expand(no_doc_hidden);
let maybe_decl_interface = if interface.is_some() {
let self_type = &injectable_impl.self_type;
quote! {
syrette::declare_interface!(#self_type -> #interface);
}
} else {
quote! {}
};
quote! {
#expanded_injectable_impl
#maybe_decl_interface
}
.into()
}
/// Makes a type alias usable as a factory interface.
///
/// # Panics
/// If the attributed item is not a type alias.
///
/// # Examples
/// ```
/// use std::collections::HashMap;
///
/// use syrette::interfaces::factory::IFactory;
/// use syrette::factory;
///
/// enum ConfigValue
/// {
/// String(String),
/// Bool(bool),
/// Int(i32),
/// None,
/// }
///
/// trait IConfigurator
/// {
/// fn configure(&self, key: String, value: ConfigValue);
/// }
///
/// struct Configurator {
/// config: HashMap<String, ConfigValue>,
/// }
///
/// impl Configurator
/// {
/// fn new(keys: Vec<String>) -> Self
/// {
/// Self {
/// config: HashMap::from(
/// keys
/// .iter()
/// .map(|key| (key.clone(), ConfigValue::None))
/// .collect::<HashMap<_, _>>()
/// )
/// }
/// }
/// }
///
/// impl IConfigurator for Configurator
/// {
/// fn configure(&self, key: String, value: ConfigValue)
/// {
/// // ...
/// }
/// }
///
/// #[factory]
/// type IConfiguratorFactory = dyn IFactory<(Vec<String>,), dyn IConfigurator>;
/// ```
#[proc_macro_attribute]
pub fn factory(_: TokenStream, type_alias_stream: TokenStream) -> TokenStream
{
let factory_type_alias::FactoryTypeAlias {
type_alias,
factory_interface,
arg_types,
return_type,
} = parse(type_alias_stream).unwrap();
quote! {
#type_alias
syrette::declare_interface!(
syrette::castable_factory::CastableFactory<
#arg_types,
#return_type
> -> #factory_interface
);
syrette::declare_interface!(
syrette::castable_factory::CastableFactory<
#arg_types,
#return_type
> -> syrette::interfaces::any_factory::AnyFactory
);
}
.into()
}
/// Declares the interface trait of a implementation.
///
/// # Arguments
/// {Implementation} -> {Interface}
///
#[proc_macro]
pub fn declare_interface(input: TokenStream) -> TokenStream
{
let DeclareInterfaceArgs {
implementation,
interface,
} = parse_macro_input!(input);
generate_caster(&implementation, &interface).into()
}
|
