brakoll 0.2.9

Simple issue tracker for coding projects
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

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

use crossterm::{
    QueueableCommand,
    cursor::{self, MoveTo},
    event::{self, Event, KeyCode, KeyEvent, KeyModifiers, poll},
    execute,
    terminal::{self, Clear, ClearType, disable_raw_mode, enable_raw_mode},
};

const LOADING_BAR_SIZE: i32 = 30;

#[derive(PartialEq)]
pub enum State {
    Active,
    Quit,
}

pub struct LoadingBar {
    pub state: State,
    pub sout: Stdout,
    pub processed_counter: i32,
    pub files_to_process: i32,
    icp_col: u16,
    icp_row: u16,
}

impl LoadingBar {
    pub fn new(sout: Stdout, files_to_process: i32, icp_col: u16, icp_row: u16) -> Self {
        Self {
            state: State::Active,
            sout,
            processed_counter: 0,
            files_to_process,
            icp_col,
            icp_row,
        }
    }

    pub fn loading_bar(&mut self) -> io::Result<()> {
        // move to init cursor pos
        self.sout.queue(MoveTo(self.icp_col, self.icp_row))?;

        // write progress text
        let text = format!("{}/{} ", self.processed_counter, self.files_to_process);
        self.sout.write(text.as_bytes())?;

        // filled = floor((current_progress / total_work) * bar_width)
        // empty = bar_width - filled

        // === increment loading bar ===
        self.move_to_loading_bar_beginning(&text, 0)?;
        self.sout.write("".as_bytes())?;

        self.move_to_loading_bar_beginning(&text, 4)?;
        // fill empty parts of loading bar
        let progress = "░".repeat(LOADING_BAR_SIZE as usize - 1);
        self.sout.write(progress.as_bytes())?;

        // calculate space to fill
        let fill_n = ((self.processed_counter as f64 / self.files_to_process as f64)
            * LOADING_BAR_SIZE as f64)
            .floor();

        self.move_to_loading_bar_beginning(&text, 3)?;
        // write progress
        let progress = "█".repeat(fill_n as usize);
        self.sout.write(progress.as_bytes())?;

        self.move_to_loading_bar_beginning(&text, LOADING_BAR_SIZE as u16 + 3)?;
        self.sout.write("".as_bytes())?;
        Ok(())
    }

    /// helper: loading_bar()
    fn move_to_loading_bar_beginning(&mut self, text: &String, offset: u16) -> io::Result<()> {
        self.sout.queue(MoveTo(
            self.icp_col + text.chars().count() as u16 + offset,
            self.icp_row,
        ))?;
        Ok(())
    }

    pub fn controls(&mut self) -> std::io::Result<()> {
        if poll(Duration::ZERO)? {
            match self.state {
                State::Active => {
                    if let Event::Key(KeyEvent {
                        code, modifiers, ..
                    }) = event::read()?
                    {
                        match (code, modifiers) {
                            // quit
                            (KeyCode::Esc, _) => {
                                self.state = State::Quit;
                            }

                            (
                                KeyCode::Char('c'),
                                KeyModifiers::CONTROL,
                            ) => {
                                self.state = State::Quit;
                            }
                            _ => {}
                        }
                    }
                }

                State::Quit => {}
            }
        }
        Ok(())
    }

    pub fn util_setup(&mut self) -> io::Result<()> {
        enable_raw_mode()?;
        self.sout.queue(cursor::SavePosition)?;
        self.sout.queue(cursor::Hide)?;
        Ok(())
    }

    pub fn util_cleanup(&mut self) -> io::Result<()> {
        self.sout.queue(MoveTo(self.icp_col, self.icp_row))?;
        execute!(self.sout, Clear(ClearType::CurrentLine))?;
        disable_raw_mode()?;
        self.sout.queue(cursor::RestorePosition)?;
        self.sout.queue(MoveTo(self.icp_col, self.icp_row))?;
        self.sout.queue(cursor::Show)?;
        Ok(())
    }
}