fix unwrap errors

engine/src/core/mod.rs

@@ -6,7 +6,7 @@ use renderer::App;
 use winit::event_loop::{ControlFlow, EventLoop};
 
 pub fn init_renderer() -> Result<()> {
-    let event_loop = EventLoop::new().unwrap();
+    let event_loop = EventLoop::new()?;
     event_loop.set_control_flow(ControlFlow::Poll);
     let mut app = App::default();
     Ok(event_loop.run_app(&mut app)?)

engine/src/core/renderer/ctx.rs

@@ -41,7 +41,9 @@ impl<'window> WgpuCtx<'window> {
         let width = size.width.max(1);
         let height = size.height.max(1);
 
-        let surface_config = surface.get_default_config(&adapter, width, height).unwrap();
+        let surface_config = surface
+            .get_default_config(&adapter, width, height)
+            .expect("Failed to get default surface configuration");
         surface.configure(&device, &surface_config);
 
         Ok(WgpuCtx {
@@ -55,9 +57,7 @@ impl<'window> WgpuCtx<'window> {
 
     pub fn new_blocking(window: Arc<Window>) -> Result<WgpuCtx<'window>> {
         tokio::task::block_in_place(|| {
-            tokio::runtime::Runtime::new()
+            tokio::runtime::Runtime::new()?.block_on(async { WgpuCtx::new(window).await })
-                .unwrap()
-                .block_on(async { WgpuCtx::new(window).await })
         })
     }
 

engine/src/core/repl/repl.rs

@@ -1,12 +1,13 @@
 use std::{
     borrow::Cow::{self, Borrowed, Owned},
-    sync::{Arc, Mutex},
+    sync::Arc,
 };
 
 use anyhow::Result;
 use chrono::Local;
 use colored::Colorize;
 use log::debug;
+use parking_lot::Mutex;
 use regex::Regex;
 use rustyline::{
     error::ReadlineError, highlight::Highlighter, hint::HistoryHinter, history::DefaultHistory,
@@ -49,7 +50,7 @@ impl ConditionalEventHandler for BacktickEventHandler {
     fn handle(&self, evt: &Event, _: RepeatCount, _: bool, _: &EventContext) -> Option<Cmd> {
         if let Some(k) = evt.get(0) {
             if *k == KeyEvent::from('`') {
-                let mut state = self.toggle_state.lock().unwrap();
+                let mut state = self.toggle_state.lock();
                 println!(
                     "Stdout Logging: {}",
                     if *state { "ON".green() } else { "OFF".red() }

engine/src/main.rs

@@ -1,3 +1,5 @@
+#![deny(clippy::unwrap_in_result)]
+
 use anyhow::Result;
 use log::LevelFilter;
 
@@ -11,7 +13,7 @@ async fn main() -> Result<()> {
     let t = zephyr::add(0, 2);
     println!("{}", t);
 
-    log::set_logger(&*LOGGER).unwrap();
+    log::set_logger(&*LOGGER).ok();
     log::set_max_level(LevelFilter::Debug);
 
     print_splash();

engine/src/utils/logger.rs

@@ -1,10 +1,11 @@
 use std::fs::OpenOptions;
 use std::io::{self, Write};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 
 use colored::Colorize;
 use log::{Level, Log, Metadata, Record};
 use once_cell::sync::Lazy;
+use parking_lot::Mutex;
 
 pub static LOGGER: Lazy<DynamicLogger> = Lazy::new(DynamicLogger::new);
 
@@ -28,11 +29,11 @@ impl DynamicLogger {
             .open(file_path)
             .expect("Failed to open log file");
 
-        *self.writer.lock().unwrap() = Box::new(file);
+        *self.writer.lock() = Box::new(file);
     }
 
     pub fn write_to_stdout(&self) {
-        *self.writer.lock().unwrap() = Box::new(io::stdout());
+        *self.writer.lock() = Box::new(io::stdout());
     }
 
     fn colorize_level(level: Level) -> colored::ColoredString {
@@ -58,7 +59,7 @@ impl Log for DynamicLogger {
 
     fn log(&self, record: &Record) {
         if self.enabled(record.metadata()) {
-            let mut writer = self.writer.lock().unwrap();
+            let mut writer = self.writer.lock();
             let level = Self::colorize_level(record.level()); // Apply coloring
             writeln!(
                 writer,
@@ -72,7 +73,7 @@ impl Log for DynamicLogger {
     }
 
     fn flush(&self) {
-        let mut writer = self.writer.lock().unwrap();
+        let mut writer = self.writer.lock();
         writer.flush().unwrap();
     }
 }