Revamp `RwLock` usage in the lib

Also not quite sure if they goofed rustfmt or something, but its changes it did were a bit bizarre.

3 files changed, 102 insertions, 151 deletions

diff --git a/src/client/context.rs b/src/client/context.rs
index a20a316..e8595cd 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -75,26 +75,26 @@ impl Context {
     /// let mut client = Client::new("token", Handler); client.start().unwrap();
     /// ```
     #[cfg(feature = "builder")]
-    pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser> {
+pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser>{
         let mut map = Map::new();
 
         feature_cache! {{
-            let cache = CACHE.read().unwrap();
-
-            map.insert("username".to_owned(), Value::String(cache.user.name.clone()));
-
-            if let Some(email) = cache.user.email.as_ref() {
-                map.insert("email".to_owned(), Value::String(email.clone()));
-            }
-        } else {
-            let user = http::get_current_user()?;
-
-            map.insert("username".to_owned(), Value::String(user.name.clone()));
-
-            if let Some(email) = user.email.as_ref() {
-                map.insert("email".to_owned(), Value::String(email.clone()));
-            }
-        }}
+                            let cache = CACHE.read().unwrap();
+        
+                            map.insert("username".to_owned(), Value::String(cache.user.name.clone()));
+        
+                            if let Some(email) = cache.user.email.as_ref() {
+                                map.insert("email".to_owned(), Value::String(email.clone()));
+                            }
+                        } else {
+                            let user = http::get_current_user()?;
+        
+                            map.insert("username".to_owned(), Value::String(user.name.clone()));
+        
+                            if let Some(email) = user.email.as_ref() {
+                                map.insert("email".to_owned(), Value::String(email.clone()));
+                            }
+                        }}
 
         let edited = f(EditProfile(map)).0;
 
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 0a2ad8d..cb45428 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -62,7 +62,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            framework: &Arc<sync::Mutex<Option<Box<Framework>>>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -75,12 +75,12 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
 
             if let Some(ref mut framework) = *framework.lock().unwrap() {
                 helper! {{
-					if framework.initialized() {
-						framework.dispatch(context, event.message, tokio_handle);
-					}
-				} else {
-					framework.dispatch(context, event.message, tokio_handle);
-				}}
+                if framework.initialized() {
+                framework.dispatch(context, event.message, tokio_handle);
+                }
+                } else {
+                framework.dispatch(context, event.message, tokio_handle);
+                }}
             }
         },
         other => handle_event(other, conn, data, event_handler, tokio_handle),
@@ -92,7 +92,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -106,7 +106,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
 fn dispatch_message<H: EventHandler + 'static>(context: Context,
                                                mut message: Message,
                                                event_handler: &Arc<H>,
-                                               tokio_handle: &Handle) {
+tokio_handle: &Handle){
     let h = event_handler.clone();
     tokio_handle.spawn_fn(move || {
         #[cfg(feature = "model")]
@@ -125,7 +125,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-                                           tokio_handle: &Handle) {
+tokio_handle: &Handle){
     #[cfg(feature="cache")]
     let mut last_guild_create_time = now!();
 
@@ -172,8 +172,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data);
 
             match event.channel {
-                Channel::Private(_) |
-                Channel::Group(_) => {},
+                Channel::Private(_) | Channel::Group(_) => {},
                 Channel::Guild(channel) => {
                     let h = event_handler.clone();
                     tokio_handle.spawn_fn(move || {
@@ -199,11 +198,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_addition(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_addition(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -214,11 +209,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_removal(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_removal(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -332,11 +323,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_emojis_update(
-                    context,
-                    event.guild_id,
-                    event.emojis,
-                );
+                h.on_guild_emojis_update(context, event.guild_id, event.emojis);
                 Ok(())
             });
         },
@@ -356,11 +343,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_member_addition(
-                    context,
-                    event.guild_id,
-                    event.member,
-                );
+                h.on_guild_member_addition(context, event.guild_id, event.member);
                 Ok(())
             });
         },
@@ -387,25 +370,25 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             feature_cache! {{
-                // This is safe to unwrap, as the update would have created
-                // the member if it did not exist. So, there is be _no_ way
-                // that this could fail under any circumstance.
-                let after = CACHE.read()
-                    .unwrap()
-                    .member(event.guild_id, event.user.id)
-                    .unwrap()
-                    .clone();
-
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_member_update(context, _before, after);
-                    Ok(())
-                });
-            } else {
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_member_update(context, event);
-                    Ok(())
-                });
-            }}
+                                                                // This is safe to unwrap, as the update would have created
+                                                                // the member if it did not exist. So, there is be _no_ way
+                                                                // that this could fail under any circumstance.
+                                                                let after = CACHE.read()
+                                                                    .unwrap()
+                                                                    .member(event.guild_id, event.user.id)
+                                                                    .unwrap()
+                                                                    .clone();
+            
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_member_update(context, _before, after);
+                                                                    Ok(())
+                                                                });
+                                                            } else {
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_member_update(context, event);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         Event::GuildMembersChunk(event) => {
             update!(update_with_guild_members_chunk, event);
@@ -414,11 +397,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_members_chunk(
-                    context,
-                    event.guild_id,
-                    event.members,
-                );
+                h.on_guild_members_chunk(context, event.guild_id, event.members);
                 Ok(())
             });
         },
