chore: add push command to bump script

.gitea/workflows/release.yaml

@@ -0,0 +1,38 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+
+jobs:
+  build_release:
+    runs-on: ubuntu-latest
+    env:
+      GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+      GITEA_SERVER: ${{ secrets.GITEA_SERVER }}
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: nightly
+
+      - name: Build release
+        run: |
+          cargo build --release
+      - name: Generate a changelog
+        uses: orhun/git-cliff-action@v4
+        id: git-cliff
+        with:
+          config: cliff.toml
+          args: --verbose --latest
+          github_token: ""
+        env:
+          OUTPUT: CHANGELOG.md
+      - uses: akkuman/gitea-release-action@v1
+        with:
+          files: |-
+            target/release/chkr
+          body: ${{ steps.git-cliff.outputs.content }}

.gitea/workflows/test.yaml

@@ -0,0 +1,13 @@
+name: Rust
+
+on: [push, pull_request]
+
+jobs:
+  build_and_test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions-rust-lang/setup-rust-toolchain@v1
+        with:
+          toolchain: nightly
+      - run: cargo test --all-features

Cargo.lock

@@ -23,6 +23,38 @@ version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
 
+[[package]]
+name = "argh"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ff18325c8a36b82f992e533ece1ec9f9a9db446bd1c14d4f936bac88fcd240"
+dependencies = [
+ "argh_derive",
+ "argh_shared",
+ "rust-fuzzy-search",
+]
+
+[[package]]
+name = "argh_derive"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb7b2b83a50d329d5d8ccc620f5c7064028828538bdf5646acd60dc1f767803"
+dependencies = [
+ "argh_shared",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.114",
+]
+
+[[package]]
+name = "argh_shared"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a464143cc82dedcdc3928737445362466b7674b5db4e2eb8e869846d6d84f4f6"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "atomic"
 version = "0.6.1"
@@ -115,9 +147,12 @@ checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
 [[package]]
 name = "chkr"
-version = "0.1.0"
+version = "0.3.0"
 dependencies = [
+ "anyhow",
+ "argh",
  "crossterm",
+ "insta",
  "ratatui",
 ]
 
@@ -135,6 +170,18 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
 [[package]]
 name = "convert_case"
 version = "0.10.0"
@@ -296,6 +343,12 @@ version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
 
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -309,7 +362,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -331,6 +384,12 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
 [[package]]
 name = "filedescriptor"
 version = "0.8.3"
@@ -426,6 +485,18 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "insta"
+version = "1.46.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "248b42847813a1550dafd15296fd9748c651d0c32194559dbc05d804d54b21e8"
+dependencies = [
+ "console",
+ "once_cell",
+ "similar",
+ "tempfile",
+]
+
 [[package]]
 name = "instability"
 version = "0.3.11"
@@ -584,7 +655,7 @@ dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -952,6 +1023,12 @@ version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
+[[package]]
+name = "rust-fuzzy-search"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a157657054ffe556d8858504af8a672a054a6e0bd9e8ee531059100c0fa11bb2"
+
 [[package]]
 name = "rustc_version"
 version = "0.4.1"
@@ -971,7 +1048,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1070,6 +1147,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
 [[package]]
 name = "siphasher"
 version = "1.0.1"
@@ -1137,6 +1220,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.24.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "655da9c7eb6305c55742045d5a8d2037996d61d8de95806335c7c86ce0f82e9c"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "terminfo"
 version = "0.9.0"
@@ -1495,6 +1591,15 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1504,6 +1609,70 @@ dependencies = [
  "windows-link",
 ]
 
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"

Cargo.toml

@@ -1,8 +1,31 @@
 [package]
 name = "chkr"
-version = "0.1.0"
+version = "0.3.0"
 edition = "2024"
 
 [dependencies]
 crossterm = "0.29"
 ratatui = { version = "0.30", features = ["crossterm"] }
+anyhow = "1.0"
+argh = "0.1.13"
+
+[dev-dependencies]
+insta = "1.33"
+
+[lints.clippy]
+pedantic = "warn"
+unused_trait_names = "warn"
+missing_docs_in_private_items = "warn"
+empty_structs_with_brackets = "warn"
+let_underscore_must_use = "warn"
+arbitrary_source_item_ordering = "warn"
+as_conversions = "warn"
+default_constructed_unit_structs = "warn"
+equatable_if_let = "warn"
+indexing_slicing = "warn"
+missing_assert_message = "warn"
+panic_in_result_fn = "warn"
+redundant_closure_for_method_calls = "warn"
+str_to_string = "warn"
+used_underscore_binding = "warn"
+wildcard_enum_match_arm = "warn"

