refactor: Adapt to the changes of the room summary and directory endpoints

Signed-off-by: Kévin Commaille <zecakeh@tedomum.fr>

Author: zecakeh

bindings/matrix-sdk-ffi/src/room_directory_search.rs

@@ -28,15 +28,21 @@ use crate::{error::ClientError, runtime::get_runtime_handle, task_handle::TaskHa
 pub enum PublicRoomJoinRule {
     Public,
     Knock,
+    Restricted,
+    KnockRestricted,
+    Invite,
 }
 
-impl TryFrom<ruma::directory::PublicRoomJoinRule> for PublicRoomJoinRule {
+impl TryFrom<ruma::room::JoinRuleKind> for PublicRoomJoinRule {
     type Error = String;
 
-    fn try_from(value: ruma::directory::PublicRoomJoinRule) -> Result<Self, Self::Error> {
+    fn try_from(value: ruma::room::JoinRuleKind) -> Result<Self, Self::Error> {
         match value {
-            ruma::directory::PublicRoomJoinRule::Public => Ok(Self::Public),
-            ruma::directory::PublicRoomJoinRule::Knock => Ok(Self::Knock),
+            ruma::room::JoinRuleKind::Public => Ok(Self::Public),
+            ruma::room::JoinRuleKind::Knock => Ok(Self::Knock),
+            ruma::room::JoinRuleKind::Restricted => Ok(Self::Restricted),
+            ruma::room::JoinRuleKind::KnockRestricted => Ok(Self::KnockRestricted),
+            ruma::room::JoinRuleKind::Invite => Ok(Self::Invite),
             rule => Err(format!("unsupported join rule: {rule:?}")),
         }
     }

bindings/matrix-sdk-ffi/src/room_preview.rs

@@ -1,10 +1,10 @@
 use anyhow::Context as _;
 use matrix_sdk::{room_preview::RoomPreview as SdkRoomPreview, Client};
-use ruma::{room::RoomType as RumaRoomType, space::SpaceRoomJoinRule};
+use ruma::room::{JoinRuleSummary, RoomType as RumaRoomType};
 use tracing::warn;
 
 use crate::{
-    client::JoinRule,
+    client::{AllowRule, JoinRule},
     error::ClientError,
     room::{Membership, RoomHero},
     room_member::{RoomMember, RoomMemberWithSenderInfo},
@@ -40,7 +40,7 @@ impl RoomPreview {
                 .as_ref()
                 .map(TryInto::try_into)
                 .transpose()
-                .map_err(|_| anyhow::anyhow!("unhandled SpaceRoomJoinRule kind"))?,
+                .map_err(|_| anyhow::anyhow!("unhandled JoinRuleSummary kind"))?,
             is_direct: info.is_direct,
             heroes: info
                 .heroes
@@ -122,20 +122,32 @@ pub struct RoomPreviewInfo {
     pub heroes: Option<Vec<RoomHero>>,
 }
 
-impl TryFrom<&SpaceRoomJoinRule> for JoinRule {
+impl TryFrom<&JoinRuleSummary> for JoinRule {
     type Error = ();
 
-    fn try_from(join_rule: &SpaceRoomJoinRule) -> Result<Self, ()> {
+    fn try_from(join_rule: &JoinRuleSummary) -> Result<Self, ()> {
         Ok(match join_rule {
-            SpaceRoomJoinRule::Invite => JoinRule::Invite,
-            SpaceRoomJoinRule::Knock => JoinRule::Knock,
-            SpaceRoomJoinRule::Private => JoinRule::Private,
-            SpaceRoomJoinRule::Restricted => JoinRule::Restricted { rules: Vec::new() },
-            SpaceRoomJoinRule::KnockRestricted => JoinRule::KnockRestricted { rules: Vec::new() },
-            SpaceRoomJoinRule::Public => JoinRule::Public,
-            SpaceRoomJoinRule::_Custom(_) => JoinRule::Custom { repr: join_rule.to_string() },
+            JoinRuleSummary::Invite => JoinRule::Invite,
+            JoinRuleSummary::Knock => JoinRule::Knock,
+            JoinRuleSummary::Private => JoinRule::Private,
+            JoinRuleSummary::Restricted(summary) => JoinRule::Restricted {
+                rules: summary
+                    .allowed_room_ids
+                    .iter()
+                    .map(|room_id| AllowRule::RoomMembership { room_id: room_id.to_string() })
+                    .collect(),
+            },
+            JoinRuleSummary::KnockRestricted(summary) => JoinRule::KnockRestricted {
+                rules: summary
+                    .allowed_room_ids
+                    .iter()
+                    .map(|room_id| AllowRule::RoomMembership { room_id: room_id.to_string() })
+                    .collect(),
+            },
+            JoinRuleSummary::Public => JoinRule::Public,
+            JoinRuleSummary::_Custom(_) => JoinRule::Custom { repr: join_rule.as_str().to_owned() },
             _ => {
-                warn!("unhandled SpaceRoomJoinRule: {join_rule}");
+                warn!("unhandled JoinRuleSummary: {}", join_rule.as_str());
                 return Err(());
             }
         })

crates/matrix-sdk/src/room_directory_search.rs

@@ -20,8 +20,7 @@ use futures_core::Stream;
 use imbl::Vector;
 use ruma::{
     api::client::directory::get_public_rooms_filtered::v3::Request as PublicRoomsFilterRequest,
-    directory::{Filter, PublicRoomJoinRule},
-    OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId,
+    directory::Filter, room::JoinRuleKind, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId,
 };
 
 use crate::{Client, OwnedServerName, Result};
@@ -42,7 +41,7 @@ pub struct RoomDescription {
     /// The room's avatar URL, if any.
     pub avatar_url: Option<OwnedMxcUri>,
     /// The room's join rule.
-    pub join_rule: PublicRoomJoinRule,
+    pub join_rule: JoinRuleKind,
     /// Whether can be previewed
     pub is_world_readable: bool,
     /// The number of members that have joined the room.
@@ -220,7 +219,9 @@ mod tests {
     use eyeball_im::VectorDiff;
     use futures_util::StreamExt;
     use matrix_sdk_test::{async_test, test_json};
-    use ruma::{directory::Filter, owned_server_name, serde::Raw, RoomAliasId, RoomId};
+    use ruma::{
+        directory::Filter, owned_server_name, room::JoinRuleKind, serde::Raw, RoomAliasId, RoomId,
+    };
     use serde_json::Value as JsonValue;
     use stream_assert::assert_pending;
     use wiremock::{
@@ -279,7 +280,7 @@ mod tests {
             topic: Some("Tasty tasty cheese".into()),
             alias: None,
             avatar_url: Some("mxc://bleeker.street/CHEDDARandBRIE".into()),
-            join_rule: ruma::directory::PublicRoomJoinRule::Public,
+            join_rule: JoinRuleKind::Public,
             is_world_readable: true,
             joined_members: 37,
         }
@@ -292,7 +293,7 @@ mod tests {
             topic: Some("Tasty tasty pear".into()),
             alias: RoomAliasId::parse("#murrays:pear.bar").ok(),
             avatar_url: Some("mxc://bleeker.street/pear".into()),
-            join_rule: ruma::directory::PublicRoomJoinRule::Knock,
+            join_rule: JoinRuleKind::Knock,
             is_world_readable: false,
             joined_members: 20,
         }

crates/matrix-sdk/src/room_preview.rs

@@ -22,10 +22,8 @@ use futures_util::future::join_all;
 use matrix_sdk_base::{RoomHero, RoomInfo, RoomState};
 use ruma::{
     api::client::{membership::joined_members, state::get_state_events},
-    directory::PublicRoomJoinRule,
-    events::room::{history_visibility::HistoryVisibility, join_rules::JoinRule},
-    room::RoomType,
-    space::SpaceRoomJoinRule,
+    events::room::history_visibility::HistoryVisibility,
+    room::{JoinRuleSummary, RoomType},
     OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedServerName, RoomId, RoomOrAliasId, ServerName,
 };
 use tokio::try_join;
@@ -64,7 +62,7 @@ pub struct RoomPreview {
     pub room_type: Option<RoomType>,
 
     /// What's the join rule for this room?
-    pub join_rule: Option<SpaceRoomJoinRule>,
+    pub join_rule: Option<JoinRuleSummary>,
 
     /// Is the room world-readable (i.e. is its history_visibility set to
     /// world_readable)?
@@ -102,19 +100,7 @@ impl RoomPreview {
             topic: room_info.topic().map(ToOwned::to_owned),
             avatar_url: room_info.avatar_url().map(ToOwned::to_owned),
             room_type: room_info.room_type().cloned(),
-            join_rule: room_info.join_rule().map(|rule| match rule {
-                JoinRule::Invite => SpaceRoomJoinRule::Invite,
-                JoinRule::Knock => SpaceRoomJoinRule::Knock,
-                JoinRule::Private => SpaceRoomJoinRule::Private,
-                JoinRule::Restricted(_) => SpaceRoomJoinRule::Restricted,
-                JoinRule::KnockRestricted(_) => SpaceRoomJoinRule::KnockRestricted,
-                JoinRule::Public => SpaceRoomJoinRule::Public,
-                _ => {
-                    // The JoinRule enum is non-exhaustive. Let's do a white lie and pretend it's
-                    // private (a cautious choice).
-                    SpaceRoomJoinRule::Private
-                }
-            }),
+            join_rule: room_info.join_rule().cloned().map(Into::into),
             is_world_readable: room_info
                 .history_visibility()
                 .map(|vis| *vis == HistoryVisibility::WorldReadable),
@@ -253,7 +239,7 @@ impl RoomPreview {
         let own_server_name = client.session_meta().map(|s| s.user_id.server_name());
         let via = ensure_server_names_is_not_empty(own_server_name, via, room_or_alias_id);
 
-        let request = ruma::api::client::room::get_summary::msc3266::Request::new(
+        let request = ruma::api::client::room::get_summary::v1::Request::new(
             room_or_alias_id.to_owned(),
             via,
         );
@@ -278,17 +264,19 @@ impl RoomPreview {
             None
         };
 
+        let summary = response.summary;
+
         Ok(RoomPreview {
             room_id,
-            canonical_alias: response.canonical_alias,
-            name: response.name,
-            topic: response.topic,
-            avatar_url: response.avatar_url,
-            num_joined_members: response.num_joined_members.into(),
+            canonical_alias: summary.canonical_alias,
+            name: summary.name,
+            topic: summary.topic,
+            avatar_url: summary.avatar_url,
+            num_joined_members: summary.num_joined_members.into(),
             num_active_members,
-            room_type: response.room_type,
-            join_rule: Some(response.join_rule),
-            is_world_readable: Some(response.world_readable),
+            room_type: summary.room_type,
+            join_rule: Some(summary.join_rule),
+            is_world_readable: Some(summary.world_readable),
             state,
             is_direct,
             heroes: cached_room.map(|r| r.heroes()),
@@ -375,14 +363,7 @@ async fn search_for_room_preview_in_room_directory(
             num_active_members: None,
             // Assume it's a room
             room_type: None,
-            join_rule: Some(match room_description.join_rule {
-                PublicRoomJoinRule::Public => SpaceRoomJoinRule::Public,
-                PublicRoomJoinRule::Knock => SpaceRoomJoinRule::Knock,
-                PublicRoomJoinRule::_Custom(rule) => SpaceRoomJoinRule::_Custom(rule),
-                _ => {
-                    panic!("Unexpected PublicRoomJoinRule {:?}", room_description.join_rule)
-                }
-            }),
+            join_rule: Some(room_description.join_rule.into()),
             is_world_readable: Some(room_description.is_world_readable),
             state: None,
             is_direct: None,

crates/matrix-sdk/tests/integration/room_preview.rs

@@ -9,12 +9,12 @@ use matrix_sdk_test::{
     async_test, InvitedRoomBuilder, JoinedRoomBuilder, KnockedRoomBuilder, SyncResponseBuilder,
 };
 use ruma::{
-    api::client::sync::sync_events::{v5 as sliding_sync_http, v5::response::Hero},
+    api::client::sync::sync_events::v5::{self as sliding_sync_http, response::Hero},
     assign,
     events::room::member::MembershipState,
-    owned_user_id, room_id,
-    space::SpaceRoomJoinRule,
-    RoomId,
+    owned_user_id,
+    room::JoinRuleSummary,
+    room_id, RoomId,
 };
 use serde_json::json;
 use wiremock::{
@@ -39,7 +39,7 @@ async fn test_room_preview_leave_invited() {
     mock_unknown_summary(
         room_id,
         None,
-        SpaceRoomJoinRule::Knock,
+        JoinRuleSummary::Knock,
         Some(MembershipState::Invite),
         &server,
     )
@@ -97,7 +97,7 @@ async fn test_room_preview_leave_knocked() {
     mock_unknown_summary(
         room_id,
         None,
-        SpaceRoomJoinRule::Knock,
+        JoinRuleSummary::Knock,
         Some(MembershipState::Knock),
         &server,
     )
@@ -141,7 +141,7 @@ async fn test_room_preview_leave_unknown_room_fails() {
     let (client, server) = logged_in_client_with_server().await;
     let room_id = room_id!("!room:localhost");
 
-    mock_unknown_summary(room_id, None, SpaceRoomJoinRule::Knock, None, &server).await;
+    mock_unknown_summary(room_id, None, JoinRuleSummary::Knock, None, &server).await;
 
     let room_preview = client.get_room_preview(room_id.into(), Vec::new()).await.unwrap();
     assert!(room_preview.state.is_none());
@@ -193,7 +193,7 @@ async fn mock_leave(room_id: &RoomId, server: &MockServer) {
 async fn mock_unknown_summary(
     room_id: &RoomId,
     alias: Option<String>,
-    join_rule: SpaceRoomJoinRule,
+    join_rule: JoinRuleSummary,
     membership: Option<MembershipState>,
     server: &MockServer,
 ) {

testing/matrix-sdk-integration-testing/src/tests/sliding_sync/room.rs

@@ -32,9 +32,9 @@ use matrix_sdk::{
             },
             AnySyncMessageLikeEvent, InitialStateEvent, Mentions, StateEventType,
         },
-        mxc_uri, owned_server_name, room_id,
-        space::SpaceRoomJoinRule,
-        uint, RoomId,
+        mxc_uri, owned_server_name,
+        room::JoinRuleSummary,
+        room_id, uint, RoomId,
     },
     sliding_sync::VersionBuilder,
     test_utils::{logged_in_client_with_server, mocks::MatrixMockServer},
@@ -1228,7 +1228,7 @@ fn assert_room_preview(preview: &RoomPreview, room_alias: &str) {
     assert_eq!(preview.avatar_url.as_ref().unwrap(), mxc_uri!("mxc://localhost/alice"));
     assert_eq!(preview.num_joined_members, 1);
     assert!(preview.room_type.is_none());
-    assert_eq!(preview.join_rule, Some(SpaceRoomJoinRule::Invite));
+    assert_eq!(preview.join_rule, Some(JoinRuleSummary::Invite));
     assert!(preview.is_world_readable.unwrap());
 }