feat(sdk,ui): Support edits as LatestEventValue.

This patch supports any edits at a possible `LatestEventValue`
candidate.

Author: Hywan

crates/matrix-sdk-ui/src/timeline/latest_event.rs

@@ -14,11 +14,17 @@
 
 use matrix_sdk::{Client, Room, latest_events::LocalLatestEventValue};
 use matrix_sdk_base::latest_event::LatestEventValue as BaseLatestEventValue;
-use ruma::{MilliSecondsSinceUnixEpoch, OwnedUserId};
+use ruma::{
+    MilliSecondsSinceUnixEpoch, OwnedUserId,
+    events::{
+        AnyMessageLikeEventContent, relation::Replacement, room::message::RoomMessageEventContent,
+    },
+};
 use tracing::trace;
 
 use crate::timeline::{
-    Profile, TimelineDetails, TimelineItemContent, event_handler::TimelineAction,
+    Profile, TimelineDetails, TimelineItemContent,
+    event_handler::{HandleAggregationKind, TimelineAction},
     traits::RoomDataProvider,
 };
 
@@ -92,7 +98,7 @@ impl LatestEventValue {
                     .map(TimelineDetails::Ready)
                     .unwrap_or(TimelineDetails::Unavailable);
 
-                let Some(TimelineAction::AddItem { content }) = TimelineAction::from_event(
+                match TimelineAction::from_event(
                     any_sync_timeline_event,
                     &raw_any_sync_timeline_event,
                     room,
@@ -102,11 +108,50 @@ impl LatestEventValue {
                     None,
                 )
                 .await
-                else {
-                    return Self::None;
-                };
+                {
+                    // Easy path: no aggregation, direct event.
+                    Some(TimelineAction::AddItem { content }) => {
+                        Self::Remote { timestamp, sender, is_own, profile, content }
+                    }
 
-                Self::Remote { timestamp, sender, is_own, profile, content }
+                    // Aggregated event.
+                    //
+                    // Only edits are supported for the moment.
+                    Some(TimelineAction::HandleAggregation {
+                        kind:
+                            HandleAggregationKind::Edit { replacement: Replacement { new_content, .. } },
+                        ..
+                    }) => {
+                        // Let's map the edit into a regular message.
+                        match TimelineAction::from_content(
+                            AnyMessageLikeEventContent::RoomMessage(RoomMessageEventContent::new(
+                                new_content.msgtype,
+                            )),
+                            // We don't care about the `InReplyToDetails` in the context of a
+                            // `LatestEventValue`.
+                            None,
+                            // We don't care about the thread information in the context of a
+                            // `LatestEventValue`.
+                            None,
+                            None,
+                        ) {
+                            // The expected case.
+                            TimelineAction::AddItem { content } => {
+                                Self::Remote { timestamp, sender, is_own, profile, content }
+                            }
+
+                            // Supposedly unreachable, but let's pretend there is no
+                            // `LatestEventValue` if it happens.
+                            _ => {
+                                trace!("latest event was an edit that failed to be un-aggregated");
+
+                                Self::None
+                            }
+                        }
+                    }
+
+                    _ => Self::None,
+                }
             }
             BaseLatestEventValue::LocalIsSending(LocalLatestEventValue {
                 timestamp,
@@ -209,7 +254,9 @@ mod tests {
             assert_matches!(profile, TimelineDetails::Unavailable);
             assert_matches!(
                 content,
-                TimelineItemContent::MsgLike(MsgLikeContent { kind: MsgLikeKind::Message(_), .. })
+                TimelineItemContent::MsgLike(MsgLikeContent { kind: MsgLikeKind::Message(message), .. }) => {
+                    assert_eq!(message.body(), "raclette");
+                }
             );
         })
     }
@@ -275,4 +322,38 @@ mod tests {
             assert!(is_sending.not());
         })
     }
+
+    #[async_test]
+    async fn test_remote_edit() {
+        let server = MatrixMockServer::new().await;
+        let client = server.client_builder().build().await;
+        let room = server.sync_room(&client, JoinedRoomBuilder::new(room_id!("!r0"))).await;
+        let sender = user_id!("@mnt_io:matrix.org");
+        let event_factory = EventFactory::new();
+
+        let base_value = BaseLatestEventValue::Remote(RemoteLatestEventValue::from_plaintext(
+            event_factory
+                .server_ts(42)
+                .sender(sender)
+                .text_msg("bonjour")
+                .event_id(event_id!("$ev1"))
+                .edit(event_id!("$ev0"), RoomMessageEventContent::text_plain("fondue").into())
+                .into_raw_sync(),
+        ));
+        let value =
+            LatestEventValue::from_base_latest_event_value(base_value, &room, &client).await;
+
+        assert_matches!(value, LatestEventValue::Remote { timestamp, sender: received_sender, is_own, profile, content } => {
+            assert_eq!(u64::from(timestamp.get()), 42u64);
+            assert_eq!(received_sender, sender);
+            assert!(is_own.not());
+            assert_matches!(profile, TimelineDetails::Unavailable);
+            assert_matches!(
+                content,
+                TimelineItemContent::MsgLike(MsgLikeContent { kind: MsgLikeKind::Message(message), .. }) => {
+                    assert_eq!(message.body(), "fondue");
+                }
+            );
+        })
+    }
 }

crates/matrix-sdk/src/latest_events/latest_event.rs

@@ -29,7 +29,6 @@ use ruma::{
     EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedTransactionId, TransactionId, UserId,
     events::{
         AnyMessageLikeEventContent, AnySyncStateEvent, AnySyncTimelineEvent, SyncStateEvent,
-        relation::RelationType,
         room::{member::MembershipState, message::MessageType, power_levels::RoomPowerLevels},
     },
 };
@@ -977,20 +976,7 @@ fn filter_any_message_like_event_content(event: AnyMessageLikeEventContent) -> b
                 return false;
             }
 
-            // Check if this is a replacement for another message. If it is, ignore
-            // it.
-            //
-            // TODO: if we want to support something like
-            // `LatestEventContent::EditedRoomMessage`, it's here :-].
-            let is_replacement = message.relates_to.as_ref().is_some_and(|relates_to| {
-                if let Some(relation_type) = relates_to.rel_type() {
-                    relation_type == RelationType::Replacement
-                } else {
-                    false
-                }
-            });
-
-            !is_replacement
+            true
         }
 
         AnyMessageLikeEventContent::UnstablePollStart(_)
@@ -1124,7 +1110,7 @@ mod tests_latest_event_content {
                     .edit(event_id!("$ev0"), RoomMessageEventContent::text_plain("hello").into())
                     .into_event()
             }
-            is not a candidate
+            is a candidate
         );
     }