clippy part 2

Jacherr · Jun 26, 2024 · bd99388 · bd99388
1 parent 69665aa
commit bd99388
Show file tree

Hide file tree

Showing 17 changed files with 44 additions and 44 deletions.
diff --git a/assyst-core/src/command/fun/mod.rs b/assyst-core/src/command/fun/mod.rs
@@ -26,7 +26,7 @@ pub async fn findsong(ctxt: CommandCtxt<'_>, input: ImageUrl) -> anyhow::Result<
         .await
         .context("Failed to identify song")?;
 
-    if result.len() > 0 {
+    if !result.is_empty() {
         let formatted = format!(
             "**Title:** {}\n**Artist(s):** {}\n**YouTube Link:** <{}>",
             result[0].title.clone(),

diff --git a/assyst-core/src/command/misc/help.rs b/assyst-core/src/command/misc/help.rs
@@ -62,8 +62,7 @@ pub async fn help(ctxt: CommandCtxt<'_>, labels: Vec<Word>) -> anyhow::Result<()
                 let subcommands = command.subcommands();
 
                 match subcommands
-                    .map(|x| x.iter().find(|y| y.0 == label).map(|z| z.1))
-                    .flatten()
+                    .and_then(|x| x.iter().find(|y| y.0 == label).map(|z| z.1))
                 {
                     Some(sc) => command = sc,
                     None => bail!(

diff --git a/assyst-core/src/command/misc/mod.rs b/assyst-core/src/command/misc/mod.rs
@@ -114,7 +114,7 @@ pub async fn exec(ctxt: CommandCtxt<'_>, script: Rest) -> anyhow::Result<()> {
     examples = ["1"]
 )]
 pub async fn eval(ctxt: CommandCtxt<'_>, script: Rest) -> anyhow::Result<()> {
-    let result = fake_eval(&ctxt.assyst(), script.0, true, ctxt.data.message, Vec::new())
+    let result = fake_eval(ctxt.assyst(), script.0, true, ctxt.data.message, Vec::new())
         .await
         .context("Evaluation failed")?;
 

diff --git a/assyst-core/src/command/misc/remind.rs b/assyst-core/src/command/misc/remind.rs
@@ -79,17 +79,18 @@ pub async fn list(ctxt: CommandCtxt<'_>) -> anyhow::Result<()> {
         return Ok(());
     }
 
-    let formatted = reminders
-        .iter()
-        .map(|reminder| {
-            format!(
-                "[#{}] {}: `{}`\n",
-                reminder.id,
-                format_discord_timestamp(reminder.timestamp as u64),
-                reminder.message
-            )
-        })
-        .collect::<String>();
+    let formatted = reminders.iter().fold(String::new(), |mut f, reminder| {
+        use std::fmt::Write;
+        writeln!(
+            f,
+            "[#{}] {}: `{}`",
+            reminder.id,
+            format_discord_timestamp(reminder.timestamp as u64),
+            reminder.message
+        )
+        .unwrap();
+        f
+    });
 
     ctxt.reply(format!(":calendar: **Upcoming Reminders:**\n\n{formatted}"))
         .await?;

diff --git a/assyst-core/src/command/misc/run.rs b/assyst-core/src/command/misc/run.rs
@@ -99,7 +99,7 @@ pub async fn charge(ctxt: CommandCtxt<'_>, script: Codeblock, flags: ChargeFlags
             "\nCompiler: {}\nExecutable: {}\nCommit Hash: {commit_hash}",
             result.exit_code,
             if let Some(b) = bin_result {
-                format!("{} (execution time {:?})", b.exit_code.to_string(), bin_time)
+                format!("{} (execution time {:?})", b.exit_code, bin_time)
             } else {
                 "N/A".to_owned()
             }
@@ -195,7 +195,7 @@ pub async fn dash(ctxt: CommandCtxt<'_>, script: Codeblock) -> anyhow::Result<()
                 EvalError::Exception(unrooted) => {
                     let fmt = format_value(unrooted.root(&mut scope), &mut scope);
                     if let Ok(f) = fmt {
-                        format!("Exception: {}", f.to_string())
+                        format!("Exception: {}", f)
                     } else {
                         format!("Exception: {:?}", fmt.unwrap_err())
                     }

diff --git a/assyst-core/src/command/mod.rs b/assyst-core/src/command/mod.rs
@@ -336,7 +336,7 @@ impl<'a> ParseCtxt<'a, RawMessageArgsIter<'a>> {
     }
 
     pub fn rest_all(&self, _: Label) -> String {
-        self.args.remainder().map(|x| x.to_owned()).unwrap_or(String::new())
+        self.args.remainder().map(|x| x.to_owned()).unwrap_or_default()
     }
 }
 

diff --git a/assyst-core/src/rest/bad_translation.rs b/assyst-core/src/rest/bad_translation.rs
@@ -58,7 +58,7 @@ async fn translate_retry(
     }
 
     if let Some(data) = additional_data {
-        for (k, v) in data.into_iter() {
+        for (k, v) in data.iter() {
             query_args.push((k, v.to_string()));
         }
     }

diff --git a/assyst-core/src/rest/cooltext.rs b/assyst-core/src/rest/cooltext.rs
@@ -38,7 +38,7 @@ pub async fn burn_text(text: &str) -> anyhow::Result<Vec<u8>> {
         .await?;
 
     let url = cool_text_response.render_location;
-    let content = client.get(&url.replace("https", "http")).send().await?.bytes().await?;
+    let content = client.get(url.replace("https", "http")).send().await?.bytes().await?;
 
     let mut hasher = DefaultHasher::new();
     content.hash(&mut hasher);

diff --git a/assyst-core/src/rest/eval.rs b/assyst-core/src/rest/eval.rs
@@ -18,7 +18,7 @@ pub async fn fake_eval(
         .post(format!("{}/eval", CONFIG.urls.eval))
         .query(&[("returnBuffer", accept_image)])
         .json(&FakeEvalBody {
-            code: code,
+            code,
             data: Some(FakeEvalMessageData { args, message }),
         })
         .send()

diff --git a/assyst-core/src/rest/r34.rs b/assyst-core/src/rest/r34.rs
@@ -3,7 +3,7 @@ use anyhow::{bail, Context};
 use rand::prelude::SliceRandom;
 use serde::Deserialize;
 
-static R34_URL: &'static str = "https://api.rule34.xxx/index.php?tags=";
+static R34_URL: &str = "https://api.rule34.xxx/index.php?tags=";
 
 #[derive(Deserialize, Clone)]
 pub struct R34Result {

diff --git a/assyst-core/src/rest/rust.rs b/assyst-core/src/rest/rust.rs
@@ -56,7 +56,11 @@ pub struct ApiResult {
 }
 impl ApiResult {
     pub fn format(&self) -> &str {
-        if self.stdout == "" { &self.stderr } else { &self.stdout }
+        if self.stdout.is_empty() {
+            &self.stderr
+        } else {
+            &self.stdout
+        }
     }
 }
 
@@ -85,6 +89,7 @@ pub async fn godbolt(client: &Client, code: &str) -> Result<String, Error> {
         .join("\n"))
 }
 
+#[allow(clippy::too_many_arguments)]
 pub async fn request(
     client: &Client,
     path: &str,
@@ -152,7 +157,7 @@ pub fn prepend_code(code: &str) -> Cow<str> {
 pub async fn run_miri(client: &Client, code: &str, channel: &str, opt: OptimizationLevel) -> Result<ApiResult, Error> {
     let code = prepend_code(code);
 
-    miri(client, &*code, Some(channel), opt).await
+    miri(client, &code, Some(channel), opt).await
 }
 
 pub async fn run_clippy(
@@ -163,7 +168,7 @@ pub async fn run_clippy(
 ) -> Result<ApiResult, Error> {
     let code = prepend_code(code);
 
-    clippy(client, &*code, Some(channel), opt).await
+    clippy(client, &code, Some(channel), opt).await
 }
 
 pub async fn run_binary(

diff --git a/assyst-core/src/rest/web_media_download.rs b/assyst-core/src/rest/web_media_download.rs
@@ -110,9 +110,7 @@ pub async fn get_web_download_api_urls(assyst: ThreadSafeAssyst) -> anyhow::Resu
     let test_urls = json
         .iter()
         .map(|entry: &InstancesQueryResult| {
-            if entry.protocol == "https" && entry.score >= TEST_SCORE_THRESHOLD {
-                format!("https://{}/api/json", entry.api)
-            } else if entry.api == "api.cobalt.tools" {
+            if (entry.protocol == "https" && entry.score >= TEST_SCORE_THRESHOLD) || (entry.api == "api.cobalt.tools") {
                 format!("https://{}/api/json", entry.api)
             } else {
                 String::new()
@@ -193,7 +191,7 @@ pub async fn download_web_media(assyst: ThreadSafeAssyst, url: &str, opts: WebDo
                             req_result_url = Some(j.url.to_string());
                             break;
                         },
-                        Err(e) => err = format!("Failed to deserialize download url: {}", e.to_string()),
+                        Err(e) => err = format!("Failed to deserialize download url: {}", e),
                     }
                 } else {
                     let try_err = r.text().await;
@@ -224,24 +222,22 @@ pub async fn download_web_media(assyst: ThreadSafeAssyst, url: &str, opts: WebDo
                                         break;
                                     }
                                 },
-                                Err(d_e) => {
-                                    err = format!("Download request failed: {} (raw error: {})", d_e.to_string(), e)
-                                },
+                                Err(d_e) => err = format!("Download request failed: {} (raw error: {})", d_e, e),
                             }
                         },
-                        Err(e) => err = format!("Failed to extract download request error: {}", e.to_string()),
+                        Err(e) => err = format!("Failed to extract download request error: {}", e),
                     }
                 }
             },
             Err(e) => {
-                err = format!("Download request failed: {}", e.to_string());
+                err = format!("Download request failed: {}", e);
             },
         }
     }
 
     if let Some(r) = req_result_url {
         let media = download_content(&assyst, &r, ABSOLUTE_INPUT_FILE_SIZE_LIMIT_BYTES, false).await?;
-        return Ok(media);
+        Ok(media)
     } else if !err.is_empty() {
         bail!("{err}");
     } else {

diff --git a/assyst-core/src/task/tasks/reminders.rs b/assyst-core/src/task/tasks/reminders.rs
@@ -43,12 +43,12 @@ async fn process_single_reminder(assyst: ThreadSafeAssyst, reminder: &Reminder)
 }
 
 async fn process_reminders(assyst: ThreadSafeAssyst, reminders: Vec<Reminder>) -> Result<(), anyhow::Error> {
-    if reminders.len() < 1 {
+    if reminders.is_empty() {
         return Ok(());
     }
 
     for reminder in &reminders {
-        if let Err(e) = process_single_reminder(assyst.clone(), &reminder).await {
+        if let Err(e) = process_single_reminder(assyst.clone(), reminder).await {
             err!("Failed to process reminder: {:?}", e);
         }
 

diff --git a/assyst-core/src/wsi_handler/mod.rs b/assyst-core/src/wsi_handler/mod.rs
@@ -174,11 +174,11 @@ impl WsiHandler {
             return Ok(p.tier as usize);
         }
 
-        let user_tier2 = FreeTier2Requests::get_user_free_tier_2_requests(&*self.database_handler, user_id).await?;
+        let user_tier2 = FreeTier2Requests::get_user_free_tier_2_requests(&self.database_handler, user_id).await?;
 
         if user_tier2.count > 0 {
             user_tier2
-                .change_free_tier_2_requests(&*self.database_handler, -1)
+                .change_free_tier_2_requests(&self.database_handler, -1)
                 .await?;
             Ok(2)
         } else {

diff --git a/assyst-database/src/model/reminder.rs b/assyst-database/src/model/reminder.rs
@@ -68,7 +68,6 @@ impl Reminder {
             .bind(self.message_id)
             .bind(&*self.message)
             .execute(&handler.pool)
-            .await
-            .and_then(|_| Ok(()))
+            .await.map(|_| ())
     }
 }
diff --git a/assyst-tag/src/errors.rs b/assyst-tag/src/errors.rs
@@ -228,7 +228,7 @@ impl<'buf> DiagnosticBuilder<'buf> {
                         NoteKind::Note => {
                             out += &arrows.bold();
                             out += " ";
-                            out += &message;
+                            out += message;
                         },
                     }
                 },

diff --git a/assyst-tag/src/subtags.rs b/assyst-tag/src/subtags.rs
@@ -338,7 +338,7 @@ pub fn set(parser: &mut Parser<'_>, (key, value): (String, String)) -> TResult<S
 pub fn get(parser: &mut Parser<'_>, key: String) -> TResult<String> {
     parser
         .state()
-        .with_variables(|vars| -> TResult<String> { Ok(vars.get(&key).map(Clone::clone).unwrap_or_default()) })
+        .with_variables(|vars| -> TResult<String> { Ok(vars.get(&key).cloned().unwrap_or_default()) })
 }
 
 pub fn delete(parser: &mut Parser<'_>, key: String) -> TResult<String> {
@@ -373,7 +373,7 @@ pub fn sqrt(_: &mut Parser<'_>, arg: f64) -> TResult<String> {
 }
 
 pub fn e(_: &mut Parser<'_>, _: ()) -> TResult<String> {
-    Ok(std::f64::EPSILON.to_string())
+    Ok(f64::EPSILON.to_string())
 }
 
 pub fn pi(_: &mut Parser<'_>, _: ()) -> TResult<String> {