Make all the incoming payloads able to handle unknown variants

Author: AEnterprise

.gitignore

@@ -1,2 +1,3 @@
 target/
 Cargo.lock
+idea

http/src/request/guild/get_audit_log.rs

@@ -45,7 +45,7 @@ struct GetAuditLogFields {
 ///
 /// for entry in audit_log.entries {
 ///     println!("ID: {}", entry.id);
-///     println!("  Action Type: {}", entry.action_type as u8);
+///     println!("  Action Type: {}", u16::from(entry.action_type));
 ///     println!("  Changes:");
 ///
 ///     for change in entry.changes {
@@ -134,7 +134,7 @@ impl<'a> GetAuditLog<'a> {
 impl TryIntoRequest for GetAuditLog<'_> {
     fn try_into_request(self) -> Result<Request, HttpError> {
         Ok(Request::from_route(&Route::GetAuditLogs {
-            action_type: self.fields.action_type.map(|x| x as u64),
+            action_type: self.fields.action_type.map(|x| u64::from(u16::from(x))),
             before: self.fields.before,
             guild_id: self.guild_id.get(),
             limit: self.fields.limit,

model/src/application/command/command_type.rs

@@ -1,20 +1,22 @@
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Serialize};
 
-#[derive(Clone, Copy, Debug, Deserialize_repr, Eq, Hash, PartialEq, Serialize_repr)]
-#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[serde(from = "u8", into = "u8")]
 pub enum CommandType {
     /// Slash command.
     ///
     /// Text-based command that appears when a user types `/`.
-    ChatInput = 1,
+    ChatInput,
     /// UI-based command.
     ///
     /// Appears when a user right clicks or taps om a user.
-    User = 2,
+    User,
     /// UI-based command.
     ///
     /// Appears when a user right clicks or taps on a message.
-    Message = 3,
+    Message,
+    /// Not yet known/supported
+    Unknown(u8),
 }
 
 impl CommandType {
@@ -23,6 +25,29 @@ impl CommandType {
             Self::ChatInput => "ChatInput",
             Self::User => "User",
             Self::Message => "Message",
+            CommandType::Unknown(_) => "Unknown",
+        }
+    }
+}
+
+impl From<u8> for CommandType {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => Self::ChatInput,
+            2 => Self::User,
+            3 => Self::Message,
+            unknown => Self::Unknown(unknown),
+        }
+    }
+}
+
+impl From<CommandType> for u8 {
+    fn from(value: CommandType) -> Self {
+        match value {
+            CommandType::ChatInput => 1,
+            CommandType::User => 2,
+            CommandType::Message => 3,
+            CommandType::Unknown(unknown) => unknown,
         }
     }
 }
@@ -53,12 +78,14 @@ mod tests {
         serde_test::assert_tokens(&CommandType::ChatInput, &[Token::U8(1)]);
         serde_test::assert_tokens(&CommandType::User, &[Token::U8(2)]);
         serde_test::assert_tokens(&CommandType::Message, &[Token::U8(3)]);
+        serde_test::assert_tokens(&CommandType::Unknown(4), &[Token::U8(4)]);
     }
 
     #[test]
     fn test_kinds() {
         assert_eq!("ChatInput", CommandType::ChatInput.kind());
         assert_eq!("User", CommandType::User.kind());
         assert_eq!("Message", CommandType::Message.kind());
+        assert_eq!("Unknown", CommandType::Unknown(99).kind());
     }
 }

model/src/application/component/button.rs

@@ -1,5 +1,5 @@
 use crate::channel::ReactionType;
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Serialize};
 
 /// Clickable interactive components that render on messages.
 ///
@@ -36,34 +36,62 @@ pub struct Button {
 /// Refer to [the Discord Docs/Button Object] for additional information.
 ///
 /// [the Discord Docs/Button Object]: https://discord.com/developers/docs/interactions/message-components#button-object-button-styles
-#[derive(Clone, Copy, Debug, Deserialize_repr, Eq, Hash, PartialEq, PartialOrd, Serialize_repr)]
-#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Serialize)]
+#[serde(from = "u8", into = "u8")]
 pub enum ButtonStyle {
     /// Button indicates a primary action.
     ///
     /// Selecting this button style requires specifying the
     /// [`Button::custom_id`] field.
-    Primary = 1,
+    Primary,
     /// Button indicates a secondary action.
     ///
     /// Selecting this button style requires specifying the
     /// [`Button::custom_id`] field.
-    Secondary = 2,
+    Secondary,
     /// Button indicates a successful action.
     ///
     /// Selecting this button style requires specifying the
     /// [`Button::custom_id`] field.
-    Success = 3,
+    Success,
     /// Button indicates a dangerous action.
     ///
     /// Selecting this button style requires specifying the
     /// [`Button::custom_id`] field.
-    Danger = 4,
+    Danger,
     /// Button indicates an action with a link.
     ///
     /// Selecting this button style requires specifying the [`Button::url`]
     /// field.
-    Link = 5,
+    Link,
+    /// Variant value is unknown to the library.
+    Unknown(u8),
+}
+
+impl From<u8> for ButtonStyle {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => ButtonStyle::Primary,
+            2 => ButtonStyle::Secondary,
+            3 => ButtonStyle::Success,
+            4 => ButtonStyle::Danger,
+            5 => ButtonStyle::Link,
+            unknown => ButtonStyle::Unknown(unknown),
+        }
+    }
+}
+
+impl From<ButtonStyle> for u8 {
+    fn from(value: ButtonStyle) -> Self {
+        match value {
+            ButtonStyle::Primary => 1,
+            ButtonStyle::Secondary => 2,
+            ButtonStyle::Success => 3,
+            ButtonStyle::Danger => 4,
+            ButtonStyle::Link => 5,
+            ButtonStyle::Unknown(unknown) => unknown,
+        }
+    }
 }
 
 #[cfg(test)]
