twilight-interactions-derive 0.17.0

Macros and utilities to make Discord Interactions easy to use with Twilight.
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

//! Parsing of user applications related structs.

use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Error, Lit, Result};

use crate::parse::attribute::{ParseAttribute, ParseSpanned};

/// Parsed interaction context type
pub enum InteractionContextType {
    Guild,
    BotDm,
    PrivateChannel,
}

impl ParseAttribute for Vec<InteractionContextType> {
    fn parse_attribute(input: Lit) -> Result<Self> {
        let spanned: ParseSpanned<String> = ParseAttribute::parse_attribute(input)?;

        spanned
            .inner
            .split_ascii_whitespace()
            .map(|value| InteractionContextType::parse(value, spanned.span))
            .collect()
    }
}

impl InteractionContextType {
    fn parse(value: &str, span: Span) -> Result<Self> {
        match value {
            "guild" => Ok(Self::Guild),
            "bot_dm" => Ok(Self::BotDm),
            "private_channel" => Ok(Self::PrivateChannel),
            invalid => Err(Error::new(
                span,
                format!("`{invalid}` is not a valid context type"),
            )),
        }
    }
}

/// Parsed application integration type
pub enum ApplicationIntegrationType {
    GuildInstall,
    UserInstall,
}

impl ParseAttribute for Vec<ApplicationIntegrationType> {
    fn parse_attribute(input: Lit) -> Result<Self> {
        let spanned: ParseSpanned<String> = ParseAttribute::parse_attribute(input)?;

        spanned
            .inner
            .split_ascii_whitespace()
            .map(|value| ApplicationIntegrationType::parse(value, spanned.span))
            .collect()
    }
}

impl ApplicationIntegrationType {
    fn parse(value: &str, span: Span) -> Result<Self> {
        match value {
            "guild_install" => Ok(Self::GuildInstall),
            "user_install" => Ok(Self::UserInstall),
            invalid => Err(Error::new(
                span,
                format!("`{invalid}` is not a valid integration type"),
            )),
        }
    }
}

/// Convert a [`InteractionContextType`] into a [`TokenStream`]
pub fn context(kind: &InteractionContextType) -> TokenStream {
    match kind {
        InteractionContextType::Guild => {
            quote!(::twilight_model::application::interaction::InteractionContextType::Guild)
        }
        InteractionContextType::BotDm => {
            quote!(::twilight_model::application::interaction::InteractionContextType::BotDm)
        }
        InteractionContextType::PrivateChannel => {
            quote!(
                ::twilight_model::application::interaction::InteractionContextType::PrivateChannel
            )
        }
    }
}

/// Convert a [`ApplicationIntegrationType`] into a [`TokenStream`]
pub fn integration_type(kind: &ApplicationIntegrationType) -> TokenStream {
    match kind {
        ApplicationIntegrationType::GuildInstall => {
            quote!(::twilight_model::oauth::ApplicationIntegrationType::GuildInstall)
        }
        ApplicationIntegrationType::UserInstall => {
            quote!(::twilight_model::oauth::ApplicationIntegrationType::UserInstall)
        }
    }
}