feat: add / remove reactions

Author: Bloeckchengrafik

Cargo.lock

@@ -10,3 +10,4 @@ gpui = { git = "https://github.com/scopeclient/zed.git", branch = "feature/expor
 ] }
 components = { package = "ui", git = "https://github.com/scopeclient/components", version = "0.1.0" }
 reqwest_client = { git = "https://github.com/scopeclient/zed.git", branch = "feature/export-platform-window", version = "0.1.0" }
+atomic_refcell = "0.1.13"

Cargo.toml

@@ -7,3 +7,4 @@ edition = "2021"
 tokio = "1.41.1"
 chrono.workspace = true
 gpui.workspace = true
+atomic_refcell.workspace = true

src/chat/Cargo.toml

@@ -1,5 +1,7 @@
 use std::fmt::{Debug, Formatter};
-use gpui::{IntoElement, Rgba};
+use std::sync::Arc;
+use atomic_refcell::AtomicRefCell;
+use gpui::{App, IntoElement, Rgba};
 
 pub type ReactionEvent<T> = (T, ReactionOperation);
 
@@ -43,9 +45,9 @@ pub enum ReactionOperation {
   RemoveEmoji(ReactionEmoji),
 }
 
-pub trait ReactionList: IntoElement {
-  fn get_reactions(&self) -> &Vec<impl MessageReaction>;
-  fn get_reaction(&self, emoji: &ReactionEmoji) -> Option<&impl MessageReaction>;
+pub trait ReactionList {
+  fn get_reactions(&self) -> &Arc<AtomicRefCell<Vec<impl MessageReaction>>>;
   fn increment(&mut self, emoji: &ReactionEmoji, kind: MessageReactionType, user_is_self: bool, by: isize);
   fn apply(&mut self, operation: ReactionOperation);
+  fn get_content(&self, cx: &mut App) -> impl IntoElement;
 }

src/chat/src/reaction.rs

@@ -14,7 +14,7 @@ scope-backend-cache = { version = "0.1.0", path = "../cache" }
 url = "2.5.3"
 querystring = "1.1.0"
 catty = "0.1.5"
-atomic_refcell = "0.1.13"
+atomic_refcell.workspace = true
 rand = "0.8.5"
 dashmap = "6.1.0"
 log = "0.4.22"

src/discord/Cargo.toml

@@ -76,7 +76,7 @@ impl Channel for DiscordChannel {
         sent_time: Utc::now(),
         list_item_id: Snowflake::random(),
       },
-      content: OnceLock::new(),
+      content: Arc::new(OnceLock::new()),
     }
   }
 

src/discord/src/channel/mod.rs

@@ -56,7 +56,6 @@ impl DiscordClient {
     let client = Arc::new_cyclic(|weak| DiscordClient {
       ready_notifier: AtomicRefCell::new(Some(sender)),
       weak: weak.clone(),
-
       ..Default::default()
     });
 
@@ -147,18 +146,26 @@ impl DiscordClient {
     }
   }
 
-  pub async fn add_reaction(&self, channel_id: ChannelId, message_id: MessageId, emoji: ReactionEmoji) {
-    let reaction_type = match emoji {
+  fn emoji_to_serenity(emoji: &ReactionEmoji) -> ReactionType {
+    match emoji.clone() {
       ReactionEmoji::Simple(c) => ReactionType::Unicode(c),
       ReactionEmoji::Custom { name, animated, id, .. } => ReactionType::Custom {
         id: EmojiId::new(id),
         animated,
         name,
       },
-    };
+    }
+  }
 
+  pub async fn add_reaction(&self, channel_id: ChannelId, message_id: MessageId, emoji: ReactionEmoji) {
+    let reaction_type = Self::emoji_to_serenity(&emoji);
     channel_id.create_reaction(self.discord().http.clone(), message_id, reaction_type).await.unwrap();
   }
+
+  pub async fn remove_reaction(&self, channel_id: ChannelId, message_id: MessageId, emoji: ReactionEmoji) {
+    let reaction_type = Self::emoji_to_serenity(&emoji);
+    channel_id.delete_reaction(self.discord().http.clone(), message_id, None, reaction_type).await.unwrap();
+  }
 }
 
 #[async_trait]

