Add control::RoomLeaveRequest/Response and handle them.

src/client.rs

@@ -132,6 +132,9 @@ impl Client {
             control::Request::RoomJoinRequest(room_name) =>
                 self.handle_room_join_request(room_name),
 
+            control::Request::RoomLeaveRequest(room_name) =>
+                self.handle_room_leave_request(room_name),
+
             control::Request::RoomListRequest =>
                 self.handle_room_list_request(),
 
@@ -146,6 +149,28 @@ impl Client {
         }
     }
 
+    fn handle_login_status_request(&mut self) {
+        let username = config::USERNAME.to_string();
+
+        let response = match self.login_status {
+            LoginStatus::Pending =>
+                control::LoginStatusResponse::Pending{ username: username },
+
+            LoginStatus::Success(ref motd) =>
+                control::LoginStatusResponse::Success{
+                    username: username,
+                    motd: motd.clone(),
+                },
+
+            LoginStatus::Failure(ref reason) =>
+                control::LoginStatusResponse::Failure{
+                    username: username,
+                    reason: reason.clone(),
+                },
+        };
+        self.control_send(control::Response::LoginStatusResponse(response));
+    }
+
     fn handle_room_join_request(&mut self, room_name: String) {
         // First check that we are not already a member.
         // Enclosed in a block otherwise the mutable borrow of self.rooms
@@ -180,31 +205,40 @@ impl Client {
                 }
             }
         }
+
         self.server_send(ServerRequest::RoomJoinRequest(RoomJoinRequest {
             room_name: room_name
         }));
     }
 
-    fn handle_login_status_request(&mut self) {
-        let username = config::USERNAME.to_string();
-
-        let response = match self.login_status {
-            LoginStatus::Pending =>
-                control::LoginStatusResponse::Pending{ username: username },
+    fn handle_room_leave_request(&mut self, room_name: String) {
+        {
+            let room = match self.rooms.get_mut(&room_name) {
+                Some(room) => room,
+                None => {
+                    error!("Cannot leave unknown room {:?}", room_name);
+                    return;
+                }
+            };
 
-            LoginStatus::Success(ref motd) =>
-                control::LoginStatusResponse::Success{
-                    username: username,
-                    motd: motd.clone(),
+            match room.membership {
+                room::Membership::Member => {
+                    room.membership = room::Membership::Leaving;
                 },
 
-            LoginStatus::Failure(ref reason) =>
-                control::LoginStatusResponse::Failure{
-                    username: username,
-                    reason: reason.clone(),
-                },
-        };
-        self.control_send(control::Response::LoginStatusResponse(response));
+                membership => {
+                    error!(
+                        "Cannot leave room {:?}: current membership: {:?}",
+                        room_name, membership
+                    );
+                    return;
+                }
+            }
+        }
+
+        self.server_send(ServerRequest::RoomLeaveRequest(RoomLeaveRequest {
+            room_name: room_name
+        }));
     }
 
     fn handle_room_list_request(&mut self) {
@@ -314,11 +348,40 @@ impl Client {
             room_name: response.room_name
         };
         self.control_send(control::Response::RoomJoinResponse(
-                control_response));
+                control_response
+        ));
     }
 
     fn handle_room_leave_response(&mut self, response: RoomLeaveResponse) {
-        // TODO handle it.
+        {
+            let room = match self.rooms.get_mut(&response.room_name) {
+                Some(room) => room,
+                None => {
+                    error!(
+                        "Cannot leave room: unknown room {:?}",
+                        response.room_name,
+                    );
+                    return;
+                }
+            };
+
+            match room.membership {
+                room::Membership::Leaving => info!(
+                    "Leaving room {:?}", response.room_name
+                ),
+
+                membership => warn!(
+                    "Leaving room {:?} with wrong membership: {:?}",
+                    response.room_name, membership
+                ),
+            }
+
+            room.membership = room::Membership::NonMember;
+        }
+
+        self.control_send(control::Response::RoomLeaveResponse(
+                response.room_name
+        ));
     }
 
     fn handle_room_list_response(&mut self, response: RoomListResponse) {

src/control/request.rs

@@ -11,6 +11,8 @@ pub enum Request {
     DisconnectNotification,
     /// The controller wants to join a room. Contains the room name.
     RoomJoinRequest(String),
+    /// The controller wants to leave a rom. Contains the room name.
+    RoomLeaveRequest(String),
     /// The controller wants to know what the login status is.
     LoginStatusRequest,
     /// The controller wants to know the list of visible chat rooms.

src/control/response.rs

@@ -4,8 +4,9 @@ use room;
 /// to the controller.
 #[derive(Debug, RustcDecodable, RustcEncodable)]
 pub enum Response {
-    RoomJoinResponse(RoomJoinResponse),
     LoginStatusResponse(LoginStatusResponse),
+    RoomJoinResponse(RoomJoinResponse),
+    RoomLeaveResponse(String),
     RoomListResponse(RoomListResponse),
     RoomMessageResponse(RoomMessageResponse),
 }