clippy pedantic fix + get rid of a few unwraps

src/core/protocol/commands/check_authorization.rs

@@ -57,10 +57,12 @@ pub fn print_check_authorization_output_status_json(output: &CheckAuthorizationR
 }
 
 impl CheckAuthorizationError {
+    #[must_use]
     pub fn to_error_message(&self, db_or_user: &DbOrUser) -> String {
-        self.0.to_error_message(db_or_user.clone())
+        self.0.to_error_message(db_or_user)
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         self.0.error_type()
     }

src/core/protocol/commands/create_databases.rs

@@ -29,7 +29,7 @@ pub fn print_create_databases_output_status(output: &CreateDatabasesResponse) {
     for (database_name, result) in output {
         match result {
             Ok(()) => {
-                println!("Database '{}' created successfully.", database_name);
+                println!("Database '{database_name}' created successfully.");
             }
             Err(err) => {
                 eprintln!("{}", err.to_error_message(database_name));
@@ -63,20 +63,22 @@ pub fn print_create_databases_output_status_json(output: &CreateDatabasesRespons
 }
 
 impl CreateDatabaseError {
+    #[must_use]
     pub fn to_error_message(&self, database_name: &MySQLDatabase) -> String {
         match self {
             CreateDatabaseError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::Database(database_name.clone()))
+                err.to_error_message(&DbOrUser::Database(database_name.clone()))
             }
             CreateDatabaseError::DatabaseAlreadyExists => {
-                format!("Database {} already exists.", database_name)
+                format!("Database {database_name} already exists.")
             }
             CreateDatabaseError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             CreateDatabaseError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/create_users.rs

@@ -29,7 +29,7 @@ pub fn print_create_users_output_status(output: &CreateUsersResponse) {
     for (username, result) in output {
         match result {
             Ok(()) => {
-                println!("User '{}' created successfully.", username);
+                println!("User '{username}' created successfully.");
             }
             Err(err) => {
                 eprintln!("{}", err.to_error_message(username));
@@ -63,20 +63,22 @@ pub fn print_create_users_output_status_json(output: &CreateUsersResponse) {
 }
 
 impl CreateUserError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             CreateUserError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             CreateUserError::UserAlreadyExists => {
-                format!("User '{}' already exists.", username)
+                format!("User '{username}' already exists.")
             }
             CreateUserError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             CreateUserError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/drop_databases.rs

@@ -66,20 +66,22 @@ pub fn print_drop_databases_output_status_json(output: &DropDatabasesResponse) {
 }
 
 impl DropDatabaseError {
+    #[must_use]
     pub fn to_error_message(&self, database_name: &MySQLDatabase) -> String {
         match self {
             DropDatabaseError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::Database(database_name.clone()))
+                err.to_error_message(&DbOrUser::Database(database_name.clone()))
             }
             DropDatabaseError::DatabaseDoesNotExist => {
-                format!("Database {} does not exist.", database_name)
+                format!("Database {database_name} does not exist.")
             }
             DropDatabaseError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             DropDatabaseError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/drop_users.rs

@@ -29,7 +29,7 @@ pub fn print_drop_users_output_status(output: &DropUsersResponse) {
     for (username, result) in output {
         match result {
             Ok(()) => {
-                println!("User '{}' dropped successfully.", username);
+                println!("User '{username}' dropped successfully.");
             }
             Err(err) => {
                 eprintln!("{}", err.to_error_message(username));
@@ -63,20 +63,22 @@ pub fn print_drop_users_output_status_json(output: &DropUsersResponse) {
 }
 
 impl DropUserError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             DropUserError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             DropUserError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             DropUserError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             DropUserError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/list_all_databases.rs

@@ -12,13 +12,15 @@ pub enum ListAllDatabasesError {
 }
 
 impl ListAllDatabasesError {
+    #[must_use]
     pub fn to_error_message(&self) -> String {
         match self {
-            ListAllDatabasesError::MySqlError(err) => format!("MySQL error: {}", err),
+            ListAllDatabasesError::MySqlError(err) => format!("MySQL error: {err}"),
         }
     }
 
     #[allow(dead_code)]
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListAllDatabasesError::MySqlError(_) => "mysql-error".to_string(),

src/core/protocol/commands/list_all_privileges.rs

@@ -12,13 +12,15 @@ pub enum ListAllPrivilegesError {
 }
 
 impl ListAllPrivilegesError {
+    #[must_use]
     pub fn to_error_message(&self) -> String {
         match self {
-            ListAllPrivilegesError::MySqlError(err) => format!("MySQL error: {}", err),
+            ListAllPrivilegesError::MySqlError(err) => format!("MySQL error: {err}"),
         }
     }
 
     #[allow(dead_code)]
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListAllPrivilegesError::MySqlError(_) => "mysql-error".to_string(),

src/core/protocol/commands/list_all_users.rs

@@ -12,13 +12,15 @@ pub enum ListAllUsersError {
 }
 
 impl ListAllUsersError {
+    #[must_use]
     pub fn to_error_message(&self) -> String {
         match self {
-            ListAllUsersError::MySqlError(err) => format!("MySQL error: {}", err),
+            ListAllUsersError::MySqlError(err) => format!("MySQL error: {err}"),
         }
     }
 
     #[allow(dead_code)]
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListAllUsersError::MySqlError(_) => "mysql-error".to_string(),

src/core/protocol/commands/list_databases.rs

@@ -113,20 +113,22 @@ pub fn print_list_databases_output_status_json(output: &ListDatabasesResponse) {
 }
 
 impl ListDatabasesError {
+    #[must_use]
     pub fn to_error_message(&self, database_name: &MySQLDatabase) -> String {
         match self {
             ListDatabasesError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::Database(database_name.clone()))
+                err.to_error_message(&DbOrUser::Database(database_name.clone()))
             }
             ListDatabasesError::DatabaseDoesNotExist => {
-                format!("Database '{}' does not exist.", database_name)
+                format!("Database '{database_name}' does not exist.")
             }
             ListDatabasesError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListDatabasesError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/list_privileges.rs

@@ -65,7 +65,7 @@ pub fn print_list_privileges_output_status(output: &ListPrivilegesResponse, long
         ));
 
         for (_database, rows) in final_privs_map {
-            for row in rows.iter() {
+            for row in &rows {
                 table.add_row(row![
                     row.db,
                     row.user,
@@ -129,20 +129,22 @@ pub enum ListPrivilegesError {
 }
 
 impl ListPrivilegesError {
+    #[must_use]
     pub fn to_error_message(&self, database_name: &MySQLDatabase) -> String {
         match self {
             ListPrivilegesError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::Database(database_name.clone()))
+                err.to_error_message(&DbOrUser::Database(database_name.clone()))
             }
             ListPrivilegesError::DatabaseDoesNotExist => {
-                format!("Database '{}' does not exist.", database_name)
+                format!("Database '{database_name}' does not exist.")
             }
             ListPrivilegesError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListPrivilegesError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/list_users.rs

@@ -97,20 +97,22 @@ pub fn print_list_users_output_status_json(output: &ListUsersResponse) {
 }
 
 impl ListUsersError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             ListUsersError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             ListUsersError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             ListUsersError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ListUsersError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/lock_users.rs

@@ -32,7 +32,7 @@ pub fn print_lock_users_output_status(output: &LockUsersResponse) {
     for (username, result) in output {
         match result {
             Ok(()) => {
-                println!("User '{}' locked successfully.", username);
+                println!("User '{username}' locked successfully.");
             }
             Err(err) => {
                 eprintln!("{}", err.to_error_message(username));
@@ -66,23 +66,25 @@ pub fn print_lock_users_output_status_json(output: &LockUsersResponse) {
 }
 
 impl LockUserError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             LockUserError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             LockUserError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             LockUserError::UserIsAlreadyLocked => {
-                format!("User '{}' is already locked.", username)
+                format!("User '{username}' is already locked.")
             }
             LockUserError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             LockUserError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/modify_privileges.rs

@@ -53,8 +53,7 @@ pub fn print_modify_database_privileges_output_status(output: &ModifyPrivilegesR
         match result {
             Ok(()) => {
                 println!(
-                    "Privileges for user '{}' on database '{}' modified successfully.",
-                    username, database_name
+                    "Privileges for user '{username}' on database '{database_name}' modified successfully."
                 );
             }
             Err(err) => {
@@ -67,19 +66,20 @@ pub fn print_modify_database_privileges_output_status(output: &ModifyPrivilegesR
 }
 
 impl ModifyDatabasePrivilegesError {
+    #[must_use]
     pub fn to_error_message(&self, database_name: &MySQLDatabase, username: &MySQLUser) -> String {
         match self {
             ModifyDatabasePrivilegesError::DatabaseValidationError(err) => {
-                err.to_error_message(DbOrUser::Database(database_name.clone()))
+                err.to_error_message(&DbOrUser::Database(database_name.clone()))
             }
             ModifyDatabasePrivilegesError::UserValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             ModifyDatabasePrivilegesError::DatabaseDoesNotExist => {
-                format!("Database '{}' does not exist.", database_name)
+                format!("Database '{database_name}' does not exist.")
             }
             ModifyDatabasePrivilegesError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             ModifyDatabasePrivilegesError::DiffDoesNotApply(diff) => {
                 format!(
@@ -88,12 +88,13 @@ impl ModifyDatabasePrivilegesError {
                 )
             }
             ModifyDatabasePrivilegesError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
     #[allow(dead_code)]
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ModifyDatabasePrivilegesError::DatabaseValidationError(err) => {
@@ -113,29 +114,26 @@ impl ModifyDatabasePrivilegesError {
 }
 
 impl DiffDoesNotApplyError {
+    #[must_use]
     pub fn to_error_message(&self) -> String {
         match self {
             DiffDoesNotApplyError::RowAlreadyExists(database_name, username) => {
                 format!(
-                    "Privileges for user '{}' on database '{}' already exist.",
-                    username, database_name
+                    "Privileges for user '{username}' on database '{database_name}' already exist."
                 )
             }
             DiffDoesNotApplyError::RowDoesNotExist(database_name, username) => {
                 format!(
-                    "Privileges for user '{}' on database '{}' do not exist.",
-                    username, database_name
+                    "Privileges for user '{username}' on database '{database_name}' do not exist."
                 )
             }
             DiffDoesNotApplyError::RowPrivilegeChangeDoesNotApply(diff, row) => {
-                format!(
-                    "Could not apply privilege change {:?} to row {:?}",
-                    diff, row
-                )
+                format!("Could not apply privilege change {diff:?} to row {row:?}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             DiffDoesNotApplyError::RowAlreadyExists(_, _) => "row-already-exists".to_string(),

src/core/protocol/commands/passwd_user.rs

@@ -25,7 +25,7 @@ pub enum SetPasswordError {
 pub fn print_set_password_output_status(output: &SetUserPasswordResponse, username: &MySQLUser) {
     match output {
         Ok(()) => {
-            println!("Password for user '{}' set successfully.", username);
+            println!("Password for user '{username}' set successfully.");
         }
         Err(err) => {
             eprintln!("{}", err.to_error_message(username));
@@ -35,21 +35,23 @@ pub fn print_set_password_output_status(output: &SetUserPasswordResponse, userna
 }
 
 impl SetPasswordError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             SetPasswordError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             SetPasswordError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             SetPasswordError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
     #[allow(dead_code)]
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             SetPasswordError::ValidationError(err) => err.error_type(),

src/core/protocol/commands/unlock_users.rs

@@ -32,7 +32,7 @@ pub fn print_unlock_users_output_status(output: &UnlockUsersResponse) {
     for (username, result) in output {
         match result {
             Ok(()) => {
-                println!("User '{}' unlocked successfully.", username);
+                println!("User '{username}' unlocked successfully.");
             }
             Err(err) => {
                 eprintln!("{}", err.to_error_message(username));
@@ -66,23 +66,25 @@ pub fn print_unlock_users_output_status_json(output: &UnlockUsersResponse) {
 }
 
 impl UnlockUserError {
+    #[must_use]
     pub fn to_error_message(&self, username: &MySQLUser) -> String {
         match self {
             UnlockUserError::ValidationError(err) => {
-                err.to_error_message(DbOrUser::User(username.clone()))
+                err.to_error_message(&DbOrUser::User(username.clone()))
             }
             UnlockUserError::UserDoesNotExist => {
-                format!("User '{}' does not exist.", username)
+                format!("User '{username}' does not exist.")
             }
             UnlockUserError::UserIsAlreadyUnlocked => {
-                format!("User '{}' is already unlocked.", username)
+                format!("User '{username}' is already unlocked.")
             }
             UnlockUserError::MySqlError(err) => {
-                format!("MySQL error: {}", err)
+                format!("MySQL error: {err}")
             }
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             UnlockUserError::ValidationError(err) => err.error_type(),

src/core/protocol/request_validation.rs

@@ -22,7 +22,8 @@ pub enum NameValidationError {
 }
 
 impl NameValidationError {
-    pub fn to_error_message(self, db_or_user: DbOrUser) -> String {
+    #[must_use]
+    pub fn to_error_message(self, db_or_user: &DbOrUser) -> String {
         match self {
             NameValidationError::EmptyString => {
                 format!("{} name can not be empty.", db_or_user.capitalized_noun())
@@ -32,15 +33,16 @@ impl NameValidationError {
                 db_or_user.capitalized_noun()
             ),
             NameValidationError::InvalidCharacters => format!(
-                indoc! {r#"
+                indoc! {r"
                   Invalid characters in {} name: '{}', only A-Z, a-z, 0-9, _ (underscore) and - (dash) are permitted.
-                "#},
+                "},
                 db_or_user.lowercased_noun(),
                 db_or_user.name(),
             ),
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> &'static str {
         match self {
             NameValidationError::EmptyString => "empty-string",
@@ -64,7 +66,8 @@ pub enum AuthorizationError {
 }
 
 impl AuthorizationError {
-    pub fn to_error_message(self, db_or_user: DbOrUser) -> String {
+    #[must_use]
+    pub fn to_error_message(self, db_or_user: &DbOrUser) -> String {
         match self {
             AuthorizationError::IllegalPrefix => format!(
                 "Illegal {} name prefix: you are not allowed to manage databases or users prefixed with '{}'",
@@ -82,6 +85,7 @@ impl AuthorizationError {
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> &'static str {
         match self {
             AuthorizationError::IllegalPrefix => "illegal-prefix",
@@ -102,7 +106,8 @@ pub enum ValidationError {
 }
 
 impl ValidationError {
-    pub fn to_error_message(&self, db_or_user: DbOrUser) -> String {
+    #[must_use]
+    pub fn to_error_message(&self, db_or_user: &DbOrUser) -> String {
         match self {
             ValidationError::NameValidationError(err) => err.to_error_message(db_or_user),
             ValidationError::AuthorizationError(err) => err.to_error_message(db_or_user),
@@ -116,6 +121,7 @@ impl ValidationError {
         }
     }
 
+    #[must_use]
     pub fn error_type(&self) -> String {
         match self {
             ValidationError::NameValidationError(err) => {
@@ -153,7 +159,7 @@ pub fn validate_authorization_by_unix_user(
     name: &str,
     user: &UnixUser,
 ) -> Result<(), AuthorizationError> {
-    let prefixes = std::iter::once(user.username.to_owned())
+    let prefixes = std::iter::once(user.username.clone())
         .chain(user.groups.iter().cloned())
         .collect::<Vec<String>>();
 
@@ -174,12 +180,12 @@ pub fn validate_authorization_by_prefixes(
 
     if prefixes
         .iter()
-        .filter(|p| name.starts_with(&(p.to_string() + "_")))
+        .filter(|p| name.starts_with(&((*p).clone() + "_")))
         .collect::<Vec<_>>()
         .is_empty()
     {
         return Err(AuthorizationError::IllegalPrefix);
-    };
+    }
 
     Ok(())
 }