Set 80-char line width.

rustfmt.toml

@@ -0,0 +1 @@
+max_width = 80

src/client.rs

@@ -114,7 +114,9 @@ impl Client {
 
         loop {
             match self.recv() {
-                IncomingMessage::Proto(response) => self.handle_proto_response(response),
+                IncomingMessage::Proto(response) => {
+                    self.handle_proto_response(response)
+                }
 
                 IncomingMessage::ControlNotification(notif) => {
                     self.handle_control_notification(notif)
@@ -186,7 +188,9 @@ impl Client {
                 self.control_tx = None;
             }
 
-            control::Notification::Request(req) => self.handle_control_request(req),
+            control::Notification::Request(req) => {
+                self.handle_control_request(req)
+            }
         }
     }
 
@@ -196,7 +200,9 @@ impl Client {
 
     fn handle_control_request(&mut self, request: control::Request) {
         match request {
-            control::Request::LoginStatusRequest => self.handle_login_status_request(),
+            control::Request::LoginStatusRequest => {
+                self.handle_login_status_request()
+            }
 
             control::Request::RoomJoinRequest(room_name) => {
                 self.handle_room_join_request(room_name)
@@ -206,13 +212,17 @@ impl Client {
                 self.handle_room_leave_request(room_name)
             }
 
-            control::Request::RoomListRequest => self.handle_room_list_request(),
+            control::Request::RoomListRequest => {
+                self.handle_room_list_request()
+            }
 
             control::Request::RoomMessageRequest(request) => {
                 self.handle_room_message_request(request)
             }
 
-            control::Request::UserListRequest => self.handle_user_list_request(),
+            control::Request::UserListRequest => {
+                self.handle_user_list_request()
+            }
             /*
             _ =>{
                 error!("Unhandled control request: {:?}", request);
@@ -225,22 +235,30 @@ impl Client {
         let username = config::USERNAME.to_string();
 
         let response = match self.login_status {
-            LoginStatus::Todo => control::LoginStatusResponse::Pending { username: username },
+            LoginStatus::Todo => {
+                control::LoginStatusResponse::Pending { username: username }
+            }
             LoginStatus::AwaitingResponse => {
                 control::LoginStatusResponse::Pending { username: username }
             }
 
-            LoginStatus::Success(ref motd) => control::LoginStatusResponse::Success {
-                username: username,
-                motd: motd.clone(),
-            },
+            LoginStatus::Success(ref motd) => {
+                control::LoginStatusResponse::Success {
+                    username: username,
+                    motd: motd.clone(),
+                }
+            }
 
-            LoginStatus::Failure(ref reason) => control::LoginStatusResponse::Failure {
-                username: username,
-                reason: reason.clone(),
-            },
+            LoginStatus::Failure(ref reason) => {
+                control::LoginStatusResponse::Failure {
+                    username: username,
+                    reason: reason.clone(),
+                }
+            }
         };
-        self.send_to_controller(control::Response::LoginStatusResponse(response));
+        self.send_to_controller(control::Response::LoginStatusResponse(
+            response,
+        ));
     }
 
     fn handle_room_join_request(&mut self, room_name: String) {
@@ -284,7 +302,10 @@ impl Client {
         self.send_to_server(server::ServerRequest::RoomListRequest);
     }
 
-    fn handle_room_message_request(&mut self, request: control::RoomMessageRequest) {
+    fn handle_room_message_request(
+        &mut self,
+        request: control::RoomMessageRequest,
+    ) {
         self.send_to_server(server::ServerRequest::RoomMessageRequest(
             server::RoomMessageRequest {
                 room_name: request.room_name,
@@ -363,11 +384,13 @@ impl Client {
                 #[allow(deprecated)]
                 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();
             }
@@ -382,10 +405,12 @@ impl Client {
                 #[allow(deprecated)]
                 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();
             }
@@ -407,7 +432,10 @@ impl Client {
                     ..
                 },
             ) => {
-                error!("Peer connection {} was already open: {:?}", peer_id, peer);
+                error!(
+                    "Peer connection {} was already open: {:?}",
+                    peer_id, peer
+                );
                 return;
             }
 
@@ -471,7 +499,9 @@ impl Client {
                 self.handle_connect_to_peer_response(response)
             }
 
-            server::ServerResponse::LoginResponse(response) => self.handle_login_response(response),
+            server::ServerResponse::LoginResponse(response) => {
+                self.handle_login_response(response)
+            }
 
             server::ServerResponse::PrivilegedUsersResponse(response) => {
                 self.handle_privileged_users_response(response)
@@ -521,7 +551,10 @@ impl Client {
         }
     }
 
-    fn handle_connect_to_peer_response(&mut self, response: server::ConnectToPeerResponse) {
+    fn handle_connect_to_peer_response(
+        &mut self,
+        response: server::ConnectToPeerResponse,
+    ) {
         let peer = Peer {
             user_name: response.user_name,
             ip: response.ip,
@@ -596,11 +629,17 @@ impl Client {
         }
     }
 
-    fn handle_privileged_users_response(&mut self, response: server::PrivilegedUsersResponse) {
+    fn handle_privileged_users_response(
+        &mut self,
+        response: server::PrivilegedUsersResponse,
+    ) {
         self.users.set_all_privileged(response.users);
     }
 
-    fn handle_room_join_response(&mut self, mut response: server::RoomJoinResponse) {
+    fn handle_room_join_response(
+        &mut self,
+        mut response: server::RoomJoinResponse,
+    ) {
         // Join the room and store the received information.
         let result = self.rooms.join(
             &response.room_name,
@@ -621,10 +660,15 @@ impl Client {
         let control_response = control::RoomJoinResponse {
             room_name: response.room_name,
         };
-        self.send_to_controller(control::Response::RoomJoinResponse(control_response));
+        self.send_to_controller(control::Response::RoomJoinResponse(
+            control_response,
+        ));
     }
 
-    fn handle_room_leave_response(&mut self, response: server::RoomLeaveResponse) {
+    fn handle_room_leave_response(
+        &mut self,
+        response: server::RoomLeaveResponse,
+    ) {
         if let Err(err) = self.rooms.leave(&response.room_name) {
             error!("RoomLeaveResponse: {}", err);
         }
@@ -636,7 +680,10 @@ impl Client {
         ));
     }
 
-    fn handle_room_list_response(&mut self, response: server::RoomListResponse) {
+    fn handle_room_list_response(
+        &mut self,
+        response: server::RoomListResponse,
+    ) {
         // Update the room map in memory.
         self.rooms.set_room_list(response);
         // Send the updated version to the controller.
@@ -646,7 +693,10 @@ impl Client {
         ));
     }
 
-    fn handle_room_message_response(&mut self, response: server::RoomMessageResponse) {
+    fn handle_room_message_response(
+        &mut self,
+        response: server::RoomMessageResponse,
+    ) {
         let result = self.rooms.add_message(
             &response.room_name,
             room::Message {
@@ -668,7 +718,10 @@ impl Client {
         ));
     }
 
-    fn handle_room_tickers_response(&mut self, response: server::RoomTickersResponse) {
+    fn handle_room_tickers_response(
+        &mut self,
+        response: server::RoomTickersResponse,
+    ) {
         let result = self
             .rooms
             .set_tickers(&response.room_name, response.tickers);
@@ -677,7 +730,10 @@ impl Client {
         }
     }
 
-    fn handle_room_user_joined_response(&mut self, response: server::RoomUserJoinedResponse) {
+    fn handle_room_user_joined_response(
+        &mut self,
+        response: server::RoomUserJoinedResponse,
+    ) {
         let result = self
             .rooms
             .insert_member(&response.room_name, response.user.name.clone());
@@ -693,7 +749,10 @@ impl Client {
         ));
     }
 
-    fn handle_room_user_left_response(&mut self, response: server::RoomUserLeftResponse) {
+    fn handle_room_user_left_response(
+        &mut self,
+        response: server::RoomUserLeftResponse,
+    ) {
         let result = self
             .rooms
             .remove_member(&response.room_name, &response.user_name);
@@ -709,7 +768,10 @@ impl Client {
         ));
     }
 
-    fn handle_user_info_response(&mut self, response: server::UserInfoResponse) {
+    fn handle_user_info_response(
+        &mut self,
+        response: server::UserInfoResponse,
+    ) {
         let c_response = match self.users.get_mut_strict(&response.user_name) {
             Ok(user) => {
                 user.average_speed = response.average_speed;
@@ -726,11 +788,17 @@ impl Client {
                 return;
             }
         };
-        self.send_to_controller(control::Response::UserInfoResponse(c_response));
+        self.send_to_controller(control::Response::UserInfoResponse(
+            c_response,
+        ));
     }
 
-    fn handle_user_status_response(&mut self, response: server::UserStatusResponse) {
-        let result = self.users.set_status(&response.user_name, response.status);
+    fn handle_user_status_response(
+        &mut self,
+        response: server::UserStatusResponse,
+    ) {
+        let result =
+            self.users.set_status(&response.user_name, response.status);
         if let Err(err) = result {
             error!("UserStatusResponse: {}", err);
             return;

src/control/ws.rs

@@ -37,8 +37,12 @@ pub enum SendError {
 impl fmt::Display for SendError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            SendError::JSONEncoderError(ref err) => write!(fmt, "JSONEncoderError: {}", err),
-            SendError::WebSocketError(ref err) => write!(fmt, "WebSocketError: {}", err),
+            SendError::JSONEncoderError(ref err) => {
+                write!(fmt, "JSONEncoderError: {}", err)
+            }
+            SendError::WebSocketError(ref err) => {
+                write!(fmt, "WebSocketError: {}", err)
+            }
         }
     }
 }
@@ -141,7 +145,10 @@ impl ws::Handler for Handler {
             Ok(control_request) => control_request,
             Err(e) => {
                 error!("Received invalid JSON message from controller: {}", e);
-                return Err(ws::Error::new(ws::ErrorKind::Protocol, "Invalid JSON"));
+                return Err(ws::Error::new(
+                    ws::ErrorKind::Protocol,
+                    "Invalid JSON",
+                ));
             }
         };
 
@@ -179,7 +186,8 @@ pub fn listen(client_tx: crossbeam_channel::Sender<Notification>) {
         }
     };
 
-    let listen_result = websocket.listen((config::CONTROL_HOST, config::CONTROL_PORT));
+    let listen_result =
+        websocket.listen((config::CONTROL_HOST, config::CONTROL_PORT));
 
     match listen_result {
         Ok(_) => (),

src/dispatcher.rs

@@ -56,12 +56,18 @@ impl Dispatcher {
     /// Dispatches the given message by wrapping it with a handler.
     pub fn dispatch(&self, message: Message) -> Box<dyn Job> {
         match message {
-            Message::ServerResponse(ServerResponse::LoginResponse(response)) => {
-                Box::new(DispatchedMessage::new(response, LoginHandler::default()))
-            }
-            Message::ServerResponse(ServerResponse::PrivilegedUsersResponse(response)) => Box::new(
-                DispatchedMessage::new(response, SetPrivilegedUsersHandler::default()),
-            ),
+            Message::ServerResponse(ServerResponse::LoginResponse(
+                response,
+            )) => Box::new(DispatchedMessage::new(
+                response,
+                LoginHandler::default(),
+            )),
+            Message::ServerResponse(
+                ServerResponse::PrivilegedUsersResponse(response),
+            ) => Box::new(DispatchedMessage::new(
+                response,
+                SetPrivilegedUsersHandler::default(),
+            )),
             _ => panic!("Unimplemented"),
         }
     }
@@ -76,18 +82,26 @@ mod tests {
     #[test]
     fn dispatcher_privileged_users_response() {
         Dispatcher::new().dispatch(Message::ServerResponse(
-            server::ServerResponse::PrivilegedUsersResponse(server::PrivilegedUsersResponse {
-                users: vec!["foo".to_string(), "bar".to_string(), "baz".to_string()],
-            }),
+            server::ServerResponse::PrivilegedUsersResponse(
+                server::PrivilegedUsersResponse {
+                    users: vec![
+                        "foo".to_string(),
+                        "bar".to_string(),
+                        "baz".to_string(),
+                    ],
+                },
+            ),
         ));
     }
 
     #[test]
     fn dispatcher_login_response() {
         Dispatcher::new().dispatch(Message::ServerResponse(
-            server::ServerResponse::LoginResponse(server::LoginResponse::LoginFail {
-                reason: "bleep bloop".to_string(),
-            }),
+            server::ServerResponse::LoginResponse(
+                server::LoginResponse::LoginFail {
+                    reason: "bleep bloop".to_string(),
+                },
+            ),
         ));
     }
 }

src/executor.rs

@@ -136,7 +136,8 @@ mod tests {
 
         let context = executor.join();
 
-        let expected_users = vec![(user1.name.clone(), user1), (user2.name.clone(), user2)];
+        let expected_users =
+            vec![(user1.name.clone(), user1), (user2.name.clone(), user2)];
 
         let mut users = context.users.lock().get_list();
         users.sort();

src/handlers/login_handler.rs

@@ -9,7 +9,11 @@ use crate::proto::server::LoginResponse;
 pub struct LoginHandler;
 
 impl MessageHandler<LoginResponse> for LoginHandler {
-    fn run(self, context: &Context, _message: &LoginResponse) -> io::Result<()> {
+    fn run(
+        self,
+        context: &Context,
+        _message: &LoginResponse,
+    ) -> io::Result<()> {
         let lock = context.login.lock();
 
         match *lock {

src/handlers/set_privileged_users_handler.rs

@@ -8,7 +8,11 @@ use crate::proto::server::PrivilegedUsersResponse;
 pub struct SetPrivilegedUsersHandler;
 
 impl MessageHandler<PrivilegedUsersResponse> for SetPrivilegedUsersHandler {
-    fn run(self, context: &Context, message: &PrivilegedUsersResponse) -> io::Result<()> {
+    fn run(
+        self,
+        context: &Context,
+        message: &PrivilegedUsersResponse,
+    ) -> io::Result<()> {
         let users = message.users.clone();
         context.users.lock().set_all_privileged(users);
         Ok(())

src/main.rs

@@ -29,7 +29,8 @@ fn main() {
         }
     };
 
-    let (proto_to_client_tx, proto_to_client_rx) = crossbeam_channel::unbounded();
+    let (proto_to_client_tx, proto_to_client_rx) =
+        crossbeam_channel::unbounded();
 
     let mut proto_agent = match proto::Agent::new(proto_to_client_tx) {
         Ok(agent) => agent,
@@ -40,10 +41,14 @@ fn main() {
     };
 
     let client_to_proto_tx = proto_agent.channel();
-    let (control_to_client_tx, control_to_client_rx) = crossbeam_channel::unbounded();
-
-    let mut client =
-        client::Client::new(client_to_proto_tx, proto_to_client_rx, control_to_client_rx);
+    let (control_to_client_tx, control_to_client_rx) =
+        crossbeam_channel::unbounded();
+
+    let mut client = client::Client::new(
+        client_to_proto_tx,
+        proto_to_client_rx,
+        control_to_client_rx,
+    );
 
     thread::spawn(move || control::listen(control_to_client_tx));
     thread::spawn(move || proto_agent.run().unwrap());

src/proto/codec.rs

@@ -12,7 +12,8 @@ use thiserror::Error;
 use super::prefix::Prefixer;
 use super::u32::{decode_u32, U32_BYTE_LEN};
 use super::value_codec::{
-    ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder,
+    ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder,
 };
 
 #[derive(Debug, Error, PartialEq)]
@@ -45,7 +46,11 @@ impl<T: ValueEncode + ?Sized> FrameEncoder<T> {
         }
     }
 
-    pub fn encode_to(&mut self, value: &T, buffer: &mut BytesMut) -> Result<(), FrameEncodeError> {
+    pub fn encode_to(
+        &mut self,
+        value: &T,
+        buffer: &mut BytesMut,
+    ) -> Result<(), FrameEncodeError> {
         let mut prefixer = Prefixer::new(buffer);
 
         ValueEncoder::new(prefixer.suffix_mut()).encode(value)?;
@@ -83,7 +88,10 @@ impl<T: ValueDecode> FrameDecoder<T> {
     ///
     /// Returns an error if the length prefix or the framed value are malformed,
     /// in which case `bytes` is untouched.
-    pub fn decode_from(&mut self, bytes: &mut BytesMut) -> Result<Option<T>, ValueDecodeError> {
+    pub fn decode_from(
+        &mut self,
+        bytes: &mut BytesMut,
+    ) -> Result<Option<T>, ValueDecodeError> {
         if bytes.len() < U32_BYTE_LEN {
             return Ok(None); // Not enough bytes yet.
         }
@@ -205,7 +213,8 @@ mod tests {
         let mut bytes = BytesMut::new();
         bytes.extend_from_slice(&initial_bytes);
 
-        let value: Option<u32> = FrameDecoder::new().decode_from(&mut bytes).unwrap();
+        let value: Option<u32> =
+            FrameDecoder::new().decode_from(&mut bytes).unwrap();
 
         assert_eq!(value, None);
         assert_eq!(bytes, initial_bytes); // Untouched.
@@ -221,7 +230,8 @@ mod tests {
         let mut bytes = BytesMut::new();
         bytes.extend_from_slice(&initial_bytes);
 
-        let value: Option<u32> = FrameDecoder::new().decode_from(&mut bytes).unwrap();
+        let value: Option<u32> =
+            FrameDecoder::new().decode_from(&mut bytes).unwrap();
 
         assert_eq!(value, None);
         assert_eq!(bytes, initial_bytes); // Untouched.

src/proto/handler.rs

@@ -123,11 +123,13 @@ impl Handler {
     ) -> io::Result<Self> {
         let host = config::SERVER_HOST;
         let port = config::SERVER_PORT;
-        let server_stream = Stream::new((host, port), ServerResponseSender(client_tx.clone()))?;
+        let server_stream =
+            Stream::new((host, port), ServerResponseSender(client_tx.clone()))?;
 
         info!("Connected to server at {}:{}", host, port);
 
-        let listener = listener_bind((config::LISTEN_HOST, config::LISTEN_PORT))?;
+        let listener =
+            listener_bind((config::LISTEN_HOST, config::LISTEN_PORT))?;
         info!(
             "Listening for connections on {}:{}",
             config::LISTEN_HOST,
@@ -311,10 +313,16 @@ impl mio::deprecated::Handler for Handler {
         }
     }
 
-    fn notify(&mut self, event_loop: &mut mio::deprecated::EventLoop<Self>, request: Request) {
+    fn notify(
+        &mut self,
+        event_loop: &mut mio::deprecated::EventLoop<Self>,
+        request: Request,
+    ) {
         match request {
             Request::PeerConnect(peer_id, ip, port) => {
-                if let Err(err) = self.connect_to_peer(peer_id, ip, port, event_loop) {
+                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
@@ -336,7 +344,11 @@ impl mio::deprecated::Handler for Handler {
                         return;
                     }
                 };
-                self.process_peer_intent(intent, mio::Token(peer_id), event_loop);
+                self.process_peer_intent(
+                    intent,
+                    mio::Token(peer_id),
+                    event_loop,
+                );
             }
 
             Request::ServerRequest(server_request) => {
@@ -357,7 +369,9 @@ pub struct Agent {
 }
 
 impl Agent {
-    pub fn new(client_tx: crossbeam_channel::Sender<Response>) -> io::Result<Self> {
+    pub fn new(
+        client_tx: crossbeam_channel::Sender<Response>,
+    ) -> io::Result<Self> {
         // Create the event loop.
         #[allow(deprecated)]
         let mut event_loop = mio::deprecated::EventLoop::new()?;

src/proto/mod.rs

@@ -21,6 +21,6 @@ pub use self::server::{ServerRequest, ServerResponse};
 pub use self::stream::*;
 pub use self::user::{User, UserStatus};
 pub use self::value_codec::{
-    Decode, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
-    ValueEncoder,
+    Decode, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode,
+    ValueEncodeError, ValueEncoder,
 };

src/proto/packet.rs

@@ -132,15 +132,21 @@ pub enum PacketReadError {
 impl fmt::Display for PacketReadError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            PacketReadError::InvalidBoolError(n) => write!(fmt, "InvalidBoolError: {}", n),
-            PacketReadError::InvalidU16Error(n) => write!(fmt, "InvalidU16Error: {}", n),
+            PacketReadError::InvalidBoolError(n) => {
+                write!(fmt, "InvalidBoolError: {}", n)
+            }
+            PacketReadError::InvalidU16Error(n) => {
+                write!(fmt, "InvalidU16Error: {}", n)
+            }
             PacketReadError::InvalidStringError(ref bytes) => {
                 write!(fmt, "InvalidStringError: {:?}", bytes)
             }
             PacketReadError::InvalidUserStatusError(n) => {
                 write!(fmt, "InvalidUserStatusError: {}", n)
             }
-            PacketReadError::IOError(ref err) => write!(fmt, "IOError: {}", err),
+            PacketReadError::IOError(ref err) => {
+                write!(fmt, "IOError: {}", err)
+            }
         }
     }
 }
@@ -151,7 +157,9 @@ impl error::Error for PacketReadError {
             PacketReadError::InvalidBoolError(_) => "InvalidBoolError",
             PacketReadError::InvalidU16Error(_) => "InvalidU16Error",
             PacketReadError::InvalidStringError(_) => "InvalidStringError",
-            PacketReadError::InvalidUserStatusError(_) => "InvalidUserStatusError",
+            PacketReadError::InvalidUserStatusError(_) => {
+                "InvalidUserStatusError"
+            }
             PacketReadError::IOError(_) => "IOError",
         }
     }
@@ -383,7 +391,8 @@ impl Parser {
                 // If we have finished reading the length prefix, then
                 // deserialize it, switch states and try to read the packet
                 // bytes.
-                let message_len = LittleEndian::read_u32(&mut self.buffer) as usize;
+                let message_len =
+                    LittleEndian::read_u32(&mut self.buffer) as usize;
                 if message_len > MAX_MESSAGE_SIZE {
                     unimplemented!();
                 };

src/proto/peer/message.rs

@@ -2,8 +2,9 @@ use std::io;
 
 use crate::proto::peer::constants::*;
 use crate::proto::{
-    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode, ValueDecodeError,
-    ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder, WriteToPacket,
+    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode,
+    ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder, WriteToPacket,
 };
 
 /*=========*
@@ -22,7 +23,9 @@ impl ReadFromPacket for Message {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
         let code: u32 = packet.read_value()?;
         let message = match code {
-            CODE_PIERCE_FIREWALL => Message::PierceFirewall(packet.read_value()?),
+            CODE_PIERCE_FIREWALL => {
+                Message::PierceFirewall(packet.read_value()?)
+            }
 
             CODE_PEER_INIT => Message::PeerInit(packet.read_value()?),
 
@@ -42,7 +45,9 @@ impl ReadFromPacket for Message {
 }
 
 impl ValueDecode for Message {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let message = match code {
@@ -67,7 +72,10 @@ impl ValueDecode for Message {
 }
 
 impl ValueEncode for Message {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         match *self {
             Message::PierceFirewall(token) => {
                 encoder.encode_u32(CODE_PIERCE_FIREWALL)?;
@@ -132,7 +140,10 @@ impl WriteToPacket for PeerInit {
 }
 
 impl ValueEncode for PeerInit {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.connection_type)?;
         encoder.encode_u32(self.token)?;
@@ -141,7 +152,9 @@ impl ValueEncode for PeerInit {
 }
 
 impl ValueDecode for PeerInit {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
         let token = decoder.decode()?;

src/proto/server/request.rs

@@ -6,7 +6,8 @@ use crypto::md5::Md5;
 use crate::proto::packet::{MutPacket, WriteToPacket};
 use crate::proto::server::constants::*;
 use crate::proto::{
-    ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder,
+    ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder,
 };
 
 /* ------- *
@@ -100,7 +101,10 @@ impl WriteToPacket for ServerRequest {
 }
 
 impl ValueEncode for ServerRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         match *self {
             ServerRequest::CannotConnectRequest(ref request) => {
                 encoder.encode_u32(CODE_CANNOT_CONNECT)?;
@@ -151,7 +155,9 @@ impl ValueEncode for ServerRequest {
 }
 
 impl ValueDecode for ServerRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let request = match code {
@@ -227,14 +233,19 @@ impl WriteToPacket for CannotConnectRequest {
 }
 
 impl ValueEncode for CannotConnectRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.token)?;
         encoder.encode_string(&self.user_name)
     }
 }
 
 impl ValueDecode for CannotConnectRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let token = decoder.decode()?;
         let user_name = decoder.decode()?;
         Ok(CannotConnectRequest { token, user_name })
@@ -262,7 +273,10 @@ impl WriteToPacket for ConnectToPeerRequest {
 }
 
 impl ValueEncode for ConnectToPeerRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.token)?;
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.connection_type)
@@ -270,7 +284,9 @@ impl ValueEncode for ConnectToPeerRequest {
 }
 
 impl ValueDecode for ConnectToPeerRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let token = decoder.decode()?;
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
@@ -301,14 +317,19 @@ impl WriteToPacket for FileSearchRequest {
 }
 
 impl ValueEncode for FileSearchRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.ticket)?;
         encoder.encode_string(&self.query)
     }
 }
 
 impl ValueDecode for FileSearchRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let ticket = decoder.decode()?;
         let query = decoder.decode()?;
         Ok(FileSearchRequest { ticket, query })
@@ -370,7 +391,10 @@ impl WriteToPacket for LoginRequest {
 }
 
 impl ValueEncode for LoginRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.username)?;
         encoder.encode_string(&self.password)?;
         encoder.encode_u32(self.major)?;
@@ -380,7 +404,9 @@ impl ValueEncode for LoginRequest {
 }
 
 impl ValueDecode for LoginRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         let password = decoder.decode()?;
         let major = decoder.decode()?;
@@ -413,13 +439,18 @@ impl WriteToPacket for PeerAddressRequest {
 }
 
 impl ValueEncode for PeerAddressRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.username)
     }
 }
 
 impl ValueDecode for PeerAddressRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         Ok(PeerAddressRequest { username: username })
     }
@@ -442,13 +473,18 @@ impl WriteToPacket for RoomJoinRequest {
 }
 
 impl ValueEncode for RoomJoinRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
 impl ValueDecode for RoomJoinRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomJoinRequest {
             room_name: room_name,
@@ -473,13 +509,18 @@ impl WriteToPacket for RoomLeaveRequest {
 }
 
 impl ValueEncode for RoomLeaveRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
 impl ValueDecode for RoomLeaveRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomLeaveRequest {
             room_name: room_name,
@@ -506,14 +547,19 @@ impl WriteToPacket for RoomMessageRequest {
 }
 
 impl ValueEncode for RoomMessageRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.message)
     }
 }
 
 impl ValueDecode for RoomMessageRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let message = decoder.decode()?;
         Ok(RoomMessageRequest { room_name, message })
@@ -537,13 +583,18 @@ impl WriteToPacket for SetListenPortRequest {
 }
 
 impl ValueEncode for SetListenPortRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.port)
     }
 }
 
 impl ValueDecode for SetListenPortRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let port = decoder.decode()?;
         Ok(SetListenPortRequest { port: port })
     }
@@ -566,13 +617,18 @@ impl WriteToPacket for UserStatusRequest {
 }
 
 impl ValueEncode for UserStatusRequest {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)
     }
 }
 
 impl ValueDecode for UserStatusRequest {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         Ok(UserStatusRequest {
             user_name: user_name,
@@ -643,7 +699,8 @@ mod tests {
 
     #[test]
     fn new_login_request_has_correct_digest() {
-        let request = LoginRequest::new("alice", "password1234", 1337, 42).unwrap();
+        let request =
+            LoginRequest::new("alice", "password1234", 1337, 42).unwrap();
         assert!(request.has_correct_digest());
     }
 

src/proto/server/response.rs

@@ -3,8 +3,8 @@ use std::net;
 use crate::proto::packet::{Packet, PacketReadError, ReadFromPacket};
 use crate::proto::server::constants::*;
 use crate::proto::{
-    User, UserStatus, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
-    ValueEncoder,
+    User, UserStatus, ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode,
+    ValueEncodeError, ValueEncoder,
 };
 
 /*=================*
@@ -40,39 +40,67 @@ impl ReadFromPacket for ServerResponse {
     fn read_from_packet(packet: &mut Packet) -> Result<Self, PacketReadError> {
         let code: u32 = packet.read_value()?;
         let resp = match code {
-            CODE_CONNECT_TO_PEER => ServerResponse::ConnectToPeerResponse(packet.read_value()?),
+            CODE_CONNECT_TO_PEER => {
+                ServerResponse::ConnectToPeerResponse(packet.read_value()?)
+            }
 
-            CODE_FILE_SEARCH => ServerResponse::FileSearchResponse(packet.read_value()?),
+            CODE_FILE_SEARCH => {
+                ServerResponse::FileSearchResponse(packet.read_value()?)
+            }
 
             CODE_LOGIN => ServerResponse::LoginResponse(packet.read_value()?),
 
-            CODE_PEER_ADDRESS => ServerResponse::PeerAddressResponse(packet.read_value()?),
+            CODE_PEER_ADDRESS => {
+                ServerResponse::PeerAddressResponse(packet.read_value()?)
+            }
 
-            CODE_PRIVILEGED_USERS => ServerResponse::PrivilegedUsersResponse(packet.read_value()?),
+            CODE_PRIVILEGED_USERS => {
+                ServerResponse::PrivilegedUsersResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_JOIN => ServerResponse::RoomJoinResponse(packet.read_value()?),
+            CODE_ROOM_JOIN => {
+                ServerResponse::RoomJoinResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_LEAVE => ServerResponse::RoomLeaveResponse(packet.read_value()?),
+            CODE_ROOM_LEAVE => {
+                ServerResponse::RoomLeaveResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_LIST => ServerResponse::RoomListResponse(packet.read_value()?),
+            CODE_ROOM_LIST => {
+                ServerResponse::RoomListResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_MESSAGE => ServerResponse::RoomMessageResponse(packet.read_value()?),
+            CODE_ROOM_MESSAGE => {
+                ServerResponse::RoomMessageResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_TICKERS => ServerResponse::RoomTickersResponse(packet.read_value()?),
+            CODE_ROOM_TICKERS => {
+                ServerResponse::RoomTickersResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_USER_JOINED => ServerResponse::RoomUserJoinedResponse(packet.read_value()?),
+            CODE_ROOM_USER_JOINED => {
+                ServerResponse::RoomUserJoinedResponse(packet.read_value()?)
+            }
 
-            CODE_ROOM_USER_LEFT => ServerResponse::RoomUserLeftResponse(packet.read_value()?),
+            CODE_ROOM_USER_LEFT => {
+                ServerResponse::RoomUserLeftResponse(packet.read_value()?)
+            }
 
-            CODE_USER_INFO => ServerResponse::UserInfoResponse(packet.read_value()?),
+            CODE_USER_INFO => {
+                ServerResponse::UserInfoResponse(packet.read_value()?)
+            }
 
-            CODE_USER_STATUS => ServerResponse::UserStatusResponse(packet.read_value()?),
+            CODE_USER_STATUS => {
+                ServerResponse::UserStatusResponse(packet.read_value()?)
+            }
 
             CODE_WISHLIST_INTERVAL => {
                 ServerResponse::WishlistIntervalResponse(packet.read_value()?)
             }
 
-            CODE_PARENT_MIN_SPEED => ServerResponse::ParentMinSpeedResponse(packet.read_value()?),
+            CODE_PARENT_MIN_SPEED => {
+                ServerResponse::ParentMinSpeedResponse(packet.read_value()?)
+            }
 
             CODE_PARENT_SPEED_RATIO => {
                 ServerResponse::ParentSpeedRatioResponse(packet.read_value()?)
@@ -92,7 +120,10 @@ impl ReadFromPacket for ServerResponse {
 }
 
 impl ValueEncode for ServerResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         match *self {
             ServerResponse::ConnectToPeerResponse(ref response) => {
                 encoder.encode_u32(CODE_CONNECT_TO_PEER)?;
@@ -171,7 +202,9 @@ impl ValueEncode for ServerResponse {
 }
 
 impl ValueDecode for ServerResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let code: u32 = decoder.decode()?;
         let response = match code {
@@ -290,7 +323,10 @@ impl ReadFromPacket for ConnectToPeerResponse {
 }
 
 impl ValueEncode for ConnectToPeerResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.user_name)?;
         encoder.encode(&self.connection_type)?;
         encoder.encode(&self.ip)?;
@@ -301,7 +337,9 @@ impl ValueEncode for ConnectToPeerResponse {
 }
 
 impl ValueDecode for ConnectToPeerResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let connection_type = decoder.decode()?;
         let ip = decoder.decode()?;
@@ -346,7 +384,10 @@ impl ReadFromPacket for FileSearchResponse {
 }
 
 impl ValueEncode for FileSearchResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         encoder.encode_u32(self.ticket)?;
         encoder.encode_string(&self.query)
@@ -354,7 +395,9 @@ impl ValueEncode for FileSearchResponse {
 }
 
 impl ValueDecode for FileSearchResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let ticket = decoder.decode()?;
         let query = decoder.decode()?;
@@ -409,7 +452,10 @@ impl ReadFromPacket for LoginResponse {
 }
 
 impl ValueEncode for LoginResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         match *self {
             LoginResponse::LoginOk {
                 ref motd,
@@ -430,7 +476,9 @@ impl ValueEncode for LoginResponse {
 }
 
 impl ValueDecode for LoginResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let ok: bool = decoder.decode()?;
         if !ok {
             let reason = decoder.decode()?;
@@ -471,13 +519,18 @@ impl ReadFromPacket for ParentMinSpeedResponse {
 }
 
 impl ValueEncode for ParentMinSpeedResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.value)
     }
 }
 
 impl ValueDecode for ParentMinSpeedResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let value = decoder.decode()?;
         Ok(ParentMinSpeedResponse { value })
     }
@@ -500,13 +553,18 @@ impl ReadFromPacket for ParentSpeedRatioResponse {
 }
 
 impl ValueEncode for ParentSpeedRatioResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.value)
     }
 }
 
 impl ValueDecode for ParentSpeedRatioResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let value = decoder.decode()?;
         Ok(ParentSpeedRatioResponse { value })
     }
@@ -534,7 +592,10 @@ impl ReadFromPacket for PeerAddressResponse {
 }
 
 impl ValueEncode for PeerAddressResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.username)?;
         encoder.encode(&self.ip)?;
         encoder.encode_u16(self.port)
@@ -542,7 +603,9 @@ impl ValueEncode for PeerAddressResponse {
 }
 
 impl ValueDecode for PeerAddressResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let username = decoder.decode()?;
         let ip = decoder.decode()?;
         let port = decoder.decode()?;
@@ -567,13 +630,18 @@ impl ReadFromPacket for PrivilegedUsersResponse {
 }
 
 impl ValueEncode for PrivilegedUsersResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode(&self.users)
     }
 }
 
 impl ValueDecode for PrivilegedUsersResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let users = decoder.decode()?;
         Ok(PrivilegedUsersResponse { users })
     }
@@ -633,7 +701,10 @@ impl ReadFromPacket for RoomJoinResponse {
 }
 
 impl RoomJoinResponse {
-    fn read_user_infos(&mut self, packet: &mut Packet) -> Result<(), PacketReadError> {
+    fn read_user_infos(
+        &mut self,
+        packet: &mut Packet,
+    ) -> Result<(), PacketReadError> {
         let num_statuses: usize = packet.read_value()?;
         for i in 0..num_statuses {
             if let Some(user) = self.users.get_mut(i) {
@@ -674,7 +745,11 @@ impl RoomJoinResponse {
         {
             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
             );
         }
 
@@ -727,7 +802,10 @@ fn build_user(
 }
 
 impl ValueEncode for UserInfo {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.average_speed)?;
         encoder.encode_u32(self.num_downloads)?;
         encoder.encode_u32(self.unknown)?;
@@ -737,7 +815,9 @@ impl ValueEncode for UserInfo {
 }
 
 impl ValueDecode for UserInfo {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let average_speed = decoder.decode()?;
         let num_downloads = decoder.decode()?;
         let unknown = decoder.decode()?;
@@ -754,7 +834,10 @@ impl ValueDecode for UserInfo {
 }
 
 impl ValueEncode for RoomJoinResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         let mut user_names = vec![];
         let mut user_statuses = vec![];
         let mut user_infos = vec![];
@@ -801,9 +884,13 @@ fn build_users(
         let country_opt = countries.pop();
 
         match (name_opt, status_opt, info_opt, slots_opt, country_opt) {
-            (Some(name), Some(status), Some(info), Some(slots), Some(country)) => {
-                users.push(build_user(name, status, info, slots, country))
-            }
+            (
+                Some(name),
+                Some(status),
+                Some(info),
+                Some(slots),
+                Some(country),
+            ) => users.push(build_user(name, status, info, slots, country)),
             _ => break,
         }
     }
@@ -813,7 +900,9 @@ fn build_users(
 }
 
 impl ValueDecode for RoomJoinResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_names = decoder.decode()?;
         let user_statuses = decoder.decode()?;
@@ -863,13 +952,18 @@ impl ReadFromPacket for RoomLeaveResponse {
 }
 
 impl ValueEncode for RoomLeaveResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)
     }
 }
 
 impl ValueDecode for RoomLeaveResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         Ok(RoomLeaveResponse { room_name })
     }
@@ -903,7 +997,9 @@ impl ReadFromPacket for RoomListResponse {
 }
 
 impl RoomListResponse {
-    fn read_rooms(packet: &mut Packet) -> Result<Vec<(String, u32)>, PacketReadError> {
+    fn read_rooms(
+        packet: &mut Packet,
+    ) -> Result<Vec<(String, u32)>, PacketReadError> {
         let num_rooms: usize = packet.read_value()?;
         let mut rooms = Vec::new();
         for _ in 0..num_rooms {
@@ -928,7 +1024,10 @@ impl RoomListResponse {
         Ok(rooms)
     }
 
-    fn build_rooms(mut room_names: Vec<String>, mut user_counts: Vec<u32>) -> Vec<(String, u32)> {
+    fn build_rooms(
+        mut room_names: Vec<String>,
+        mut user_counts: Vec<u32>,
+    ) -> Vec<(String, u32)> {
         let mut rooms = vec![];
 
         loop {
@@ -936,7 +1035,9 @@ impl RoomListResponse {
             let user_count_opt = user_counts.pop();
 
             match (room_name_opt, user_count_opt) {
-                (Some(room_name), Some(user_count)) => rooms.push((room_name, user_count)),
+                (Some(room_name), Some(user_count)) => {
+                    rooms.push((room_name, user_count))
+                }
                 _ => break,
             }
         }
@@ -958,7 +1059,9 @@ impl RoomListResponse {
         rooms
     }
 
-    fn decode_rooms(decoder: &mut ValueDecoder) -> Result<Vec<(String, u32)>, ValueDecodeError> {
+    fn decode_rooms(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Vec<(String, u32)>, ValueDecodeError> {
         let room_names = decoder.decode()?;
         let user_counts = decoder.decode()?;
         Ok(Self::build_rooms(room_names, user_counts))
@@ -982,7 +1085,10 @@ impl RoomListResponse {
 }
 
 impl ValueEncode for RoomListResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         Self::encode_rooms(&self.rooms, encoder)?;
         Self::encode_rooms(&self.owned_private_rooms, encoder)?;
         Self::encode_rooms(&self.other_private_rooms, encoder)?;
@@ -991,7 +1097,9 @@ impl ValueEncode for RoomListResponse {
 }
 
 impl ValueDecode for RoomListResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let rooms = RoomListResponse::decode_rooms(decoder)?;
         let owned_private_rooms = RoomListResponse::decode_rooms(decoder)?;
         let other_private_rooms = RoomListResponse::decode_rooms(decoder)?;
@@ -1030,7 +1138,10 @@ impl ReadFromPacket for RoomMessageResponse {
 }
 
 impl ValueEncode for RoomMessageResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user_name)?;
         encoder.encode_string(&self.message)
@@ -1038,7 +1149,9 @@ impl ValueEncode for RoomMessageResponse {
 }
 
 impl ValueDecode for RoomMessageResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         let message = decoder.decode()?;
@@ -1077,14 +1190,19 @@ impl ReadFromPacket for RoomTickersResponse {
 }
 
 impl ValueEncode for RoomTickersResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode(&self.tickers)
     }
 }
 
 impl ValueDecode for RoomTickersResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let tickers = decoder.decode()?;
         Ok(RoomTickersResponse { room_name, tickers })
@@ -1135,7 +1253,10 @@ impl ReadFromPacket for RoomUserJoinedResponse {
 }
 
 impl ValueEncode for RoomUserJoinedResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user.name)?;
         self.user.status.encode(encoder)?;
@@ -1146,7 +1267,9 @@ impl ValueEncode for RoomUserJoinedResponse {
 }
 
 impl ValueDecode for RoomUserJoinedResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         let status = decoder.decode()?;
@@ -1182,14 +1305,19 @@ impl ReadFromPacket for RoomUserLeftResponse {
 }
 
 impl ValueEncode for RoomUserLeftResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.room_name)?;
         encoder.encode_string(&self.user_name)
     }
 }
 
 impl ValueDecode for RoomUserLeftResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let room_name = decoder.decode()?;
         let user_name = decoder.decode()?;
         Ok(RoomUserLeftResponse {
@@ -1230,7 +1358,10 @@ impl ReadFromPacket for UserInfoResponse {
 }
 
 impl ValueEncode for UserInfoResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         encoder.encode_u32(self.average_speed as u32)?;
         encoder.encode_u32(self.num_downloads as u32)?;
@@ -1240,7 +1371,9 @@ impl ValueEncode for UserInfoResponse {
 }
 
 impl ValueDecode for UserInfoResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let average_speed: u32 = decoder.decode()?;
         let num_downloads: u32 = decoder.decode()?;
@@ -1281,7 +1414,10 @@ impl ReadFromPacket for UserStatusResponse {
 }
 
 impl ValueEncode for UserStatusResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(&self.user_name)?;
         self.status.encode(encoder)?;
         encoder.encode_bool(self.is_privileged)
@@ -1289,7 +1425,9 @@ impl ValueEncode for UserStatusResponse {
 }
 
 impl ValueDecode for UserStatusResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let user_name = decoder.decode()?;
         let status = decoder.decode()?;
         let is_privileged = decoder.decode()?;
@@ -1318,13 +1456,18 @@ impl ReadFromPacket for WishlistIntervalResponse {
 }
 
 impl ValueEncode for WishlistIntervalResponse {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.seconds)
     }
 }
 
 impl ValueDecode for WishlistIntervalResponse {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let seconds = decoder.decode()?;
         Ok(WishlistIntervalResponse { seconds })
     }
@@ -1492,9 +1635,18 @@ mod tests {
     fn roundtrip_room_list() {
         roundtrip(ServerResponse::RoomListResponse(RoomListResponse {
             rooms: vec![("red".to_string(), 12), ("blue".to_string(), 13)],
-            owned_private_rooms: vec![("green".to_string(), 14), ("purple".to_string(), 15)],
-            other_private_rooms: vec![("yellow".to_string(), 16), ("orange".to_string(), 17)],
-            operated_private_room_names: vec!["brown".to_string(), "pink".to_string()],
+            owned_private_rooms: vec![
+                ("green".to_string(), 14),
+                ("purple".to_string(), 15),
+            ],
+            other_private_rooms: vec![
+                ("yellow".to_string(), 16),
+                ("orange".to_string(), 17),
+            ],
+            operated_private_room_names: vec![
+                "brown".to_string(),
+                "pink".to_string(),
+            ],
         }))
     }
 

src/proto/stream.rs

@@ -201,7 +201,8 @@ impl<T: SendPacket> Stream<T> {
 
         // We're always interested in reading more.
         #[allow(deprecated)]
-        let mut event_set = mio::Ready::readable() | mio::Ready::hup() | mio::Ready::error();
+        let mut event_set =
+            mio::Ready::readable() | mio::Ready::hup() | mio::Ready::error();
         // If there is still stuff to write in the queue, we're interested in
         // the socket becoming writable too.
         if self.queue.len() > 0 {

src/proto/testing.rs

@@ -8,14 +8,16 @@ use tokio::net::{TcpListener, TcpStream};
 use crate::proto::{Connection, ServerRequest, ServerResponse};
 
 async fn process(stream: TcpStream) -> io::Result<()> {
-    let mut connection = Connection::<ServerRequest, ServerResponse>::new(stream);
+    let mut connection =
+        Connection::<ServerRequest, ServerResponse>::new(stream);
 
     let _request = match connection.read().await? {
         ServerRequest::LoginRequest(request) => request,
         request => {
             return Err(io::Error::new(
-                    io::ErrorKind::InvalidData,
-                    format!("expected login request, got: {:?}", request)));
+                io::ErrorKind::InvalidData,
+                format!("expected login request, got: {:?}", request),
+            ));
         }
     };
 

src/proto/user.rs

@@ -1,8 +1,9 @@
 use std::io;
 
 use crate::proto::{
-    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode, ValueDecodeError,
-    ValueDecoder, ValueEncode, ValueEncodeError, ValueEncoder, WriteToPacket,
+    MutPacket, Packet, PacketReadError, ReadFromPacket, ValueDecode,
+    ValueDecodeError, ValueDecoder, ValueEncode, ValueEncodeError,
+    ValueEncoder, WriteToPacket,
 };
 
 const STATUS_OFFLINE: u32 = 1;
@@ -10,7 +11,17 @@ const STATUS_AWAY: u32 = 2;
 const STATUS_ONLINE: u32 = 3;
 
 /// This enumeration is the list of possible user statuses.
-#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd, RustcDecodable, RustcEncodable)]
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Eq,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    RustcDecodable,
+    RustcEncodable,
+)]
 pub enum UserStatus {
     /// The user if offline.
     Offline,
@@ -45,7 +56,10 @@ impl WriteToPacket for UserStatus {
 }
 
 impl ValueEncode for UserStatus {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         let value = match *self {
             UserStatus::Offline => STATUS_OFFLINE,
             UserStatus::Away => STATUS_AWAY,
@@ -56,7 +70,9 @@ impl ValueEncode for UserStatus {
 }
 
 impl ValueDecode for UserStatus {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let position = decoder.position();
         let value: u32 = decoder.decode()?;
         match value {
@@ -73,7 +89,9 @@ impl ValueDecode for UserStatus {
 }
 
 /// This structure contains the last known information about a fellow user.
-#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd, RustcDecodable, RustcEncodable)]
+#[derive(
+    Clone, Debug, Eq, Ord, PartialEq, PartialOrd, RustcDecodable, RustcEncodable,
+)]
 pub struct User {
     /// The name of the user.
     pub name: String,

src/proto/value_codec.rs

@@ -95,7 +95,9 @@ pub enum ValueDecodeError {
 impl From<ValueDecodeError> for io::Error {
     fn from(error: ValueDecodeError) -> Self {
         let kind = match &error {
-            &ValueDecodeError::NotEnoughData { .. } => io::ErrorKind::UnexpectedEof,
+            &ValueDecodeError::NotEnoughData { .. } => {
+                io::ErrorKind::UnexpectedEof
+            }
             _ => io::ErrorKind::InvalidData,
         };
         let message = format!("{}", &error);
@@ -125,7 +127,9 @@ pub struct ValueDecoder<'a> {
 /// a `ValueDecoder`.
 pub trait ValueDecode: Sized {
     /// Attempts to decode a value of this type with the given decoder.
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError>;
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError>;
 }
 
 impl<'a> ValueDecoder<'a> {
@@ -225,11 +229,13 @@ impl<'a> ValueDecoder<'a> {
         let position = self.position;
         let bytes = self.consume(length)?;
 
-        let result = WINDOWS_1252.decode_without_bom_handling_and_without_replacement(bytes);
+        let result = WINDOWS_1252
+            .decode_without_bom_handling_and_without_replacement(bytes);
         match result {
             Some(string) => Ok(string.into_owned()),
             None => Err(ValueDecodeError::InvalidString {
-                cause: "malformed sequence in Windows-1252-encoded string".to_string(),
+                cause: "malformed sequence in Windows-1252-encoded string"
+                    .to_string(),
                 position: position,
             }),
         }
@@ -248,38 +254,50 @@ impl<'a> ValueDecoder<'a> {
 }
 
 impl ValueDecode for u32 {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         decoder.decode_u32()
     }
 }
 
 impl ValueDecode for u16 {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         decoder.decode_u16()
     }
 }
 
 impl ValueDecode for bool {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         decoder.decode_bool()
     }
 }
 
 impl ValueDecode for net::Ipv4Addr {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let ip = decoder.decode_u32()?;
         Ok(net::Ipv4Addr::from(ip))
     }
 }
 
 impl ValueDecode for String {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         decoder.decode_string()
     }
 }
 
 impl<T: ValueDecode, U: ValueDecode> ValueDecode for (T, U) {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let first = decoder.decode()?;
         let second = decoder.decode()?;
         Ok((first, second))
@@ -287,7 +305,9 @@ impl<T: ValueDecode, U: ValueDecode> ValueDecode for (T, U) {
 }
 
 impl<T: ValueDecode> ValueDecode for Vec<T> {
-    fn decode_from(decoder: &mut ValueDecoder) -> Result<Self, ValueDecodeError> {
+    fn decode_from(
+        decoder: &mut ValueDecoder,
+    ) -> Result<Self, ValueDecodeError> {
         let len = decoder.decode_u32()? as usize;
         let mut vec = Vec::with_capacity(len);
         for _ in 0..len {
@@ -328,7 +348,10 @@ pub struct ValueEncoder<'a> {
 pub trait ValueEncode {
     // TODO: Rename to encode_to().
     /// Attempts to encode `self` with the given encoder.
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError>;
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError>;
 }
 
 impl<'a> ValueEncoder<'a> {
@@ -388,31 +411,46 @@ impl<'a> ValueEncoder<'a> {
     /// ```
     /// encoder.encode(&Foo::new(bar))?;
     /// ```
-    pub fn encode<T: ValueEncode + ?Sized>(&mut self, val: &T) -> Result<(), ValueEncodeError> {
+    pub fn encode<T: ValueEncode + ?Sized>(
+        &mut self,
+        val: &T,
+    ) -> Result<(), ValueEncodeError> {
         val.encode(self)
     }
 }
 
 impl ValueEncode for u32 {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(*self)
     }
 }
 
 impl ValueEncode for u16 {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u16(*self)
     }
 }
 
 impl ValueEncode for bool {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_bool(*self)
     }
 }
 
 impl ValueEncode for net::Ipv4Addr {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(u32::from(*self))
     }
 }
@@ -426,32 +464,47 @@ impl ValueEncode for net::Ipv4Addr {
 // Value{De,En}code) but it is not really worth the hassle.
 
 impl ValueEncode for str {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(self)
     }
 }
 
 impl ValueEncode for String {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(self)
     }
 }
 
 impl<'a> ValueEncode for &'a String {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_string(*self)
     }
 }
 
 impl<T: ValueEncode, U: ValueEncode> ValueEncode for (T, U) {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         self.0.encode(encoder)?;
         self.1.encode(encoder)
     }
 }
 
 impl<T: ValueEncode> ValueEncode for [T] {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         encoder.encode_u32(self.len() as u32)?;
         for ref item in self {
             item.encode(encoder)?;
@@ -461,7 +514,10 @@ impl<T: ValueEncode> ValueEncode for [T] {
 }
 
 impl<T: ValueEncode> ValueEncode for Vec<T> {
-    fn encode(&self, encoder: &mut ValueEncoder) -> Result<(), ValueEncodeError> {
+    fn encode(
+        &self,
+        encoder: &mut ValueEncoder,
+    ) -> Result<(), ValueEncodeError> {
         let slice: &[T] = &*self;
         slice.encode(encoder)
     }
@@ -480,7 +536,9 @@ pub mod tests {
 
     use bytes::{BufMut, BytesMut};
 
-    use super::{ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncoder};
+    use super::{
+        ValueDecode, ValueDecodeError, ValueDecoder, ValueEncode, ValueEncoder,
+    };
 
     // Declared here because assert_eq!(bytes, &[]) fails to infer types.
     const EMPTY_BYTES: &'static [u8] = &[];
@@ -864,7 +922,13 @@ pub mod tests {
         let mut vec = vec![];
 
         let mut expected_bytes = BytesMut::new();
-        expected_bytes.extend_from_slice(&[13, U32_ENCODINGS.len() as u8, 0, 0, 0]);
+        expected_bytes.extend_from_slice(&[
+            13,
+            U32_ENCODINGS.len() as u8,
+            0,
+            0,
+            0,
+        ]);
 
         for &(val, ref encoded_bytes) in &U32_ENCODINGS {
             vec.push(val);

src/room.rs

@@ -92,13 +92,17 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Error::RoomNotFound(ref room_name) => write!(f, "room {:?} not found", room_name),
+            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
+                )
+            }
         }
     }
 }
@@ -172,7 +176,8 @@ impl RoomMap {
     /// server response.
     pub fn set_room_list(&mut self, mut response: server::RoomListResponse) {
         // Replace the old mapping with an empty one.
-        let mut old_map = mem::replace(&mut self.map, collections::HashMap::new());
+        let mut old_map =
+            mem::replace(&mut self.map, collections::HashMap::new());
 
         // Add all public rooms.
         for (name, user_count) in response.rooms.drain(..) {
@@ -181,12 +186,22 @@ impl RoomMap {
 
         // Add all private, owned, rooms.
         for (name, user_count) in response.owned_private_rooms.drain(..) {
-            self.update_one(name, Visibility::PrivateOwned, user_count, &mut old_map);
+            self.update_one(
+                name,
+                Visibility::PrivateOwned,
+                user_count,
+                &mut old_map,
+            );
         }
 
         // Add all private, unowned, rooms.
         for (name, user_count) in response.other_private_rooms.drain(..) {
-            self.update_one(name, Visibility::PrivateOther, user_count, &mut old_map);
+            self.update_one(
+                name,
+                Visibility::PrivateOther,
+                user_count,
+                &mut old_map,
+            );
         }
 
         // Mark all operated rooms as necessary.
@@ -303,7 +318,11 @@ impl RoomMap {
     }
 
     /// Saves the given message as the last one in the given room.
-    pub fn add_message(&mut self, room_name: &str, message: Message) -> Result<(), Error> {
+    pub fn add_message(
+        &mut self,
+        room_name: &str,
+        message: Message,
+    ) -> Result<(), Error> {
         let room = self.get_mut_strict(room_name)?;
         room.messages.push(message);
         Ok(())
@@ -311,7 +330,11 @@ impl RoomMap {
 
     /// 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<(), Error> {
+    pub fn insert_member(
+        &mut self,
+        room_name: &str,
+        user_name: String,
+    ) -> Result<(), Error> {
         let room = self.get_mut_strict(room_name)?;
         room.members.insert(user_name);
         Ok(())
@@ -319,7 +342,11 @@ impl RoomMap {
 
     /// 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<(), Error> {
+    pub fn remove_member(
+        &mut self,
+        room_name: &str,
+        user_name: &str,
+    ) -> Result<(), Error> {
         let room = self.get_mut_strict(room_name)?;
         room.members.remove(user_name);
         Ok(())
@@ -355,7 +382,10 @@ mod tests {
     fn room_map_get_strict() {
         let mut rooms = RoomMap::new();
         rooms.set_room_list(RoomListResponse {
-            rooms: vec![("room a".to_string(), 42), ("room b".to_string(), 1337)],
+            rooms: vec![
+                ("room a".to_string(), 42),
+                ("room b".to_string(), 1337),
+            ],
             owned_private_rooms: vec![],
             other_private_rooms: vec![],
             operated_private_room_names: vec![],

src/user.rs

@@ -50,7 +50,10 @@ impl UserMap {
 
     /// Looks up the given user name in the map, returning a mutable reference
     /// to the associated data if found, or an error if not found.
-    pub fn get_mut_strict(&mut self, user_name: &str) -> Result<&mut User, UserNotFoundError> {
+    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 {
@@ -130,7 +133,8 @@ mod tests {
     fn set_get_all_privileged() {
         let mut users = UserMap::new();
 
-        users.set_all_privileged(vec!["bleep".to_string(), "bloop".to_string()]);
+        users
+            .set_all_privileged(vec!["bleep".to_string(), "bloop".to_string()]);
 
         let mut privileged = users.get_all_privileged();
         privileged.sort();