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
191
192
193
194
195
196
197
198
199
200
201
202
|
mod command;
mod configuration;
pub use self::command::Command;
pub use self::configuration::Configuration;
use self::command::InternalCommand;
use std::collections::HashMap;
use std::sync::Arc;
use std::thread;
use ::client::Context;
use ::model::Message;
#[macro_export]
macro_rules! command {
($fname:ident($c:ident, $m:ident, $a:ident, $($name:ident: $t:ty),*) $b:block) => {
fn $fname($c: Context, $m: Message, $a: Vec<String>) {
let mut i = $a.iter();
$(
let $name = match i.next() {
Some(v) => match v.parse::<$t>() {
Ok(v) => v,
Err(_why) => return,
},
None => return,
};
)*
drop(i);
$b
}
}
}
/// The type of command being received.
///
/// The [`Mention`] variant is emitted if the bot is being commanded via a
/// mention (`<@USER_ID>` or `<@!USER_ID>`). This can only be emitted if
/// [`Configuration::on_mention`] is set to `true`.
///
/// The [`Prefix`] variant is emitted if a message starts with the prefix set
/// via [`Configuration::prefix`].
///
/// [`Mention`]: #variant.Mention
/// [`Prefix`]: #variant.Prefix
// This is public due to being leaked by [`command::positions`], which is used
// in [`Framework::dispatch`]. It therefore is hidden from the docs, due to
// having no use to users.
//
// [`Framework::dispatch`]: struct.Framework.html#method.dispatch
// [`command::positions`]: command/fn.positions.html
#[derive(Clone, Copy, Debug)]
#[doc(hidden)]
pub enum CommandType {
/// This is emitted if the bot is being commanded via a mention
/// (`<@USER_ID>` or `<@!USER_ID>`). This can only be emitted if
/// [`Configuration::on_mention`] is set to `true`.
Mention,
None,
Prefix,
}
#[allow(type_complexity)]
#[derive(Default)]
pub struct Framework {
configuration: Configuration,
commands: HashMap<String, InternalCommand>,
checks: HashMap<String, Arc<Fn(&Context, &Message) -> bool + Send + Sync + 'static>>,
/// Whether the framework has been "initialized".
///
/// The framework is initialized once one of the following occurs:
///
/// - configuration has been set;
/// - a command handler has been set;
/// - a command check has been set.
///
/// This is used internally to determine whether or not - in addition to
/// dispatching to the [`Client::on_message`] handler - to have the
/// framework check if a [`Event::MessageCreate`] should be processed by
/// itself.
///
/// [`Client::on_message`]: ../../client/struct.Client.html#method.on_message
/// [`Event::MessageCreate`]: ../../model/enum.Event.html#variant.MessageCreate
pub initialized: bool,
}
impl Framework {
/// Configures the framework, setting non-default values. All fields are
/// optional. Refer to [`Configuration::default`] for more information on
/// the default values.
///
/// # Examples
///
/// Configuring the framework for a [`Client`], setting the [`depth`] to 3,
/// [allowing whitespace], and setting the [`prefix`] to `"~"`:
///
/// ```rust,no_run
/// use serenity::Client;
/// use std::env;
///
/// let mut client = Client::login_bot(&env::var("DISCORD_TOKEN").unwrap());
/// client.with_framework(|f| f
/// .configure(|c| c
/// .depth(3)
/// .allow_whitespace(true)
/// .prefix("~")));
/// ```
///
/// [`Client`]: ../../client/struct.Client.html
/// [`Configuration::default`]: struct.Configuration.html#method.default
/// [`depth`]: struct.Configuration.html#method.depth
/// [`prefix`]: struct.Configuration.html#method.prefix
/// [allowing whitespace]: struct.Configuration.html#method.allow_whitespace
pub fn configure<F>(mut self, f: F) -> Self
where F: FnOnce(Configuration) -> Configuration {
self.configuration = f(self.configuration);
self.initialized = true;
self
}
#[doc(hidden)]
pub fn dispatch(&mut self, context: Context, message: Message) {
let res = command::positions(&message.content, &self.configuration);
let positions = match res {
Some((positions, _kind)) => positions,
None => return,
};
// Ensure that the message length is at least longer than a prefix
// length. There's no point in checking further ahead if there's nothing
// _to_ check.
if positions.iter().all(|p| message.content.len() <= *p) {
return;
}
for position in positions {
let mut built = String::new();
for i in 0..self.configuration.depth {
if i != 0 {
built.push(' ');
}
built.push_str(match {
message.content
.split_at(position)
.1
.trim()
.split_whitespace()
.collect::<Vec<&str>>()
.get(i)
} {
Some(piece) => piece,
None => continue,
});
if let Some(command) = self.commands.get(&built) {
if let Some(check) = self.checks.get(&built) {
if !(check)(&context, &message) {
continue;
}
}
let command = command.clone();
thread::spawn(move || {
let args = message.content[position + built.len()..]
.split_whitespace()
.map(|arg| arg.to_owned())
.collect::<Vec<String>>();
(command)(context, message, args)
});
return;
}
}
}
}
pub fn on<F, S>(mut self, command_name: S, f: F) -> Self
where F: Fn(Context, Message, Vec<String>) + Send + Sync + 'static,
S: Into<String> {
self.commands.insert(command_name.into(), Arc::new(f));
self.initialized = true;
self
}
pub fn set_check<F, S>(mut self, command: S, check: F) -> Self
where F: Fn(&Context, &Message) -> bool + Send + Sync + 'static,
S: Into<String> {
self.checks.insert(command.into(), Arc::new(check));
self.initialized = true;
self
}
}
|