optimize codebase

Author: Tricked-dev

src/ai_message.rs

@@ -1,15 +1,13 @@
-use std::sync::Arc;
 
 use color_eyre::Result;
-use parking_lot::RwLock;
 use r2d2_sqlite::SqliteConnectionManager;
-use rig::prelude::*;
 use rig::{
     completion::{Prompt, ToolDefinition},
+    prelude::*,
     providers,
     tool::Tool,
 };
-use rusqlite::{params, Connection};
+use rusqlite::params;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use serde_rusqlite::from_row;
@@ -151,24 +149,34 @@ impl Tool for SocialCredit {
     async fn call(&self, mut args: Self::Args) -> Result<Self::Output, Self::Error> {
         let mut user = {
             let db = self.0.get()?;
-            let mut stm = db.prepare("SELECT * FROM user WHERE id = ?").map_err(|err| color_eyre::eyre::eyre!("Failed to prepare SQL query: {}", err))?;
+            let mut stm = db
+                .prepare("SELECT * FROM user WHERE id = ?")
+                .map_err(|err| color_eyre::eyre::eyre!("Failed to prepare SQL query: {}", err))?;
             stm.query_one([self.1.to_string()], |row| {
                 from_row::<User>(row).map_err(|_| rusqlite::Error::QueryReturnedNoRows)
             })
-            .map_err(|err| color_eyre::eyre::eyre!("Failed to query SQL query: {:?}", err)).unwrap()
+            .map_err(|err| color_eyre::eyre::eyre!("Failed to query SQL query: {:?}", err))
+            .unwrap()
         };
-        
+
         if args.remove == Some(true) && args.social_credit > 0 {
             args.social_credit = -args.social_credit;
         }
 
         user.social_credit += args.social_credit;
-        user.update_sync(&*self.0.get()?).map_err(|err| color_eyre::eyre::eyre!("Failed to update SQL query: {:?}", err)).unwrap();
+        user.update_sync(&*self.0.get()?)
+            .map_err(|err| color_eyre::eyre::eyre!("Failed to update SQL query: {:?}", err))
+            .unwrap();
         Ok(user.social_credit)
     }
 }
 
-pub async fn main(database: r2d2::Pool<SqliteConnectionManager>, user_id: u64, message: &str, context: &str) -> Result<String> {
+pub async fn main(
+    database: r2d2::Pool<SqliteConnectionManager>,
+    user_id: u64,
+    message: &str,
+    context: &str,
+) -> Result<String> {
     // Create OpenAI client
     let openai_client = providers::openai::Client::from_env();
 
@@ -177,12 +185,12 @@ pub async fn main(database: r2d2::Pool<SqliteConnectionManager>, user_id: u64, m
     {
         let db = database.get()?;
         let mut stm = db.prepare("SELECT * FROM memory WHERE user_id = ?")?;
-        let mut rows = stm
+        let rows = stm
             .query_map(params![user_id], |row| {
                 from_row::<database::Memory>(row).map_err(|err| rusqlite::Error::InvalidColumnName(err.to_string()))
             })?
             .flatten();
-        while let Some(row) = rows.next() {
+        for row in rows {
             memory.push_str(&format!("{}: {}\n", row.key, row.content));
         }
     }

src/commands/invite_stats.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use serde_rusqlite::{from_row, from_rows};
 use tokio::sync::Mutex;
 
-use twilight_model::{gateway::presence::UserOrId, id::{marker::UserMarker, Id}};
+use twilight_model::id::{marker::UserMarker, Id};
 use vesper::{
     prelude::*,
     twilight_exports::{InteractionResponse, InteractionResponseData, InteractionResponseType},
@@ -15,8 +15,13 @@ use crate::{database::User, structs::State, utils::levels::xp_required_for_level
 
 #[command]
 #[description = "Level "]
-pub async fn level(ctx: &SlashContext<'_, Arc<Mutex<State>>>, #[description = "The user to level up"] user: Option<Id<UserMarker>>) -> DefaultCommandResult {
-    let id = user.unwrap_or(ctx.interaction.member.clone().unwrap().user.unwrap().id).get();
+pub async fn level(
+    ctx: &SlashContext<'_, Arc<Mutex<State>>>,
+    #[description = "The user to level up"] user: Option<Id<UserMarker>>,
+) -> DefaultCommandResult {
+    let id = user
+        .unwrap_or(ctx.interaction.member.clone().unwrap().user.unwrap().id)
+        .get();
     let state = ctx.data.lock().await;
 
     let user = {
@@ -43,7 +48,6 @@ pub async fn level(ctx: &SlashContext<'_, Arc<Mutex<State>>>, #[description = "T
             .prepare("SELECT * FROM user WHERE level != 0 ORDER BY level DESC")
             .unwrap();
         from_rows::<User>(statement.query([]).unwrap())
-            .into_iter()
             .flatten()
             .collect::<Vec<User>>()
     };

src/commands/level.rs

@@ -1,3 +1 @@
-pub mod invite_stats;
 pub mod level;
-pub mod roms;

src/commands/mod.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use wb_sqlite::{CreateTableSql, InsertSync, UpdateSync};
 
-use serde:: Deserializer;
+use serde::Deserializer;
 use std::fmt;
 
 fn u64_from_str_or_int<'de, D>(deserializer: D) -> Result<u64, D::Error>
@@ -10,7 +10,7 @@ where
 {
     struct U64Visitor;
 
-    impl<'de> serde::de::Visitor<'de> for U64Visitor {
+    impl serde::de::Visitor<'_> for U64Visitor {
         type Value = u64;
 
         fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {