Apply rustfmt

author: Zeyla Hellyer <[email protected]> 2017-09-18 17:48:52 -0700
committer: Zeyla Hellyer <[email protected]> 2017-09-18 17:48:52 -0700
commit: dae2cb77b407044f44a7a2790d93efba3891854e (patch)
tree: bef263c4490536cf8b56e988e71dd1aa43bc2696 /src
parent: Fix compiles of a variety of feature combinations (diff)
download: serenity-dae2cb77b407044f44a7a2790d93efba3891854e.tar.xz
serenity-dae2cb77b407044f44a7a2790d93efba3891854e.zip
54 files changed, 642 insertions, 960 deletions
diff --git a/src/builder/create_embed.rs b/src/builder/create_embed.rs
index 6d61653..1e0bc8d 100644
--- a/src/builder/create_embed.rs
+++ b/src/builder/create_embed.rs
@@ -87,10 +87,8 @@ 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)
     }
@@ -284,30 +282,24 @@ 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)
     }
@@ -327,10 +319,7 @@ 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)
     }
@@ -407,30 +396,24 @@ 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
     }
@@ -457,20 +440,16 @@ 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
     }
@@ -500,20 +479,16 @@ 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 d17f273..58893fc 100644
--- a/src/builder/create_invite.rs
+++ b/src/builder/create_invite.rs
@@ -89,10 +89,8 @@ 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
     }
@@ -125,10 +123,8 @@ 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
     }
@@ -159,10 +155,8 @@ 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 1ac5211..dea77e1 100644
--- a/src/builder/create_message.rs
+++ b/src/builder/create_message.rs
@@ -46,10 +46,8 @@ impl CreateMessage {
     ///
     /// **Note**: Message contents must be under 2000 unicode code points.
     pub fn content<D: Display>(mut self, content: D) -> Self {
-        self.0.insert(
-            "content".to_owned(),
-            Value::String(format!("{}", content)),
-        );
+        self.0
+            .insert("content".to_owned(), Value::String(format!("{}", content)));
 
         CreateMessage(self.0, self.1)
     }
diff --git a/src/builder/edit_channel.rs b/src/builder/edit_channel.rs
index a5d799f..e3bf78e 100644
--- a/src/builder/edit_channel.rs
+++ b/src/builder/edit_channel.rs
@@ -27,10 +27,8 @@ 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
     }
@@ -39,20 +37,16 @@ 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
     }
@@ -65,10 +59,8 @@ 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 6cfd13a..f88db2a 100644
--- a/src/builder/edit_guild.rs
+++ b/src/builder/edit_guild.rs
@@ -79,10 +79,7 @@ impl EditGuild {
     pub fn icon(mut self, icon: Option<&str>) -> Self {
         self.0.insert(
             "icon".to_owned(),
-            icon.map_or_else(
-                || Value::Null,
-                |x| Value::String(x.to_owned()),
-            ),
+            icon.map_or_else(|| Value::Null, |x| Value::String(x.to_owned())),
         );
 
         self
@@ -92,10 +89,8 @@ impl EditGuild {
     ///
     /// **Note**: Must be between (and including) 2-100 chracters.
     pub fn name(mut self, name: &str) -> Self {
-        self.0.insert(
-            "name".to_owned(),
-            Value::String(name.to_owned()),
-        );
+        self.0
+            .insert("name".to_owned(), Value::String(name.to_owned()));
 
         self
     }
@@ -139,10 +134,8 @@ impl EditGuild {
     ///
     /// [`Region::UsWest`]: ../model/enum.Region.html#variant.UsWest
     pub fn region(mut self, region: Region) -> Self {
-        self.0.insert(
-            "region".to_owned(),
-            Value::String(region.name().to_owned()),
-        );
+        self.0
+            .insert("region".to_owned(), Value::String(region.name().to_owned()));
 
         self
     }
diff --git a/src/builder/edit_member.rs b/src/builder/edit_member.rs
index 80ec983..23bf1f2 100644
--- a/src/builder/edit_member.rs
+++ b/src/builder/edit_member.rs
@@ -39,10 +39,8 @@ impl EditMember {
     ///
     /// [Manage Nicknames]: ../model/permissions/constant.MANAGE_NICKNAMES.html
     pub fn nickname(mut self, nickname: &str) -> Self {
-        self.0.insert(
-            "nick".to_owned(),
-            Value::String(nickname.to_owned()),
-        );
+        self.0
+            .insert("nick".to_owned(), Value::String(nickname.to_owned()));
 
         self
     }
diff --git a/src/builder/edit_profile.rs b/src/builder/edit_profile.rs
index 3bc121c..6aa4e78 100644
--- a/src/builder/edit_profile.rs
+++ b/src/builder/edit_profile.rs
@@ -61,10 +61,8 @@ 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
     }
@@ -90,10 +88,8 @@ 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
     }
@@ -105,10 +101,8 @@ 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 d034149..8be3404 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, Role, permissions};
+use model::{permissions, Permissions, Role};
 
 /// A builer to create or edit a [`Role`] for use via a number of model methods.
 ///
@@ -58,22 +58,13 @@ 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())),
@@ -88,10 +79,8 @@ 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
     }
@@ -106,20 +95,16 @@ 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
     }
@@ -137,10 +122,8 @@ 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
     }
@@ -163,24 +146,12 @@ 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 05f0d00..0cb276c 100644
--- a/src/builder/execute_webhook.rs
+++ b/src/builder/execute_webhook.rs
@@ -103,10 +103,8 @@ 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
     }
@@ -167,10 +165,8 @@ 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 8ac5dfe..bca2f0e 100644
--- a/src/builder/get_messages.rs
+++ b/src/builder/get_messages.rs
@@ -85,10 +85,8 @@ 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/mod.rs b/src/cache/mod.rs
index 5d7d153..2bbc9bc 100644
--- a/src/cache/mod.rs
+++ b/src/cache/mod.rs
@@ -553,9 +553,9 @@ impl Cache {
     /// ```
     pub fn role<G, R>(&self, guild_id: G, role_id: R) -> Option<Role>
         where G: Into<GuildId>, R: Into<RoleId> {
-        self.guilds.get(&guild_id.into()).and_then(|g| {
-            g.read().unwrap().roles.get(&role_id.into()).cloned()
-        })
+        self.guilds
+            .get(&guild_id.into())
+            .and_then(|g| g.read().unwrap().roles.get(&role_id.into()).cloned())
     }
 
     /// Retrieves a `User` from the cache's [`users`] map, if it exists.
diff --git a/src/client/dispatch.rs b/src/client/dispatch.rs
index 04739b6..494ab6d 100644
--- a/src/client/dispatch.rs
+++ b/src/client/dispatch.rs
@@ -158,8 +158,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             let context = context(conn, data, tokio_handle);
 
             match event.channel {
-                Channel::Private(_) |
-                Channel::Group(_) => {},
+                Channel::Private(_) | Channel::Group(_) => {},
                 Channel::Guild(channel) => {
                     let h = event_handler.clone();
                     tokio_handle.spawn_fn(move || {
@@ -192,11 +191,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_addition(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_addition(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -207,11 +202,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_channel_recipient_removal(
-                    context,
-                    event.channel_id,
-                    event.user,
-                );
+                h.on_channel_recipient_removal(context, event.channel_id, event.user);
                 Ok(())
             });
         },
@@ -253,7 +244,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
             });
         },
         Event::GuildCreate(mut event) => {
-            #[cfg(feature="cache")]
+            #[cfg(feature = "cache")]
             let _is_new = {
                 let cache = CACHE.read().unwrap();
 
@@ -325,11 +316,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_emojis_update(
-                    context,
-                    event.guild_id,
-                    event.emojis,
-                );
+                h.on_guild_emojis_update(context, event.guild_id, event.emojis);
                 Ok(())
             });
         },
