ripnode 1.1.11

Simple tool for deleting node_modules and other folders
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
141
142
143
144
145
146

use crate::modules::dir::Dir;
use crate::modules::ui::draw_ui;
use bytesize::ByteSize;
use crossterm::event::{poll, Event, KeyCode};
use ratatui::backend::CrosstermBackend;
use ratatui::widgets::ListState;
use ratatui::Terminal;
use std::io::Stdout;
use std::time::Duration;

pub struct StatefulList {
    pub state: ListState,
    pub items: Vec<Dir>,
    pub handles: Vec<std::thread::JoinHandle<()>>,
}

impl StatefulList {
    pub fn with_items(items: Vec<Dir>) -> StatefulList {
        StatefulList {
            state: ListState::default(),
            items,
            handles: vec![],
        }
    }

    pub fn next(&mut self) {
        let i = match self.state.selected() {
            Some(i) => {
                if i >= self.items.len() - 1 {
                    0
                } else {
                    i + 1
                }
            }
            None => 0,
        };
        self.state.select(Some(i));
    }

    pub fn previous(&mut self) {
        let i = match self.state.selected() {
            Some(i) => {
                if i == 0 {
                    self.items.len() - 1
                } else {
                    i - 1
                }
            }
            None => 0,
        };
        self.state.select(Some(i));
    }

    fn unselect(&mut self) {
        self.state.select(None);
    }
}

pub struct App {
    pub title: &'static str,
    pub should_quit: bool,
    pub dirs: StatefulList,
    pub saved_space: u64,
}

impl App {
    pub fn new(dirs: Vec<Dir>) -> App {
        App {
            title: r#"
██████╗ ██╗██████╗ ███╗   ██╗ ██████╗ ██████╗ ███████╗
██╔══██╗██║██╔══██╗████╗  ██║██╔═══██╗██╔══██╗██╔════╝
██████╔╝██║██████╔╝██╔██╗ ██║██║   ██║██║  ██║█████╗
██╔══██╗██║██╔═══╝ ██║╚██╗██║██║   ██║██║  ██║██╔══╝
██║  ██║██║██║     ██║ ╚████║╚██████╔╝██████╔╝███████╗
╚═╝  ╚═╝╚═╝╚═╝     ╚═╝  ╚═══╝ ╚═════╝ ╚═════╝ ╚══════╝


"#,
            should_quit: false,
            dirs: StatefulList::with_items(dirs),
            saved_space: 0,
        }
    }

    pub fn on_up(&mut self) {
        self.dirs.previous();
    }

    pub fn on_down(&mut self) {
        self.dirs.next();
    }

    pub fn on_quit(&mut self) {
        self.should_quit = true;
    }

    pub fn on_delete(&mut self) {
        let selected = self.dirs.state.selected();
        if let Some(selected) = selected {
            let dir = &mut self.dirs.items[selected];
            if !dir.is_deleted() && !dir.is_deleting() {
                self.saved_space += dir.size().parse::<ByteSize>().unwrap().0;
            }
            let mut dir_to_delete = dir.clone();
            let handle = std::thread::spawn(move || {
                dir_to_delete.delete_dir();
            });
            self.dirs.handles.push(handle);
            dir.set_deleting(true);
        }
    }

    pub fn run(
        &mut self,
        terminal: &mut Terminal<CrosstermBackend<Stdout>>,
    ) -> std::io::Result<()> {
        loop {
            if self.should_quit {
                break;
            }

            for dir in &mut self.dirs.items {
                dir.still_exists();
            }

            terminal.draw(|f| draw_ui(f, self))?;

            if poll(Duration::from_millis(100))? {
                if let Event::Key(key) = crossterm::event::read()? {
                    match key.code {
                        KeyCode::Char('q') | KeyCode::Esc => self.on_quit(),
                        KeyCode::Left | KeyCode::Char('h') => self.dirs.unselect(),
                        KeyCode::Down | KeyCode::Char('j') => self.on_down(),
                        KeyCode::Up | KeyCode::Char('k') => self.on_up(),
                        KeyCode::Enter | KeyCode::Backspace | KeyCode::Char(' ') => {
                            self.on_delete()
                        }
                        _ => {}
                    }
                }
            }
        }

        Ok(())
    }
}