Run cargo clippy fix (#284)

Author: Filip-L

fplus-database/src/database/allocation_amounts.rs

@@ -66,7 +66,7 @@ pub async fn create_allocation_amount(
     };
 
     let insert_result = new_allocation_amount.insert(&conn).await;
-    println!("Allocation amount inserted: {:?}", insert_result);
+    println!("Allocation amount inserted: {insert_result:?}");
 
     Ok(())
 }

fplus-database/src/database/allocators.rs

@@ -212,7 +212,7 @@ pub async fn create_or_update_allocator(
             .await
             .expect("Failed to get DB connection");
         let insert_result = new_allocator.insert(&conn).await?;
-        println!("Allocator inserted: {:?}", insert_result);
+        println!("Allocator inserted: {insert_result:?}");
         Ok(insert_result)
     }
 }

fplus-database/src/lib.rs

@@ -40,7 +40,7 @@ pub async fn setup() -> Result<(), DbErr> {
     let db_conn = Database::connect(&database_url).await?;
     let mut db_conn_global = DB_CONN
         .lock()
-        .map_err(|e| DbErr::Custom(format!("Failed to lock database connection: {}", e)))?;
+        .map_err(|e| DbErr::Custom(format!("Failed to lock database connection: {e}")))?;
     *db_conn_global = Some(db_conn);
     Ok(())
 }