src/discord/src/client.rs

@@ -2,6 +2,7 @@ use crate::message::reaction_list::DiscordReactionList;
 use gpui::prelude::FluentBuilder;
 use gpui::{div, Context, IntoElement, ParentElement, Render, Styled, Window};
 use serenity::all::Message;
+use scope_chat::reaction::ReactionList;
 
 #[derive(Clone, Debug)]
 pub struct DiscordMessageContent {
@@ -29,10 +30,10 @@ impl DiscordMessageContent {
 }
 
 impl Render for DiscordMessageContent {
-  fn render(&mut self, _: &mut Window, _: &mut Context<DiscordMessageContent>) -> impl IntoElement {
+  fn render(&mut self, _: &mut Window, cx: &mut Context<DiscordMessageContent>) -> impl IntoElement {
     div()
       .opacity(if self.is_pending { 0.25 } else { 1.0 })
       .child(self.content.clone())
-      .when_some(self.reactions.clone(), |d, reactions| d.child(reactions))
+      .when_some(self.reactions.clone(), |d, reactions| d.child(reactions.get_content(cx)))
   }
 }

src/discord/src/message/content.rs

@@ -24,15 +24,19 @@ pub enum DiscordMessageData {
     sent_time: DateTime<Utc>,
     list_item_id: Snowflake,
   },
-  Received(Arc<serenity::model::channel::Message>, Option<Arc<serenity::model::guild::Member>>, DiscordReactionList),
+  Received(
+    Arc<serenity::model::channel::Message>,
+    Option<Arc<serenity::model::guild::Member>>,
+    DiscordReactionList,
+  ),
 }
 
 #[derive(Clone)]
 pub struct DiscordMessage {
   pub client: Arc<DiscordClient>,
   pub channel: Arc<serenity::model::channel::Channel>,
   pub data: DiscordMessageData,
-  pub content: OnceLock<Entity<DiscordMessageContent>>,
+  pub content: Arc<OnceLock<Entity<DiscordMessageContent>>>,
 }
 
 impl DiscordMessage {
@@ -45,13 +49,13 @@ impl DiscordMessage {
     }
     .unwrap();
 
-    let reactions = DiscordReactionList::new_serenity(msg.reactions.clone(), channel.id(), msg.id.clone(), client.clone());
+    let reactions = DiscordReactionList::new(msg.reactions.clone(), channel.id(), msg.id.clone(), client.clone());
 
     Self {
       client,
       channel,
       data: DiscordMessageData::Received(msg, member, reactions),
-      content: OnceLock::new(),
+      content: Arc::new(OnceLock::new()),
     }
   }
 
@@ -61,12 +65,12 @@ impl DiscordMessage {
     channel: Arc<serenity::model::channel::Channel>,
     member: Option<Arc<serenity::model::guild::Member>>,
   ) -> Self {
-    let reactions = DiscordReactionList::new_serenity(msg.reactions.clone(), channel.id(), msg.id.clone(), client.clone());
+    let reactions = DiscordReactionList::new(msg.reactions.clone(), channel.id(), msg.id.clone(), client.clone());
     Self {
       client,
       channel,
       data: DiscordMessageData::Received(msg, member, reactions),
-      content: OnceLock::new(),
+      content: Arc::new(OnceLock::new()),
     }
   }
 }
@@ -129,18 +133,18 @@ impl Message for DiscordMessage {
   }
 
   // TODO: want reviewer discussion. I'm really stretching the abilities of gpui here and im not sure if this is the right way to do this.
