ci: initialized

.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.toml

@@ -4,5 +4,26 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-crossterm = "0.26"
-ratatui = { version = "0.20", features = ["crossterm"] }
+crossterm = "0.29"
+ratatui = { version = "0.30", features = ["crossterm"] }
+
+[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"

src/main.rs

@@ -1,17 +1,18 @@
-use std::io::{self, Read, Stdout};
-use std::time::Duration;
+mod terminal_guard;
+/// UI components (todo list)
+mod todo_list;
 
-use crossterm::event::{self, Event, KeyCode};
+use core::time::Duration;
+use crossterm::event::{self, EnableMouseCapture, Event, KeyCode};
 use crossterm::execute;
-use crossterm::terminal::{
-    EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode,
-};
+use crossterm::terminal::{EnterAlternateScreen, enable_raw_mode};
+use ratatui::Terminal;
 use ratatui::backend::CrosstermBackend;
-use ratatui::layout::{Constraint, Direction, Layout};
-use ratatui::style::{Color, Modifier, Style};
-use ratatui::terminal::Terminal;
-use ratatui::widgets::{Block, Borders, List, ListItem, ListState};
+use std::io::{self, Read as _};
+use terminal_guard::TerminalModeGuard;
+use todo_list::TodoList;
 
+#[allow(clippy::wildcard_enum_match_arm)]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut input = String::new();
     io::stdin().read_to_string(&mut input)?;
@@ -21,81 +22,70 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         return Ok(());
     }
 
-    let lines: Vec<String> = input.lines().map(|s| s.to_string()).collect();
-    let mut marked = vec![false; lines.len()];
+    let lines: Vec<String> = input
+        .lines()
+        .map(std::string::ToString::to_string)
+        .collect();
+    let mut todo = TodoList::with_lines(lines);
 
     enable_raw_mode()?;
     let mut stdout = std::io::stdout();
-    execute!(stdout, EnterAlternateScreen)?;
+    execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+
+    let mode_guard = TerminalModeGuard;
+
     let backend = CrosstermBackend::new(stdout);
     let mut terminal = Terminal::new(backend)?;
 
-    let mut state = ListState::default();
-    if !lines.is_empty() {
-        state.select(Some(0));
-    }
-
     loop {
         terminal.draw(|f| {
-            let size = f.size();
-            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()
-                        .fg(Color::White)
-                        .bg(Color::Blue)
-                        .add_modifier(Modifier::BOLD),
-                );
-
-            f.render_stateful_widget(list, chunks[0], &mut state);
+            todo.draw(f);
         })?;
 
-        // Event handling
-        if event::poll(Duration::from_millis(100))?
-            && let Event::Key(key) = event::read()?
-        {
-            match key.code {
+        if event::poll(Duration::from_millis(100))? {
+            match event::read()? {
+                Event::Key(key) => match key.code {
                     KeyCode::Char('q') => break,
                     KeyCode::Up => {
-                    if let Some(i) = state.selected()
-                        && i > 0
-                    {
-                        state.select(Some(i - 1));
+                        if let Some(i) = todo.state.selected() {
+                            todo.state.select(Some(i.saturating_sub(1)));
                         }
                     }
                     KeyCode::Down => {
-                    if let Some(i) = state.selected()
-                        && i + 1 < lines.len()
-                    {
-                        state.select(Some(i + 1));
+                        if let Some(i) = todo.state.selected() {
+                            todo.state.select(Some((i + 1).min(todo.lines.len() - 1)));
                         }
                     }
                     KeyCode::Char(' ') => {
-                    if let Some(i) = state.selected()
-                        && i < marked.len()
+                        if let Some(i) = todo.state.selected() {
+                            let Some(marked_cell) = todo.marked.get_mut(i) else {
+                                return Err("Index out of bounds".into());
+                            };
+                            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 s.kind == event::MouseEventKind::Down(event::MouseButton::Left) {
+                        let area = terminal.size()?;
+                        if let Some(row_idx) = s
+                            .row
+                            .checked_sub(area.height + 1)
+                            .filter(|_| s.row < area.height.saturating_add(area.height))
                         {
-                        marked[i] = true;
-                        // move cursor down
-                        let next = if i + 1 < lines.len() { i + 1 } else { i };
-                        state.select(Some(next));
+                            let idx = usize::from(row_idx);
+                            if idx < todo.lines.len() {
+                                todo.state.select(Some(idx));
+                            }
+                        }
                     }
                 }
                 _ => {}
@@ -103,9 +93,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         }
     }
 
-    disable_raw_mode()?;
-    let mut stdout: Stdout = std::io::stdout();
-    execute!(stdout, LeaveAlternateScreen)?;
+    drop(mode_guard);
     terminal.show_cursor()?;
 
     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,56 @@
+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 {
+    pub lines: Vec<String>,
+    pub marked: Vec<bool>,
+    pub state: ListState,
+    pub title: String,
+}
+
+impl TodoList {
+    /// 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(|_| 0).unwrap_or(0)],
+            state,
+            title: "Lines (space to mark, q to quit)".to_string(),
+        }
+    }
+
+    /// 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
+    }
+
+    /// 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);
+    }
+}

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.into(), height.into());
+    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();
+    let buf = backend.buffer().clone();
+    buf
+}
+
+#[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);
+}