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
|
use std::path::PathBuf;
use anyhow::Result;
use crossbeam::channel::Receiver;
use crosstermion::input::Event;
use dua::{
traverse::{Traversal, TraversalStats},
ByteFormat, WalkOptions, WalkResult,
};
use tui::prelude::Backend;
use tui_react::Terminal;
use crate::interactive::widgets::MainWindow;
use super::{sorted_entries, state::AppState, DisplayOptions};
/// State and methods representing the interactive disk usage analyser for the terminal
pub struct TerminalApp {
pub traversal: Traversal,
pub stats: TraversalStats,
pub display: DisplayOptions,
pub state: AppState,
pub window: MainWindow,
}
impl TerminalApp {
pub fn initialize<B>(
terminal: &mut Terminal<B>,
walk_options: WalkOptions,
byte_format: ByteFormat,
input: Vec<PathBuf>,
) -> Result<TerminalApp>
where
B: Backend,
{
terminal.hide_cursor()?;
terminal.clear()?;
let display = DisplayOptions::new(byte_format);
let window = MainWindow::default();
let mut state = AppState::new(walk_options, input);
let traversal = Traversal::new();
let stats = TraversalStats::default();
state.navigation_mut().view_root = traversal.root_index;
state.entries = sorted_entries(
&traversal.tree,
state.navigation().view_root,
state.sorting,
state.glob_root(),
state.scan.is_some(),
);
state.navigation_mut().selected = state.entries.first().map(|b| b.index);
let app = TerminalApp {
state,
display,
traversal,
stats,
window,
};
Ok(app)
}
pub fn traverse(&mut self) -> Result<()> {
self.state.traverse(&self.traversal)?;
Ok(())
}
pub fn process_events<B>(
&mut self,
terminal: &mut Terminal<B>,
events: Receiver<Event>,
) -> Result<WalkResult>
where
B: Backend,
{
self.state.process_events(
&mut self.window,
&mut self.traversal,
&mut self.display,
terminal,
events,
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use super::TerminalApp;
impl TerminalApp {
pub fn run_until_traversed<B>(
&mut self,
terminal: &mut Terminal<B>,
events: Receiver<Event>,
) -> Result<WalkResult>
where
B: Backend,
{
while self.state.scan.is_some() {
self.state.process_event(
&mut self.window,
&mut self.traversal,
&mut self.display,
terminal,
&events,
)?;
}
Ok(WalkResult {
num_errors: self.stats.io_errors,
})
}
}
}
|
