Change the config a bit, and a few nitpicks

2 files changed, 680 insertions, 439 deletions

diff --git a/src/http/mod.rs b/src/http/mod.rs
index fcf2331..0efea78 100644
--- a/src/http/mod.rs
+++ b/src/http/mod.rs
@@ -89,12 +89,16 @@ pub fn set_token(token: &str) { TOKEN.lock().unwrap().clone_from(&token.to_owned
 /// [`Group::add_recipient`]: ../model/struct.Group.html#method.add_recipient
 /// [`User`]: ../model/struct.User.html
 pub fn add_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::None,
-                    put,
-                    "/channels/{}/recipients/{}",
-                    group_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::None,
+            put,
+            "/channels/{}/recipients/{}",
+            group_id,
+            user_id
+        ),
+    )
 }
 
 /// Adds a single [`Role`] to a [`Member`] in a [`Guild`].
@@ -107,13 +111,17 @@ pub fn add_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
 /// [`Role`]: ../model/struct.Role.html
 /// [Manage Roles]: ../model/permissions/constant.MANAGE_ROLES.html
 pub fn add_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersIdRolesId(guild_id),
-                    put,
-                    "/guilds/{}/members/{}/roles/{}",
-                    guild_id,
-                    user_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersIdRolesId(guild_id),
+            put,
+            "/guilds/{}/members/{}/roles/{}",
+            guild_id,
+            user_id,
+            role_id
+        ),
+    )
 }
 
 /// Bans a [`User`] from a [`Guild`], removing their messages sent in the last
@@ -128,14 +136,18 @@ pub fn add_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()>
 /// [`User`]: ../model/struct.User.html
 /// [Ban Members]: ../model/permissions/constant.BAN_MEMBERS.html
 pub fn ban_user(guild_id: u64, user_id: u64, delete_message_days: u8, reason: &str) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdBansUserId(guild_id),
-                    put,
-                    "/guilds/{}/bans/{}?delete_message_days={}&reason={}",
-                    guild_id,
-                    user_id,
-                    delete_message_days,
-                    reason))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdBansUserId(guild_id),
+            put,
+            "/guilds/{}/bans/{}?delete_message_days={}&reason={}",
+            guild_id,
+            user_id,
+            delete_message_days,
+            reason
+        ),
+    )
 }
 
 /// Broadcasts that the current user is typing in the given [`Channel`].
@@ -148,11 +160,15 @@ pub fn ban_user(guild_id: u64, user_id: u64, delete_message_days: u8, reason: &s
 ///
 /// [`Channel`]: ../model/enum.Channel.html
 pub fn broadcast_typing(channel_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdTyping(channel_id),
-                    post,
-                    "/channels/{}/typing",
-                    channel_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdTyping(channel_id),
+            post,
+            "/channels/{}/typing",
+            channel_id
+        ),
+    )
 }
 
 /// Creates a [`GuildChannel`] in the [`Guild`] given its Id.
@@ -167,12 +183,15 @@ pub fn broadcast_typing(channel_id: u64) -> Result<()> {
 /// [Manage Channels]: ../model/permissions/constant.MANAGE_CHANNELS.html
 pub fn create_channel(guild_id: u64, map: &Value) -> Result<GuildChannel> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdChannels(guild_id),
-                            post(body),
-                            "/guilds/{}/channels",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildChannel>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdChannels(guild_id),
+        post(body),
+        "/guilds/{}/channels",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildChannel>(response)
+        .map_err(From::from)
 }
 
 /// Creates an emoji in the given [`Guild`] with the given data.
@@ -187,12 +206,15 @@ pub fn create_channel(guild_id: u64, map: &Value) -> Result<GuildChannel> {
 /// [Manage Emojis]: ../model/permissions/constant.MANAGE_EMOJIS.html
 pub fn create_emoji(guild_id: u64, map: &Value) -> Result<Emoji> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmojis(guild_id),
-                            post(body),
-                            "/guilds/{}/emojis",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojis(guild_id),
+        post(body),
+        "/guilds/{}/emojis",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Creates a guild with the data provided.
@@ -235,7 +257,8 @@ pub fn create_guild(map: &Value) -> Result<PartialGuild> {
     let body = map.to_string();
     let response = request!(Route::Guilds, post(body), "/guilds");
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Creates an [`Integration`] for a [`Guild`].
@@ -251,12 +274,16 @@ pub fn create_guild(map: &Value) -> Result<PartialGuild> {
 pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::GuildsIdIntegrations(guild_id),
-                    post(body),
-                    "/guilds/{}/integrations/{}",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrations(guild_id),
+            post(body),
+            "/guilds/{}/integrations/{}",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Creates a [`RichInvite`] for the given [channel][`GuildChannel`].
@@ -273,24 +300,31 @@ pub fn create_guild_integration(guild_id: u64, integration_id: u64, map: &Value)
 /// [docs]: https://discordapp.com/developers/docs/resources/channel#create-channel-invite
 pub fn create_invite(channel_id: u64, map: &JsonMap) -> Result<RichInvite> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::ChannelsIdInvites(channel_id),
-                            post(body),
-                            "/channels/{}/invites",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, RichInvite>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdInvites(channel_id),
+        post(body),
+        "/channels/{}/invites",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, RichInvite>(response)
+        .map_err(From::from)
 }
 
 /// Creates a permission override for a member or a role in a channel.
 pub fn create_permission(channel_id: u64, target_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::ChannelsIdPermissionsOverwriteId(channel_id),
-                    put(body),
-                    "/channels/{}/permissions/{}",
-                    channel_id,
-                    target_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPermissionsOverwriteId(channel_id),
+            put(body),
+            "/channels/{}/permissions/{}",
+            channel_id,
+            target_id
+        ),
+    )
 }
 
 /// Creates a private channel with a user.
