Run rustfmt.

src/client.rs

@@ -12,7 +12,6 @@ use proto::server;
 use room;
 use user;
 
-
 #[derive(Debug)]
 enum IncomingMessage {
     Proto(proto::Response),
@@ -101,7 +100,9 @@ impl Client {
         ));
 
         self.send_to_server(server::ServerRequest::SetListenPortRequest(
-            server::SetListenPortRequest { port: config::LISTEN_PORT },
+            server::SetListenPortRequest {
+                port: config::LISTEN_PORT,
+            },
         ));
 
         loop {
@@ -202,7 +203,6 @@ impl Client {
             }
 
             control::Request::UserListRequest => self.handle_user_list_request(),
-
             /*
             _ =>{
                 error!("Unhandled control request: {:?}", request);
@@ -236,8 +236,8 @@ impl Client {
                 info!("Requesting to join room {:?}", room_name);
                 self.send_to_server(server::ServerRequest::RoomJoinRequest(
                     server::RoomJoinRequest {
-                        room_name: room_name
-                    }
+                        room_name: room_name,
+                    },
                 ));
             }
 
@@ -251,8 +251,8 @@ impl Client {
                 info!("Requesting to leave room {:?}", room_name);
                 self.send_to_server(server::ServerRequest::RoomLeaveRequest(
                     server::RoomLeaveRequest {
-                        room_name: room_name
-                    }
+                        room_name: room_name,
+                    },
                 ));
             }
 
@@ -284,7 +284,9 @@ impl Client {
         // Send the controller client what we have in memory.
         let user_list = self.users.get_list();
         self.send_to_controller(control::Response::UserListResponse(
-            control::UserListResponse { user_list: user_list },
+            control::UserListResponse {
+                user_list: user_list,
+            },
         ));
     }
 
@@ -314,8 +316,7 @@ impl Client {
 
     fn handle_peer_connection_closed(&mut self, peer_id: usize) {
         let mut occupied_entry = match self.peers.entry(peer_id) {
-            None |
-            Some(slab::Entry::Vacant(_)) => {
+            None | Some(slab::Entry::Vacant(_)) => {
                 error!("Unknown peer connection {} has closed", peer_id);
                 return;
             }
@@ -348,13 +349,11 @@ impl Client {
 
                 self.proto_tx
                     .send(proto::Request::ServerRequest(
-                        server::ServerRequest::ConnectToPeerRequest(
-                            server::ConnectToPeerRequest {
-                                token: peer.token,
-                                user_name: peer.user_name.clone(),
-                                connection_type: peer.connection_type.clone(),
-                            },
-                        ),
+                        server::ServerRequest::ConnectToPeerRequest(server::ConnectToPeerRequest {
+                            token: peer.token,
+                            user_name: peer.user_name.clone(),
+                            connection_type: peer.connection_type.clone(),
+                        }),
                     ))
                     .unwrap();
             }
@@ -368,12 +367,10 @@ impl Client {
                 let (peer, _) = occupied_entry.remove();
                 self.proto_tx
                     .send(proto::Request::ServerRequest(
-                        server::ServerRequest::CannotConnectRequest(
-                            server::CannotConnectRequest {
-                                token: peer.token,
-                                user_name: peer.user_name,
-                            },
-                        ),
+                        server::ServerRequest::CannotConnectRequest(server::CannotConnectRequest {
+                            token: peer.token,
+                            user_name: peer.user_name,
+                        }),
                     ))
                     .unwrap();
             }
@@ -387,17 +384,32 @@ impl Client {
                 return;
             }
 
-            Some(peer @ &mut Peer { state: PeerState::Open, .. }) => {
+            Some(
+                peer @ &mut Peer {
+                    state: PeerState::Open,
+                    ..
+                },
+            ) => {
                 error!("Peer connection {} was already open: {:?}", peer_id, peer);
                 return;
             }
 
-            Some(peer @ &mut Peer { state: PeerState::WaitingFirewalled, .. }) => {
+            Some(
+                peer @ &mut Peer {
+                    state: PeerState::WaitingFirewalled,
+                    ..
+                },
+            ) => {
                 error!("Peer connection {} was waiting: {:?}", peer_id, peer);
                 return;
             }
 
-            Some(peer @ &mut Peer { state: PeerState::Opening, .. }) => {
+            Some(
+                peer @ &mut Peer {
+                    state: PeerState::Opening,
+                    ..
+                },
+            ) => {
                 info!("Peer connection {} is now open: {:?}", peer_id, peer);
                 // Mark it as open.
                 peer.state = PeerState::Open;
@@ -409,7 +421,12 @@ impl Client {
                 })
             }
 
-            Some(peer @ &mut Peer { state: PeerState::OpeningFirewalled, .. }) => {
+            Some(
+                peer @ &mut Peer {
+                    state: PeerState::OpeningFirewalled,
+                    ..
+                },
+            ) => {
                 info!("Peer connection {} is now open: {:?}", peer_id, peer);
                 // Mark it as open.
                 peer.state = PeerState::Open;
@@ -495,9 +512,7 @@ impl Client {
             Ok(peer_id) => {
                 info!(
                     "Opening peer connection {} to {}:{} to pierce firewall",
-                    peer_id,
-                    response.ip,
-                    response.port
+                    peer_id, response.ip, response.port
                 );
                 self.proto_tx
                     .send(proto::Request::PeerConnect(
@@ -536,12 +551,10 @@ impl Client {
                                 "as official client"
                             ));
                         }
-                        None => {
-                            info!(concat!(
-                                "Connected to official server ",
-                                "as unofficial client"
-                            ))
-                        }
+                        None => info!(concat!(
+                            "Connected to official server ",
+                            "as unofficial client"
+                        )),
                     }
                     self.login_status = LoginStatus::Success(motd);
                 }
@@ -581,7 +594,9 @@ impl Client {
             self.users.insert(user);
         }
 
-        let control_response = control::RoomJoinResponse { room_name: response.room_name };
+        let control_response = control::RoomJoinResponse {
+            room_name: response.room_name,
+        };
         self.send_to_controller(control::Response::RoomJoinResponse(control_response));
     }
 
@@ -591,7 +606,9 @@ impl Client {
         }
 
         self.send_to_controller(control::Response::RoomLeaveResponse(
-            control::RoomLeaveResponse { room_name: response.room_name },
+            control::RoomLeaveResponse {
+                room_name: response.room_name,
+            },
         ));
     }
 
@@ -628,20 +645,18 @@ impl Client {
     }
 
     fn handle_room_tickers_response(&mut self, response: server::RoomTickersResponse) {
-        let result = self.rooms.set_tickers(
-            &response.room_name,
-            response.tickers,
-        );
+        let result = self
+            .rooms
+            .set_tickers(&response.room_name, response.tickers);
         if let Err(e) = result {
             error!("RoomTickersResponse: {}", e);
         }
     }
 
     fn handle_room_user_joined_response(&mut self, response: server::RoomUserJoinedResponse) {
-        let result = self.rooms.insert_member(
-            &response.room_name,
-            response.user.name.clone(),
-        );
+        let result = self
+            .rooms
+            .insert_member(&response.room_name, response.user.name.clone());
         if let Err(err) = result {
             error!("RoomUserJoinedResponse: {}", err);
             return;
@@ -655,10 +670,9 @@ impl Client {
     }
 
     fn handle_room_user_left_response(&mut self, response: server::RoomUserLeftResponse) {
-        let result = self.rooms.remove_member(
-            &response.room_name,
-            &response.user_name,
-        );
+        let result = self
+            .rooms
+            .remove_member(&response.room_name, &response.user_name);
         if let Err(err) = result {
             error!("RoomUserLeftResponse: {}", err);
             return;

src/control/mod.rs

@@ -2,6 +2,6 @@ mod request;
 mod response;
 mod ws;
 
-pub use self::ws::{listen, Notification, Sender, SendError};
 pub use self::request::*;
 pub use self::response::*;
+pub use self::ws::{listen, Notification, SendError, Sender};

src/control/ws.rs

@@ -112,16 +112,15 @@ impl Handler {
 impl ws::Handler for Handler {
     fn on_open(&mut self, _: ws::Handshake) -> ws::Result<()> {
         info!("Websocket open");
-        self.send_to_client(Notification::Connected(
-            Sender { sender: self.socket_tx.clone() },
-        ))
+        self.send_to_client(Notification::Connected(Sender {
+            sender: self.socket_tx.clone(),
+        }))
     }
 
     fn on_close(&mut self, code: ws::CloseCode, reason: &str) {
         info!("Websocket closed: code: {:?}, reason: {:?}", code, reason);
-        self.send_to_client(Notification::Disconnected).unwrap_or(
-            (),
-        )
+        self.send_to_client(Notification::Disconnected)
+            .unwrap_or(())
     }
 
     fn on_message(&mut self, msg: ws::Message) -> ws::Result<()> {
@@ -161,11 +160,9 @@ pub fn listen(client_tx: mpsc::Sender<Notification>) {
             max_connections: 1,
             ..ws::Settings::default()
         })
-        .build(|socket_tx| {
-            Handler {
-                client_tx: client_tx.clone(),
-                socket_tx: socket_tx,
-            }
+        .build(|socket_tx| Handler {
+            client_tx: client_tx.clone(),
+            socket_tx: socket_tx,
         });
 
     let websocket = match websocket_result {
@@ -173,9 +170,10 @@ pub fn listen(client_tx: mpsc::Sender<Notification>) {
         Err(e) => {
             error!("Unable to build websocket: {}", e);
             client_tx
-                .send(Notification::Error(
-                    format!("Unable to build websocket: {}", e),
-                ))
+                .send(Notification::Error(format!(
+                    "Unable to build websocket: {}",
+                    e
+                )))
                 .unwrap();
             return;
         }
@@ -188,9 +186,10 @@ pub fn listen(client_tx: mpsc::Sender<Notification>) {
         Err(e) => {
             error!("Unable to listen on websocket: {}", e);
             client_tx
-                .send(Notification::Error(
-                    format!("Unable to listen on websocket: {}", e),
-                ))
+                .send(Notification::Error(format!(
+                    "Unable to listen on websocket: {}",
+                    e
+                )))
                 .unwrap();
         }
     }

src/proto/codec.rs

@@ -4,8 +4,8 @@ use std::net;
 use std::u16;
 
 use bytes::{Buf, BufMut, BytesMut, LittleEndian};
-use encoding::{Encoding, EncoderTrap, DecoderTrap};
 use encoding::all::WINDOWS_1252;
+use encoding::{DecoderTrap, EncoderTrap, Encoding};
 
 // Constants
 // ---------
@@ -123,11 +123,9 @@ impl<T: Buf> Decode<String> for T {
 
         let result = {
             let bytes = &self.bytes()[..len];
-            WINDOWS_1252.decode(bytes, DecoderTrap::Strict).map_err(
-                |err| {
-                    invalid_data_error("string", (err, bytes))
-                },
-            )
+            WINDOWS_1252
+                .decode(bytes, DecoderTrap::Strict)
+                .map_err(|err| invalid_data_error("string", (err, bytes)))
         };
 
         self.advance(len);
@@ -324,7 +322,7 @@ pub mod tests {
 
     use bytes::{Buf, BytesMut};
 
-    use super::{Decode, ProtoEncoder, ProtoEncode};
+    use super::{Decode, ProtoEncode, ProtoEncoder};
 
     pub fn roundtrip<T>(input: T)
     where
@@ -570,13 +568,12 @@ pub mod tests {
     }
 
     // A few strings and their corresponding encodings.
-    const STRING_ENCODINGS: [(&'static str, &'static [u8]); 3] =
-        [
-            ("", &[0, 0, 0, 0]),
-            ("hey!", &[4, 0, 0, 0, 104, 101, 121, 33]),
-            // Windows 1252 specific codepoints.
-            ("‘’“”€", &[5, 0, 0, 0, 145, 146, 147, 148, 128]),
-        ];
+    const STRING_ENCODINGS: [(&'static str, &'static [u8]); 3] = [
+        ("", &[0, 0, 0, 0]),
+        ("hey!", &[4, 0, 0, 0, 104, 101, 121, 33]),
+        // Windows 1252 specific codepoints.
+        ("‘’“”€", &[5, 0, 0, 0, 145, 146, 147, 148, 128]),
+    ];
 
     #[test]
     fn encode_string() {

src/proto/handler.rs

@@ -9,9 +9,9 @@ use slab;
 
 use config;
 
-use super::{Intent, Stream, SendPacket};
-use super::server::*;
 use super::peer;
+use super::server::*;
+use super::{Intent, SendPacket, Stream};
 
 /*===========*
  * CONSTANTS *
@@ -315,10 +315,7 @@ impl mio::deprecated::Handler for Handler {
                 if let Err(err) = self.connect_to_peer(peer_id, ip, port, event_loop) {
                     error!(
                         "Cannot open peer connection {} to {}:{}: {}",
-                        peer_id,
-                        ip,
-                        port,
-                        err
+                        peer_id, ip, port, err
                     );
                     self.client_tx
                         .send(Response::PeerConnectionClosed(peer_id))
@@ -332,8 +329,7 @@ impl mio::deprecated::Handler for Handler {
                     None => {
                         error!(
                             "Cannot send peer message {:?}: unknown id {}",
-                            message,
-                            peer_id
+                            message, peer_id
                         );
                         return;
                     }

src/proto/mod.rs

@@ -11,6 +11,6 @@ mod user;
 pub use self::codec::{Decode, ProtoEncode, ProtoEncoder};
 pub use self::handler::*;
 pub use self::packet::*;
+pub use self::server::{ServerRequest, ServerResponse};
 pub use self::stream::*;
-pub use self::server::{ServerResponse, ServerRequest};
 pub use self::user::{User, UserStatus};

src/proto/packet.rs

@@ -1,13 +1,13 @@
 use std::error;
 use std::fmt;
 use std::io;
+use std::io::{Read, Write};
 use std::mem;
 use std::net;
-use std::io::{Read, Write};
 
 use byteorder::{ByteOrder, LittleEndian, ReadBytesExt, WriteBytesExt};
-use encoding::{Encoding, DecoderTrap, EncoderTrap};
 use encoding::all::ISO_8859_1;
+use encoding::{DecoderTrap, EncoderTrap, Encoding};
 use mio::deprecated::TryRead;
 
 use super::constants::*;
@@ -73,7 +73,9 @@ impl MutPacket {
     /// Returns an empty packet with the given packet code.
     pub fn new() -> Self {
         // Leave space for the eventual size of the packet.
-        MutPacket { bytes: vec![0; U32_SIZE] }
+        MutPacket {
+            bytes: vec![0; U32_SIZE],
+        }
     }
 
     /// Provides the main way to write data into a binary packet.

src/proto/peer/message.rs

@@ -2,9 +2,11 @@ use std::io;
 
 use bytes;
 
-use proto::{Decode, MutPacket, Packet, PacketReadError, ProtoEncode, ProtoEncoder, ReadFromPacket,
-            WriteToPacket};
 use proto::peer::constants::*;
+use proto::{
+    Decode, MutPacket, Packet, PacketReadError, ProtoEncode, ProtoEncoder, ReadFromPacket,
+    WriteToPacket,
+};
 
 /*=========*
  * MESSAGE *
@@ -33,8 +35,7 @@ impl ReadFromPacket for Message {
         if bytes_remaining > 0 {
             warn!(
                 "Peer message with code {} contains {} extra bytes",
-                code,
-                bytes_remaining
+                code, bytes_remaining
             )
         }
 
@@ -158,8 +159,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::{Decode, ProtoEncoder};
     use proto::codec::tests::{expect_io_error, roundtrip};
+    use proto::{Decode, ProtoEncoder};
 
     use super::*;
 

src/proto/server/request.rs

@@ -1,12 +1,12 @@
 use std::io;
 
 use bytes;
-use crypto::md5::Md5;
 use crypto::digest::Digest;
+use crypto::md5::Md5;
 
-use proto::{Decode, ProtoEncode, ProtoEncoder};
 use proto::packet::{MutPacket, WriteToPacket};
 use proto::server::constants::*;
+use proto::{Decode, ProtoEncode, ProtoEncoder};
 
 /* ------- *
  * Helpers *
@@ -447,7 +447,9 @@ impl ProtoEncode for RoomJoinRequest {
 impl<T: bytes::Buf> Decode<RoomJoinRequest> for T {
     fn decode(&mut self) -> io::Result<RoomJoinRequest> {
         let room_name = self.decode()?;
-        Ok(RoomJoinRequest { room_name: room_name })
+        Ok(RoomJoinRequest {
+            room_name: room_name,
+        })
     }
 }
 
@@ -476,7 +478,9 @@ impl ProtoEncode for RoomLeaveRequest {
 impl<T: bytes::Buf> Decode<RoomLeaveRequest> for T {
     fn decode(&mut self) -> io::Result<RoomLeaveRequest> {
         let room_name = self.decode()?;
-        Ok(RoomLeaveRequest { room_name: room_name })
+        Ok(RoomLeaveRequest {
+            room_name: room_name,
+        })
     }
 }
 
@@ -567,7 +571,9 @@ impl ProtoEncode for UserStatusRequest {
 impl<T: bytes::Buf> Decode<UserStatusRequest> for T {
     fn decode(&mut self) -> io::Result<UserStatusRequest> {
         let user_name = self.decode()?;
-        Ok(UserStatusRequest { user_name: user_name })
+        Ok(UserStatusRequest {
+            user_name: user_name,
+        })
     }
 }
 
@@ -581,8 +587,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::{Decode, ProtoEncoder};
     use proto::codec::tests::{expect_io_error, roundtrip};
+    use proto::{Decode, ProtoEncoder};
 
     use super::*;
 
@@ -639,30 +645,29 @@ mod tests {
     #[test]
     fn roundtrip_login_request() {
         roundtrip(ServerRequest::LoginRequest(
-            LoginRequest::new("alice", "password1234", 1337, 42)
-                .unwrap(),
+            LoginRequest::new("alice", "password1234", 1337, 42).unwrap(),
         ))
     }
 
     #[test]
     fn roundtrip_peer_address_request() {
-        roundtrip(ServerRequest::PeerAddressRequest(
-            PeerAddressRequest { username: "alice".to_string() },
-        ))
+        roundtrip(ServerRequest::PeerAddressRequest(PeerAddressRequest {
+            username: "alice".to_string(),
+        }))
     }
 
     #[test]
     fn roundtrip_room_join_request() {
-        roundtrip(ServerRequest::RoomJoinRequest(
-            RoomJoinRequest { room_name: "best room ever".to_string() },
-        ))
+        roundtrip(ServerRequest::RoomJoinRequest(RoomJoinRequest {
+            room_name: "best room ever".to_string(),
+        }))
     }
 
     #[test]
     fn roundtrip_room_leave_request() {
-        roundtrip(ServerRequest::RoomLeaveRequest(
-            RoomLeaveRequest { room_name: "best room ever".to_string() },
-        ))
+        roundtrip(ServerRequest::RoomLeaveRequest(RoomLeaveRequest {
+            room_name: "best room ever".to_string(),
+        }))
     }
 
     #[test]
@@ -680,15 +685,15 @@ mod tests {
 
     #[test]
     fn roundtrip_set_listen_port_request() {
-        roundtrip(ServerRequest::SetListenPortRequest(
-            SetListenPortRequest { port: 1337 },
-        ))
+        roundtrip(ServerRequest::SetListenPortRequest(SetListenPortRequest {
+            port: 1337,
+        }))
     }
 
     #[test]
     fn roundtrip_user_status_request() {
-        roundtrip(ServerRequest::UserStatusRequest(
-            UserStatusRequest { user_name: "alice".to_string() },
-        ))
+        roundtrip(ServerRequest::UserStatusRequest(UserStatusRequest {
+            user_name: "alice".to_string(),
+        }))
     }
 }

src/proto/server/response.rs

@@ -3,9 +3,9 @@ use std::net;
 
 use bytes;
 
+use proto::packet::{Packet, PacketReadError, ReadFromPacket};
 use proto::server::constants::*;
 use proto::{Decode, ProtoEncode, ProtoEncoder, User, UserStatus};
-use proto::packet::{Packet, PacketReadError, ReadFromPacket};
 
 /*=================*
  * SERVER RESPONSE *
@@ -40,9 +40,9 @@ impl ReadFromPacket for ServerResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
         let code: u32 = try!(packet.read_value());
         let resp = match code {
-            CODE_CONNECT_TO_PEER => ServerResponse::ConnectToPeerResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_CONNECT_TO_PEER => {
+                ServerResponse::ConnectToPeerResponse(try!(packet.read_value()))
+            }
 
             CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(try!(packet.read_value())),
 
@@ -50,9 +50,9 @@ impl ReadFromPacket for ServerResponse {
 
             CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(try!(packet.read_value())),
 
-            CODE_PRIVILEGED_USERS => ServerResponse::PrivilegedUsersResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_PRIVILEGED_USERS => {
+                ServerResponse::PrivilegedUsersResponse(try!(packet.read_value()))
+            }
 
             CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(try!(packet.read_value())),
 
@@ -64,9 +64,9 @@ impl ReadFromPacket for ServerResponse {
 
             CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(try!(packet.read_value())),
 
-            CODE_ROOM_USER_JOINED => ServerResponse::RoomUserJoinedResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_ROOM_USER_JOINED => {
+                ServerResponse::RoomUserJoinedResponse(try!(packet.read_value()))
+            }
 
             CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(try!(packet.read_value())),
 
@@ -74,17 +74,17 @@ impl ReadFromPacket for ServerResponse {
 
             CODE_USER_STATUS => ServerResponse::UserStatusResponse(try!(packet.read_value())),
 
-            CODE_WISHLIST_INTERVAL => ServerResponse::WishlistIntervalResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_WISHLIST_INTERVAL => {
+                ServerResponse::WishlistIntervalResponse(try!(packet.read_value()))
+            }
 
-            CODE_PARENT_MIN_SPEED => ServerResponse::ParentMinSpeedResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_PARENT_MIN_SPEED => {
+                ServerResponse::ParentMinSpeedResponse(try!(packet.read_value()))
+            }
 
-            CODE_PARENT_SPEED_RATIO => ServerResponse::ParentSpeedRatioResponse(
-                try!(packet.read_value()),
-            ),
+            CODE_PARENT_SPEED_RATIO => {
+                ServerResponse::ParentSpeedRatioResponse(try!(packet.read_value()))
+            }
 
             code => ServerResponse::UnknownResponse(code),
         };
@@ -92,8 +92,7 @@ impl ReadFromPacket for ServerResponse {
         if bytes_remaining > 0 {
             warn!(
                 "Packet with code {} contains {} extra bytes",
-                code,
-                bytes_remaining
+                code, bytes_remaining
             )
         }
         Ok(resp)
@@ -385,7 +384,9 @@ pub enum LoginResponse {
         ip: net::Ipv4Addr,
         password_md5_opt: Option<String>,
     },
-    LoginFail { reason: String },
+    LoginFail {
+        reason: String,
+    },
 }
 
 impl ReadFromPacket for LoginResponse {
@@ -672,16 +673,14 @@ impl RoomJoinResponse {
         }
 
         let num_users = self.users.len();
-        if num_users != num_statuses || num_users != num_infos || num_users != num_free_slots ||
-            num_users != num_countries
+        if num_users != num_statuses
+            || num_users != num_infos
+            || num_users != num_free_slots
+            || num_users != num_countries
         {
             warn!(
                 "RoomJoinResponse: mismatched vector sizes {}, {}, {}, {}, {}",
-                num_users,
-                num_statuses,
-                num_infos,
-                num_free_slots,
-                num_countries
+                num_users, num_statuses, num_infos, num_free_slots, num_countries
             );
         }
 
@@ -863,7 +862,9 @@ pub struct RoomLeaveResponse {
 
 impl ReadFromPacket for RoomLeaveResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
-        Ok(RoomLeaveResponse { room_name: try!(packet.read_value()) })
+        Ok(RoomLeaveResponse {
+            room_name: try!(packet.read_value()),
+        })
     }
 }
 
@@ -926,8 +927,7 @@ impl RoomListResponse {
         if num_rooms != num_user_counts {
             warn!(
                 "Numbers of rooms and user counts do not match: {} != {}",
-                num_rooms,
-                num_user_counts
+                num_rooms, num_user_counts
             );
         }
 
@@ -1344,8 +1344,8 @@ mod tests {
 
     use bytes::BytesMut;
 
-    use proto::{Decode, ProtoEncoder};
     use proto::codec::tests::{expect_io_error, roundtrip};
+    use proto::{Decode, ProtoEncoder};
 
     use super::*;
 
@@ -1484,9 +1484,9 @@ mod tests {
 
     #[test]
     fn roundtrip_room_leave() {
-        roundtrip(ServerResponse::RoomLeaveResponse(
-            RoomLeaveResponse { room_name: "red".to_string() },
-        ))
+        roundtrip(ServerResponse::RoomLeaveResponse(RoomLeaveResponse {
+            room_name: "red".to_string(),
+        }))
     }
 
     #[test]

src/proto/transport.rs

@@ -2,11 +2,11 @@ use std::fmt;
 use std::io;
 
 use bytes::{Buf, BytesMut};
-use tokio_io::{AsyncRead, AsyncWrite};
 use tokio_io::codec::length_delimited;
+use tokio_io::{AsyncRead, AsyncWrite};
 
 use proto::peer;
-use proto::{Decode, ProtoEncode, ProtoEncoder, ServerResponse, ServerRequest};
+use proto::{Decode, ProtoEncode, ProtoEncoder, ServerRequest, ServerResponse};
 
 fn decode_frame<'a, T>(frame_type: &str, bytes: &'a mut BytesMut) -> io::Result<T>
 where

src/proto/user.rs

@@ -2,8 +2,10 @@ use std::io;
 
 use bytes;
 
-use proto::{Decode, MutPacket, Packet, PacketReadError, ProtoEncode, ProtoEncoder, ReadFromPacket,
-            WriteToPacket};
+use proto::{
+    Decode, MutPacket, Packet, PacketReadError, ProtoEncode, ProtoEncoder, ReadFromPacket,
+    WriteToPacket,
+};
 
 const STATUS_OFFLINE: u32 = 1;
 const STATUS_AWAY: u32 = 2;

src/room.rs

@@ -94,14 +94,11 @@ impl fmt::Display for Error {
         match *self {
             Error::RoomNotFound(ref room_name) => write!(f, "room {:?} not found", room_name),
 
-            Error::MembershipChangeInvalid(old_membership, new_membership) => {
-                write!(
-                    f,
-                    "cannot change membership from {:?} to {:?}",
-                    old_membership,
-                    new_membership
-                )
-            }
+            Error::MembershipChangeInvalid(old_membership, new_membership) => write!(
+                f,
+                "cannot change membership from {:?} to {:?}",
+                old_membership, new_membership
+            ),
         }
     }
 }
@@ -126,7 +123,9 @@ pub struct RoomMap {
 impl RoomMap {
     /// Creates an empty mapping.
     pub fn new() -> Self {
-        RoomMap { map: collections::HashMap::new() }
+        RoomMap {
+            map: collections::HashMap::new(),
+        }
     }
 
     /// Looks up the given room name in the map, returning an immutable
@@ -220,12 +219,10 @@ impl RoomMap {
                 Ok(())
             }
 
-            membership => {
-                Err(Error::MembershipChangeInvalid(
-                    membership,
-                    Membership::Joining,
-                ))
-            }
+            membership => Err(Error::MembershipChangeInvalid(
+                membership,
+                Membership::Joining,
+            )),
         }
     }
 
@@ -247,8 +244,7 @@ impl RoomMap {
         } else {
             warn!(
                 "Joined room {:?} but membership was already {:?}",
-                room_name,
-                room.membership
+                room_name, room.membership
             );
         }
 
@@ -282,12 +278,10 @@ impl RoomMap {
                 Ok(())
             }
 
-            membership => {
-                Err(Error::MembershipChangeInvalid(
-                    membership,
-                    Membership::Leaving,
-                ))
-            }
+            membership => Err(Error::MembershipChangeInvalid(
+                membership,
+                Membership::Leaving,
+            )),
         }
     }
 
@@ -298,13 +292,10 @@ impl RoomMap {
         match room.membership {
             Membership::Leaving => info!("Left room {:?}", room_name),
 
-            membership => {
-                warn!(
-                    "Left room {:?} with wrong membership: {:?}",
-                    room_name,
-                    membership
-                )
-            }
+            membership => warn!(
+                "Left room {:?} with wrong membership: {:?}",
+                room_name, membership
+            ),
         }
 
         room.membership = Membership::NonMember;

src/user.rs

@@ -53,7 +53,9 @@ impl UserMap {
     pub fn get_mut_strict(&mut self, user_name: &str) -> Result<&mut User, UserNotFoundError> {
         match self.map.get_mut(user_name) {
             Some(user) => Ok(user),
-            None => Err(UserNotFoundError { user_name: user_name.to_string() }),
+            None => Err(UserNotFoundError {
+                user_name: user_name.to_string(),
+            }),
         }
     }