chore: lint unused unwraps

src/app_data/mod.rs

@@ -87,7 +87,8 @@ impl AppData {
         }
     }
 
-    // Current time as unix timestamp
+    /// Current time as unix timestamp
+    #[allow(clippy::expect_used)]
     fn get_systemtime(&self) -> u64 {
         SystemTime::now()
             .duration_since(UNIX_EPOCH)

src/main.rs

@@ -1,3 +1,13 @@
+#![forbid(unsafe_code)]
+#![warn(clippy::unused_async, clippy::unwrap_used, clippy::expect_used)]
+// Wanring - These are indeed pedantic
+// #![warn(clippy::pedantic)]
+// #![warn(clippy::nursery)]
+// #![allow(clippy::module_name_repetitions, clippy::doc_markdown)]
+
+// Only allow when debugging
+// #![allow(unused)]
+
 use app_data::AppData;
 use app_error::AppError;
 use bollard::Docker;
@@ -35,7 +45,10 @@ async fn main() {
     let (docker_sx, docker_rx) = tokio::sync::mpsc::channel(16);
 
     // Create docker daemon handler, and only spawn up the docker data handler if ping returns non-error
-    let docker = Arc::new(Docker::connect_with_socket_defaults().unwrap());
+
+    match Docker::connect_with_socket_defaults() {
+        Ok(docker) => {
+            let docker = Arc::new(docker);
             match docker.ping().await {
                 Ok(_) => {
                     let docker = Arc::clone(&docker);
@@ -51,7 +64,9 @@ async fn main() {
                 }
                 Err(_) => app_data.lock().set_error(AppError::DockerConnect),
             }
-
+        }
+        Err(_) => app_data.lock().set_error(AppError::DockerConnect),
+    }
     let input_app_data = Arc::clone(&app_data);
 
     let (input_sx, input_rx) = tokio::sync::mpsc::channel(16);

src/ui/mod.rs

@@ -94,9 +94,12 @@ async fn run_app<B: Backend>(
                     is_running.store(false, Ordering::SeqCst);
                     break;
                 }
-                terminal
+                if terminal
                     .draw(|f| draw_error(f, AppError::DockerConnect, Some(seconds)))
-                    .unwrap();
+                    .is_err()
+                {
+                    return Err(AppError::Terminal);
+                }
                 tokio::time::sleep(std::time::Duration::from_secs(1)).await;
                 seconds -= 1;
             }
@@ -104,7 +107,9 @@ async fn run_app<B: Backend>(
     } else {
         let mut now = Instant::now();
         loop {
-            terminal.draw(|f| ui(f, &app_data, &gui_state)).unwrap();
+            if terminal.draw(|f| ui(f, &app_data, &gui_state)).is_err() {
+                return Err(AppError::Terminal);
+            }
             if crossterm::event::poll(input_poll_rate).unwrap_or_default() {
                 if let Ok(event) = event::read() {
                     if let Event::Key(key) = event {