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.

7 files changed, 92 insertions, 130 deletions

diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index d8ccc71..cf9e41c 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -1,5 +1,6 @@
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::borrow::Cow;
@@ -99,7 +100,7 @@ impl ChannelId {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
         http::delete_message(self.0, message_id.into().0)
     }
 
@@ -186,7 +187,7 @@ impl ChannelId {
     /// [`Channel`]: enum.Channel.html
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     #[inline]
-    pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel> {
+pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel>{
         http::edit_channel(self.0, &f(EditChannel::default()).0)
     }
 
@@ -255,13 +256,12 @@ impl ChannelId {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
-        http::get_message(self.0, message_id.into().0).map(
-            |mut msg| {
+        http::get_message(self.0, message_id.into().0)
+            .map(|mut msg| {
                 msg.transform_content();
 
                 msg
-            },
-        )
+            })
     }
 
     /// Gets messages from the channel.
@@ -306,11 +306,9 @@ impl ChannelId {
                   None => return None,
               } {
             Guild(channel) => channel.read().unwrap().name().to_string(),
-            Group(channel) => {
-                match channel.read().unwrap().name() {
-                    Cow::Borrowed(name) => name.to_string(),
-                    Cow::Owned(name) => name,
-                }
+            Group(channel) => match channel.read().unwrap().name() {
+                Cow::Borrowed(name) => name.to_string(),
+                Cow::Owned(name) => name,
             },
             Private(channel) => channel.read().unwrap().name(),
         })
@@ -512,9 +510,9 @@ impl From<Channel> for ChannelId {
     /// Gets the Id of a `Channel`.
     fn from(channel: Channel) -> ChannelId {
         match channel {
-            Channel::Group(group) => group.read().unwrap().channel_id,
-            Channel::Guild(ch) => ch.read().unwrap().id,
-            Channel::Private(ch) => ch.read().unwrap().id,
+            Channel::Group(group) => group.with(|g| g.channel_id),
+            Channel::Guild(ch) => ch.with(|c| c.id),
+            Channel::Private(ch) => ch.with(|c| c.id),
         }
     }
 }
@@ -523,9 +521,9 @@ impl<'a> From<&'a Channel> for ChannelId {
     /// Gets the Id of a `Channel`.
     fn from(channel: &Channel) -> ChannelId {
         match *channel {
-            Channel::Group(ref group) => group.read().unwrap().channel_id,
-            Channel::Guild(ref ch) => ch.read().unwrap().id,
-            Channel::Private(ref ch) => ch.read().unwrap().id,
+            Channel::Group(ref group) => group.with(|g| g.channel_id),
+            Channel::Guild(ref ch) => ch.with(|c| c.id),
+            Channel::Private(ref ch) => ch.with(|c| c.id),
         }
     }
 }
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index 7007ad6..94483ec 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -1,5 +1,6 @@
 use chrono::{DateTime, FixedOffset};
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::borrow::Cow;
@@ -123,11 +124,8 @@ impl Group {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.channel_id.delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.channel_id
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -208,12 +206,12 @@ impl Group {
             Some(ref name) => Cow::Borrowed(name),
             None => {
                 let mut name = match self.recipients.values().nth(0) {
-                    Some(recipient) => recipient.read().unwrap().name.clone(),
+                    Some(recipient) => recipient.with(|c| c.name.clone()),
                     None => return Cow::Borrowed("Empty Group"),
                 };
 
                 for recipient in self.recipients.values().skip(1) {
-                    let _ = write!(name, ", {}", recipient.read().unwrap().name);
+                    let _ = write!(name, ", {}", recipient.with(|r| r.name.clone()));
                 }
 
                 Cow::Owned(name)
@@ -245,12 +243,8 @@ impl Group {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Removes a recipient from the group. If the recipient is already not in
@@ -315,7 +309,7 @@ impl Group {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         self.channel_id.send_message(f)
     }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 3fadd72..620ba93 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -300,7 +300,6 @@ impl GuildChannel {
     /// ```
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditChannel) -> EditChannel {
-
         #[cfg(feature = "cache")]
         {
             let req = permissions::MANAGE_CHANNELS;
@@ -311,10 +310,7 @@ impl GuildChannel {
         }
 
         let mut map = Map::new();
-        map.insert(
-            "name".to_owned(),
-            Value::String(self.name.clone()),
-        );
+        map.insert("name".to_owned(), Value::String(self.name.clone()));
         map.insert(
             "position".to_owned(),
             Value::Number(Number::from(self.position)),
@@ -543,12 +539,8 @@ impl GuildChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Sends a message with just the given message content in the channel.
@@ -607,7 +599,7 @@ impl GuildChannel {
     /// [`ModelError::MessageTooLong`]: enum.ModelError.html#variant.MessageTooLong
     /// [`Message`]: struct.Message.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         #[cfg(feature = "cache")]
         {
             let req = permissions::SEND_MESSAGES;
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 27f4e31..399d351 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -291,10 +291,9 @@ impl Message {
         }
 
         // And finally replace everyone and here mentions.
-        result.replace("@everyone", "@\u{200B}everyone").replace(
-            "@here",
-            "@\u{200B}here",
-        )
+        result
+            .replace("@everyone", "@\u{200B}everyone")
+            .replace("@here", "@\u{200B}here")
     }
 
     /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
@@ -320,12 +319,8 @@ impl Message {
                                 after: Option<U>)
                                 -> Result<Vec<User>>
         where R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            self.id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(self.id, reaction_type, limit, after)
     }
 
     /// Returns the associated `Guild` for the message if one is in the cache.
@@ -338,9 +333,8 @@ impl Message {
     /// [`guild_id`]: #method.guild_id
     #[cfg(feature = "cache")]
     pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> {
-        self.guild_id().and_then(|guild_id| {
-            CACHE.read().unwrap().guild(guild_id)
-        })
+        self.guild_id()
+            .and_then(|guild_id| CACHE.read().unwrap().guild(guild_id))
     }
 
     /// Retrieves the Id of the guild that the message was sent in, if sent in
@@ -360,8 +354,7 @@ impl Message {
     #[cfg(feature = "cache")]
     pub fn is_private(&self) -> bool {
         match CACHE.read().unwrap().channel(self.channel_id) {
-            Some(Channel::Group(_)) |
-            Some(Channel::Private(_)) => true,
+            Some(Channel::Group(_)) | Some(Channel::Private(_)) => true,
             _ => false,
         }
     }
@@ -378,7 +371,11 @@ impl Message {
         let count = content.chars().count() as i64;
         let diff = count - (constants::MESSAGE_CODE_LIMIT as i64);
 
-        if diff > 0 { Some(diff as u64) } else { None }
+        if diff > 0 {
+            Some(diff as u64)
+        } else {
+            None
+        }
     }
 
     /// Pins this message to its channel.
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 626f466..0911139 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -20,6 +20,7 @@ use serde::de::Error as DeError;
 use serde_json;
 use super::utils::deserialize_u64;
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use std::fmt::{Display, Formatter, Result as FmtResult};
@@ -99,7 +100,7 @@ impl Channel {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
+pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
         self.id().delete_message(message_id)
     }
 
@@ -117,11 +118,8 @@ impl Channel {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.id().delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.id()
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -158,9 +156,8 @@ impl Channel {
     #[inline]
     pub fn is_nsfw(&self) -> bool {
         match *self {
-            Channel::Guild(ref channel) => channel.read().unwrap().is_nsfw(),
-            Channel::Group(_) |
-            Channel::Private(_) => false,
+            Channel::Guild(ref channel) => channel.with(|c| c.is_nsfw()),
+            Channel::Group(_) | Channel::Private(_) => false,
         }
     }
 
@@ -220,12 +217,8 @@ impl Channel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id().reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id()
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Retrieves the Id of the inner [`Group`], [`GuildChannel`], or
@@ -236,9 +229,9 @@ impl Channel {
     /// [`PrivateChannel`]: struct.PrivateChannel.html
     pub fn id(&self) -> ChannelId {
         match *self {
-            Channel::Group(ref group) => group.read().unwrap().channel_id,
-            Channel::Guild(ref channel) => channel.read().unwrap().id,
-            Channel::Private(ref channel) => channel.read().unwrap().id,
+            Channel::Group(ref group) => group.with(|g| g.channel_id),
+            Channel::Guild(ref ch) => ch.with(|c| c.id),
+            Channel::Private(ref ch) => ch.with(|c| c.id),
         }
     }
 
@@ -326,21 +319,15 @@ impl<'de> Deserialize<'de> for Channel {
         };
 
         match kind {
-            0 | 2 => {
-                serde_json::from_value::<GuildChannel>(Value::Object(v))
-                    .map(|x| Channel::Guild(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
-            1 => {
-                serde_json::from_value::<PrivateChannel>(Value::Object(v))
-                    .map(|x| Channel::Private(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
-            3 => {
-                serde_json::from_value::<Group>(Value::Object(v))
-                    .map(|x| Channel::Group(Arc::new(RwLock::new(x))))
-                    .map_err(DeError::custom)
-            },
+            0 | 2 => serde_json::from_value::<GuildChannel>(Value::Object(v))
+                .map(|x| Channel::Guild(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
+            1 => serde_json::from_value::<PrivateChannel>(Value::Object(v))
+                .map(|x| Channel::Private(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
+            3 => serde_json::from_value::<Group>(Value::Object(v))
+                .map(|x| Channel::Group(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
             _ => Err(DeError::custom("Unknown channel type")),
         }
     }
@@ -412,10 +399,8 @@ impl ChannelType {
 struct PermissionOverwriteData {
     allow: Permissions,
     deny: Permissions,
-    #[serde(deserialize_with = "deserialize_u64")]
-    id: u64,
-    #[serde(rename = "type")]
-    kind: String,
+    #[serde(deserialize_with = "deserialize_u64")] id: u64,
+    #[serde(rename = "type")] kind: String,
 }
 
 /// A channel-specific permission overwrite for a member or role.
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index 30dc01d..e5e14d9 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -2,6 +2,7 @@ use chrono::{DateTime, FixedOffset};
 use std::fmt::{Display, Formatter, Result as FmtResult};
 use super::deserialize_single_recipient;
 use model::*;
+use internal::RwLockExt;
 
 #[cfg(feature = "model")]
 use builder::{CreateMessage, GetMessages};
@@ -169,7 +170,7 @@ impl PrivateChannel {
     }
 
     /// Returns "DM with $username#discriminator".
-    pub fn name(&self) -> String { format!("DM with {}", self.recipient.read().unwrap().tag()) }
+    pub fn name(&self) -> String { format!("DM with {}", self.recipient.with(|r| r.tag())) }
 
     /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
     /// certain [`Emoji`].
@@ -191,12 +192,8 @@ impl PrivateChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Pins a [`Message`] to the channel.
@@ -262,7 +259,7 @@ impl PrivateChannel {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [`Message`]: struct.Message.html
     #[inline]
-    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
+pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
         self.id.send_message(f)
     }
 
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 88fd24c..be5dfb8 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -46,32 +46,31 @@ impl Reaction {
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     /// [permissions]: permissions
     pub fn delete(&self) -> Result<()> {
-        let user_id =
-            feature_cache! {{
-            let user = if self.user_id == CACHE.read().unwrap().user.id {
-                None
-            } else {
-                Some(self.user_id.0)
-            };
-
-            // If the reaction is one _not_ made by the current user, then ensure
-            // that the current user has permission* to delete the reaction.
-            //
-            // Normally, users can only delete their own reactions.
-            //
-            // * The `Manage Messages` permission.
-            if user.is_some() {
-                let req = permissions::MANAGE_MESSAGES;
-
-                if !utils::user_has_perms(self.channel_id, req).unwrap_or(true) {
-                    return Err(Error::Model(ModelError::InvalidPermissions(req)));
-                }
-            }
-
-            user
-        } else {
-            Some(self.user_id.0)
-        }};
+        let user_id = feature_cache! {{
+                                            let user = if self.user_id == CACHE.read().unwrap().user.id {
+                                                None
+                                            } else {
+                                                Some(self.user_id.0)
+                                            };
+        
+                                            // If the reaction is one _not_ made by the current user, then ensure
+                                            // that the current user has permission* to delete the reaction.
+                                            //
+                                            // Normally, users can only delete their own reactions.
+                                            //
+                                            // * The `Manage Messages` permission.
+                                            if user.is_some() {
+                                                let req = permissions::MANAGE_MESSAGES;
+        
+                                                if !utils::user_has_perms(self.channel_id, req).unwrap_or(true) {
+                                                    return Err(Error::Model(ModelError::InvalidPermissions(req)));
+                                                }
+                                            }
+        
+                                            user
+                                        } else {
+                                            Some(self.user_id.0)
+                                        }};
 
         http::delete_reaction(self.channel_id.0, self.message_id.0, user_id, &self.emoji)
     }