clippy: auto fix

src/auth.rs

@@ -29,9 +29,7 @@ impl AuthorizationService {
 
         let claims = UserClaims { user, exp: exp_date };
 
-        let token = encode(&Header::default(), &claims, &EncodingKey::from_secret(key)).unwrap();
-
-        token
+        encode(&Header::default(), &claims, &EncodingKey::from_secret(key)).unwrap()
     }
 
     pub async fn verify_jwt(&self, token: &str) -> Result<UserClaims, ServiceError> {

src/config.rs

@@ -135,9 +135,9 @@ impl Configuration {
             eprintln!("Creating config file..");
             let config = Configuration::default();
             let _ = config.save_to_file().await;
-            return Err(ConfigError::Message(format!(
-                "Please edit the config.TOML in the root folder and restart the tracker."
-            )));
+            return Err(ConfigError::Message(
+                "Please edit the config.TOML in the root folder and restart the tracker.".to_string(),
+            ));
         }
 
         let torrust_config: TorrustConfig = match config.try_into() {

src/databases/database.rs

@@ -11,7 +11,7 @@ use crate::models::tracker_key::TrackerKey;
 use crate::models::user::{User, UserAuthentication, UserCompact, UserProfile};
 
 /// Database drivers.
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub enum DatabaseDriver {
     Sqlite3,
     Mysql,

src/databases/mysql.rs

@@ -323,7 +323,7 @@ impl Database for MysqlDatabase {
                     i += 1;
                 }
             }
-            if category_filters.len() > 0 {
+            if !category_filters.is_empty() {
                 format!(
                     "INNER JOIN torrust_categories tc ON tt.category_id = tc.category_id AND ({}) ",
                     category_filters

src/databases/sqlite.rs

@@ -318,7 +318,7 @@ impl Database for SqliteDatabase {
                     i += 1;
                 }
             }
-            if category_filters.len() > 0 {
+            if !category_filters.is_empty() {
                 format!(
                     "INNER JOIN torrust_categories tc ON tt.category_id = tc.category_id AND ({}) ",
                     category_filters

src/errors.rs

@@ -10,7 +10,7 @@ use crate::databases::database::DatabaseError;
 
 pub type ServiceResult<V> = Result<V, ServiceError>;
 
-#[derive(Debug, Display, PartialEq, Error)]
+#[derive(Debug, Display, PartialEq, Eq, Error)]
 #[allow(dead_code)]
 pub enum ServiceError {
     #[display(fmt = "internal server error")]
@@ -182,7 +182,6 @@ impl ResponseError for ServiceError {
         HttpResponseBuilder::new(self.status_code())
             .append_header((header::CONTENT_TYPE, "application/json; charset=UTF-8"))
             .body(serde_json::to_string(&ErrorToResponse { error: self.to_string() }).unwrap())
-            .into()
     }
 }
 

src/models/torrent.rs

@@ -4,7 +4,7 @@ use crate::models::torrent_file::Torrent;
 use crate::routes::torrent::CreateTorrent;
 
 #[allow(dead_code)]
-#[derive(Debug, PartialEq, Serialize, Deserialize, sqlx::FromRow)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, sqlx::FromRow)]
 pub struct TorrentListing {
     pub torrent_id: i64,
     pub uploader: String,

src/models/torrent_file.rs

@@ -6,18 +6,18 @@ use sha1::{Digest, Sha1};
 use crate::config::Configuration;
 use crate::utils::hex::{bytes_to_hex, hex_to_bytes};
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct TorrentNode(String, i64);
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct TorrentFile {
     pub path: Vec<String>,
     pub length: i64,
     #[serde(default)]
     pub md5sum: Option<String>,
 }
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize)]
 pub struct TorrentInfo {
     pub name: String,
     #[serde(default)]
@@ -160,7 +160,7 @@ impl Torrent {
 
     pub fn file_size(&self) -> i64 {
         if self.info.length.is_some() {
-            return self.info.length.unwrap();
+            self.info.length.unwrap()
         } else {
             match &self.info.files {
                 None => 0,
@@ -176,15 +176,15 @@ impl Torrent {
     }
 }
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
 pub struct DbTorrentFile {
     pub path: Option<String>,
     pub length: i64,
     #[serde(default)]
     pub md5sum: Option<String>,
 }
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
 pub struct DbTorrentInfo {
     pub name: String,
     pub pieces: String,
@@ -194,7 +194,7 @@ pub struct DbTorrentInfo {
     pub root_hash: i64,
 }
 
-#[derive(PartialEq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
+#[derive(PartialEq, Eq, Debug, Clone, Serialize, Deserialize, sqlx::FromRow)]
 pub struct DbTorrentAnnounceUrl {
     pub tracker_url: String,
 }

src/models/user.rs

@@ -13,7 +13,7 @@ pub struct UserAuthentication {
     pub password_hash: String,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone, sqlx::FromRow)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone, sqlx::FromRow)]
 pub struct UserProfile {
     pub user_id: i64,
     pub username: String,

src/routes/category.rs

@@ -57,7 +57,7 @@ pub async fn delete_category(
         return Err(ServiceError::Unauthorized);
     }
 
-    let _ = app_data.database.delete_category(&payload.name).await?;
+    app_data.database.delete_category(&payload.name).await?;
 
     Ok(HttpResponse::Ok().json(OkResponse {
         data: payload.name.clone(),

src/routes/torrent.rs

@@ -250,12 +250,12 @@ pub async fn update_torrent(
 
     // update torrent title
     if let Some(title) = &payload.title {
-        let _res = app_data.database.update_torrent_title(torrent_id, title).await?;
+        app_data.database.update_torrent_title(torrent_id, title).await?;
     }
 
     // update torrent description
     if let Some(description) = &payload.description {
-        let _res = app_data.database.update_torrent_description(torrent_id, description).await?;
+        app_data.database.update_torrent_description(torrent_id, description).await?;
     }
 
     let torrent_listing = app_data.database.get_torrent_listing_from_id(torrent_id).await?;
@@ -278,7 +278,7 @@ pub async fn delete_torrent(req: HttpRequest, app_data: WebAppData) -> ServiceRe
     // needed later for removing torrent from tracker whitelist
     let torrent_listing = app_data.database.get_torrent_listing_from_id(torrent_id).await?;
 
-    let _res = app_data.database.delete_torrent(torrent_id).await?;
+    app_data.database.delete_torrent(torrent_id).await?;
 
     // remove info_hash from tracker whitelist
     let _ = app_data
@@ -344,7 +344,7 @@ async fn get_torrent_request_from_payload(mut payload: Multipart) -> Result<Torr
                     continue;
                 }
                 let wrapped_data = &data.unwrap().unwrap();
-                let parsed_data = std::str::from_utf8(&wrapped_data).unwrap();
+                let parsed_data = std::str::from_utf8(wrapped_data).unwrap();
 
                 match name {
                     "title" => title = parsed_data.to_string(),

src/routes/user.rs

@@ -179,7 +179,7 @@ pub async fn verify_token(payload: web::Json<Token>, app_data: WebAppData) -> Se
     let _claims = app_data.auth.verify_jwt(&payload.token).await?;
 
     Ok(HttpResponse::Ok().json(OkResponse {
-        data: format!("Token is valid."),
+        data: "Token is valid.".to_string(),
     }))
 }
 
@@ -256,7 +256,7 @@ pub async fn ban_user(req: HttpRequest, app_data: WebAppData) -> ServiceResult<i
     let date_expiry = chrono::NaiveDateTime::parse_from_str("9999-01-01 00:00:00", "%Y-%m-%d %H:%M:%S")
         .expect("Could not parse date from 9999-01-01 00:00:00.");
 
-    let _ = app_data.database.ban_user(user_profile.user_id, &reason, date_expiry).await?;
+    app_data.database.ban_user(user_profile.user_id, &reason, date_expiry).await?;
 
     Ok(HttpResponse::Ok().json(OkResponse {
         data: format!("Banned user: {}", to_be_banned_username),

tests/databases/tests.rs

@@ -29,7 +29,7 @@ async fn add_test_torrent_category(db: &Box<dyn Database>) -> Result<i64, Databa
 }
 
 pub async fn it_can_add_a_user(db: &Box<dyn Database>) {
-    let add_test_user_result = add_test_user(&db).await;
+    let add_test_user_result = add_test_user(db).await;
 
     assert!(add_test_user_result.is_ok());
 
@@ -49,15 +49,15 @@ pub async fn it_can_add_a_user(db: &Box<dyn Database>) {
             user_id: inserted_user_id,
             username: TEST_USER_USERNAME.to_string(),
             email: TEST_USER_EMAIL.to_string(),
-            email_verified: returned_user_profile.email_verified.clone(),
+            email_verified: returned_user_profile.email_verified,
             bio: returned_user_profile.bio.clone(),
             avatar: returned_user_profile.avatar.clone()
         }
     );
 }
 
 pub async fn it_can_add_a_torrent_category(db: &Box<dyn Database>) {
-    let add_test_torrent_category_result = add_test_torrent_category(&db).await;
+    let add_test_torrent_category_result = add_test_torrent_category(db).await;
 
     assert!(add_test_torrent_category_result.is_ok());
 
@@ -72,8 +72,8 @@ pub async fn it_can_add_a_torrent_category(db: &Box<dyn Database>) {
 
 pub async fn it_can_add_a_torrent_and_tracker_stats_to_that_torrent(db: &Box<dyn Database>) {
     // set pre-conditions
-    let user_id = add_test_user(&db).await.expect("add_test_user failed.");
-    let torrent_category_id = add_test_torrent_category(&db)
+    let user_id = add_test_user(db).await.expect("add_test_user failed.");
+    let torrent_category_id = add_test_torrent_category(db)
         .await
         .expect("add_test_torrent_category failed.");