diff --git a/src/client.rs b/src/client.rs index f4a8beb..33d7795 100644 --- a/src/client.rs +++ b/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; diff --git a/src/control/mod.rs b/src/control/mod.rs index c84360e..1057a8e 100644 --- a/src/control/mod.rs +++ b/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}; diff --git a/src/control/ws.rs b/src/control/ws.rs index 3bba30b..3a48e47 100644 --- a/src/control/ws.rs +++ b/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) { 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) { 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) { 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(); } } diff --git a/src/proto/codec.rs b/src/proto/codec.rs index 9583b4e..b228e8b 100644 --- a/src/proto/codec.rs +++ b/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 Decode 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(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() { diff --git a/src/proto/handler.rs b/src/proto/handler.rs index 44f0196..ad55564 100644 --- a/src/proto/handler.rs +++ b/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; } diff --git a/src/proto/mod.rs b/src/proto/mod.rs index 0282c60..e1a99ef 100644 --- a/src/proto/mod.rs +++ b/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}; diff --git a/src/proto/packet.rs b/src/proto/packet.rs index 15f409a..af6d9a7 100644 --- a/src/proto/packet.rs +++ b/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. diff --git a/src/proto/peer/message.rs b/src/proto/peer/message.rs index eeed8d7..e3c237a 100644 --- a/src/proto/peer/message.rs +++ b/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::*; diff --git a/src/proto/server/request.rs b/src/proto/server/request.rs index 70eda63..31c1ea1 100644 --- a/src/proto/server/request.rs +++ b/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 Decode for T { fn decode(&mut self) -> io::Result { 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 Decode for T { fn decode(&mut self) -> io::Result { 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 Decode for T { fn decode(&mut self) -> io::Result { 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(), + })) } } diff --git a/src/proto/server/response.rs b/src/proto/server/response.rs index 5a2b03b..9fb21da 100644 --- a/src/proto/server/response.rs +++ b/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 { 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, }, - 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 { - 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] diff --git a/src/proto/transport.rs b/src/proto/transport.rs index 05435d9..fe5097c 100644 --- a/src/proto/transport.rs +++ b/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 where diff --git a/src/proto/user.rs b/src/proto/user.rs index 653fd0a..d54ce35 100644 --- a/src/proto/user.rs +++ b/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; diff --git a/src/room.rs b/src/room.rs index 889053f..951c53c 100644 --- a/src/room.rs +++ b/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; diff --git a/src/user.rs b/src/user.rs index dce9e9e..169e312 100644 --- a/src/user.rs +++ b/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(), + }), } }