Add ability to play DCA and Opus files. (#148)

56 files changed, 1111 insertions, 612 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 32cd781..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)
     }
@@ -74,7 +76,7 @@ impl CreateMessage {
     }
 
     /// Adds a list of reactions to create after the message's sent.
-pub fn reactions<R: Into<ReactionType>>(mut self, reactions: Vec<R>) -> Self{
+    pub fn reactions<R: Into<ReactionType>>(mut self, reactions: Vec<R>) -> Self {
         self.1 = Some(reactions.into_iter().map(|r| r.into()).collect());
 
         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 0fca747..6cfd13a 100644
--- a/src/builder/edit_guild.rs
+++ b/src/builder/edit_guild.rs
@@ -22,7 +22,7 @@ impl EditGuild {
     /// valid.
     ///
     /// [`afk_timeout`]: #method.afk_timeout
-pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self{
+    pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self {
         self.0.insert(
             "afk_channel_id".to_owned(),
             match channel {
@@ -79,7 +79,10 @@ pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self{
     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 @@ pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self{
     ///
     /// **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 @@ pub fn afk_channel<C: Into<ChannelId>>(mut self, channel: Option<C>) -> Self{
     ///
     /// [`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 9143640..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
     }
@@ -66,7 +68,7 @@ impl EditMember {
     /// Requires the [Move Members] permission.
     ///
     /// [Move Members]: ../model/permissions/constant.MOVE_MEMBERS.html
-pub fn voice_channel<C: Into<ChannelId>>(mut self, channel_id: C) -> Self{
+    pub fn voice_channel<C: Into<ChannelId>>(mut self, channel_id: C) -> Self {
         self.0.insert(
             "channel_id".to_owned(),
             Value::Number(Number::from(channel_id.into().0)),
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 8be3404..d034149 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(10_070_709)));
+        map.insert(
+            "color".to_owned(),
+            Value::Number(Number::from(10_070_709)),
+        );
         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 0b511b2..23fa314 100644
--- a/src/cache/cache_events_impl.rs
+++ b/src/cache/cache_events_impl.rs
@@ -85,8 +85,9 @@ impl CacheEventsImpl for super::Cache {
                 self.guilds
                     .get_mut(&guild_id)
                     .and_then(|guild| {
-                        guild
-                            .with_mut(|guild| guild.channels.insert(channel_id, channel.clone()))
+                        guild.with_mut(|guild| {
+                            guild.channels.insert(channel_id, channel.clone())
+                        })
                     })
                     .map(Channel::Guild)
             },
@@ -120,56 +121,59 @@ impl CacheEventsImpl for super::Cache {
             // 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 (guild_id, channel_id) = channel.with(|channel| (channel.guild_id, channel.id));
 
         self.channels.remove(&channel_id);
 
-        self.guilds
-            .get_mut(&guild_id)
-            .and_then(|guild| guild.with_mut(|g| g.channels.remove(&channel_id)));
+        self.guilds.get_mut(&guild_id).and_then(|guild| {
+            guild.with_mut(|g| g.channels.remove(&channel_id))
+        });
     }
 
     #[allow(dead_code)]
-fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent){
+    fn update_with_channel_pins_update(&mut self, event: &ChannelPinsUpdateEvent) {
         if let Some(channel) = self.channels.get(&event.channel_id) {
-            channel
-                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
+            channel.with_mut(|c| {
+                c.last_pin_timestamp = event.last_pin_timestamp;
+            });
 
             return;
         }
 
         if let Some(channel) = self.private_channels.get_mut(&event.channel_id) {
-            channel
-                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
+            channel.with_mut(|c| {
+                c.last_pin_timestamp = event.last_pin_timestamp;
+            });
 
             return;
         }
 
         if let Some(group) = self.groups.get_mut(&event.channel_id) {
-            group
-                .with_mut(|c| { c.last_pin_timestamp = event.last_pin_timestamp; });
+            group.with_mut(|c| {
+                c.last_pin_timestamp = event.last_pin_timestamp;
+            });
 
             return;
         }
     }
 
-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.with_mut(|g| g.recipients.remove(&event.user.id))
         });
@@ -205,8 +209,9 @@ fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemov
 
                 self.channels.insert(channel_id, channel.clone());
                 self.guilds.get_mut(&guild_id).map(|guild| {
-                    guild
-                        .with_mut(|g| g.channels.insert(channel_id, channel.clone()))
+                    guild.with_mut(
+                        |g| g.channels.insert(channel_id, channel.clone()),
+                    )
                 });
             },
             Channel::Private(ref channel) => {
@@ -230,8 +235,10 @@ fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemov
         }
 
         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>>> {
@@ -245,13 +252,13 @@ fn update_with_channel_recipient_remove(&mut self, event: &ChannelRecipientRemov
         })
     }
 
-fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent){
+    fn update_with_guild_emojis_update(&mut self, event: &GuildEmojisUpdateEvent) {
         self.guilds.get_mut(&event.guild_id).map(|guild| {
             guild.with_mut(|g| g.emojis.extend(event.emojis.clone()))
         });
     }
 
-fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
+    fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent) {
         let user_id = event.member.user.with(|u| u.id);
         self.update_user_entry(&event.member.user.read().unwrap());
 
@@ -268,7 +275,7 @@ fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
 
     fn update_with_guild_member_remove(&mut self,
                                        event: &GuildMemberRemoveEvent)
--> Option<Member>{
+                                       -> Option<Member> {
         self.guilds.get_mut(&event.guild_id).and_then(|guild| {
             guild.with_mut(|guild| {
                 guild.member_count -= 1;
@@ -279,7 +286,7 @@ fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
 
     fn update_with_guild_member_update(&mut self,
                                        event: &GuildMemberUpdateEvent)
--> Option<Member>{
+                                       -> Option<Member> {
         self.update_user_entry(&event.user);
 
         if let Some(guild) = self.guilds.get_mut(&event.guild_id) {
@@ -322,7 +329,7 @@ fn update_with_guild_member_add(&mut self, event: &mut GuildMemberAddEvent){
         }
     }
 
-fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent){
+    fn update_with_guild_members_chunk(&mut self, event: &GuildMembersChunkEvent) {
         for member in event.members.values() {
             self.update_user_entry(&member.user.read().unwrap());
         }
@@ -332,33 +339,32 @@ 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_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.with_mut(|g| g.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.with_mut(|g| g.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.with_mut(|g| {
-                g.roles
-                    .get_mut(&event.role.id)
-                    .map(|role| mem::replace(role, event.role.clone()))
+                g.roles.get_mut(&event.role.id).map(|role| {
+                    mem::replace(role, event.role.clone())
+                })
             })
         })
     }
 
-fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent){
+    fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent) {
         self.unavailable_guilds.insert(event.guild_id);
         self.guilds.remove(&event.guild_id);
     }
@@ -378,7 +384,7 @@ fn update_with_guild_unavailable(&mut self, event: &GuildUnavailableEvent){
         });
     }
 
-fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent){
+    fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent) {
         self.presences.extend({
             let mut p: HashMap<UserId, Presence> = HashMap::default();
 
@@ -406,16 +412,19 @@ fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent){
                 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(),
+            );
         }
     }
 
@@ -456,7 +465,7 @@ fn update_with_presences_replace(&mut self, event: &PresencesReplaceEvent){
         mem::replace(&mut self.user, event.current_user.clone())
     }
 
-fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent){
+    fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent) {
         if let Some(guild_id) = event.guild_id {
             if let Some(guild) = self.guilds.get_mut(&guild_id) {
                 let mut guild = guild.write().unwrap();
@@ -473,9 +482,10 @@ fn update_with_voice_state_update(&mut self, event: &VoiceStateUpdateEvent){
                         }
                     }
 
-                    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);
diff --git a/src/cache/mod.rs b/src/cache/mod.rs
index 4aa587f..b92e72f 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -517,7 +517,7 @@ impl Cache {
     #[inline]
     pub fn private_channel<C: Into<ChannelId>>(&self,
                                                channel_id: C)
--> Option<Arc<RwLock<PrivateChannel>>>{
+                                               -> Option<Arc<RwLock<PrivateChannel>>> {
         self.private_channels.get(&channel_id.into()).cloned()
     }
 
@@ -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/context.rs b/src/client/context.rs
index e8595cd..d0600b6 100644
--- a/src/client/context.rs
+++ b/src/client/context.rs
@@ -75,7 +75,7 @@ impl Context {
     /// let mut client = Client::new("token", Handler); client.start().unwrap();
     /// ```
     #[cfg(feature = "builder")]
-pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser>{
+    pub fn edit_profile<F: FnOnce(EditProfile) -> EditProfile>(&self, f: F) -> Result<CurrentUser> {
         let mut map = Map::new();
 
         feature_cache! {{
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index cb45428..461fe8c 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -62,7 +62,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            framework: &Arc<sync::Mutex<Option<Box<Framework>>>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-tokio_handle: &Handle){
+                                           tokio_handle: &Handle) {
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -92,7 +92,7 @@ pub fn dispatch<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-tokio_handle: &Handle){
+                                           tokio_handle: &Handle) {
     match event {
         Event::MessageCreate(event) => {
             let context = context(conn, data);
@@ -106,7 +106,7 @@ tokio_handle: &Handle){
 fn dispatch_message<H: EventHandler + 'static>(context: Context,
                                                mut message: Message,
                                                event_handler: &Arc<H>,
-tokio_handle: &Handle){
+                                               tokio_handle: &Handle) {
     let h = event_handler.clone();
     tokio_handle.spawn_fn(move || {
         #[cfg(feature = "model")]
@@ -125,7 +125,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
                                            conn: &Arc<Mutex<Shard>>,
                                            data: &Arc<Mutex<ShareMap>>,
                                            event_handler: &Arc<H>,
-tokio_handle: &Handle){
+                                           tokio_handle: &Handle) {
     #[cfg(feature="cache")]
     let mut last_guild_create_time = now!();
 
@@ -172,7 +172,8 @@ tokio_handle: &Handle){
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 @@ tokio_handle: &Handle){
 
             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 47ff96c..5821597 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -37,7 +37,7 @@ pub use CACHE;
 
 use self::dispatch::dispatch;
 use std::sync::{self, Arc};
-use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
+use std::sync::atomic::{ATOMIC_BOOL_INIT, AtomicBool, Ordering};
 use parking_lot::Mutex;
 use tokio_core::reactor::Core;
 use futures;
@@ -194,7 +194,8 @@ pub struct Client<H: EventHandler + 'static> {
     /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
     /// [`on_ready`]: #method.on_ready
     event_handler: Arc<H>,
-    #[cfg(feature = "framework")] framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
+    #[cfg(feature = "framework")]
+    framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
     token: Arc<sync::Mutex<String>>,
 }
 
@@ -354,7 +355,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`on_message`]: #method.on_message
     /// [framework docs]: ../framework/index.html
     #[cfg(feature = "framework")]
-pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
+    pub fn with_framework<F: Framework + 'static>(&mut self, f: F) {
         self.framework = Arc::new(sync::Mutex::new(Some(Box::new(f))));
     }
 
@@ -539,7 +540,10 @@ pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
     /// [`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.
@@ -664,7 +668,10 @@ pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
     /// [`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.
@@ -722,7 +729,8 @@ pub fn with_framework<F: Framework + 'static>(&mut self, f: F){
                 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(),
@@ -838,7 +846,7 @@ fn boot_shard(info: &BootInfo) -> Result<Shard> {
     Err(Error::Client(ClientError::ShardBootFailure))
 }
 
-fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>){
+fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>) {
     handle_shard(&mut info);
 
     let mut handle_still = HANDLE_STILL.load(Ordering::Relaxed);
@@ -892,7 +900,7 @@ fn monitor_shard<H: EventHandler + 'static>(mut info: MonitorInfo<H>){
     }
 }
 
-fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>){
+fn handle_shard<H: EventHandler + 'static>(info: &mut MonitorInfo<H>) {
     let mut core = Core::new().unwrap();
     let handle = core.handle();
 
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/standard/buckets.rs b/src/framework/standard/buckets.rs
index 4719b85..f2c4486 100644
--- a/src/framework/standard/buckets.rs
+++ b/src/framework/standard/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/standard/command.rs b/src/framework/standard/command.rs
index 8c23ca0..22a82ce 100644
--- a/src/framework/standard/command.rs
+++ b/src/framework/standard/command.rs
@@ -6,7 +6,10 @@ use std::collections::HashMap;
 
 pub type Check = Fn(&mut Context, &Message, &mut Args, &Arc<Command>) -> bool + 'static;
 pub type Exec = Fn(&mut Context, &Message, Args) -> Result<(), String> + 'static;
-pub type Help = Fn(&mut Context, &Message, HashMap<String, Arc<CommandGroup>>, Args)
+pub type Help = Fn(&mut Context,
+                   &Message,
+                   HashMap<String, Arc<CommandGroup>>,
+                   Args)
                    -> Result<(), String>
                     + 'static;
 pub type BeforeHook = Fn(&mut Context, &Message, &str) -> bool + 'static;
diff --git a/src/framework/standard/configuration.rs b/src/framework/standard/configuration.rs
index dd1c7e7..491bbc4 100644
--- a/src/framework/standard/configuration.rs
+++ b/src/framework/standard/configuration.rs
@@ -33,19 +33,32 @@ use model::{GuildId, Message, UserId};
 /// [`Client`]: ../../client/struct.Client.html
 /// [`Framework`]: struct.Framework.html
 pub struct Configuration {
-    #[doc(hidden)] pub allow_dm: bool,
-    #[doc(hidden)] pub allow_whitespace: bool,
-    #[doc(hidden)] pub blocked_guilds: HashSet<GuildId>,
-    #[doc(hidden)] pub blocked_users: HashSet<UserId>,
-    #[doc(hidden)] pub depth: usize,
-    #[doc(hidden)] pub disabled_commands: HashSet<String>,
-    #[doc(hidden)] pub dynamic_prefix: Option<Box<PrefixCheck>>,
-    #[doc(hidden)] pub ignore_bots: bool,
-    #[doc(hidden)] pub ignore_webhooks: bool,
-    #[doc(hidden)] pub on_mention: Option<Vec<String>>,
-    #[doc(hidden)] pub owners: HashSet<UserId>,
-    #[doc(hidden)] pub prefixes: Vec<String>,
-    #[doc(hidden)] pub delimiters: Vec<String>,
+    #[doc(hidden)]
+    pub allow_dm: bool,
+    #[doc(hidden)]
+    pub allow_whitespace: bool,
+    #[doc(hidden)]
+    pub blocked_guilds: HashSet<GuildId>,
+    #[doc(hidden)]
+    pub blocked_users: HashSet<UserId>,
+    #[doc(hidden)]
+    pub depth: usize,
+    #[doc(hidden)]
+    pub disabled_commands: HashSet<String>,
+    #[doc(hidden)]
+    pub dynamic_prefix: Option<Box<PrefixCheck>>,
+    #[doc(hidden)]
+    pub ignore_bots: bool,
+    #[doc(hidden)]
+    pub ignore_webhooks: bool,
+    #[doc(hidden)]
+    pub on_mention: Option<Vec<String>>,
+    #[doc(hidden)]
+    pub owners: HashSet<UserId>,
+    #[doc(hidden)]
+    pub prefixes: Vec<String>,
+    #[doc(hidden)]
+    pub delimiters: Vec<String>,
 }
 
 impl Configuration {
@@ -256,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 */,
             ]);
         }
 
@@ -402,8 +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/standard/create_command.rs b/src/framework/standard/create_command.rs
index 97bf092..0a467e1 100644
--- a/src/framework/standard/create_command.rs
+++ b/src/framework/standard/create_command.rs
@@ -11,9 +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
     }
@@ -115,7 +115,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>>, Args)
+        where F: Fn(&mut Context,
+                    &Message,
+                    HashMap<String, Arc<CommandGroup>>,
+                    Args)
                     -> Result<(), String>
                      + 'static {
         self.0.exec = CommandType::WithCommands(Box::new(f));
diff --git a/src/framework/standard/create_group.rs b/src/framework/standard/create_group.rs
index d533c6a..013ba67 100644
--- a/src/framework/standard/create_group.rs
+++ b/src/framework/standard/create_group.rs
@@ -35,7 +35,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(
@@ -59,9 +61,10 @@ impl CreateGroup {
         where F: Fn(&mut Context, &Message, Args) -> Result<(), String> + Send + Sync + '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/standard/help_commands.rs b/src/framework/standard/help_commands.rs
index 75c5b0b..f081e1a 100644
--- a/src/framework/standard/help_commands.rs
+++ b/src/framework/standard/help_commands.rs
@@ -116,15 +116,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
+                                ))
                             });
                         }
 
@@ -293,8 +297,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/standard/mod.rs b/src/framework/standard/mod.rs
index c67e128..04ebc5f 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -402,9 +402,9 @@ impl StandardFramework {
             }
 
             if let Some(guild) = guild_id.find() {
-                return self.configuration
-                    .blocked_users
-                    .contains(&guild.with(|g| g.owner_id));
+                return self.configuration.blocked_users.contains(
+                    &guild.with(|g| g.owner_id),
+                );
             }
         }
 
@@ -415,8 +415,9 @@ impl StandardFramework {
     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
-                    .with(|g| g.permissions_for(message.channel_id, message.author.id));
+                let perms = guild.with(|g| {
+                    g.permissions_for(message.channel_id, message.author.id)
+                });
 
                 return perms.contains(command.required_permissions);
             }
@@ -446,7 +447,8 @@ impl StandardFramework {
                     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 {
@@ -457,8 +459,10 @@ impl StandardFramework {
                                 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));
+                            }
                         },
                     }
                 }
@@ -508,19 +512,18 @@ impl StandardFramework {
 
             if command.owners_only {
                 Some(DispatchError::OnlyForOwners)
-            } 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()))
             } else if self.configuration.disabled_commands.contains(built) {
                 Some(DispatchError::CommandDisabled(built.to_owned()))
             } else {
-                let all_passed = command
-                    .checks
-                    .iter()
-                    .all(|check| check(&mut context, message, args, command));
+                let all_passed = command.checks.iter().all(|check| {
+                    check(&mut context, message, args, command)
+                });
 
                 if all_passed {
                     None
@@ -574,16 +577,21 @@ impl StandardFramework {
     pub fn on<F, S>(mut self, command_name: S, f: F) -> Self
         where F: Fn(&mut Context, &Message, Args) -> 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)),
+                    ),
+                );
             }
         }
 
