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,23 +45,28 @@ 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.ping().await {
+    match Docker::connect_with_socket_defaults() {
-        Ok(_) => {
+        Ok(docker) => {
-            let docker = Arc::clone(&docker);
+            let docker = Arc::new(docker);
-            let is_running = Arc::clone(&is_running);
+            match docker.ping().await {
-            tokio::spawn(DockerData::init(
+                Ok(_) => {
-                docker_args,
+                    let docker = Arc::clone(&docker);
-                docker_app_data,
+                    let is_running = Arc::clone(&is_running);
-                docker,
+                    tokio::spawn(DockerData::init(
-                docker_gui_state,
+                        docker_args,
-                docker_rx,
+                        docker_app_data,
-                is_running,
+                        docker,
-            ));
+                        docker_gui_state,
+                        docker_rx,
+                        is_running,
+                    ));
+                }
+                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/color_match.rs

@@ -24,7 +24,7 @@ pub mod log_sanitizer {
                     if i.reversed.is_some() {
                         style.add_modifier(Modifier::REVERSED);
                     }
-                    if  i.intensity == Some(Intensity::Bold) {
+                    if i.intensity == Some(Intensity::Bold) {
                         style.add_modifier(Modifier::BOLD);
                     }
                     if i.hidden.is_some() {

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 {