+  // Additional Context to this discussion: the OnceLock in context CANNOT be cloned because it messes with the internal gpui entityids
+  // and recreates the entity on every interaction making it impossible to interact with the message content in any way. Right now, I'm
+  // using an arc for this, but this feels like a band-aid solution. I do agree that this should be refactored out at some point.
   fn get_content(&self, cx: &mut App) -> Entity<Self::Content> {
     self
       .content
       .get_or_init(|| {
-        let content = match &self.data {
+        cx.new(|_| match &self.data {
           DiscordMessageData::Pending { content, .. } => DiscordMessageContent::pending(content.clone()),
           DiscordMessageData::Received(message, _, reactions) => DiscordMessageContent::received(message, reactions),
-        };
-
-        cx.new(|_| content)
-      })
-      .clone()
+        })
+      }).clone()
   }
 
   fn get_identifier(&self) -> Option<Snowflake> {

src/discord/src/message/mod.rs

@@ -1,10 +1,12 @@
+use crate::client::DiscordClient;
 use components::theme::ActiveTheme;
 use gpui::prelude::FluentBuilder;
-use gpui::{div, img, px, AnyElement, App, IntoElement, ParentElement, RenderOnce, Rgba, Styled};
+use gpui::{div, img, px, AnyElement, App, InteractiveElement, IntoElement, ParentElement, RenderOnce, Rgba, StatefulInteractiveElement, Styled};
 use scope_chat::reaction::MessageReactionType::Normal;
 use scope_chat::reaction::{MessageReaction, MessageReactionType, ReactionEmoji};
-use serenity::all::ReactionType;
+use serenity::all::{ChannelId, MessageId, ReactionType};
 use std::fmt::Debug;
+use std::sync::Arc;
 use MessageReactionType::Burst;
 
 #[derive(Clone, Debug)]
@@ -35,15 +37,21 @@ impl ReactionData {
   }
 }
 
-#[derive(Clone, Debug, IntoElement)]
+#[derive(Clone, IntoElement)]
 pub struct DiscordMessageReaction {
   pub data: ReactionData,
+  pub(crate) client: Arc<DiscordClient>,
+  pub(crate) message_id: MessageId,
+  pub(crate) channel_id: ChannelId,
 }
 
 impl DiscordMessageReaction {
-  pub fn from_message(reaction: &serenity::all::MessageReaction) -> Self {
+  pub fn new(reaction: &serenity::all::MessageReaction, client: Arc<DiscordClient>, message_id: MessageId, channel_id: ChannelId) -> Self {
     DiscordMessageReaction {
       data: ReactionData::Message(reaction.clone()),
+      client,
+      message_id,
+      channel_id,
     }
   }
 
@@ -71,6 +79,18 @@ impl DiscordMessageReaction {
       ReactionEmoji::Custom { url, .. } => img(url.clone()).w(px(16f32)).h(px(16f32)).into_any_element(),
     }
   }
+
+  fn handle_click(&self, app: &App) {
+    let reaction = self.clone();
+    let had_reaction = reaction.get_self_reaction().is_some();
+    app.spawn(|_| async move {
+      if had_reaction {
+        reaction.client.remove_reaction(reaction.channel_id, reaction.message_id, reaction.get_emoji()).await;
+      } else {
+        reaction.client.add_reaction(reaction.channel_id, reaction.message_id, reaction.get_emoji()).await;
+      }
+    }).detach();
+  }
 }
 
 impl MessageReaction for DiscordMessageReaction {
@@ -165,6 +185,10 @@ impl RenderOnce for DiscordMessageReaction {
       .gap_1()
       .child(Self::render_emoji(&emoji))
       .child(self.get_count(None).to_string())
+      .id("reaction")
+      .on_click(move |_, _, app| {
+        self.handle_click(app);
+      })
   }
 }
 
@@ -183,3 +207,9 @@ pub fn discord_reaction_to_emoji(reaction: &ReactionType) -> ReactionEmoji {
     }
   }
 }
+
+impl Debug for DiscordMessageReaction {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    f.debug_struct("DiscordMessageReaction").field("data", &self.data).finish()
+  }
+}