mamegrep 0.1.0

A TUI tool for `$ git grep` to easily edit search patterns and view results
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::{io::Write, time::Duration};

use crossterm::{
    event::Event,
    style::{Attribute, Attributes, ContentStyle, StyledContent},
    terminal::{EnterAlternateScreen, LeaveAlternateScreen},
};
use orfail::OrFail;

use crate::canvas::{Frame, TokenPosition, TokenStyle};

#[derive(Debug)]
pub struct Terminal {
    size: TerminalSize,
    prev: Frame,
    show_cursor: bool,
}

impl Terminal {
    pub fn new() -> orfail::Result<Self> {
        crossterm::execute!(
            std::io::stdout(),
            EnterAlternateScreen,
            crossterm::cursor::Hide,
        )
        .or_fail()?;
        crossterm::terminal::enable_raw_mode().or_fail()?;

        let (cols, rows) = crossterm::terminal::size().or_fail()?;
        let size = TerminalSize {
            rows: rows as usize,
            cols: cols as usize,
        };

        Ok(Self {
            size,
            prev: Frame::new(size),
            show_cursor: false,
        })
    }

    pub fn show_cursor(&mut self, position: TokenPosition) -> orfail::Result<()> {
        if !self.show_cursor {
            crossterm::execute!(std::io::stdout(), crossterm::cursor::Show).or_fail()?;
            self.show_cursor = true;
        }
        crossterm::execute!(
            std::io::stdout(),
            crossterm::cursor::MoveTo(position.col as u16, position.row as u16)
        )
        .or_fail()?;
        Ok(())
    }

    pub fn hide_cursor(&mut self) -> orfail::Result<()> {
        if self.show_cursor {
            crossterm::execute!(std::io::stdout(), crossterm::cursor::Hide).or_fail()?;
            self.show_cursor = false;
        }
        Ok(())
    }

    pub fn size(&self) -> TerminalSize {
        self.size
    }

    pub fn next_event(&mut self) -> orfail::Result<Event> {
        let timeout = Duration::from_secs(1);
        while !crossterm::event::poll(timeout).or_fail()? {}

        let event = crossterm::event::read().or_fail()?;
        if let Event::Resize(cols, rows) = event {
            self.size.cols = cols as usize;
            self.size.rows = rows as usize;
        }

        Ok(event)
    }

    pub fn draw_frame(&mut self, frame: Frame) -> orfail::Result<()> {
        let stdout = std::io::stdout();
        let mut writer = stdout.lock();
        for (row, line) in frame.dirty_lines(&self.prev) {
            crossterm::queue!(
                writer,
                crossterm::cursor::MoveTo(0, row as u16),
                crossterm::terminal::Clear(crossterm::terminal::ClearType::CurrentLine)
            )
            .or_fail()?;

            for token in line.tokens() {
                let attributes = match token.style() {
                    TokenStyle::Plain => Attributes::none(),
                    TokenStyle::Bold => Attributes::none().with(Attribute::Bold),
                    TokenStyle::Dim => Attributes::none().with(Attribute::Dim),
                    TokenStyle::Underlined => Attributes::none().with(Attribute::Underlined),
                    TokenStyle::Reverse => Attributes::none().with(Attribute::Reverse),
                };
                let content = StyledContent::new(
                    ContentStyle {
                        attributes,
                        ..Default::default()
                    },
                    token.text(),
                );
                crossterm::queue!(writer, crossterm::style::PrintStyledContent(content))
                    .or_fail()?;
            }
        }

        writer.flush().or_fail()?;
        self.prev = frame;
        Ok(())
    }
}

impl Drop for Terminal {
    fn drop(&mut self) {
        let _ = crossterm::terminal::disable_raw_mode();
        let _ = crossterm::execute!(
            std::io::stdout(),
            LeaveAlternateScreen,
            crossterm::cursor::Show,
        );
    }
}

#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
pub struct TerminalSize {
    pub rows: usize,
    pub cols: usize,
}

impl TerminalSize {
    pub const EMPTY: Self = Self { cols: 0, rows: 0 };

    pub fn is_empty(self) -> bool {
        self.rows == 0 || self.cols == 0
    }
}