dyncord 0.13.6

A high-level, ergonomic, batteries-included Discord bot library for Rust. WIP.
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
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

use std::sync::Arc;

use twilight_gateway::Event;
use twilight_model::gateway::payload::incoming::MessageCreate;

use crate::commands::CommandNode;
use crate::commands::errors::CommandError;
use crate::commands::prefixed::context::PrefixedContext;
use crate::commands::prefixed::parsing::{self, CommandParts};
use crate::commands::prefixed::prefixes::PrefixesContext;
use crate::commands::prefixed::{PrefixedCommand, PrefixedCommandGroup};
use crate::errors::{
    self, DyncordError, ErrorContext, ErrorHandlerWithoutType, ErrorOriginalContext,
};
use crate::events::EventContext;
use crate::state::StateBound;

/// Handles the invokation of message commands.
///
/// When a [`MessageCreate`] event is received, this function checks if the message starts with any
/// of the bot's registered commands and invokes it.
pub(crate) async fn route_prefixed_command<State>(event_ctx: EventContext<State, MessageCreate>)
where
    State: StateBound,
{
    if let Some(prefixes) = &event_ctx.handle.prefixes {
        let prefixes_ctx = PrefixesContext {
            state: event_ctx.state.clone(),
            event: event_ctx.event.clone(),
        };

        let prefixes = match prefixes.get(prefixes_ctx.clone()).await {
            Ok(prefixes) => prefixes,
            Err(error) => {
                let error_ctx = ErrorContext {
                    event: Event::MessageCreate(Box::new(event_ctx.event)),
                    handle: event_ctx.handle.clone(),
                    state: event_ctx.state,
                    original: ErrorOriginalContext::PrefixesContext(Box::new(prefixes_ctx)),
                };

                errors::handle(
                    error_ctx,
                    DyncordError::Command(CommandError::Prefixes(error)),
                    &[event_ctx.handle.on_errors],
                )
                .await;

                return;
            }
        };

        'prefixes: for prefix in prefixes {
            let Some(parts) = parsing::parse(&prefix, &event_ctx.event.content) else {
                continue;
            };

            for node in &*event_ctx.handle.commands {
                let command = match node {
                    CommandNode::PrefixedCommand(command) => {
                        match_command(&event_ctx, parts, command)
                    }
                    CommandNode::PrefixedCommandGroup(group) => {
                        match_group(&event_ctx, parts, group)
                    }
                    _ => {
                        continue;
                    }
                };

                if let Some((command, mut error_handlers)) = command {
                    let command_identifier = parts.command_name.to_string();
                    let command_prefix = parts.prefix.to_string();
                    let command_args = parts.command_args.to_string();

                    let command_ctx = PrefixedContext {
                        event: event_ctx.event.clone(),
                        state: event_ctx.state.clone(),
                        handle: event_ctx.handle.clone(),
                        command_identifier,
                        command_prefix,
                        command_args,
                    };

                    let result = command.run(command_ctx.clone(), parts.command_args).await;

                    if let Err(error) = result {
                        let error_ctx = ErrorContext {
                            event: Event::MessageCreate(Box::new(event_ctx.event)),
                            handle: event_ctx.handle,
                            state: event_ctx.state,
                            original: ErrorOriginalContext::PrefixedContext(Box::new(command_ctx)),
                        };

                        error_handlers.push(error_ctx.handle.on_errors.clone());

                        errors::handle(error_ctx, DyncordError::Command(error), &error_handlers)
                            .await;
                    }

                    break 'prefixes;
                }
            }
        }
    }
}

type ErrorHandlers<State> = Vec<Vec<Arc<dyn ErrorHandlerWithoutType<State>>>>;

fn match_command<'a, State>(
    _ctx: &'a EventContext<State, MessageCreate>,
    parts: CommandParts<'a>,
    command: &'a PrefixedCommand<State>,
) -> Option<(&'a PrefixedCommand<State>, ErrorHandlers<State>)>
where
    State: StateBound,
{
    if command
        .identifiers()
        .contains(&parts.command_name.to_string())
    {
        return Some((command, vec![command.on_errors.clone()]));
    }

    None
}

fn match_group<'a, State>(
    ctx: &'a EventContext<State, MessageCreate>,
    parts: CommandParts<'a>,
    group: &'a PrefixedCommandGroup<State>,
) -> Option<(&'a PrefixedCommand<State>, ErrorHandlers<State>)>
where
    State: StateBound,
{
    for node in &group.children {
        let command = match node {
            CommandNode::PrefixedCommand(subcommand) => match_command(ctx, parts, subcommand),
            CommandNode::PrefixedCommandGroup(subgroup) => match_group(ctx, parts, subgroup),
            _ => None,
        };

        if let Some((command, mut error_handlers)) = command {
            error_handlers.push(group.on_errors.clone());

            return Some((command, error_handlers));
        }
    }

    None
}