@@ -606,9 +614,11 @@ impl StandardFramework {
     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;
@@ -623,15 +633,17 @@ impl StandardFramework {
                     }
                 } 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)),
+                );
             }
         }
 
@@ -844,7 +856,8 @@ impl Framework for StandardFramework {
                 for group in groups.values() {
                     let command_length = built.len();
 
-                    if let Some(&CommandOrAlias::Alias(ref points_to)) = group.commands.get(&built) {
+                    if let Some(&CommandOrAlias::Alias(ref points_to)) =
+                        group.commands.get(&built) {
                         built = points_to.to_owned();
                     }
 
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index 7663cee..6f6a949 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};
@@ -95,7 +95,8 @@ pub struct Shard {
     /// update the voice connections' states.
     #[cfg(feature = "voice")]
     pub manager: VoiceManager,
-    #[cfg(feature = "voice")] manager_rx: MpscReceiver<Value>,
+    #[cfg(feature = "voice")]
+    manager_rx: MpscReceiver<Value>,
 }
 
 impl Shard {
@@ -136,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()?;
@@ -469,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;
@@ -739,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);
diff --git a/src/http/mod.rs b/src/http/mod.rs
index 91a5e96..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)?;
@@ -1811,7 +1836,8 @@ pub fn unpin_message(channel_id: u64, message_id: u64) -> Result<()> {
 fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
     where F: Fn() -> RequestBuilder<'a> {
     let response = ratelimiting::perform(route, || {
-        f().header(header::Authorization(TOKEN.lock().unwrap().clone()))
+        f()
+            .header(header::Authorization(TOKEN.lock().unwrap().clone()))
             .header(header::ContentType::json())
     })?;
 
@@ -1825,7 +1851,8 @@ fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
 pub(crate) fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
     where F: Fn() -> RequestBuilder<'a> {
     let req = || {
-        f().header(header::UserAgent(constants::USER_AGENT.to_owned()))
+        f()
+            .header(header::UserAgent(constants::USER_AGENT.to_owned()))
             .send()
     };
 
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index 52762f5..039f15d 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::*;
 
@@ -399,16 +399,15 @@ pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
             let redo = if response.headers.get_raw("x-ratelimit-global").is_some() {
                 let _ = GLOBAL.lock().expect("global route lock poisoned");
 
-                Ok(
-                    if let Some(retry_after) = parse_header(&response.headers, "retry-after")? {
-                        debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
-                        thread::sleep(Duration::from_millis(retry_after as u64));
+                Ok(if let Some(retry_after) =
+                    parse_header(&response.headers, "retry-after")? {
+                    debug!("Ratelimited on route {:?} for {:?}ms", route, retry_after);
+                    thread::sleep(Duration::from_millis(retry_after as u64));
 
-                        true
-                    } else {
-                        false
-                    },
-                )
+                    true
+                } else {
+                    false
+                })
             } else {
                 lock.post_hook(&response, &route)
             };
@@ -506,12 +505,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 70c4cb7..cd9161a 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -7,8 +7,7 @@ use gateway::GatewayError;
 use internal::prelude::*;
 
 pub trait ReceiverExt {
-    fn recv_json<F, T>(&mut self, decode: F) -> Result<T>
-        where F: Fn(Value) -> Result<T>;
+    fn recv_json<F, T>(&mut self, decode: F) -> Result<T> where F: Fn(Value) -> Result<T>;
 }
 
 pub trait SenderExt {
@@ -43,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 cf9e41c..122b5bc 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -100,7 +100,7 @@ impl ChannelId {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
+    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
         http::delete_message(self.0, message_id.into().0)
     }
 
@@ -187,7 +187,7 @@ pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
     /// [`Channel`]: enum.Channel.html
     /// [Manage Channel]: permissions/constant.MANAGE_CHANNELS.html
     #[inline]
-pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel>{
+    pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildChannel> {
         http::edit_channel(self.0, &f(EditChannel::default()).0)
     }
 
@@ -256,12 +256,13 @@ pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildC
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
-        http::get_message(self.0, message_id.into().0)
-            .map(|mut msg| {
+        http::get_message(self.0, message_id.into().0).map(
+            |mut msg| {
                 msg.transform_content();
 
                 msg
-            })
+            },
+        )
     }
 
     /// Gets messages from the channel.
@@ -306,9 +307,11 @@ pub fn edit<F: FnOnce(EditChannel) -> EditChannel>(&self, f: F) -> Result<GuildC
                   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 94483ec..ad20fcd 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -124,8 +124,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.
@@ -243,8 +246,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
@@ -309,7 +316,7 @@ impl Group {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
     #[inline]
-pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
+    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
         self.channel_id.send_message(f)
     }
 
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index 620ba93..d4e93f0 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -310,7 +310,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)),
@@ -539,8 +542,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.
@@ -599,7 +606,7 @@ impl GuildChannel {
     /// [`ModelError::MessageTooLong`]: enum.ModelError.html#variant.MessageTooLong
     /// [`Message`]: struct.Message.html
     /// [Send Messages]: permissions/constant.SEND_MESSAGES.html
-pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
+    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
         #[cfg(feature = "cache")]
         {
             let req = permissions::SEND_MESSAGES;
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 399d351..27f4e31 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -291,9 +291,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
@@ -319,8 +320,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.
@@ -333,8 +338,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
@@ -354,7 +360,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,
         }
     }
@@ -371,11 +378,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 0911139..ddaa183 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -100,7 +100,7 @@ impl Channel {
     /// [`Message::delete`]: struct.Message.html#method.delete
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     #[inline]
-pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
+    pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()> {
         self.id().delete_message(message_id)
     }
 
@@ -118,8 +118,11 @@ pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
                                  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.
@@ -157,7 +160,8 @@ pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
     pub fn is_nsfw(&self) -> bool {
         match *self {
             Channel::Guild(ref channel) => channel.with(|c| c.is_nsfw()),
-            Channel::Group(_) | Channel::Private(_) => false,
+            Channel::Group(_) |
+            Channel::Private(_) => false,
         }
     }
 
@@ -217,8 +221,12 @@ pub fn delete_message<M: Into<MessageId>>(&self, message_id: M) -> Result<()>{
                                    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
@@ -319,15 +327,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")),
         }
     }
@@ -399,8 +413,10 @@ impl ChannelType {
 struct PermissionOverwriteData {
     allow: Permissions,
     deny: Permissions,
-    #[serde(deserialize_with = "deserialize_u64")] id: u64,
-    #[serde(rename = "type")] kind: String,
+    #[serde(deserialize_with = "deserialize_u64")]
+    id: u64,
+    #[serde(rename = "type")]
+    kind: String,
 }
 
 /// A channel-specific permission overwrite for a member or role.
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index e5e14d9..d9abbb2 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -192,8 +192,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.
@@ -259,7 +263,7 @@ impl PrivateChannel {
     /// [`CreateMessage`]: ../builder/struct.CreateMessage.html
     /// [`Message`]: struct.Message.html
     #[inline]
-pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
+    pub fn send_message<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
         self.id.send_message(f)
     }
 
diff --git a/src/model/event.rs b/src/model/event.rs
index 7881864..22cf649 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -126,7 +126,8 @@ impl<'de> Deserialize<'de> for GuildDeleteEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct GuildEmojisUpdateEvent {
-    #[serde(deserialize_with = "deserialize_emojis")] pub emojis: HashMap<EmojiId, Emoji>,
+    #[serde(deserialize_with = "deserialize_emojis")]
+    pub emojis: HashMap<EmojiId, Emoji>,
     pub guild_id: GuildId,
 }
 
@@ -152,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,
+            )?,
         })
     }
 }
