refactor(timeline): rename RepliedToEvent to EmbeddedEvent and reuse it for the thread summary

Author: bnjbvr

bindings/matrix-sdk-ffi/src/timeline/msg_like.rs

@@ -254,6 +254,7 @@ impl ThreadSummary {
 
 #[derive(Clone, uniffi::Enum)]
 #[allow(clippy::large_enum_variant)]
+// TODO: unify with the FFI replied-to-event-details
 pub enum ThreadSummaryLatestEventDetails {
     Unavailable,
     Pending,

crates/matrix-sdk-ui/src/timeline/controller/mod.rs

@@ -69,8 +69,8 @@ use super::{
     subscriber::TimelineSubscriber,
     threaded_events_loader::ThreadedEventsLoader,
     traits::{Decryptor, RoomDataProvider},
-    DateDividerMode, Error, EventSendState, EventTimelineItem, InReplyToDetails, PaginationError,
-    Profile, RepliedToEvent, TimelineDetails, TimelineEventItemId, TimelineFocus, TimelineItem,
+    DateDividerMode, EmbeddedEvent, Error, EventSendState, EventTimelineItem, InReplyToDetails,
+    PaginationError, Profile, TimelineDetails, TimelineEventItemId, TimelineFocus, TimelineItem,
     TimelineItemContent, TimelineItemKind, VirtualTimelineItem,
 };
 use crate::{
@@ -1338,20 +1338,20 @@ impl<P: RoomDataProvider, D: Decryptor> TimelineController<P, D> {
         txn.commit();
     }
 
-    /// Create a [`RepliedToEvent`] from an arbitrary event, be it in the
+    /// Create a [`EmbeddedEvent`] from an arbitrary event, be it in the
     /// timeline or not.
     ///
     /// Can be `None` if the event cannot be represented as a standalone item,
     /// because it's an aggregation.
     pub(super) async fn make_replied_to(
         &self,
         event: TimelineEvent,
-    ) -> Result<Option<RepliedToEvent>, Error> {
+    ) -> Result<Option<EmbeddedEvent>, Error> {
         // Reborrow, to avoid that the automatic deref borrows the entire guard (and we
         // can't borrow both items and meta).
         let state = &mut *self.state.write().await;
 
-        RepliedToEvent::try_from_timeline_event(
+        EmbeddedEvent::try_from_timeline_event(
             event,
             &self.room_data_provider,
             &state.items,
@@ -1562,9 +1562,9 @@ async fn fetch_replied_to_event(
     msglike: &MsgLikeContent,
     in_reply_to: &EventId,
     room: &Room,
-) -> Result<TimelineDetails<Box<RepliedToEvent>>, Error> {
+) -> Result<TimelineDetails<Box<EmbeddedEvent>>, Error> {
     if let Some((_, item)) = rfind_event_by_id(&state_guard.items, in_reply_to) {
-        let details = TimelineDetails::Ready(Box::new(RepliedToEvent::from_timeline_item(&item)));
+        let details = TimelineDetails::Ready(Box::new(EmbeddedEvent::from_timeline_item(&item)));
         trace!("Found replied-to event locally");
         return Ok(details);
     };
@@ -1589,7 +1589,7 @@ async fn fetch_replied_to_event(
         Ok(timeline_event) => {
             let state = &mut *state_lock.write().await;
 
-            let replied_to_item = RepliedToEvent::try_from_timeline_event(
+            let replied_to_item = EmbeddedEvent::try_from_timeline_event(
                 timeline_event,
                 room,
                 &state.items,

crates/matrix-sdk-ui/src/timeline/controller/state_transaction.rs

@@ -37,7 +37,7 @@ use super::{
 };
 use crate::timeline::{
     event_handler::{FailedToParseEvent, RemovedItem, TimelineAction},
-    ThreadSummary, ThreadSummaryLatestEvent, TimelineDetails, VirtualTimelineItem,
+    EmbeddedEvent, ThreadSummary, TimelineDetails, VirtualTimelineItem,
 };
 
 pub(in crate::timeline) struct TimelineStateTransaction<'a> {
@@ -558,21 +558,19 @@ impl<'a> TimelineStateTransaction<'a> {
         let TimelineEvent { push_actions, kind, thread_summary } = event;
 
         let thread_summary = if let Some(summary) = thread_summary.summary() {
-            let latest_reply_item =
-                if let Some(event_id) = summary.latest_reply.as_ref() {
-                    // Attempt to load the timeline event, either from the event cache or the
-                    // storage.
-                    let event = room_data_provider
-                        .load_event(event_id)
-                        .await
-                        .inspect_err(|err| {
-                            warn!("Failed to load thread latest event: {err}");
-                        })
-                        .ok();
-
-                    if let Some(event) = event {
-                        // lol @ hack
-                        crate::timeline::RepliedToEvent::try_from_timeline_event(
+            let latest_reply_item = if let Some(event_id) = summary.latest_reply.as_ref() {
+                // Attempt to load the timeline event, either from the event cache or the
+                // storage.
+                let event = room_data_provider
+                    .load_event(event_id)
+                    .await
+                    .inspect_err(|err| {
+                        warn!("Failed to load thread latest event: {err}");
+                    })
+                    .ok();
+
+                if let Some(event) = event {
+                    EmbeddedEvent::try_from_timeline_event(
                         event,
                         room_data_provider,
                         &self.items,
@@ -584,17 +582,13 @@ impl<'a> TimelineStateTransaction<'a> {
                     })
                     .ok()
                     .flatten()
-                    .map(|replied_to| Box::new(ThreadSummaryLatestEvent {
-                        content: replied_to.content().clone(),
-                        sender: replied_to.sender().to_owned(),
-                        sender_profile: replied_to.sender_profile().clone(),
-                    }))
-                    } else {
-                        None
-                    }
+                    .map(Box::new)
                 } else {
                     None
-                };
+                }
+            } else {
+                None
+            };
 
             Some(ThreadSummary {
                 latest_event: TimelineDetails::from_initial_value(latest_reply_item),

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

@@ -56,8 +56,8 @@ use super::{
         TimelineEventItemId,
     },
     traits::RoomDataProvider,
-    EncryptedMessage, EventTimelineItem, InReplyToDetails, MsgLikeContent, MsgLikeKind, OtherState,
-    ReactionStatus, RepliedToEvent, Sticker, ThreadSummary, TimelineDetails, TimelineItem,
+    EmbeddedEvent, EncryptedMessage, EventTimelineItem, InReplyToDetails, MsgLikeContent,
+    MsgLikeKind, OtherState, ReactionStatus, Sticker, ThreadSummary, TimelineDetails, TimelineItem,
     TimelineItemContent,
 };
 use crate::timeline::controller::aggregations::PendingEdit;
@@ -1205,7 +1205,7 @@ impl<'a, 'o> TimelineEventHandler<'a, 'o> {
             trace!(reply_event_id = ?event_item.identifier(), "Updating response to updated event");
             let in_reply_to = InReplyToDetails {
                 event_id: in_reply_to.event_id.clone(),
-                event: TimelineDetails::Ready(Box::new(RepliedToEvent::from_timeline_item(
+                event: TimelineDetails::Ready(Box::new(EmbeddedEvent::from_timeline_item(
                     new_item,
                 ))),
             };

crates/matrix-sdk-ui/src/timeline/event_item/content/mod.rs

@@ -71,9 +71,9 @@ pub(in crate::timeline) use self::message::{
 };
 pub use self::{
     message::Message,
-    msg_like::{MsgLikeContent, MsgLikeKind, ThreadSummary, ThreadSummaryLatestEvent},
+    msg_like::{MsgLikeContent, MsgLikeKind, ThreadSummary},
     polls::{PollResult, PollState},
-    reply::{InReplyToDetails, RepliedToEvent},
+    reply::{EmbeddedEvent, InReplyToDetails},
 };
 use super::ReactionsByKeyBySender;
 

crates/matrix-sdk-ui/src/timeline/event_item/content/msg_like.rs

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 use as_variant::as_variant;
-use ruma::{OwnedEventId, OwnedUserId};
+use ruma::OwnedEventId;
 
-use super::{EncryptedMessage, InReplyToDetails, Message, PollState, Sticker, TimelineItemContent};
-use crate::timeline::{Profile, ReactionsByKeyBySender, TimelineDetails};
+use super::{EmbeddedEvent, EncryptedMessage, InReplyToDetails, Message, PollState, Sticker};
+use crate::timeline::{ReactionsByKeyBySender, TimelineDetails};
 
 #[derive(Clone, Debug)]
 pub enum MsgLikeKind {
@@ -38,7 +38,7 @@ pub enum MsgLikeKind {
 
 #[derive(Clone, Debug)]
 pub struct ThreadSummary {
-    pub latest_event: TimelineDetails<Box<ThreadSummaryLatestEvent>>,
+    pub latest_event: TimelineDetails<Box<EmbeddedEvent>>,
 
     /// The number of events in the thread, except for the thread root.
     ///
@@ -50,13 +50,6 @@ pub struct ThreadSummary {
     pub num_replies: usize,
 }
 
-#[derive(Clone, Debug)]
-pub struct ThreadSummaryLatestEvent {
-    pub content: TimelineItemContent,
-    pub sender: OwnedUserId,
-    pub sender_profile: TimelineDetails<Profile>,
-}
-
 /// A special kind of [`super::TimelineItemContent`] that groups together
 /// different room message types with their respective reactions and thread
 /// information.

crates/matrix-sdk-ui/src/timeline/event_item/content/reply.rs

@@ -40,7 +40,7 @@ pub struct InReplyToDetails {
     /// unavailable.
     ///
     /// [`Timeline::fetch_details_for_event`]: crate::Timeline::fetch_details_for_event
-    pub event: TimelineDetails<Box<RepliedToEvent>>,
+    pub event: TimelineDetails<Box<EmbeddedEvent>>,
 }
 
 impl InReplyToDetails {
@@ -52,21 +52,26 @@ impl InReplyToDetails {
             .iter()
             .filter_map(|it| it.as_event())
             .find(|it| it.event_id() == Some(&*event_id))
-            .map(|item| Box::new(RepliedToEvent::from_timeline_item(item)));
+            .map(|item| Box::new(EmbeddedEvent::from_timeline_item(item)));
 
         InReplyToDetails { event_id, event: TimelineDetails::from_initial_value(event) }
     }
 }
 
-/// An event that is replied to.
+/// An event that is embedded in another event, such as a replied-to event, or a
+/// thread latest event.
 #[derive(Clone, Debug)]
-pub struct RepliedToEvent {
-    content: TimelineItemContent,
-    sender: OwnedUserId,
-    sender_profile: TimelineDetails<Profile>,
+pub struct EmbeddedEvent {
+    /// The content of the embedded item.
+    pub content: TimelineItemContent,
+    /// The user ID of the sender of the related embedded event.
+    pub sender: OwnedUserId,
+    /// The profile of the sender of the related embedded event.
+    pub sender_profile: TimelineDetails<Profile>,
 }
 
-impl RepliedToEvent {
+impl EmbeddedEvent {
+    // TODO: remove public getters
     /// Get the message of this event.
     pub fn content(&self) -> &TimelineItemContent {
         &self.content
@@ -82,7 +87,7 @@ impl RepliedToEvent {
         &self.sender_profile
     }
 
-    /// Create a [`RepliedToEvent`] from a loaded event timeline item.
+    /// Create a [`EmbeddedEvent`] from a loaded event timeline item.
     pub fn from_timeline_item(timeline_item: &EventTimelineItem) -> Self {
         Self {
             content: timeline_item.content.clone(),

crates/matrix-sdk-ui/src/timeline/event_item/mod.rs

@@ -51,10 +51,10 @@ pub(super) use self::{
 };
 pub use self::{
     content::{
-        AnyOtherFullStateEventContent, EncryptedMessage, InReplyToDetails, MemberProfileChange,
-        MembershipChange, Message, MsgLikeContent, MsgLikeKind, OtherState, PollResult, PollState,
-        RepliedToEvent, RoomMembershipChange, RoomPinnedEventsChange, Sticker, ThreadSummary,
-        ThreadSummaryLatestEvent, TimelineItemContent,
+        AnyOtherFullStateEventContent, EmbeddedEvent, EncryptedMessage, InReplyToDetails,
+        MemberProfileChange, MembershipChange, Message, MsgLikeContent, MsgLikeKind, OtherState,
+        PollResult, PollState, RoomMembershipChange, RoomPinnedEventsChange, Sticker,
+        ThreadSummary, TimelineItemContent,
     },
     local::EventSendState,
 };

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

@@ -85,12 +85,12 @@ pub use self::{
     controller::default_event_filter,
     error::*,
     event_item::{
-        AnyOtherFullStateEventContent, EncryptedMessage, EventItemOrigin, EventSendState,
-        EventTimelineItem, InReplyToDetails, MemberProfileChange, MembershipChange, Message,
-        MsgLikeContent, MsgLikeKind, OtherState, PollResult, PollState, Profile, ReactionInfo,
-        ReactionStatus, ReactionsByKeyBySender, RepliedToEvent, RoomMembershipChange,
-        RoomPinnedEventsChange, Sticker, ThreadSummary, ThreadSummaryLatestEvent, TimelineDetails,
-        TimelineEventItemId, TimelineItemContent,
+        AnyOtherFullStateEventContent, EmbeddedEvent, EncryptedMessage, EventItemOrigin,
+        EventSendState, EventTimelineItem, InReplyToDetails, MemberProfileChange, MembershipChange,
+        Message, MsgLikeContent, MsgLikeKind, OtherState, PollResult, PollState, Profile,
+        ReactionInfo, ReactionStatus, ReactionsByKeyBySender, RoomMembershipChange,
+        RoomPinnedEventsChange, Sticker, ThreadSummary, TimelineDetails, TimelineEventItemId,
+        TimelineItemContent,
     },
     event_type_filter::TimelineEventTypeFilter,
     item::{TimelineItem, TimelineItemKind, TimelineUniqueId},
@@ -715,15 +715,15 @@ impl Timeline {
         }
     }
 
-    /// Create a [`RepliedToEvent`] from an arbitrary event, be it in the
+    /// Create a [`EmbeddedEvent`] from an arbitrary event, be it in the
     /// timeline or not.
     ///
     /// Can be `None` if the event cannot be represented as a standalone item,
     /// because it's an aggregation.
     pub async fn make_replied_to(
         &self,
         event: TimelineEvent,
-    ) -> Result<Option<RepliedToEvent>, Error> {
+    ) -> Result<Option<EmbeddedEvent>, Error> {
         self.controller.make_replied_to(event).await
     }
 }