@@ -349,11 +336,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_member_addition(
-                    context,
-                    event.guild_id,
-                    event.member,
-                );
+                h.on_guild_member_addition(context, event.guild_id, event.member);
                 Ok(())
             });
         },
@@ -409,11 +392,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_guild_members_chunk(
-                    context,
-                    event.guild_id,
-                    event.members,
-                );
+                h.on_guild_members_chunk(context, event.guild_id, event.members);
                 Ok(())
             });
         },
@@ -506,11 +485,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete_bulk(
-                    context,
-                    event.channel_id,
-                    event.ids,
-                );
+                h.on_message_delete_bulk(context, event.channel_id, event.ids);
                 Ok(())
             });
         },
@@ -519,11 +494,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_message_delete(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_message_delete(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -579,11 +550,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_reaction_remove_all(
-                    context,
-                    event.channel_id,
-                    event.message_id,
-                );
+                h.on_reaction_remove_all(context, event.channel_id, event.message_id);
                 Ok(())
             });
         },
@@ -675,11 +642,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_voice_state_update(
-                    context,
-                    event.guild_id,
-                    event.voice_state,
-                );
+                h.on_voice_state_update(context, event.guild_id, event.voice_state);
                 Ok(())
             });
         },
@@ -688,11 +651,7 @@ fn handle_event<H: EventHandler + 'static>(event: Event,
 
             let h = event_handler.clone();
             tokio_handle.spawn_fn(move || {
-                h.on_webhook_update(
-                    context,
-                    event.guild_id,
-                    event.channel_id,
-                );
+                h.on_webhook_update(context, event.guild_id, event.channel_id);
                 Ok(())
             });
         },
diff --git a/src/client/mod.rs b/src/client/mod.rs
index ea98cdb..6bd1579 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -37,7 +37,7 @@ pub use CACHE;
 
 use self::dispatch::dispatch;
 use std::sync::{self, Arc};
-use std::sync::atomic::{ATOMIC_BOOL_INIT, AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, Ordering, ATOMIC_BOOL_INIT};
 use parking_lot::Mutex;
 use tokio_core::reactor::Core;
 use futures;
@@ -195,8 +195,7 @@ pub struct Client<H: EventHandler + 'static> {
     /// [`Event::Ready`]: ../model/event/enum.Event.html#variant.Ready
     /// [`on_ready`]: #method.on_ready
     event_handler: Arc<H>,
-    #[cfg(feature = "framework")]
-    framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
+    #[cfg(feature = "framework")] framework: Arc<sync::Mutex<Option<Box<Framework>>>>,
     /// A HashMap of all shards instantiated by the Client.
     ///
     /// The key is the shard ID and the value is the shard itself.