@@ -298,7 +332,8 @@ pub fn create_private_channel(map: &Value) -> Result<PrivateChannel> {
     let body = map.to_string();
     let response = request!(Route::UsersMeChannels, post(body), "/users/@me/channels");
 
-    serde_json::from_reader::<HyperResponse, PrivateChannel>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PrivateChannel>(response)
+        .map_err(From::from)
 }
 
 /// Reacts to a message.
@@ -306,24 +341,31 @@ pub fn create_reaction(channel_id: u64,
                        message_id: u64,
                        reaction_type: &ReactionType)
                        -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                    put,
-                    "/channels/{}/messages/{}/reactions/{}/@me",
-                    channel_id,
-                    message_id,
-                    reaction_type.as_data()))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+            put,
+            "/channels/{}/messages/{}/reactions/{}/@me",
+            channel_id,
+            message_id,
+            reaction_type.as_data()
+        ),
+    )
 }
 
 /// Creates a role.
 pub fn create_role(guild_id: u64, map: &JsonMap) -> Result<Role> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsIdRoles(guild_id),
-                            post(body),
-                            "/guilds/{}/roles",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Role>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRoles(guild_id),
+        post(body),
+        "/guilds/{}/roles",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Role>(response)
+        .map_err(From::from)
 }
 
 /// Creates a webhook for the given [channel][`GuildChannel`]'s Id, passing in
@@ -358,78 +400,102 @@ pub fn create_role(guild_id: u64, map: &JsonMap) -> Result<Role> {
 /// [`GuildChannel`]: ../model/struct.GuildChannel.html
 pub fn create_webhook(channel_id: u64, map: &Value) -> Result<Webhook> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdWebhooks(channel_id),
-                            post(body),
-                            "/channels/{}/webhooks",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdWebhooks(channel_id),
+        post(body),
+        "/channels/{}/webhooks",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Deletes a private channel or a channel in a guild.
 pub fn delete_channel(channel_id: u64) -> Result<Channel> {
-    let response = request!(Route::ChannelsId(channel_id),
-                            delete,
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Channel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        delete,
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Channel>(response)
+        .map_err(From::from)
 }
 
 /// Deletes an emoji from a server.
 pub fn delete_emoji(guild_id: u64, emoji_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdEmojisId(guild_id),
-                    delete,
-                    "/guilds/{}/emojis/{}",
-                    guild_id,
-                    emoji_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdEmojisId(guild_id),
+            delete,
+            "/guilds/{}/emojis/{}",
+            guild_id,
+            emoji_id
+        ),
+    )
 }
 
 /// Deletes a guild, only if connected account owns it.
 pub fn delete_guild(guild_id: u64) -> Result<PartialGuild> {
     let response = request!(Route::GuildsId(guild_id), delete, "/guilds/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Remvoes an integration from a guild.
 pub fn delete_guild_integration(guild_id: u64, integration_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdIntegrationsId(guild_id),
-                    delete,
-                    "/guilds/{}/integrations/{}",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrationsId(guild_id),
+            delete,
+            "/guilds/{}/integrations/{}",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Deletes an invite by code.
 pub fn delete_invite(code: &str) -> Result<Invite> {
     let response = request!(Route::InvitesCode, delete, "/invites/{}", code);
 
-    serde_json::from_reader::<HyperResponse, Invite>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Invite>(response)
+        .map_err(From::from)
 }
 
 /// Deletes a message if created by us or we have
 /// specific permissions.
 pub fn delete_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesId(LightMethod::Delete, channel_id),
-                    delete,
-                    "/channels/{}/messages/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesId(LightMethod::Delete, channel_id),
+            delete,
+            "/channels/{}/messages/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Deletes a bunch of messages, only works for bots.
 pub fn delete_messages(channel_id: u64, map: &Value) -> Result<()> {
     let body = map.to_string();
 
-    verify(204,
-           request!(Route::ChannelsIdMessagesBulkDelete(channel_id),
-                    post(body),
-                    "/channels/{}/messages/bulk_delete",
-                    channel_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesBulkDelete(channel_id),
+            post(body),
+            "/channels/{}/messages/bulk_delete",
+            channel_id
+        ),
+    )
 }
 
 /// Deletes all of the [`Reaction`]s associated with a [`Message`].
@@ -450,22 +516,30 @@ pub fn delete_messages(channel_id: u64, map: &Value) -> Result<()> {
 /// [`Message`]: ../model/struct.Message.html
 /// [`Reaction`]: ../model/struct.Reaction.html
 pub fn delete_message_reactions(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactions(channel_id),
-                    delete,
-                    "/channels/{}/messages/{}/reactions",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactions(channel_id),
+            delete,
+            "/channels/{}/messages/{}/reactions",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Deletes a permission override from a role or a member in a channel.
 pub fn delete_permission(channel_id: u64, target_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPermissionsOverwriteId(channel_id),
-                    delete,
-                    "/channels/{}/permissions/{}",
-                    channel_id,
-                    target_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPermissionsOverwriteId(channel_id),
+            delete,
+            "/channels/{}/permissions/{}",
+            channel_id,
+            target_id
+        ),
+    )
 }
 
 /// Deletes a reaction from a message if owned by us or
@@ -479,24 +553,32 @@ pub fn delete_reaction(channel_id: u64,
         .map(|uid| uid.to_string())
         .unwrap_or_else(|| "@me".to_string());
 
-    verify(204,
-           request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                    delete,
-                    "/channels/{}/messages/{}/reactions/{}/{}",
-                    channel_id,
-                    message_id,
-                    reaction_type.as_data(),
-                    user))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+            delete,
+            "/channels/{}/messages/{}/reactions/{}/{}",
+            channel_id,
+            message_id,
+            reaction_type.as_data(),
+            user
+        ),
+    )
 }
 
 /// Deletes a role from a server. Can't remove the default everyone role.
 pub fn delete_role(guild_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdRolesId(guild_id),
-                    delete,
-                    "/guilds/{}/roles/{}",
-                    guild_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdRolesId(guild_id),
+            delete,
+            "/guilds/{}/roles/{}",
+            guild_id,
+            role_id
+        ),
+    )
 }
 
 /// Deletes a [`Webhook`] given its Id.