@@ -72,7 +100,7 @@ mod tests {
     use super::*;
     use serde::{Deserialize, Serialize};
     use serde_test::Token;
-    use static_assertions::{assert_fields, assert_impl_all, const_assert_eq};
+    use static_assertions::{assert_fields, assert_impl_all};
     use std::{fmt::Debug, hash::Hash};
 
     assert_fields!(Button: custom_id, disabled, emoji, label, style, url);
@@ -91,11 +119,6 @@ mod tests {
         Serialize,
         Sync
     );
-    const_assert_eq!(1, ButtonStyle::Primary as u8);
-    const_assert_eq!(2, ButtonStyle::Secondary as u8);
-    const_assert_eq!(3, ButtonStyle::Success as u8);
-    const_assert_eq!(4, ButtonStyle::Danger as u8);
-    const_assert_eq!(5, ButtonStyle::Link as u8);
 
     #[test]
     fn test_button_style() {
@@ -104,5 +127,6 @@ mod tests {
         serde_test::assert_tokens(&ButtonStyle::Success, &[Token::U8(3)]);
         serde_test::assert_tokens(&ButtonStyle::Danger, &[Token::U8(4)]);
         serde_test::assert_tokens(&ButtonStyle::Link, &[Token::U8(5)]);
+        serde_test::assert_tokens(&ButtonStyle::Unknown(6), &[Token::U8(6)]);
     }
 }

model/src/application/component/kind.rs

@@ -1,33 +1,60 @@
-use serde_repr::{Deserialize_repr, Serialize_repr};
+use serde::{Deserialize, Serialize};
 use std::fmt::{Display, Formatter, Result as FmtResult};
 
 /// Type of Component.
 ///
 /// See [Discord Docs/Message Components].
 ///
 /// [Discord Docs/Message Components]: https://discord.com/developers/docs/interactions/message-components#component-types
-#[derive(Clone, Copy, Debug, Deserialize_repr, Eq, Hash, PartialEq, Serialize_repr)]
-#[repr(u8)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, Serialize)]
+#[serde(from = "u8", into = "u8")]
 pub enum ComponentType {
     /// Component is an [`ActionRow`].
     ///
     /// [`ActionRow`]: super::ActionRow
-    ActionRow = 1,
+    ActionRow,
 
     /// Component is an [`Button`].
     ///
     /// [`Button`]: super::Button
-    Button = 2,
+    Button,
 
     /// Component is an [`SelectMenu`].
     ///
     /// [`SelectMenu`]: super::SelectMenu
-    SelectMenu = 3,
+    SelectMenu,
 
     /// Component is an [`TextInput`].
     ///
     /// [`TextInput`]: super::TextInput
-    TextInput = 4,
+    TextInput,
+
+    ///Variant value is unknown to the library.
+    Unknown(u8),
+}
+
+impl From<u8> for ComponentType {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => ComponentType::ActionRow,
+            2 => ComponentType::Button,
+            3 => ComponentType::SelectMenu,
+            4 => ComponentType::TextInput,
+            unknown => ComponentType::Unknown(unknown),
+        }
+    }
+}
+
+impl From<ComponentType> for u8 {
+    fn from(value: ComponentType) -> Self {
+        match value {
+            ComponentType::ActionRow => 1,
+            ComponentType::Button => 2,
+            ComponentType::SelectMenu => 3,
+            ComponentType::TextInput => 4,
+            ComponentType::Unknown(unknown) => unknown,
+        }
+    }
 }
 
 impl ComponentType {
@@ -52,6 +79,7 @@ impl ComponentType {
             Self::Button => "Button",
             Self::SelectMenu => "SelectMenu",
             Self::TextInput => "TextInput",
+            Self::Unknown(_) => "Unknown",
         }
     }
 }
@@ -67,7 +95,7 @@ mod tests {
     use super::*;
     use serde::{Deserialize, Serialize};
     use serde_test::Token;
-    use static_assertions::{assert_impl_all, const_assert_eq};
+    use static_assertions::assert_impl_all;
     use std::{fmt::Debug, hash::Hash};
 
     assert_impl_all!(
@@ -82,21 +110,22 @@ mod tests {
         Serialize,
         Sync
     );
-    const_assert_eq!(1, ComponentType::ActionRow as u8);
-    const_assert_eq!(2, ComponentType::Button as u8);
-    const_assert_eq!(3, ComponentType::SelectMenu as u8);
 
     #[test]
     fn test_variants() {
         serde_test::assert_tokens(&ComponentType::ActionRow, &[Token::U8(1)]);
         serde_test::assert_tokens(&ComponentType::Button, &[Token::U8(2)]);
         serde_test::assert_tokens(&ComponentType::SelectMenu, &[Token::U8(3)]);
+        serde_test::assert_tokens(&ComponentType::TextInput, &[Token::U8(4)]);
+        serde_test::assert_tokens(&ComponentType::Unknown(99), &[Token::U8(99)]);
     }
 
     #[test]
     fn test_names() {
         assert_eq!("ActionRow", ComponentType::ActionRow.name());
         assert_eq!("Button", ComponentType::Button.name());
         assert_eq!("SelectMenu", ComponentType::SelectMenu.name());
+        assert_eq!("TextInput", ComponentType::TextInput.name());
+        assert_eq!("Unknown", ComponentType::Unknown(99).name());
     }
 }