@@ -594,10 +593,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_autosharded`]: #method.start_autosharded
     /// [gateway docs]: gateway/index.html#sharding
     pub fn start_shard(&mut self, shard: u64, shards: u64) -> Result<()> {
-        self.start_connection(
-            [shard, shard, shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([shard, shard, shards], http::get_gateway()?.url)
     }
 
     /// Establish sharded connections and start listening for events.
@@ -722,10 +718,7 @@ impl<H: EventHandler + 'static> Client<H> {
     /// [`start_shards`]: #method.start_shards
     /// [Gateway docs]: gateway/index.html#sharding
     pub fn start_shard_range(&mut self, range: [u64; 2], total_shards: u64) -> Result<()> {
-        self.start_connection(
-            [range[0], range[1], total_shards],
-            http::get_gateway()?.url,
-        )
+        self.start_connection([range[0], range[1], total_shards], http::get_gateway()?.url)
     }
 
     /// Returns a thread-safe handle for closing shards.
@@ -785,8 +778,7 @@ impl<H: EventHandler + 'static> Client<H> {
 
                     self.shards.lock().insert(shard_number, shard.clone());
 
-                    let monitor_info =
-                        feature_framework! {{
+                    let monitor_info = feature_framework! {{
                         MonitorInfo {
                             data: self.data.clone(),
                             event_handler: self.event_handler.clone(),
diff --git a/src/error.rs b/src/error.rs
index 3944a4c..508578b 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -171,8 +171,7 @@ 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/args.rs b/src/framework/standard/args.rs
index b88f345..d22b1a8 100644
--- a/src/framework/standard/args.rs
+++ b/src/framework/standard/args.rs
@@ -144,9 +144,10 @@ impl Args {
             return Err(Error::Eos);
         }
 
-        match self.delimiter_split.iter().position(
-            |e| e.parse::<T>().is_ok(),
-        ) {
+        match self.delimiter_split
+                  .iter()
+                  .position(|e| e.parse::<T>().is_ok())
+        {
             Some(index) => {
                 let value = self.delimiter_split
                     .get(index)
diff --git a/src/framework/standard/buckets.rs b/src/framework/standard/buckets.rs
index f2c4486..4719b85 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 501798c..e9bdd52 100644
--- a/src/framework/standard/command.rs
+++ b/src/framework/standard/command.rs
@@ -6,10 +6,7 @@ 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 015fb42..58861bb 100644
--- a/src/framework/standard/configuration.rs
+++ b/src/framework/standard/configuration.rs
@@ -33,34 +33,20 @@ 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 case_insensitive: bool,
+    #[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 case_insensitive: bool,
 }
 
 impl Configuration {
@@ -271,8 +257,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
             ]);
         }
 
@@ -417,9 +403,8 @@ 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 546447e..a8421e6 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,10 +115,7 @@ 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 2184c93..d4e2d15 100644
--- a/src/framework/standard/create_group.rs
+++ b/src/framework/standard/create_group.rs
@@ -51,9 +51,7 @@ 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(
@@ -77,10 +75,9 @@ 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 72e0468..a14f510 100644
--- a/src/framework/standard/help_commands.rs
+++ b/src/framework/standard/help_commands.rs
@@ -140,19 +140,15 @@ 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))
                             });
                         }
 
@@ -342,10 +338,8 @@ 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 bd1300d..4e145e0 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -404,9 +404,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));
             }
         }
 
@@ -417,9 +417,8 @@ 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);
             }
@@ -449,8 +448,7 @@ 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 {
@@ -461,10 +459,8 @@ 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));
                         },
                     }
                 }
@@ -514,9 +510,9 @@ 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()))
@@ -543,9 +539,10 @@ impl StandardFramework {
                     }
                 }
 
-                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
@@ -599,21 +596,16 @@ 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))));
             }
         }
 
@@ -636,11 +628,9 @@ 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;
@@ -655,17 +645,15 @@ 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)));
             }
         }
 
@@ -878,8 +866,9 @@ 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) {
+                    let cmd = group.commands.get(&built);
+
+                    if let Some(&CommandOrAlias::Alias(ref points_to)) = cmd {
                         built = points_to.to_owned();
                     }
 
diff --git a/src/gateway/shard.rs b/src/gateway/shard.rs
index 028efeb..571d522 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, OpCode, close_codes};
+use constants::{self, close_codes, OpCode};
 use internal::prelude::*;
 use internal::ws_impl::SenderExt;
 use model::event::{Event, GatewayEvent};
@@ -95,8 +95,7 @@ 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 {
@@ -137,44 +136,43 @@ impl Shard {
         let stage = ConnectionStage::Handshake;
         let session_id = None;
 
-        let mut shard =
-            feature_voice! {
-                {
-                    let (tx, rx) = mpsc::channel();
-
-                    let user = http::get_current_user()?;
-
-                    Shard {
-                        client,
-                        current_presence,
-                        heartbeat_instants,
-                        heartbeat_interval,
-                        last_heartbeat_acknowledged,
-                        seq,
-                        stage,
-                        token,
-                        session_id,
-                        shard_info,
-                        ws_url,
-                        manager: VoiceManager::new(tx, user.id),
-                        manager_rx: rx,
-                    }
-                } else {
-                    Shard {
-                        client,
-                        current_presence,
-                        heartbeat_instants,
-                        heartbeat_interval,
-                        last_heartbeat_acknowledged,
-                        seq,
-                        stage,
-                        token,
-                        session_id,
-                        shard_info,
-                        ws_url,
-                    }
+        let mut shard = feature_voice! {
+            {
+                let (tx, rx) = mpsc::channel();
+
+                let user = http::get_current_user()?;
+
+                Shard {
+                    client,
+                    current_presence,
+                    heartbeat_instants,
+                    heartbeat_interval,
+                    last_heartbeat_acknowledged,
+                    seq,
+                    stage,
+                    token,
+                    session_id,
+                    shard_info,
+                    ws_url,
+                    manager: VoiceManager::new(tx, user.id),
+                    manager_rx: rx,
                 }
-            };
+            } else {
+                Shard {
+                    client,
+                    current_presence,
+                    heartbeat_instants,
+                    heartbeat_interval,
+                    last_heartbeat_acknowledged,
+                    seq,
+                    stage,
+                    token,
+                    session_id,
+                    shard_info,
+                    ws_url,
+                }
+            }
+        };
 
         shard.identify()?;
 
@@ -417,8 +415,10 @@ impl Shard {
                 }
             },
             Ok(GatewayEvent::InvalidateSession) => {
-                info!("[Shard {:?}] Received session invalidation; re-identifying",
-                self.shard_info);
+                info!(
+                    "[Shard {:?}] Received session invalidation; re-identifying",
+                    self.shard_info
+                );
 
                 self.seq = 0;
                 self.session_id = None;
@@ -436,11 +436,13 @@ impl Shard {
                 {
                     let kind = if clean { "Cleanly" } else { "Uncleanly" };
 
-                    info!("[Shard {:?}] {} closing with {:?}: {:?}",
-                    self.shard_info,
-                    kind,
-                    num,
-                    reason);
+                    info!(
+                        "[Shard {:?}] {} closing with {:?}: {:?}",
+                        self.shard_info,
+                        kind,
+                        num,
+                        reason
+                    );
                 }
 
                 match num {
@@ -458,7 +460,11 @@ impl Shard {
                     },
                     Some(close_codes::ALREADY_AUTHENTICATED) => warn!("Already authenticated"),
                     Some(close_codes::INVALID_SEQUENCE) => {
-                        warn!("[Shard {:?}] Sent invalid seq: {}", self.shard_info, self.seq);
+                        warn!(
+                            "[Shard {:?}] Sent invalid seq: {}",
+                            self.shard_info,
+                            self.seq
+                        );
 
                         self.seq = 0;
                     },
@@ -473,17 +479,18 @@ 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;
                     },
                     Some(other) if !clean => {
-                        warn!("[Shard {:?}] Unknown unclean close {}: {:?}",
-                        self.shard_info,
-                        other,
-                        reason);
+                        warn!(
+                            "[Shard {:?}] Unknown unclean close {}: {:?}",
+                            self.shard_info,
+                            other,
+                            reason
+                        );
                     },
                     _ => {},
                 }
@@ -507,7 +514,10 @@ impl Shard {
                 }
 
                 warn!("[Shard {:?}] Websocket error: {:?}", self.shard_info, why);
-                info!("[Shard {:?}] Will attempt to auto-reconnect", self.shard_info);
+                info!(
+                    "[Shard {:?}] Will attempt to auto-reconnect",
+                    self.shard_info
+                );
 
                 self.autoreconnect().and(Ok(None))
             },
@@ -722,7 +732,11 @@ impl Shard {
     pub(crate) fn cycle_voice_recv(&mut self) {
         if let Ok(v) = self.manager_rx.try_recv() {
             if let Err(why) = self.client.send_json(&v) {
-                warn!("[Shard {:?}] Err sending voice msg: {:?}", self.shard_info, why);
+                warn!(
+                    "[Shard {:?}] Err sending voice msg: {:?}",
+                    self.shard_info,
+                    why
+                );
             }
         }
     }
@@ -733,7 +747,11 @@ impl Shard {
             "op": OpCode::Heartbeat.num(),
         });
 
-        trace!("[Shard {:?}] Sending heartbeat d: {}", self.shard_info, self.seq);
+        trace!(
+            "[Shard {:?}] Sending heartbeat d: {}",
+            self.shard_info,
+            self.seq
+        );
 
         match self.client.send_json(&map) {
             Ok(_) => {
@@ -744,13 +762,20 @@ 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);
+                        warn!(
+                            "[Shard {:?}] Other err w/ keepalive: {:?}",
+                            self.shard_info,
+                            other
+                        );
                     },
                 }
 
@@ -778,12 +803,17 @@ impl Shard {
         // If the last heartbeat didn't receive an acknowledgement, then
         // auto-reconnect.
         if !self.last_heartbeat_acknowledged {
-            debug!("[Shard {:?}] Last heartbeat not acknowledged; re-connecting", self.shard_info);
+            debug!(
+                "[Shard {:?}] Last heartbeat not acknowledged; re-connecting",
+                self.shard_info
+            );
 
             return self.reconnect().map_err(|why| {
-                warn!("[Shard {:?}] Err auto-reconnecting from heartbeat check: {:?}",
-                self.shard_info,
-                why);
+                warn!(
+                    "[Shard {:?}] Err auto-reconnecting from heartbeat check: {:?}",
+                    self.shard_info,
+                    why
+                );
 
                 why
             });
@@ -807,11 +837,17 @@ impl Shard {
         }
 
         if self.session_id.is_some() {
-            debug!("[Shard {:?}] Autoreconnector choosing to resume", self.shard_info);
+            debug!(
+                "[Shard {:?}] Autoreconnector choosing to resume",
+                self.shard_info
+            );
 
             self.resume()
         } else {
-            debug!("[Shard {:?}] Autoreconnector choosing to reconnect", self.shard_info);
+            debug!(
+                "[Shard {:?}] Autoreconnector choosing to reconnect",
+                self.shard_info
+            );
 
             self.reconnect()
         }
@@ -918,7 +954,11 @@ impl Shard {
         });
 
         if let Err(why) = self.client.send_json(&msg) {
-            warn!("[Shard {:?}] Err sending presence update: {:?}", self.shard_info, why);
+            warn!(
+                "[Shard {:?}] Err sending presence update: {:?}",
+                self.shard_info,
+                why
+            );
         }
 
         #[cfg(feature = "cache")]
diff --git a/src/http/mod.rs b/src/http/mod.rs
index 03e249c..8789ac3 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::{Error as HyperError, Result as HyperResult, Url, header};
+use hyper::{header, Error as HyperError, Result as HyperResult, Url};
 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,9 +634,8 @@ 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)?,
     )
 }
@@ -739,9 +738,7 @@ 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),
@@ -779,9 +776,8 @@ 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.
@@ -991,11 +987,8 @@ 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![]),
     }
 }
@@ -1354,10 +1347,7 @@ 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)
@@ -1442,11 +1432,8 @@ 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![]),
     }
 }
@@ -1464,11 +1451,8 @@ 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![]),
     }
 }
@@ -1542,9 +1526,8 @@ 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)
@@ -1620,12 +1603,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();
@@ -1633,20 +1616,12 @@ 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)?;
@@ -1789,8 +1764,7 @@ 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())
     })?;
 
@@ -1804,8 +1778,7 @@ 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 bce9f12..a0023f6 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::{i64, str, thread};
+use std::{str, thread, i64};
 use super::{HttpError, LightMethod};
 use internal::prelude::*;
 
@@ -399,15 +399,16 @@ 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)
             };
@@ -508,9 +509,9 @@ fn parse_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
         str::from_utf8(&header[0])
             .map_err(|_| Error::Http(HttpError::RateLimitUtf8))
             .and_then(|v| {
-                v.parse::<i64>().map(|v| Some(v)).map_err(|_| {
-                    Error::Http(HttpError::RateLimitI64)
-                })
+                v.parse::<i64>()
+                    .map(|v| Some(v))
+                    .map_err(|_| Error::Http(HttpError::RateLimitI64))
             })
     })
 }
diff --git a/src/internal/ws_impl.rs b/src/internal/ws_impl.rs
index cd9161a..70c4cb7 100644
--- a/src/internal/ws_impl.rs
+++ b/src/internal/ws_impl.rs
@@ -7,7 +7,8 @@ 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 {
@@ -42,9 +43,8 @@ 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/attachment.rs b/src/model/channel/attachment.rs
index 079f4a9..8a3cbfa 100644
--- a/src/model/channel/attachment.rs
+++ b/src/model/channel/attachment.rs
@@ -32,9 +32,8 @@ impl Attachment {
     /// If this attachment is an image, then a tuple of the width and height
     /// in pixels is returned.
     pub fn dimensions(&self) -> Option<(u64, u64)> {
-        self.width.and_then(
-            |width| self.height.map(|height| (width, height)),
-        )
+        self.width
+            .and_then(|width| self.height.map(|height| (width, height)))
     }
 
     /// Downloads the attachment, returning back a vector of bytes.
diff --git a/src/model/channel/channel_category.rs b/src/model/channel/channel_category.rs
index 119f1f1..c88f7fa 100644
--- a/src/model/channel/channel_category.rs
+++ b/src/model/channel/channel_category.rs
@@ -94,10 +94,7 @@ impl ChannelCategory {
         }
 
         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)),
diff --git a/src/model/channel/channel_id.rs b/src/model/channel/channel_id.rs
index a8e16ef..e5dad79 100644
--- a/src/model/channel/channel_id.rs
+++ b/src/model/channel/channel_id.rs
@@ -124,9 +124,7 @@ impl ChannelId {
             .map(|message_id| message_id.0)
             .collect::<Vec<u64>>();
 
-        let map = json!({
-            "messages": ids
-        });
+        let map = json!({ "messages": ids });
 
         http::delete_messages(self.0, &map)
     }
@@ -256,13 +254,12 @@ impl ChannelId {
     /// [Read Message History]: permissions/constant.READ_MESSAGE_HISTORY.html
     #[inline]
     pub fn message<M: Into<MessageId>>(&self, message_id: M) -> Result<Message> {
-        http::get_message(self.0, message_id.into().0).map(
-            |mut msg| {
+        http::get_message(self.0, message_id.into().0)
+            .map(|mut msg| {
                 msg.transform_content();
 
                 msg
-            },
-        )
+            })
     }
 
     /// Gets messages from the channel.
diff --git a/src/model/channel/group.rs b/src/model/channel/group.rs
index 438437c..418ce3a 100644
--- a/src/model/channel/group.rs
+++ b/src/model/channel/group.rs
@@ -5,7 +5,7 @@ use model::*;
 use builder::{CreateMessage, GetMessages};
 #[cfg(feature = "model")]
 use http::{self, AttachmentType};
-#[cfg(feature="model")]
+#[cfg(feature = "model")]
 use internal::RwLockExt;
 #[cfg(feature = "model")]
 use std::borrow::Cow;
@@ -125,11 +125,8 @@ impl Group {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.channel_id.delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.channel_id
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -247,12 +244,8 @@ impl Group {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Removes a recipient from the group. If the recipient is already not in
diff --git a/src/model/channel/guild_channel.rs b/src/model/channel/guild_channel.rs
index e75ba60..20e5d41 100644
--- a/src/model/channel/guild_channel.rs
+++ b/src/model/channel/guild_channel.rs
@@ -313,10 +313,7 @@ impl GuildChannel {
         }
 
         let mut map = Map::new();
-        map.insert(
-            "name".to_owned(),
-            Value::String(self.name.clone()),
-        );
+        map.insert("name".to_owned(), Value::String(self.name.clone()));
         map.insert(
             "position".to_owned(),
             Value::Number(Number::from(self.position)),
@@ -545,12 +542,8 @@ impl GuildChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Sends a message with just the given message content in the channel.
diff --git a/src/model/channel/message.rs b/src/model/channel/message.rs
index 1edc9a1..d36d290 100644
--- a/src/model/channel/message.rs
+++ b/src/model/channel/message.rs
@@ -292,10 +292,9 @@ impl Message {
         }
 
         // And finally replace everyone and here mentions.
-        result.replace("@everyone", "@\u{200B}everyone").replace(
-            "@here",
-            "@\u{200B}here",
-        )
+        result
+            .replace("@everyone", "@\u{200B}everyone")
+            .replace("@here", "@\u{200B}here")
     }
 
     /// Gets the list of [`User`]s who have reacted to a [`Message`] with a
@@ -321,12 +320,8 @@ impl Message {
                                 after: Option<U>)
                                 -> Result<Vec<User>>
         where R: Into<ReactionType>, U: Into<UserId> {
-        self.channel_id.reaction_users(
-            self.id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.channel_id
+            .reaction_users(self.id, reaction_type, limit, after)
     }
 
     /// Returns the associated `Guild` for the message if one is in the cache.
@@ -339,9 +334,8 @@ impl Message {
     /// [`guild_id`]: #method.guild_id
     #[cfg(feature = "cache")]
     pub fn guild(&self) -> Option<Arc<RwLock<Guild>>> {
-        self.guild_id().and_then(|guild_id| {
-            CACHE.read().unwrap().guild(guild_id)
-        })
+        self.guild_id()
+            .and_then(|guild_id| CACHE.read().unwrap().guild(guild_id))
     }
 
     /// Retrieves the Id of the guild that the message was sent in, if sent in
@@ -361,8 +355,7 @@ impl Message {
     #[cfg(feature = "cache")]
     pub fn is_private(&self) -> bool {
         match CACHE.read().unwrap().channel(self.channel_id) {
-            Some(Channel::Group(_)) |
-            Some(Channel::Private(_)) => true,
+            Some(Channel::Group(_)) | Some(Channel::Private(_)) => true,
             _ => false,
         }
     }
@@ -379,7 +372,11 @@ impl Message {
         let count = content.chars().count() as i64;
         let diff = count - (constants::MESSAGE_CODE_LIMIT as i64);
 
-        if diff > 0 { Some(diff as u64) } else { None }
+        if diff > 0 {
+            Some(diff as u64)
+        } else {
+            None
+        }
     }
 
     /// Pins this message to its channel.
diff --git a/src/model/channel/mod.rs b/src/model/channel/mod.rs
index 824aea7..33912f1 100644
--- a/src/model/channel/mod.rs
+++ b/src/model/channel/mod.rs
@@ -130,11 +130,8 @@ impl Channel {
                                  reaction_type: R)
                                  -> Result<()>
         where M: Into<MessageId>, R: Into<ReactionType> {
-        self.id().delete_reaction(
-            message_id,
-            user_id,
-            reaction_type,
-        )
+        self.id()
+            .delete_reaction(message_id, user_id, reaction_type)
     }
 
     /// Edits a [`Message`] in the channel given its Id.
@@ -237,12 +234,8 @@ impl Channel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id().reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id()
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Retrieves the Id of the inner [`Group`], [`GuildChannel`], or
@@ -348,26 +341,18 @@ 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)
-            },
-            4 => {
-                serde_json::from_value::<ChannelCategory>(Value::Object(v))
-                    .map(|x| Channel::Category(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),
+            4 => serde_json::from_value::<ChannelCategory>(Value::Object(v))
+                .map(|x| Channel::Category(Arc::new(RwLock::new(x))))
+                .map_err(DeError::custom),
             _ => Err(DeError::custom("Unknown channel type")),
         }
     }
@@ -445,10 +430,8 @@ impl ChannelType {
 struct PermissionOverwriteData {
     allow: Permissions,
     deny: Permissions,
-    #[serde(deserialize_with = "deserialize_u64")]
-    id: u64,
-    #[serde(rename = "type")]
-    kind: String,
+    #[serde(deserialize_with = "deserialize_u64")] id: u64,
+    #[serde(rename = "type")] kind: String,
 }
 
 /// A channel-specific permission overwrite for a member or role.
diff --git a/src/model/channel/private_channel.rs b/src/model/channel/private_channel.rs
index a51ba09..dab3bc5 100644
--- a/src/model/channel/private_channel.rs
+++ b/src/model/channel/private_channel.rs
@@ -7,7 +7,7 @@ use model::*;
 use builder::{CreateMessage, GetMessages};
 #[cfg(feature = "model")]
 use http::AttachmentType;
-#[cfg(feature="model")]
+#[cfg(feature = "model")]
 use internal::RwLockExt;
 
 /// A Direct Message text channel with another user.
@@ -193,12 +193,8 @@ impl PrivateChannel {
                                    after: Option<U>)
                                    -> Result<Vec<User>>
         where M: Into<MessageId>, R: Into<ReactionType>, U: Into<UserId> {
-        self.id.reaction_users(
-            message_id,
-            reaction_type,
-            limit,
-            after,
-        )
+        self.id
+            .reaction_users(message_id, reaction_type, limit, after)
     }
 
     /// Pins a [`Message`] to the channel.
diff --git a/src/model/channel/reaction.rs b/src/model/channel/reaction.rs
index 44e1db6..605ac7f 100644
--- a/src/model/channel/reaction.rs
+++ b/src/model/channel/reaction.rs
@@ -46,8 +46,7 @@ impl Reaction {
     /// [Manage Messages]: permissions/constant.MANAGE_MESSAGES.html
     /// [permissions]: permissions
     pub fn delete(&self) -> Result<()> {
-        let user_id =
-            feature_cache! {
+        let user_id = feature_cache! {
             {
                 let user = if self.user_id == CACHE.read().unwrap().user.id {
                     None
diff --git a/src/model/event.rs b/src/model/event.rs
index f17ed53..6e54a25 100644
--- a/src/model/event.rs
+++ b/src/model/event.rs
@@ -82,9 +82,8 @@ impl CacheUpdate for ChannelCreateEvent {
                     .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)
             },
@@ -109,12 +108,10 @@ impl CacheUpdate for ChannelCreateEvent {
                 let ch = cache.private_channels.insert(id, channel.clone());
                 ch.map(Channel::Private)
             },
-            Channel::Category(ref category) => {
-                cache
-                    .categories
-                    .insert(category.read().unwrap().id, category.clone())
-                    .map(Channel::Category)
-            },
+            Channel::Category(ref category) => cache
+                .categories
+                .insert(category.read().unwrap().id, category.clone())
+                .map(Channel::Category),
         }
     }
 }
@@ -135,9 +132,10 @@ impl CacheUpdate for ChannelDeleteEvent {
 
                 cache.channels.remove(&channel_id);
 
-                cache.guilds.get_mut(&guild_id).and_then(|guild| {
-                    guild.with_mut(|g| g.channels.remove(&channel_id))
-                });
+                cache
+                    .guilds
+                    .get_mut(&guild_id)
+                    .and_then(|guild| guild.with_mut(|g| g.channels.remove(&channel_id)));
             },
             Channel::Category(ref category) => {
                 let channel_id = category.with(|cat| cat.id);
@@ -146,8 +144,7 @@ impl CacheUpdate for ChannelDeleteEvent {
             },
             // 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!(),
         };
 
         None
@@ -190,9 +187,9 @@ impl CacheUpdate for ChannelPinsUpdateEvent {
         }
 
         if let Some(group) = cache.groups.get_mut(&self.channel_id) {
-            group.with_mut(
-                |c| { c.last_pin_timestamp = self.last_pin_timestamp; },
-            );
+            group.with_mut(|c| {
+                c.last_pin_timestamp = self.last_pin_timestamp;
+            });
 
             return None;
         }
@@ -285,9 +282,8 @@ impl CacheUpdate for ChannelUpdateEvent {
 
                 cache.channels.insert(channel_id, channel.clone());
                 cache.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) => {
@@ -297,11 +293,10 @@ impl CacheUpdate for ChannelUpdateEvent {
                     .map(|private| private.clone_from(channel));
             },
             Channel::Category(ref category) => {
-                cache.categories.get_mut(&category.read().unwrap().id).map(
-                    |c| {
-                        c.clone_from(category)
-                    },
-                );
+                cache
+                    .categories
+                    .get_mut(&category.read().unwrap().id)
+                    .map(|c| c.clone_from(category));
             },
         }
 
@@ -352,10 +347,9 @@ impl CacheUpdate for GuildCreateEvent {
         }
 
         cache.channels.extend(guild.channels.clone());
-        cache.guilds.insert(
-            self.guild.id,
-            Arc::new(RwLock::new(guild)),
-        );
+        cache
+            .guilds
+            .insert(self.guild.id, Arc::new(RwLock::new(guild)));
 
         None
     }
@@ -400,8 +394,7 @@ 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,
 }
 
@@ -463,9 +456,8 @@ 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)?,
         })
     }
 }
@@ -578,9 +570,8 @@ 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));
@@ -614,10 +605,11 @@ impl CacheUpdate for GuildRoleCreateEvent {
 
     fn update(&mut self, cache: &mut Cache) -> Option<()> {
         cache.guilds.get_mut(&self.guild_id).map(|guild| {
-            guild.write().unwrap().roles.insert(
-                self.role.id,
-                self.role.clone(),
-            )
+            guild
+                .write()
+                .unwrap()
+                .roles
+                .insert(self.role.id, self.role.clone())
         });
 
         None
@@ -635,9 +627,10 @@ impl CacheUpdate for GuildRoleDeleteEvent {
     type Output = Role;
 
     fn update(&mut self, cache: &mut Cache) -> Option<Self::Output> {
-        cache.guilds.get_mut(&self.guild_id).and_then(|guild| {
-            guild.with_mut(|g| g.roles.remove(&self.role_id))
-        })
+        cache
+            .guilds
+            .get_mut(&self.guild_id)
+            .and_then(|guild| guild.with_mut(|g| g.roles.remove(&self.role_id)))
     }
 }
 
@@ -654,9 +647,9 @@ impl CacheUpdate for GuildRoleUpdateEvent {
     fn update(&mut self, cache: &mut Cache) -> Option<Self::Output> {
         cache.guilds.get_mut(&self.guild_id).and_then(|guild| {
             guild.with_mut(|g| {
-                g.roles.get_mut(&self.role.id).map(|role| {
-                    mem::replace(role, self.role.clone())
-                })
+                g.roles
+                    .get_mut(&self.role.id)
+                    .map(|role| mem::replace(role, self.role.clone()))
             })
         })
     }
@@ -664,8 +657,7 @@ impl CacheUpdate for GuildRoleUpdateEvent {
 
 #[derive(Clone, Debug, Deserialize)]
 pub struct GuildUnavailableEvent {
-    #[serde(rename = "id")]
-    pub guild_id: GuildId,
+    #[serde(rename = "id")] pub guild_id: GuildId,
 }
 
 #[cfg(feature = "cache")]
@@ -737,8 +729,7 @@ 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)]
@@ -787,19 +778,17 @@ impl CacheUpdate for PresenceUpdateEvent {
                 if self.presence.status == OnlineStatus::Offline {
                     guild.presences.remove(&self.presence.user_id);
                 } else {
-                    guild.presences.insert(
-                        self.presence.user_id,
-                        self.presence.clone(),
-                    );
+                    guild
+                        .presences
+                        .insert(self.presence.user_id, self.presence.clone());
                 }
             }
         } else if self.presence.status == OnlineStatus::Offline {
             cache.presences.remove(&self.presence.user_id);
         } else {
-            cache.presences.insert(
-                self.presence.user_id,
-                self.presence.clone(),
-            );
+            cache
+                .presences
+                .insert(self.presence.user_id, self.presence.clone());
         }
 
         None
@@ -811,24 +800,17 @@ 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,
@@ -960,8 +942,7 @@ 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)]
@@ -1035,10 +1016,9 @@ impl CacheUpdate for VoiceStateUpdateEvent {
                         }
                     }
 
-                    guild.voice_states.insert(
-                        self.voice_state.user_id,
-                        self.voice_state.clone(),
-                    );
+                    guild
+                        .voice_states
+                        .insert(self.voice_state.user_id, self.voice_state.clone());
                 } else {
                     // Remove the user from the voice state list
                     guild.voice_states.remove(&self.voice_state.user_id);
@@ -1062,9 +1042,8 @@ 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)?,
         })
     }
 }
@@ -1412,20 +1391,16 @@ 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 1b3a40b..4edf0b8 100644
--- a/src/model/gateway.rs
+++ b/src/model/gateway.rs
@@ -106,9 +106,8 @@ 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,
@@ -174,9 +173,8 @@ 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 {
@@ -190,11 +188,8 @@ 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") {
@@ -202,11 +197,8 @@ 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")
@@ -229,15 +221,13 @@ 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 962b145..d019b61 100644
--- a/src/model/guild/audit_log.rs
+++ b/src/model/guild/audit_log.rs
@@ -91,12 +91,9 @@ 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)]
@@ -180,8 +177,7 @@ 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/integration.rs b/src/model/guild/integration.rs
index 18da39d..b903a2c 100644
--- a/src/model/guild/integration.rs
+++ b/src/model/guild/integration.rs
@@ -6,8 +6,7 @@ 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 fcd2ccd..3e8ae64 100644
--- a/src/model/guild/member.rs
+++ b/src/model/guild/member.rs
@@ -168,9 +168,10 @@ 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.
@@ -178,9 +179,10 @@ 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.
@@ -246,11 +248,12 @@ impl Member {
         {
             let req = permissions::KICK_MEMBERS;
 
-            let has_perms = CACHE.read().unwrap().guilds.get(&self.guild_id).map(
-                |guild| {
-                    guild.read().unwrap().has_perms(req)
-                },
-            );
+            let has_perms = CACHE
+                .read()
+                .unwrap()
+                .guilds
+                .get(&self.guild_id)
+                .map(|guild| guild.read().unwrap().has_perms(req));
 
             if let Some(Ok(false)) = has_perms {
                 return Err(Error::Model(ModelError::InvalidPermissions(req)));
@@ -294,10 +297,10 @@ impl Member {
             None => return Err(From::from(ModelError::ItemMissing)),
         };
 
-        Ok(guild.permissions_for(
-            default_channel.id,
-            self.user.read().unwrap().id,
-        ))
+        Ok(
+            guild
+                .permissions_for(default_channel.id, 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 b4b0461..b668875 100644
--- a/src/model/guild/mod.rs
+++ b/src/model/guild/mod.rs
@@ -168,10 +168,7 @@ 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())
@@ -607,9 +604,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's icon, if one exists.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
     }
 
     /// Gets all integration of the guild.
@@ -687,10 +684,8 @@ impl Guild {
 
         for (&id, member) in &self.members {
             match self.presences.get(&id) {
-                Some(presence) => {
-                    if status == presence.status {
-                        members.push(member);
-                    }
+                Some(presence) => if status == presence.status {
+                    members.push(member);
                 },
                 None => continue,
             }
@@ -777,9 +772,11 @@ impl Guild {
         let everyone = match self.roles.get(&RoleId(self.id.0)) {
             Some(everyone) => everyone,
             None => {
-                error!("(╯°□°）╯︵ ┻━┻ @everyone role ({}) missing in '{}'",
-                self.id,
-                self.name);
+                error!(
+                    "(╯°□°）╯︵ ┻━┻ @everyone role ({}) missing in '{}'",
+                    self.id,
+                    self.name
+                );
 
                 return Permissions::empty();
             },
@@ -797,10 +794,12 @@ impl Guild {
             if let Some(role) = self.roles.get(&role) {
                 permissions |= role.permissions;
             } else {
-                warn!("(╯°□°）╯︵ ┻━┻ {} on {} has non-existent role {:?}",
-                member.user.read().unwrap().id,
-                self.id,
-                role);
+                warn!(
+                    "(╯°□°）╯︵ ┻━┻ {} on {} has non-existent role {:?}",
+                    member.user.read().unwrap().id,
+                    self.id,
+                    role
+                );
             }
         }
 
@@ -814,8 +813,8 @@ impl Guild {
 
             // If this is a text channel, then throw out voice permissions.
             if channel.kind == ChannelType::Text {
-                permissions &= !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS |
-                                 USE_VAD);
+                permissions &=
+                    !(CONNECT | SPEAK | MUTE_MEMBERS | DEAFEN_MEMBERS | MOVE_MEMBERS | USE_VAD);
             }
 
             // Apply the permission overwrites for the channel for each of the
@@ -845,9 +844,11 @@ impl Guild {
                 permissions = (permissions & !overwrite.deny) | overwrite.allow;
             }
         } else {
-            warn!("(╯°□°）╯︵ ┻━┻ Guild {} does not contain channel {}",
-            self.id,
-            channel_id);
+            warn!(
+                "(╯°□°）╯︵ ┻━┻ Guild {} does not contain channel {}",
+                self.id,
+                channel_id
+            );
         }
 
         // The default channel is always readable.
@@ -941,9 +942,9 @@ impl Guild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon.as_ref().map(
-            |icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon),
-        )
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
     }
 
     /// Starts an integration sync for the given integration Id.
@@ -1057,18 +1058,16 @@ 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)));
                     }
                 }
             }
@@ -1076,21 +1075,16 @@ 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")
@@ -1242,9 +1236,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))
     }
 }
 
@@ -1264,9 +1258,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 02cdbf5..cb2f8ef 100644
--- a/src/model/guild/partial_guild.rs
+++ b/src/model/guild/partial_guild.rs
@@ -16,16 +16,14 @@ 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,
 }
@@ -301,9 +299,9 @@ impl PartialGuild {
 
     /// Returns a formatted URL of the guild's icon, if the guild has an icon.
     pub fn icon_url(&self) -> Option<String> {
-        self.icon.as_ref().map(|icon| {
-            format!(cdn!("/icons/{}/{}.webp"), self.id, icon)
-        })
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/icons/{}/{}.webp"), self.id, icon))
     }
 
     /// Gets all integration of the guild.
@@ -403,9 +401,9 @@ impl PartialGuild {
 
     /// Returns the formatted URL of the guild's splash image, if one exists.
     pub fn splash_url(&self) -> Option<String> {
-        self.icon.as_ref().map(|icon| {
-            format!(cdn!("/splashes/{}/{}.webp"), self.id, icon)
-        })
+        self.icon
+            .as_ref()
+            .map(|icon| format!(cdn!("/splashes/{}/{}.webp"), self.id, icon))
     }
 
     /// Starts an integration sync for the given integration Id.
diff --git a/src/model/guild/role.rs b/src/model/guild/role.rs
index 4b61736..e097311 100644
--- a/src/model/guild/role.rs
+++ b/src/model/guild/role.rs
@@ -93,9 +93,8 @@ impl Role {
     /// [Manage Roles]: permissions/constant.MANAGE_ROLES.html
     #[cfg(all(feature = "builder", feature = "cache"))]
     pub fn edit<F: FnOnce(EditRole) -> EditRole>(&self, f: F) -> Result<Role> {
-        self.find_guild().and_then(
-            |guild_id| guild_id.edit_role(self.id, f),
-        )
+        self.find_guild()
+            .and_then(|guild_id| guild_id.edit_role(self.id, f))
     }
 
     /// Searches the cache for the guild that owns the role.
diff --git a/src/model/invite.rs b/src/model/invite.rs
index 66196ed..4c5aa28 100644
--- a/src/model/invite.rs
+++ b/src/model/invite.rs
@@ -152,8 +152,7 @@ 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 0584018..af49a76 100644
--- a/src/model/misc.rs
+++ b/src/model/misc.rs
@@ -242,11 +242,9 @@ 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 d512ffb..b5ffc69 100644
--- a/src/model/mod.rs
+++ b/src/model/mod.rs
@@ -198,41 +198,26 @@ 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 {
diff --git a/src/model/user.rs b/src/model/user.rs
index c65a860..fb6acf0 100644
--- a/src/model/user.rs
+++ b/src/model/user.rs
@@ -25,14 +25,11 @@ 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,
 }
 
@@ -88,10 +85,7 @@ 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()));
@@ -116,9 +110,8 @@ 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.
@@ -326,16 +319,11 @@ 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 {
@@ -489,8 +477,7 @@ impl User {
             return Err(Error::Model(ModelError::MessagingBot));
         }
 
-        let private_channel_id =
-            feature_cache! {
+        let private_channel_id = feature_cache! {
             {
                 let finding = {
                     let cache = CACHE.read().unwrap();
@@ -559,9 +546,8 @@ impl User {
     /// [`avatar_url`]: #method.avatar_url
     /// [`default_avatar_url`]: #method.default_avatar_url
     pub fn face(&self) -> String {
-        self.avatar_url().unwrap_or_else(
-            || self.default_avatar_url(),
-        )
+        self.avatar_url()
+            .unwrap_or_else(|| self.default_avatar_url())
     }
 
     /// Check if a user has a [`Role`]. This will retrieve the [`Guild`] from
@@ -807,9 +793,7 @@ 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 c90ce46..719a472 100644
--- a/src/model/utils.rs
+++ b/src/model/utils.rs
@@ -157,9 +157,7 @@ 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::Category(_) => {
+        Channel::Group(_) | Channel::Private(_) | Channel::Category(_) => {
             // Both users in DMs, and all users in groups and maybe all channels in categories will
             // have the same
             // permissions.
@@ -179,10 +177,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 39099e0..5e10d90 100644
--- a/src/model/webhook.rs
+++ b/src/model/webhook.rs
@@ -118,10 +118,7 @@ impl Webhook {
         }
 
         if let Some(name) = name {
-            map.insert(
-                "name".to_owned(),
-                Value::String(name.to_owned()),
-            );
+            map.insert("name".to_owned(), Value::String(name.to_owned()));
         }
 
         match http::edit_webhook_with_token(self.id.0, &self.token, &map) {
diff --git a/src/utils/message_builder.rs b/src/utils/message_builder.rs
index 8f13db2..2f714ec 100644
--- a/src/utils/message_builder.rs
+++ b/src/utils/message_builder.rs
@@ -852,8 +852,11 @@ 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/connection.rs b/src/voice/connection.rs
index 7f2ac23..620f19e 100644
--- a/src/voice/connection.rs
+++ b/src/voice/connection.rs
@@ -1,6 +1,11 @@
 use byteorder::{BigEndian, LittleEndian, ReadBytesExt, WriteBytesExt};
-use opus::{Application as CodingMode, Channels, Decoder as OpusDecoder, Encoder as OpusEncoder,
-           packet as opus_packet};
+use opus::{
+    packet as opus_packet,
+    Application as CodingMode,
+    Channels,
+    Decoder as OpusDecoder,
+    Encoder as OpusEncoder,
+};
 use sodiumoxide::crypto::secretbox::{self, Key, Nonce};
 use std::collections::HashMap;
 use std::io::Write;
@@ -11,7 +16,7 @@ use std::thread::{self, Builder as ThreadBuilder, JoinHandle};
 use std::time::Duration;
 use super::audio::{AudioReceiver, AudioSource, AudioType, HEADER_LEN, SAMPLE_RATE};
 use super::connection_info::ConnectionInfo;
-use super::{CRYPTO_MODE, VoiceError, payload};
+use super::{payload, VoiceError, CRYPTO_MODE};
 use websocket::client::Url as WebsocketUrl;
 use websocket::sync::client::ClientBuilder;
 use websocket::sync::stream::{AsTcpStream, TcpStream, TlsStream};
@@ -110,27 +115,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)?;
@@ -178,21 +183,17 @@ 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)?;
 
@@ -200,13 +201,8 @@ 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)) => {
@@ -227,9 +223,10 @@ 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
@@ -257,14 +254,12 @@ impl Connection {
                 }
 
                 match stream.get_type() {
-                    AudioType::Opus => {
-                        match stream.read_opus_frame() {
-                            Some(frame) => {
-                                opus_frame = frame;
-                                opus_frame.len()
-                            },
-                            None => 0,
-                        }
+                    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 };
@@ -326,23 +321,19 @@ 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 = if opus_frame.is_empty() {
-            self.encoder.encode(
-                &buffer[..buffer_len],
-                &mut packet[HEADER_LEN..sl_index],
-            )?
+            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,
-            );
+            packet[HEADER_LEN..HEADER_LEN + len]
+                .clone_from_slice(opus_frame);
             len
         };
 
@@ -366,11 +357,10 @@ 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))
     }
 }
 
@@ -390,9 +380,8 @@ 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]
@@ -404,9 +393,8 @@ 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/error.rs b/src/voice/error.rs
index a0bb11a..d402e54 100644
--- a/src/voice/error.rs
+++ b/src/voice/error.rs
@@ -8,20 +8,14 @@ use std;
 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`.