@@ -522,8 +604,10 @@ pub fn delete_role(guild_id: u64, role_id: u64) -> Result<()> {
 /// [`Webhook`]: ../model/struct.Webhook.html
 /// [`delete_webhook_with_token`]: fn.delete_webhook_with_token.html
 pub fn delete_webhook(webhook_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::WebhooksId, delete, "/webhooks/{}", webhook_id))
+    verify(
+        204,
+        request!(Route::WebhooksId, delete, "/webhooks/{}", webhook_id),
+    )
 }
 
 /// Deletes a [`Webhook`] given its Id and unique token.
@@ -547,43 +631,56 @@ pub fn delete_webhook(webhook_id: u64) -> Result<()> {
 pub fn delete_webhook_with_token(webhook_id: u64, token: &str) -> Result<()> {
     let client = request_client!();
 
-    verify(204,
-           retry(|| client.delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token)))
-               .map_err(Error::Hyper)?)
+    verify(
+        204,
+        retry(|| {
+            client
+                .delete(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+        }).map_err(Error::Hyper)?,
+    )
 }
 
 /// Changes channel information.
 pub fn edit_channel(channel_id: u64, map: &JsonMap) -> Result<GuildChannel> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::ChannelsId(channel_id),
-                            patch(body),
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, GuildChannel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        patch(body),
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildChannel>(response)
+        .map_err(From::from)
 }
 
 /// Changes emoji information.
 pub fn edit_emoji(guild_id: u64, emoji_id: u64, map: &Value) -> Result<Emoji> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmojisId(guild_id),
-                            patch(body),
-                            "/guilds/{}/emojis/{}",
-                            guild_id,
-                            emoji_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojisId(guild_id),
+        patch(body),
+        "/guilds/{}/emojis/{}",
+        guild_id,
+        emoji_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Changes guild information.
 pub fn edit_guild(guild_id: u64, map: &JsonMap) -> Result<PartialGuild> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsId(guild_id),