scripts/bump.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+set -euo pipefail
+
+VERSION="$(git cliff --bumped-version)"
+VERSION_CLEAN="${VERSION#v}"
+sed -i "s/^version = \".*\"/version = \"${VERSION_CLEAN}\"/" Cargo.toml
+cargo check
+
+echo Press Y to commit version bump to ${VERSION_CLEAN}
+read -r CONFIRM
+if [ "${CONFIRM}" != "Y" ]; then
+    echo Aborting
+    exit 1
+fi
+
+git commit -am "chore: bump version to ${VERSION}"
+git tag -am "Version ${VERSION}" "${VERSION}"
+
+echo Press Y to push commit and tag
+read -r CONFIRM
+if [ "${CONFIRM}" != "Y" ]; then
+    echo Aborting
+    exit 1
+fi
+git push
+git push --tags

src/event_source.rs

@@ -0,0 +1,28 @@
+//! Abstraction around event sourcing for the checklist application.
+use anyhow::Result;
+use crossterm::event::{self, Event};
+use std::time::Duration;
+
+/// An abstraction around event sourcing so we can inject events in tests.
+pub trait EventSource {
+    /// Polls for an event for up to `timeout`, returning `Ok(true)` if an event is
+    /// available, `Ok(false)` if the timeout elapsed without an event, or an `Err`
+    /// if polling failed.
+    fn poll(&mut self, timeout: Duration) -> Result<bool>;
+
+    /// Reads the next available event, or returns an `Err` if reading fails.
+    fn read(&mut self) -> Result<Event>;
+}
+
+/// Production implementation that delegates to `crossterm::event`.
+pub struct CrosstermEventSource;
+
+impl EventSource for CrosstermEventSource {
+    fn poll(&mut self, timeout: Duration) -> Result<bool> {
+        Ok(event::poll(timeout).map_err(Box::new)?)
+    }
+
+    fn read(&mut self) -> Result<Event> {
+        Ok(event::read().map_err(Box::new)?)
+    }
+}

src/main.rs

@@ -1,118 +1,142 @@
-use std::io::{self, Read, Stdout};
+//! A simple terminal checklist application.
-use std::time::Duration;
+mod event_source;
+mod terminal_guard;
+mod todo_list;
 
-use crossterm::event::{self, Event, KeyCode};
+use anyhow::{Context as _, Result, anyhow, bail};
+use argh::FromArgs;
+use core::time::Duration;
+use crossterm::event::{self, EnableMouseCapture, Event, KeyCode};
 use crossterm::execute;
-use crossterm::terminal::{
+use crossterm::terminal::{EnterAlternateScreen, enable_raw_mode};
-    EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
+use event_source::{CrosstermEventSource, EventSource};
-};
 use ratatui::Terminal;
+use ratatui::backend::Backend;
 use ratatui::backend::CrosstermBackend;
-use ratatui::layout::{Constraint, Direction, Layout};
+use std::io::{self, Read as _};
-use ratatui::style::Style;
+use terminal_guard::TerminalModeGuard;
-use ratatui::widgets::{Block, Borders, List, ListItem, ListState};
+use todo_list::TodoList;
 
