Apply rustfmt

23 files changed, 244 insertions, 375 deletions

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) {