refactor: remove App from simple templates (#94)

Author: orhun

simple-async-generated/src/app.rs

@@ -1,6 +1,12 @@
-pub use app::App;
-
-pub mod app;
+use color_eyre::Result;
+use crossterm::event::{Event, EventStream, KeyCode, KeyEvent, KeyEventKind, KeyModifiers};
+use futures::{FutureExt, StreamExt};
+use ratatui::{
+    style::Stylize,
+    text::Line,
+    widgets::{Block, Paragraph},
+    DefaultTerminal, Frame,
+};
 
 #[tokio::main]
 async fn main() -> color_eyre::Result<()> {
@@ -10,3 +16,89 @@ async fn main() -> color_eyre::Result<()> {
     ratatui::restore();
     result
 }
+
+#[derive(Debug, Default)]
+pub struct App {
+    /// Is the application running?
+    running: bool,
+    // Event stream.
+    event_stream: EventStream,
+}
+
+impl App {
+    /// Construct a new instance of [`App`].
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Run the application's main loop.
+    pub async fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> {
+        self.running = true;
+        while self.running {
+            terminal.draw(|frame| self.draw(frame))?;
+            self.handle_crossterm_events().await?;
+        }
+        Ok(())
+    }
+
+    /// Renders the user interface.
+    ///
+    /// This is where you add new widgets. See the following resources for more information:
+    /// - <https://docs.rs/ratatui/latest/ratatui/widgets/index.html>
+    /// - <https://github.com/ratatui/ratatui/tree/master/examples>
+    fn draw(&mut self, frame: &mut Frame) {
+        let title = Line::from("Ratatui Simple Template")
+            .bold()
+            .blue()
+            .centered();
+        let text = "Hello, Ratatui!\n\n\
+            Created using https://github.com/ratatui/templates\n\
+            Press `Esc`, `Ctrl-C` or `q` to stop running.";
+        frame.render_widget(
+            Paragraph::new(text)
+                .block(Block::bordered().title(title))
+                .centered(),
+            frame.area(),
+        )
+    }
+
+    /// Reads the crossterm events and updates the state of [`App`].
+    async fn handle_crossterm_events(&mut self) -> Result<()> {
+        tokio::select! {
+            event = self.event_stream.next().fuse() => {
+                match event {
+                    Some(Ok(evt)) => {
+                        match evt {
+                            Event::Key(key)
+                                if key.kind == KeyEventKind::Press
+                                    => self.on_key_event(key),
+                            Event::Mouse(_) => {}
+                            Event::Resize(_, _) => {}
+                            _ => {}
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            _ = tokio::time::sleep(tokio::time::Duration::from_millis(100)) => {
+                // Sleep for a short duration to avoid busy waiting.
+            }
+        }
+        Ok(())
+    }
+
+    /// Handles the key events and updates the state of [`App`].
+    fn on_key_event(&mut self, key: KeyEvent) {
+        match (key.modifiers, key.code) {
+            (_, KeyCode::Esc | KeyCode::Char('q'))
+            | (KeyModifiers::CONTROL, KeyCode::Char('c') | KeyCode::Char('C')) => self.quit(),
+            // Add other key handlers here.
+            _ => {}
+        }
+    }
+
+    /// Set running to false to quit the application.
+    fn quit(&mut self) {
+        self.running = false;
+    }
+}

simple-async-generated/src/main.rs

@@ -1,12 +1,6 @@
 # Ratatui Simple template
 
-The simple template will create the following project structure:
-
-```text
-src/
-├── app.rs     -> holds the state and application logic
-└── main.rs    -> entry-point
-```
+A simple example of a Ratatui application.
 
 This is identical to the [simple](../simple) template but has `async` events out of the box with `tokio` and
 `crossterm`'s `EventStream`.