-fn main() -> Result<(), Box<dyn std::error::Error>> {
+#[derive(FromArgs)]
-    let mut input = String::new();
+/// chkr - terminal checklist
-    io::stdin().read_to_string(&mut input)?;
+struct Args {
+    /// load checklist from file instead of stdin
+    #[argh(option, short = 'f', long = "file")]
+    file: Option<String>,
 
-    if input.trim().is_empty() {
+    /// print version and exit
-        eprintln!("Provide text via stdin (pipe or heredoc). Example: \n  cat file.txt | chkr");
+    #[argh(switch, short = 'V', long = "version")]
+    version: bool,
+}
+
+fn main() -> Result<()> {
+    let args: Args = argh::from_env();
+
+    if args.version {
+        println!("v{}", env!("CARGO_PKG_VERSION"));
         return Ok(());
     }
 
-    let lines: Vec<String> = input.lines().map(|s| s.to_string()).collect();
+    let input: String = if let Some(path) = args.file {
-    let mut marked = vec![false; lines.len()];
+        std::fs::read_to_string(&path).with_context(|| format!("reading file {path}"))?
+    } else {
+        let mut input = String::new();
+        io::stdin()
+            .read_to_string(&mut input)
+            .context("reading stdin")?;
+        input
+    };
 
-    enable_raw_mode()?;
+    if input.trim().is_empty() {
-    let mut stdout = std::io::stdout();
+        eprintln!(
-    execute!(stdout, EnterAlternateScreen)?;
+            "Provide text via stdin (pipe or heredoc), or use --file. Example: \n  cat file.txt | chkr"
-    let backend = CrosstermBackend::new(stdout);
+        );
-    let mut terminal = Terminal::new(backend)?;
+        return Ok(());
-
-    let mut state = ListState::default();
-    if !lines.is_empty() {
-        state.select(Some(0));
     }
 
+    let lines: Vec<String> = input
+        .lines()
+        .map(std::string::ToString::to_string)
+        .collect();
+    let mut todo = TodoList::with_lines(lines);
+
+    enable_raw_mode().context("enable raw mode")?;
+    let mut stdout = std::io::stdout();
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture).context("enter alternate screen")?;
+
+    let mode_guard = TerminalModeGuard;
+
+    let backend = CrosstermBackend::new(stdout);
+    let mut terminal = Terminal::new(backend).context("create terminal")?;
+
+    run_app(&mut terminal, &mut CrosstermEventSource, &mut todo)
+        .map_err(|e| anyhow!("running app: {e}"))?;
+
+    drop(mode_guard);
+    terminal.show_cursor().context("show cursor")?;
+
+    Ok(())
+}
+
+/// Run the app loop using an abstract `EventSource` so tests can inject events.
+/// # Errors
+/// If terminal drawing or event sourcing fails.
+pub fn run_app<B: Backend, E: EventSource>(
+    terminal: &mut Terminal<B>,
+    event_source: &mut E,
+    todo: &mut TodoList,
+) -> Result<()>
+where
+    <B as Backend>::Error: 'static + Sync + Send,
+{
     loop {
         terminal.draw(|f| {
-            let size = f.area();
+            todo.draw(f);
-            let chunks = Layout::default()
-                .direction(Direction::Vertical)
-                .constraints([Constraint::Min(0)].as_ref())
-                .split(size);
-
-            let items: Vec<ListItem> = lines
-                .iter()
-                .enumerate()
-                .map(|(i, l)| {
-                    let prefix = if marked[i] { "[x]" } else { "[ ]" };
-                    ListItem::new(format!("{} {}", prefix, l))
-                })
-                .collect();
-
-            let list = List::new(items)
-                .block(
-                    Block::default()
-                        .borders(Borders::ALL)
-                        .title("Lines (space to mark, q to quit)"),
-                )
-                .highlight_style(Style::default().bold().yellow().on_dark_gray());
-
-            f.render_stateful_widget(list, chunks[0], &mut state);
         })?;
 
-        // Event handling
+        if event_source.poll(Duration::from_millis(100))? {
-        if event::poll(Duration::from_millis(100))? {
+            #[allow(clippy::wildcard_enum_match_arm)]
-            match event::read()? {
+            match event_source.read()? {
-                Event::Key(key) => {
+                Event::Key(key) => match key.code {
-                    match key.code {
+                    KeyCode::Char('q') => break,
-                        KeyCode::Char('q') => break,
+                    KeyCode::Up => {
-                        KeyCode::Up => {
+                        if let Some(i) = todo.state.selected() {
-                            if let Some(i) = state.selected()
+                            todo.state.select(Some(i.saturating_sub(1)));
-                                && i > 0
-                            {
-                                state.select(Some(i - 1));
-                            }
                         }
-                        KeyCode::Down => {
-                            if let Some(i) = state.selected()
-                                && i + 1 < lines.len()
-                            {
-                                state.select(Some(i + 1));
-                            }
-                        }
-                        KeyCode::Char(' ') => {
-                            if let Some(i) = state.selected()
-                                && i < marked.len()
-                            {
-                                assert!(i < marked.len());
-                                if marked[i] {
-                                    marked[i] = false;
-                                } else {
-                                    marked[i] = true;
-                                    // move cursor down
-                                    let next = lines.len().min(i + 1);
-                                    state.select(Some(next));
-                                }
-                            }
-                        }
-                        KeyCode::Char('c')
-                            if key.modifiers.contains(event::KeyModifiers::CONTROL) =>
-                        {
-                            break;
-                        }
-                        _ => {}
                     }
-                }
+                    KeyCode::Down => {
+                        if let Some(i) = todo.state.selected() {
+                            todo.state.select(Some((i + 1).min(todo.lines.len() - 1)));
+                        }
+                    }
+                    KeyCode::Char(' ') => {
+                        if let Some(i) = todo.state.selected() {
+                            let Some(marked_cell) = todo.marked.get_mut(i) else {
+                                bail!("Index out of bounds");
+                            };
+                            if !*marked_cell {
+                                let next = todo.lines.len().min(i + 1);
+                                todo.state.select(Some(next));
+                            }
+                            *marked_cell = !*marked_cell;
+                        }
+                    }
+                    KeyCode::Char('c') if key.modifiers.contains(event::KeyModifiers::CONTROL) => {
+                        break;
+                    }
+                    _ => {}
+                },
                 Event::Mouse(s) => {
-                    if let event::MouseEventKind::Down(event::MouseButton::Left) = s.kind {
+                    if s.kind == event::MouseEventKind::Down(event::MouseButton::Left) {
                         let area = terminal.size()?;
-                        if s.row > area.height && s.row < area.height + area.height {
+                        if let Some(row_idx) = s
-                            let idx = (s.row - area.height - 1) as usize;
+                            .row
-                            if idx < lines.len() {
+                            .checked_sub(area.height + 1)
-                                state.select(Some(idx));
+                            .filter(|_| s.row < area.height.saturating_add(area.height))
+                        {
+                            let idx = usize::from(row_idx);
+                            if idx < todo.lines.len() {
+                                todo.state.select(Some(idx));
                             }
                         }
                     }
@@ -122,10 +146,63 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    disable_raw_mode()?;
-    let mut stdout: Stdout = std::io::stdout();
-    execute!(stdout, LeaveAlternateScreen)?;
-    terminal.show_cursor()?;
-
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    #![allow(clippy::panic_in_result_fn)]
+    use super::*;
+    use crate::todo_list::TodoList;
+    use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};
+    use ratatui::Terminal;
+    use ratatui::backend::TestBackend;
+    use std::collections::VecDeque;
+    use std::time::Duration;
+
+    struct MockEventSource {
+        events: VecDeque<Event>,
+    }
+
+    impl MockEventSource {
+        fn new(events: Vec<Event>) -> Self {
+            Self {
+                events: VecDeque::from(events),
+            }
+        }
+    }
+
+    impl crate::event_source::EventSource for MockEventSource {
+        fn poll(&mut self, _timeout: Duration) -> Result<bool> {
+            Ok(!self.events.is_empty())
+        }
+
+        fn read(&mut self) -> Result<Event> {
+            Ok(self.events.pop_front().expect("no events left"))
+        }
+    }
+
+    #[test]
+    fn pressing_down_moves_selection() -> Result<(), Box<dyn std::error::Error>> {
+        let lines = vec!["one".to_owned(), "two".to_owned(), "three".to_owned()];
+        let mut todo = TodoList::with_lines(lines);
+
+        // prepare events: Down then 'q' to exit
+        let down = Event::Key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+        let quit = Event::Key(KeyEvent::new(KeyCode::Char('q'), KeyModifiers::NONE));
+        let mut source = MockEventSource::new(vec![down, quit]);
+
+        let backend = TestBackend::new(80, 24);
+        let mut terminal = Terminal::new(backend)?;
+
+        // initially selection is Some(0)
+        assert_eq!(todo.state.selected(), Some(0));
+
+        run_app(&mut terminal, &mut source, &mut todo)?;
+
+        // after pressing Down we expect selection to move to 1
+        assert_eq!(todo.state.selected(), Some(1));
+
+        Ok(())
+    }
+}

src/terminal_guard.rs

@@ -0,0 +1,23 @@
+//! A guard that restores the terminal state on drop.
+use crossterm::cursor::Show;
+use crossterm::execute;
+use crossterm::terminal::{LeaveAlternateScreen, disable_raw_mode};
+
+/// A guard that ensures the terminal is restored to its original state
+/// when dropped.
+#[derive(Default, Debug)]
+pub struct TerminalModeGuard;
+
+impl TerminalModeGuard {}
+
+impl Drop for TerminalModeGuard {
+    #[allow(
+        clippy::let_underscore_must_use,
+        reason = "We want to ignore errors during cleanup."
+    )]
+    fn drop(&mut self) {
+        let _ = disable_raw_mode();
+        let mut stdout = std::io::stdout();
+        let _ = execute!(stdout, LeaveAlternateScreen, Show);
+    }
+}

src/todo_list.rs

@@ -0,0 +1,61 @@
+//! Todo list UI component for the checklist application.
+use ratatui::style::Style;
+use ratatui::widgets::{Block, Borders, List, ListItem, ListState};
+// use Frame via the crate root type `ratatui::Frame` in the signature below
+
+/// A simple todo/list view that owns the lines, marked flags and selection state.
+pub struct TodoList {
+    /// The text lines in the todo list.
+    pub lines: Vec<String>,
+    /// Flags indicating whether each corresponding line is marked.
+    pub marked: Vec<bool>,
+    /// Stateful selection for the list widget.
+    pub state: ListState,
+    /// Title displayed above the list widget.
+    pub title: String,
+}
+
+impl TodoList {
+    /// Draw the list into a `ratatui` frame.
+    pub fn draw(&mut self, f: &mut ratatui::Frame<'_>) {
+        let size = f.area();
+
+        let items: Vec<ListItem> = self
+            .lines
+            .iter()
+            .zip(self.marked.iter())
+            .map(|(text, marked)| {
+                let prefix = if *marked { 'x' } else { ' ' };
+                ListItem::new(format!("[{prefix}] {text}"))
+            })
+            .collect();
+
+        let list = List::new(items)
+            .block(Block::default().borders(Borders::ALL).title(&*self.title))
+            .highlight_style(Style::default().bold().yellow().on_dark_gray());
+
+        f.render_stateful_widget(list, size, &mut self.state);
+    }
+
+    /// Create a new `TodoList` from lines.
+    pub fn new(lines: Vec<String>) -> Self {
+        let mut state = ListState::default();
+        if !lines.is_empty() {
+            state.select(Some(0));
+        }
+
+        Self {
+            lines,
+            marked: vec![false; state.selected().map_or(0, |_| 0)],
+            state,
+            title: "Lines (space to mark, q to quit)".to_owned(),
+        }
+    }
+
+    /// Convenience constructor that ensures marked has same length as lines.
+    pub fn with_lines(lines: Vec<String>) -> Self {
+        let mut s = Self::new(lines);
+        s.marked = vec![false; s.lines.len()];
+        s
+    }
+}

tests/snapshots/ui_snapshot__ui_snapshot_basic.snap

@@ -0,0 +1,23 @@
+---
+source: tests/ui_snapshot.rs
+assertion_line: 50
+expression: out
+---
+Buffer {
+    area: Rect { x: 0, y: 0, width: 40, height: 10 },
+    content: [
+        "┌Lines (space to mark, q to quit)──────┐",
+        "│[ ] first                             │",
+        "│[x] second                            │",
+        "│[ ] third                             │",
+        "│                                      │",
+        "│                                      │",
+        "│                                      │",
+        "│                                      │",
+        "│                                      │",
+        "└──────────────────────────────────────┘",
+    ],
+    styles: [
+        x: 0, y: 0, fg: Reset, bg: Reset, underline: Reset, modifier: NONE,
+    ]
+}

tests/ui_snapshot.rs

@@ -0,0 +1,61 @@
+use ratatui::Terminal;
+use ratatui::backend::TestBackend;
+use ratatui::buffer::Buffer;
+use ratatui::layout::Rect;
+use ratatui::style::Style;
+use ratatui::widgets::{Block, Borders, List, ListItem, ListState};
+
+fn render_list_into_buffer(
+    lines: &[&str],
+    marked: &[bool],
+    selected: Option<usize>,
+    width: u16,
+    height: u16,
+) -> Buffer {
+    let backend = TestBackend::new(width, height);
+    let mut terminal = Terminal::new(backend).expect("create terminal");
+
+    let lines_vec: Vec<ListItem> = lines
+        .iter()
+        .zip(marked.iter())
+        .map(|(text, marked)| {
+            let prefix = if *marked { 'x' } else { ' ' };
+            ListItem::new(format!("[{prefix}] {text}"))
+        })
+        .collect();
+
+    let mut state = ListState::default();
+    state.select(selected);
+
+    terminal
+        .draw(|f| {
+            let size = Rect::new(0, 0, width, height);
+
+            let list = List::new(lines_vec.clone())
+                .block(
+                    Block::default()
+                        .borders(Borders::ALL)
+                        .title("Lines (space to mark, q to quit)"),
+                )
+                .highlight_style(Style::default());
+
+            f.render_stateful_widget(list, size, &mut state);
+        })
+        .expect("draw");
+
+    // Extract the underlying backend buffer (clone to own it)
+    let backend = terminal.backend();
+
+    backend.buffer().clone()
+}
+
+#[test]
+fn ui_snapshot_basic() {
+    let lines = ["first", "second", "third"];
+    let marked = [false, true, false];
+    let buf = render_list_into_buffer(&lines, &marked, Some(1), 40, 10);
+
+    // Use the buffer's debug representation for snapshotting
+    let out = format!("{buf:#?}");
+    insta::assert_snapshot!(out);
+}