Implement CAH

Author: Astavie

Cargo.lock

@@ -15,6 +15,7 @@ discord = { path = "discord" }
 futures-util = "0.3.28"
 monostate = "0.1.6"
 ini = "1.3.0"
+rand = "0.8.5"
 
 [patch.crates-io]
 serde = { git = "https://github.com/Astavie/serde.git", branch = "integer-tags-for-enums-noprecompile" }

Cargo.toml

@@ -58,8 +58,8 @@ pub fn derive_partial(input: proc_macro::TokenStream) -> proc_macro::TokenStream
         if ident.to_string() == "id" {
             quote!{}
         } else {
-            let get_ident = Ident::new(&format!("get_{}", ident), Span::call_site());
-            let get_ident_mut = Ident::new(&format!("get_{}_mut", ident), Span::call_site());
+            let get_ident = Ident::new(&format!("get_{}", ident), ident.span());
+            let get_ident_mut = Ident::new(&format!("get_{}_mut", ident), ident.span());
             quote! {
                 #vis async fn #get_ident(&mut self, client: &crate::request::Discord) -> crate::request::Result<&#ty> {
                     crate::request::Result::Ok(match self.#ident {

discord/partial_id/src/lib.rs

@@ -66,8 +66,28 @@ impl CommandData {
 #[derive(Debug, Deserialize, Serialize)]
 #[serde(tag = "type")]
 pub enum CommandOption {
+    #[serde(rename = 1)]
+    SubCommand,
+    #[serde(rename = 2)]
+    SubCommandGroup,
     #[serde(rename = 3)]
     String(StringOption),
+    #[serde(rename = 4)]
+    Integer,
+    #[serde(rename = 5)]
+    Boolean,
+    #[serde(rename = 6)]
+    User,
+    #[serde(rename = 7)]
+    Channel,
+    #[serde(rename = 8)]
+    Role,
+    #[serde(rename = 9)]
+    Mentionable,
+    #[serde(rename = 10)]
+    Number,
+    #[serde(rename = 11)]
+    Attachment,
 }
 
 #[derive(Debug, Deserialize, Serialize, Setters)]

discord/src/command.rs

@@ -81,16 +81,17 @@ impl GatewayState {
                             GatewayOpcode::Dispatch => {
                                 // event happened
                                 self.sequence = message.s;
-                                let event: GatewayEvent = serde_json::from_str(&s).unwrap();
+                                let event: std::result::Result<GatewayEvent, _> = serde_json::from_str(&s);
                                 match event {
-                                    GatewayEvent::Ready(ready) => {
+                                    Ok(GatewayEvent::Ready(ready)) => {
                                         self.ready = Some(ready);
                                     }
-                                    event => {
+                                    Ok(event) => {
                                         if self.sender.send(event).await.is_err() {
                                             return Err(());
                                         }
                                     }
+                                    _ => (),
                                 }
                             }
                             GatewayOpcode::Heartbeat => {
@@ -214,7 +215,7 @@ const NAME: &str = env!("CARGO_PKG_NAME");
 
 impl Gateway {
     pub async fn connect(client: &Discord) -> request::Result<Self> {
-        let GatewayResponse { url } = Request::get("/gateway".to_owned()).request(client).await?;
+        let GatewayResponse { url } = Request::get("/gateway".into()).request(client).await?;
         let full_url = url + "/?v=10&encoding=json";
 
         let (mut ws_stream, _) = connect_async(full_url).await.expect("could not connect");
@@ -236,12 +237,12 @@ impl Gateway {
         let identify = serde_json::to_string(&GatewayMessage {
             op: GatewayOpcode::Identify,
             d: Identify {
-                token: client.token().to_owned(),
+                token: client.token().into(),
                 intents: 0,
                 properties: ConnectionProperties {
-                    os: "linux".to_owned(),
-                    browser: NAME.to_owned(),
-                    device: NAME.to_owned(),
+                    os: "linux".into(),
+                    browser: NAME.into(),
+                    device: NAME.into(),
                 },
             },
             s: None,

discord/src/gateway.rs

@@ -94,6 +94,16 @@ pub struct CreateReply {
     flags: EnumSet<ReplyFlag>,
 }
 
+#[derive(Default, Setters, Serialize)]
+#[setters(strip_option)]
+pub struct CreateUpdate {
+    content: Option<String>,
+
+    // send these even if empty, so they can also be removed
+    embeds: Vec<Embed>,
+    components: Vec<ActionRow>,
+}
+
 #[derive(EnumSetType)]
 pub enum ReplyFlag {
     Ephemeral = 6,
@@ -120,7 +130,7 @@ impl Client for Webhook {
         // send request
         let http = isahc::Request::builder()
             .method(method)
-            .uri("https://discord.com/api/v10".to_owned() + uri);
+            .uri(format!("https://discord.com/api/v10{}", uri));
 
         let mut response = if let Some(body) = body {
             let request = http
@@ -231,7 +241,7 @@ pub trait InteractionResource: Sized {
 pub trait ComponentInteractionResource: InteractionResource<Data = MessageComponent> {
     fn update_request(
         self,
-        f: impl FnOnce(CreateReply) -> CreateReply,
+        f: impl FnOnce(CreateUpdate) -> CreateUpdate,
     ) -> Request<
         (),
         Webhook,
@@ -242,7 +252,7 @@ pub trait ComponentInteractionResource: InteractionResource<Data = MessageCompon
         let application_id = token.application_id;
         let str = token.token.clone();
 
-        let reply = f(CreateReply::default());
+        let reply = f(CreateUpdate::default());
         Request::post(
             token.uri_response(),
             &Response {
@@ -259,7 +269,7 @@ pub trait ComponentInteractionResource: InteractionResource<Data = MessageCompon
     async fn update(
         self,
         client: &Webhook,
-        f: impl FnOnce(CreateReply) -> CreateReply + Send,
+        f: impl FnOnce(CreateUpdate) -> CreateUpdate + Send,
     ) -> Result<InteractionResponseIdentifier> {
         self.update_request(f).request(client).await
     }
@@ -289,6 +299,7 @@ pub trait ComponentInteractionResource: InteractionResource<Data = MessageCompon
     }
 }
 
+#[derive(Clone, PartialEq, Eq)]
 pub struct InteractionResponseIdentifier {
     application_id: Snowflake<Application>,
     token: String,
@@ -343,7 +354,7 @@ impl Endpoint for InteractionResponseIdentifier {
             .message
             .as_ref()
             .map(|id| id.as_int().to_string())
-            .unwrap_or_else(|| "@original".to_owned());
+            .unwrap_or_else(|| "@original".into());
 
         format!(
             "/webhooks/{}/{}/messages/{}",
@@ -392,11 +403,11 @@ impl<'de> Deserialize<'de> for AnyInteraction {
 
         Ok(match typ {
             2 => {
-                data.insert("application_id".to_owned(), app_id.unwrap());
+                data.insert("application_id".into(), app_id.unwrap());
                 AnyInteraction::Command(Interaction::deserialize(value).unwrap())
             }
             3 => {
-                data.insert("message".to_owned(), message.unwrap().clone());
+                data.insert("message".into(), message.unwrap().clone());
                 AnyInteraction::Component(Interaction::deserialize(value).unwrap())
             }
             _ => panic!("unsupported type {:?}", typ),

discord/src/interaction.rs

@@ -12,3 +12,33 @@ pub mod guild;
 pub mod interaction;
 pub mod message;
 pub mod user;
+
+pub struct EscapedChars<T: Iterator<Item = char>>(T, Option<char>);
+
+impl<T: Iterator<Item = char>> EscapedChars<T> {
+    pub fn new(t: T) -> Self {
+        Self(t, None)
+    }
+}
+
+impl<T: Iterator<Item = char>> Iterator for EscapedChars<T> {
+    type Item = char;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.1.take() {
+            Some(c) => Some(c),
+            None => match self.0.next() {
+                c
+                @ Some('\\' | '_' | '*' | '|' | '~' | '`' | '[' | ']' | '(' | ')' | '<' | '>') => {
+                    self.1 = c;
+                    Some('\\')
+                }
+                c => c,
+            },
+        }
+    }
+}
+
+pub fn escape_string(s: &str) -> String {
+    EscapedChars::new(s.chars()).collect()
+}

discord/src/lib.rs

@@ -14,7 +14,7 @@ use super::{
     user::PartialUser,
 };
 
-#[derive(Debug, Deserialize, Copy, Clone)]
+#[derive(Debug, Deserialize, Copy, Clone, PartialEq, Eq)]
 pub struct MessageIdentifier {
     channel_id: Snowflake<Channel>,
 
@@ -85,7 +85,7 @@ pub struct ActionRow {
     pub components: Vec<ActionRowComponent>,
 }
 
-#[derive(Debug, Serialize_repr, Deserialize_repr)]
+#[derive(Debug, Clone, Copy, Serialize_repr, Deserialize_repr)]
 #[repr(u8)]
 pub enum ButtonStyle {
     Primary = 1,

discord/src/message.rs

@@ -202,9 +202,9 @@ impl Discord {
     fn get_bucket(uri: &str) -> String {
         if uri.starts_with("/guilds/") || uri.starts_with("/channels/") {
             let s: String = uri.split_inclusive('/').take(3).collect();
-            s.strip_suffix("/").unwrap_or(&s).to_owned()
+            s.strip_suffix("/").unwrap_or(&s).into()
         } else {
-            uri.to_owned()
+            uri.into()
         }
     }
     fn bound_to_global_limit(uri: &str) -> bool {
@@ -268,12 +268,12 @@ impl Client for Discord {
         // send request
         let http = isahc::Request::builder()
             .method(method)
-            .uri("https://discord.com/api/v10".to_owned() + uri)
+            .uri(format!("https://discord.com/api/v10{}", uri))
             .header(
                 "User-Agent",
                 format!("DiscordBot ({}, {})", "https://astavie.github.io/", VERSION),
             )
-            .header("Authorization", "Bot ".to_owned() + &self.token);
+            .header("Authorization", format!("Bot {}", self.token));
 
         let mut response = if let Some(body) = body {
             let request = http
@@ -313,8 +313,8 @@ impl Client for Discord {
                     };
 
                     let mut me = self.limits.lock().await;
-                    me.bucket_cache.insert(bucket, bucket_id.to_owned());
-                    me.buckets.insert(bucket_id.to_owned(), limit);
+                    me.bucket_cache.insert(bucket, bucket_id.into());
+                    me.buckets.insert(bucket_id.into(), limit);
                 }
             }
         }