@@ -187,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));
@@ -230,7 +233,8 @@ pub struct GuildRoleUpdateEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct GuildUnavailableEvent {
-    #[serde(rename = "id")] pub guild_id: GuildId,
+    #[serde(rename = "id")]
+    pub guild_id: GuildId,
 }
 
 #[derive(Clone, Debug)]
@@ -268,7 +272,8 @@ pub struct MessageDeleteBulkEvent {
 #[derive(Clone, Copy, Debug, Deserialize)]
 pub struct MessageDeleteEvent {
     pub channel_id: ChannelId,
-    #[serde(rename = "id")] pub message_id: MessageId,
+    #[serde(rename = "id")]
+    pub message_id: MessageId,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -302,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,
@@ -385,7 +397,8 @@ impl<'de> Deserialize<'de> for ReadyEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct ResumedEvent {
-    #[serde(rename = "_trace")] pub trace: Vec<Option<String>>,
+    #[serde(rename = "_trace")]
+    pub trace: Vec<Option<String>>,
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -438,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,
+            )?,
         })
     }
 }
@@ -787,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 4edf0b8..1b3a40b 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -106,8 +106,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,
@@ -173,8 +174,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 {
@@ -188,8 +190,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") {
@@ -197,8 +202,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")
@@ -221,13 +229,15 @@ impl<'de> Deserialize<'de> for Presence {
 #[derive(Clone, Debug, Deserialize)]
 pub struct Ready {
     pub guilds: Vec<GuildStatus>,
-    #[serde(deserialize_with = "deserialize_presences")] pub presences: HashMap<UserId, Presence>,
+    #[serde(deserialize_with = "deserialize_presences")]
+    pub presences: HashMap<UserId, Presence>,
     #[serde(deserialize_with = "deserialize_private_channels")]
-    pub private_channels:
-        HashMap<ChannelId, Channel>,
+    pub private_channels: HashMap<ChannelId, Channel>,
     pub session_id: String,
     pub shard: Option<[u64; 2]>,
-    #[serde(default, rename = "_trace")] pub trace: Vec<String>,
+    #[serde(default, rename = "_trace")]
+    pub trace: Vec<String>,
     pub user: CurrentUser,
-    #[serde(rename = "v")] pub version: u64,
+    #[serde(rename = "v")]
+    pub version: u64,
 }
diff --git a/src/model/guild/audit_log.rs b/src/model/guild/audit_log.rs
index 6c24662..962b145 100644
--- a/src/model/guild/audit_log.rs
+++ b/src/model/guild/audit_log.rs
@@ -91,9 +91,12 @@ pub enum ActionEmoji {
 
 #[derive(Debug, Deserialize)]
 pub struct Change {
-    #[serde(rename = "key")] pub name: String,
-    #[serde(rename = "old_value")] pub old: String,
-    #[serde(rename = "new_value")] pub new: String,
+    #[serde(rename = "key")]
+    pub name: String,
+    #[serde(rename = "old_value")]
+    pub old: String,
+    #[serde(rename = "new_value")]
+    pub new: String,
 }
 
 #[derive(Debug)]
@@ -123,7 +126,7 @@ pub struct AuditLogEntry {
     pub id: AuditLogEntryId,
 }
 
-fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Error>{
+fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Error> {
     struct TargetVisitor;
 
     impl<'de> Visitor<'de> for TargetVisitor {
@@ -144,7 +147,7 @@ fn deserialize_target<'de, D: Deserializer<'de>>(de: D) -> Result<Target, D::Err
     de.deserialize_i32(TargetVisitor)
 }
 
-fn deserialize_action<'de, D: Deserializer<'de>>(de: D) -> Result<Action, D::Error>{
+fn deserialize_action<'de, D: Deserializer<'de>>(de: D) -> Result<Action, D::Error> {
     struct ActionVisitor;
 
     impl<'de> Visitor<'de> for ActionVisitor {
@@ -177,7 +180,8 @@ impl<'de> Deserialize<'de> for AuditLogs {
         #[derive(Deserialize)]
         #[serde(field_identifier)]
         enum Field {
-            #[serde(rename = "audit_log_entries")] Entries,
+            #[serde(rename = "audit_log_entries")]
+            Entries,
         }
 
         struct EntriesVisitor;
diff --git a/src/model/guild/guild_id.rs b/src/model/guild/guild_id.rs
index 02775ba..4d6ba9b 100644
--- a/src/model/guild/guild_id.rs
+++ b/src/model/guild/guild_id.rs
@@ -48,7 +48,7 @@ impl GuildId {
     /// [`Guild::ban`]: struct.Guild.html#method.ban
     /// [`User`]: struct.User.html
     /// [Ban Members]: permissions/constant.BAN_MEMBERS.html
-pub fn ban<U: Into<UserId>, BO: BanOptions>(&self, user: U, ban_options: BO) -> Result<()>{
+    pub fn ban<U: Into<UserId>, BO: BanOptions>(&self, user: U, ban_options: BO) -> Result<()> {
         let dmd = ban_options.dmd();
         if dmd > 7 {
             return Err(Error::Model(ModelError::DeleteMessageDaysAmount(dmd)));
@@ -167,7 +167,7 @@ pub fn ban<U: Into<UserId>, BO: BanOptions>(&self, user: U, ban_options: BO) ->
     /// [`Guild::create_role`]: struct.Guild.html#method.create_role
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
-pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>{
+    pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
         http::create_role(self.0, &f(EditRole::default()).0)
     }
 
@@ -199,7 +199,7 @@ pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         http::delete_guild_integration(self.0, integration_id.into().0)
     }
 
@@ -228,7 +228,7 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
     /// [`Guild::edit`]: struct.Guild.html#method.edit
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild>{
+    pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<PartialGuild> {
         http::edit_guild(self.0, &f(EditGuild::default()).0)
     }
 
@@ -459,7 +459,7 @@ pub fn edit<F: FnOnce(EditGuild) -> EditGuild>(&mut self, f: F) -> Result<Partia
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         http::start_integration_sync(self.0, integration_id.into().0)
     }
 
diff --git a/src/model/guild/integration.rs b/src/model/guild/integration.rs
index b903a2c..18da39d 100644
--- a/src/model/guild/integration.rs
+++ b/src/model/guild/integration.rs
@@ -6,7 +6,8 @@ pub struct Integration {
     pub id: IntegrationId,
     pub account: IntegrationAccount,
     pub enabled: bool,
-    #[serde(rename = "expire_behaviour")] pub expire_behaviour: u64,
+    #[serde(rename = "expire_behaviour")]
+    pub expire_behaviour: u64,
     pub expire_grace_period: u64,
     pub kind: String,
     pub name: String,
diff --git a/src/model/guild/member.rs b/src/model/guild/member.rs
index 370f555..f1a5114 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.
@@ -204,7 +202,7 @@ impl Member {
     /// [`Guild::edit_member`]: ../model/struct.Guild.html#method.edit_member
     /// [`EditMember`]: ../builder/struct.EditMember.html
     #[cfg(feature = "cache")]
-pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()>{
+    pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()> {
         let map = f(EditMember::default()).0;
 
         http::edit_member(self.guild_id.0, self.user.read().unwrap().id.0, &map)
@@ -248,12 +246,11 @@ pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()>{
         {
             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 @@ pub fn edit<F: FnOnce(EditMember) -> EditMember>(&self, f: F) -> Result<()>{
 
         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 7fdd7d4..5ffbf4e 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -168,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())
@@ -442,7 +445,7 @@ impl Guild {
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         self.id.delete_integration(integration_id)
     }
 
@@ -626,9 +629,9 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
     /// 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.
@@ -706,8 +709,10 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
         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,
             }
@@ -831,8 +836,8 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
             // 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
@@ -958,9 +963,9 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
     /// 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.
@@ -969,7 +974,7 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         self.id.start_integration_sync(integration_id)
     }
 
@@ -1039,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)),
+                        );
                     }
                 }
             }
@@ -1056,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")
@@ -1217,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),
+        )
     }
 }
 
@@ -1239,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 1690167..799f6b6 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -16,14 +16,16 @@ pub struct PartialGuild {
     pub default_message_notifications: u64,
     pub embed_channel_id: Option<ChannelId>,
     pub embed_enabled: bool,
-    #[serde(deserialize_with = "deserialize_emojis")] pub emojis: HashMap<EmojiId, Emoji>,
+    #[serde(deserialize_with = "deserialize_emojis")]
+    pub emojis: HashMap<EmojiId, Emoji>,
     pub features: Vec<Feature>,
     pub icon: Option<String>,
     pub mfa_level: u64,
     pub name: String,
     pub owner_id: UserId,
     pub region: String,
-    #[serde(deserialize_with = "deserialize_roles")] pub roles: HashMap<RoleId, Role>,
+    #[serde(deserialize_with = "deserialize_roles")]
+    pub roles: HashMap<RoleId, Role>,
     pub splash: Option<String>,
     pub verification_level: VerificationLevel,
 }
@@ -150,7 +152,7 @@ impl PartialGuild {
     /// [`Guild::create_role`]: struct.Guild.html#method.create_role
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[inline]
-pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>{
+    pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
         self.id.create_role(f)
     }
 
@@ -178,7 +180,7 @@ pub fn create_role<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role>
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         self.id.delete_integration(integration_id)
     }
 
@@ -315,9 +317,9 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
     /// 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.
@@ -417,9 +419,9 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
 
     /// 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.
@@ -428,7 +430,7 @@ pub fn delete_integration<I: Into<IntegrationId>>(&self, integration_id: I) -> R
     ///
     /// [Manage Guild]: permissions/constant.MANAGE_GUILD.html
     #[inline]
-pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()>{
+    pub fn start_integration_sync<I: Into<IntegrationId>>(&self, integration_id: I) -> Result<()> {
         self.id.start_integration_sync(integration_id)
     }
 
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 5a6f75c..5956113 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -92,9 +92,10 @@ impl Role {
     /// [`Role`]: struct.Role.html
     /// [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))
+    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),
+        )
     }
 
     /// Searches the cache for the guild that owns the role.
diff --git a/src/model/invite.rs b/src/model/invite.rs
index c066128..f48ecbc 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -152,7 +152,8 @@ impl Invite {
 pub struct InviteChannel {
     pub id: ChannelId,
     pub name: String,
-    #[serde(rename = "type")] pub kind: ChannelType,
+    #[serde(rename = "type")]
+    pub kind: ChannelType,
 }
 
 /// A minimal amount of information about the guild an invite points to.
diff --git a/src/model/misc.rs b/src/model/misc.rs
index 3310e4a..dce8491 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -90,9 +90,11 @@ impl FromStr for User {
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_username(s) {
-            Some(x) => UserId(x as u64)
-                .get()
-                .map_err(|e| UserParseError::Rest(Box::new(e))),
+            Some(x) => {
+                UserId(x as u64).get().map_err(
+                    |e| UserParseError::Rest(Box::new(e)),
+                )
+            },
             _ => Err(UserParseError::InvalidUsername),
         }
     }
@@ -161,9 +163,11 @@ impl FromStr for Role {
 
     fn from_str(s: &str) -> StdResult<Self, Self::Err> {
         match utils::parse_role(s) {
-            Some(x) => match RoleId(x).find() {
-                Some(user) => Ok(user),
-                _ => Err(RoleParseError::NotPresentInCache),
+            Some(x) => {
+                match RoleId(x).find() {
+                    Some(user) => Ok(user),
+                    _ => Err(RoleParseError::NotPresentInCache),
+                }
             },
             _ => Err(RoleParseError::InvalidRole),
         }
@@ -242,9 +246,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/mod.rs b/src/model/mod.rs
index cc8860f..d512ffb 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -198,26 +198,41 @@ pub struct CurrentApplicationInfo {
     pub id: UserId,
     pub name: String,
     pub owner: User,
-    #[serde(default)] pub rpc_origins: Vec<String>,
+    #[serde(default)]
+    pub rpc_origins: Vec<String>,
 }
 
 /// The name of a region that a voice server can be located in.
 #[derive(Copy, Clone, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Ord, Serialize)]
 pub enum Region {
-    #[serde(rename = "amsterdam")] Amsterdam,
-    #[serde(rename = "brazil")] Brazil,
-    #[serde(rename = "eu-central")] EuCentral,
-    #[serde(rename = "eu-west")] EuWest,
-    #[serde(rename = "frankfurt")] Frankfurt,
-    #[serde(rename = "london")] London,
-    #[serde(rename = "sydney")] Sydney,
-    #[serde(rename = "us-central")] UsCentral,
-    #[serde(rename = "us-east")] UsEast,
-    #[serde(rename = "us-south")] UsSouth,
-    #[serde(rename = "us-west")] UsWest,
-    #[serde(rename = "vip-amsterdam")] VipAmsterdam,
-    #[serde(rename = "vip-us-east")] VipUsEast,
-    #[serde(rename = "vip-us-west")] VipUsWest,
+    #[serde(rename = "amsterdam")]
+    Amsterdam,
+    #[serde(rename = "brazil")]
+    Brazil,
+    #[serde(rename = "eu-central")]
+    EuCentral,
+    #[serde(rename = "eu-west")]
+    EuWest,
+    #[serde(rename = "frankfurt")]
+    Frankfurt,
+    #[serde(rename = "london")]
+    London,
+    #[serde(rename = "sydney")]
+    Sydney,
+    #[serde(rename = "us-central")]
+    UsCentral,
+    #[serde(rename = "us-east")]
+    UsEast,
+    #[serde(rename = "us-south")]
+    UsSouth,
+    #[serde(rename = "us-west")]
+    UsWest,
+    #[serde(rename = "vip-amsterdam")]
+    VipAmsterdam,
+    #[serde(rename = "vip-us-east")]
+    VipUsEast,
+    #[serde(rename = "vip-us-west")]
+    VipUsWest,
 }
 
 impl Region {
@@ -245,6 +260,6 @@ use serde::{Deserialize, Deserializer};
 use std::result::Result as StdResult;
 
 fn deserialize_sync_user<'de, D: Deserializer<'de>>(deserializer: D)
--> StdResult<Arc<RwLock<User>>, D::Error>{
+                                                    -> StdResult<Arc<RwLock<User>>, D::Error> {
     Ok(Arc::new(RwLock::new(User::deserialize(deserializer)?)))
 }
diff --git a/src/model/user.rs b/src/model/user.rs
index c3b131b..66b7285 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -25,11 +25,14 @@ use http::{self, GuildPagination};
 pub struct CurrentUser {
     pub id: UserId,
     pub avatar: Option<String>,
-    #[serde(default)] pub bot: bool,
-    #[serde(deserialize_with = "deserialize_u16")] pub discriminator: u16,
+    #[serde(default)]
+    pub bot: bool,
+    #[serde(deserialize_with = "deserialize_u16")]
+    pub discriminator: u16,
     pub email: Option<String>,
     pub mfa_enabled: bool,
-    #[serde(rename = "username")] pub name: String,
+    #[serde(rename = "username")]
+    pub name: String,
     pub verified: bool,
 }
 
@@ -85,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()));
@@ -110,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.
@@ -322,11 +329,16 @@ enum_number!(
 /// [`Invisible`]: #variant.Invisible
 #[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, PartialEq, PartialOrd, Ord, Serialize)]
 pub enum OnlineStatus {
-    #[serde(rename = "dnd")] DoNotDisturb,
-    #[serde(rename = "idle")] Idle,
-    #[serde(rename = "invisible")] Invisible,
-    #[serde(rename = "offline")] Offline,
-    #[serde(rename = "online")] Online,
+    #[serde(rename = "dnd")]
+    DoNotDisturb,
+    #[serde(rename = "idle")]
+    Idle,
+    #[serde(rename = "invisible")]
+    Invisible,
+    #[serde(rename = "offline")]
+    Offline,
+    #[serde(rename = "online")]
+    Online,
 }
 
 impl OnlineStatus {
@@ -534,7 +546,7 @@ impl User {
     /// [direct_message]: #method.direct_message
     #[cfg(feature = "builder")]
     #[inline]
-pub fn dm<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message>{
+    pub fn dm<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Message> {
         self.direct_message(f)
     }
 
@@ -547,8 +559,9 @@ pub fn dm<F: FnOnce(CreateMessage) -> CreateMessage>(&self, f: F) -> Result<Mess
     /// [`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
@@ -794,7 +807,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 b85b58f..9fed660 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -123,11 +123,11 @@ pub fn deserialize_users<'de, D: Deserializer<'de>>(
     Ok(users)
 }
 
-pub fn deserialize_u16<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u16, D::Error>{
+pub fn deserialize_u16<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u16, D::Error> {
     deserializer.deserialize_u16(U16Visitor)
 }
 
-pub fn deserialize_u64<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u64, D::Error>{
+pub fn deserialize_u64<'de, D: Deserializer<'de>>(deserializer: D) -> StdResult<u64, D::Error> {
     deserializer.deserialize_u64(U64Visitor)
 }
 
@@ -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 4725ec1..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) {
@@ -182,7 +185,7 @@ impl Webhook {
     pub fn execute<F: FnOnce(ExecuteWebhook) -> ExecuteWebhook>(&self,
                                                                 wait: bool,
                                                                 f: F)
--> Result<Option<Message>>{
+                                                                -> Result<Option<Message>> {
         http::execute_webhook(
             self.id.0,
             &self.token,
diff --git a/src/utils/message_builder.rs b/src/utils/message_builder.rs
index 2f714ec..8f13db2 100644
--- a/src/utils/message_builder.rs
+++ b/src/utils/message_builder.rs
@@ -852,11 +852,8 @@ impl Content {
     pub fn to_string(&self) -> String {
         let capacity =
             self.inner.len() + if self.bold { 4 } else { 0 } + if self.italic { 2 } else { 0 } +
-            if self.strikethrough { 4 } else { 0 } + if self.underline {
-                4
-            } else {
-                0
-            } + if self.code { 2 } else { 0 };
+            if self.strikethrough { 4 } else { 0 } +
+            if self.underline { 4 } else { 0 } + if self.code { 2 } else { 0 };
         let mut new_str = String::with_capacity(capacity);
 
         if self.bold {
diff --git a/src/voice/audio.rs b/src/voice/audio.rs
index 14b9ccd..be3ae60 100644
--- a/src/voice/audio.rs
+++ b/src/voice/audio.rs
@@ -5,7 +5,11 @@ pub const SAMPLE_RATE: u32 = 48000;
 pub trait AudioSource: Send {
     fn is_stereo(&mut self) -> bool;
 
-    fn read_frame(&mut self, buffer: &mut [i16]) -> Option<usize>;
+    fn get_type(&self) -> AudioType;
+
+    fn read_pcm_frame(&mut self, buffer: &mut [i16]) -> Option<usize>;
+
+    fn read_opus_frame(&mut self) -> Option<Vec<u8>>;
 }
 
 /// A receiver for incoming audio.
@@ -19,3 +23,9 @@ pub trait AudioReceiver: Send {
                     stereo: bool,
                     data: &[i16]);
 }
+
+#[derive(Clone)]
+pub enum AudioType {
+    Opus,
+    Pcm,
+}
diff --git a/src/voice/connection.rs b/src/voice/connection.rs
index 7cc8b3a..7f2ac23 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;
@@ -14,9 +9,9 @@ use std::sync::mpsc::{self, Receiver as MpscReceiver, Sender as MpscSender};
 use std::sync::{Arc, Mutex};
 use std::thread::{self, Builder as ThreadBuilder, JoinHandle};
 use std::time::Duration;
-use super::audio::{AudioReceiver, AudioSource, HEADER_LEN, SAMPLE_RATE};
+use super::audio::{AudioReceiver, AudioSource, AudioType, 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
@@ -236,7 +239,45 @@ impl Connection {
             self.udp.send_to(&bytes, self.destination)?;
         }
 
-        let len = self.read(source, &mut buffer)?;
+
+        let mut opus_frame = Vec::new();
+
+        let len = match source.as_mut() {
+            Some(stream) => {
+                let is_stereo = stream.is_stereo();
+
+                if is_stereo != self.encoder_stereo {
+                    let channels = if is_stereo {
+                        Channels::Stereo
+                    } else {
+                        Channels::Mono
+                    };
+                    self.encoder = OpusEncoder::new(SAMPLE_RATE, channels, CodingMode::Audio)?;
+                    self.encoder_stereo = is_stereo;
+                }
+
+                match stream.get_type() {
+                    AudioType::Opus => {
+                        match stream.read_opus_frame() {
+                            Some(frame) => {
+                                opus_frame = frame;
+                                opus_frame.len()
+                            },
+                            None => 0,
+                        }
+                    },
+                    AudioType::Pcm => {
+                        let buffer_len = if is_stereo { 960 * 2 } else { 960 };
+
+                        match stream.read_pcm_frame(&mut buffer[..buffer_len]) {
+                            Some(len) => len,
+                            None => 0,
+                        }
+                    },
+                }
+            },
+            None => 0,
+        };
 
         if len == 0 {
             self.set_speaking(false)?;
@@ -262,7 +303,7 @@ impl Connection {
 
         self.set_speaking(true)?;
 
-        let index = self.prep_packet(&mut packet, buffer, nonce)?;
+        let index = self.prep_packet(&mut packet, buffer, &opus_frame, nonce)?;
         audio_timer.await();
 
         self.udp.send_to(&packet[..index], self.destination)?;
@@ -274,6 +315,7 @@ impl Connection {
     fn prep_packet(&mut self,
                    packet: &mut [u8; 512],
                    buffer: [i16; 1920],
+                   opus_frame: &[u8],
                    mut nonce: Nonce)
                    -> Result<usize> {
         {
@@ -284,14 +326,26 @@ 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 = if opus_frame.is_empty() {
+            self.encoder.encode(
+                &buffer[..buffer_len],
+                &mut packet[HEADER_LEN..sl_index],
+            )?
+        } else {
+            let len = opus_frame.len();
+            packet[HEADER_LEN..HEADER_LEN + len].clone_from_slice(
+                opus_frame,
+            );
+            len
+        };
+
         let crypted = {
             let slice = &packet[HEADER_LEN..HEADER_LEN + len];
             secretbox::seal(slice, &nonce, &self.key)
@@ -305,47 +359,6 @@ impl Connection {
         Ok(HEADER_LEN + crypted.len())
     }
 
-    fn read(&mut self,
-            source: &mut Option<Box<AudioSource>>,
-            buffer: &mut [i16; 1920])
-            -> Result<usize> {
-        let mut clear = false;
-
-        let len = match source.as_mut() {
-            Some(source) => {
-                let is_stereo = source.is_stereo();
-
-                if is_stereo != self.encoder_stereo {
-                    let channels = if is_stereo {
-                        Channels::Stereo
-                    } else {
-                        Channels::Mono
-                    };
-                    self.encoder = OpusEncoder::new(SAMPLE_RATE, channels, CodingMode::Audio)?;
-                    self.encoder_stereo = is_stereo;
-                }
-
-                let buffer_len = if is_stereo { 960 * 2 } else { 960 };
-
-                match source.read_frame(&mut buffer[..buffer_len]) {
-                    Some(len) => len,
-                    None => {
-                        clear = true;
-
-                        0
-                    },
-                }
-            },
-            None => 0,
-        };
-
-        if clear {
-            *source = None;
-        }
-
-        Ok(len)
-    }
-
     fn set_speaking(&mut self, speaking: bool) -> Result<()> {
         if self.speaking == speaking {
             return Ok(());
@@ -353,10 +366,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 +390,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 +404,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/dca.rs b/src/voice/dca.rs
new file mode 100644
index 0000000..4f3d7e7
--- /dev/null
+++ b/src/voice/dca.rs
@@ -0,0 +1,14 @@
+#[derive(Debug, Deserialize)]
+pub struct DcaMetadata {
+    opus: OpusInfo,
+}
+
+#[derive(Debug, Deserialize)]
+struct OpusInfo {
+    /// Number of channels
+    channels: u8,
+}
+
+impl DcaMetadata {
+    pub fn is_stereo(&self) -> bool { self.opus.channels == 2 }
+}
diff --git a/src/voice/error.rs b/src/voice/error.rs
index b756bfb..a0bb11a 100644
--- a/src/voice/error.rs
+++ b/src/voice/error.rs
@@ -1,5 +1,6 @@
-use serde_json::Value;
+use serde_json::{self, Value};
 use std::process::Output;
+use std;
 
 /// An error returned from the voice module.
 // Errors which are not visible to the end user are hidden.
@@ -7,14 +8,20 @@ use std::process::Output;
 pub enum VoiceError {
     /// An indicator that an endpoint URL was invalid.
     EndpointUrl,
-    #[doc(hidden)] ExpectedHandshake,
-    #[doc(hidden)] FindingByte,
-    #[doc(hidden)] HostnameResolve,
-    #[doc(hidden)] KeyGen,
+    #[doc(hidden)]
+    ExpectedHandshake,
+    #[doc(hidden)]
+    FindingByte,
+    #[doc(hidden)]
+    HostnameResolve,
+    #[doc(hidden)]
+    KeyGen,
     /// An error occurred while checking if a path is stereo.
     Streams,
-    #[doc(hidden)] VoiceModeInvalid,
-    #[doc(hidden)] VoiceModeUnavailable,
+    #[doc(hidden)]
+    VoiceModeInvalid,
+    #[doc(hidden)]
+    VoiceModeUnavailable,
     /// An error occurred while running `youtube-dl`.
     YouTubeDLRun(Output),
     /// An error occurred while processing the JSON output from `youtube-dl`.
@@ -26,3 +33,12 @@ pub enum VoiceError {
     /// The JSON output is given.
     YouTubeDLUrl(Value),
 }
+
+/// An error returned from the dca method.
+#[derive(Debug)]
+pub enum DcaError {
+    IoError(std::io::Error),
+    InvalidHeader,
+    InvalidMetadata(serde_json::Error),
+    InvalidSize(i32),
+}
diff --git a/src/voice/handler.rs b/src/voice/handler.rs
index 9c3f691..24b3cd9 100644
--- a/src/voice/handler.rs
+++ b/src/voice/handler.rs
@@ -225,7 +225,7 @@ impl Handler {
     /// can pass in just a boxed receiver, and do not need to specify `Some`.
     ///
     /// Pass `None` to drop the current receiver, if one exists.
-pub fn listen<O: Into<Option<Box<AudioReceiver>>>>(&mut self, receiver: O){
+    pub fn listen<O: Into<Option<Box<AudioReceiver>>>>(&mut self, receiver: O) {
         self.send(VoiceStatus::SetReceiver(receiver.into()))
     }
 
diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index a94c8a0..6af5926 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -3,6 +3,7 @@
 mod audio;
 mod connection;
 mod connection_info;
+mod dca;
 mod error;
 mod manager;
 mod handler;
@@ -10,11 +11,12 @@ mod payload;
 mod streamer;
 mod threading;
 
-pub use self::audio::{AudioReceiver, AudioSource};
-pub use self::error::VoiceError;
+pub use self::audio::{AudioReceiver, AudioSource, AudioType};
+pub use self::dca::DcaMetadata;
+pub use self::error::{DcaError, VoiceError};
 pub use self::handler::Handler;
 pub use self::manager::Manager;
-pub use self::streamer::{ffmpeg, pcm, ytdl};
+pub use self::streamer::{dca, ffmpeg, opus, pcm, ytdl};
 
 use self::connection_info::ConnectionInfo;
 
@@ -22,7 +24,8 @@ const CRYPTO_MODE: &'static str = "xsalsa20_poly1305";
 
 pub(crate) enum Status {
     Connect(ConnectionInfo),
-    #[allow(dead_code)] Disconnect,
+    #[allow(dead_code)]
+    Disconnect,
     SetReceiver(Option<Box<AudioReceiver>>),
     SetSender(Option<Box<AudioSource>>),
 }
diff --git a/src/voice/streamer.rs b/src/voice/streamer.rs
index c8400f0..5f05879 100644
--- a/src/voice/streamer.rs
+++ b/src/voice/streamer.rs
@@ -1,11 +1,14 @@
 use byteorder::{LittleEndian, ReadBytesExt};
 use serde_json;
 use std::ffi::OsStr;
-use std::io::{ErrorKind as IoErrorKind, Read, Result as IoResult};
+use std::io::{BufReader, ErrorKind as IoErrorKind, Read, Result as IoResult};
 use std::process::{Child, Command, Stdio};
-use super::{AudioSource, VoiceError};
+use super::{AudioSource, AudioType, DcaError, DcaMetadata, VoiceError};
 use internal::prelude::*;
 
+use std::fs::File;
+use std::result::Result as StdResult;
+
 struct ChildContainer(Child);
 
 impl Read for ChildContainer {
@@ -14,14 +17,20 @@ impl Read for ChildContainer {
     }
 }
 
-struct PcmSource<R: Read + Send + 'static>(bool, R);
+struct InputSource<R: Read + Send + 'static> {
+    stereo: bool,
+    reader: R,
+    kind: AudioType,
+}
+
+impl<R: Read + Send> AudioSource for InputSource<R> {
+    fn is_stereo(&mut self) -> bool { self.stereo }
 
-impl<R: Read + Send> AudioSource for PcmSource<R> {
-    fn is_stereo(&mut self) -> bool { self.0 }
+    fn get_type(&self) -> AudioType { self.kind.clone() }
 
-    fn read_frame(&mut self, buffer: &mut [i16]) -> Option<usize> {
+    fn read_pcm_frame(&mut self, buffer: &mut [i16]) -> Option<usize> {
         for (i, v) in buffer.iter_mut().enumerate() {
-            *v = match self.1.read_i16::<LittleEndian>() {
+            *v = match self.reader.read_i16::<LittleEndian>() {
                 Ok(v) => v,
                 Err(ref e) => {
                     return if e.kind() == IoErrorKind::UnexpectedEof {
@@ -35,13 +44,38 @@ impl<R: Read + Send> AudioSource for PcmSource<R> {
 
         Some(buffer.len())
     }
+
+    fn read_opus_frame(&mut self) -> Option<Vec<u8>> {
+        match self.reader.read_i16::<LittleEndian>() {
+            Ok(size) => {
+                let mut frame = Vec::with_capacity(size as usize);
+
+                {
+                    let reader = self.reader.by_ref();
+
+                    if reader.take(size as u64).read_to_end(&mut frame).is_err() {
+                        return None;
+                    }
+                }
+
+                Some(frame)
+            },
+            Err(ref e) => {
+                if e.kind() == IoErrorKind::UnexpectedEof {
+                    Some(Vec::new())
+                } else {
+                    None
+                }
+            },
+        }
+    }
 }
 
 /// Opens an audio file through `ffmpeg` and creates an audio source.
 pub fn ffmpeg<P: AsRef<OsStr>>(path: P) -> Result<Box<AudioSource>> {
     let path = path.as_ref();
 
-    /// Will fail if the path is not to a file on the fs. Likely a YouTube URI.
+    // Will fail if the path is not to a file on the fs. Likely a YouTube URI.
     let is_stereo = is_stereo(path).unwrap_or(false);
     let stereo_val = if is_stereo { "2" } else { "1" };
 
@@ -69,9 +103,63 @@ pub fn ffmpeg<P: AsRef<OsStr>>(path: P) -> Result<Box<AudioSource>> {
     Ok(pcm(is_stereo, ChildContainer(command)))
 }
 
+/// Creates a streamed audio source from a DCA file.
+/// Currently only accepts the DCA1 format.
+pub fn dca<P: AsRef<OsStr>>(path: P) -> StdResult<Box<AudioSource>, DcaError> {
+    let file = File::open(path.as_ref()).map_err(DcaError::IoError)?;
+
+    let mut reader = BufReader::new(file);
+
+    let mut header = [0u8; 4];
+
+    // Read in the magic number to verify it's a DCA file.
+    reader.read_exact(&mut header).map_err(DcaError::IoError)?;
+
+    if header != b"DCA1"[..] {
+        return Err(DcaError::InvalidHeader);
+    }
+
+    reader.read_exact(&mut header).map_err(DcaError::IoError)?;
+
+    let size = (&header[..]).read_i32::<LittleEndian>().unwrap();
+
+    // Sanity check
+    if size < 2 {
+        return Err(DcaError::InvalidSize(size));
+    }
+
+    let mut raw_json = Vec::with_capacity(size as usize);
+
+    {
+        let json_reader = reader.by_ref();
+        json_reader
+            .take(size as u64)
+            .read_to_end(&mut raw_json)
+            .map_err(DcaError::IoError)?;
+    }
+
+    let metadata = serde_json::from_slice::<DcaMetadata>(raw_json.as_slice())
+        .map_err(DcaError::InvalidMetadata)?;
+
+    Ok(opus(metadata.is_stereo(), reader))
+}
+
+/// Creates an Opus audio source.
+pub fn opus<R: Read + Send + 'static>(is_stereo: bool, reader: R) -> Box<AudioSource> {
+    Box::new(InputSource {
+        stereo: is_stereo,
+        reader: reader,
+        kind: AudioType::Opus,
+    })
+}
+
 /// Creates a PCM audio source.
 pub fn pcm<R: Read + Send + 'static>(is_stereo: bool, reader: R) -> Box<AudioSource> {
-    Box::new(PcmSource(is_stereo, reader))
+    Box::new(InputSource {
+        stereo: is_stereo,
+        reader: reader,
+        kind: AudioType::Pcm,
+    })
 }
 
 /// Creates a streamed audio source with `youtube-dl` and `ffmpeg`.
@@ -101,9 +189,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 +219,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)
     });