Apply rustfmt

1 files changed, 33 insertions, 44 deletions

diff --git a/src/framework/standard/mod.rs b/src/framework/standard/mod.rs
index bd1300d..4e145e0 100644
--- a/src/framework/standard/mod.rs
+++ b/src/framework/standard/mod.rs
@@ -404,9 +404,9 @@ impl StandardFramework {
             }
 
             if let Some(guild) = guild_id.find() {
-                return self.configuration.blocked_users.contains(
-                    &guild.with(|g| g.owner_id),
-                );
+                return self.configuration
+                    .blocked_users
+                    .contains(&guild.with(|g| g.owner_id));
             }
         }
 
@@ -417,9 +417,8 @@ impl StandardFramework {
     fn has_correct_permissions(&self, command: &Arc<Command>, message: &Message) -> bool {
         if !command.required_permissions.is_empty() {
             if let Some(guild) = message.guild() {
-                let perms = guild.with(|g| {
-                    g.permissions_for(message.channel_id, message.author.id)
-                });
+                let perms = guild
+                    .with(|g| g.permissions_for(message.channel_id, message.author.id));
 
                 return perms.contains(command.required_permissions);
             }
@@ -449,8 +448,7 @@ impl StandardFramework {
                     let rate_limit = bucket.take(message.author.id.0);
                     match bucket.check {
                         Some(ref check) => {
-                            let apply =
-                                feature_cache! {{
+                            let apply = feature_cache! {{
                                 let guild_id = message.guild_id();
                                 (check)(context, guild_id, message.channel_id, message.author.id)
                             } else {
@@ -461,10 +459,8 @@ impl StandardFramework {
                                 return Some(DispatchError::RateLimited(rate_limit));
                             }
                         },
-                        None => {
-                            if rate_limit > 0i64 {
-                                return Some(DispatchError::RateLimited(rate_limit));
-                            }
+                        None => if rate_limit > 0i64 {
+                            return Some(DispatchError::RateLimited(rate_limit));
                         },
                     }
                 }
@@ -514,9 +510,9 @@ impl StandardFramework {
 
             if command.owners_only {
                 Some(DispatchError::OnlyForOwners)
-            } else if self.configuration.blocked_users.contains(
-                &message.author.id,
-            ) {
+            } else if self.configuration
+                   .blocked_users
+                   .contains(&message.author.id) {
                 Some(DispatchError::BlockedUser)
             } else if self.configuration.disabled_commands.contains(to_check) {
                 Some(DispatchError::CommandDisabled(to_check.to_owned()))
@@ -543,9 +539,10 @@ impl StandardFramework {
                     }
                 }
 
-                let all_passed = command.checks.iter().all(|check| {
-                    check(&mut context, message, args, command)
-                });
+                let all_passed = command
+                    .checks
+                    .iter()
+                    .all(|check| check(&mut context, message, args, command));
 
                 if all_passed {
                     None
@@ -599,21 +596,16 @@ impl StandardFramework {
     pub fn on<F, S>(mut self, command_name: S, f: F) -> Self
         where F: Fn(&mut Context, &Message, Args) -> Result<(), String> + 'static, S: Into<String> {
         {
-            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
-                || {
-                    Arc::new(CommandGroup::default())
-                },
-            );
+            let ungrouped = self.groups
+                .entry("Ungrouped".to_owned())
+                .or_insert_with(|| Arc::new(CommandGroup::default()));
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let name = command_name.into();
 
-                group.commands.insert(
-                    name,
-                    CommandOrAlias::Command(
-                        Arc::new(Command::new(f)),
-                    ),
-                );
+                group
+                    .commands
+                    .insert(name, CommandOrAlias::Command(Arc::new(Command::new(f))));
             }
         }
 
@@ -636,11 +628,9 @@ impl StandardFramework {
     pub fn command<F, S>(mut self, command_name: S, f: F) -> Self
         where F: FnOnce(CreateCommand) -> CreateCommand, S: Into<String> {
         {
-            let ungrouped = self.groups.entry("Ungrouped".to_owned()).or_insert_with(
-                || {
-                    Arc::new(CommandGroup::default())
-                },
-            );
+            let ungrouped = self.groups
+                .entry("Ungrouped".to_owned())
+                .or_insert_with(|| Arc::new(CommandGroup::default()));
 
             if let Some(ref mut group) = Arc::get_mut(ungrouped) {
                 let cmd = f(CreateCommand(Command::default())).0;
@@ -655,17 +645,15 @@ impl StandardFramework {
                     }
                 } else {
                     for v in &cmd.aliases {
-                        group.commands.insert(
-                            v.to_owned(),
-                            CommandOrAlias::Alias(name.clone()),
-                        );
+                        group
+                            .commands
+                            .insert(v.to_owned(), CommandOrAlias::Alias(name.clone()));
                     }
                 }
 
-                group.commands.insert(
-                    name,
-                    CommandOrAlias::Command(Arc::new(cmd)),
-                );
+                group
+                    .commands
+                    .insert(name, CommandOrAlias::Command(Arc::new(cmd)));
             }
         }
 
@@ -878,8 +866,9 @@ impl Framework for StandardFramework {
                 for group in groups.values() {
                     let command_length = built.len();
 
-                    if let Some(&CommandOrAlias::Alias(ref points_to)) =
-                        group.commands.get(&built) {
+                    let cmd = group.commands.get(&built);
+
+                    if let Some(&CommandOrAlias::Alias(ref points_to)) = cmd {
                         built = points_to.to_owned();
                     }