Fix clippy lints.

Author: Triton171

build.rs

@@ -2,12 +2,12 @@ use std::process::Command;
 
 fn main() {
     let output = Command::new("git")
-        .args(&["rev-parse", "HEAD"])
+        .args(["rev-parse", "HEAD"])
         .output()
         .unwrap();
     let git_hash = String::from_utf8(output.stdout).unwrap();
 
-    if git_hash.len() > 0 {
+    if !git_hash.is_empty() {
         println!("cargo:rustc-env=GIT_HASH={}", git_hash);
         println!(
             "cargo:rustc-env=FULL_VERSION=v{} @ {}",

src/character.rs

@@ -6,7 +6,7 @@ use serde::Deserialize;
 use std::path::Path;
 use tokio::fs;
 
-const LOADED_CHARACTER_FILE: &'static str = "loaded_character";
+const LOADED_CHARACTER_FILE: &str = "loaded_character";
 
 mod default {
     pub fn skills() -> Vec<super::CharacterSkill> {
@@ -118,7 +118,7 @@ impl Character {
         if Path::exists(&path) {
             let char_path = std::fs::read_to_string(&path)?;
             let char_path = Path::new(&char_path);
-            let character = Self::from_file(&char_path).await?;
+            let character = Self::from_file(char_path).await?;
             Ok(Some(character))
         } else {
             Ok(None)

src/character_manager.rs

@@ -391,14 +391,14 @@ impl CharacterManager {
 
     pub async fn get_character(&self, id: CharacterId) -> Result<Character, Error> {
         let path = get_character_path(id).await?;
-        Ok(Character::from_file(&path).await?)
+        Character::from_file(&path).await
     }
 
-    pub fn get_character_name<'a>(
-        &'a self,
+    pub fn get_character_name(
+        &self,
         user_id: u64,
         character_id: CharacterId,
-    ) -> Result<&'a str, Error> {
+    ) -> Result<&str, Error> {
         match self.characters.characters.get(&user_id) {
             None => Err(Error::new(
                 "Error getting character name: No character found for this account",
@@ -407,8 +407,7 @@ impl CharacterManager {
             Some(user_characters) => {
                 match user_characters
                     .iter()
-                    .filter(|c| c.character_id == character_id)
-                    .next()
+                    .find(|c| c.character_id == character_id)
                 {
                     None => Err(Error::new(
                         "Error getting character name: No character found with the given id",
@@ -440,6 +439,6 @@ async fn get_character_path(character_id: CharacterId) -> Result<PathBuf, Error>
     let mut path = config::get_config_dir()?;
     path.push("discord_characters");
     fs::create_dir_all(&path).await?;
-    path.push(&character_id.0.to_string());
+    path.push(character_id.0.to_string());
     Ok(path)
 }

src/config.rs

@@ -19,7 +19,7 @@ mod default {
             }
         }
         pub fn crit_rules() -> super::super::ConfigDSACritType {
-            super::super::ConfigDSACritType::DefaultCrits
+            super::super::ConfigDSACritType::Default
         }
     }
     pub mod discord {
@@ -102,9 +102,9 @@ pub struct ConfigDSARules {
 
 #[derive(Deserialize)]
 pub enum ConfigDSACritType {
-    NoCrits,
-    DefaultCrits,
-    AlternativeCrits,
+    None,
+    Default,
+    Alternative,
 }
 
 #[derive(Deserialize)]

src/default_config/config.json

@@ -1,7 +1,7 @@
 {
     "auto_update_dsa_data" : true,
     "dsa_rules" : {
-        "crit_rules" : "AlternativeCrits"
+        "crit_rules" : "Default"
     },
     "discord": {
         "login_token" : null,
@@ -13,4 +13,4 @@
         "max_attachement_size" : 1000000,
         "max_name_length" : 32
     }
-}
+}

src/discord.rs

@@ -134,7 +134,7 @@ pub async fn start_bot(config: Config, dsa_data: DSAData) {
         }
     };
     let application_id = match &config.discord.application_id {
-        Some(app_id) => app_id.clone(),
+        Some(app_id) => *app_id,
         None => {
             println!("Unable to start bot: Missing discord application id");
             return;
@@ -163,12 +163,12 @@ pub async fn start_bot(config: Config, dsa_data: DSAData) {
     {
         Ok(client) => client,
         Err(e) => {
-            println!("Error creating discord client: {}", e.to_string());
+            println!("Error creating discord client: {}", e);
             return;
         }
     };
     if let Err(e) = client.start().await {
-        println!("Error starting discord client: {}", e.to_string());
+        println!("Error starting discord client: {}", e);
     }
 }
 
@@ -197,7 +197,7 @@ impl<'a> DiscordOutputWrapper<'a> {
     pub async fn send(&mut self, ctx: &Context) {
         if self.msg_empty {
             return;
-        } else if self.msg_buf.as_bytes().len() > DISCORD_MAX_MESSAGE_LENGTH {
+        } else if self.msg_buf.len() > DISCORD_MAX_MESSAGE_LENGTH {
             self.msg_buf = format!(
                 "```Error: Reply length exceeds the maximum of {}",
                 DISCORD_MAX_MESSAGE_LENGTH
@@ -248,10 +248,10 @@ impl<'a> OutputWrapper for DiscordOutputWrapper<'a> {
         self.msg_empty = false;
     }
     fn output_line(&mut self, msg: &impl std::fmt::Display) {
-        std::write!(self.msg_buf, "{}\n", msg).unwrap();
+        std::writeln!(self.msg_buf, "{}", msg).unwrap();
         self.msg_empty = false;
     }
-    fn output_table(&mut self, table: &Vec<Vec<String>>) {
+    fn output_table(&mut self, table: &[Vec<String>]) {
         let num_cols = table.iter().map(|row| row.len()).max().unwrap_or(0);
         let mut col_lengths: Vec<usize> = Vec::with_capacity(num_cols);
         for col in 0..num_cols {
@@ -271,7 +271,7 @@ impl<'a> OutputWrapper for DiscordOutputWrapper<'a> {
             for (col, entry) in row.iter().enumerate() {
                 self.msg_buf.push_str(entry);
                 self.msg_buf
-                    .extend(std::iter::repeat(' ').take(col_lengths[col] - entry.len()));
+                    .extend(std::iter::repeat_n(' ', col_lengths[col] - entry.len()));
             }
             self.msg_buf.push('\n');
         }

src/discord_commands.rs

@@ -28,7 +28,7 @@ use serenity::{
 
 #[async_trait]
 pub trait CommandContext: Sync {
-    fn context<'a>(&'a self) -> &'a Context;
+    fn context(&self) -> &Context;
     fn sender(&self) -> Result<UserId, Error>;
     fn channel(&self) -> Result<ChannelId, Error>;
     async fn attachments<'a>(&'a self) -> Result<&'a [Attachment], Error>;
@@ -59,7 +59,7 @@ pub trait CommandContext: Sync {
         let g_members = guild.members(self.context(), Some(1000), None).await?;
 
         Ok(
-            futures::stream::iter(g_members.iter().map(|m| m.clone())) // fetch members in the channel message was sent in
+            futures::stream::iter(g_members.iter().cloned()) // fetch members in the channel message was sent in
                 .filter_map(|member| async {
                     if guild
                         .user_permissions_in(&channel, &member)
@@ -121,7 +121,7 @@ impl MessageContext<'_> {
 
 #[async_trait]
 impl CommandContext for MessageContext<'_> {
-    fn context<'a>(&'a self) -> &'a Context {
+    fn context(&self) -> &Context {
         self.ctx
     }
     fn sender(&self) -> Result<UserId, Error> {
@@ -148,7 +148,7 @@ impl SlashCommandContext<'_> {
 
 #[async_trait]
 impl CommandContext for SlashCommandContext<'_> {
-    fn context<'a>(&'a self) -> &'a Context {
+    fn context(&self) -> &Context {
         self.ctx
     }
     fn sender(&self) -> Result<UserId, Error> {
@@ -164,13 +164,10 @@ impl CommandContext for SlashCommandContext<'_> {
         }
     }
     fn channel(&self) -> Result<ChannelId, Error> {
-        self.interaction.channel_id.map_or(
-            Err(Error::new(
-                "Error retrieving channel for slash command",
-                ErrorType::IO(IOErrorType::Discord),
-            )),
-            |c| Ok(c),
-        )
+        self.interaction.channel_id.ok_or(Error::new(
+            "Error retrieving channel for slash command",
+            ErrorType::IO(IOErrorType::Discord),
+        ))
     }
     async fn attachments<'a>(&'a self) -> Result<&'a [Attachment], Error> {
         Err(Error::new(
@@ -427,14 +424,13 @@ pub async fn execute_command<T>(
                 output.output_line(&"Selected character:");
                 output.output_line(&selected);
                 output.output_line(&"");
+            } else if non_selected.is_empty() {
+                output.output_line(&"No character found for your discord account");
             } else {
-                if non_selected.is_empty() {
-                    output.output_line(&"No character found for your discord account");
-                } else {
-                    output.output_line(&"No character currently selected");
-                    output.output_line(&"");
-                }
+                output.output_line(&"No character currently selected");
+                output.output_line(&"");
             }
+
             if !non_selected.is_empty() {
                 output.output_line(&"Other characters:");
                 for name in non_selected {
@@ -594,7 +590,7 @@ pub async fn execute_command<T>(
         }
 
         Some(("ini", sub_m)) => {
-            match initiative(character_manager.read().await, &sub_m, cmd_ctx, output).await {
+            match initiative(character_manager.read().await, sub_m, cmd_ctx, output).await {
                 Ok(()) => {}
                 Err(e) => match e.err_type() {
                     ErrorType::InvalidInput(_) => {
@@ -609,7 +605,7 @@ pub async fn execute_command<T>(
         }
 
         Some(("rename", sub_m)) => {
-            match rename(character_manager.read().await, &sub_m, cmd_ctx, output).await {
+            match rename(character_manager.read().await, sub_m, cmd_ctx, output).await {
                 Ok(()) => {}
                 Err(e) => match e.err_type() {
                     ErrorType::InvalidInput(_) => {
@@ -735,7 +731,7 @@ where
                             Ok(character_name) => {
                                 let display_name = member.display_name();
                                 let display_name = display_name.split(" Ξ ").last().unwrap();
-                                new_name = calculate_name(&character_name, &display_name, 32)?;
+                                new_name = calculate_name(character_name, display_name, 32)?;
                             }
                         };
                     } else if let Some(index) = nickname.find(' ') {
@@ -816,7 +812,7 @@ where
 
     if sub_m.is_present("new") {
         let custom_args: Vec<&str> = sub_m.values_of("new").unwrap().collect();
-        if custom_args.len() % 2 != 0 {
+        if !custom_args.len().is_multiple_of(2) {
             return Err(Error::new(
             "The \"new\" argument expects an even number of values (name and level for each custom character)",
             ErrorType::InvalidInput(InputErrorType::InvalidArgument)
@@ -865,7 +861,7 @@ where
                             s
                         });
                 let discord_name = displ_name.split(" Ξ ").last().unwrap();
-                let suffix = calculate_name(&character.0, &discord_name, 32 - ini_str.len())?;
+                let suffix = calculate_name(&character.0, discord_name, 32 - ini_str.len())?;
                 let new_name = match displ_name.contains('Ξ') {
                     // only use cool renameing if already used rename
                     true => format!("{} {}", ini_str, suffix),
@@ -875,7 +871,7 @@ where
                     let roll = roll;
                     let member = characters_members[roll.0].as_ref().unwrap();
                     let new_name = new_name;
-                    if let Err(e) = cmd_ctx.rename_member(&member, &new_name).await {
+                    if let Err(e) = cmd_ctx.rename_member(member, &new_name).await {
                         println!(
                             "Error changing user nickname from {} to {}: {:?}",
                             member.display_name(),
@@ -912,9 +908,10 @@ where
             2. The user has a discord nickname
             3. The discord nickname is of the form ".* Ξ orig_name"
             */
-            if let Ok(_) = character_manager
+            if character_manager
                 .find_character_for_user(user_id, None::<String>)
                 .await
+                .is_ok()
             {
                 if let Some(nickname) = member.nick.clone() {
                     if let Some(index) = nickname.find('Ξ') {
@@ -967,23 +964,20 @@ where
                     ));
                 }
                 Ok(character_name) => {
-                    let new_name = calculate_name(&character_name, &nickname, 32)?;
+                    let new_name = calculate_name(character_name, &nickname, 32)?;
 
                     rename_futs.push(async {
                         let member = member;
                         let new_name = new_name;
                         if let Err(e) = cmd_ctx.rename_member(&member, &new_name).await {
                             if e.message() == "Missing Permissions" {
-                                match &cmd_ctx.get_guild_owner().await {
-                                    Ok(Some(owner)) => {
-                                        if owner == &member.user.id {
-                                            return Ok(Some(format!(
-                                                "Unable to change server owners nickname to {}",
-                                                new_name
-                                            )));
-                                        }
+                                if let Ok(Some(owner)) = &cmd_ctx.get_guild_owner().await {
+                                    if owner == &member.user.id {
+                                        return Ok(Some(format!(
+                                            "Unable to change server owners nickname to {}",
+                                            new_name
+                                        )));
                                     }
-                                    _ => {}
                                 }
                             }
 
@@ -1058,7 +1052,7 @@ fn calculate_name(character_name: &str, org_name: &str, limit: usize) -> Result<
         // we don't fit our first name :(
         character_name.push_str(&first_name[..allowed_character_len]);
     } else {
-        character_name.push_str(&first_name);
+        character_name.push_str(first_name);
         allowed_character_len -= first_name.len();
 
         let last_name = character_split.clone().last().unwrap_or("");
@@ -1074,11 +1068,11 @@ fn calculate_name(character_name: &str, org_name: &str, limit: usize) -> Result<
                     break;
                 }
                 allowed_character_len -= mid_name.len() + 1;
-                character_name.push_str(" ");
+                character_name.push(' ');
                 character_name.push_str(mid_name);
             }
 
-            character_name.push_str(" ");
+            character_name.push(' ');
             character_name.push_str(last_name);
         }
     }