@@ -54,7 +54,7 @@ pub async fn setup() -> Result<(), DbErr> {
 pub async fn get_database_connection() -> Result<DatabaseConnection, DbErr> {
     let db_conn = DB_CONN
         .lock()
-        .map_err(|e| DbErr::Custom(format!("Failed to lock database connection: {}", e)))?;
+        .map_err(|e| DbErr::Custom(format!("Failed to lock database connection: {e}")))?;
     if let Some(ref conn) = *db_conn {
         Ok(conn.clone())
     } else {

fplus-http-server/src/main.rs

@@ -47,14 +47,14 @@ async fn main() -> std::io::Result<()> {
     dotenv::dotenv().ok();
     env_logger::init();
     if let Err(e) = fplus_database::setup().await {
-        panic!("Failed to setup database connection: {}", e);
+        panic!("Failed to setup database connection: {e}");
     }
 
     tokio::spawn(async {
         run_cron("0 0 0,4,8,12,16,20 * * * *", || {
             tokio::spawn(async {
                 if let Err(e) = update_installation_ids_logic().await {
-                    eprintln!("Error: {:?}", e);
+                    eprintln!("Error: {e:?}");
                 }
             })
         })

fplus-http-server/src/middleware/verifier_auth.rs

@@ -60,7 +60,7 @@ where
         } = match query {
             Ok(q) => q.into_inner(),
             Err(e) => {
-                println!("{}", e);
+                println!("{e}");
                 return Box::pin(async {
                     Err(actix_web::error::ErrorBadRequest(
                         "Wrong query string format",
@@ -85,7 +85,7 @@ where
                 let client = Client::new();
                 let user_info_result = client
                     .get("https://api.github.com/user")
-                    .header("Authorization", format!("Bearer {}", token))
+                    .header("Authorization", format!("Bearer {token}"))
                     .header("User-Agent", "Actix-web")
                     .send()
                     .await
@@ -130,7 +130,7 @@ where
                                 .map(|s| s.trim().to_lowercase())
                                 .collect();
                             if verifier_handles.contains(&user_handle.to_lowercase()) {
-                                println!("{} is a verifier.", user_handle);
+                                println!("{user_handle} is a verifier.");
                             } else {
                                 println!("The user is not a verifier.");
                                 return Err(actix_web::error::ErrorUnauthorized(
@@ -141,7 +141,7 @@ where
                     }
                 }
                 Err(e) => {
-                    println!("Failed to get allocator: {:?}", e);
+                    println!("Failed to get allocator: {e:?}");
                 }
             }
 

fplus-lib/src/core/allocator/mod.rs

@@ -32,7 +32,7 @@ pub async fn process_allocator_file(file_name: &str) -> Result<AllocatorModel, L
     let repo = get_env_var_or_default("ALLOCATOR_GOVERNANCE_REPO");
     let installation_id = get_env_var_or_default("GITHUB_INSTALLATION_ID")
         .parse::<i64>()
-        .map_err(|e| LDNError::New(format!("Parse installation_id to i64 failed: {}", e)))?;
+        .map_err(|e| LDNError::New(format!("Parse installation_id to i64 failed: {e}")))?;
     let branch = "main";
     let path = file_name.to_string();
 
@@ -108,8 +108,7 @@ pub async fn is_allocator_repo_initialized(gh: &GithubWrapper) -> Result<bool, L
     let applications_directory = "applications";
     let all_files_result = gh.get_files(applications_directory).await.map_err(|e| {
         LDNError::Load(format!(
-            "Failed to retrieve all files from GitHub. Reason: {}",
-            e
+            "Failed to retrieve all files from GitHub. Reason: {e}"
         ))
     });
 
@@ -151,11 +150,11 @@ pub async fn create_file_in_repo(
         )
         .send()
         .await
-        .map_err(|e| LDNError::Load(format!("here {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("here {e}")))?;
     let file = file
         .text()
         .await
-        .map_err(|e| LDNError::Load(format!("here1 {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("here1 {e}")))?;
 
     //Get file from target repo. If file does not exist or fails to retrieve, create it
     let target_file = match gh.get_file(&file_path, "main").await {
@@ -243,8 +242,7 @@ pub async fn init_allocator_repo(gh: &GithubWrapper) -> Result<(), LDNError> {
             .await
             .map_err(|e| {
                 LDNError::Load(format!(
-                    "Failed to retrieve all files from GitHub. Reason: {}",
-                    e
+                    "Failed to retrieve all files from GitHub. Reason: {e}"
                 ))
             })?;
 
@@ -264,19 +262,14 @@ pub async fn init_allocator_repo(gh: &GithubWrapper) -> Result<(), LDNError> {
 pub async fn generate_github_app_jwt() -> Result<String, LDNError> {
     let app_id = get_env_var_or_default("GITHUB_APP_ID")
         .parse::<u64>()
-        .map_err(|e| {
-            LDNError::New(format!(
-                "Parse days to next allocation to i64 failed: {}",
-                e
-            ))
-        })?;
+        .map_err(|e| LDNError::New(format!("Parse days to next allocation to i64 failed: {e}")))?;
     let pem = get_env_var_or_default("GH_PRIVATE_KEY");
 
     let key = EncodingKey::from_rsa_pem(pem.to_string().as_bytes())
-        .map_err(|e| LDNError::Load(format!("Failed to load RSA PEM: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to load RSA PEM: {e}")))?;
 
     let token = create_jwt(octocrab::models::AppId(app_id), &key)
-        .map_err(|e| LDNError::Load(format!("Failed to create JWT: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to create JWT: {e}")))?;
 
     Ok(token)
 }
@@ -285,13 +278,13 @@ pub async fn fetch_installation_ids(client: &Client, jwt: &str) -> Result<Vec<u6
     let req_url = "https://api.github.com/app/installations";
     let response = client
         .get(req_url)
-        .header(header::AUTHORIZATION, format!("Bearer {}", jwt))
+        .header(header::AUTHORIZATION, format!("Bearer {jwt}"))
         .header(header::ACCEPT, "application/vnd.github+json")
         .header("X-GitHub-Api-Version", "2022-11-28")
         .header(header::USER_AGENT, "YourApp")
         .send()
         .await
-        .map_err(|e| LDNError::Load(format!("Failed to send request: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to send request: {e}")))?;
 
     if !response.status().is_success() {
         log::error!("Request failed with status: {}", response.status());
@@ -300,12 +293,12 @@ pub async fn fetch_installation_ids(client: &Client, jwt: &str) -> Result<Vec<u6
     let text = response
         .text()
         .await
-        .map_err(|e| LDNError::Load(format!("Failed to decode response: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to decode response: {e}")))?;
 
     log::debug!("Response body: {}", text);
 
     let installations: Vec<Installation> = serde_json::from_str(&text)
-        .map_err(|e| LDNError::Load(format!("Failed to parse response as JSON: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to parse response as JSON: {e}")))?;
 
     Ok(installations.into_iter().map(|i| i.id).collect())
 }
@@ -315,13 +308,11 @@ pub async fn fetch_access_token(
     jwt: &str,
     installation_id: u64,
 ) -> Result<String> {
-    let req_url = format!(
-        "https://api.github.com/app/installations/{}/access_tokens",
-        installation_id
-    );
+    let req_url =
+        format!("https://api.github.com/app/installations/{installation_id}/access_tokens");
     let res: AccessTokenResponse = client
         .post(req_url)
-        .header(header::AUTHORIZATION, format!("Bearer {}", jwt))
+        .header(header::AUTHORIZATION, format!("Bearer {jwt}"))
         .header(header::USER_AGENT, "YourApp")
         .send()
         .await?
@@ -334,7 +325,7 @@ pub async fn fetch_repositories(client: &Client, token: &str) -> Result<Vec<Repo
     let req_url = "https://api.github.com/installation/repositories";
     let res: RepositoriesResponse = client
         .get(req_url)
-        .header(header::AUTHORIZATION, format!("Bearer {}", token))
+        .header(header::AUTHORIZATION, format!("Bearer {token}"))
         .header(header::USER_AGENT, "YourApp")
         .send()
         .await?
@@ -366,7 +357,7 @@ pub async fn update_installation_ids_in_db(
     let installation_id: i64 = installation
         .installation_id
         .try_into()
-        .map_err(|e| LDNError::Load(format!("Failed to pasre installation id to i64: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to pasre installation id to i64: {e}")))?;
     for repo in installation.repositories.iter() {
         update_allocator_installation_ids(
             repo.owner.clone(),
@@ -390,7 +381,7 @@ pub async fn update_installation_ids_logic() -> Result<(), LDNError> {
     let client = Client::new();
     let jwt = generate_github_app_jwt()
         .await
-        .map_err(|e| LDNError::Load(format!("Failed to generate GitHub App JWT: {}", e)))?;
+        .map_err(|e| LDNError::Load(format!("Failed to generate GitHub App JWT: {e}")))?;
 
     let installation_ids_result = fetch_installation_ids(&client, &jwt).await;
     let mut results: Vec<InstallationRepositories> = Vec::new();
@@ -401,8 +392,7 @@ pub async fn update_installation_ids_logic() -> Result<(), LDNError> {
                 .await
                 .map_err(|e| {
                     LDNError::Load(format!(
-                        "Failed to fetch repositories for installation id: {}",
-                        e
+                        "Failed to fetch repositories for installation id: {e}"
                     ))
                 })?;
         results.push(InstallationRepositories {
@@ -486,7 +476,7 @@ pub async fn force_update_allocators(
                     Some(file),
                 )
                 .await
-                .map_err(|e| LDNError::Load(format!("Failed to get files: {}", e)))?;
+                .map_err(|e| LDNError::Load(format!("Failed to get files: {e}")))?;
             create_file_in_repo(&gh, &content.items[0], true).await?;
         }
     }
@@ -508,7 +498,7 @@ pub fn validate_amount_type_and_options(
 pub fn validate_fixed_amount_options(amount_options: &[String]) -> Result<(), String> {
     for option in amount_options {
         if !is_valid_fixed_option(option) {
-            return Err(format!("Invalid fixed amount option: {}", option));
+            return Err(format!("Invalid fixed amount option: {option}"));
         }
     }
     Ok(())
@@ -518,7 +508,7 @@ pub fn validate_percentage_amount_options(amount_options: &[String]) -> Result<(
     for option in amount_options {
         let no_percentage_option = option.replace('%', "");
         if no_percentage_option.parse::<i32>().is_err() {
-            return Err(format!("Invalid percentage amount option: {}", option));
+            return Err(format!("Invalid percentage amount option: {option}"));
         }
     }
     Ok(())
@@ -601,8 +591,7 @@ pub async fn create_allocator_from_file(files_changed: Vec<String>) -> Result<()
             })
             .map_err(|e| {
                 LDNError::New(format!(
-                    "Installation Id not found for a repo: {} /// {}",
-                    repo, e
+                    "Installation Id not found for a repo: {repo} /// {e}"
                 ))
             })?;
 
@@ -611,12 +600,11 @@ pub async fn create_allocator_from_file(files_changed: Vec<String>) -> Result<()
         match is_allocator_repo_initialized(&gh).await {
             Ok(true) => (),
             Ok(false) => init_allocator_repo(&gh).await.map_err(|e| {
-                LDNError::New(format!("Initializing the allocator repo failed: {}", e))
+                LDNError::New(format!("Initializing the allocator repo failed: {e}"))
             })?,
             Err(e) => {
                 return Err(LDNError::New(format!(
-                    "Checking if the repo is initialized failed: {}",
-                    e
+                    "Checking if the repo is initialized failed: {e}"
                 )));
             }
         }
@@ -642,7 +630,7 @@ pub async fn create_allocator_from_file(files_changed: Vec<String>) -> Result<()
             model.ma_address,
         )
         .await
-        .map_err(|e| LDNError::New(format!("Create or update allocator failed: {}", e)))?;
+        .map_err(|e| LDNError::New(format!("Create or update allocator failed: {e}")))?;
 
         let allocator_id = allocator_creation_result.id;
 
@@ -651,8 +639,7 @@ pub async fn create_allocator_from_file(files_changed: Vec<String>) -> Result<()
             .await
             .map_err(|e| {
                 LDNError::New(format!(
-                    "Delete all old allocation amounts by allocator id failed: {}",
-                    e
+                    "Delete all old allocation amounts by allocator id failed: {e}"
                 ))
             })?;
 
@@ -664,8 +651,7 @@ pub async fn create_allocator_from_file(files_changed: Vec<String>) -> Result<()
                         .await
                         .map_err(|e| {
                             LDNError::New(format!(
-                                "Create allocation amount rows in the database failed: {}",
-                                e
+                                "Create allocation amount rows in the database failed: {e}"
                             ))
                         })?;
                 }

fplus-lib/src/core/application/file.rs

@@ -22,7 +22,7 @@ impl FromStr for DatacapGroup {
             "da" => Ok(Self::DA),
             "ldn-v3" => Ok(Self::LDN),
             "e-fil" => Ok(Self::EFIL),
-            _ => Err(format!("{} is not a valid datacap group", s)),
+            _ => Err(format!("{s} is not a valid datacap group")),
         }
     }
 }
@@ -158,7 +158,7 @@ impl FromStr for DataType {
             "Public, Open Commercial/Enterprise" => Ok(Self::PublicOpenCommercialEnterprise),
             "Private Commercial/Enterprise" => Ok(Self::PrivateCommercialEnterprise),
             "Private Non-Profit / Social impact" => Ok(Self::PrivateNonProfitSocialImpact),
-            _ => Err(format!("{} is not a valid data type", s)),
+            _ => Err(format!("{s} is not a valid data type")),
         }
     }
 }

fplus-lib/src/core/application/gitcoin_interaction.rs

@@ -74,8 +74,7 @@ pub async fn verify_on_gitcoin(address_from_signature: &Address) -> Result<f64,
 
     if score <= minimum_score {
         return Err(LDNError::New(format!(
-            "For address: {}, Gitcoin passport score is too low ({}). Minimum value is: {}",
-            address_from_signature, score, minimum_score
+            "For address: {address_from_signature}, Gitcoin passport score is too low ({score}). Minimum value is: {minimum_score}"
         )));
     }
     Ok(score)
@@ -103,7 +102,7 @@ async fn get_gitcoin_score_for_address(rpc_url: &str, address: Address) -> Resul
 
 fn calculate_score(response: Bytes) -> Result<f64, LDNError> {
     let score = U256::from_str(&response.to_string())
-        .map_err(|e| LDNError::Load(format!("Failed to parse response to U256: {}", e)))?
+        .map_err(|e| LDNError::Load(format!("Failed to parse response to U256: {e}")))?
         .to::<u128>();
     Ok(score as f64 / 10000.0)
 }