diff --git a/src/voice/mod.rs b/src/voice/mod.rs
index 6af5926..70f1ae2 100644
--- a/src/voice/mod.rs
+++ b/src/voice/mod.rs
@@ -24,8 +24,7 @@ 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 cf62d27..4702bdb 100644
--- a/src/voice/streamer.rs
+++ b/src/voice/streamer.rs
@@ -65,12 +65,10 @@ impl<R: Read + Send> AudioSource for InputSource<R> {
 
                 Some(frame)
             },
-            Err(ref e) => {
-                if e.kind() == IoErrorKind::UnexpectedEof {
-                    Some(Vec::new())
-                } else {
-                    None
-                }
+            Err(ref e) => if e.kind() == IoErrorKind::UnexpectedEof {
+                Some(Vec::new())
+            } else {
+                None
             },
         }
     }
@@ -194,11 +192,9 @@ 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)))),
     };
@@ -224,9 +220,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)
     });
author	Zeyla Hellyer <[email protected]>	2017-09-18 17:48:52 -0700
committer	Zeyla Hellyer <[email protected]>	2017-09-18 17:48:52 -0700
commit	dae2cb77b407044f44a7a2790d93efba3891854e (patch)
tree	bef263c4490536cf8b56e988e71dd1aa43bc2696 /src
parent	Fix compiles of a variety of feature combinations (diff)
download	serenity-dae2cb77b407044f44a7a2790d93efba3891854e.tar.xz serenity-dae2cb77b407044f44a7a2790d93efba3891854e.zip