macltok

public

Star0

Fork 0

Watch0

69 commits 3 branches 0 tags 0 releases3.0 MiB

Commit `cb7b3362e1ce`

tarball

atagen <boss@atagen.co>2026-10-25 09:30 UTC

7 files changed+479-187

context: restore what the focused timeline gave event context

Raw /messages pages lost sender profiles, showed edits, reactions and redactions as rows of their own and left replies Pending forever. Pages now fold in-page edits and reactions into their targets, hide thread replies as the live timeline does, take profiles from room members and settle every reply from the page or a fetch. Truncating to the limit while handing back the server's end token skipped events, so pages are no longer cut.

Modified file: src/engine/context.rs+208 additions−159 deletions@@ -1,15 +1,17 @@
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
 
-use matrix_sdk::{
-    Room, deserialized_responses::TimelineEvent as SdkTimelineEvent, room::MessagesOptions,
-};
-use ruma::{OwnedEventId, OwnedUserId, RoomId, UInt};
+use futures_util::future::{join_all, try_join};
+use matrix_sdk::{Room, room::MessagesOptions};
+use ruma::{OwnedEventId, OwnedUserId, UInt};
+use serde_json::Value;
 
 use crate::{
-    Error, ErrorKind, EventContext, EventContextCommand, EventContextDirection, EventContextPage,
-    TimelineItem,
+    Error, ErrorKind, EventContext, EventContextCommand, EventContextPage, MediaId, Sender,
+    TimelineEvent, TimelineItem,
     engine::MediaService,
-    normalise::{MediaRegistration, normalise_observed},
+    normalise::{
+        MediaRegistration, apply_profiles, normalise_context, normalise_observed, resolve_replies,
+    },
 };
 
 const MAX_CONTEXT_LIMIT: u16 = 50;
