EventHandler::message_update with cache feature sends old message if available

4 files changed, 64 insertions, 27 deletions

diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 14e1a14..913fe21 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -578,6 +578,17 @@ impl Cache {
         })
     }
 
+    #[inline]
+    pub fn message<C, M>(&self, channel_id: C, user_id: M) -> Option<Message>
+        where C: Into<ChannelId>, M: Into<MessageId> {
+        self._message(channel_id.into(), user_id.into())
+    }
+
+    fn _message(&self, channel_id: ChannelId, message_id: MessageId) -> Option<Message> {
+        self.messages.get(&channel_id).and_then(|messages| {
+            messages.get(&message_id).cloned()
+        })
+    }
     /// Retrieves a [`PrivateChannel`] from the cache's [`private_channels`]
     /// map, if it exists.
     ///
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 04bd8c9..dd5b4fe 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -510,13 +510,25 @@ fn handle_event<H: EventHandler + Send + Sync + 'static>(
             });
         },
         DispatchEvent::Model(Event::MessageUpdate(mut event)) => {
-            update!(event);
+            let _before = update!(event);
+
+            let _after: Option<Message> = feature_cache! {{
+                CACHE.read().message(event.channel_id, event.id)
+            } else {
+                None
+            }};
 
             let context = context(data, runner_tx, shard_id);
             let event_handler = Arc::clone(event_handler);
 
             threadpool.execute(move || {
-                event_handler.message_update(context, event);
+                feature_cache! {{
+                    if let Some(after) = _after {
+                        event_handler.message_update(context, _before, after);
+                    }
+                } else {
+                    event_handler.message_update(context, event);
+                }}
             });
         },
         DispatchEvent::Model(Event::PresencesReplace(mut event)) => {
diff --git a/src/client/event_handler.rs b/src/client/event_handler.rs
index 32fdaa1..8100532 100644
--- a/src/client/event_handler.rs
+++ b/src/client/event_handler.rs
@@ -230,6 +230,13 @@ pub trait EventHandler {
     /// Dispatched when a message is updated.
     ///
     /// Provides the new data of the message.
+    #[cfg(feature = "cache")]
+    fn message_update(&self, _ctx: Context, _old_if_available: Option<Message>, _new: Message) {}
+
+    /// Dispatched when a message is updated.
+    ///
+    /// Provides the new data of the message.
+    #[cfg(not(feature = "cache"))]
     fn message_update(&self, _ctx: Context, _new_data: MessageUpdateEvent) {}
 
     fn presence_replace(&self, _ctx: Context, _: Vec<Presence>) {}
diff --git a/src/model/event.rs b/src/model/event.rs
index c4d13ff..ff4cceb 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -848,41 +848,48 @@ pub struct MessageUpdateEvent {
 
 #[cfg(feature = "cache")]
 impl CacheUpdate for MessageUpdateEvent {
-    type Output = ();
+    type Output = Message;
 
     fn update(&mut self, cache: &mut Cache) -> Option<Self::Output> {
-        let messages = cache.messages.get_mut(&self.channel_id)?;
-        let message = messages.get_mut(&self.id)?;
+        if let Some(messages) = cache.messages.get_mut(&self.channel_id) {
+            if let Some(message) = messages.get_mut(&self.id) {
+                let item = message.clone();
 
-        if let Some(attachments) = self.attachments.clone() {
-            message.attachments = attachments;
-        }
+                if let Some(attachments) = self.attachments.clone() {
+                    message.attachments = attachments;
+                }
 
-        if let Some(content) = self.content.clone() {
-            message.content = content;
-        }
+                if let Some(content) = self.content.clone() {
+                    message.content = content;
+                }
 
-        if let Some(edited_timestamp) = self.edited_timestamp {
-            message.edited_timestamp = Some(edited_timestamp);
-        }
+                if let Some(edited_timestamp) = self.edited_timestamp {
+                    message.edited_timestamp = Some(edited_timestamp);
+                }
 
-        if let Some(mentions) = self.mentions.clone() {
-            message.mentions = mentions;
-        }
+                if let Some(mentions) = self.mentions.clone() {
+                    message.mentions = mentions;
+                }
 
-        if let Some(mention_everyone) = self.mention_everyone {
-            message.mention_everyone = mention_everyone;
-        }
+                if let Some(mention_everyone) = self.mention_everyone {
+                    message.mention_everyone = mention_everyone;
+                }
 
-        if let Some(mention_roles) = self.mention_roles.clone() {
-            message.mention_roles = mention_roles;
-        }
+                if let Some(mention_roles) = self.mention_roles.clone() {
+                    message.mention_roles = mention_roles;
+                }
 
-        if let Some(pinned) = self.pinned {
-            message.pinned = pinned;
-        }
+                if let Some(pinned) = self.pinned {
+                    message.pinned = pinned;
+                }
 
-        None
+                Some(item)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
     }
 }