mirror/matrix-rust-sdk
1
0
Fork 0
mirror of https://github.com/matrix-org/matrix-rust-sdk.git synced 2026-05-08 07:56:55 -04:00
Code Issues Packages Projects Releases Wiki Activity

chore(base): Rename fields of RoomUpdate.

Browse Source 
This patch renames the fields in `RoomUpdate`: `join` becomes `joined`,
`leave` becomes `left`, `invite` becomes `invited`, to match their
associate type.
This commit is contained in:
Ivan Enderlin
2025-04-14 17:56:38 +02:00
parent 2479339c46
commit bad1c683f8
10 changed files with 67 additions and 67 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
crates/matrix-sdk-base/src/client.rs
View File

@@ -563,7 +563,7 @@ impl BaseClient {
)
.await?;
new_rooms.join.insert(room_id, joined_room_update);
new_rooms.joined.insert(room_id, joined_room_update);
}
for (room_id, left_room) in response.rooms.leave {
@@ -589,7 +589,7 @@ impl BaseClient {
)
.await?;
new_rooms.leave.insert(room_id, left_room_update);
new_rooms.left.insert(room_id, left_room_update);
}
for (room_id, invited_room) in response.rooms.invite {
@@ -607,7 +607,7 @@ impl BaseClient {
)
.await?;
new_rooms.invite.insert(room_id, invited_room_update);
new_rooms.invited.insert(room_id, invited_room_update);
}
for (room_id, knocked_room) in response.rooms.knock {

52
crates/matrix-sdk-base/src/sliding_sync.rs
View File

@@ -181,13 +181,13 @@ impl BaseClient {
match room_update {
RoomUpdateKind::Joined(joined_room_update) => {
room_updates.join.insert(room_id, joined_room_update);
room_updates.joined.insert(room_id, joined_room_update);
}
RoomUpdateKind::Left(left_room_update) => {
room_updates.leave.insert(room_id, left_room_update);
room_updates.left.insert(room_id, left_room_update);
}
RoomUpdateKind::Invited(invited_room_update) => {
room_updates.invite.insert(room_id, invited_room_update);
room_updates.invited.insert(room_id, invited_room_update);
}
RoomUpdateKind::Knocked(knocked_room_update) => {
room_updates.knocked.insert(room_id, knocked_room_update);
@@ -204,7 +204,7 @@ impl BaseClient {
// We assume this can only happen in joined rooms, or something's very wrong.
room_updates
.join
.joined
.entry(room_id.to_owned())
.or_insert_with(JoinedRoomUpdate::default)
.ephemeral
@@ -214,7 +214,7 @@ impl BaseClient {
for (room_id, raw) in &extensions.typing.rooms {
// We assume this can only happen in joined rooms, or something's very wrong.
room_updates
.join
.joined
.entry(room_id.to_owned())
.or_insert_with(JoinedRoomUpdate::default)
.ephemeral
@@ -228,13 +228,13 @@ impl BaseClient {
if let Some(room) = self.state_store.room(room_id) {
match room.state() {
RoomState::Joined => room_updates
.join
.joined
.entry(room_id.to_owned())
.or_insert_with(JoinedRoomUpdate::default)
.account_data
.append(&mut raw.to_vec()),
RoomState::Left | RoomState::Banned => room_updates
.leave
.left
.entry(room_id.to_owned())
.or_insert_with(LeftRoomUpdate::default)
.account_data
@@ -248,7 +248,7 @@ impl BaseClient {
// receipt. Update the read receipt accordingly.
let user_id = &self.session_meta().expect("logged in user").user_id;
for (room_id, joined_room_update) in &mut room_updates.join {
for (room_id, joined_room_update) in &mut room_updates.joined {
if let Some(mut room_info) = context
.state_changes
.room_infos
@@ -380,7 +380,7 @@ mod tests {
.expect("Failed to process sync");
// Check it's present in the response.
let room = sync_response.rooms.join.get(room_id).unwrap();
let room = sync_response.rooms.joined.get(room_id).unwrap();
assert_eq!(room.unread_notifications, count.clone().into());
// Check it's been updated in the store.
@@ -421,9 +421,9 @@ mod tests {
assert_eq!(client_room.state(), RoomState::Joined);
// And it is added to the list of joined rooms only.
assert!(sync_resp.rooms.join.contains_key(room_id));
assert!(!sync_resp.rooms.leave.contains_key(room_id));
assert!(!sync_resp.rooms.invite.contains_key(room_id));
assert!(sync_resp.rooms.joined.contains_key(room_id));
assert!(!sync_resp.rooms.left.contains_key(room_id));
assert!(!sync_resp.rooms.invited.contains_key(room_id));
}
#[async_test]
@@ -449,9 +449,9 @@ mod tests {
assert_eq!(client_room.state(), RoomState::Joined);
// And it is added to the list of joined rooms only.
assert!(sync_resp.rooms.join.contains_key(room_id));
assert!(!sync_resp.rooms.leave.contains_key(room_id));
assert!(!sync_resp.rooms.invite.contains_key(room_id));
assert!(sync_resp.rooms.joined.contains_key(room_id));
assert!(!sync_resp.rooms.left.contains_key(room_id));
assert!(!sync_resp.rooms.invited.contains_key(room_id));
assert!(!sync_resp.rooms.knocked.contains_key(room_id));
}
@@ -509,9 +509,9 @@ mod tests {
assert_eq!(client_room.state(), RoomState::Invited);
// And it is added to the list of invited rooms only.
assert!(!sync_resp.rooms.join.contains_key(room_id));
assert!(!sync_resp.rooms.leave.contains_key(room_id));
assert!(sync_resp.rooms.invite.contains_key(room_id));
assert!(!sync_resp.rooms.joined.contains_key(room_id));
assert!(!sync_resp.rooms.left.contains_key(room_id));
assert!(sync_resp.rooms.invited.contains_key(room_id));
assert!(!sync_resp.rooms.knocked.contains_key(room_id));
}
@@ -655,9 +655,9 @@ mod tests {
assert_eq!(client.get_room(room_id).unwrap().state(), RoomState::Left);
// And it is added to the list of left rooms only.
assert!(!sync_resp.rooms.join.contains_key(room_id));
assert!(sync_resp.rooms.leave.contains_key(room_id));
assert!(!sync_resp.rooms.invite.contains_key(room_id));
assert!(!sync_resp.rooms.joined.contains_key(room_id));
assert!(sync_resp.rooms.left.contains_key(room_id));
assert!(!sync_resp.rooms.invited.contains_key(room_id));
assert!(!sync_resp.rooms.knocked.contains_key(room_id));
}
@@ -706,9 +706,9 @@ mod tests {
}
// And it is added to the list of left rooms only.
assert!(!sync_resp.rooms.join.contains_key(room_id));
assert!(sync_resp.rooms.leave.contains_key(room_id));
assert!(!sync_resp.rooms.invite.contains_key(room_id));
assert!(!sync_resp.rooms.joined.contains_key(room_id));
assert!(sync_resp.rooms.left.contains_key(room_id));
assert!(!sync_resp.rooms.invited.contains_key(room_id));
assert!(!sync_resp.rooms.knocked.contains_key(room_id));
}
}
@@ -1021,8 +1021,8 @@ mod tests {
assert_eq!(client_room.state(), RoomState::Invited);
// And it is added to the list of invited rooms, not the joined ones
assert!(!sync_resp.rooms.invite[room_id].invite_state.is_empty());
assert!(!sync_resp.rooms.join.contains_key(room_id));
assert!(!sync_resp.rooms.invited[room_id].invite_state.is_empty());
assert!(!sync_resp.rooms.joined.contains_key(room_id));
}
#[async_test]

18
crates/matrix-sdk-base/src/sync.rs
View File

@@ -72,11 +72,11 @@ impl fmt::Debug for SyncResponse {
#[derive(Clone, Default)]
pub struct RoomUpdates {
/// The rooms that the user has left or been banned from.
pub leave: BTreeMap<OwnedRoomId, LeftRoomUpdate>,
pub left: BTreeMap<OwnedRoomId, LeftRoomUpdate>,
/// The rooms that the user has joined.
pub join: BTreeMap<OwnedRoomId, JoinedRoomUpdate>,
pub joined: BTreeMap<OwnedRoomId, JoinedRoomUpdate>,
/// The rooms that the user has been invited to.
pub invite: BTreeMap<OwnedRoomId, InvitedRoomUpdate>,
pub invited: BTreeMap<OwnedRoomId, InvitedRoomUpdate>,
/// The rooms that the user has knocked on.
pub knocked: BTreeMap<OwnedRoomId, KnockedRoomUpdate>,
}
@@ -87,10 +87,10 @@ impl RoomUpdates {
/// This will only fill the in-memory caches, not save the info on disk.
pub(crate) async fn update_in_memory_caches(&self, store: &BaseStateStore) {
for room in self
.leave
.left
.keys()
.chain(self.join.keys())
.chain(self.invite.keys())
.chain(self.joined.keys())
.chain(self.invited.keys())
.chain(self.knocked.keys())
.filter_map(|room_id| store.room(room_id))
{
@@ -103,9 +103,9 @@ impl RoomUpdates {
impl fmt::Debug for RoomUpdates {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("RoomUpdates")
.field("leave", &self.leave)
.field("join", &self.join)
.field("invite", &DebugInvitedRoomUpdates(&self.invite))
.field("leave", &self.left)
.field("join", &self.joined)
.field("invite", &DebugInvitedRoomUpdates(&self.invited))
.field("knocked", &DebugKnockedRoomUpdates(&self.knocked))
.finish()
}

6
crates/matrix-sdk/src/client/mod.rs
View File

@@ -2203,7 +2203,7 @@ impl Client {
/// client
/// .sync_with_callback(sync_settings, |response| async move {
/// let channel = sync_channel;
/// for (room_id, room) in response.rooms.join {
/// for (room_id, room) in response.rooms.joined {
/// for event in room.timeline.events {
/// channel.send(event).await.unwrap();
/// }
@@ -2283,7 +2283,7 @@ impl Client {
/// .sync_with_result_callback(sync_settings, |response| async move {
/// let channel = sync_channel;
/// let sync_response = response?;
/// for (room_id, room) in sync_response.rooms.join {
/// for (room_id, room) in sync_response.rooms.joined {
/// for event in room.timeline.events {
/// channel.send(event).await.unwrap();
/// }
@@ -2356,7 +2356,7 @@ impl Client {
/// Box::pin(client.sync_stream(SyncSettings::default()).await);
///
/// while let Some(Ok(response)) = sync_stream.next().await {
/// for room in response.rooms.join.values() {
/// for room in response.rooms.joined.values() {
/// for e in &room.timeline.events {
/// if let Ok(event) = e.raw().deserialize() {
/// println!("Received event {:?}", event);

8
crates/matrix-sdk/src/event_cache/mod.rs
View File

@@ -538,7 +538,7 @@ impl EventCacheInner {
let _lock = self.multiple_room_updates_lock.lock().await;
// Left rooms.
for (room_id, left_room_update) in updates.leave {
for (room_id, left_room_update) in updates.left {
let room = self.for_room(&room_id).await?;
if let Err(err) =
@@ -550,7 +550,7 @@ impl EventCacheInner {
}
// Joined rooms.
for (room_id, joined_room_update) in updates.join {
for (room_id, joined_room_update) in updates.joined {
let room = self.for_room(&room_id).await?;
if let Err(err) =
@@ -810,8 +810,8 @@ mod tests {
};
let mut updates = RoomUpdates::default();
updates.join.insert(room_id1.to_owned(), joined_room_update1);
updates.join.insert(room_id2.to_owned(), joined_room_update2);
updates.joined.insert(room_id1.to_owned(), joined_room_update1);
updates.joined.insert(room_id2.to_owned(), joined_room_update2);
// Have the event cache handle them.
event_cache.inner.handle_room_updates(updates).await.unwrap();

2
crates/matrix-sdk/src/sliding_sync/client.rs
View File

@@ -248,7 +248,7 @@ impl<'a> SlidingSyncResponseProcessor<'a> {
///
/// This will only fill the in-memory caches, not save the info on disk.
async fn update_in_memory_caches(client: &Client, response: &SyncResponse) -> Result<()> {
for room_id in response.rooms.join.keys() {
for room_id in response.rooms.joined.keys() {
let Some(room) = client.get_room(room_id) else {
error!(room_id = ?room_id, "Cannot post process a room in sliding sync because it is missing");
continue;

6
crates/matrix-sdk/src/sliding_sync/mod.rs
View File

@@ -321,14 +321,14 @@ impl SlidingSync {
let updated_rooms = {
let mut rooms_map = self.inner.rooms.write().await;
let mut updated_rooms = Vec::with_capacity(sync_response.rooms.join.len());
let mut updated_rooms = Vec::with_capacity(sync_response.rooms.joined.len());
for (room_id, mut room_data) in sliding_sync_response.rooms.into_iter() {
// `sync_response` contains the rooms with decrypted events if any, so look at
// the timeline events here first if the room exists.
// Otherwise, let's look at the timeline inside the `sliding_sync_response`.
let timeline =
if let Some(joined_room) = sync_response.rooms.join.remove(&room_id) {
if let Some(joined_room) = sync_response.rooms.joined.remove(&room_id) {
joined_room.timeline.events
} else {
room_data.timeline.drain(..).map(TimelineEvent::new).collect()
@@ -363,7 +363,7 @@ impl SlidingSync {
// Since we've removed rooms that were in the room subsection from
// `sync_response.rooms.join`, the remaining ones aren't already present in
// `updated_rooms` and wouldn't cause any duplicates.
updated_rooms.extend(sync_response.rooms.join.keys().cloned());
updated_rooms.extend(sync_response.rooms.joined.keys().cloned());
updated_rooms
};

6
crates/matrix-sdk/src/sync.rs
View File

@@ -178,7 +178,7 @@ impl Client {
// Ignore errors when there are no receivers.
let _ = self.inner.room_updates_sender.send(rooms.clone());
for (room_id, room_info) in &rooms.join {
for (room_id, room_info) in &rooms.joined {
let Some(room) = self.get_room(room_id) else {
error!(?room_id, "Can't call event handler, room not found");
continue;
@@ -207,7 +207,7 @@ impl Client {
self.handle_sync_events(HandlerKind::EphemeralRoomData, room, ephemeral).await?;
}
for (room_id, room_info) in &rooms.leave {
for (room_id, room_info) in &rooms.left {
let Some(room) = self.get_room(room_id) else {
error!(?room_id, "Can't call event handler, room not found");
continue;
@@ -226,7 +226,7 @@ impl Client {
self.handle_sync_timeline_events(room, &timeline.events).await?;
}
for (room_id, room_info) in &rooms.invite {
for (room_id, room_info) in &rooms.invited {
let Some(room) = self.get_room(room_id) else {
error!(?room_id, "Can't call event handler, room not found");
continue;

26
crates/matrix-sdk/tests/integration/client.rs
View File

@@ -349,13 +349,13 @@ async fn test_subscribe_all_room_updates() {
client.sync_once(sync_settings).await.unwrap();
let room_updates = rx.recv().now_or_never().unwrap().unwrap();
assert_let!(RoomUpdates { leave, join, invite, knocked } = room_updates);
assert_let!(RoomUpdates { left, joined, invited, knocked } = room_updates);
// Check the left room updates.
{
assert_eq!(leave.len(), 1);
assert_eq!(left.len(), 1);
let (room_id, update) = leave.iter().next().unwrap();
let (room_id, update) = left.iter().next().unwrap();
assert_eq!(room_id, *MIXED_LEFT_ROOM_ID);
assert!(update.state.is_empty());
@@ -365,9 +365,9 @@ async fn test_subscribe_all_room_updates() {
// Check the joined room updates.
{
assert_eq!(join.len(), 1);
assert_eq!(joined.len(), 1);
let (room_id, update) = join.iter().next().unwrap();
let (room_id, update) = joined.iter().next().unwrap();
assert_eq!(room_id, *MIXED_JOINED_ROOM_ID);
@@ -385,9 +385,9 @@ async fn test_subscribe_all_room_updates() {
// Check the invited room updates.
{
assert_eq!(invite.len(), 1);
assert_eq!(invited.len(), 1);
let (room_id, update) = invite.iter().next().unwrap();
let (room_id, update) = invited.iter().next().unwrap();
assert_eq!(room_id, *MIXED_INVITED_ROOM_ID);
assert_eq!(update.invite_state.events.len(), 2);
@@ -938,7 +938,7 @@ async fn test_test_ambiguity_changes() {
let room = client.get_room(&DEFAULT_TEST_ROOM_ID).unwrap();
let changes = &response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
let changes = &response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
// A new member always triggers an ambiguity change.
let example_change = changes.get(event_id!("$151800140517rfvjc:localhost")).unwrap();
@@ -1009,7 +1009,7 @@ async fn test_test_ambiguity_changes() {
let response = client.sync_once(SyncSettings::default()).await.unwrap();
server.reset().await;
let changes = &response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
let changes = &response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
// First joined member made both members ambiguous.
let example_2_change = changes.get(example_2_rename_1_event_id).unwrap();
@@ -1068,7 +1068,7 @@ async fn test_test_ambiguity_changes() {
let response = client.sync_once(SyncSettings::default()).await.unwrap();
server.reset().await;
let changes = &response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
let changes = &response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
// example 2 is not ambiguous anymore.
let example_2_change = changes.get(example_2_rename_2_event_id).unwrap();
@@ -1114,7 +1114,7 @@ async fn test_test_ambiguity_changes() {
let response = client.sync_once(SyncSettings::default()).await.unwrap();
server.reset().await;
let changes = &response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
let changes = &response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
// example 3 is now ambiguous with example 2, not example.
let example_3_change = changes.get(example_3_rename_event_id).unwrap();
@@ -1160,7 +1160,7 @@ async fn test_test_ambiguity_changes() {
let response = client.sync_once(SyncSettings::default()).await.unwrap();
server.reset().await;
let changes = &response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
let changes = &response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes;
// name change, even if still not ambiguous, triggers ambiguity change.
let example_change = changes.get(example_rename_event_id).unwrap();
@@ -1207,7 +1207,7 @@ async fn test_test_ambiguity_changes() {
server.reset().await;
// Avatar change does not trigger ambiguity change.
assert!(response.rooms.join.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes.is_empty());
assert!(response.rooms.joined.get(*DEFAULT_TEST_ROOM_ID).unwrap().ambiguity_changes.is_empty());
let changes = assert_next_matches!(updates, Ok(RoomUpdate::Joined { updates, .. }) => updates.ambiguity_changes);
assert!(changes.is_empty());

4
testing/matrix-sdk-integration-testing/src/tests/sliding_sync/notification_client.rs
View File

@@ -61,7 +61,7 @@ async fn test_notification() -> Result<()> {
let bob_invite_response = bob.sync_once(Default::default()).await?;
let sync_token = bob_invite_response.next_batch;
let mut invited_rooms = bob_invite_response.rooms.invite;
let mut invited_rooms = bob_invite_response.rooms.invited;
assert_eq!(invited_rooms.len(), 1, "must be only one invitation");
@@ -145,7 +145,7 @@ async fn test_notification() -> Result<()> {
// In this sync, Bob receives the message from Alice.
let bob_response = bob.sync_once(SyncSettings::default().token(sync_token)).await?;
let mut joined_rooms = bob_response.rooms.join.into_iter();
let mut joined_rooms = bob_response.rooms.joined.into_iter();
let (_, bob_room) = joined_rooms.next().expect("must have joined one room");
assert!(joined_rooms.next().is_none(), "no more joined rooms: {joined_rooms:#?}");