@@ -20,44 +22,42 @@ pub(crate) async fn execute(
     media: Arc<MediaService>,
     command: EventContextCommand,
 ) -> Result<crate::CommandOutput, Error> {
-    if let EventContextCommand::Before { token, limit, .. }
-    | EventContextCommand::After { token, limit, .. } = &command
-    {
-        validate_limit(*limit)?;
-        if token.is_empty() {
-            return Err(Error::new(
-                ErrorKind::Invalid,
-                "context pagination token is empty",
-            ));
-        }
-        return execute_page(
-            room,
-            current_user_id,
-            media,
-            token,
-            *limit,
-            matches!(command, EventContextCommand::Before { .. }),
-        )
-        .await;
-    }
-
-    let (event_id, before_limit, after_limit) = match &command {
+    let (token, limit, backwards) = match command {
         EventContextCommand::Fetch {
             event_id,
             before_limit,
             after_limit,
             ..
         } => {
-            validate_limit(*before_limit)?;
-            validate_limit(*after_limit)?;
-            (event_id.clone(), *before_limit, *after_limit)
+            let (context, registrations, _) =
+                capture(room, current_user_id, event_id, before_limit, after_limit).await?;
+            media.register(registrations).await;
+            return Ok(crate::CommandOutput::EventContext(context));
         }
-        EventContextCommand::Before { .. } | EventContextCommand::After { .. } => unreachable!(),
+        EventContextCommand::Before { token, limit, .. } => (token, limit, true),
+        EventContextCommand::After { token, limit, .. } => (token, limit, false),
     };
-    let (context, registrations, _) =
-        capture(room, current_user_id, event_id, before_limit, after_limit).await?;
-    media.register(registrations).await;
-    Ok(crate::CommandOutput::EventContext(context))
+    if limit == 0 {
+        return Err(Error::new(
+            ErrorKind::Invalid,
+            "context page limit must be at least 1",
+        ));
+    }
+    validate_limit(limit)?;
+    if token.is_empty() {
+        return Err(Error::new(
+            ErrorKind::Invalid,
+            "context pagination token is empty",
+        ));
+    }
+    let side = fetch_side(&room, Some(&token), limit, backwards).await?;
+    let mut page = Assembly::new(&room, current_user_id.as_deref(), &side.values, None).await;
+    let events = page.take(0..side.values.len());
+    media.register(page.media).await;
+    Ok(crate::CommandOutput::EventContextPage(EventContextPage {
+        events,
+        next_token: side.token,
+    }))
 }
 
 pub(crate) async fn capture(
@@ -66,7 +66,7 @@ pub(crate) async fn capture(
     event_id: OwnedEventId,
     before_limit: u16,
     after_limit: u16,
-) -> Result<(EventContext, Vec<MediaRegistration>, Vec<serde_json::Value>), Error> {
+) -> Result<(EventContext, Vec<MediaRegistration>, Vec<Value>), Error> {
     validate_limit(before_limit)?;
     validate_limit(after_limit)?;
     let raw = room
@@ -84,76 +84,70 @@ pub(crate) async fn capture(
                 error
             }
         })?;
-    if raw.event.is_none() {
-        return Err(Error::new(ErrorKind::EventNotFound, "event was not found"));
-    }
-    let before = fetch_side(
-        &room,
-        raw.prev_batch_token.as_deref(),
-        before_limit,
-        true,
-        current_user_id.as_deref(),
-    );
-    let after = fetch_side(
-        &room,
-        raw.next_batch_token.as_deref(),
-        after_limit,
-        false,
-        current_user_id.as_deref(),
-    );
-    let (events_before, mut before_media, start_token, mut observed) = before.await?;
-    let (events_after, after_media, end_token, following) = after.await?;
-    observed.extend(following);
-    if let Some(value) = raw
+    let target = raw
         .event
         .as_ref()
-        .and_then(|event| serde_json::from_str(event.raw().json().get()).ok())
-    {
-        observed.push(value);
-    }
-    let event = raw.event.as_ref().and_then(|event| {
-        normalise_sdk_event(event, current_user_id.as_deref(), room.room_id()).map(
-            |(item, media)| {
-                before_media.extend(media);
-                item
-            },
-        )
-    });
-    before_media.extend(after_media);
+        .and_then(|event| serde_json::from_str::<Value>(event.raw().json().get()).ok())
+        .ok_or_else(|| Error::new(ErrorKind::EventNotFound, "event was not found"))?;
+    let (before, after) = try_join(
+        fetch_side(&room, raw.prev_batch_token.as_deref(), before_limit, true),
+        fetch_side(&room, raw.next_batch_token.as_deref(), after_limit, false),
+    )
+    .await?;
+    let target_index = before.values.len();
+    let mut values = before.values;
+    values.push(target);
+    values.extend(after.values);
+    let mut page = Assembly::new(
+        &room,
+        current_user_id.as_deref(),
+        &values,
+        Some(target_index),
+    )
+    .await;
+    let events_before = page.take(0..target_index);
+    let event = page
+        .take(target_index..target_index + 1)
+        .pop()
+        .ok_or_else(|| Error::new(ErrorKind::EventNotFound, "event could not be read"))?;
+    let events_after = page.take(target_index + 1..values.len());
     Ok((
         EventContext {
             events_before,
             event,
             events_after,
-            start_token,
-            end_token,
+            start_token: before.token,
+            end_token: after.token,
         },
-        before_media,
-        observed,
+        page.media,
+        values,
     ))
 }
 
