Message Grouping

Author: roobscoob

src/chat/src/message.rs

@@ -7,7 +7,8 @@ pub trait Message: Clone {
   fn get_nonce(&self) -> Option<&String>;
 }
 
-pub trait MessageAuthor {
+pub trait MessageAuthor: PartialEq + Eq {
   fn get_display_name(&self) -> impl Element;
   fn get_icon(&self) -> String;
+  fn get_id(&self) -> String;
 }

src/discord/src/client.rs

@@ -87,6 +87,7 @@ impl RawEventHandler for RawClient {
             user.get("id").unwrap().as_str().unwrap(),
             user.get("avatar").unwrap().as_str().unwrap()
           ),
+          id: user.get("id").unwrap().as_str().unwrap().to_owned(),
         });
       }
     }
@@ -107,6 +108,7 @@ impl EventHandler for DiscordClient {
           author: DiscordMessageAuthor {
             display_name: DisplayName(msg.author.name.clone()),
             icon: msg.author.avatar_url().unwrap_or(msg.author.default_avatar_url()),
+            id: msg.author.id.to_string(),
           },
           content: DiscordMessageContent {
             content: msg.content.clone(),

src/discord/src/message/author.rs

@@ -5,8 +5,16 @@ use scope_chat::message::MessageAuthor;
 pub struct DiscordMessageAuthor {
   pub display_name: DisplayName,
   pub icon: String,
+  pub id: String,
 }
 
+impl PartialEq for DiscordMessageAuthor {
+  fn eq(&self, other: &Self) -> bool {
+    self.id == other.id
+  }
+}
+impl Eq for DiscordMessageAuthor {}
+
 impl MessageAuthor for DiscordMessageAuthor {
   fn get_display_name(&self) -> impl Element {
     self.display_name.clone().into_element()
@@ -15,6 +23,10 @@ impl MessageAuthor for DiscordMessageAuthor {
   fn get_icon(&self) -> String {
     self.icon.clone()
   }
+
+  fn get_id(&self) -> String {
+    self.id.clone()
+  }
 }
 
 #[derive(Clone, IntoElement)]

src/ui/src/channel/message.rs

@@ -1,13 +1,63 @@
-use gpui::{div, img, rgb, IntoElement, ParentElement, Styled};
+use gpui::{div, img, rgb, Element, IntoElement, ParentElement, Styled};
 use scope_chat::message::{Message, MessageAuthor};
 
-pub fn message(message: impl Message) -> impl IntoElement {
+#[derive(Clone)]
+pub struct MessageGroup<M: Message> {
+  contents: Vec<M>,
+}
+
+impl<M: Message> MessageGroup<M> {
+  pub fn new(message: M) -> MessageGroup<M> {
+    MessageGroup { contents: vec![message] }
+  }
+
+  pub fn get_author<'s>(&'s self) -> &'s (impl MessageAuthor + 's) {
+    self.contents.get(0).unwrap().get_author()
+  }
+
+  pub fn add(&mut self, message: M) {
+    // FIXME: This is scuffed, should be using PartialEq trait.
+    if self.get_author().get_id() != message.get_author().get_id() {
+      panic!("Authors must match in a message group")
+    }
+
+    self.contents.push(message);
+  }
+
+  pub fn contents<'s>(&'s self) -> impl IntoIterator<Item = impl Element + 's> {
+    self.contents.iter().map(|v| v.get_content())
+  }
+
+  pub fn find_matching(&self, nonce: &String) -> Option<usize> {
+    for haystack in self.contents.iter().zip(0usize..) {
+      if haystack.0.get_nonce().is_some() && haystack.0.get_nonce().unwrap() == nonce {
+        return Some(haystack.1);
+      }
+    }
+
+    return None;
+  }
+
+  pub fn size(&self) -> usize {
+    self.contents.len()
+  }
+
+  pub fn remove(&mut self, index: usize) {
+    if self.size() == 1 {
+      panic!("Cannot remove such that it would leave the group empty.");
+    }
+
+    self.contents.remove(index);
+  }
+}
+
+pub fn message<M: Message>(message: MessageGroup<M>) -> impl IntoElement {
   div()
     .flex()
     .flex_row()
     .text_color(rgb(0xFFFFFF))
     .gap_2()
     .p_2()
     .child(img(message.get_author().get_icon()).object_fit(gpui::ObjectFit::Fill).bg(rgb(0xFFFFFF)).rounded_full().w_12().h_12())
-    .child(div().flex().flex_col().child(message.get_author().get_display_name()).child(message.get_content()))
+    .child(div().flex().flex_col().child(message.get_author().get_display_name()).child(div().children(message.contents())))
 }

src/ui/src/channel/message_list.rs

@@ -1,50 +1,65 @@
 use gpui::{div, IntoElement, ListAlignment, ListState, ParentElement, Pixels};
 
-use scope_chat::message::Message;
+use scope_chat::message::{Message, MessageAuthor};
 
-use super::message::message;
+use super::message::{message, MessageGroup};
 
 #[derive(Clone)]
 pub struct MessageList<M: Message + 'static> {
-  real_messages: Vec<M>,
-  pending_messages: Vec<M>,
+  messages: Vec<MessageGroup<M>>,
 }
 
 impl<M: Message> MessageList<M> {
   pub fn new() -> MessageList<M> {
-    Self {
-      real_messages: Vec::default(),
-      pending_messages: Vec::default(),
-    }
+    Self { messages: Vec::default() }
   }
 
   pub fn add_external_message(&mut self, message: M) {
-    if let Some((_, pending_index)) = self
-      .pending_messages
-      .iter()
-      .zip(0..)
-      .find(|(msg, _)| msg.get_nonce().map(|v1| message.get_nonce().map(|v2| v2 == v1).unwrap_or(false)).unwrap_or(false))
-    {
-      self.pending_messages.remove(pending_index);
+    if let Some(nonce) = message.get_nonce() {
+      let mut removal_index: Option<usize> = None;
+
+      for (group, index) in self.messages.iter_mut().zip(0..) {
+        let matching = group.find_matching(nonce);
+
+        if let Some(matching) = matching {
+          if group.size() == 1 {
+            removal_index = Some(index);
+          } else {
+            group.remove(matching);
+          }
+        }
+      }
+
+      if let Some(removal_index) = removal_index {
+        self.messages.remove(removal_index);
+      }
     }
 
-    self.real_messages.push(message);
+    let last = self.messages.last_mut();
+
+    if last.is_some() && last.as_ref().unwrap().get_author().get_id() == message.get_author().get_id() {
+      last.unwrap().add(message);
+    } else {
+      self.messages.push(MessageGroup::new(message));
+    }
   }
 
   pub fn add_pending_message(&mut self, pending_message: M) {
-    self.pending_messages.push(pending_message);
+    let last = self.messages.last_mut();
+
+    if last.is_some() && last.as_ref().unwrap().get_author().get_id() == pending_message.get_author().get_id() {
+      last.unwrap().add(pending_message);
+    } else {
+      self.messages.push(MessageGroup::new(pending_message));
+    }
   }
 
   pub fn length(&self) -> usize {
-    self.real_messages.len() + self.pending_messages.len()
+    self.messages.len()
   }
 
-  pub fn get(&self, index: usize) -> Option<&M> {
-    if index >= self.real_messages.len() {
-      self.pending_messages.get(index - self.real_messages.len())
-    } else {
-      self.real_messages.get(index)
-    }
+  pub fn get(&self, index: usize) -> Option<&MessageGroup<M>> {
+    self.messages.get(index)
   }
 
   pub fn create_list_state(&self) -> ListState {