Move set_tickers() from RoomMap to RoomEntry.

client/src/client.rs

@@ -577,9 +577,15 @@ impl Client {
     &mut self,
     response: server::RoomLeaveResponse,
   ) {
-    if let Err(err) = self.rooms.leave(&response.room_name) {
-      error!("RoomLeaveResponse: {}", err);
-    }
+    let room = match self.rooms.get_mut_strict(&response.room_name) {
+      Ok(room) => room,
+      Err(err) => {
+        error!("RoomLeaveResponse: {}", err);
+        return;
+      }
+    };
+
+    room.leave();
 
     self.send_to_controller(control::Response::RoomLeaveResponse(
       control::RoomLeaveResponse {
@@ -630,25 +636,31 @@ impl Client {
     &mut self,
     response: server::RoomTickersResponse,
   ) {
-    let result = self
-      .rooms
-      .set_tickers(&response.room_name, response.tickers);
-    if let Err(e) = result {
-      error!("RoomTickersResponse: {}", e);
-    }
+    let room = match self.rooms.get_mut_strict(&response.room_name) {
+      Ok(room) => room,
+      Err(err) => {
+        error!("RoomTickersResponse: {}", err);
+        return;
+      }
+    };
+
+    room.set_tickers(response.tickers);
   }
 
   fn handle_room_user_joined_response(
     &mut self,
     response: server::RoomUserJoinedResponse,
   ) {
-    let result = self
-      .rooms
-      .insert_member(&response.room_name, response.user.name.clone());
-    if let Err(err) = result {
-      error!("RoomUserJoinedResponse: {}", err);
-      return;
-    }
+    let room = match self.rooms.get_mut_strict(&response.room_name) {
+      Ok(room) => room,
+      Err(err) => {
+        error!("RoomUserJoinedResponse: {}", err);
+        return;
+      }
+    };
+
+    room.insert_member(response.user.name.clone());
+
     self.send_to_controller(control::Response::RoomUserJoinedResponse(
       control::RoomUserJoinedResponse {
         room_name: response.room_name,
@@ -661,13 +673,16 @@ impl Client {
     &mut self,
     response: server::RoomUserLeftResponse,
   ) {
-    let result = self
-      .rooms
-      .remove_member(&response.room_name, &response.user_name);
-    if let Err(err) = result {
-      error!("RoomUserLeftResponse: {}", err);
-      return;
-    }
+    let room = match self.rooms.get_mut_strict(&response.room_name) {
+      Ok(room) => room,
+      Err(err) => {
+        error!("RoomUserLeftResponse: {}", err);
+        return;
+      }
+    };
+
+    room.remove_member(&response.user_name);
+
     self.send_to_controller(control::Response::RoomUserLeftResponse(
       control::RoomUserLeftResponse {
         room_name: response.room_name,

client/src/room/map.rs

@@ -95,9 +95,8 @@ impl RoomEntry {
     self.state.members = members.iter().map(|user| user.name.clone()).collect();
   }
 
-  /// Records that we are now trying to leave the given room.
-  /// If the room is not found, or if its membership status is not `Member`,
-  /// returns an error.
+  /// Records that we are now trying to leave this room.
+  /// Returns an error if its membership status is not `Member`,
   #[cfg(test)]
   pub fn start_leaving(&mut self) -> Result<(), RoomMembershipChangeError> {
     match self.state.membership {
@@ -112,6 +111,35 @@ impl RoomEntry {
       )),
     }
   }
+
+  /// Records that we have now left this room.
+  pub fn leave(&mut self) {
+    match self.state.membership {
+      RoomMembership::Leaving => info!("Left room {:?}", self.name),
+
+      membership => warn!(
+        "Left room {:?} with wrong membership: {:?}",
+        self.name, membership
+      ),
+    }
+
+    self.state.membership = RoomMembership::NonMember;
+  }
+
+  /// Adds the given user to this room's members.
+  pub fn insert_member(&mut self, user_name: String) {
+    self.state.members.insert(user_name);
+  }
+
+  /// Removes the given user from this room's members.
+  pub fn remove_member(&mut self, user_name: &str) {
+    self.state.members.remove(user_name);
+  }
+
+  /// Sets this room's "tickers" to the given list.
+  pub fn set_tickers(&mut self, tickers: Vec<(String, String)>) {
+    self.state.tickers = tickers;
+  }
 }
 
 /// Contains the mapping from room names to room data and provides a clean
@@ -232,61 +260,6 @@ impl RoomMap {
     }
     rooms
   }
-
-  /// Records that we have now left the given room.
-  pub fn leave(&mut self, room_name: &str) -> Result<(), RoomError> {
-    let room = self.get_mut_strict(room_name)?;
-
-    match room.state.membership {
-      RoomMembership::Leaving => info!("Left room {:?}", room_name),
-
-      membership => warn!(
-        "Left room {:?} with wrong membership: {:?}",
-        room_name, membership
-      ),
-    }
-
-    room.state.membership = RoomMembership::NonMember;
-    Ok(())
-  }
-
-  /// Inserts the given user in the given room's set of members.
-  /// Returns an error if the room is not found.
-  pub fn insert_member(
-    &mut self,
-    room_name: &str,
-    user_name: String,
-  ) -> Result<(), RoomError> {
-    let room = self.get_mut_strict(room_name)?;
-    room.state.members.insert(user_name);
-    Ok(())
-  }
-
-  /// Removes the given user from the given room's set of members.
-  /// Returns an error if the room is not found.
-  pub fn remove_member(
-    &mut self,
-    room_name: &str,
-    user_name: &str,
-  ) -> Result<(), RoomError> {
-    let room = self.get_mut_strict(room_name)?;
-    room.state.members.remove(user_name);
-    Ok(())
-  }
-
-  /*---------*
-   * Tickers *
-   *---------*/
-
-  pub fn set_tickers(
-    &mut self,
-    room_name: &str,
-    tickers: Vec<(String, String)>,
-  ) -> Result<(), RoomError> {
-    let room = self.get_mut_strict(room_name)?;
-    room.state.tickers = tickers;
-    Ok(())
-  }
 }
 
 #[cfg(test)]
@@ -392,6 +365,27 @@ mod tests {
     );
   }
 
+  #[test]
+  fn entry_leave() {
+    let mut room = RoomEntry::new(
+      "bleep".to_string(),
+      RoomState {
+        membership: RoomMembership::Member,
+        ..RoomState::default()
+      },
+    );
+
+    room.leave();
+
+    assert_eq!(
+      room.into_state(),
+      RoomState {
+        membership: RoomMembership::NonMember,
+        ..RoomState::default()
+      }
+    );
+  }
+
   #[test]
   fn map_new_is_empty() {
     assert_eq!(RoomMap::new().get_room_list(), vec![]);