fix builders, test, fixedstring, type resolved variant of media items

Author: jamesbt365

examples/e01_basic_ping_bot/Cargo.toml

@@ -5,7 +5,5 @@ authors = ["my name <[email protected]>"]
 edition.workspace = true
 
 [dependencies]
-serde_json = "1.0.139"
 serenity = { path = "../../", default-features = false, features = ["gateway", "model", "rustls_backend"] }
-tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
-tracing-subscriber = "0.3.19"
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

examples/e01_basic_ping_bot/src/main.rs

@@ -7,64 +7,51 @@ struct Handler;
 
 #[async_trait]
 impl EventHandler for Handler {
+    // Set a handler for the `message` event. This is called whenever a new message is received.
+    //
+    // Event handlers are dispatched through a threadpool, and so multiple events can be dispatched
+    // simultaneously.
     async fn message(&self, ctx: Context, msg: Message) {
-        if msg.content == "mtest" {
-            let display = serenity::all::CreateTextDisplay::new("test");
-            let thumbnail = serenity::all::CreateThumbnail::new(serenity::all::CreateUnfurledMediaItem::new("https://cdn.discordapp.com/avatars/158567567487795200/9aa2a84b9c7b3b147ebe88e799e535d3.webp?size=4096"));
-
-            let section = serenity::all::CreateSection::new(
-                vec![serenity::all::CreateSectionComponent::TextDisplay(display)],
-                serenity::all::CreateSectionAccessory::Thumbnail(thumbnail),
-            );
-
-            let components = serenity::all::CreateComponent::Section(section);
-
-            let builder = serenity::all::CreateMessage::new()
-                .flags(serenity::all::MessageFlags::IS_COMPONENTS_V2)
-                .components(vec![components]);
-
-            if let Err(why) = msg.channel_id.send_message(&ctx.http, builder).await {
+        if msg.content == "!ping" {
+            // Sending a message can fail, due to a network error, an authentication error, or lack
+            // of permissions to post in the channel, so log to stdout when some error happens,
+            // with a description of it.
+            if let Err(why) = msg.channel_id.say(&ctx.http, "Pong!").await {
                 println!("Error sending message: {why:?}");
             }
         }
     }
 
+    // Set a handler to be called on the `ready` event. This is called when a shard is booted, and
+    // a READY payload is sent by Discord. This payload contains data like the current user's guild
+    // Ids, current user data, private channels, and more.
+    //
+    // In this case, just print what the current user's username is.
     async fn ready(&self, _: Context, ready: Ready) {
         println!("{} is connected!", ready.user.name);
-
-        let display = serenity::all::CreateTextDisplay::new("test");
-        let button = serenity::all::CreateButton::new("h").label("test");
-
-        let section = serenity::all::CreateSection::new(
-            vec![serenity::all::CreateSectionComponent::TextDisplay(display)],
-            serenity::all::CreateSectionAccessory::Button(button),
-        );
-
-        let components = serenity::all::CreateComponent::Section(section);
-
-        let builder = serenity::all::CreateMessage::new()
-            .flags(serenity::all::MessageFlags::IS_COMPONENTS_V2)
-            .components(vec![components]);
-
-        let json = serde_json::to_string_pretty(&builder).unwrap();
-
-        println!("{json}");
     }
 }
 
 #[tokio::main]
 async fn main() {
-    tracing_subscriber::fmt::init();
+    // Configure the client with your Discord bot token in the environment.
     let token =
         Token::from_env("DISCORD_TOKEN").expect("Expected a valid token in the environment");
+    // Set gateway intents, which decides what events the bot will be notified about
     let intents = GatewayIntents::GUILD_MESSAGES
         | GatewayIntents::DIRECT_MESSAGES
         | GatewayIntents::MESSAGE_CONTENT;
 
+    // Create a new instance of the Client, logging in as a bot. This will automatically prepend
+    // your bot token with "Bot ", which is a requirement by Discord for bot users.
     let mut client =
         Client::builder(token, intents).event_handler(Handler).await.expect("Err creating client");
 
+    // Finally, start a single shard, and start listening to events.
+    //
+    // Shards will automatically attempt to reconnect, and will perform exponential backoff until
+    // it reconnects.
     if let Err(why) = client.start().await {
         println!("Client error: {why:?}");
     }
-}
+}

src/builder/create_components.rs

@@ -65,6 +65,12 @@ pub enum CreateComponent<'a> {
     ActionRow(CreateActionRow<'a>),
     /// A section, V2 component.
     Section(CreateSection<'a>),
+    TextDisplay(CreateTextDisplay<'a>),
+    Thumbnail(CreateThumbnail<'a>),
+    MediaGallery(CreateMediaGallery<'a>),
+    File(CreateFile<'a>),
+    Separator(CreateSeparator),
+    Container(CreateContainer<'a>),
 }
 
 #[derive(Clone, Debug, Serialize)]
@@ -78,7 +84,6 @@ pub struct CreateSection<'a> {
 }
 
 impl<'a> CreateSection<'a> {
-    // TODO: change type
     pub fn new(
         components: impl Into<Cow<'a, [CreateSectionComponent<'a>]>>,
         accessory: CreateSectionAccessory<'a>,
@@ -190,18 +195,18 @@ impl<'a> CreateUnfurledMediaItem<'a> {
 pub struct CreateMediaGallery<'a> {
     #[serde(rename = "type")]
     kind: StaticU8<12>,
-    items: Cow<'a, [CreateSectionComponent<'a>]>,
+    items: Cow<'a, [CreateMediaGalleryItem<'a>]>,
 }
 
 impl<'a> CreateMediaGallery<'a> {
-    pub fn new(items: impl Into<Cow<'a, [CreateSectionComponent<'a>]>>) -> Self {
+    pub fn new(items: impl Into<Cow<'a, [CreateMediaGalleryItem<'a>]>>) -> Self {
         CreateMediaGallery {
             kind: StaticU8::<12>,
             items: items.into(),
         }
     }
 
-    pub fn items(mut self, items: impl Into<Cow<'a, [CreateSectionComponent<'a>]>>) -> Self {
+    pub fn items(mut self, items: impl Into<Cow<'a, [CreateMediaGalleryItem<'a>]>>) -> Self {
         self.items = items.into();
         self
     }
@@ -217,6 +222,31 @@ pub struct CreateMediaGalleryItem<'a> {
     spoiler: Option<bool>,
 }
 
+impl<'a> CreateMediaGalleryItem<'a> {
+    pub fn new(media: CreateUnfurledMediaItem<'a>) -> Self {
+        CreateMediaGalleryItem {
+            media,
+            description: None,
+            spoiler: None,
+        }
+    }
+
+    pub fn media(mut self, media: CreateUnfurledMediaItem<'a>) -> Self {
+        self.media = media;
+        self
+    }
+
+    pub fn description(mut self, description: impl Into<Cow<'a, str>>) -> Self {
+        self.description = Some(description.into());
+        self
+    }
+
+    pub fn spoiler(mut self, spoiler: bool) -> Self {
+        self.spoiler = Some(spoiler);
+        self
+    }
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[must_use]
 pub struct CreateFile<'a> {

src/model/application/component.rs

@@ -1,3 +1,4 @@
+use nonmax::NonMaxU32;
 use serde::de::Error as DeError;
 use serde::ser::{Serialize, Serializer};
 use serde_json::from_value;
@@ -52,10 +53,6 @@ pub enum Component {
 
 // TODO: add something like this to every variant.
 // The component type, it will always be [`ComponentType::Thing`].
-// #[serde(rename = "type")]
-// pub kind: ComponentType,
-
-// TODO: use fixedstring is places i missed when i find suitable lengths
 
 // Define the macro to implement Deserialize
 macro_rules! impl_deserialize_component {
@@ -119,15 +116,50 @@ pub struct Section {
 #[non_exhaustive]
 pub struct Thumbnail {
     media: UnfurledMediaItem,
-    description: Option<String>,
+    description: Option<FixedString<u16>>,
     spoiler: Option<bool>,
 }
 
+#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[non_exhaustive]
+#[serde(untagged)]
+pub enum MediaItem {
+    Resolved(ResolvedUnfurledMediaItem),
+    Unresolved(UnfurledMediaItem),
+}
+
 #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[non_exhaustive]
 pub struct UnfurledMediaItem {
-    url: String,
+    url: FixedString<u16>,
+}
+
+#[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[non_exhaustive]
+pub struct ResolvedUnfurledMediaItem {
+    url: FixedString<u16>,
+    proxy_url: FixedString<u16>,
+    width: NonMaxU32,
+    height: NonMaxU32,
+    content_type: FixedString,
+    loading_state: UnfurledMediaItemLoadingState,
+}
+
+enum_number! {
+    /// The loading state of the media item.
+    #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd, Deserialize, Serialize)]
+    #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
+    #[non_exhaustive]
+    pub enum UnfurledMediaItemLoadingState {
+        DiscordUnknown = 0,
+        Loading = 1,
+        LoadingSuccess = 2,
+        LoadingNotFound = 3,
+        _ => Unknown(u8),
+    }
 }
 
 #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
@@ -158,7 +190,7 @@ pub enum SectionComponent {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 #[non_exhaustive]
 pub struct TextDisplay {
-    content: String,
+    content: FixedString<u16>,
 }
 
 #[cfg_attr(feature = "typesize", derive(typesize::derive::TypeSize))]
@@ -173,7 +205,7 @@ pub struct MediaGallery {
 #[non_exhaustive]
 pub struct MediaGalleryItem {
     media: UnfurledMediaItem,
-    description: Option<String>,
+    description: Option<FixedString<u16>>,
     spoiler: Option<bool>,
 }