cyndikator 0.1.0

A cli rss reader
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

use crate::db::Database;
use crossterm::{event::read, terminal};
use std::io::{stdout, Write};

use draw::*;
use record::Cache;

mod draw;
mod inter;
mod record;

pub struct View {
    db: Database,
}

pub enum Action {
    Delete,
    Undo,
    Open,
    Noop,
    Quit,
}

impl View {
    pub fn new(db: Database) -> View {
        View { db }
    }

    fn render(self, out: &mut impl Write) -> eyre::Result<()> {
        let (_, height) = terminal::size()?;
        let mut cache = Cache::new(self.db);
        let mut inter = inter::Inter::new(height, 0);

        loop {
            let selected = inter.offset;
            let entries = cache.window(inter.base, height as u32)?;
            Full { selected, entries }.draw(out)?;
            out.flush()?;

            let e = read()?;

            match inter.interact(&e)? {
                Action::Open => {
                    if let Some(url) = &entries
                        .get(inter.offset as usize)
                        .and_then(|e| e.url.as_ref())
                    {
                        let _ = open::that_in_background(url);
                    }
                }

                Action::Delete => {
                    cache.delete(inter.offset as usize);
                }

                Action::Undo => {
                    cache.undo();
                }

                Action::Noop => (),
                Action::Quit => break,
            };

            let total = cache.total();
            if inter.offset as u32 + inter.base >= total {
                inter.base = total.checked_sub(inter.height as u32).unwrap_or(0);

                inter.offset = total
                    .checked_sub(inter.base)
                    .unwrap_or(0)
                    .checked_sub(1)
                    .unwrap_or(0) as u16;
            }
            inter.offset = inter.offset.min(cache.total() as u16 - 1);
        }

        Ok(())
    }

    pub fn interact(self) -> eyre::Result<()> {
        let mut out = stdout();

        let raw = Raw::default();

        Clear.draw(&mut out)?;
        ShowCur(false).draw(&mut out)?;

        let res = self.render(&mut out);

        let _ = Clear.draw(&mut out);
        let _ = ShowCur(true).draw(&mut out);

        drop(raw);
        out.flush()?;

        res
    }
}

struct Raw;

impl Default for Raw {
    fn default() -> Raw {
        let _ = terminal::enable_raw_mode();

        Raw
    }
}

impl Drop for Raw {
    fn drop(&mut self) {
        let _ = terminal::disable_raw_mode();
    }
}