From fb4b3474331a99c0e98b38ea42568473ba18417c Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Mon, 13 Mar 2023 12:17:15 +0100 Subject: [PATCH] base: Rename RoomType to RoomState --- crates/matrix-sdk-base/Changelog.md | 4 +- crates/matrix-sdk-base/src/client.rs | 26 ++++----- crates/matrix-sdk-base/src/lib.rs | 2 +- crates/matrix-sdk-base/src/rooms/mod.rs | 2 +- crates/matrix-sdk-base/src/rooms/normal.rs | 56 +++++++++---------- crates/matrix-sdk-base/src/sliding_sync.rs | 4 +- .../src/store/integration_tests.rs | 10 ++-- crates/matrix-sdk-base/src/store/mod.rs | 16 +++--- crates/matrix-sdk/src/client/mod.rs | 4 +- crates/matrix-sdk/src/lib.rs | 2 +- crates/matrix-sdk/src/room/common.rs | 4 +- crates/matrix-sdk/src/room/invited.rs | 14 ++--- crates/matrix-sdk/src/room/joined.rs | 16 +++--- crates/matrix-sdk/src/room/left.rs | 14 ++--- crates/matrix-sdk/src/room/mod.rs | 34 +++++------ .../src/tests/repeated_join.rs | 4 +- 16 files changed, 107 insertions(+), 105 deletions(-) diff --git a/crates/matrix-sdk-base/Changelog.md b/crates/matrix-sdk-base/Changelog.md index f8e6777b9..b10574bf5 100644 --- a/crates/matrix-sdk-base/Changelog.md +++ b/crates/matrix-sdk-base/Changelog.md @@ -1,6 +1,8 @@ # Changelog -All notable changes to this crate will be documented in this file. +## unreleased + +- Rename `RoomType` to `RoomState` ## 0.5.1 diff --git a/crates/matrix-sdk-base/src/client.rs b/crates/matrix-sdk-base/src/client.rs index 2fdf47356..8af784eb4 100644 --- a/crates/matrix-sdk-base/src/client.rs +++ b/crates/matrix-sdk-base/src/client.rs @@ -60,7 +60,7 @@ use crate::error::Error; use crate::{ deserialized_responses::{AmbiguityChanges, MembersResponse, SyncTimelineEvent}, error::Result, - rooms::{Room, RoomInfo, RoomType}, + rooms::{Room, RoomInfo, RoomState}, store::{ ambiguity_map::AmbiguityCache, DynStateStore, Result as StoreResult, StateChanges, StateStoreDataKey, StateStoreDataValue, StateStoreExt, Store, StoreConfig, @@ -167,8 +167,8 @@ impl BaseClient { /// Lookup the Room for the given RoomId, or create one, if it didn't exist /// yet in the store - pub async fn get_or_create_room(&self, room_id: &RoomId, room_type: RoomType) -> Room { - self.store.get_or_create_room(room_id, room_type).await + pub async fn get_or_create_room(&self, room_id: &RoomId, room_state: RoomState) -> Room { + self.store.get_or_create_room(room_id, room_state).await } /// Get all the rooms this client knows about. @@ -623,8 +623,8 @@ impl BaseClient { /// /// Update the internal and cached state accordingly. Return the final Room. pub async fn room_joined(&self, room_id: &RoomId) -> Result { - let room = self.store.get_or_create_room(room_id, RoomType::Joined).await; - if room.room_type() != RoomType::Joined { + let room = self.store.get_or_create_room(room_id, RoomState::Joined).await; + if room.state() != RoomState::Joined { let _sync_lock = self.sync_lock().read().await; let mut room_info = room.clone_info(); @@ -644,8 +644,8 @@ impl BaseClient { /// /// Update the internal and cached state accordingly. Return the final Room. pub async fn room_left(&self, room_id: &RoomId) -> Result { - let room = self.store.get_or_create_room(room_id, RoomType::Left).await; - if room.room_type() != RoomType::Left { + let room = self.store.get_or_create_room(room_id, RoomState::Left).await; + if room.state() != RoomState::Left { let _sync_lock = self.sync_lock().read().await; let mut room_info = room.clone_info(); @@ -718,7 +718,7 @@ impl BaseClient { let mut new_rooms = Rooms::default(); for (room_id, new_info) in rooms.join { - let room = self.store.get_or_create_room(&room_id, RoomType::Joined).await; + let room = self.store.get_or_create_room(&room_id, RoomState::Joined).await; let mut room_info = room.clone_info(); room_info.mark_as_joined(); @@ -802,7 +802,7 @@ impl BaseClient { } for (room_id, new_info) in rooms.leave { - let room = self.store.get_or_create_room(&room_id, RoomType::Left).await; + let room = self.store.get_or_create_room(&room_id, RoomState::Left).await; let mut room_info = room.clone_info(); room_info.mark_as_left(); room_info.mark_state_partially_synced(); @@ -1254,7 +1254,7 @@ mod tests { use serde_json::json; use super::BaseClient; - use crate::{DisplayName, RoomType, SessionMeta}; + use crate::{DisplayName, RoomState, SessionMeta}; #[async_test] async fn invite_after_leaving() { @@ -1288,7 +1288,7 @@ mod tests { )) .build_sync_response(); client.receive_sync_response(response).await.unwrap(); - assert_eq!(client.get_room(room_id).unwrap().room_type(), RoomType::Left); + assert_eq!(client.get_room(room_id).unwrap().state(), RoomState::Left); let response = ev_builder .add_invited_room(InvitedRoomBuilder::new(room_id).add_state_event( @@ -1306,7 +1306,7 @@ mod tests { )) .build_sync_response(); client.receive_sync_response(response).await.unwrap(); - assert_eq!(client.get_room(room_id).unwrap().room_type(), RoomType::Invited); + assert_eq!(client.get_room(room_id).unwrap().state(), RoomState::Invited); } #[async_test] @@ -1397,7 +1397,7 @@ mod tests { client.receive_sync_response(response).await.unwrap(); let room = client.get_room(room_id).expect("Room not found"); - assert_eq!(room.room_type(), RoomType::Invited); + assert_eq!(room.state(), RoomState::Invited); assert_eq!( room.display_name().await.expect("fetching display name failed"), DisplayName::Calculated("Kyra".to_owned()) diff --git a/crates/matrix-sdk-base/src/lib.rs b/crates/matrix-sdk-base/src/lib.rs index d411e5663..c69e4867f 100644 --- a/crates/matrix-sdk-base/src/lib.rs +++ b/crates/matrix-sdk-base/src/lib.rs @@ -42,7 +42,7 @@ pub use http; #[cfg(feature = "e2e-encryption")] pub use matrix_sdk_crypto as crypto; pub use once_cell; -pub use rooms::{DisplayName, Room, RoomInfo, RoomMember, RoomType}; +pub use rooms::{DisplayName, Room, RoomInfo, RoomMember, RoomState}; pub use store::{StateChanges, StateStore, StateStoreDataKey, StateStoreDataValue, StoreError}; pub use utils::{ MinimalRoomMemberEvent, MinimalStateEvent, OriginalMinimalStateEvent, RedactedMinimalStateEvent, diff --git a/crates/matrix-sdk-base/src/rooms/mod.rs b/crates/matrix-sdk-base/src/rooms/mod.rs index 7ef982238..f414fd20e 100644 --- a/crates/matrix-sdk-base/src/rooms/mod.rs +++ b/crates/matrix-sdk-base/src/rooms/mod.rs @@ -4,7 +4,7 @@ mod normal; use std::{collections::HashSet, fmt}; pub use members::RoomMember; -pub use normal::{Room, RoomInfo, RoomType}; +pub use normal::{Room, RoomInfo, RoomState}; use ruma::{ assign, events::{ diff --git a/crates/matrix-sdk-base/src/rooms/normal.rs b/crates/matrix-sdk-base/src/rooms/normal.rs index f9e9314e8..1f6b10d65 100644 --- a/crates/matrix-sdk-base/src/rooms/normal.rs +++ b/crates/matrix-sdk-base/src/rooms/normal.rs @@ -31,7 +31,7 @@ use ruma::{ AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncStateEvent, RoomAccountDataEventType, }, - room::RoomType as CreateRoomType, + room::RoomType, EventId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedUserId, RoomAliasId, RoomId, RoomVersionId, UserId, }; @@ -71,7 +71,7 @@ pub struct RoomSummary { /// Enum keeping track in which state the room is, e.g. if our own user is /// joined, invited, or has left the room. #[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)] -pub enum RoomType { +pub enum RoomState { /// The room is in a joined state. Joined, /// The room is in a left state. @@ -85,9 +85,9 @@ impl Room { own_user_id: &UserId, store: Arc, room_id: &RoomId, - room_type: RoomType, + room_state: RoomState, ) -> Self { - let room_info = RoomInfo::new(room_id, room_type); + let room_info = RoomInfo::new(room_id, room_state); Self::restore(own_user_id, store, room_info) } @@ -114,14 +114,14 @@ impl Room { &self.own_user_id } - /// Get the type of the room. - pub fn room_type(&self) -> RoomType { - self.inner.read().unwrap().room_type + /// Get the state of the room. + pub fn state(&self) -> RoomState { + self.inner.read().unwrap().room_state } - /// Whether this room's [`RoomType`](CreateRoomType) is `m.space`. + /// Whether this room's [`RoomType`] is `m.space`. pub fn is_space(&self) -> bool { - self.inner.read().unwrap().room_type().map_or(false, |t| *t == CreateRoomType::Space) + self.inner.read().unwrap().room_type().map_or(false, |t| *t == RoomType::Space) } /// Get the unread notification counts. @@ -381,13 +381,13 @@ impl Room { members? }; - let (joined, invited) = match self.room_type() { - RoomType::Invited => { + let (joined, invited) = match self.state() { + RoomState::Invited => { // when we were invited we don't have a proper summary, we have to do best // guessing (members.len() as u64, 1u64) } - RoomType::Joined if summary.joined_member_count == 0 => { + RoomState::Joined if summary.joined_member_count == 0 => { // joined but the summary is not completed yet ( (members.len() as u64) + 1, // we've taken ourselves out of the count @@ -514,8 +514,8 @@ impl Room { pub struct RoomInfo { /// The unique room id of the room. pub(crate) room_id: Arc, - /// The type of the room. - room_type: RoomType, + /// The state of the room. + room_state: RoomState, /// The unread notifications counts. notification_counts: UnreadNotificationsCount, /// The summary of this room. @@ -572,10 +572,10 @@ fn encryption_state_default() -> bool { impl RoomInfo { #[doc(hidden)] // used by store tests, otherwise it would be pub(crate) - pub fn new(room_id: &RoomId, room_type: RoomType) -> Self { + pub fn new(room_id: &RoomId, room_state: RoomState) -> Self { Self { room_id: room_id.into(), - room_type, + room_state, notification_counts: Default::default(), summary: Default::default(), members_synced: false, @@ -588,17 +588,17 @@ impl RoomInfo { /// Mark this Room as joined. pub fn mark_as_joined(&mut self) { - self.room_type = RoomType::Joined; + self.room_state = RoomState::Joined; } /// Mark this Room as left. pub fn mark_as_left(&mut self) { - self.room_type = RoomType::Left; + self.room_state = RoomState::Left; } /// Mark this Room as invited. pub fn mark_as_invited(&mut self) { - self.room_type = RoomType::Invited; + self.room_state = RoomState::Invited; } /// Mark this Room as having all the members synced. @@ -743,7 +743,7 @@ impl RoomInfo { } /// Get the room type of this room. - pub fn room_type(&self) -> Option<&CreateRoomType> { + pub fn room_type(&self) -> Option<&RoomType> { self.base_info.create.as_ref()?.as_original()?.content.room_type.as_ref() } @@ -815,7 +815,7 @@ mod test { MinimalStateEvent, OriginalMinimalStateEvent, }; - fn make_room(room_type: RoomType) -> (Arc, Room) { + fn make_room(room_type: RoomState) -> (Arc, Room) { let store = Arc::new(MemoryStore::new()); let user_id = user_id!("@me:example.org"); let room_id = room_id!("!test:localhost"); @@ -853,7 +853,7 @@ mod test { #[async_test] async fn test_display_name_default() { - let (_, room) = make_room(RoomType::Joined); + let (_, room) = make_room(RoomState::Joined); assert_eq!(room.display_name().await.unwrap(), DisplayName::Empty); let canonical_alias_event = MinimalStateEvent::Original(OriginalMinimalStateEvent { @@ -876,7 +876,7 @@ mod test { room.inner.write().unwrap().base_info.name = Some(name_event.clone()); assert_eq!(room.display_name().await.unwrap(), DisplayName::Named("Test Room".to_owned())); - let (_, room) = make_room(RoomType::Invited); + let (_, room) = make_room(RoomState::Invited); assert_eq!(room.display_name().await.unwrap(), DisplayName::Empty); // has precedence @@ -890,7 +890,7 @@ mod test { #[async_test] async fn test_display_name_dm_invited() { - let (store, room) = make_room(RoomType::Invited); + let (store, room) = make_room(RoomState::Invited); let room_id = room_id!("!test:localhost"); let matthew = user_id!("@matthew:example.org"); let me = user_id!("@me:example.org"); @@ -916,7 +916,7 @@ mod test { #[async_test] async fn test_display_name_dm_invited_no_heroes() { - let (store, room) = make_room(RoomType::Invited); + let (store, room) = make_room(RoomState::Invited); let room_id = room_id!("!test:localhost"); let matthew = user_id!("@matthew:example.org"); let me = user_id!("@me:example.org"); @@ -938,7 +938,7 @@ mod test { #[async_test] async fn test_display_name_dm_joined() { - let (store, room) = make_room(RoomType::Joined); + let (store, room) = make_room(RoomState::Joined); let room_id = room_id!("!test:localhost"); let matthew = user_id!("@matthew:example.org"); let me = user_id!("@me:example.org"); @@ -969,7 +969,7 @@ mod test { #[async_test] async fn test_display_name_dm_joined_no_heroes() { - let (store, room) = make_room(RoomType::Joined); + let (store, room) = make_room(RoomState::Joined); let room_id = room_id!("!test:localhost"); let matthew = user_id!("@matthew:example.org"); let me = user_id!("@me:example.org"); @@ -995,7 +995,7 @@ mod test { #[async_test] async fn test_display_name_dm_alone() { - let (store, room) = make_room(RoomType::Joined); + let (store, room) = make_room(RoomState::Joined); let room_id = room_id!("!test:localhost"); let matthew = user_id!("@matthew:example.org"); let me = user_id!("@me:example.org"); diff --git a/crates/matrix-sdk-base/src/sliding_sync.rs b/crates/matrix-sdk-base/src/sliding_sync.rs index 23ede4ef4..0b1cd6847 100644 --- a/crates/matrix-sdk-base/src/sliding_sync.rs +++ b/crates/matrix-sdk-base/src/sliding_sync.rs @@ -17,7 +17,7 @@ use super::BaseClient; use crate::{ deserialized_responses::AmbiguityChanges, error::Result, - rooms::RoomType, + rooms::RoomState, store::{ambiguity_map::AmbiguityCache, StateChanges}, sync::{JoinedRoom, Rooms, SyncResponse}, }; @@ -138,7 +138,7 @@ impl BaseClient { v3::InvitedRoom::from(v3::InviteState::from(invite_states.clone())), ); } else { - let room = store.get_or_create_room(room_id, RoomType::Joined).await; + let room = store.get_or_create_room(room_id, RoomState::Joined).await; let mut room_info = room.clone_info(); room_info.mark_as_joined(); // FIXME: this might not be accurate room_info.mark_state_partially_synced(); diff --git a/crates/matrix-sdk-base/src/store/integration_tests.rs b/crates/matrix-sdk-base/src/store/integration_tests.rs index 982ed149a..05fe6e049 100644 --- a/crates/matrix-sdk-base/src/store/integration_tests.rs +++ b/crates/matrix-sdk-base/src/store/integration_tests.rs @@ -35,7 +35,7 @@ use crate::{ deserialized_responses::MemberEvent, media::{MediaFormat, MediaRequest, MediaThumbnailSize}, store::{Result, StateStoreExt}, - RoomInfo, RoomType, StateChanges, StateStoreDataKey, StateStoreDataValue, + RoomInfo, RoomState, StateChanges, StateStoreDataKey, StateStoreDataValue, }; /// `StateStore` integration tests. @@ -101,7 +101,7 @@ impl StateStoreIntegrationTests for DynStateStore { let pushrules_event = pushrules_raw.deserialize().unwrap(); changes.add_account_data(pushrules_event, pushrules_raw); - let mut room = RoomInfo::new(room_id, RoomType::Joined); + let mut room = RoomInfo::new(room_id, RoomState::Joined); room.mark_as_left(); let tag_json: &JsonValue = &test_json::TAG; @@ -168,7 +168,7 @@ impl StateStoreIntegrationTests for DynStateStore { changes.members.insert(room_id.to_owned(), room_members); changes.add_room(room); - let mut stripped_room = RoomInfo::new(stripped_room_id, RoomType::Invited); + let mut stripped_room = RoomInfo::new(stripped_room_id, RoomState::Invited); let stripped_name_json: &JsonValue = &test_json::NAME_STRIPPED; let stripped_name_raw = @@ -764,7 +764,7 @@ impl StateStoreIntegrationTests for DynStateStore { .entry(room_id.to_owned()) .or_default() .insert(user_id.to_owned(), membership_event()); - changes.add_room(RoomInfo::new(room_id, RoomType::Left)); + changes.add_room(RoomInfo::new(room_id, RoomState::Left)); self.save_changes(&changes).await.unwrap(); let member_event = @@ -778,7 +778,7 @@ impl StateStoreIntegrationTests for DynStateStore { let mut changes = StateChanges::default(); changes.add_stripped_member(room_id, user_id, custom_stripped_membership_event(user_id)); - changes.add_stripped_room(RoomInfo::new(room_id, RoomType::Invited)); + changes.add_stripped_room(RoomInfo::new(room_id, RoomState::Invited)); self.save_changes(&changes).await.unwrap(); let member_event = diff --git a/crates/matrix-sdk-base/src/store/mod.rs b/crates/matrix-sdk-base/src/store/mod.rs index 11dc6b512..35a0cdb41 100644 --- a/crates/matrix-sdk-base/src/store/mod.rs +++ b/crates/matrix-sdk-base/src/store/mod.rs @@ -63,7 +63,7 @@ use ruma::{ pub type BoxStream = Pin + Send>>; use crate::{ - rooms::{RoomInfo, RoomType}, + rooms::{RoomInfo, RoomState}, MinimalRoomMemberEvent, Room, Session, SessionMeta, SessionTokens, }; @@ -236,10 +236,10 @@ impl Store { pub fn get_room(&self, room_id: &RoomId) -> Option { self.rooms .get(room_id) - .and_then(|r| match r.room_type() { - RoomType::Joined => Some(r.clone()), - RoomType::Left => Some(r.clone()), - RoomType::Invited => self.get_stripped_room(room_id), + .and_then(|r| match r.state() { + RoomState::Joined => Some(r.clone()), + RoomState::Left => Some(r.clone()), + RoomState::Invited => self.get_stripped_room(room_id), }) .or_else(|| self.get_stripped_room(room_id)) } @@ -265,14 +265,14 @@ impl Store { self.stripped_rooms .entry(room_id.to_owned()) - .or_insert_with(|| Room::new(user_id, self.inner.clone(), room_id, RoomType::Invited)) + .or_insert_with(|| Room::new(user_id, self.inner.clone(), room_id, RoomState::Invited)) .clone() } /// Lookup the Room for the given RoomId, or create one, if it didn't exist /// yet in the store - pub async fn get_or_create_room(&self, room_id: &RoomId, room_type: RoomType) -> Room { - if room_type == RoomType::Invited { + pub async fn get_or_create_room(&self, room_id: &RoomId, room_type: RoomState) -> Room { + if room_type == RoomState::Invited { return self.get_or_create_stripped_room(room_id).await; } diff --git a/crates/matrix-sdk/src/client/mod.rs b/crates/matrix-sdk/src/client/mod.rs index d1934173c..1f3fb62a1 100644 --- a/crates/matrix-sdk/src/client/mod.rs +++ b/crates/matrix-sdk/src/client/mod.rs @@ -28,7 +28,7 @@ use dashmap::DashMap; use futures_core::Stream; use futures_util::StreamExt; use matrix_sdk_base::{ - store::DynStateStore, BaseClient, RoomType, SendOutsideWasm, Session, SessionMeta, + store::DynStateStore, BaseClient, RoomState, SendOutsideWasm, Session, SessionMeta, SessionTokens, SyncOutsideWasm, }; use matrix_sdk_common::{ @@ -1684,7 +1684,7 @@ impl Client { let response = self.send(request, None).await?; let base_room = - self.base_client().get_or_create_room(&response.room_id, RoomType::Joined).await; + self.base_client().get_or_create_room(&response.room_id, RoomState::Joined).await; Ok(room::Joined::new(self, base_room).unwrap()) } diff --git a/crates/matrix-sdk/src/lib.rs b/crates/matrix-sdk/src/lib.rs index fa6776d32..12f923632 100644 --- a/crates/matrix-sdk/src/lib.rs +++ b/crates/matrix-sdk/src/lib.rs @@ -20,7 +20,7 @@ pub use async_trait::async_trait; pub use bytes; pub use matrix_sdk_base::{ deserialized_responses, DisplayName, Room as BaseRoom, RoomInfo, RoomMember as BaseRoomMember, - RoomType, Session, StateChanges, StoreError, + RoomState, Session, StateChanges, StoreError, }; pub use matrix_sdk_common::*; pub use reqwest; diff --git a/crates/matrix-sdk/src/room/common.rs b/crates/matrix-sdk/src/room/common.rs index 035fd62f2..60c070963 100644 --- a/crates/matrix-sdk/src/room/common.rs +++ b/crates/matrix-sdk/src/room/common.rs @@ -51,7 +51,7 @@ use super::Joined; use crate::{ event_handler::{EventHandler, EventHandlerHandle, SyncEvent}, media::{MediaFormat, MediaRequest}, - room::{Left, RoomMember, RoomType}, + room::{Left, RoomMember, RoomState}, BaseRoom, Client, Error, HttpError, HttpResult, Result, }; @@ -404,7 +404,7 @@ impl Common { } fn are_events_visible(&self) -> bool { - if let RoomType::Invited = self.inner.room_type() { + if let RoomState::Invited = self.inner.state() { return matches!( self.inner.history_visibility(), HistoryVisibility::WorldReadable | HistoryVisibility::Invited diff --git a/crates/matrix-sdk/src/room/invited.rs b/crates/matrix-sdk/src/room/invited.rs index a7ea8c5c0..a99e210c6 100644 --- a/crates/matrix-sdk/src/room/invited.rs +++ b/crates/matrix-sdk/src/room/invited.rs @@ -5,14 +5,14 @@ use thiserror::Error; use super::{Joined, Left}; use crate::{ room::{Common, RoomMember}, - BaseRoom, Client, Error, Result, RoomType, + BaseRoom, Client, Error, Result, RoomState, }; /// A room in the invited state. /// -/// This struct contains all methods specific to a `Room` with type -/// `RoomType::Invited`. Operations may fail once the underlying `Room` changes -/// `RoomType`. +/// This struct contains all methods specific to a `Room` with +/// `RoomState::Invited`. Operations may fail once the underlying `Room` changes +/// `RoomState`. #[derive(Debug, Clone)] pub struct Invited { pub(crate) inner: Common, @@ -37,15 +37,15 @@ pub enum InvitationError { } impl Invited { - /// Create a new `room::Invited` if the underlying `Room` has type - /// `RoomType::Invited`. + /// Create a new `room::Invited` if the underlying `Room` has + /// `RoomState::Invited`. /// /// # Arguments /// * `client` - The client used to make requests. /// /// * `room` - The underlying room. pub(crate) fn new(client: &Client, room: BaseRoom) -> Option { - if room.room_type() == RoomType::Invited { + if room.state() == RoomState::Invited { Some(Self { inner: Common::new(client.clone(), room) }) } else { None diff --git a/crates/matrix-sdk/src/room/joined.rs b/crates/matrix-sdk/src/room/joined.rs index 86eb8eb8b..7b8a27977 100644 --- a/crates/matrix-sdk/src/room/joined.rs +++ b/crates/matrix-sdk/src/room/joined.rs @@ -39,7 +39,7 @@ use crate::{ attachment::AttachmentConfig, error::{Error, HttpResult}, room::Common, - BaseRoom, Client, Result, RoomType, + BaseRoom, Client, Result, RoomState, }; #[cfg(feature = "image-proc")] use crate::{ @@ -52,9 +52,9 @@ const TYPING_NOTICE_RESEND_TIMEOUT: Duration = Duration::from_secs(3); /// A room in the joined state. /// -/// The `JoinedRoom` contains all methods specific to a `Room` with type -/// `RoomType::Joined`. Operations may fail once the underlying `Room` changes -/// `RoomType`. +/// The `JoinedRoom` contains all methods specific to a `Room` with +/// `RoomState::Joined`. Operations may fail once the underlying `Room` changes +/// `RoomState`. #[derive(Debug, Clone)] pub struct Joined { pub(crate) inner: Common, @@ -69,15 +69,15 @@ impl Deref for Joined { } impl Joined { - /// Create a new `room::Joined` if the underlying `BaseRoom` has type - /// `RoomType::Joined`. + /// Create a new `room::Joined` if the underlying `BaseRoom` has + /// `RoomState::Joined`. /// /// # Arguments /// * `client` - The client used to make requests. /// /// * `room` - The underlying room. pub(crate) fn new(client: &Client, room: BaseRoom) -> Option { - if room.room_type() == RoomType::Joined { + if room.state() == RoomState::Joined { Some(Self { inner: Common::new(client.clone(), room) }) } else { None @@ -432,7 +432,7 @@ impl Joined { /// room anymore! #[instrument(skip_all, parent = &self.client.inner.root_span)] pub async fn sync_up(&self) { - while !self.is_synced() && self.room_type() == RoomType::Joined { + while !self.is_synced() && self.state() == RoomState::Joined { self.client.inner.sync_beat.listen().wait_timeout(Duration::from_secs(1)); } } diff --git a/crates/matrix-sdk/src/room/left.rs b/crates/matrix-sdk/src/room/left.rs index 97875e376..9690262e8 100644 --- a/crates/matrix-sdk/src/room/left.rs +++ b/crates/matrix-sdk/src/room/left.rs @@ -3,28 +3,28 @@ use std::ops::Deref; use ruma::api::client::membership::forget_room; use super::Joined; -use crate::{room::Common, BaseRoom, Client, Result, RoomType}; +use crate::{room::Common, BaseRoom, Client, Result, RoomState}; /// A room in the left state. /// -/// This struct contains all methods specific to a `Room` with type -/// `RoomType::Left`. Operations may fail once the underlying `Room` changes -/// `RoomType`. +/// This struct contains all methods specific to a `Room` with +/// `RoomState::Left`. Operations may fail once the underlying `Room` changes +/// `RoomState`. #[derive(Debug, Clone)] pub struct Left { pub(crate) inner: Common, } impl Left { - /// Create a new `room::Left` if the underlying `Room` has type - /// `RoomType::Left`. + /// Create a new `room::Left` if the underlying `Room` has + /// `RoomState::Left`. /// /// # Arguments /// * `client` - The client used to make requests. /// /// * `room` - The underlying room. pub(crate) fn new(client: &Client, room: BaseRoom) -> Option { - if room.room_type() == RoomType::Left { + if room.state() == RoomState::Left { Some(Self { inner: Common::new(client.clone(), room) }) } else { None diff --git a/crates/matrix-sdk/src/room/mod.rs b/crates/matrix-sdk/src/room/mod.rs index d2211f0e6..333b7f737 100644 --- a/crates/matrix-sdk/src/room/mod.rs +++ b/crates/matrix-sdk/src/room/mod.rs @@ -2,7 +2,7 @@ use std::ops::Deref; -use crate::RoomType; +use crate::RoomState; mod common; mod invited; @@ -45,10 +45,10 @@ impl Deref for Room { impl From for Room { fn from(room: Common) -> Self { - match room.room_type() { - RoomType::Joined => Self::Joined(Joined { inner: room }), - RoomType::Left => Self::Left(Left { inner: room }), - RoomType::Invited => Self::Invited(Invited { inner: room }), + match room.state() { + RoomState::Joined => Self::Joined(Joined { inner: room }), + RoomState::Left => Self::Left(Left { inner: room }), + RoomState::Invited => Self::Invited(Invited { inner: room }), } } } @@ -56,10 +56,10 @@ impl From for Room { impl From for Room { fn from(room: Joined) -> Self { let room = (*room).clone(); - match room.room_type() { - RoomType::Joined => Self::Joined(Joined { inner: room }), - RoomType::Left => Self::Left(Left { inner: room }), - RoomType::Invited => Self::Invited(Invited { inner: room }), + match room.state() { + RoomState::Joined => Self::Joined(Joined { inner: room }), + RoomState::Left => Self::Left(Left { inner: room }), + RoomState::Invited => Self::Invited(Invited { inner: room }), } } } @@ -67,10 +67,10 @@ impl From for Room { impl From for Room { fn from(room: Left) -> Self { let room = (*room).clone(); - match room.room_type() { - RoomType::Joined => Self::Joined(Joined { inner: room }), - RoomType::Left => Self::Left(Left { inner: room }), - RoomType::Invited => Self::Invited(Invited { inner: room }), + match room.state() { + RoomState::Joined => Self::Joined(Joined { inner: room }), + RoomState::Left => Self::Left(Left { inner: room }), + RoomState::Invited => Self::Invited(Invited { inner: room }), } } } @@ -78,10 +78,10 @@ impl From for Room { impl From for Room { fn from(room: Invited) -> Self { let room = (*room).clone(); - match room.room_type() { - RoomType::Joined => Self::Joined(Joined { inner: room }), - RoomType::Left => Self::Left(Left { inner: room }), - RoomType::Invited => Self::Invited(Invited { inner: room }), + match room.state() { + RoomState::Joined => Self::Joined(Joined { inner: room }), + RoomState::Left => Self::Left(Left { inner: room }), + RoomState::Invited => Self::Invited(Invited { inner: room }), } } } diff --git a/testing/matrix-sdk-integration-testing/src/tests/repeated_join.rs b/testing/matrix-sdk-integration-testing/src/tests/repeated_join.rs index a6506082d..0ea46b04e 100644 --- a/testing/matrix-sdk-integration-testing/src/tests/repeated_join.rs +++ b/testing/matrix-sdk-integration-testing/src/tests/repeated_join.rs @@ -9,7 +9,7 @@ use matrix_sdk::{ api::client::room::create_room::v3::Request as CreateRoomRequest, events::room::member::{MembershipState, StrippedRoomMemberEvent}, }, - Client, RoomType, + Client, RoomState, }; use tokio::sync::Notify; @@ -136,7 +136,7 @@ async fn signal_on_invite( return; } - if room.room_type() != RoomType::Invited { + if room.state() != RoomState::Invited { return; }