clippy

6 files changed, 84 insertions, 25 deletions

diff --git a/src/bin/ttyplay/display.rs b/src/bin/ttyplay/display.rs
index 906836f..09f7397 100644
--- a/src/bin/ttyplay/display.rs
+++ b/src/bin/ttyplay/display.rs
@@ -188,7 +188,9 @@ impl Display {
             output.move_to(size.0 - 1, 0);
             output.write_str("/");
             output.write_str(search);
-            output.write_str(&" ".repeat(size.1 as usize - search.len() - 1));
+            output.write_str(
+                &" ".repeat(usize::from(size.1) - search.len() - 1),
+            );
         }
     }
 }
diff --git a/src/bin/ttyplay/event.rs b/src/bin/ttyplay/event.rs
index e87699b..534b761 100644
--- a/src/bin/ttyplay/event.rs
+++ b/src/bin/ttyplay/event.rs
@@ -1,5 +1,5 @@
 pub enum Event {
-    FrameTransition((usize, vt100::Screen)),
+    FrameTransition((usize, Box<vt100::Screen>)),
     FrameLoaded(Option<usize>),
     Paused(bool),
     Speed(u32),
@@ -9,6 +9,7 @@ pub enum Event {
     ActiveSearch(String),
     CancelSearch,
     RunSearch(String, bool),
+    Error(anyhow::Error),
     Quit,
 }
 
@@ -70,7 +71,7 @@ impl Reader {
 
 #[derive(Default)]
 struct Pending {
-    render: Option<(usize, vt100::Screen)>,
+    render: Option<(usize, Box<vt100::Screen>)>,
     frame_loaded: Option<usize>,
     done_loading: bool,
     paused: Option<bool>,
@@ -81,6 +82,7 @@ struct Pending {
     active_search: Option<String>,
     cancel_search: bool,
     run_search: Option<(String, bool)>,
+    error: Option<anyhow::Error>,
     quit: bool,
 }
 
@@ -131,6 +133,9 @@ impl Pending {
                 self.cancel_search = false;
                 self.run_search = Some((s, backwards));
             }
+            Event::Error(e) => {
+                self.error = Some(e);
+            }
             Event::Quit => {
                 self.quit = true;
             }
@@ -149,11 +154,14 @@ impl Pending {
             || self.active_search.is_some()
             || self.cancel_search
             || self.run_search.is_some()
+            || self.error.is_some()
             || self.quit
     }
 
     fn get_event(&mut self) -> Option<Event> {
-        if self.quit {
+        if let Some(e) = self.error.take() {
+            Some(Event::Error(e))
+        } else if self.quit {
             self.quit = false;
             Some(Event::Quit)
         } else if let Some(action) = self.timer_actions.pop_front() {
@@ -202,7 +210,7 @@ pub async fn handle_events(
                 continue;
             }
             Event::FrameTransition((idx, screen)) => {
-                display.screen(screen);
+                display.screen(*screen);
                 display.current_frame(idx);
             }
             Event::FrameLoaded(n) => {
@@ -234,6 +242,9 @@ pub async fn handle_events(
                 display.clear_search();
                 timer_w.send(TimerAction::Search(s, backwards)).await?;
             }
+            Event::Error(e) => {
+                return Err(e);
+            }
             Event::Quit => {
                 break;
             }
diff --git a/src/bin/ttyplay/frames.rs b/src/bin/ttyplay/frames.rs
index dd60a21..55c41a8 100644
--- a/src/bin/ttyplay/frames.rs
+++ b/src/bin/ttyplay/frames.rs
@@ -73,12 +73,17 @@ impl FrameData {
         self.new_frame_w
             .send(Some(self.frames.len()))
             .await
-            .unwrap();
+            // new_frame_w is never closed, so this can never fail
+            .unwrap_or_else(|_| unreachable!());
     }
 
     pub async fn done_reading(&mut self) {
         self.done_reading = true;
-        self.new_frame_w.send(None).await.unwrap();
+        self.new_frame_w
+            .send(None)
+            .await
+            // new_frame_w is never closed, so this can never fail
+            .unwrap_or_else(|_| unreachable!());
     }
 
     pub fn wait_for_frame(
@@ -95,7 +100,12 @@ impl FrameData {
         }
         let new_frame_r = self.new_frame_r.clone();
         Box::pin(async move {
-            while let Some(new_len) = new_frame_r.recv().await.unwrap() {
+            while let Some(new_len) = new_frame_r
+                .recv()
+                .await
+                // new_frame_r is never closed, so this can never fail
+                .unwrap_or_else(|_| unreachable!())
+            {
                 if i < new_len {
                     return true;
                 }
@@ -141,13 +151,15 @@ pub fn load_from_file(
             event_w
                 .send(crate::event::Event::FrameLoaded(Some(frames.count())))
                 .await
-                .unwrap();
+                // event_w is never closed, so this can never fail
+                .unwrap_or_else(|_| unreachable!());
             prev_delay = delay;
         }
         frames.lock_arc().await.done_reading().await;
         event_w
             .send(crate::event::Event::FrameLoaded(None))
             .await
-            .unwrap();
+            // event_w is never closed, so this can never fail
+            .unwrap_or_else(|_| unreachable!());
     });
 }
diff --git a/src/bin/ttyplay/input.rs b/src/bin/ttyplay/input.rs
index f69423b..e6cf74b 100644
--- a/src/bin/ttyplay/input.rs
+++ b/src/bin/ttyplay/input.rs
@@ -5,7 +5,19 @@ pub fn spawn_task(
     async_std::task::spawn(async move {
         let mut search: Option<String> = None;
         let mut prev_search = None;
-        while let Some(key) = input.read_key().await.unwrap() {
+        loop {
+            let key = match input.read_key().await {
+                Ok(Some(key)) => key,
+                Ok(None) => break,
+                Err(e) => {
+                    event_w
+                        .send(crate::event::Event::Error(anyhow::anyhow!(e)))
+                        .await
+                        // event_w is never closed, so this can never fail
+                        .unwrap_or_else(|_| unreachable!());
+                    break;
+                }
+            };
             if let Some(ref mut search_contents) = search {
                 match key {
                     textmode::Key::Char(c) => {
@@ -15,7 +27,8 @@ pub fn spawn_task(
                                 search_contents.clone(),
                             ))
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                     }
                     textmode::Key::Backspace => {
                         search_contents.pop();
@@ -24,7 +37,8 @@ pub fn spawn_task(
                                 search_contents.clone(),
                             ))
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                     }
                     textmode::Key::Ctrl(b'm') => {
                         event_w
@@ -33,7 +47,8 @@ pub fn spawn_task(
                                 false,
                             ))
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                         prev_search = search;
                         search = None;
                     }
@@ -41,7 +56,8 @@ pub fn spawn_task(
                         event_w
                             .send(crate::event::Event::CancelSearch)
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                         search = None;
                     }
                     _ => {}
@@ -121,7 +137,8 @@ pub fn spawn_task(
                     }
                     _ => continue,
                 };
-                event_w.send(event).await.unwrap();
+                // event_w is never closed, so this can never fail
+                event_w.send(event).await.unwrap_or_else(|_| unreachable!());
             }
         }
     });
diff --git a/src/bin/ttyplay/main.rs b/src/bin/ttyplay/main.rs
index c1cebc9..401266c 100644
--- a/src/bin/ttyplay/main.rs
+++ b/src/bin/ttyplay/main.rs
@@ -1,7 +1,15 @@
+#![warn(clippy::cargo)]
 #![warn(clippy::pedantic)]
 #![warn(clippy::nursery)]
+#![warn(clippy::unwrap_used)]
+#![warn(clippy::expect_used)]
+#![warn(clippy::indexing_slicing)]
+#![warn(clippy::as_conversions)]
+#![allow(clippy::cognitive_complexity)]
 #![allow(clippy::missing_const_for_fn)]
+#![allow(clippy::similar_names)]
 #![allow(clippy::struct_excessive_bools)]
+#![allow(clippy::too_many_arguments)]
 #![allow(clippy::too_many_lines)]
 
 mod display;
diff --git a/src/bin/ttyplay/timer.rs b/src/bin/ttyplay/timer.rs
index 0cd66a6..6b4e17f 100644
--- a/src/bin/ttyplay/timer.rs
+++ b/src/bin/ttyplay/timer.rs
@@ -16,7 +16,8 @@ pub fn spawn_task(
             event_w
                 .send(crate::event::Event::Paused(true))
                 .await
-                .unwrap();
+                // event_w is never closed, so this can never fail
+                .unwrap_or_else(|_| unreachable!());
             Some(start_time)
         } else {
             None
@@ -25,7 +26,7 @@ pub fn spawn_task(
         let mut playback_ratio = 2_u32.pow(speed);
         loop {
             enum Res {
-                Wait(Option<vt100::Screen>),
+                Wait(Option<Box<vt100::Screen>>),
                 TimerAction(
                     Result<
                         crate::event::TimerAction,
@@ -62,7 +63,7 @@ pub fn spawn_task(
                         )
                         .await;
                     }
-                    Res::Wait(Some(frame.into_screen()))
+                    Res::Wait(Some(Box::new(frame.into_screen())))
                 } else {
                     Res::Wait(None)
                 }
@@ -75,7 +76,8 @@ pub fn spawn_task(
                             idx, screen,
                         )))
                         .await
-                        .unwrap();
+                        // event_w is never closed, so this can never fail
+                        .unwrap_or_else(|_| unreachable!());
                     idx += 1;
                 }
                 Res::Wait(None) => {
@@ -84,7 +86,8 @@ pub fn spawn_task(
                     event_w
                         .send(crate::event::Event::Paused(true))
                         .await
-                        .unwrap();
+                        // event_w is never closed, so this can never fail
+                        .unwrap_or_else(|_| unreachable!());
                 }
                 Res::TimerAction(Ok(action)) => match action {
                     crate::event::TimerAction::Pause => {
@@ -99,7 +102,8 @@ pub fn spawn_task(
                                 paused_time.is_some(),
                             ))
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                     }
                     crate::event::TimerAction::FirstFrame => {
                         idx = 0;
@@ -128,7 +132,9 @@ pub fn spawn_task(
                                     playback_ratio,
                                 ))
                                 .await
-                                .unwrap();
+                                // event_w is never closed, so this can never
+                                // fail
+                                .unwrap_or_else(|_| unreachable!());
                         }
                     }
                     crate::event::TimerAction::SlowDown => {
@@ -141,7 +147,9 @@ pub fn spawn_task(
                                     playback_ratio,
                                 ))
                                 .await
-                                .unwrap();
+                                // event_w is never closed, so this can never
+                                // fail
+                                .unwrap_or_else(|_| unreachable!());
                         }
                     }
                     crate::event::TimerAction::DefaultSpeed => {
@@ -152,7 +160,8 @@ pub fn spawn_task(
                         event_w
                             .send(crate::event::Event::Speed(playback_ratio))
                             .await
-                            .unwrap();
+                            // event_w is never closed, so this can never fail
+                            .unwrap_or_else(|_| unreachable!());
                     }
                     crate::event::TimerAction::Search(s, backwards) => {
                         if let Some(new_idx) =