@@ -485,22 +464,22 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             feature_cache! {{
-                let before = CACHE.read()
-                    .unwrap()
-                    .guilds
-                    .get(&event.guild.id)
-                    .cloned();
-
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_update(context, before, event.guild);
-                    Ok(())
-                });
-            } else {
-                tokio_handle.spawn_fn(move || {
-                    h.on_guild_update(context, event.guild);
-                    Ok(())
-                });
-            }}
+                                                                let before = CACHE.read()
+                                                                    .unwrap()
+                                                                    .guilds
+                                                                    .get(&event.guild.id)
+                                                                    .cloned();
+            
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_update(context, before, event.guild);
+                                                                    Ok(())
+                                                                });
+                                                            } else {
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_guild_update(context, event.guild);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         // Already handled by the framework check macro
         Event::MessageCreate(_) => {},
@@ -509,11 +488,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete_bulk(
-                    context,
-                    event.channel_id,
-                    event.ids,
-                );
+                h.on_message_delete_bulk(context, event.channel_id, event.ids);
                 Ok(())
             });
         },
@@ -522,11 +497,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_message_delete(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -582,11 +553,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_reaction_remove_all(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_reaction_remove_all(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -594,27 +561,27 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             update!(update_with_ready, event);
 
             feature_cache!{{
-                last_guild_create_time = now!();
-
-                let _ = wait_for_guilds()
-                .map(|_| {
-                    let context = context(conn, data);
-
-                    let h = event_handler.clone();
-                    tokio_handle.spawn_fn(move || {
-                        h.on_ready(context, event.ready);
-                        Ok(())
-                    });
-                });
-            } else {
-               let context = context(conn, data);
-
-                let h = event_handler.clone();
-                tokio_handle.spawn_fn(move || {
-                    h.on_ready(context, event.ready);
-                    Ok(())
-                });
-            }}
+                                                                last_guild_create_time = now!();
+            
+                                                                let _ = wait_for_guilds()
+                                                                .map(|_| {
+                                                                    let context = context(conn, data);
+            
+                                                                    let h = event_handler.clone();
+                                                                    tokio_handle.spawn_fn(move || {
+                                                                        h.on_ready(context, event.ready);
+                                                                        Ok(())
+                                                                    });
+                                                                });
+                                                            } else {
+                                                               let context = context(conn, data);
+            
+                                                                let h = event_handler.clone();
+                                                                tokio_handle.spawn_fn(move || {
+                                                                    h.on_ready(context, event.ready);
+                                                                    Ok(())
+                                                                });
+                                                            }}
         },
         Event::Resumed(event) => {
             let context = context(conn, data);
@@ -676,11 +643,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_voice_state_update(
-                    context,
-                    event.guild_id,
-                    event.voice_state,
-                );
+                h.on_voice_state_update(context, event.guild_id, event.voice_state);
                 Ok(())
             });
         },
@@ -689,11 +652,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_webhook_update(
-                    context,
-                    event.guild_id,
-                    event.channel_id,
-                );
+                h.on_webhook_update(context, event.guild_id, event.channel_id);
                 Ok(())
             });
         },
diff --git a/src/client/mod.rs b/src/client/mod.rs
index 5821597..47ff96c 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -37,7 +37,7 @@ pub use CACHE;
 
 use self::dispatch::dispatch;
 use std::sync::{self, Arc};
-use std::sync::atomic::{ATOMIC_BOOL_INIT, AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use parking_lot::Mutex;
 use tokio_core::reactor::Core;
 use futures;
@@ -194,8 +194,7 @@ pub struct Client<H: EventHandler + 'static> {
     /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
     /// [`on_ready`]: #method.on_ready
     event_handler: Arc<H>,
-    #[cfg(feature = "framework")]
-    framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
+    #[cfg(feature = "framework")] framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
     token: Arc<sync::Mutex<String>>,
 }
 
@@ -355,7 +354,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`on_message`]: #method.on_message
     /// [framework docs]: ../framework/index.html
     #[cfg(feature = "framework")]
-    pub fn with_framework<F: Framework + 'static>(&mut self, f: F) {
+pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
         self.framework = Arc::new(sync::Mutex::new(Some(Box::new(f))));
     }
 
@@ -540,10 +539,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_autosharded`]: #method.start_autosharded
     /// [gateway docs]: gateway/index.html#sharding
     pub fn start_shard(&mut self, shard: u64, shards: u64) -> Result<()> {
-        self.start_connection(
-            [shard, shard, shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([shard, shard, shards], http::get_gateway()?.url)
     }
 
     /// Establish sharded connections and start listening for events.
@@ -668,10 +664,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_shards`]: #method.start_shards
     /// [Gateway docs]: gateway/index.html#sharding
     pub fn start_shard_range(&mut self, range: [u64; 2], total_shards: u64) -> Result<()> {
-        self.start_connection(
-            [range[0], range[1], total_shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([range[0], range[1], total_shards], http::get_gateway()?.url)
     }
 
     /// Returns a thread-safe handle for closing shards.
@@ -729,8 +722,7 @@ impl<H: EventHandler + 'static> Client<H> {
                 Ok(shard) => {
                     let shard = Arc::new(Mutex::new(shard));
 
-                    let monitor_info =
-                        feature_framework! {{
+                    let monitor_info = feature_framework! {{
                         MonitorInfo {
                             data: self.data.clone(),
                             event_handler: self.event_handler.clone(),
@@ -846,7 +838,7 @@ fn boot_shard(info: &BootInfo) -> Result<Shard> {
     Err(Error::Client(ClientError::ShardBootFailure))
 }
 
-fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
+fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>){
     handle_shard(&mut info);
 
     let mut handle_still = HANDLE_STILL.load(Ordering::Relaxed);
@@ -900,7 +892,7 @@ fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
     }
 }
 
-fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>) {
+fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>){
     let mut core = Core::new().unwrap();
     let handle = core.handle();