aven 0.1.6

Local-first task manager CLI and sync server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

use crossterm::event::{KeyCode, KeyEvent};

use crate::tui::navigation::scroll_with_delta;

pub(crate) struct ScrollState {
    pub(crate) scroll: u16,
    pub(crate) cap: u16,
}

pub(crate) enum ScrollKeyOutcome {
    Cancelled,
    Continue(ScrollState),
    Ignored,
}

pub(crate) fn handle_scroll_key(
    key: KeyEvent,
    state: ScrollState,
    close_keys: &[KeyCode],
    page_rows: u16,
) -> ScrollKeyOutcome {
    if close_keys.contains(&key.code) {
        return ScrollKeyOutcome::Cancelled;
    }

    let delta = match key.code {
        KeyCode::Char('j') | KeyCode::Down => Some(1),
        KeyCode::Char('k') | KeyCode::Up => Some(-1),
        KeyCode::PageDown => Some(page_rows as isize),
        KeyCode::PageUp => Some(-(page_rows as isize)),
        _ => None,
    };

    match delta {
        Some(delta) => ScrollKeyOutcome::Continue(ScrollState {
            scroll: scroll_with_delta(state.scroll, delta, state.cap),
            cap: state.cap,
        }),
        None => ScrollKeyOutcome::Ignored,
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crossterm::event::KeyModifiers;

    fn key(code: KeyCode) -> KeyEvent {
        KeyEvent::new(code, KeyModifiers::NONE)
    }

    #[test]
    fn close_key_cancels() {
        let result = handle_scroll_key(
            key(KeyCode::Esc),
            ScrollState { scroll: 5, cap: 10 },
            &[KeyCode::Esc, KeyCode::Enter],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Cancelled));
    }

    #[test]
    fn j_key_scrolls_down() {
        let result = handle_scroll_key(
            key(KeyCode::Char('j')),
            ScrollState { scroll: 0, cap: 10 },
            &[KeyCode::Esc],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Continue(s) if s.scroll == 1));
    }

    #[test]
    fn k_key_scrolls_up() {
        let result = handle_scroll_key(
            key(KeyCode::Char('k')),
            ScrollState { scroll: 3, cap: 10 },
            &[KeyCode::Esc],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Continue(s) if s.scroll == 2));
    }

    #[test]
    fn ignored_key_returns_ignored() {
        let result = handle_scroll_key(
            key(KeyCode::Char('z')),
            ScrollState { scroll: 0, cap: 10 },
            &[KeyCode::Esc],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Ignored));
    }

    #[test]
    fn scroll_caps_at_limit() {
        let result = handle_scroll_key(
            key(KeyCode::Char('j')),
            ScrollState {
                scroll: 10,
                cap: 10,
            },
            &[KeyCode::Esc],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Continue(s) if s.scroll == 10));
    }

    #[test]
    fn page_down_with_zero_rows_is_ignored() {
        let result = handle_scroll_key(
            key(KeyCode::PageDown),
            ScrollState { scroll: 0, cap: 10 },
            &[KeyCode::Esc],
            0,
        );
        assert!(matches!(result, ScrollKeyOutcome::Continue(s) if s.scroll == 0));
    }
}