Apply rustfmt

48 files changed, 807 insertions, 506 deletions

diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index 1e0bc8d..6d61653 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -87,8 +87,10 @@ impl CreateEmbed {
     /// Set the colour of the left-hand side of the embed.
     #[cfg(not(feature = "utils"))]
     pub fn colour(mut self, colour: u32) -> Self {
-        self.0
-            .insert("color".to_owned(), Value::Number(Number::from(colour)));
+        self.0.insert(
+            "color".to_owned(),
+            Value::Number(Number::from(colour)),
+        );
 
         CreateEmbed(self.0)
     }
@@ -282,24 +284,30 @@ impl CreateEmbed {
     /// let mut client = Client::new("token", Handler); client.start().unwrap();
     /// ```
     pub fn timestamp<T: Into<Timestamp>>(mut self, timestamp: T) -> Self {
-        self.0
-            .insert("timestamp".to_owned(), Value::String(timestamp.into().ts));
+        self.0.insert(
+            "timestamp".to_owned(),
+            Value::String(timestamp.into().ts),
+        );
 
         CreateEmbed(self.0)
     }
 
     /// Set the title of the embed.
     pub fn title<D: Display>(mut self, title: D) -> Self {
-        self.0
-            .insert("title".to_owned(), Value::String(format!("{}", title)));
+        self.0.insert(
+            "title".to_owned(),
+            Value::String(format!("{}", title)),
+        );
 
         CreateEmbed(self.0)
     }
 
     /// Set the URL to direct to when clicking on the title.
     pub fn url(mut self, url: &str) -> Self {
-        self.0
-            .insert("url".to_owned(), Value::String(url.to_owned()));
+        self.0.insert(
+            "url".to_owned(),
+            Value::String(url.to_owned()),
+        );
 
         CreateEmbed(self.0)
     }
@@ -319,7 +327,10 @@ impl Default for CreateEmbed {
     /// Creates a builder with default values, setting the `type` to `rich`.
     fn default() -> CreateEmbed {
         let mut map = Map::new();
-        map.insert("type".to_owned(), Value::String("rich".to_owned()));
+        map.insert(
+            "type".to_owned(),
+            Value::String("rich".to_owned()),
+        );
 
         CreateEmbed(map)
     }
@@ -396,24 +407,30 @@ pub struct CreateEmbedAuthor(pub Map<String, Value>);
 impl CreateEmbedAuthor {
     /// Set the URL of the author's icon.
     pub fn icon_url(mut self, icon_url: &str) -> Self {
-        self.0
-            .insert("icon_url".to_owned(), Value::String(icon_url.to_owned()));
+        self.0.insert(
+            "icon_url".to_owned(),
+            Value::String(icon_url.to_owned()),
+        );
 
         self
     }
 
     /// Set the author's name.
     pub fn name(mut self, name: &str) -> Self {
-        self.0
-            .insert("name".to_owned(), Value::String(name.to_owned()));
+        self.0.insert(
+            "name".to_owned(),
+            Value::String(name.to_owned()),
+        );
 
         self
     }
 
     /// Set the author's URL.
     pub fn url(mut self, url: &str) -> Self {
-        self.0
-            .insert("url".to_owned(), Value::String(url.to_owned()));
+        self.0.insert(
+            "url".to_owned(),
+            Value::String(url.to_owned()),
+        );
 
         self
     }
@@ -440,16 +457,20 @@ impl CreateEmbedField {
 
     /// Set the field's name. It can't be longer than 256 characters.
     pub fn name<D: Display>(mut self, name: D) -> Self {
-        self.0
-            .insert("name".to_owned(), Value::String(format!("{}", name)));
+        self.0.insert(
+            "name".to_owned(),
+            Value::String(format!("{}", name)),
+        );
 
         self
     }
 
     /// Set the field's value. It can't be longer than 1024 characters.
     pub fn value<D: Display>(mut self, value: D) -> Self {
-        self.0
-            .insert("value".to_owned(), Value::String(format!("{}", value)));
+        self.0.insert(
+            "value".to_owned(),
+            Value::String(format!("{}", value)),
+        );
 
         self
     }
@@ -479,16 +500,20 @@ pub struct CreateEmbedFooter(pub Map<String, Value>);
 impl CreateEmbedFooter {
     /// Set the icon URL's value. This only supports HTTP(S).
     pub fn icon_url(mut self, icon_url: &str) -> Self {
-        self.0
-            .insert("icon_url".to_owned(), Value::String(icon_url.to_owned()));
+        self.0.insert(
+            "icon_url".to_owned(),
+            Value::String(icon_url.to_owned()),
+        );
 
         self
     }
 
     /// Set the footer's text.
     pub fn text<D: Display>(mut self, text: D) -> Self {
-        self.0
-            .insert("text".to_owned(), Value::String(format!("{}", text)));
+        self.0.insert(
+            "text".to_owned(),
+            Value::String(format!("{}", text)),
+        );
 
         self
     }
diff --git a/src/builder/create_invite.rs b/src/builder/create_invite.rs
index 58893fc..d17f273 100644
--- a/src/builder/create_invite.rs
+++ b/src/builder/create_invite.rs
@@ -89,8 +89,10 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn max_age(mut self, max_age: u64) -> Self {
-        self.0
-            .insert("max_age".to_owned(), Value::Number(Number::from(max_age)));
+        self.0.insert(
+            "max_age".to_owned(),
+            Value::Number(Number::from(max_age)),
+        );
 
         self
     }
@@ -123,8 +125,10 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn max_uses(mut self, max_uses: u64) -> Self {
-        self.0
-            .insert("max_uses".to_owned(), Value::Number(Number::from(max_uses)));
+        self.0.insert(
+            "max_uses".to_owned(),
+            Value::Number(Number::from(max_uses)),
+        );
 
         self
     }
@@ -155,8 +159,10 @@ impl CreateInvite {
     /// # }
     /// ```
     pub fn temporary(mut self, temporary: bool) -> Self {
-        self.0
-            .insert("temporary".to_owned(), Value::Bool(temporary));
+        self.0.insert(
+            "temporary".to_owned(),
+            Value::Bool(temporary),
+        );
 
         self
     }
diff --git a/src/builder/create_message.rs b/src/builder/create_message.rs
index dea77e1..1ac5211 100644
--- a/src/builder/create_message.rs
+++ b/src/builder/create_message.rs
@@ -46,8 +46,10 @@ impl CreateMessage {
     ///
     /// **Note**: Message contents must be under 2000 unicode code points.
     pub fn content<D: Display>(mut self, content: D) -> Self {
-        self.0
-            .insert("content".to_owned(), Value::String(format!("{}", content)));
+        self.0.insert(
+            "content".to_owned(),
+            Value::String(format!("{}", content)),
+        );
 
         CreateMessage(self.0, self.1)
     }
diff --git a/src/builder/edit_channel.rs b/src/builder/edit_channel.rs
index e3bf78e..a5d799f 100644
--- a/src/builder/edit_channel.rs
+++ b/src/builder/edit_channel.rs
@@ -27,8 +27,10 @@ impl EditChannel {
     ///
     /// [voice]: ../model/enum.ChannelType.html#variant.Voice
     pub fn bitrate(mut self, bitrate: u64) -> Self {
-        self.0
-            .insert("bitrate".to_owned(), Value::Number(Number::from(bitrate)));
+        self.0.insert(
+            "bitrate".to_owned(),
+            Value::Number(Number::from(bitrate)),
+        );
 
         self
     }
@@ -37,16 +39,20 @@ impl EditChannel {
     ///
     /// Must be between 2 and 100 characters long.
     pub fn name(mut self, name: &str) -> Self {
-        self.0
-            .insert("name".to_owned(), Value::String(name.to_owned()));
+        self.0.insert(
+            "name".to_owned(),
+            Value::String(name.to_owned()),
+        );
 
         self
     }
 
     /// The position of the channel in the channel list.
     pub fn position(mut self, position: u64) -> Self {
-        self.0
-            .insert("position".to_owned(), Value::Number(Number::from(position)));
+        self.0.insert(
+            "position".to_owned(),
+            Value::Number(Number::from(position)),
+        );
 
         self
     }
@@ -59,8 +65,10 @@ impl EditChannel {
     ///
     /// [text]: ../model/enum.ChannelType.html#variant.Text
     pub fn topic(mut self, topic: &str) -> Self {
-        self.0
-            .insert("topic".to_owned(), Value::String(topic.to_owned()));
+        self.0.insert(
+            "topic".to_owned(),
+            Value::String(topic.to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/edit_guild.rs b/src/builder/edit_guild.rs
index f88db2a..6cfd13a 100644
--- a/src/builder/edit_guild.rs
+++ b/src/builder/edit_guild.rs
@@ -79,7 +79,10 @@ impl EditGuild {
     pub fn icon(mut self, icon: Option<&str>) -> Self {
         self.0.insert(
             "icon".to_owned(),
-            icon.map_or_else(|| Value::Null, |x| Value::String(x.to_owned())),
+            icon.map_or_else(
+                || Value::Null,
+                |x| Value::String(x.to_owned()),
+            ),
         );
 
         self
@@ -89,8 +92,10 @@ impl EditGuild {
     ///
     /// **Note**: Must be between (and including) 2-100 chracters.
     pub fn name(mut self, name: &str) -> Self {
-        self.0
-            .insert("name".to_owned(), Value::String(name.to_owned()));
+        self.0.insert(
+            "name".to_owned(),
+            Value::String(name.to_owned()),
+        );
 
         self
     }
@@ -134,8 +139,10 @@ impl EditGuild {
     ///
     /// [`Region::UsWest`]: ../model/enum.Region.html#variant.UsWest
     pub fn region(mut self, region: Region) -> Self {
-        self.0
-            .insert("region".to_owned(), Value::String(region.name().to_owned()));
+        self.0.insert(
+            "region".to_owned(),
+            Value::String(region.name().to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/edit_member.rs b/src/builder/edit_member.rs
index 23bf1f2..80ec983 100644
--- a/src/builder/edit_member.rs
+++ b/src/builder/edit_member.rs
@@ -39,8 +39,10 @@ impl EditMember {
     ///
     /// [Manage Nicknames]: ../model/permissions/constant.MANAGE_NICKNAMES.html
     pub fn nickname(mut self, nickname: &str) -> Self {
-        self.0
-            .insert("nick".to_owned(), Value::String(nickname.to_owned()));
+        self.0.insert(
+            "nick".to_owned(),
+            Value::String(nickname.to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/edit_profile.rs b/src/builder/edit_profile.rs
index 6aa4e78..3bc121c 100644
--- a/src/builder/edit_profile.rs
+++ b/src/builder/edit_profile.rs
@@ -61,8 +61,10 @@ impl EditProfile {
     ///
     /// [provided]: #method.password
     pub fn email(mut self, email: &str) -> Self {
-        self.0
-            .insert("email".to_owned(), Value::String(email.to_owned()));
+        self.0.insert(
+            "email".to_owned(),
+            Value::String(email.to_owned()),
+        );
 
         self
     }
@@ -88,8 +90,10 @@ impl EditProfile {
     /// [modifying the password]: #method.new_password
     /// [modifying the associated email address]: #method.email
     pub fn password(mut self, password: &str) -> Self {
-        self.0
-            .insert("password".to_owned(), Value::String(password.to_owned()));
+        self.0.insert(
+            "password".to_owned(),
+            Value::String(password.to_owned()),
+        );
 
         self
     }
@@ -101,8 +105,10 @@ impl EditProfile {
     /// If there are no available discriminators with the requested username,
     /// an error will occur.
     pub fn username(mut self, username: &str) -> Self {
-        self.0
-            .insert("username".to_owned(), Value::String(username.to_owned()));
+        self.0.insert(
+            "username".to_owned(),
+            Value::String(username.to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/edit_role.rs b/src/builder/edit_role.rs
index bece07c..9ac98d7 100644
--- a/src/builder/edit_role.rs
+++ b/src/builder/edit_role.rs
@@ -1,6 +1,6 @@
 use std::default::Default;
 use internal::prelude::*;
-use model::{permissions, Permissions, Role};
+use model::{Permissions, Role, permissions};
 
 /// A builer to create or edit a [`Role`] for use via a number of model methods.
 ///
@@ -58,13 +58,22 @@ impl EditRole {
 
         #[cfg(not(feature = "utils"))]
         {
-            map.insert("color".to_owned(), Value::Number(Number::from(role.colour)));
+            map.insert(
+                "color".to_owned(),
+                Value::Number(Number::from(role.colour)),
+            );
         }
 
         map.insert("hoist".to_owned(), Value::Bool(role.hoist));
         map.insert("managed".to_owned(), Value::Bool(role.managed));
-        map.insert("mentionable".to_owned(), Value::Bool(role.mentionable));
-        map.insert("name".to_owned(), Value::String(role.name.clone()));
+        map.insert(
+            "mentionable".to_owned(),
+            Value::Bool(role.mentionable),
+        );
+        map.insert(
+            "name".to_owned(),
+            Value::String(role.name.clone()),
+        );
         map.insert(
             "permissions".to_owned(),
             Value::Number(Number::from(role.permissions.bits())),
@@ -79,8 +88,10 @@ impl EditRole {
 
     /// Sets the colour of the role.
     pub fn colour(mut self, colour: u64) -> Self {
-        self.0
-            .insert("color".to_owned(), Value::Number(Number::from(colour)));
+        self.0.insert(
+            "color".to_owned(),
+            Value::Number(Number::from(colour)),
+        );
 
         self
     }
@@ -95,16 +106,20 @@ impl EditRole {
 
     /// Whether or not to make the role mentionable, notifying its users.
     pub fn mentionable(mut self, mentionable: bool) -> Self {
-        self.0
-            .insert("mentionable".to_owned(), Value::Bool(mentionable));
+        self.0.insert(
+            "mentionable".to_owned(),
+            Value::Bool(mentionable),
+        );
 
         self
     }
 
     /// The name of the role to set.
     pub fn name(mut self, name: &str) -> Self {
-        self.0
-            .insert("name".to_owned(), Value::String(name.to_owned()));
+        self.0.insert(
+            "name".to_owned(),
+            Value::String(name.to_owned()),
+        );
 
         self
     }
@@ -122,8 +137,10 @@ impl EditRole {
     /// The position to assign the role in the role list. This correlates to the
     /// role's position in the user list.
     pub fn position(mut self, position: u8) -> Self {
-        self.0
-            .insert("position".to_owned(), Value::Number(Number::from(position)));
+        self.0.insert(
+            "position".to_owned(),
+            Value::Number(Number::from(position)),
+        );
 
         self
     }
@@ -146,12 +163,24 @@ impl Default for EditRole {
         let mut map = Map::new();
         let permissions = Number::from(permissions::PRESET_GENERAL.bits());
 
-        map.insert("color".to_owned(), Value::Number(Number::from(10070709)));
+        map.insert(
+            "color".to_owned(),
+            Value::Number(Number::from(10070709)),
+        );
         map.insert("hoist".to_owned(), Value::Bool(false));
         map.insert("mentionable".to_owned(), Value::Bool(false));
-        map.insert("name".to_owned(), Value::String("new role".to_owned()));
-        map.insert("permissions".to_owned(), Value::Number(permissions));
-        map.insert("position".to_owned(), Value::Number(Number::from(1)));
+        map.insert(
+            "name".to_owned(),
+            Value::String("new role".to_owned()),
+        );
+        map.insert(
+            "permissions".to_owned(),
+            Value::Number(permissions),
+        );
+        map.insert(
+            "position".to_owned(),
+            Value::Number(Number::from(1)),
+        );
 
         EditRole(map)
     }
diff --git a/src/builder/execute_webhook.rs b/src/builder/execute_webhook.rs
index 0cb276c..05f0d00 100644
--- a/src/builder/execute_webhook.rs
+++ b/src/builder/execute_webhook.rs
@@ -103,8 +103,10 @@ impl ExecuteWebhook {
     ///
     /// [`embeds`]: #method.embeds
     pub fn content(mut self, content: &str) -> Self {
-        self.0
-            .insert("content".to_owned(), Value::String(content.to_owned()));
+        self.0.insert(
+            "content".to_owned(),
+            Value::String(content.to_owned()),
+        );
 
         self
     }
@@ -165,8 +167,10 @@ impl ExecuteWebhook {
     /// }
     /// ```
     pub fn username(mut self, username: &str) -> Self {
-        self.0
-            .insert("username".to_owned(), Value::String(username.to_owned()));
+        self.0.insert(
+            "username".to_owned(),
+            Value::String(username.to_owned()),
+        );
 
         self
     }
diff --git a/src/builder/get_messages.rs b/src/builder/get_messages.rs
index bca2f0e..8ac5dfe 100644
--- a/src/builder/get_messages.rs
+++ b/src/builder/get_messages.rs
@@ -85,8 +85,10 @@ impl GetMessages {
     /// limitation. If an amount larger than 100 is supplied, it will be
     /// reduced.
     pub fn limit(mut self, limit: u64) -> Self {
-        self.0
-            .insert("limit".to_owned(), if limit > 100 { 100 } else { limit });
+        self.0.insert(
+            "limit".to_owned(),
+            if limit > 100 { 100 } else { limit },
+        );
 
         self
     }
diff --git a/src/cache/cache_events_impl.rs b/src/cache/cache_events_impl.rs
index 7424add..cbf0e77 100644
--- a/src/cache/cache_events_impl.rs
+++ b/src/cache/cache_events_impl.rs
@@ -7,51 +7,39 @@ use model::*;
 use model::event::*;
 
 pub(crate) trait CacheEventsImpl {
-    fn update_with_channel_create(&mut self,
-                                  event: &ChannelCreateEvent)
-                                        -> Option<Channel>;
+    fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel>;
 
     fn update_with_channel_delete(&mut self, event: &ChannelDeleteEvent);
 
     fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent);
 
-    fn update_with_channel_recipient_add(&mut self,
-                                                    event: &mut ChannelRecipientAddEvent);
+    fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent);
 
-    fn update_with_channel_recipient_remove(&mut self,
-                                                       event: &ChannelRecipientRemoveEvent);
+    fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent);
 
     fn update_with_channel_update(&mut self, event: &ChannelUpdateEvent);
 
     fn update_with_guild_create(&mut self, event: &GuildCreateEvent);
 
-    fn update_with_guild_delete(&mut self,
-                                           event: &GuildDeleteEvent)
-                                           -> Option<Arc<RwLock<Guild>>>;
+    fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent) -> Option<Arc<RwLock<Guild>>>;
 
     fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent);
 
     fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent);
 
-    fn update_with_guild_member_remove(&mut self,
-                                                  event: &GuildMemberRemoveEvent)
-                                                  -> Option<Member>;
+    fn update_with_guild_member_remove(&mut self, event: &GuildMemberRemoveEvent)
+                                       -> Option<Member>;
 
-    fn update_with_guild_member_update(&mut self,
-                                                  event: &GuildMemberUpdateEvent)
-                                                  -> Option<Member>;
+    fn update_with_guild_member_update(&mut self, event: &GuildMemberUpdateEvent)
+                                       -> Option<Member>;
 
     fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent);
 
     fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent);
 
-    fn update_with_guild_role_delete(&mut self,
-                                                event: &GuildRoleDeleteEvent)
-                                                -> Option<Role>;
+    fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role>;
 
-    fn update_with_guild_role_update(&mut self,
-                                                event: &GuildRoleUpdateEvent)
-                                                -> Option<Role>;
+    fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role>;
 
     fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent);
 
@@ -69,9 +57,7 @@ pub(crate) trait CacheEventsImpl {
 }
 
 impl CacheEventsImpl for super::Cache {
-    fn update_with_channel_create(&mut self,
-                                  event: &ChannelCreateEvent)
-                                        -> Option<Channel> {
+    fn update_with_channel_create(&mut self, event: &ChannelCreateEvent) -> Option<Channel> {
         match event.channel {
             Channel::Group(ref group) => {
                 let group = group.clone();
@@ -104,11 +90,10 @@ impl CacheEventsImpl for super::Cache {
                 self.guilds
                     .get_mut(&guild_id)
                     .and_then(|guild| {
-                        guild
-                            .write()
-                            .unwrap()
-                            .channels
-                            .insert(channel_id, channel.clone())
+                        guild.write().unwrap().channels.insert(
+                            channel_id,
+                            channel.clone(),
+                        )
                     })
                     .map(Channel::Guild)
             },
@@ -131,8 +116,10 @@ impl CacheEventsImpl for super::Cache {
 
                 channel_writer.recipient = self.users[&user_id].clone();
 
-                let ch = self.private_channels
-                    .insert(channel_writer.id, channel.clone());
+                let ch = self.private_channels.insert(
+                    channel_writer.id,
+                    channel.clone(),
+                );
                 ch.map(Channel::Private)
             },
         }
@@ -141,9 +128,11 @@ impl CacheEventsImpl for super::Cache {
     fn update_with_channel_delete(&mut self, event: &ChannelDeleteEvent) {
         let channel = match event.channel {
             Channel::Guild(ref channel) => channel,
-            // We ignore these two due to the fact that the delete event for dms/groups will _not_ fire
+            // We ignore these two due to the fact that the delete event for dms/groups
+            // will _not_ fire
             // anymore.
-            Channel::Private(_) | Channel::Group(_) => unreachable!(),
+            Channel::Private(_) |
+            Channel::Group(_) => unreachable!(),
         };
 
         let (channel_id, guild_id) = {
@@ -154,9 +143,9 @@ impl CacheEventsImpl for super::Cache {
 
         self.channels.remove(&channel_id);
 
-        self.guilds
-            .get_mut(&guild_id)
-            .and_then(|guild| guild.write().unwrap().channels.remove(&channel_id));
+        self.guilds.get_mut(&guild_id).and_then(|guild| {
+            guild.write().unwrap().channels.remove(&channel_id)
+        });
     }
 
     #[allow(dead_code)]
@@ -180,22 +169,19 @@ impl CacheEventsImpl for super::Cache {
         }
     }
 
-    fn update_with_channel_recipient_add(&mut self,
-                                                    event: &mut ChannelRecipientAddEvent) {
+    fn update_with_channel_recipient_add(&mut self, event: &mut ChannelRecipientAddEvent) {
         self.update_user_entry(&event.user);
         let user = self.users[&event.user.id].clone();
 
         self.groups.get_mut(&event.channel_id).map(|group| {
-            group
-                .write()
-                .unwrap()
-                .recipients
-                .insert(event.user.id, user);
+            group.write().unwrap().recipients.insert(
+                event.user.id,
+                user,
+            );
         });
     }
 
-    fn update_with_channel_recipient_remove(&mut self,
-                                                       event: &ChannelRecipientRemoveEvent) {
+    fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemoveEvent) {
         self.groups.get_mut(&event.channel_id).map(|group| {
             group.write().unwrap().recipients.remove(&event.user.id)
         });
@@ -238,11 +224,10 @@ impl CacheEventsImpl for super::Cache {
 
                 self.channels.insert(channel_id, channel.clone());
                 self.guilds.get_mut(&guild_id).map(|guild| {
-                    guild
-                        .write()
-                        .unwrap()
-                        .channels
-                        .insert(channel_id, channel.clone())
+                    guild.write().unwrap().channels.insert(
+                        channel_id,
+                        channel.clone(),
+                    )
                 });
             },
             Channel::Private(ref channel) => {
@@ -266,13 +251,13 @@ impl CacheEventsImpl for super::Cache {
         }
 
         self.channels.extend(guild.channels.clone());
-        self.guilds
-            .insert(event.guild.id, Arc::new(RwLock::new(guild)));
+        self.guilds.insert(
+            event.guild.id,
+            Arc::new(RwLock::new(guild)),
+        );
     }
 
-    fn update_with_guild_delete(&mut self,
-                                           event: &GuildDeleteEvent)
-                                           -> Option<Arc<RwLock<Guild>>> {
+    fn update_with_guild_delete(&mut self, event: &GuildDeleteEvent) -> Option<Arc<RwLock<Guild>>> {
         // Remove channel entries for the guild if the guild is found.
         self.guilds.remove(&event.guild.id).map(|guild| {
             for channel_id in guild.read().unwrap().channels.keys() {
@@ -305,8 +290,8 @@ impl CacheEventsImpl for super::Cache {
     }
 
     fn update_with_guild_member_remove(&mut self,
-                                                  event: &GuildMemberRemoveEvent)
-                                                  -> Option<Member> {
+                                       event: &GuildMemberRemoveEvent)
+                                       -> Option<Member> {
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
             let mut guild = guild.write().unwrap();
 
@@ -316,8 +301,8 @@ impl CacheEventsImpl for super::Cache {
     }
 
     fn update_with_guild_member_update(&mut self,
-                                                  event: &GuildMemberUpdateEvent)
-                                                  -> Option<Member> {
+                                       event: &GuildMemberUpdateEvent)
+                                       -> Option<Member> {
         self.update_user_entry(&event.user);
 
         if let Some(guild) = self.guilds.get_mut(&event.guild_id) {
@@ -372,32 +357,24 @@ impl CacheEventsImpl for super::Cache {
 
     fn update_with_guild_role_create(&mut self, event: &GuildRoleCreateEvent) {
         self.guilds.get_mut(&event.guild_id).map(|guild| {
-            guild
-                .write()
-                .unwrap()
-                .roles
-                .insert(event.role.id, event.role.clone())
+            guild.write().unwrap().roles.insert(
+                event.role.id,
+                event.role.clone(),
+            )
         });
     }
 
-    fn update_with_guild_role_delete(&mut self,
-                                                event: &GuildRoleDeleteEvent)
-                                                -> Option<Role> {
-        self.guilds
-            .get_mut(&event.guild_id)
-            .and_then(|guild| guild.write().unwrap().roles.remove(&event.role_id))
+    fn update_with_guild_role_delete(&mut self, event: &GuildRoleDeleteEvent) -> Option<Role> {
+        self.guilds.get_mut(&event.guild_id).and_then(|guild| {
+            guild.write().unwrap().roles.remove(&event.role_id)
+        })
     }
 
-    fn update_with_guild_role_update(&mut self,
-                                                event: &GuildRoleUpdateEvent)
-                                                -> Option<Role> {
+    fn update_with_guild_role_update(&mut self, event: &GuildRoleUpdateEvent) -> Option<Role> {
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
-            guild
-                .write()
-                .unwrap()
-                .roles
-                .get_mut(&event.role.id)
-                .map(|role| mem::replace(role, event.role.clone()))
+            guild.write().unwrap().roles.get_mut(&event.role.id).map(
+                |role| mem::replace(role, event.role.clone()),
+            )
         })
     }
 
@@ -449,16 +426,19 @@ impl CacheEventsImpl for super::Cache {
                 if event.presence.status == OnlineStatus::Offline {
                     guild.presences.remove(&event.presence.user_id);
                 } else {
-                    guild
-                        .presences
-                        .insert(event.presence.user_id, event.presence.clone());
+                    guild.presences.insert(
+                        event.presence.user_id,
+                        event.presence.clone(),
+                    );
                 }
             }
         } else if event.presence.status == OnlineStatus::Offline {
             self.presences.remove(&event.presence.user_id);
         } else {
-            self.presences
-                .insert(event.presence.user_id, event.presence.clone());
+            self.presences.insert(
+                event.presence.user_id,
+                event.presence.clone(),
+            );
         }
     }
 
@@ -516,9 +496,10 @@ impl CacheEventsImpl for super::Cache {
                         }
                     }
 
-                    guild
-                        .voice_states
-                        .insert(event.voice_state.user_id, event.voice_state.clone());
+                    guild.voice_states.insert(
+                        event.voice_state.user_id,
+                        event.voice_state.clone(),
+                    );
                 } else {
                     // Remove the user from the voice state list
                     guild.voice_states.remove(&event.voice_state.user_id);
@@ -528,4 +509,4 @@ impl CacheEventsImpl for super::Cache {
             return;
         }
     }
-} 
\ No newline at end of file
+}
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 19089ee..68a78a7 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -553,9 +553,9 @@ impl Cache {
     /// ```
     pub fn role<G, R>(&self, guild_id: G, role_id: R) -> Option<Role>
         where G: Into<GuildId>, R: Into<RoleId> {
-        self.guilds
-            .get(&guild_id.into())
-            .and_then(|g| g.read().unwrap().roles.get(&role_id.into()).cloned())
+        self.guilds.get(&guild_id.into()).and_then(|g| {
+            g.read().unwrap().roles.get(&role_id.into()).cloned()
+        })
     }
 
     /// Retrieves a `User` from the cache's [`users`] map, if it exists.
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index cb33cb1..a3d528e 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -172,7 +172,8 @@ 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 || {
@@ -198,7 +199,11 @@ 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(())
             });
         },
@@ -209,7 +214,11 @@ 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(())
             });
         },
@@ -323,7 +332,11 @@ 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(())
             });
         },
@@ -343,7 +356,11 @@ 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(())
             });
         },
@@ -397,7 +414,11 @@ 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(())
             });
         },
@@ -488,7 +509,11 @@ 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(())
             });
         },
@@ -497,7 +522,11 @@ 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(())
             });
         },
@@ -553,7 +582,11 @@ 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(())
             });
         },
@@ -643,7 +676,11 @@ 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(())
             });
         },
@@ -652,7 +689,11 @@ 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 619653c..1a576f2 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -540,7 +540,10 @@ 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.
@@ -665,7 +668,10 @@ 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.
@@ -723,7 +729,8 @@ 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(),
diff --git a/src/error.rs b/src/error.rs
index 508578b..3944a4c 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -171,7 +171,8 @@ impl Display for Error {
 impl StdError for Error {
     fn description(&self) -> &str {
         match *self {
-            Error::Decode(msg, _) | Error::Other(msg) => msg,
+            Error::Decode(msg, _) |
+            Error::Other(msg) => msg,
             Error::ExceededLimit(..) => "Input exceeded a limit",
             Error::Format(ref inner) => inner.description(),
             Error::Io(ref inner) => inner.description(),
diff --git a/src/framework/buckets.rs b/src/framework/buckets.rs
index 4719b85..f2c4486 100644
--- a/src/framework/buckets.rs
+++ b/src/framework/buckets.rs
@@ -31,9 +31,9 @@ pub(crate) struct Bucket {
 impl Bucket {
     pub fn take(&mut self, user_id: u64) -> i64 {
         let time = Utc::now().timestamp();
-        let user = self.users
-            .entry(user_id)
-            .or_insert_with(MemberRatelimit::default);
+        let user = self.users.entry(user_id).or_insert_with(
+            MemberRatelimit::default,
+        );
 
         if let Some((timespan, limit)) = self.ratelimit.limit {
             if (user.tickets + 1) > limit {
diff --git a/src/framework/command.rs b/src/framework/command.rs
index 3528e85..01c4c5e 100644
--- a/src/framework/command.rs
+++ b/src/framework/command.rs
@@ -6,7 +6,10 @@ use std::collections::HashMap;
 
 pub type Check = Fn(&mut Context, &Message, &[String], &Arc<Command>) -> bool + 'static;
 pub type Exec = Fn(&mut Context, &Message, Vec<String>, String) -> Result<(), String> + 'static;
-pub type Help = Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, &[String])
+pub type Help = Fn(&mut Context,
+                   &Message,
+                   HashMap<String, Arc<CommandGroup>>,
+                   &[String])
                    -> Result<(), String>
                     + 'static;
 pub type BeforeHook = Fn(&mut Context, &Message, &str) -> bool + 'static;
diff --git a/src/framework/configuration.rs b/src/framework/configuration.rs
index 2854d90..bd64cba 100644
--- a/src/framework/configuration.rs
+++ b/src/framework/configuration.rs
@@ -269,8 +269,8 @@ impl Configuration {
 
         if let Ok(current_user) = http::get_current_user() {
             self.on_mention = Some(vec![
-                format!("<@{}>", current_user.id),  // Regular mention
-                format!("<@!{}>", current_user.id), // Nickname mention
+                format!("<@{}>", current_user.id), // Regular mention
+                format!("<@!{}>", current_user.id) /* Nickname mention */,
             ]);
         }
 
@@ -415,7 +415,9 @@ impl Configuration {
     /// ```
     pub fn delimiters(mut self, delimiters: Vec<&str>) -> Self {
         self.delimiters.clear();
-        self.delimiters.extend(delimiters.into_iter().map(|s| s.to_string()));
+        self.delimiters.extend(
+            delimiters.into_iter().map(|s| s.to_string()),
+        );
 
         self
     }
diff --git a/src/framework/create_command.rs b/src/framework/create_command.rs
index 242c62f..3110a9c 100644
--- a/src/framework/create_command.rs
+++ b/src/framework/create_command.rs
@@ -11,7 +11,9 @@ pub struct CreateCommand(pub Command);
 impl CreateCommand {
     /// Adds multiple aliases.
     pub fn batch_known_as(mut self, names: Vec<&str>) -> Self {
-        self.0.aliases.extend(names.into_iter().map(|n| n.to_owned()));
+        self.0.aliases.extend(
+            names.into_iter().map(|n| n.to_owned()),
+        );
 
         self
     }
@@ -50,20 +52,25 @@ impl CreateCommand {
     ///         .desc("Replies to a ping with a pong")
     ///         .exec(ping)));
     ///
-    /// fn ping(_context: &mut Context, message: &Message, _args: Vec<String>, _original_msg: String) -> Result<(),
+    /// fn ping(_context: &mut Context, message: &Message, _args: Vec<String>, _original_msg:
+    /// String) -> Result<(),
     /// String> {
     ///     let _ = message.channel_id.say("Pong!");
     ///
     ///     Ok(())
     /// }
     ///
-    /// fn owner_check(_context: &mut Context, message: &Message, _: &[String], _: &Arc<Command>) -> bool {
+    /// fn owner_check(_context: &mut Context, message: &Message, _: &[String], _:
+    /// &Arc<Command>) -> bool {
     ///     // replace with your user ID
     ///     message.author.id == 7
     /// }
     /// ```
     pub fn check<F>(mut self, check: F) -> Self
-        where F: Fn(&mut Context, &Message, &[String], &Arc<Command>) -> bool + Send + Sync + 'static {
+        where F: Fn(&mut Context, &Message, &[String], &Arc<Command>) -> bool
+                     + Send
+                     + Sync
+                     + 'static {
         self.0.checks.push(Box::new(check));
 
         self
@@ -112,7 +119,10 @@ impl CreateCommand {
     ///
     /// You can return `Err(string)` if there's an error.
     pub fn exec_help<F>(mut self, f: F) -> Self
-        where F: Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, &[String])
+        where F: Fn(&mut Context,
+                    &Message,
+                    HashMap<String, Arc<CommandGroup>>,
+                    &[String])
                     -> Result<(), String>
                      + 'static {
         self.0.exec = CommandType::WithCommands(Box::new(f));
diff --git a/src/framework/create_group.rs b/src/framework/create_group.rs
index a999268..b45c41e 100644
--- a/src/framework/create_group.rs
+++ b/src/framework/create_group.rs
@@ -34,7 +34,9 @@ impl CreateGroup {
             if let Some(ref prefix) = self.0.prefix {
                 self.0.commands.insert(
                     format!("{} {}", prefix, n.to_owned()),
-                    CommandOrAlias::Alias(format!("{} {}", prefix, command_name.to_string())),
+                    CommandOrAlias::Alias(
+                        format!("{} {}", prefix, command_name.to_string()),
+                    ),
                 );
             } else {
                 self.0.commands.insert(
@@ -61,9 +63,10 @@ impl CreateGroup {
                      + 'static {
         let cmd = Arc::new(Command::new(f));
 
-        self.0
-            .commands
-            .insert(command_name.to_owned(), CommandOrAlias::Command(cmd));
+        self.0.commands.insert(
+            command_name.to_owned(),
+            CommandOrAlias::Command(cmd),
+        );
 
         self
     }
diff --git a/src/framework/help_commands.rs b/src/framework/help_commands.rs
index dec0053..7846259 100644
--- a/src/framework/help_commands.rs
+++ b/src/framework/help_commands.rs
@@ -117,15 +117,19 @@ pub fn with_embeds(_: &mut Context,
 
                         if let Some(ref usage) = command.usage {
                             embed = embed.field(|f| {
-                                f.name("Usage")
-                                    .value(&format!("`{} {}`", command_name, usage))
+                                f.name("Usage").value(
+                                    &format!("`{} {}`", command_name, usage),
+                                )
                             });
                         }
 
                         if let Some(ref example) = command.example {
                             embed = embed.field(|f| {
-                                f.name("Sample usage")
-                                    .value(&format!("`{} {}`", command_name, example))
+                                f.name("Sample usage").value(&format!(
+                                    "`{} {}`",
+                                    command_name,
+                                    example
+                                ))
                             });
                         }
 
@@ -295,8 +299,10 @@ pub fn plain(_: &mut Context,
             }
         }
 
-        let _ = msg.channel_id
-            .say(&format!("**Error**: Command `{}` not found.", name));
+        let _ = msg.channel_id.say(&format!(
+            "**Error**: Command `{}` not found.",
+            name
+        ));
 
         return Ok(());
     }
diff --git a/src/framework/mod.rs b/src/framework/mod.rs
index c95c160..a3a9447 100644
--- a/src/framework/mod.rs
+++ b/src/framework/mod.rs
@@ -491,9 +491,12 @@ impl BuiltinFramework {
             }
 
             if let Some(guild) = guild_id.find() {
-                return self.configuration
-                    .blocked_users
-                    .contains(&guild.read().unwrap().owner_id);
+                return self.configuration.blocked_users.contains(
+                    &guild
+                        .read()
+                        .unwrap()
+                        .owner_id,
+                );
             }
         }
 
@@ -504,10 +507,10 @@ impl BuiltinFramework {
     fn has_correct_permissions(&self, command: &Arc<Command>, message: &Message) -> bool {
         if !command.required_permissions.is_empty() {
             if let Some(guild) = message.guild() {
-                let perms = guild
-                    .read()
-                    .unwrap()
-                    .permissions_for(message.channel_id, message.author.id);
+                let perms = guild.read().unwrap().permissions_for(
+                    message.channel_id,
+                    message.author.id,
+                );
 
                 return perms.contains(command.required_permissions);
             }
@@ -537,7 +540,8 @@ impl BuiltinFramework {
                     let rate_limit = bucket.take(message.author.id.0);
                     match bucket.check {
                         Some(ref check) => {
-                            let apply = feature_cache! {{
+                            let apply =
+                                feature_cache! {{
                                 let guild_id = message.guild_id();
                                 (check)(context, guild_id, message.channel_id, message.author.id)
                             } else {
@@ -548,8 +552,10 @@ impl BuiltinFramework {
                                 return Some(DispatchError::RateLimited(rate_limit));
                             }
                         },
-                        None => if rate_limit > 0i64 {
-                            return Some(DispatchError::RateLimited(rate_limit));
+                        None => {
+                            if rate_limit > 0i64 {
+                                return Some(DispatchError::RateLimited(rate_limit));
+                            }
                         },
                     }
                 }
@@ -588,7 +594,7 @@ impl BuiltinFramework {
                 }
 
                 if (!self.configuration.allow_dm && message.is_private()) ||
-                    (command.guild_only && message.is_private()) {
+                   (command.guild_only && message.is_private()) {
                     return Some(DispatchError::OnlyForGuilds);
                 }
 
@@ -599,14 +605,13 @@ impl BuiltinFramework {
 
             if command.owners_only {
                 Some(DispatchError::OnlyForOwners)
-            } else if !command
-                .checks
-                .iter()
-                .all(|check| (check)(&mut context, message, args, command)) {
+            } else if !command.checks.iter().all(|check| {
+                (check)(&mut context, message, args, command)
+            }) {
                 Some(DispatchError::CheckFailed(command.to_owned()))
-            } else if self.configuration
-                .blocked_users
-                .contains(&message.author.id) {
+            } else if self.configuration.blocked_users.contains(
+                &message.author.id,
+            ) {
                 Some(DispatchError::BlockedUser)
             } else if self.configuration.disabled_commands.contains(to_check) {
                 Some(DispatchError::CommandDisabled(to_check.to_owned()))
@@ -661,16 +666,21 @@ impl BuiltinFramework {
         where F: Fn(&mut Context, &Message, Vec<String>, String) -> Result<(), String> + 'static,
               S: Into<String> {
         {
-            let ungrouped = self.groups
-                .entry("Ungrouped".to_owned())
-                .or_insert_with(|| Arc::new(CommandGroup::default()));
+            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
+                || {
+                    Arc::new(CommandGroup::default())
+                },
+            );
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let name = command_name.into();
 
-                group
-                    .commands
-                    .insert(name, CommandOrAlias::Command(Arc::new(Command::new(f))));
+                group.commands.insert(
+                    name,
+                    CommandOrAlias::Command(
+                        Arc::new(Command::new(f)),
+                    ),
+                );
             }
         }
 
@@ -693,9 +703,11 @@ impl BuiltinFramework {
     pub fn command<F, S>(mut self, command_name: S, f: F) -> Self
         where F: FnOnce(CreateCommand) -> CreateCommand, S: Into<String> {
         {
-            let ungrouped = self.groups
-                .entry("Ungrouped".to_owned())
-                .or_insert_with(|| Arc::new(CommandGroup::default()));
+            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
+                || {
+                    Arc::new(CommandGroup::default())
+                },
+            );
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let cmd = f(CreateCommand(Command::default())).0;
@@ -710,15 +722,17 @@ impl BuiltinFramework {
                     }
                 } else {
                     for v in &cmd.aliases {
-                        group
-                            .commands
-                            .insert(v.to_owned(), CommandOrAlias::Alias(name.clone()));
+                        group.commands.insert(
+                            v.to_owned(),
+                            CommandOrAlias::Alias(name.clone()),
+                        );
                     }
                 }
 
-                group
-                    .commands
-                    .insert(name, CommandOrAlias::Command(Arc::new(cmd)));
+                group.commands.insert(
+                    name,
+                    CommandOrAlias::Command(Arc::new(cmd)),
+                );
             }
         }
 
@@ -930,7 +944,7 @@ impl Framework for BuiltinFramework {
                     let command_length = built.len();
 
                     if let Some(&CommandOrAlias::Alias(ref points_to)) =
-                    group.commands.get(&built) {
+                        group.commands.get(&built) {
                         built = points_to.to_owned();
                     }
 
@@ -945,7 +959,7 @@ impl Framework for BuiltinFramework {
                     };
 
                     if let Some(&CommandOrAlias::Command(ref command)) =
-                    group.commands.get(&to_check) {
+                        group.commands.get(&to_check) {
                         let before = self.before.clone();
                         let command = command.clone();
                         let after = self.after.clone();
@@ -959,14 +973,24 @@ impl Framework for BuiltinFramework {
                                 (utils::parse_quotes(content), content.to_string())
                             } else {
                                 let delimiters = &self.configuration.delimiters;
-                                let regular_expression = delimiters.iter()
-                                    .map(|delimiter| escape(delimiter)).join("|");
+                                let regular_expression = delimiters
+                                    .iter()
+                                    .map(|delimiter| escape(delimiter))
+                                    .join("|");
 
                                 let regex = Regex::new(&regular_expression).unwrap();
 
-                                (regex.split(content)
-                                    .filter_map(|p| if !p.is_empty() { Some(p.to_string()) } else { None })
-                                    .collect::<Vec<_>>(), content.to_string())
+                                (
+                                    regex
+                                        .split(content)
+                                        .filter_map(|p| if !p.is_empty() {
+                                            Some(p.to_string())
+                                        } else {
+                                            None
+                                        })
+                                        .collect::<Vec<_>>(),
+                                    content.to_string(),
+                                )
                             }
                         };
 
@@ -997,7 +1021,9 @@ impl Framework for BuiltinFramework {
 
                                     Ok(())
                                 },
-                                CommandType::Basic(ref x) => (x)(&mut context, &message, args, content),
+                                CommandType::Basic(ref x) => {
+                                    (x)(&mut context, &message, args, content)
+                                },
                                 CommandType::WithCommands(ref x) => {
                                     (x)(&mut context, &message, groups, &args)
                                 },
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index ccb3f85..533d1f4 100644
--- a/src/gateway/shard.rs
+++ b/src/gateway/shard.rs
@@ -12,7 +12,7 @@ use websocket::stream::sync::AsTcpStream;
 use websocket::sync::client::{Client, ClientBuilder};
 use websocket::sync::stream::{TcpStream, TlsStream};
 use websocket::WebSocketError;
-use constants::{self, close_codes, OpCode};
+use constants::{self, OpCode, close_codes};
 use internal::prelude::*;
 use internal::ws_impl::SenderExt;
 use model::event::{Event, GatewayEvent};
@@ -137,7 +137,8 @@ impl Shard {
         let stage = ConnectionStage::Handshake;
         let session_id = None;
 
-        let mut shard = feature_voice! {{
+        let mut shard =
+            feature_voice! {{
             let (tx, rx) = mpsc::channel();
 
             let user = http::get_current_user()?;
@@ -470,7 +471,8 @@ impl Shard {
 
                         return Err(Error::Gateway(GatewayError::OverloadedShard));
                     },
-                    Some(4006) | Some(close_codes::SESSION_TIMEOUT) => {
+                    Some(4006) |
+                    Some(close_codes::SESSION_TIMEOUT) => {
                         info!("[Shard {:?}] Invalid session", self.shard_info);
 
                         self.session_id = None;
@@ -740,9 +742,10 @@ impl Shard {
             },
             Err(why) => {
                 match why {
-                    Error::WebSocket(WebSocketError::IoError(err)) => if err.raw_os_error() !=
-                                                                         Some(32) {
-                        debug!("[Shard {:?}] Err w/ heartbeating: {:?}", self.shard_info, err);
+                    Error::WebSocket(WebSocketError::IoError(err)) => {
+                        if err.raw_os_error() != Some(32) {
+                            debug!("[Shard {:?}] Err w/ heartbeating: {:?}", self.shard_info, err);
+                        }
                     },
                     other => {
                         warn!("[Shard {:?}] Other err w/ keepalive: {:?}", self.shard_info, other);
@@ -936,8 +939,7 @@ fn connect(base_url: &str) -> Result<WsClient> {
 
 fn set_client_timeout(client: &mut WsClient) -> Result<()> {
     let stream = client.stream_ref().as_tcp();
-    stream
-        .set_read_timeout(Some(StdDuration::from_millis(100)))?;
+    stream.set_read_timeout(Some(StdDuration::from_millis(100)))?;
     stream.set_write_timeout(Some(StdDuration::from_secs(5)))?;
 
     Ok(())
diff --git a/src/http/mod.rs b/src/http/mod.rs
index 7692961..ab9bdb0 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -35,7 +35,7 @@ use hyper::header::ContentType;
 use hyper::method::Method;
 use hyper::mime::{Mime, SubLevel, TopLevel};
 use hyper::net::HttpsConnector;
-use hyper::{header, Error as HyperError, Result as HyperResult, Url};
+use hyper::{Error as HyperError, Result as HyperResult, Url, header};
 use hyper_native_tls::NativeTlsClient;
 use multipart::client::Multipart;
 use self::ratelimiting::Route;
@@ -549,9 +549,9 @@ pub fn delete_reaction(channel_id: u64,
                        user_id: Option<u64>,
                        reaction_type: &ReactionType)
                        -> Result<()> {
-    let user = user_id
-        .map(|uid| uid.to_string())
-        .unwrap_or_else(|| "@me".to_string());
+    let user = user_id.map(|uid| uid.to_string()).unwrap_or_else(
+        || "@me".to_string(),
+    );
 
     verify(
         204,
@@ -634,8 +634,9 @@ pub fn delete_webhook_with_token(webhook_id: u64, token: &str) -> Result<()> {
     verify(
         204,
         retry(|| {
-            client
-                .delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+            client.delete(
+                &format!(api!("/webhooks/{}/{}"), webhook_id, token),
+            )
         }).map_err(Error::Hyper)?,
     )
 }
@@ -738,7 +739,9 @@ pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Mes
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>) -> Result<()> {
-    let map = json!({ "nick": new_nickname });
+    let map = json!({
+        "nick": new_nickname
+    });
     let body = map.to_string();
     let response = request!(
         Route::GuildsIdMembersMeNick(guild_id),
@@ -776,8 +779,9 @@ pub fn edit_profile(map: &JsonMap) -> Result<CurrentUser> {
         }
     }
 
-    serde_json::from_value::<CurrentUser>(value)
-        .map_err(From::from)
+    serde_json::from_value::<CurrentUser>(value).map_err(
+        From::from,
+    )
 }
 
 /// Changes a role in a guild.
@@ -987,8 +991,11 @@ pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
-        Some(v) => serde_json::from_value::<Vec<Maintenance>>(v)
-            .map_err(From::from),
+        Some(v) => {
+            serde_json::from_value::<Vec<Maintenance>>(v).map_err(
+                From::from,
+            )
+        },
         None => Ok(vec![]),
     }
 }
@@ -1394,7 +1401,10 @@ pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
     if let Some(map) = v.as_object_mut() {
-        map.insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
+        map.insert(
+            "guild_id".to_owned(),
+            Value::Number(Number::from(guild_id)),
+        );
     }
 
     serde_json::from_value::<Member>(v).map_err(From::from)
@@ -1479,8 +1489,11 @@ pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("incidents") {
-        Some(v) => serde_json::from_value::<Vec<Incident>>(v)
-            .map_err(From::from),
+        Some(v) => {
+            serde_json::from_value::<Vec<Incident>>(v).map_err(
+                From::from,
+            )
+        },
         None => Ok(vec![]),
     }
 }
@@ -1498,8 +1511,11 @@ pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
     let mut map: BTreeMap<String, Value> = serde_json::from_reader(response)?;
 
     match map.remove("scheduled_maintenances") {
-        Some(v) => serde_json::from_value::<Vec<Maintenance>>(v)
-            .map_err(From::from),
+        Some(v) => {
+            serde_json::from_value::<Vec<Maintenance>>(v).map_err(
+                From::from,
+            )
+        },
         None => Ok(vec![]),
     }
 }
@@ -1573,8 +1589,9 @@ pub fn get_webhook_with_token(webhook_id: u64, token: &str) -> Result<Webhook> {
     let client = request_client!();
 
     let response = retry(|| {
-        client
-            .get(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+        client.get(
+            &format!(api!("/webhooks/{}/{}"), webhook_id, token),
+        )
     }).map_err(Error::Hyper)?;
 
     serde_json::from_reader::<HyperResponse, Webhook>(response)
@@ -1650,12 +1667,12 @@ pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result
     let tc = NativeTlsClient::new()?;
     let connector = HttpsConnector::new(tc);
     let mut request = Request::with_connector(Method::Post, url, &connector)?;
-    request
-        .headers_mut()
-        .set(header::Authorization(TOKEN.lock().unwrap().clone()));
-    request
-        .headers_mut()
-        .set(header::UserAgent(constants::USER_AGENT.to_owned()));
+    request.headers_mut().set(header::Authorization(
+        TOKEN.lock().unwrap().clone(),
+    ));
+    request.headers_mut().set(header::UserAgent(
+        constants::USER_AGENT.to_owned(),
+    ));
 
     let mut request = Multipart::from_request(request)?;
     let mut file_num = "0".to_owned();
@@ -1663,12 +1680,20 @@ pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result
     for file in files {
         match file.into() {
             AttachmentType::Bytes((mut bytes, filename)) => {
-                request
-                    .write_stream(&file_num, &mut bytes, Some(filename), None)?;
+                request.write_stream(
+                    &file_num,
+                    &mut bytes,
+                    Some(filename),
+                    None,
+                )?;
             },
             AttachmentType::File((mut f, filename)) => {
-                request
-                    .write_stream(&file_num, &mut f, Some(filename), None)?;
+                request.write_stream(
+                    &file_num,
+                    &mut f,
+                    Some(filename),
+                    None,
+                )?;
             },
             AttachmentType::Path(p) => {
                 request.write_file(&file_num, &p)?;
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index f0eb8fc..382661c 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -47,7 +47,7 @@ use hyper::status::StatusCode;
 use std::collections::HashMap;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
-use std::{str, thread, i64};
+use std::{i64, str, thread};
 use super::{HttpError, LightMethod};
 use internal::prelude::*;
 
@@ -503,12 +503,16 @@ impl RateLimit {
 
 fn parse_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
     match headers.get_raw(header) {
-        Some(header) => match str::from_utf8(&header[0]) {
-            Ok(v) => match v.parse::<i64>() {
-                Ok(v) => Ok(Some(v)),
-                Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
-            },
-            Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
+        Some(header) => {
+            match str::from_utf8(&header[0]) {
+                Ok(v) => {
+                    match v.parse::<i64>() {
+                        Ok(v) => Ok(Some(v)),
+                        Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
+                    }
+                },
+                Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
+            }
         },
         None => Ok(None),
     }
diff --git a/src/internal/ws_impl.rs b/src/internal/ws_impl.rs
index a80745d..cd9161a 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -42,8 +42,9 @@ impl ReceiverExt for WsClient<TlsStream<TcpStream>> {
                 }))
             },
             OwnedMessage::Ping(x) => {
-                self.send_message(&OwnedMessage::Pong(x))
-                    .map_err(Error::from)?;
+                self.send_message(&OwnedMessage::Pong(x)).map_err(
+                    Error::from,
+                )?;
 
                 None
             },
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index 1c7eb46..d8ccc71 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -306,9 +306,11 @@ 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(),
         })
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index 11d6162..7007ad6 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -123,8 +123,11 @@ 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.
@@ -242,8 +245,12 @@ 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
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 5706fa6..3fadd72 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -311,7 +311,10 @@ 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)),
@@ -540,8 +543,12 @@ 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.
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 6fdab2a..fb8fbaa 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -290,9 +290,10 @@ 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
@@ -318,8 +319,12 @@ 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.
@@ -332,8 +337,9 @@ 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
@@ -353,7 +359,8 @@ 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,
         }
     }
@@ -370,11 +377,7 @@ 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 cbe6085..626f466 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -117,8 +117,11 @@ 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.
@@ -156,7 +159,8 @@ impl Channel {
     pub fn is_nsfw(&self) -> bool {
         match *self {
             Channel::Guild(ref channel) => channel.read().unwrap().is_nsfw(),
-            Channel::Group(_) | Channel::Private(_) => false,
+            Channel::Group(_) |
+            Channel::Private(_) => false,
         }
     }
 
@@ -216,8 +220,12 @@ 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
@@ -318,15 +326,21 @@ 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")),
         }
     }
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index 277c6a1..30dc01d 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -191,8 +191,12 @@ 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.
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index ac522a0..8922182 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -46,7 +46,8 @@ impl Reaction {
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     /// [permissions]: permissions
     pub fn delete(&self) -> Result<()> {
-        let user_id = feature_cache! {{
+        let user_id =
+            feature_cache! {{
             let user = if self.user_id == CACHE.read().unwrap().user.id {
                 None
             } else {
diff --git a/src/model/event.rs b/src/model/event.rs
index 4178847..22cf649 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -153,8 +153,9 @@ impl<'de> Deserialize<'de> for GuildMemberAddEvent {
 
         Ok(GuildMemberAddEvent {
             guild_id: guild_id,
-            member: Member::deserialize(Value::Object(map))
-                .map_err(DeError::custom)?,
+            member: Member::deserialize(Value::Object(map)).map_err(
+                DeError::custom,
+            )?,
         })
     }
 }
@@ -188,8 +189,9 @@ impl<'de> Deserialize<'de> for GuildMembersChunkEvent {
             .and_then(|v| GuildId::deserialize(v.clone()))
             .map_err(DeError::custom)?;
 
-        let mut members = map.remove("members")
-            .ok_or_else(|| DeError::custom("missing member chunk members"))?;
+        let mut members = map.remove("members").ok_or_else(|| {
+            DeError::custom("missing member chunk members")
+        })?;
 
         if let Some(members) = members.as_array_mut() {
             let num = Value::Number(Number::from(guild_id.0));
@@ -305,17 +307,24 @@ impl<'de> Deserialize<'de> for PresenceUpdateEvent {
         let mut map = JsonMap::deserialize(deserializer)?;
 
         let guild_id = match map.remove("guild_id") {
-            Some(v) => serde_json::from_value::<Option<GuildId>>(v)
-                .map_err(DeError::custom)?,
+            Some(v) => {
+                serde_json::from_value::<Option<GuildId>>(v).map_err(
+                    DeError::custom,
+                )?
+            },
             None => None,
         };
         let roles = match map.remove("roles") {
-            Some(v) => serde_json::from_value::<Option<Vec<RoleId>>>(v)
-                .map_err(DeError::custom)?,
+            Some(v) => {
+                serde_json::from_value::<Option<Vec<RoleId>>>(v).map_err(
+                    DeError::custom,
+                )?
+            },
             None => None,
         };
-        let presence = Presence::deserialize(Value::Object(map))
-            .map_err(DeError::custom)?;
+        let presence = Presence::deserialize(Value::Object(map)).map_err(
+            DeError::custom,
+        )?;
 
         Ok(Self {
             guild_id: guild_id,
@@ -442,8 +451,9 @@ impl<'de> Deserialize<'de> for VoiceStateUpdateEvent {
 
         Ok(VoiceStateUpdateEvent {
             guild_id: guild_id,
-            voice_state: VoiceState::deserialize(Value::Object(map))
-                .map_err(DeError::custom)?,
+            voice_state: VoiceState::deserialize(Value::Object(map)).map_err(
+                DeError::custom,
+            )?,
         })
     }
 }
@@ -482,10 +492,9 @@ impl GatewayEvent {
                 let t = map.remove("t")
                     .ok_or_else(|| DeError::custom("expected gateway event type"))
                     .and_then(String::deserialize)?;
-                let d = map.remove("d")
-                    .ok_or_else(|| {
-                        Error::Decode("expected gateway event d", Value::Object(map))
-                    })?;
+                let d = map.remove("d").ok_or_else(|| {
+                    Error::Decode("expected gateway event d", Value::Object(map))
+                })?;
 
                 GatewayEvent::Dispatch(s, Event::decode(t, d)?)
             },
@@ -792,16 +801,20 @@ impl VoiceEvent {
         let mut map = JsonMap::deserialize(value)?;
 
         let op = match map.remove("op") {
-            Some(v) => VoiceOpCode::deserialize(v)
-                .map_err(JsonError::from)
-                .map_err(Error::from)?,
+            Some(v) => {
+                VoiceOpCode::deserialize(v)
+                    .map_err(JsonError::from)
+                    .map_err(Error::from)?
+            },
             None => return Err(Error::Decode("expected voice event op", Value::Object(map))),
         };
 
         let d = match map.remove("d") {
-            Some(v) => JsonMap::deserialize(v)
-                .map_err(JsonError::from)
-                .map_err(Error::from)?,
+            Some(v) => {
+                JsonMap::deserialize(v).map_err(JsonError::from).map_err(
+                    Error::from,
+                )?
+            },
             None => {
                 return Err(Error::Decode(
                     "expected voice gateway d",
diff --git a/src/model/gateway.rs b/src/model/gateway.rs
index 0c9f33e..6153abb 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -103,8 +103,9 @@ impl<'de> Deserialize<'de> for Game {
         let name = map.remove("name")
             .and_then(|v| String::deserialize(v).ok())
             .unwrap_or_else(String::new);
-        let url = map.remove("url")
-            .and_then(|v| serde_json::from_value::<String>(v).ok());
+        let url = map.remove("url").and_then(|v| {
+            serde_json::from_value::<String>(v).ok()
+        });
 
         Ok(Game {
             kind: kind,
@@ -170,8 +171,9 @@ impl<'de> Deserialize<'de> for Presence {
             .map_err(DeError::custom)?;
 
         let (user_id, user) = if user_map.len() > 1 {
-            let user = User::deserialize(Value::Object(user_map))
-                .map_err(DeError::custom)?;
+            let user = User::deserialize(Value::Object(user_map)).map_err(
+                DeError::custom,
+            )?;
 
             (user.id, Some(Arc::new(RwLock::new(user))))
         } else {
@@ -185,8 +187,11 @@ impl<'de> Deserialize<'de> for Presence {
         };
 
         let game = match map.remove("game") {
-            Some(v) => serde_json::from_value::<Option<Game>>(v)
-                .map_err(DeError::custom)?,
+            Some(v) => {
+                serde_json::from_value::<Option<Game>>(v).map_err(
+                    DeError::custom,
+                )?
+            },
             None => None,
         };
         let last_modified = match map.remove("last_modified") {
@@ -194,8 +199,11 @@ impl<'de> Deserialize<'de> for Presence {
             None => None,
         };
         let nick = match map.remove("nick") {
-            Some(v) => serde_json::from_value::<Option<String>>(v)
-                .map_err(DeError::custom)?,
+            Some(v) => {
+                serde_json::from_value::<Option<String>>(v).map_err(
+                    DeError::custom,
+                )?
+            },
             None => None,
         };
         let status = map.remove("status")
diff --git a/src/model/guild/audit_log.rs b/src/model/guild/audit_log.rs
index 916530e..962b145 100644
--- a/src/model/guild/audit_log.rs
+++ b/src/model/guild/audit_log.rs
@@ -53,7 +53,7 @@ pub enum ActionMember {
     Prune = 21,
     BanAdd = 22,
     BanRemove = 23,
-    Update = 24, 
+    Update = 24,
     RoleUpdate = 25,
 }
 
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 38033e3..819a4e9 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -168,10 +168,9 @@ impl Member {
 
         let default = Colour::default();
 
-        roles
-            .iter()
-            .find(|r| r.colour.0 != default.0)
-            .map(|r| r.colour)
+        roles.iter().find(|r| r.colour.0 != default.0).map(
+            |r| r.colour,
+        )
     }
 
     /// Calculates the member's display name.
@@ -179,10 +178,9 @@ impl Member {
     /// The nickname takes priority over the member's username if it exists.
     #[inline]
     pub fn display_name(&self) -> Cow<String> {
-        self.nick
-            .as_ref()
-            .map(Cow::Borrowed)
-            .unwrap_or_else(|| Cow::Owned(self.user.read().unwrap().name.clone()))
+        self.nick.as_ref().map(Cow::Borrowed).unwrap_or_else(|| {
+            Cow::Owned(self.user.read().unwrap().name.clone())
+        })
     }
 
     /// Returns the DiscordTag of a Member, taking possible nickname into account.
@@ -248,12 +246,11 @@ impl Member {
         {
             let req = permissions::KICK_MEMBERS;
 
-            let has_perms = CACHE
-                .read()
-                .unwrap()
-                .guilds
-                .get(&self.guild_id)
-                .map(|guild| guild.read().unwrap().has_perms(req));
+            let has_perms = CACHE.read().unwrap().guilds.get(&self.guild_id).map(
+                |guild| {
+                    guild.read().unwrap().has_perms(req)
+                },
+            );
 
             if let Some(Ok(false)) = has_perms {
                 return Err(Error::Model(ModelError::InvalidPermissions(req)));
@@ -288,10 +285,10 @@ impl Member {
 
         let guild = guild.read().unwrap();
 
-        Ok(
-            guild
-                .permissions_for(ChannelId(guild.id.0), self.user.read().unwrap().id),
-        )
+        Ok(guild.permissions_for(
+            ChannelId(guild.id.0),
+            self.user.read().unwrap().id,
+        ))
     }
 
     /// Removes a [`Role`] from the member, editing its roles in-place if the
diff --git a/src/model/guild/mod.rs b/src/model/guild/mod.rs
index e5e997c..3fc2a86 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -125,10 +125,11 @@ pub struct Guild {
 impl Guild {
     #[cfg(feature = "cache")]
     /// Returns the "default" channel of the guild.
-    /// (This returns the first channel that can be read by the bot, if there isn't one, returns `None`)
+    /// (This returns the first channel that can be read by the bot, if there isn't one,
+    /// returns `None`)
     pub fn default_channel(&self) -> Option<GuildChannel> {
         let uid = CACHE.read().unwrap().user.id;
-        
+
         for (cid, channel) in &self.channels {
             if self.permissions_for(*cid, uid).read_messages() {
                 return Some(channel.read().unwrap().clone());
@@ -139,14 +140,16 @@ impl Guild {
     }
 
     /// Returns the guaranteed "default" channel of the guild.
-    /// (This returns the first channel that can be read by everyone, if there isn't one, returns `None`)
-    /// Note however that this is very costy if used in a server with lots of channels, members, or both.
+    /// (This returns the first channel that can be read by everyone, if there isn't one,
+    /// returns `None`)
+    /// Note however that this is very costy if used in a server with lots of channels,
+    /// members, or both.
     pub fn default_channel_guaranteed(&self) -> Option<GuildChannel> {
         for (cid, channel) in &self.channels {
             for memid in self.members.keys() {
                 if self.permissions_for(*cid, *memid).read_messages() {
-                return Some(channel.read().unwrap().clone());
-            }
+                    return Some(channel.read().unwrap().clone());
+                }
             }
         }
 
@@ -165,7 +168,10 @@ impl Guild {
             None => return Err(Error::Model(ModelError::ItemMissing)),
         };
 
-        let perms = self.permissions_for(default_channel.id, member.user.read().unwrap().id);
+        let perms = self.permissions_for(
+            default_channel.id,
+            member.user.read().unwrap().id,
+        );
         permissions.remove(perms);
 
         Ok(permissions.is_empty())
@@ -623,9 +629,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's icon, if one exists.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(
+            |icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon),
+        )
     }
 
     /// Gets all integration of the guild.
@@ -703,8 +709,10 @@ impl Guild {
 
         for (&id, member) in &self.members {
             match self.presences.get(&id) {
-                Some(presence) => if status == presence.status {
-                    members.push(member);
+                Some(presence) => {
+                    if status == presence.status {
+                        members.push(member);
+                    }
                 },
                 None => continue,
             }
@@ -828,8 +836,8 @@ impl Guild {
 
             // If this is a text channel, then throw out voice permissions.
             if channel.kind == ChannelType::Text {
-                permissions &=
-                    !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS | USE_VAD);
+                permissions &= !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS |
+                                 USE_VAD);
             }
 
             // Apply the permission overwrites for the channel for each of the
@@ -955,9 +963,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(
+            |icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon),
+        )
     }
 
     /// Starts an integration sync for the given integration Id.
@@ -1036,16 +1044,18 @@ impl<'de> Deserialize<'de> for Guild {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> StdResult<Self, D::Error> {
         let mut map = JsonMap::deserialize(deserializer)?;
 
-        let id = map.get("id")
-            .and_then(|x| x.as_str())
-            .and_then(|x| x.parse::<u64>().ok());
+        let id = map.get("id").and_then(|x| x.as_str()).and_then(|x| {
+            x.parse::<u64>().ok()
+        });
 
         if let Some(guild_id) = id {
             if let Some(array) = map.get_mut("channels").and_then(|x| x.as_array_mut()) {
                 for value in array {
                     if let Some(channel) = value.as_object_mut() {
-                        channel
-                            .insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
+                        channel.insert(
+                            "guild_id".to_owned(),
+                            Value::Number(Number::from(guild_id)),
+                        );
                     }
                 }
             }
@@ -1053,16 +1063,21 @@ impl<'de> Deserialize<'de> for Guild {
             if let Some(array) = map.get_mut("members").and_then(|x| x.as_array_mut()) {
                 for value in array {
                     if let Some(member) = value.as_object_mut() {
-                        member
-                            .insert("guild_id".to_owned(), Value::Number(Number::from(guild_id)));
+                        member.insert(
+                            "guild_id".to_owned(),
+                            Value::Number(Number::from(guild_id)),
+                        );
                     }
                 }
             }
         }
 
         let afk_channel_id = match map.remove("afk_channel_id") {
-            Some(v) => serde_json::from_value::<Option<ChannelId>>(v)
-                .map_err(DeError::custom)?,
+            Some(v) => {
+                serde_json::from_value::<Option<ChannelId>>(v).map_err(
+                    DeError::custom,
+                )?
+            },
             None => None,
         };
         let afk_timeout = map.remove("afk_timeout")
@@ -1214,9 +1229,9 @@ pub struct GuildInfo {
 impl GuildInfo {
     /// Returns the formatted URL of the guild's icon, if the guild has an icon.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(
+            |icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon),
+        )
     }
 }
 
@@ -1236,9 +1251,9 @@ impl From<u64> for GuildContainer {
 impl InviteGuild {
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(
+            |icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon),
+        )
     }
 }
 
diff --git a/src/model/guild/partial_guild.rs b/src/model/guild/partial_guild.rs
index 88256f0..799f6b6 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -317,9 +317,9 @@ impl PartialGuild {
 
     /// Returns a formatted URL of the guild's icon, if the guild has an icon.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(|icon| {
+            format!(cdn!("/icons/{}/{}.webp"), self.id, icon)
+        })
     }
 
     /// Gets all integration of the guild.
@@ -419,9 +419,9 @@ impl PartialGuild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon
-            .as_ref()
-            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
+        self.icon.as_ref().map(|icon| {
+            format!(cdn!("/splashes/{}/{}.webp"), self.id, icon)
+        })
     }
 
     /// Starts an integration sync for the given integration Id.
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 3f74498..5956113 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -93,8 +93,9 @@ impl Role {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "builder", feature = "cache"))]
     pub fn edit<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
-        self.find_guild()
-            .and_then(|guild_id| guild_id.edit_role(self.id, f))
+        self.find_guild().and_then(
+            |guild_id| guild_id.edit_role(self.id, f),
+        )
     }
 
     /// Searches the cache for the guild that owns the role.
diff --git a/src/model/misc.rs b/src/model/misc.rs
index d2c17c5..9420968 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -58,9 +58,11 @@ impl FromStr for User {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_username(s) {
-            Some(x) => match UserId(x as u64).find() {
-                Some(user) => Ok(user.read().unwrap().clone()),
-                _ => Err(()),
+            Some(x) => {
+                match UserId(x as u64).find() {
+                    Some(user) => Ok(user.read().unwrap().clone()),
+                    _ => Err(()),
+                }
             },
             _ => Err(()),
         }
@@ -82,9 +84,11 @@ impl FromStr for Role {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_role(s) {
-            Some(x) => match RoleId(x).find() {
-                Some(user) => Ok(user),
-                _ => Err(()),
+            Some(x) => {
+                match RoleId(x).find() {
+                    Some(user) => Ok(user),
+                    _ => Err(()),
+                }
             },
             _ => Err(()),
         }
@@ -139,9 +143,11 @@ impl FromStr for Channel {
 
     fn from_str(s: &str) -> StdResult<Self, ()> {
         match utils::parse_channel(s) {
-            Some(x) => match ChannelId(x).find() {
-                Some(channel) => Ok(channel),
-                _ => Err(()),
+            Some(x) => {
+                match ChannelId(x).find() {
+                    Some(channel) => Ok(channel),
+                    _ => Err(()),
+                }
             },
             _ => Err(()),
         }
diff --git a/src/model/user.rs b/src/model/user.rs
index 16d5a06..7d26fd4 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -88,7 +88,10 @@ impl CurrentUser {
     pub fn edit<F>(&mut self, f: F) -> Result<()>
         where F: FnOnce(EditProfile) -> EditProfile {
         let mut map = Map::new();
-        map.insert("username".to_owned(), Value::String(self.name.clone()));
+        map.insert(
+            "username".to_owned(),
+            Value::String(self.name.clone()),
+        );
 
         if let Some(email) = self.email.as_ref() {
             map.insert("email".to_owned(), Value::String(email.clone()));
@@ -113,8 +116,9 @@ impl CurrentUser {
     /// [`avatar_url`]: #method.avatar_url
     /// [`default_avatar_url`]: #method.default_avatar_url
     pub fn face(&self) -> String {
-        self.avatar_url()
-            .unwrap_or_else(|| self.default_avatar_url())
+        self.avatar_url().unwrap_or_else(
+            || self.default_avatar_url(),
+        )
     }
 
     /// Gets a list of guilds that the current user is in.
@@ -487,7 +491,8 @@ impl User {
             return Err(Error::Model(ModelError::MessagingBot));
         }
 
-        let private_channel_id = feature_cache! {{
+        let private_channel_id =
+            feature_cache! {{
             let finding = {
                 let cache = CACHE.read().unwrap();
 
@@ -554,8 +559,9 @@ impl User {
     /// [`avatar_url`]: #method.avatar_url
     /// [`default_avatar_url`]: #method.default_avatar_url
     pub fn face(&self) -> String {
-        self.avatar_url()
-            .unwrap_or_else(|| self.default_avatar_url())
+        self.avatar_url().unwrap_or_else(
+            || self.default_avatar_url(),
+        )
     }
 
     /// Check if a user has a [`Role`]. This will retrieve the [`Guild`] from
@@ -792,7 +798,9 @@ fn default_avatar_url(discriminator: u16) -> String {
 
 #[cfg(feature = "model")]
 fn static_avatar_url(user_id: UserId, hash: Option<&String>) -> Option<String> {
-    hash.map(|hash| cdn!("/avatars/{}/{}.webp?size=1024", user_id, hash))
+    hash.map(
+        |hash| cdn!("/avatars/{}/{}.webp?size=1024", user_id, hash),
+    )
 }
 
 #[cfg(feature = "model")]
diff --git a/src/model/utils.rs b/src/model/utils.rs
index e793df2..9fed660 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -156,7 +156,8 @@ pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Re
 
     let guild_id = match channel {
         Channel::Guild(channel) => channel.read().unwrap().guild_id,
-        Channel::Group(_) | Channel::Private(_) => {
+        Channel::Group(_) |
+        Channel::Private(_) => {
             // Both users in DMs, and all users in groups, will have the same
             // permissions.
             //
@@ -175,10 +176,10 @@ pub fn user_has_perms(channel_id: ChannelId, mut permissions: Permissions) -> Re
         None => return Err(Error::Model(ModelError::ItemMissing)),
     };
 
-    let perms = guild
-        .read()
-        .unwrap()
-        .permissions_for(channel_id, current_user.id);
+    let perms = guild.read().unwrap().permissions_for(
+        channel_id,
+        current_user.id,
+    );
 
     permissions.remove(perms);
 
diff --git a/src/model/webhook.rs b/src/model/webhook.rs
index 5e10d90..39099e0 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -118,7 +118,10 @@ impl Webhook {
         }
 
         if let Some(name) = name {
-            map.insert("name".to_owned(), Value::String(name.to_owned()));
+            map.insert(
+                "name".to_owned(),
+                Value::String(name.to_owned()),
+            );
         }
 
         match http::edit_webhook_with_token(self.id.0, &self.token, &map) {
diff --git a/src/utils/colour.rs b/src/utils/colour.rs
index cea6f45..77e4cdf 100644
--- a/src/utils/colour.rs
+++ b/src/utils/colour.rs
@@ -229,7 +229,7 @@ impl From<u64> for Colour {
 
 impl From<(u8, u8, u8)> for Colour {
     /// Constructs a Colour from rgb.
-    fn from((r, g,b): (u8, u8, u8)) -> Self { Colour::from_rgb(r, g, b) }
+    fn from((r, g, b): (u8, u8, u8)) -> Self { Colour::from_rgb(r, g, b) }
 }
 
 colour! {
diff --git a/src/utils/message_builder.rs b/src/utils/message_builder.rs
index d1fd2f5..8f13db2 100644
--- a/src/utils/message_builder.rs
+++ b/src/utils/message_builder.rs
@@ -463,7 +463,7 @@ impl MessageBuilder {
     pub fn push_safe<C: I>(mut self, content: C) -> Self {
         {
             let mut c = content.into();
-            c.inner  = normalize(&c.inner)
+            c.inner = normalize(&c.inner)
                 .replace('*', "\\*")
                 .replace('`', "\\`")
                 .replace('_', "\\_");
@@ -484,7 +484,7 @@ impl MessageBuilder {
 
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace("```", " "); 
+            c.inner = normalize(&c.inner).replace("```", " ");
             self.0.push_str(&c.to_string());
         }
         self.0.push_str("```");
@@ -497,7 +497,7 @@ impl MessageBuilder {
         self.0.push('`');
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace('`', "'"); 
+            c.inner = normalize(&c.inner).replace('`', "'");
             self.0.push_str(&c.to_string());
         }
         self.0.push('`');
@@ -510,7 +510,7 @@ impl MessageBuilder {
         self.0.push('_');
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace('_', " "); 
+            c.inner = normalize(&c.inner).replace('_', " ");
             self.0.push_str(&c.to_string());
         }
         self.0.push('_');
@@ -523,7 +523,7 @@ impl MessageBuilder {
         self.0.push_str("**");
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace("**", " "); 
+            c.inner = normalize(&c.inner).replace("**", " ");
             self.0.push_str(&c.to_string());
         }
         self.0.push_str("**");
@@ -536,7 +536,7 @@ impl MessageBuilder {
         self.0.push_str("__");
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace("__", " "); 
+            c.inner = normalize(&c.inner).replace("__", " ");
             self.0.push_str(&c.to_string());
         }
         self.0.push_str("__");
@@ -549,7 +549,7 @@ impl MessageBuilder {
         self.0.push_str("~~");
         {
             let mut c = content.into();
-            c.inner = normalize(&c.inner).replace("~~", " "); 
+            c.inner = normalize(&c.inner).replace("~~", " ");
             self.0.push_str(&c.to_string());
         }
         self.0.push_str("~~");
@@ -906,14 +906,15 @@ impl From<ContentModifier> for Content {
     fn from(cm: ContentModifier) -> Content { cm.to_content() }
 }
 
-/// This trait only exists as way to bypass the shouting of the compiler. Specifically "conflicting implementations in core" and alike.
+/// This trait only exists as way to bypass the shouting of the compiler. Specifically "conflicting
+/// implementations in core" and alike.
 /// However is not meant to be used outside, nor implemented.
 pub trait I {
     fn into(self) -> Content;
 }
 
 impl<T: fmt::Display> I for T {
-     fn into(self) -> Content {
+    fn into(self) -> Content {
         Content {
             italic: false,
             bold: false,
@@ -926,15 +927,11 @@ impl<T: fmt::Display> I for T {
 }
 
 impl I for ContentModifier {
-    fn into(self) -> Content {
-        self.to_content()
-    }
+    fn into(self) -> Content { self.to_content() }
 }
 
 impl I for Content {
-    fn into(self) -> Content {
-        self
-    }
+    fn into(self) -> Content { self }
 }
 
 fn normalize(text: &str) -> String {
diff --git a/src/voice/connection.rs b/src/voice/connection.rs
index 7cc8b3a..2d1e8f5 100644
--- a/src/voice/connection.rs
+++ b/src/voice/connection.rs
@@ -1,11 +1,6 @@
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt, WriteBytesExt};
-use opus::{
-    packet as opus_packet,
-    Application as CodingMode,
-    Channels,
-    Decoder as OpusDecoder,
-    Encoder as OpusEncoder,
-};
+use opus::{Application as CodingMode, Channels, Decoder as OpusDecoder, Encoder as OpusEncoder,
+           packet as opus_packet};
 use sodiumoxide::crypto::secretbox::{self, Key, Nonce};
 use std::collections::HashMap;
 use std::io::Write;
@@ -16,7 +11,7 @@ use std::thread::{self, Builder as ThreadBuilder, JoinHandle};
 use std::time::Duration;
 use super::audio::{AudioReceiver, AudioSource, HEADER_LEN, SAMPLE_RATE};
 use super::connection_info::ConnectionInfo;
-use super::{payload, VoiceError, CRYPTO_MODE};
+use super::{CRYPTO_MODE, VoiceError, payload};
 use websocket::client::Url as WebsocketUrl;
 use websocket::sync::client::ClientBuilder;
 use websocket::sync::stream::{AsTcpStream, TcpStream, TlsStream};
@@ -115,27 +110,27 @@ impl Connection {
 
             // Find the position in the bytes that contains the first byte of 0,
             // indicating the "end of the address".
-            let index = bytes
-                .iter()
-                .skip(4)
-                .position(|&x| x == 0)
-                .ok_or(Error::Voice(VoiceError::FindingByte))?;
+            let index = bytes.iter().skip(4).position(|&x| x == 0).ok_or(
+                Error::Voice(
+                    VoiceError::FindingByte,
+                ),
+            )?;
 
             let pos = 4 + index;
             let addr = String::from_utf8_lossy(&bytes[4..pos]);
             let port_pos = len - 2;
             let port = (&bytes[port_pos..]).read_u16::<LittleEndian>()?;
 
-            client
-                .send_json(&payload::build_select_protocol(addr, port))?;
+            client.send_json(
+                &payload::build_select_protocol(addr, port),
+            )?;
         }
 
         let key = encryption_key(&mut client)?;
 
-        let _ = client
-            .stream_ref()
-            .as_tcp()
-            .set_read_timeout(Some(Duration::from_millis(25)));
+        let _ = client.stream_ref().as_tcp().set_read_timeout(
+            Some(Duration::from_millis(25)),
+        );
 
         let mutexed_client = Arc::new(Mutex::new(client));
         let thread_items = start_threads(mutexed_client.clone(), &udp)?;
@@ -183,17 +178,21 @@ impl Connection {
                         let timestamp = handle.read_u32::<BigEndian>()?;
                         let ssrc = handle.read_u32::<BigEndian>()?;
 
-                        nonce.0[..HEADER_LEN]
-                            .clone_from_slice(&packet[..HEADER_LEN]);
+                        nonce.0[..HEADER_LEN].clone_from_slice(
+                            &packet[..HEADER_LEN],
+                        );
 
-                        if let Ok(decrypted) =
-                            secretbox::open(&packet[HEADER_LEN..], &nonce, &self.key) {
+                        if let Ok(decrypted) = secretbox::open(
+                            &packet[HEADER_LEN..],
+                            &nonce,
+                            &self.key,
+                        ) {
                             let channels = opus_packet::get_nb_channels(&decrypted)?;
 
                             let entry =
-                                self.decoder_map.entry((ssrc, channels)).or_insert_with(
-                                    || OpusDecoder::new(SAMPLE_RATE, channels).unwrap(),
-                                );
+                                self.decoder_map.entry((ssrc, channels)).or_insert_with(|| {
+                                    OpusDecoder::new(SAMPLE_RATE, channels).unwrap()
+                                });
 
                             let len = entry.decode(&decrypted, &mut buffer, false)?;
 
@@ -201,8 +200,13 @@ impl Connection {
 
                             let b = if is_stereo { len * 2 } else { len };
 
-                            receiver
-                                .voice_packet(ssrc, seq, timestamp, is_stereo, &buffer[..b]);
+                            receiver.voice_packet(
+                                ssrc,
+                                seq,
+                                timestamp,
+                                is_stereo,
+                                &buffer[..b],
+                            );
                         }
                     },
                     ReceiverStatus::Websocket(VoiceEvent::Speaking(ev)) => {
@@ -223,10 +227,9 @@ impl Connection {
 
         // Send the voice websocket keepalive if it's time
         if self.keepalive_timer.check() {
-            self.client
-                .lock()
-                .unwrap()
-                .send_json(&payload::build_keepalive())?;
+            self.client.lock().unwrap().send_json(
+                &payload::build_keepalive(),
+            )?;
         }
 
         // Send UDP keepalive if it's time
@@ -284,14 +287,17 @@ impl Connection {
             cursor.write_u32::<BigEndian>(self.ssrc)?;
         }
 
-        nonce.0[..HEADER_LEN]
-            .clone_from_slice(&packet[..HEADER_LEN]);
+        nonce.0[..HEADER_LEN].clone_from_slice(
+            &packet[..HEADER_LEN],
+        );
 
         let sl_index = packet.len() - 16;
         let buffer_len = if self.encoder_stereo { 960 * 2 } else { 960 };
 
-        let len = self.encoder
-            .encode(&buffer[..buffer_len], &mut packet[HEADER_LEN..sl_index])?;
+        let len = self.encoder.encode(
+            &buffer[..buffer_len],
+            &mut packet[HEADER_LEN..sl_index],
+        )?;
         let crypted = {
             let slice = &packet[HEADER_LEN..HEADER_LEN + len];
             secretbox::seal(slice, &nonce, &self.key)
@@ -353,10 +359,11 @@ impl Connection {
 
         self.speaking = speaking;
 
-        self.client
-            .lock()
-            .unwrap()
-            .send_json(&payload::build_speaking(speaking))
+        self.client.lock().unwrap().send_json(
+            &payload::build_speaking(
+                speaking,
+            ),
+        )
     }
 }
 
@@ -376,8 +383,9 @@ fn generate_url(endpoint: &mut String) -> Result<WebsocketUrl> {
         endpoint.truncate(len - 3);
     }
 
-    WebsocketUrl::parse(&format!("wss://{}", endpoint))
-        .or(Err(Error::Voice(VoiceError::EndpointUrl)))
+    WebsocketUrl::parse(&format!("wss://{}", endpoint)).or(Err(
+        Error::Voice(VoiceError::EndpointUrl),
+    ))
 }
 
 #[inline]
@@ -389,8 +397,9 @@ fn encryption_key(client: &mut Client) -> Result<Key> {
                     return Err(Error::Voice(VoiceError::VoiceModeInvalid));
                 }
 
-                return Key::from_slice(&ready.secret_key)
-                    .ok_or(Error::Voice(VoiceError::KeyGen));
+                return Key::from_slice(&ready.secret_key).ok_or(Error::Voice(
+                    VoiceError::KeyGen,
+                ));
             },
             VoiceEvent::Unknown(op, value) => {
                 debug!(
diff --git a/src/voice/streamer.rs b/src/voice/streamer.rs
index c8400f0..3f40bae 100644
--- a/src/voice/streamer.rs
+++ b/src/voice/streamer.rs
@@ -101,9 +101,11 @@ pub fn ytdl(uri: &str) -> Result<Box<AudioSource>> {
     };
 
     let uri = match obj.remove("url") {
-        Some(v) => match v {
-            Value::String(uri) => uri,
-            other => return Err(Error::Voice(VoiceError::YouTubeDLUrl(other))),
+        Some(v) => {
+            match v {
+                Value::String(uri) => uri,
+                other => return Err(Error::Voice(VoiceError::YouTubeDLUrl(other))),
+            }
         },
         None => return Err(Error::Voice(VoiceError::YouTubeDLUrl(Value::Object(obj)))),
     };
@@ -129,9 +131,9 @@ fn is_stereo(path: &OsStr) -> Result<bool> {
         .ok_or(Error::Voice(VoiceError::Streams))?;
 
     let check = streams.iter().any(|stream| {
-        let channels = stream
-            .as_object()
-            .and_then(|m| m.get("channels").and_then(|v| v.as_i64()));
+        let channels = stream.as_object().and_then(|m| {
+            m.get("channels").and_then(|v| v.as_i64())
+        });
 
         channels == Some(2)
     });