chore(spaces): converge on single naming scheme for all spaces related components on both the UI and the FFI crates

Author: stefanceriu

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

@@ -1261,7 +1261,7 @@ impl Client {
         SyncServiceBuilder::new((*self.inner).clone(), self.utd_hook_manager.get().cloned())
     }
 
-    pub fn spaces_service(&self) -> Arc<SpaceService> {
+    pub fn space_service(&self) -> Arc<SpaceService> {
         let inner = UISpaceService::new((*self.inner).clone());
         Arc::new(SpaceService::new(inner))
     }

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

@@ -17,9 +17,8 @@ use std::{fmt::Debug, sync::Arc};
 use futures_util::{pin_mut, StreamExt};
 use matrix_sdk_common::{SendOutsideWasm, SyncOutsideWasm};
 use matrix_sdk_ui::spaces::{
-    room_list::SpaceServiceRoomListPaginationState as UISpaceServiceRoomListPaginationState,
-    SpaceService as UISpaceService, SpaceServiceRoom as UISpaceServiceRoom,
-    SpaceServiceRoomList as UISpaceServiceRoomList,
+    room_list::SpaceRoomListPaginationState, SpaceRoom as UISpaceRoom,
+    SpaceRoomList as UISpaceRoomList, SpaceService as UISpaceService,
 };
 use ruma::RoomId;
 
@@ -38,14 +37,14 @@ pub struct SpaceService {
 }
 
 impl SpaceService {
-    pub fn new(inner: UISpaceService) -> Self {
+    pub(crate) fn new(inner: UISpaceService) -> Self {
         Self { inner }
     }
 }
 
 #[matrix_sdk_ffi_macros::export]
 impl SpaceService {
-    pub async fn joined_spaces(&self) -> Vec<SpaceServiceRoom> {
+    pub async fn joined_spaces(&self) -> Vec<SpaceRoom> {
         self.inner.joined_spaces().await.into_iter().map(Into::into).collect()
     }
 
@@ -77,51 +76,51 @@ impl SpaceService {
     pub async fn space_room_list(
         &self,
         space_id: String,
-    ) -> Result<Arc<SpaceServiceRoomList>, ClientError> {
+    ) -> Result<Arc<SpaceRoomList>, ClientError> {
         let space_id = RoomId::parse(space_id)?;
-        Ok(Arc::new(SpaceServiceRoomList::new(self.inner.space_room_list(space_id))))
+        Ok(Arc::new(SpaceRoomList::new(self.inner.space_room_list(space_id))))
     }
 }
 
 #[derive(uniffi::Object)]
-pub struct SpaceServiceRoomList {
-    inner: UISpaceServiceRoomList,
+pub struct SpaceRoomList {
+    inner: UISpaceRoomList,
 }
 
-impl SpaceServiceRoomList {
-    pub fn new(inner: UISpaceServiceRoomList) -> Self {
+impl SpaceRoomList {
+    fn new(inner: UISpaceRoomList) -> Self {
         Self { inner }
     }
 }
 
 #[matrix_sdk_ffi_macros::export]
-impl SpaceServiceRoomList {
-    pub fn pagination_state(&self) -> SpaceServiceRoomListPaginationState {
-        self.inner.pagination_state().into()
+impl SpaceRoomList {
+    pub fn pagination_state(&self) -> SpaceRoomListPaginationState {
+        self.inner.pagination_state()
     }
 
     pub fn subscribe_to_pagination_state_updates(
         &self,
-        listener: Box<dyn SpaceServiceRoomListPaginationStateListener>,
+        listener: Box<dyn SpaceRoomListPaginationStateListener>,
     ) -> Arc<TaskHandle> {
         let pagination_state = self.inner.subscribe_to_pagination_state_updates();
 
         Arc::new(TaskHandle::new(get_runtime_handle().spawn(async move {
             pin_mut!(pagination_state);
 
             while let Some(state) = pagination_state.next().await {
-                listener.on_update(state.into());
+                listener.on_update(state);
             }
         })))
     }
 
-    pub fn rooms(&self) -> Vec<SpaceServiceRoom> {
+    pub fn rooms(&self) -> Vec<SpaceRoom> {
         self.inner.rooms().into_iter().map(Into::into).collect()
     }
 
     pub fn subscribe_to_room_update(
         &self,
-        listener: Box<dyn SpaceServiceRoomListEntriesListener>,
+        listener: Box<dyn SpaceRoomListEntriesListener>,
     ) -> Arc<TaskHandle> {
         let entries_stream = self.inner.subscribe_to_room_updates();
 
@@ -139,44 +138,23 @@ impl SpaceServiceRoomList {
     }
 }
 
-#[derive(uniffi::Enum)]
-pub enum SpaceServiceRoomListPaginationState {
-    Idle { end_reached: bool },
-    Loading,
-}
-
-impl From<UISpaceServiceRoomListPaginationState> for SpaceServiceRoomListPaginationState {
-    fn from(state: UISpaceServiceRoomListPaginationState) -> Self {
-        match state {
-            UISpaceServiceRoomListPaginationState::Idle { end_reached } => {
-                SpaceServiceRoomListPaginationState::Idle { end_reached }
-            }
-            UISpaceServiceRoomListPaginationState::Loading => {
-                SpaceServiceRoomListPaginationState::Loading
-            }
-        }
-    }
-}
-
 #[matrix_sdk_ffi_macros::export(callback_interface)]
-pub trait SpaceServiceRoomListPaginationStateListener:
-    SendOutsideWasm + SyncOutsideWasm + Debug
-{
-    fn on_update(&self, pagination_state: SpaceServiceRoomListPaginationState);
+pub trait SpaceRoomListPaginationStateListener: SendOutsideWasm + SyncOutsideWasm + Debug {
+    fn on_update(&self, pagination_state: SpaceRoomListPaginationState);
 }
 
 #[matrix_sdk_ffi_macros::export(callback_interface)]
-pub trait SpaceServiceRoomListEntriesListener: SendOutsideWasm + SyncOutsideWasm + Debug {
-    fn on_update(&self, rooms: Vec<SpaceServiceRoom>);
+pub trait SpaceRoomListEntriesListener: SendOutsideWasm + SyncOutsideWasm + Debug {
+    fn on_update(&self, rooms: Vec<SpaceRoom>);
 }
 
 #[matrix_sdk_ffi_macros::export(callback_interface)]
 pub trait SpaceServiceJoinedSpacesListener: SendOutsideWasm + SyncOutsideWasm + Debug {
-    fn on_update(&self, rooms: Vec<SpaceServiceRoom>);
+    fn on_update(&self, rooms: Vec<SpaceRoom>);
 }
 
 #[derive(uniffi::Record)]
-pub struct SpaceServiceRoom {
+pub struct SpaceRoom {
     pub room_id: String,
     pub canonical_alias: Option<String>,
     pub name: Option<String>,
@@ -193,8 +171,8 @@ pub struct SpaceServiceRoom {
     pub heroes: Option<Vec<RoomHero>>,
 }
 
-impl From<UISpaceServiceRoom> for SpaceServiceRoom {
-    fn from(room: UISpaceServiceRoom) -> Self {
+impl From<UISpaceRoom> for SpaceRoom {
+    fn from(room: UISpaceRoom) -> Self {
         Self {
             room_id: room.room_id.into(),
             canonical_alias: room.canonical_alias.map(|alias| alias.into()),

crates/matrix-sdk-ui/src/spaces/graph.rs

@@ -17,30 +17,30 @@ use std::collections::{BTreeMap, BTreeSet};
 use ruma::OwnedRoomId;
 
 #[derive(Debug)]
-struct SpaceServiceGraphNode {
+struct SpaceGraphNode {
     id: OwnedRoomId,
     parents: BTreeSet<OwnedRoomId>,
     children: BTreeSet<OwnedRoomId>,
 }
 
-impl SpaceServiceGraphNode {
+impl SpaceGraphNode {
     fn new(id: OwnedRoomId) -> Self {
         Self { id, parents: BTreeSet::new(), children: BTreeSet::new() }
     }
 }
 
 #[derive(Debug)]
-pub struct SpaceServiceGraph {
-    nodes: BTreeMap<OwnedRoomId, SpaceServiceGraphNode>,
+pub struct SpaceGraph {
+    nodes: BTreeMap<OwnedRoomId, SpaceGraphNode>,
 }
 
-impl Default for SpaceServiceGraph {
+impl Default for SpaceGraph {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl SpaceServiceGraph {
+impl SpaceGraph {
     pub fn new() -> Self {
         Self { nodes: BTreeMap::new() }
     }
@@ -54,15 +54,13 @@ impl SpaceServiceGraph {
     }
 
     pub fn add_node(&mut self, node_id: OwnedRoomId) {
-        self.nodes.entry(node_id.clone()).or_insert(SpaceServiceGraphNode::new(node_id));
+        self.nodes.entry(node_id.clone()).or_insert(SpaceGraphNode::new(node_id));
     }
 
     pub fn add_edge(&mut self, parent_id: OwnedRoomId, child_id: OwnedRoomId) {
-        self.nodes
-            .entry(parent_id.clone())
-            .or_insert(SpaceServiceGraphNode::new(parent_id.clone()));
+        self.nodes.entry(parent_id.clone()).or_insert(SpaceGraphNode::new(parent_id.clone()));
 
-        self.nodes.entry(child_id.clone()).or_insert(SpaceServiceGraphNode::new(child_id.clone()));
+        self.nodes.entry(child_id.clone()).or_insert(SpaceGraphNode::new(child_id.clone()));
 
         self.nodes.get_mut(&parent_id).unwrap().children.insert(child_id.clone());
         self.nodes.get_mut(&child_id).unwrap().parents.insert(parent_id);
@@ -124,7 +122,7 @@ mod tests {
 
     #[test]
     fn test_add_edge_and_root_nodes() {
-        let mut graph = SpaceServiceGraph::new();
+        let mut graph = SpaceGraph::new();
 
         let a = room_id!("!a:example.org").to_owned();
         let b = room_id!("!b:example.org").to_owned();
@@ -143,7 +141,7 @@ mod tests {
 
     #[test]
     fn test_remove_cycles() {
-        let mut graph = SpaceServiceGraph::new();
+        let mut graph = SpaceGraph::new();
 
         let a = room_id!("!a:example.org").to_owned();
         let b = room_id!("!b:example.org").to_owned();
@@ -163,7 +161,7 @@ mod tests {
 
     #[test]
     fn test_disconnected_graph_roots() {
-        let mut graph = SpaceServiceGraph::new();
+        let mut graph = SpaceGraph::new();
 
         let a = room_id!("!a:example.org").to_owned();
         let b = room_id!("!b:example.org").to_owned();
@@ -182,7 +180,7 @@ mod tests {
 
     #[test]
     fn test_multiple_parents() {
-        let mut graph = SpaceServiceGraph::new();
+        let mut graph = SpaceGraph::new();
 
         let a = room_id!("!a:example.org").to_owned();
         let b = room_id!("!b:example.org").to_owned();

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

@@ -29,8 +29,8 @@ use ruma::{
 };
 use tracing::error;
 
-use crate::spaces::graph::SpaceServiceGraph;
-pub use crate::spaces::{room::SpaceServiceRoom, room_list::SpaceServiceRoomList};
+use crate::spaces::graph::SpaceGraph;
+pub use crate::spaces::{room::SpaceRoom, room_list::SpaceRoomList};
 
 pub mod graph;
 pub mod room;
@@ -39,7 +39,7 @@ pub mod room_list;
 pub struct SpaceService {
     client: Client,
 
-    joined_spaces: SharedObservable<Vec<SpaceServiceRoom>>,
+    joined_spaces: SharedObservable<Vec<SpaceRoom>>,
 
     room_update_handle: Mutex<Option<JoinHandle<()>>>,
 }
@@ -61,7 +61,7 @@ impl SpaceService {
         }
     }
 
-    pub fn subscribe_to_joined_spaces(&self) -> Subscriber<Vec<SpaceServiceRoom>> {
+    pub fn subscribe_to_joined_spaces(&self) -> Subscriber<Vec<SpaceRoom>> {
         if self.room_update_handle.lock().is_none() {
             let client_clone = self.client.clone();
             let joined_spaces_clone = self.joined_spaces.clone();
@@ -89,7 +89,7 @@ impl SpaceService {
         self.joined_spaces.subscribe()
     }
 
-    pub async fn joined_spaces(&self) -> Vec<SpaceServiceRoom> {
+    pub async fn joined_spaces(&self) -> Vec<SpaceRoom> {
         let spaces = Self::joined_spaces_for(&self.client).await;
 
         if spaces != self.joined_spaces.get() {
@@ -99,18 +99,18 @@ impl SpaceService {
         spaces
     }
 
-    pub fn space_room_list(&self, space_id: OwnedRoomId) -> SpaceServiceRoomList {
-        SpaceServiceRoomList::new(self.client.clone(), space_id)
+    pub fn space_room_list(&self, space_id: OwnedRoomId) -> SpaceRoomList {
+        SpaceRoomList::new(self.client.clone(), space_id)
     }
 
-    async fn joined_spaces_for(client: &Client) -> Vec<SpaceServiceRoom> {
+    async fn joined_spaces_for(client: &Client) -> Vec<SpaceRoom> {
         let joined_spaces = client
             .joined_rooms()
             .into_iter()
             .filter_map(|room| room.is_space().then_some(room))
             .collect::<Vec<_>>();
 
-        let mut graph = SpaceServiceGraph::new();
+        let mut graph = SpaceGraph::new();
 
         for space in joined_spaces.iter() {
             graph.add_node(space.room_id().to_owned());
@@ -160,7 +160,7 @@ impl SpaceService {
                 let room_id = room.room_id().to_owned();
 
                 if root_notes.contains(&&room_id) {
-                    Some(SpaceServiceRoom::new_from_known(
+                    Some(SpaceRoom::new_from_known(
                         room.clone(),
                         graph.children_of(&room_id).len() as u64,
                     ))
@@ -346,7 +346,7 @@ mod tests {
 
         assert_eq!(
             space_service.joined_spaces().await,
-            vec![SpaceServiceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
+            vec![SpaceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
         );
 
         // Join the second space
@@ -375,17 +375,17 @@ mod tests {
         assert_eq!(
             space_service.joined_spaces().await,
             vec![
-                SpaceServiceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0),
-                SpaceServiceRoom::new_from_known(client.get_room(second_space_id).unwrap(), 1)
+                SpaceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0),
+                SpaceRoom::new_from_known(client.get_room(second_space_id).unwrap(), 1)
             ]
         );
 
         // The subscriber yields new results when a space is joined
         assert_next_eq!(
             joined_spaces_subscriber,
             vec![
-                SpaceServiceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0),
-                SpaceServiceRoom::new_from_known(client.get_room(second_space_id).unwrap(), 1)
+                SpaceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0),
+                SpaceRoom::new_from_known(client.get_room(second_space_id).unwrap(), 1)
             ]
         );
 
@@ -394,7 +394,7 @@ mod tests {
         // and when one is left
         assert_next_eq!(
             joined_spaces_subscriber,
-            vec![SpaceServiceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
+            vec![SpaceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
         );
 
         // but it doesn't when a non-space room gets joined
@@ -410,7 +410,7 @@ mod tests {
         assert_pending!(joined_spaces_subscriber);
         assert_eq!(
             space_service.joined_spaces().await,
-            vec![SpaceServiceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
+            vec![SpaceRoom::new_from_known(client.get_room(first_space_id).unwrap(), 0)]
         );
     }
 }

crates/matrix-sdk-ui/src/spaces/room.rs

@@ -20,7 +20,7 @@ use ruma::{
 };
 
 #[derive(Debug, Clone, PartialEq)]
-pub struct SpaceServiceRoom {
+pub struct SpaceRoom {
     pub room_id: OwnedRoomId,
     pub canonical_alias: Option<OwnedRoomAliasId>,
     pub name: Option<String>,
@@ -37,7 +37,7 @@ pub struct SpaceServiceRoom {
     pub heroes: Option<Vec<RoomHero>>,
 }
 
-impl SpaceServiceRoom {
+impl SpaceRoom {
     pub fn new_from_summary(
         summary: &RoomSummary,
         known_room: Option<Room>,