+struct Side {
+    /// in timeline order
+    values: Vec<Value>,
+    token: Option<String>,
+}
+
 async fn fetch_side(
     room: &Room,
     token: Option<&str>,
     limit: u16,
     backwards: bool,
-    current_user_id: Option<&ruma::UserId>,
-) -> Result<
-    (
-        Vec<TimelineItem>,
-        Vec<MediaRegistration>,
-        Option<String>,
-        Vec<serde_json::Value>,
-    ),
-    Error,
-> {
-    if limit == 0 {
-        return Ok((Vec::new(), Vec::new(), token.map(str::to_owned), Vec::new()));
-    }
+) -> Result<Side, Error> {
     let Some(token) = token else {
-        return Ok((Vec::new(), Vec::new(), None, Vec::new()));
+        return Ok(Side {
+            values: Vec::new(),
+            token: None,
+        });
     };
+    if limit == 0 {
+        return Ok(Side {
+            values: Vec::new(),
+            token: Some(token.to_owned()),
+        });
+    }
     let mut options = if backwards {
         MessagesOptions::backward()
     } else {
@@ -165,87 +159,142 @@ async fn fetch_side(
         .messages(options)
         .await
         .map_err(|source| Error::from_sdk("fetching event context events failed", source))?;
-    let mut events = messages.chunk;
-    events.truncate(usize::from(limit));
-    if backwards {
-        events.reverse();
-    }
-    let next_token = messages.end;
-    let observed = events
+    let mut values: Vec<Value> = messages
+        .chunk
         .iter()
         .filter_map(|event| serde_json::from_str(event.raw().json().get()).ok())
         .collect();
-    let (items, media) = normalise_events(events, current_user_id, room.room_id());
-    Ok((items, media, next_token, observed))
-}
-
-async fn execute_page(
-    room: Room,
-    current_user_id: Option<OwnedUserId>,
-    media: Arc<MediaService>,
-    token: &str,
-    limit: u16,
-    backwards: bool,
-) -> Result<crate::CommandOutput, Error> {
-    let mut options = if backwards {
-        MessagesOptions::backward()
-    } else {
-        MessagesOptions::forward()
-    };
-    options = options.from(token);
-    options.limit = UInt::from(limit);
-    let messages = room
-        .messages(options)
-        .await
-        .map_err(|source| Error::from_sdk("fetching event context page failed", source))?;
-    let next_token = messages.end.clone();
-    let mut events = messages.chunk;
-    events.truncate(usize::from(limit));
     if backwards {
-        events.reverse();
+        values.reverse();
     }
-    let (events, registrations) =
-        normalise_events(events, current_user_id.as_deref(), room.room_id());
-    media.register(registrations).await;
-    let end_reached = next_token.is_none();
-    let direction = if backwards {
-        EventContextDirection::Before
-    } else {
-        EventContextDirection::After
-    };
-    Ok(crate::CommandOutput::EventContextPage(EventContextPage {
-        direction,
-        events,
-        next_token,
-        end_reached,
-    }))
+    Ok(Side {
+        values,
+        token: messages.end,
+    })
 }
 
-fn normalise_events(
-    events: Vec<SdkTimelineEvent>,
-    current_user_id: Option<&ruma::UserId>,
-    room_id: &RoomId,
-) -> (Vec<TimelineItem>, Vec<MediaRegistration>) {
-    let mut items = Vec::with_capacity(events.len());
-    let mut media = Vec::new();
-    for event in events {
-        if let Some((item, registrations)) = normalise_sdk_event(&event, current_user_id, room_id) {
-            items.push(item);
+/// a window of raw events normalised together, so relations inside it land on their targets
+struct Assembly {
+    items: Vec<(usize, TimelineItem)>,
+    media: Vec<MediaRegistration>,
+}
+
+impl Assembly {
+    async fn new(
+        room: &Room,
+        current_user_id: Option<&ruma::UserId>,
+        values: &[Value],
+        keep: Option<usize>,
+    ) -> Self {
+        let page = normalise_context(values, keep, current_user_id, room.room_id());
+        let mut items = page.items;
+        let mut media = page.media;
+        let mut targets: HashMap<OwnedEventId, TimelineEvent> = HashMap::new();
+        let mut missing = Vec::new();
+        for (_, item) in &items {
+            if let TimelineItem::Event(event) = item
+                && let Some(event_id) = &event.event_id
+            {
+                targets.insert(event_id.clone(), (**event).clone());
+            }
+        }
+        for event in events(&mut items) {
+            if let Some(reply) = &event.reply_to
+                && !targets.contains_key(&reply.event_id)
+                && !missing.contains(&reply.event_id)
+            {
+                missing.push(reply.event_id.clone());
+            }
+        }
+        let fetched = join_all(
+            missing
+                .into_iter()
+                .map(|event_id| fetch_reply(room, current_user_id, event_id)),
+        )
+        .await;
+        for (event, registrations) in fetched.into_iter().flatten() {
             media.extend(registrations);
+            if let Some(event_id) = event.event_id.clone() {
+                targets.insert(event_id, event);
+            }
         }
+        let profiles = profiles(
+            room,
+            items
+                .iter()
+                .filter_map(|(_, item)| match item {
+                    TimelineItem::Event(event) => Some(&event.sender.user_id),
+                    _ => None,
+                })
+                .chain(targets.values().map(|event| &event.sender.user_id)),
+        )
+        .await;
+        apply_profiles(targets.values_mut(), &profiles);
+        apply_profiles(events(&mut items), &profiles);
+        resolve_replies(events(&mut items), &targets);
+        Self { items, media }
     }
-    (items, media)
+
+    /// the items that came from raw events in `range`
+    fn take(&mut self, range: std::ops::Range<usize>) -> Vec<TimelineItem> {
+        let (taken, kept) = std::mem::take(&mut self.items)
+            .into_iter()
+            .partition(|(index, _)| range.contains(index));
+        self.items = kept;
+        taken.into_iter().map(|(_, item)| item).collect()
+    }
+}
+
+fn events(items: &mut [(usize, TimelineItem)]) -> impl Iterator<Item = &mut TimelineEvent> {
+    items.iter_mut().filter_map(|(_, item)| match item {
+        TimelineItem::Event(event) => Some(&mut **event),
+        _ => None,
+    })
 }
 
-fn normalise_sdk_event(
-    event: &SdkTimelineEvent,
+async fn fetch_reply(
+    room: &Room,
     current_user_id: Option<&ruma::UserId>,
-    room_id: &RoomId,
-) -> Option<(TimelineItem, Vec<MediaRegistration>)> {
-    let value: serde_json::Value = serde_json::from_str(event.raw().json().get()).ok()?;
-    let event_id = value.get("event_id")?.as_str()?;
-    let identity = format!("{room_id}\n{event_id}");
-    normalise_observed(&value, current_user_id, &identity)
+    event_id: OwnedEventId,
+) -> Option<(TimelineEvent, Vec<MediaRegistration>)> {
+    let event = room
+        .load_or_fetch_event(&event_id, None)
+        .await
+        .inspect_err(|error| tracing::debug!(%event_id, %error, "fetching a reply target failed"))
+        .ok()?;
+    let value: Value = serde_json::from_str(event.raw().json().get()).ok()?;
+    let identity = format!("{}\n{event_id}", room.room_id());
+    match normalise_observed(&value, current_user_id, &identity)? {
+        (TimelineItem::Event(event), media) => Some((*event, media)),
+        _ => None,
+    }
+}
+
+/// under lazy-loaded members a sender may be unknown locally, and `get_member` fetches the
+/// member list once for the room when it is
+async fn profiles<'a>(
+    room: &Room,
+    user_ids: impl Iterator<Item = &'a OwnedUserId>,
+) -> HashMap<OwnedUserId, Sender> {
+    let mut unique: Vec<&OwnedUserId> = user_ids.collect();
+    unique.sort();
+    unique.dedup();
+    join_all(unique.into_iter().map(|user_id| async move {
+        let member = room.get_member(user_id).await.ok().flatten()?;
+        Some((
+            user_id.clone(),
+            Sender {
+                user_id: user_id.clone(),
+                display_name: member.display_name().map(str::to_owned),
+                avatar: member.avatar_url().map(MediaId::plain),
+                name_ambiguous: member.name_ambiguous(),
+            },
+        ))
+    }))
+    .await
+    .into_iter()
+    .flatten()
+    .collect()
 }
 
 fn validate_limit(limit: u16) -> Result<(), Error> {

Modified file: src/lib.rs+9 additions−9 deletions@@ -57,15 +57,15 @@ pub use mirror::{
 pub use model::{
     AccountCommand, AttachmentEncryption, AttachmentUpload, Change, Command, CommandOutput,
     ConnectionState, CreateRoomOptions, EncryptionCommand, EncryptionState, EngineErrorKind,
-    EngineFailure, Event, EventContext, EventContextCommand, EventContextDirection,
-    EventContextPage, EventRef, HistoryState, ImagePack, ImagePackSource, ImagePacks,
-    KeyBackupState, LatestEvent, LifecycleCommand, LinkPreview, LinkPreviewImage, Media,
-    MediaCommand, MediaDescriptor, MediaFile, MediaId, MediaKind, MediaLocation, MediaSize,
-    MemberFilter, MemberMembership, MemberSummary, MembershipChange, Message, MessageContent,
-    MessageEditContent, MessageKind, MessageMentions, NotificationCommand, OwnDevice, PackCommand,
-    PackImage, PackImageInfo, PackUsage, Patch, PowerLevelChanges, Profile, PushNotification,
-    PushNotificationEvent, PushNotificationRoom, PushNotificationSender, PushNotificationStatus,
-    Reaction, RecentHistoryState, RecoveryState, ReplyDetails, ReplyReference, Retain, RichText,
+    EngineFailure, Event, EventContext, EventContextCommand, EventContextPage, EventRef,
+    HistoryState, ImagePack, ImagePackSource, ImagePacks, KeyBackupState, LatestEvent,
+    LifecycleCommand, LinkPreview, LinkPreviewImage, Media, MediaCommand, MediaDescriptor,
+    MediaFile, MediaId, MediaKind, MediaLocation, MediaSize, MemberFilter, MemberMembership,
+    MemberSummary, MembershipChange, Message, MessageContent, MessageEditContent, MessageKind,
+    MessageMentions, NotificationCommand, OwnDevice, PackCommand, PackImage, PackImageInfo,
+    PackUsage, Patch, PowerLevelChanges, Profile, PushNotification, PushNotificationEvent,
+    PushNotificationRoom, PushNotificationSender, PushNotificationStatus, Reaction,
+    RecentHistoryState, RecoveryState, ReplyDetails, ReplyReference, Retain, RichText,
     RoomCategory, RoomCommand, RoomHero, RoomListFilter, RoomMatcher, RoomMembership,
     RoomNotificationMode, RoomNotificationSettings, RoomPowerLevels, RoomPreset, RoomSummary,
     RoomVisibility, SendState, Sender, SpaceChild, Termination, ThreadSummary, TimelineCommand,

Modified file: src/mentions/state_tests.rs+1−1

@@ -257,7 +257,7 @@ async fn context_uses_the_redacted_saved_event_instead_of_the_entry_preview() {

257257 );

258258

259259 let (context, media) = data.context(&mention).unwrap();

260- let saved = context.context.unwrap().event.unwrap();

260+ let saved = context.context.unwrap().event;

261261 let TimelineItem::Event(saved) = saved else {

262262 panic!("the saved target should remain a timeline event");

263263 };

Modified file: src/model.rs+2 additions−10 deletions@@ -679,27 +679,19 @@ pub enum CommandOutput {
 #[non_exhaustive]
 pub struct EventContext {
     pub events_before: Vec<TimelineItem>,
-    pub event: Option<TimelineItem>,
+    pub event: TimelineItem,
     pub events_after: Vec<TimelineItem>,
     pub start_token: Option<String>,
     pub end_token: Option<String>,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub enum EventContextDirection {
-    Before,
-    After,
-}
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[non_exhaustive]
 pub struct EventContextPage {
-    pub direction: EventContextDirection,
     pub events: Vec<TimelineItem>,
+    /// `None` once that end of the room is reached
     pub next_token: Option<String>,
-    pub end_reached: bool,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]

Added file: src/normalise/context.rs+249 additions@@ -0,0 +1,249 @@
+use std::collections::HashMap;
+
+use ruma::{MxcUri, OwnedEventId, OwnedUserId, RoomId, UserId};
+use serde_json::Value;
+
+use super::{media::MediaRegistration, observed::normalise_observed};
+use crate::{MediaId, Reaction, ReplyDetails, Sender, TimelineEvent, TimelineItem};
+
+pub(crate) struct ContextPage {
+    /// each with the index of the raw event it came from
+    pub(crate) items: Vec<(usize, TimelineItem)>,
+    pub(crate) media: Vec<MediaRegistration>,
+}
+
+struct Annotation<'a> {
+    key: &'a str,
+    sender: &'a str,
+    shortcode: Option<&'a str>,
+}
+
+/// raw events in timeline order, shown the way the live room timeline shows them. edits and
+/// reactions fold into their targets within the page, and redactions, unmatched relations
+/// and thread replies go. `keep` is never dropped
+pub(crate) fn normalise_context(
+    values: &[Value],
+    keep: Option<usize>,
+    current_user_id: Option<&UserId>,
+    room_id: &RoomId,
+) -> ContextPage {
+    let mut edits: HashMap<&str, Vec<&Value>> = HashMap::new();
+    let mut annotations: HashMap<&str, Vec<Annotation<'_>>> = HashMap::new();
+    let mut shown = Vec::new();
+    for (index, value) in values.iter().enumerate() {
+        let str_at = |pointer: &str| value.pointer(pointer).and_then(Value::as_str);
+        let target = str_at("/content/m.relates_to/event_id");
+        if Some(index) == keep {
+            shown.push(index);
+            continue;
+        }
+        match (
+            str_at("/type"),
+            str_at("/content/m.relates_to/rel_type"),
+            target,
+        ) {
+            (Some("m.room.redaction"), ..) => {}
+            (Some("m.reaction"), Some("m.annotation"), Some(target)) => {
+                if let (Some(key), Some(sender)) =
+                    (str_at("/content/m.relates_to/key"), str_at("/sender"))
+                {
+                    annotations.entry(target).or_default().push(Annotation {
+                        key,
+                        sender,
+                        shortcode: str_at("/content/com.beeper.reaction.shortcode")
+                            .or_else(|| str_at("/content/shortcode")),
+                    });
+                }
+            }
+            (Some("m.reaction"), ..) => {}
+            (_, Some("m.replace"), Some(target)) => edits.entry(target).or_default().push(value),
+            (_, Some("m.thread"), _) => {}
+            _ => shown.push(index),
+        }
+    }
+    let mut media = Vec::new();
+    let items = shown
+        .into_iter()
+        .filter_map(|index| {
+            let mut value = std::borrow::Cow::Borrowed(&values[index]);
+            let event_id = value.get("event_id")?.as_str()?.to_owned();
+            let latest_edit = edits.get(event_id.as_str()).and_then(|edits| {
+                edits
+                    .iter()
+                    .rev()
+                    .find(|edit| edit.get("sender") == value.get("sender"))
+            });
+            if let Some(edit) = latest_edit.copied()
+                && value.pointer("/unsigned/m.relations/m.replace").is_none()
+            {
+                let unsigned = value
+                    .to_mut()
+                    .as_object_mut()?
+                    .entry("unsigned")
+                    .or_insert_with(|| Value::Object(Default::default()));
+                let relations = unsigned
+                    .as_object_mut()?
+                    .entry("m.relations")
+                    .or_insert_with(|| Value::Object(Default::default()));
+                relations
+                    .as_object_mut()?
+                    .insert("m.replace".to_owned(), edit.clone());
+            }
+            let identity = format!("{room_id}\n{event_id}");
+            let (mut item, registrations) = normalise_observed(&value, current_user_id, &identity)?;
+            media.extend(registrations);
+            if let (TimelineItem::Event(event), Some(annotations)) =
+                (&mut item, annotations.get(event_id.as_str()))
+            {
+                event.reactions = reactions(annotations, current_user_id);
+            }
+            Some((index, item))
+        })
+        .collect();
+    ContextPage { items, media }
+}
+
+fn reactions(annotations: &[Annotation<'_>], current_user_id: Option<&UserId>) -> Vec<Reaction> {
+    let mut reactions: Vec<Reaction> = Vec::new();
+    for annotation in annotations {
+        let Ok(sender) = OwnedUserId::try_from(annotation.sender) else {
+            continue;
+        };
+        let index = match reactions.iter().position(|r| r.key == annotation.key) {
+            Some(index) => index,
+            None => {
+                reactions.push(Reaction {
+                    key: annotation.key.to_owned(),
+                    shortcode: None,
+                    image: <&MxcUri>::from(annotation.key)
+                        .is_valid()
+                        .then(|| MediaId::plain(annotation.key)),
+                    count: 0,
+                    own: false,
+                    senders: Vec::new(),
+                });
+                reactions.len() - 1
+            }
+        };
+        let reaction = &mut reactions[index];
+        if reaction.senders.contains(&sender) {
+            continue;
+        }
+        reaction.own |= current_user_id == Some(sender.as_ref());
+        reaction.senders.push(sender);
+        reaction.count = reaction.senders.len();
+        if reaction.shortcode.is_none() {
+            reaction.shortcode = annotation.shortcode.map(str::to_owned);
+        }
+    }
+    reactions
+}
+
+/// the sender's member data, for each event and every reply quoted in it
+pub(crate) fn apply_profiles<'a>(
+    events: impl Iterator<Item = &'a mut TimelineEvent>,
+    profiles: &HashMap<OwnedUserId, Sender>,
+) {
+    for event in events {
+        if let Some(sender) = profiles.get(&event.sender.user_id) {
+            event.sender = sender.clone();
+        }
+    }
+}
+
+/// settles every reply, from `targets` or as unavailable
+pub(crate) fn resolve_replies<'a>(
+    events: impl Iterator<Item = &'a mut TimelineEvent>,
+    targets: &HashMap<OwnedEventId, TimelineEvent>,
+) {
+    for event in events {
+        let Some(reply) = event.reply_to.as_mut() else {
+            continue;
+        };
+        if !matches!(reply.details, ReplyDetails::Pending) {
+            continue;
+        }
+        reply.details = match targets.get(&reply.event_id) {
+            Some(target) => ReplyDetails::Ready {
+                sender: target.sender.clone(),
+                content: Box::new(target.content.clone()),
+                timestamp_ms: target.timestamp_ms,
+            },
+            None => ReplyDetails::Unavailable,
+        };
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use ruma::{room_id, user_id};
+    use serde_json::json;
+
+    use super::*;
+    use crate::TimelineContent;
+
+    fn message(id: &str, sender: &str, body: &str) -> Value {
+        json!({
+            "type": "m.room.message",
+            "event_id": id,
+            "sender": sender,
+            "origin_server_ts": 1,
+            "content": { "msgtype": "m.text", "body": body },
+        })
+    }
+
+    #[test]
+    fn edits_and_reactions_fold_into_their_targets() {
+        let mut edit = message("$edit", "@a:x", "* fixed");
+        edit["content"]["m.new_content"] = json!({ "msgtype": "m.text", "body": "fixed" });
+        edit["content"]["m.relates_to"] = json!({ "rel_type": "m.replace", "event_id": "$orig" });
+        let mut foreign_edit = message("$foreign", "@b:x", "* hijack");
+        foreign_edit["content"]["m.new_content"] = json!({ "msgtype": "m.text", "body": "hijack" });
+        foreign_edit["content"]["m.relates_to"] =
+            json!({ "rel_type": "m.replace", "event_id": "$orig" });
+        let reaction = |id: &str, sender: &str| {
+            json!({
+                "type": "m.reaction",
+                "event_id": id,
+                "sender": sender,
+                "origin_server_ts": 1,
+                "content": { "m.relates_to": {
+                    "rel_type": "m.annotation", "event_id": "$orig", "key": "👍",
+                }},
+            })
+        };
+        let mut threaded = message("$threaded", "@b:x", "in a thread");
+        threaded["content"]["m.relates_to"] =
+            json!({ "rel_type": "m.thread", "event_id": "$orig" });
+        let values = [
+            message("$orig", "@a:x", "typo"),
+            edit,
+            foreign_edit,
+            reaction("$r1", "@b:x"),
+            reaction("$r2", "@b:x"),
+            reaction("$r3", "@a:x"),
+            threaded,
+            json!({
+                "type": "m.room.redaction",
+                "event_id": "$redaction",
+                "sender": "@a:x",
+                "origin_server_ts": 1,
+                "redacts": "$gone",
+                "content": {},
+            }),
+        ];
+        let page = normalise_context(&values, None, Some(user_id!("@a:x")), room_id!("!room:x"));
+        assert_eq!(page.items.len(), 1);
+        let TimelineItem::Event(event) = &page.items[0].1 else {
+            panic!("expected an event");
+        };
+        let TimelineContent::Message(message) = &event.content else {
+            panic!("expected a message");
+        };
+        assert_eq!(message.body, "fixed");
+        assert!(message.edited);
+        assert_eq!(event.reactions.len(), 1);
+        assert_eq!(event.reactions[0].count, 2);
+        assert!(event.reactions[0].own);
+    }
+}

Modified file: src/normalise/mod.rs+2

@@ -1,3 +1,4 @@

1+mod context;

12 mod image_pack;

23 mod link_preview;

34 mod media;

@@ -6,6 +7,7 @@ mod observed;

67 mod room;

78 mod timeline;

10+pub(crate) use context::{apply_profiles, normalise_context, resolve_replies};

911 pub(crate) use image_pack::{

1012 ENABLED_ROOMS, ROOM_PACKS, USER_PACK, can_edit_packs, image_packs, resolve_pack_id, stored_pack,

1113 };

Modified file: src/transport.rs+8 additions−8 deletions@@ -362,15 +362,15 @@ impl ClientHandle {
         &self,
         room_id: &RoomId,
         event_id: &EventId,
-        before_limit: u32,
-        after_limit: u32,
+        before_limit: u16,
+        after_limit: u16,
     ) -> Result<EventContext, Error> {
         match self
             .execute(Command::EventContext(EventContextCommand::Fetch {
                 room_id: room_id.to_owned(),
                 event_id: event_id.to_owned(),
-                before_limit: before_limit.min(50) as u16,
-                after_limit: after_limit.min(50) as u16,
+                before_limit,
+                after_limit,
             }))
             .await?
         {
@@ -383,11 +383,11 @@ impl ClientHandle {
         &self,
         room_id: &RoomId,
         token: &str,
-        limit: u32,
+        limit: u16,
     ) -> Result<EventContextPage, Error> {
         self.event_context_page(EventContextCommand::Before {
             room_id: room_id.to_owned(),
-            limit: limit.min(50) as u16,
+            limit,
             token: token.to_owned(),
         })
         .await
@@ -397,11 +397,11 @@ impl ClientHandle {
         &self,
         room_id: &RoomId,
         token: &str,
-        limit: u32,
+        limit: u16,
     ) -> Result<EventContextPage, Error> {
         self.event_context_page(EventContextCommand::After {
             room_id: room_id.to_owned(),
-            limit: limit.min(50) as u16,
+            limit,
             token: token.to_owned(),
         })
         .await

macltok

Commit cb7b3362e1ce

Commit `cb7b3362e1ce`