fix all warnings

Author: Sturdyfool11

src/app_state.rs

@@ -15,6 +15,7 @@ pub struct AppState {
     pub config: Arc<Mutex<Config>>,
     pub slave_servers: Arc<Mutex<Vec<ServerInfo>>>,
     pub slave_connections: Arc<Mutex<Vec<SlaveConnection>>>,
+    #[allow(dead_code)]
     pub global_crash_prevention: Arc<AtomicBool>,
     pub specialization_registry: Arc<SpecializationRegistry>,
 }

src/controlled_program.rs

@@ -125,7 +125,7 @@ impl Drop for ControlledProgramInstance {
         // Attempt to kill the process if it's still running
         if let Some(id) = self.process.id() {
             // Try to kill the process gracefully
-            let _ = self.process.kill();
+            std::mem::drop(self.process.kill());
             tracing::info!(
                 "Terminated server process '{}' (PID {}) on drop.",
                 self.name,
@@ -143,7 +143,7 @@ impl ControlledProgramInstance {
         // Ensure the working directory exists, create if it doesn't
         let working_dir_path = Path::new(&working_dir);
         if !working_dir_path.exists() {
-            if let Err(e) = fs::create_dir_all(&working_dir_path) {
+            if let Err(e) = fs::create_dir_all(working_dir_path) {
                 panic!(
                     "Failed to create working directory {:?}: {}",
                     working_dir_path, e
@@ -232,7 +232,7 @@ impl ControlledProgramInstance {
         if inp < 150 {
             inp = 0;
         } else {
-            inp = inp - 150;
+            inp -= 150;
         }
         self.curr_output_in_progress = lines[std::cmp::max(0, inp)..lines.len()].join("\n");
         if out.is_empty() {

src/main.rs

@@ -29,7 +29,7 @@ use crate::{
 #[tokio::main]
 async fn main() -> Result<(), String> {
     let config = load_json("config.json");
-    let slave: bool = config.slave.clone();
+    let slave: bool = config.slave;
     tracing_subscriber::FmtSubscriber::builder()
         .pretty()
         .with_line_number(false)
@@ -42,17 +42,16 @@ async fn main() -> Result<(), String> {
     let (tx, _rx) = broadcast::channel(100);
     let specialization_registry = specializations::init_builtin_registry();
     let mut app_state = app_state::AppState::new(tx, config, specialization_registry);
-    let handles: Vec<tokio::task::JoinHandle<()>>;
-    if slave {
-        handles = spawn_tasks!(app_state.clone(), start_servers, start_slave)
+    let handles: Vec<tokio::task::JoinHandle<()>> = if slave {
+        spawn_tasks!(app_state.clone(), start_servers, start_slave)
     } else {
-        handles = spawn_tasks!(
+        spawn_tasks!(
             app_state.clone(),
             start_web_server,
             start_servers,
             create_slave_connections
-        );
-    }
+        )
+    };
     {
         info!("Starting {} tasks", handles.len());
     }
@@ -72,7 +71,9 @@ async fn main() -> Result<(), String> {
     };
 
     // Ctrl+C handler
+    #[allow(unused_variables)]
     let app_state_clone_ctrlc = app_state.clone();
+    let _app_state_clone_ctrlc = app_state.clone();
     tokio::spawn({
         let shutdown = shutdown.clone();
         async move {
@@ -83,7 +84,9 @@ async fn main() -> Result<(), String> {
     });
 
     // T key handler
+    #[allow(unused_variables)]
     let app_state_clone_t = app_state.clone();
+    let _app_state_clone_t = app_state.clone();
     tokio::spawn({
         let shutdown = shutdown.clone();
         async move {
@@ -226,8 +229,10 @@ Theme files are JSON files that define colors for the UI. Each theme should have
         }
 
         // Create custom theme example (purple-based theme)
-        let mut custom_theme = Theme::default();
-        custom_theme.name = "Purple Dream".to_string();
+        let mut custom_theme = Theme {
+            name: "Purple Dream".to_string(),
+            ..Theme::default()
+        };
 
         // Use public oklch function to create colors
         custom_theme.primary = oklch(0.7, 0.25, 290.0); // Vibrant purple

src/master.rs

@@ -65,9 +65,7 @@ impl SlaveConnection {
                             // Handle the message, e.g., if it's a text message
                             if let Message::Text(text) = msg {
                                 let js: Result<Value, _> = serde_json::from_str(&text);
-                                let js2: Value;
-                                if js.is_ok() {
-                                    js2 = js.unwrap();
+                                if let Ok(js2) = js {
                                     match js2["type"].as_str().unwrap() {
                                         "ServerInfo" => {
                                             let serde_res = serde_json::from_str(&text);
@@ -78,7 +76,8 @@ impl SlaveConnection {
                                                 let s_message =
                                                     serde_json::to_string(&_sinfo).unwrap();
                                                 let s_def = serde_json::to_string(&def).unwrap();
-                                                if s_message != s_def && _sinfo.servers.len() != 0 {
+                                                if s_message != s_def && !_sinfo.servers.is_empty()
+                                                {
                                                     for server_info in _sinfo.servers.iter() {
                                                         let new_info = ServerInfo {
                                                             name: server_info.name.clone(),
@@ -138,6 +137,8 @@ impl SlaveConnection {
             Err("No active connection".into())
         }
     }
+
+    #[allow(dead_code)]
     pub async fn write_stdin(
         &mut self,
         server_name: String,
@@ -164,6 +165,7 @@ impl SlaveConnection {
         Ok(())
     }
 }
+
 pub async fn create_slave_connections(state: AppState) {
     let mut slaves: Vec<SlaveConnection> = vec![];
     let conf = state.config.lock().await;

src/servers.rs

@@ -115,29 +115,22 @@ pub async fn process_stdout(state: AppState) {
             }
             //all of our process are valid at this point, no need to even be careful about it
             for server in servers.iter_mut() {
-                let str = match tokio::time::timeout(
+                let str = tokio::time::timeout(
                     tokio::time::Duration::from_secs_f64(1. / 10.),
                     server.read_output(),
                 )
                 .await
-                {
-                    Ok(val) => val,
-                    _ => None,
-                };
-                match str {
-                    Some(val) => {
-                        if !val.is_empty() {
-                            let out = ConsoleOutput {
-                                r#type: "ServerOutput".to_owned(),
-                                output: val,
-                                server_name: server.name.clone(),
-                                server_type: server.specialized_server_type.clone(),
-                            };
-                            let _ = state.tx.send(serde_json::to_string(&out).unwrap());
-                        }
+                .unwrap_or_default();
+                if let Some(val) = str {
+                    if !val.is_empty() {
+                        let out = ConsoleOutput {
+                            r#type: "ServerOutput".to_owned(),
+                            output: val,
+                            server_name: server.name.clone(),
+                            server_type: server.specialized_server_type.clone(),
+                        };
+                        let _ = state.tx.send(serde_json::to_string(&out).unwrap());
                     }
-
-                    _ => {}
                 }
             }
             drop(servers);

src/specializations/minecraft.rs

@@ -7,8 +7,9 @@ use serde_json::{json, Value};
 use std::path::Path;
 
 /// Minecraft specialization struct.
-/// Holds any state needed for Minecraft-specific logic.
+
 #[derive(Default)]
+
 pub struct MinecraftSpecialization {
     // No internal state needed; all info is stored in ControlledProgramInstance
 }
@@ -57,6 +58,7 @@ impl ServerSpecialization for MinecraftSpecialization {
         // Ready regex
         let ready_pattern = Regex::new(r#"Done \(\d+\.\d+s\)! For help, type "help""#).unwrap();
 
+        #[allow(clippy::type_complexity)]
         let mut update_info =
             |f: &mut dyn FnMut(&mut usize, usize, &mut bool, &mut Vec<String>)| {
                 if let Some(Value::Object(ref mut obj)) = instance.specialized_server_info {

src/specializations/mod.rs

@@ -9,21 +9,14 @@ use std::sync::Arc;
 
 pub trait ServerSpecialization: Send + Sync {
     /// Called when the specialization is first attached to a server instance.
-
     fn init(&mut self, instance: &mut ControlledProgramInstance);
-
     /// Called for each output line from the server process.
-
     /// Takes ownership of the log line. Return Some(String) to transform the line, None to omit it.
-
     fn parse_output(
         &mut self,
-
         line: String,
-
         instance: &mut ControlledProgramInstance,
     ) -> Option<String>;
-
     /// Called when the server process exits.
     /// Allows the specialization to handle exit-specific logic (e.g., EULA patching, auto-restart).
     /// Default implementation does nothing.
@@ -35,11 +28,8 @@ pub trait ServerSpecialization: Send + Sync {
     ) {
         // Default: do nothing
     }
-
     /// Returns the current status/info for this specialization.
-
     #[allow(unused)]
-
     fn get_status(&self) -> serde_json::Value;
 }
 
@@ -93,7 +83,3 @@ pub fn init_builtin_registry() -> Arc<SpecializationRegistry> {
     registry.register("Terraria", terraria::factory);
     registry
 }
-
-// pub mod minecraft;
-// pub mod terraria;
-// (Uncomment and implement these modules as you migrate logic.)

src/theme.rs

@@ -9,8 +9,9 @@ use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 
 /// Represents the available color spaces that can be used for themes
-#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, Default)]
 pub enum ThemeColorSpace {
+    #[default]
     Oklch,
     Oklab,
     Lch,
@@ -26,12 +27,6 @@ pub enum ThemeColorSpace {
     Xyz,
 }
 
-impl Default for ThemeColorSpace {
-    fn default() -> Self {
-        ThemeColorSpace::Oklch // Default to Oklch as it's perceptually uniform and uses polar coordinates
-    }
-}
-
 /// A struct representing a complete theme for the application
 /// Contains all CSS variables needed to style the UI
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -103,9 +98,10 @@ fn oklab_to_color(l: f64, a: f64, b: f64, alpha: f64) -> Color {
 impl Theme {
     /// Creates a new theme with the specified name
     pub fn new(name: &str) -> Self {
-        let mut theme = Self::default();
-        theme.name = name.to_string();
-        theme
+        Self {
+            name: name.to_string(),
+            ..Self::default()
+        }
     }
 
     /// Create a light theme variant
@@ -309,7 +305,7 @@ impl Theme {
                 let path = entry.path();
 
                 // Only check JSON files
-                if path.extension().map_or(false, |ext| ext == "json") {
+                if path.extension().is_some_and(|ext| ext == "json") {
                     if let Ok(json) = fs::read_to_string(&path) {
                         if let Ok(theme) = serde_json::from_str::<Theme>(&json) {
                             if theme.name == theme_name {
@@ -506,7 +502,7 @@ impl ThemeCollection {
             let path = entry.path();
 
             // Only process JSON files
-            if path.extension().map_or(false, |ext| ext == "json") {
+            if path.extension().is_some_and(|ext| ext == "json") {
                 match Theme::load_from_file(&path) {
                     Ok(theme) => {
                         collection.add_theme(theme);

src/webserver.rs

@@ -29,13 +29,11 @@ async fn get_router(_state: AppState) -> Router<AppState> {
 }
 async fn handle_icon(State(_state): State<AppState>) -> impl IntoResponse {
     let ico_bytes: &'static [u8] = include_bytes!("html_src/icon.ico");
-    let response = Response::builder()
+    Response::builder()
         .status(StatusCode::OK)
         .header("Content-Type", "image/x-icon")
         .body(Body::from(ico_bytes))
-        .unwrap();
-
-    response
+        .unwrap()
 }
 #[no_mangle]
 pub async fn start_web_server(_state: AppState) {

src/websocket.rs

@@ -21,10 +21,13 @@ fn utf8bytes_to_string(bytes: Utf8Bytes) -> String {
     bytes.to_string()
 }
 
+#[allow(unused_imports)]
+use crate::master::SlaveConnection;
+#[allow(unused_imports)]
+use crate::servers::send_termination_message;
 use crate::{
     app_state::AppState, configuration::Config, controlled_program::ControlledProgramDescriptor,
-    master::SlaveConnection, messages::*, servers::send_termination_message,
-    theme::ThemeCollection,
+    messages::*, theme::ThemeCollection,
 };
 #[no_mangle]
 pub async fn handle_ws_upgrade(ws: WebSocketUpgrade, State(state): State<AppState>) -> Response {
@@ -127,10 +130,8 @@ async fn process_message(text: String, state: AppState) {
                 .unwrap_or_else(|| "themes".to_string());
             drop(config);
 
-            let theme_collection = match ThemeCollection::load_from_directory(&themes_folder) {
-                Ok(collection) => collection,
-                Err(_) => ThemeCollection::default(),
-            };
+            let theme_collection =
+                ThemeCollection::load_from_directory(&themes_folder).unwrap_or_default();
 
             let theme_names: Vec<String> = theme_collection
                 .themes
@@ -148,6 +149,7 @@ async fn process_message(text: String, state: AppState) {
         }
         "getThemeCSS" => {
             #[derive(Deserialize)]
+            #[allow(dead_code)]
             struct GetThemeCSSWeb {
                 r#type: String,
                 theme_name: String,
@@ -169,10 +171,8 @@ async fn process_message(text: String, state: AppState) {
                 .unwrap_or_else(|| "themes".to_string());
             drop(config);
 
-            let theme_collection = match ThemeCollection::load_from_directory(&themes_folder) {
-                Ok(collection) => collection,
-                Err(_) => ThemeCollection::default(),
-            };
+            let theme_collection =
+                ThemeCollection::load_from_directory(&themes_folder).unwrap_or_default();
 
             let css = if let Some(theme) = theme_collection
                 .themes
@@ -227,14 +227,14 @@ async fn process_message(text: String, state: AppState) {
                     specialized_info: server.specialized_server_info.clone(),
                     host: None,
                 };
-                if val.arguments.get(0).copied().unwrap_or(false) {
+                if val.arguments.first().copied().unwrap_or(false) {
                     let cl: String = server.curr_output_in_progress.clone();
                     let split: Vec<&str> = cl.split("\n").collect();
                     let mut inp = split.len();
                     if inp < 150 {
                         inp = 0;
                     } else {
-                        inp = inp - 150;
+                        inp -= 150;
                     }
                     s_info.output = split[inp..split.len()].join("\n");
                 }
@@ -283,7 +283,7 @@ async fn process_message(text: String, state: AppState) {
                     drop(servers);
                     let config = state.config.lock().await;
                     #[allow(unused)]
-                    let slave = config.slave.clone();
+                    let slave = config.slave;
                     drop(config);
                     // If not active, and value is "start", start the server
                     if !is_active_server && value.value == "start" {
@@ -311,6 +311,7 @@ async fn process_message(text: String, state: AppState) {
         }
         "configChange" => {
             #[derive(Deserialize)]
+            #[allow(dead_code)]
             struct ConfigChangeMessage {
                 r#type: String,
                 #[serde(alias = "updatedConfig", alias = "updated_config")]