-                            patch(body),
-                            "/guilds/{}",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsId(guild_id),
+        patch(body),
+        "/guilds/{}",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Edits a [`Guild`]'s embed setting.
@@ -591,24 +688,31 @@ pub fn edit_guild(guild_id: u64, map: &JsonMap) -> Result<PartialGuild> {
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn edit_guild_embed(guild_id: u64, map: &Value) -> Result<GuildEmbed> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdEmbed(guild_id),
-                            patch(body),
-                            "/guilds/{}/embed",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildEmbed>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmbed(guild_id),
+        patch(body),
+        "/guilds/{}/embed",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildEmbed>(response)
+        .map_err(From::from)
 }
 
 /// Does specific actions to a member.
 pub fn edit_member(guild_id: u64, user_id: u64, map: &JsonMap) -> Result<()> {
     let body = serde_json::to_string(map)?;
 
-    verify(204,
-           request!(Route::GuildsIdMembersId(guild_id),
-                    patch(body),
-                    "/guilds/{}/members/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersId(guild_id),
+            patch(body),
+            "/guilds/{}/members/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Edits a message by Id.
@@ -616,13 +720,16 @@ pub fn edit_member(guild_id: u64, user_id: u64, map: &JsonMap) -> Result<()> {
 /// **Note**: Only the author of a message can modify it.
 pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Message> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
-                            patch(body),
-                            "/channels/{}/messages/{}",
-                            channel_id,
-                            message_id);
+    let response = request!(
+        Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
+        patch(body),
+        "/channels/{}/messages/{}",
+        channel_id,
+        message_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Edits the current user's nickname for the provided [`Guild`] via its Id.
@@ -633,10 +740,12 @@ pub fn edit_message(channel_id: u64, message_id: u64, map: &Value) -> Result<Mes
 pub fn edit_nickname(guild_id: u64, new_nickname: Option<&str>) -> Result<()> {
     let map = json!({ "nick": new_nickname });
     let body = map.to_string();
-    let response = request!(Route::GuildsIdMembersMeNick(guild_id),
-                            patch(body),
-                            "/guilds/{}/members/@me/nick",
-                            guild_id);
+    let response = request!(
+        Route::GuildsIdMembersMeNick(guild_id),
+        patch(body),
+        "/guilds/{}/members/@me/nick",
+        guild_id
+    );
 
     verify(200, response)
 }
@@ -667,19 +776,23 @@ 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.
 pub fn edit_role(guild_id: u64, role_id: u64, map: &JsonMap) -> Result<Role> {
     let body = serde_json::to_string(map)?;
-    let response = request!(Route::GuildsIdRolesId(guild_id),
-                            patch(body),
-                            "/guilds/{}/roles/{}",
-                            guild_id,
-                            role_id);
-
-    serde_json::from_reader::<HyperResponse, Role>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRolesId(guild_id),
+        patch(body),
+        "/guilds/{}/roles/{}",
+        guild_id,
+        role_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Role>(response)
+        .map_err(From::from)
 }
 
 /// Edits a the webhook with the given data.
@@ -725,7 +838,8 @@ pub fn edit_webhook(webhook_id: u64, map: &Value) -> Result<Webhook> {
     let body = map.to_string();
     let response = request!(Route::WebhooksId, patch(body), "/webhooks/{}", webhook_id);
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Edits the webhook with the given data.
@@ -764,7 +878,8 @@ pub fn edit_webhook_with_token(webhook_id: u64, token: &str, map: &JsonMap) -> R
             .body(&body)
     }).map_err(Error::Hyper)?;
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Executes a webhook, posting a [`Message`] in the webhook's associated
@@ -838,9 +953,16 @@ pub fn execute_webhook(webhook_id: u64,
 
     let response = retry(|| {
         client
-            .post(&format!(api!("/webhooks/{}/{}?wait={}"), webhook_id, token, wait))
+            .post(&format!(
+                api!("/webhooks/{}/{}?wait={}"),
+                webhook_id,
+                token,
+                wait
+            ))
             .body(&body)
-            .header(ContentType(Mime(TopLevel::Application, SubLevel::Json, vec![])))
+            .header(ContentType(
+                Mime(TopLevel::Application, SubLevel::Json, vec![]),
+            ))
     }).map_err(Error::Hyper)?;
 
     if response.status == StatusCode::NoContent {
@@ -858,12 +980,15 @@ pub fn execute_webhook(webhook_id: u64,
 pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
     let client = request_client!();
 
-    let response = retry(|| client.get(status!("/scheduled-maintenances/active.json")))?;
+    let response = retry(|| {
+        client.get(status!("/scheduled-maintenances/active.json"))
+    })?;
 
     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![]),
     }
 }
@@ -874,7 +999,8 @@ pub fn get_active_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_application_info(id: u64) -> Result<ApplicationInfo> {
     let response = request!(Route::None, get, "/oauth2/applications/{}", id);
 
-    serde_json::from_reader::<HyperResponse, ApplicationInfo>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, ApplicationInfo>(response)
+        .map_err(From::from)
 }
 
 /// Gets all oauth2 applications we've made.
@@ -883,44 +1009,55 @@ pub fn get_application_info(id: u64) -> Result<ApplicationInfo> {
 pub fn get_applications() -> Result<Vec<ApplicationInfo>> {
     let response = request!(Route::None, get, "/oauth2/applications");
 
-    serde_json::from_reader::<HyperResponse, Vec<ApplicationInfo>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<ApplicationInfo>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all the users that are banned in specific guild.
 pub fn get_bans(guild_id: u64) -> Result<Vec<Ban>> {
-    let response = request!(Route::GuildsIdBans(guild_id),
-                            get,
-                            "/guilds/{}/bans",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Ban>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdBans(guild_id),
+        get,
+        "/guilds/{}/bans",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Ban>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all audit logs in a specific guild.
 pub fn get_audit_logs(guild_id: u64) -> Result<AuditLogs> {
-    let response = request!(Route::GuildsIdAuditLogs(guild_id),
-                            get,
-                            "/guilds/{}/audit-logs",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, AuditLogs>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdAuditLogs(guild_id),
+        get,
+        "/guilds/{}/audit-logs",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, AuditLogs>(response)
+        .map_err(From::from)
 }
 
 /// Gets current bot gateway.
 pub fn get_bot_gateway() -> Result<BotGateway> {
     let response = request!(Route::GatewayBot, get, "/gateway/bot");
 
-    serde_json::from_reader::<HyperResponse, BotGateway>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, BotGateway>(response)
+        .map_err(From::from)
 }
 
 /// Gets all invites for a channel.
 pub fn get_channel_invites(channel_id: u64) -> Result<Vec<RichInvite>> {
-    let response = request!(Route::ChannelsIdInvites(channel_id),
-                            get,
-                            "/channels/{}/invites",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdInvites(channel_id),
+        get,
+        "/channels/{}/invites",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves the webhooks for the given [channel][`GuildChannel`]'s Id.
@@ -942,32 +1079,41 @@ pub fn get_channel_invites(channel_id: u64) -> Result<Vec<RichInvite>> {
 ///
 /// [`GuildChannel`]: ../model/struct.GuildChannel.html
 pub fn get_channel_webhooks(channel_id: u64) -> Result<Vec<Webhook>> {
-    let response = request!(Route::ChannelsIdWebhooks(channel_id),
-                            get,
-                            "/channels/{}/webhooks",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdWebhooks(channel_id),
+        get,
+        "/channels/{}/webhooks",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response)
+        .map_err(From::from)
 }
 
 /// Gets channel information.
 pub fn get_channel(channel_id: u64) -> Result<Channel> {
-    let response = request!(Route::ChannelsId(channel_id),
-                            get,
-                            "/channels/{}",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Channel>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(channel_id),
+        get,
+        "/channels/{}",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Channel>(response)
+        .map_err(From::from)
 }
 
 /// Gets all channels in a guild.
 pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
-    let response = request!(Route::ChannelsId(guild_id),
-                            get,
-                            "/guilds/{}/channels",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<GuildChannel>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsId(guild_id),
+        get,
+        "/guilds/{}/channels",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<GuildChannel>>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about the current application.
@@ -976,79 +1122,98 @@ pub fn get_channels(guild_id: u64) -> Result<Vec<GuildChannel>> {
 pub fn get_current_application_info() -> Result<CurrentApplicationInfo> {
     let response = request!(Route::None, get, "/oauth2/applications/@me");
 
-    serde_json::from_reader::<HyperResponse, CurrentApplicationInfo>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, CurrentApplicationInfo>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about the user we're connected with.
 pub fn get_current_user() -> Result<CurrentUser> {
     let response = request!(Route::UsersMe, get, "/users/@me");
 
-    serde_json::from_reader::<HyperResponse, CurrentUser>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, CurrentUser>(response)
+        .map_err(From::from)
 }
 
 /// Gets current gateway.
 pub fn get_gateway() -> Result<Gateway> {
     let response = request!(Route::Gateway, get, "/gateway");
 
-    serde_json::from_reader::<HyperResponse, Gateway>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Gateway>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about an emoji.
 pub fn get_emoji(guild_id: u64, emoji_id: u64) -> Result<Emoji> {
-    let response = request!(Route::GuildsIdEmojisId(guild_id),
-                            get,
-                            "/guilds/{}/emojis/{}",
-                            guild_id,
-                            emoji_id);
-
-    serde_json::from_reader::<HyperResponse, Emoji>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojisId(guild_id),
+        get,
+        "/guilds/{}/emojis/{}",
+        guild_id,
+        emoji_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Emoji>(response)
+        .map_err(From::from)
 }
 
 /// Gets all emojis in a guild.
 pub fn get_emojis(guild_id: u64) -> Result<Vec<Emoji>> {
-    let response = request!(Route::GuildsIdEmojis(guild_id),
-                            get,
-                            "/guilds/{}/emojis",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Emoji>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmojis(guild_id),
+        get,
+        "/guilds/{}/emojis",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Emoji>>(response)
+        .map_err(From::from)
 }
 
 /// Gets guild information.
 pub fn get_guild(guild_id: u64) -> Result<PartialGuild> {
     let response = request!(Route::GuildsId(guild_id), get, "/guilds/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, PartialGuild>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, PartialGuild>(response)
+        .map_err(From::from)
 }
 
 /// Gets a guild embed information.
 pub fn get_guild_embed(guild_id: u64) -> Result<GuildEmbed> {
-    let response = request!(Route::GuildsIdEmbed(guild_id),
-                            get,
-                            "/guilds/{}/embeds",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildEmbed>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdEmbed(guild_id),
+        get,
+        "/guilds/{}/embeds",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildEmbed>(response)
+        .map_err(From::from)
 }
 
 /// Gets integrations that a guild has.
 pub fn get_guild_integrations(guild_id: u64) -> Result<Vec<Integration>> {
-    let response = request!(Route::GuildsIdIntegrations(guild_id),
-                            get,
-                            "/guilds/{}/integrations",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Integration>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdIntegrations(guild_id),
+        get,
+        "/guilds/{}/integrations",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Integration>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all invites to a guild.
 pub fn get_guild_invites(guild_id: u64) -> Result<Vec<RichInvite>> {
-    let response = request!(Route::GuildsIdInvites(guild_id),
-                            get,
-                            "/guilds/{}/invites",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdInvites(guild_id),
+        get,
+        "/guilds/{}/invites",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<RichInvite>>(response)
+        .map_err(From::from)
 }
 
 /// Gets the members of a guild. Optionally pass a `limit` and the Id of the
@@ -1057,12 +1222,14 @@ pub fn get_guild_members(guild_id: u64,
                          limit: Option<u64>,
                          after: Option<u64>)
                          -> Result<Vec<Member>> {
-    let response = request!(Route::GuildsIdMembers(guild_id),
-                            get,
-                            "/guilds/{}/members?limit={}&after={}",
-                            guild_id,
-                            limit.unwrap_or(500),
-                            after.unwrap_or(0));
+    let response = request!(
+        Route::GuildsIdMembers(guild_id),
+        get,
+        "/guilds/{}/members?limit={}&after={}",
+        guild_id,
+        limit.unwrap_or(500),
+        after.unwrap_or(0)
+    );
 
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
@@ -1082,12 +1249,15 @@ pub fn get_guild_members(guild_id: u64,
 /// Gets the amount of users that can be pruned.
 pub fn get_guild_prune_count(guild_id: u64, map: &Value) -> Result<GuildPrune> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdPrune(guild_id),
-                            get(body),
-                            "/guilds/{}/prune",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildPrune>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdPrune(guild_id),
+        get(body),
+        "/guilds/{}/prune",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildPrune>(response)
+        .map_err(From::from)
 }
 
 /// Gets regions that a guild can use. If a guild has [`Feature::VipRegions`]
@@ -1095,24 +1265,30 @@ pub fn get_guild_prune_count(guild_id: u64, map: &Value) -> Result<GuildPrune> {
 ///
 /// [`Feature::VipRegions`]: ../model/enum.Feature.html#variant.VipRegions
 pub fn get_guild_regions(guild_id: u64) -> Result<Vec<VoiceRegion>> {
-    let response = request!(Route::GuildsIdRegions(guild_id),
-                            get,
-                            "/guilds/{}/regions",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRegions(guild_id),
+        get,
+        "/guilds/{}/regions",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a list of roles in a [`Guild`].
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn get_guild_roles(guild_id: u64) -> Result<Vec<Role>> {
-    let response = request!(Route::GuildsIdRoles(guild_id),
-                            get,
-                            "/guilds/{}/roles",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Role>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdRoles(guild_id),
+        get,
+        "/guilds/{}/roles",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Role>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves the webhooks for the given [guild][`Guild`]'s Id.
@@ -1134,12 +1310,15 @@ pub fn get_guild_roles(guild_id: u64) -> Result<Vec<Role>> {
 ///
 /// [`Guild`]: ../model/struct.Guild.html
 pub fn get_guild_webhooks(guild_id: u64) -> Result<Vec<Webhook>> {
-    let response = request!(Route::GuildsIdWebhooks(guild_id),
-                            get,
-                            "/guilds/{}/webhooks",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdWebhooks(guild_id),
+        get,
+        "/guilds/{}/webhooks",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Webhook>>(response)
+        .map_err(From::from)
 }
 
 /// Gets a paginated list of the current user's guilds.
@@ -1176,7 +1355,8 @@ pub fn get_guilds(target: &GuildPagination, limit: u64) -> Result<Vec<GuildInfo>
 
     let response = request!(Route::UsersMeGuilds, get, "{}", uri);
 
-    serde_json::from_reader::<HyperResponse, Vec<GuildInfo>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<GuildInfo>>(response)
+        .map_err(From::from)
 }
 
 /// Gets information about a specific invite.
@@ -1197,16 +1377,19 @@ pub fn get_invite(code: &str, stats: bool) -> Result<Invite> {
 
     let response = request!(Route::InvitesCode, get, "{}", uri);
 
-    serde_json::from_reader::<HyperResponse, Invite>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Invite>(response)
+        .map_err(From::from)
 }
 
 /// Gets member of a guild.
 pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
-    let response = request!(Route::GuildsIdMembersId(guild_id),
-                            get,
-                            "/guilds/{}/members/{}",
-                            guild_id,
-                            user_id);
+    let response = request!(
+        Route::GuildsIdMembersId(guild_id),
+        get,
+        "/guilds/{}/members/{}",
+        guild_id,
+        user_id
+    );
 
     let mut v = serde_json::from_reader::<HyperResponse, Value>(response)?;
 
@@ -1219,13 +1402,16 @@ pub fn get_member(guild_id: u64, user_id: u64) -> Result<Member> {
 
 /// Gets a message by an Id, bots only.
 pub fn get_message(channel_id: u64, message_id: u64) -> Result<Message> {
-    let response = request!(Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
-                            get,
-                            "/channels/{}/messages/{}",
-                            channel_id,
-                            message_id);
+    let response = request!(
+        Route::ChannelsIdMessagesId(LightMethod::Any, channel_id),
+        get,
+        "/channels/{}/messages/{}",
+        channel_id,
+        message_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Gets X messages from a channel.
@@ -1235,17 +1421,21 @@ pub fn get_messages(channel_id: u64, query: &str) -> Result<Vec<Message>> {
 
     let response = request(Route::ChannelsIdMessages(channel_id), || client.get(&url))?;
 
-    serde_json::from_reader::<HyperResponse, Vec<Message>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<Message>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all pins of a channel.
 pub fn get_pins(channel_id: u64) -> Result<Vec<Message>> {
-    let response = request!(Route::ChannelsIdPins(channel_id),
-                            get,
-                            "/channels/{}/pins",
-                            channel_id);
-
-    serde_json::from_reader::<HyperResponse, Vec<Message>>(response).map_err(From::from)
+    let response = request!(
+        Route::ChannelsIdPins(channel_id),
+        get,
+        "/channels/{}/pins",
+        channel_id
+    );
+
+    serde_json::from_reader::<HyperResponse, Vec<Message>>(response)
+        .map_err(From::from)
 }
 
 /// Gets user Ids based on their reaction to a message. This endpoint is dumb.
@@ -1255,22 +1445,27 @@ pub fn get_reaction_users(channel_id: u64,
                           limit: u8,
                           after: Option<u64>)
                           -> Result<Vec<User>> {
-    let mut uri = format!("/channels/{}/messages/{}/reactions/{}?limit={}",
-                          channel_id,
-                          message_id,
-                          reaction_type.as_data(),
-                          limit);
+    let mut uri = format!(
+        "/channels/{}/messages/{}/reactions/{}?limit={}",
+        channel_id,
+        message_id,
+        reaction_type.as_data(),
+        limit
+    );
 
     if let Some(user_id) = after {
         write!(uri, "&after={}", user_id)?;
     }
 
-    let response = request!(Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
-                            get,
-                            "{}",
-                            uri);
+    let response = request!(
+        Route::ChannelsIdMessagesIdReactionsUserIdType(channel_id),
+        get,
+        "{}",
+        uri
+    );
 
-    serde_json::from_reader::<HyperResponse, Vec<User>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<User>>(response)
+        .map_err(From::from)
 }
 
 /// Gets the current unresolved incidents from Discord's Status API.
@@ -1284,7 +1479,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![]),
     }
 }
@@ -1295,12 +1491,15 @@ pub fn get_unresolved_incidents() -> Result<Vec<Incident>> {
 pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
     let client = request_client!();
 
-    let response = retry(|| client.get(status!("/scheduled-maintenances/upcoming.json")))?;
+    let response = retry(|| {
+        client.get(status!("/scheduled-maintenances/upcoming.json"))
+    })?;
 
     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![]),
     }
 }
@@ -1309,21 +1508,24 @@ pub fn get_upcoming_maintenances() -> Result<Vec<Maintenance>> {
 pub fn get_user(user_id: u64) -> Result<User> {
     let response = request!(Route::UsersId, get, "/users/{}", user_id);
 
-    serde_json::from_reader::<HyperResponse, User>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, User>(response)
+        .map_err(From::from)
 }
 
 /// Gets our DM channels.
 pub fn get_user_dm_channels() -> Result<Vec<PrivateChannel>> {
     let response = request!(Route::UsersMeChannels, get, "/users/@me/channels");
 
-    serde_json::from_reader::<HyperResponse, Vec<PrivateChannel>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<PrivateChannel>>(response)
+        .map_err(From::from)
 }
 
 /// Gets all voice regions.
 pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
     let response = request!(Route::VoiceRegions, get, "/voice/regions");
 
-    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Vec<VoiceRegion>>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a webhook given its Id.
@@ -1346,7 +1548,8 @@ pub fn get_voice_regions() -> Result<Vec<VoiceRegion>> {
 pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
     let response = request!(Route::WebhooksId, get, "/webhooks/{}", webhook_id);
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Retrieves a webhook given its Id and unique token.
@@ -1369,46 +1572,62 @@ pub fn get_webhook(webhook_id: u64) -> Result<Webhook> {
 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)))
-        .map_err(Error::Hyper)?;
+    let response = retry(|| {
+        client
+            .get(&format!(api!("/webhooks/{}/{}"), webhook_id, token))
+    }).map_err(Error::Hyper)?;
 
-    serde_json::from_reader::<HyperResponse, Webhook>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Webhook>(response)
+        .map_err(From::from)
 }
 
 /// Kicks a member from a guild.
 pub fn kick_member(guild_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersId(guild_id),
-                    delete,
-                    "/guilds/{}/members/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersId(guild_id),
+            delete,
+            "/guilds/{}/members/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Leaves a group DM.
 pub fn leave_group(guild_id: u64) -> Result<Group> {
     let response = request!(Route::None, delete, "/channels/{}", guild_id);
 
-    serde_json::from_reader::<HyperResponse, Group>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Group>(response)
+        .map_err(From::from)
 }
 
 /// Leaves a guild.
 pub fn leave_guild(guild_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::UsersMeGuildsId,
-                    delete,
-                    "/users/@me/guilds/{}",
-                    guild_id))
+    verify(
+        204,
+        request!(
+            Route::UsersMeGuildsId,
+            delete,
+            "/users/@me/guilds/{}",
+            guild_id
+        ),
+    )
 }
 
 /// Deletes a user from group DM.
 pub fn remove_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::None,
-                    delete,
-                    "/channels/{}/recipients/{}",
-                    group_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::None,
+            delete,
+            "/channels/{}/recipients/{}",
+            group_id,
+            user_id
+        ),
+    )
 }
 
 /// Sends file(s) to a channel.
@@ -1421,8 +1640,7 @@ pub fn remove_group_recipient(group_id: u64, user_id: u64) -> Result<()> {
 ///
 /// [`HttpError::InvalidRequest`]: enum.HttpError.html#variant.InvalidRequest
 pub fn send_files<'a, T>(channel_id: u64, files: Vec<T>, map: JsonMap) -> Result<Message>
-where
-    T: Into<AttachmentType<'a>>, {
+    where T: Into<AttachmentType<'a>> {
     let uri = format!(api!("/channels/{}/messages"), channel_id);
     let url = match Url::parse(&uri) {
         Ok(url) => url,
@@ -1479,38 +1697,50 @@ where
         return Err(Error::Http(HttpError::InvalidRequest(response.status)));
     }
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Sends a message to a channel.
 pub fn send_message(channel_id: u64, map: &Value) -> Result<Message> {
     let body = map.to_string();
-    let response = request!(Route::ChannelsIdMessages(channel_id),
-                            post(body),
-                            "/channels/{}/messages",
-                            channel_id);
+    let response = request!(
+        Route::ChannelsIdMessages(channel_id),
+        post(body),
+        "/channels/{}/messages",
+        channel_id
+    );
 
-    serde_json::from_reader::<HyperResponse, Message>(response).map_err(From::from)
+    serde_json::from_reader::<HyperResponse, Message>(response)
+        .map_err(From::from)
 }
 
 /// Pins a message in a channel.
 pub fn pin_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPinsMessageId(channel_id),
-                    put,
-                    "/channels/{}/pins/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPinsMessageId(channel_id),
+            put,
+            "/channels/{}/pins/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 /// Unbans a user from a guild.
 pub fn remove_ban(guild_id: u64, user_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdBansUserId(guild_id),
-                    delete,
-                    "/guilds/{}/bans/{}",
-                    guild_id,
-                    user_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdBansUserId(guild_id),
+            delete,
+            "/guilds/{}/bans/{}",
+            guild_id,
+            user_id
+        ),
+    )
 }
 
 /// Deletes a single [`Role`] from a [`Member`] in a [`Guild`].
@@ -1523,49 +1753,63 @@ pub fn remove_ban(guild_id: u64, user_id: u64) -> Result<()> {
 /// [`Role`]: ../model/struct.Role.html
 /// [Manage Roles]: ../model/permissions/constant.MANAGE_ROLES.html
 pub fn remove_member_role(guild_id: u64, user_id: u64, role_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdMembersIdRolesId(guild_id),
-                    delete,
-                    "/guilds/{}/members/{}/roles/{}",
-                    guild_id,
-                    user_id,
-                    role_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdMembersIdRolesId(guild_id),
+            delete,
+            "/guilds/{}/members/{}/roles/{}",
+            guild_id,
+            user_id,
+            role_id
+        ),
+    )
 }
 
 /// Starts removing some members from a guild based on the last time they've been online.
 pub fn start_guild_prune(guild_id: u64, map: &Value) -> Result<GuildPrune> {
     let body = map.to_string();
-    let response = request!(Route::GuildsIdPrune(guild_id),
-                            post(body),
-                            "/guilds/{}/prune",
-                            guild_id);
-
-    serde_json::from_reader::<HyperResponse, GuildPrune>(response).map_err(From::from)
+    let response = request!(
+        Route::GuildsIdPrune(guild_id),
+        post(body),
+        "/guilds/{}/prune",
+        guild_id
+    );
+
+    serde_json::from_reader::<HyperResponse, GuildPrune>(response)
+        .map_err(From::from)
 }
 
 /// Starts syncing an integration with a guild.
 pub fn start_integration_sync(guild_id: u64, integration_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::GuildsIdIntegrationsIdSync(guild_id),
-                    post,
-                    "/guilds/{}/integrations/{}/sync",
-                    guild_id,
-                    integration_id))
+    verify(
+        204,
+        request!(
+            Route::GuildsIdIntegrationsIdSync(guild_id),
+            post,
+            "/guilds/{}/integrations/{}/sync",
+            guild_id,
+            integration_id
+        ),
+    )
 }
 
 /// Unpins a message from a channel.
 pub fn unpin_message(channel_id: u64, message_id: u64) -> Result<()> {
-    verify(204,
-           request!(Route::ChannelsIdPinsMessageId(channel_id),
-                    delete,
-                    "/channels/{}/pins/{}",
-                    channel_id,
-                    message_id))
+    verify(
+        204,
+        request!(
+            Route::ChannelsIdPinsMessageId(channel_id),
+            delete,
+            "/channels/{}/pins/{}",
+            channel_id,
+            message_id
+        ),
+    )
 }
 
 fn request<'a, F>(route: Route, f: F) -> Result<HyperResponse>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     let response = ratelimiting::perform(route, || {
         f()
             .header(header::Authorization(TOKEN.lock().unwrap().clone()))
@@ -1580,8 +1824,7 @@ where
 }
 
 pub(crate) fn retry<'a, F>(f: F) -> HyperResult<HyperResponse>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     let req = || {
         f()
             .header(header::UserAgent(constants::USER_AGENT.to_owned()))
diff --git a/src/http/ratelimiting.rs b/src/http/ratelimiting.rs
index 12066a9..f0eb8fc 100644
--- a/src/http/ratelimiting.rs
+++ b/src/http/ratelimiting.rs
@@ -346,8 +346,7 @@ pub enum Route {
 }
 
 pub(crate) fn perform<'a, F>(route: Route, f: F) -> Result<Response>
-where
-    F: Fn() -> RequestBuilder<'a>, {
+    where F: Fn() -> RequestBuilder<'a> {
     loop {
         // This will block if another thread already has the global
         // unlocked already (due to receiving an x-ratelimit-global).
@@ -367,10 +366,10 @@ where
             .entry(route)
             .or_insert_with(|| {
                 Arc::new(Mutex::new(RateLimit {
-                                        limit: i64::MAX,
-                                        remaining: i64::MAX,
-                                        reset: i64::MAX,
-                                    }))
+                    limit: i64::MAX,
+                    remaining: i64::MAX,
+                    reset: i64::MAX,
+                }))
             })
             .clone();
 
@@ -398,14 +397,15 @@ where
             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)
             };
@@ -462,9 +462,11 @@ impl RateLimit {
         if self.remaining == 0 {
             let delay = (diff * 1000) + 500;
 
-            debug!("Pre-emptive ratelimit on route {:?} for {:?}ms",
-                   route,
-                   delay);
+            debug!(
+                "Pre-emptive ratelimit on route {:?} for {:?}ms",
+                route,
+                delay
+            );
             thread::sleep(Duration::from_millis(delay));
 
             return;
@@ -487,30 +489,26 @@ impl RateLimit {
         }
 
         Ok(if response.status != StatusCode::TooManyRequests {
-               false
-           } else 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));
+            false
+        } else 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
+        })
     }
 }
 
 fn parse_header(headers: &Headers, header: &str) -> Result<Option<i64>> {
     match headers.get_raw(header) {
-        Some(header) => {
-            match str::from_utf8(&header[0]) {
-                Ok(v) => {
-                    match v.parse::<i64>() {
-                        Ok(v) => Ok(Some(v)),
-                        Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
-                    }
-                },
-                Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
-            }
+        Some(header) => match str::from_utf8(&header[0]) {
+            Ok(v) => match v.parse::<i64>() {
+                Ok(v) => Ok(Some(v)),
+                Err(_) => Err(Error::Http(HttpError::RateLimitI64)),
+            },
+            Err(_) => Err(Error::Http(HttpError::RateLimitUtf8)),
         },
         None => Ok(None),
     }