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
|
use std::path::PathBuf;
use anyhow::Result;
use crossbeam::channel::Receiver;
use crosstermion::input::Event;
use dua::{
traverse::{EntryData, Traversal, Tree},
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 display: DisplayOptions,
pub state: AppState,
pub window: MainWindow,
}
impl TerminalApp {
pub fn initialize<B>(
terminal: &mut Terminal<B>,
walk_options: WalkOptions,
byte_format: ByteFormat,
) -> 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);
let traversal = {
let mut tree = Tree::new();
let root_index = tree.add_node(EntryData::default());
Traversal {
tree,
root_index,
entries_traversed: 0,
start: std::time::Instant::now(),
elapsed: None,
io_errors: 0,
total_bytes: None,
}
};
state.navigation_mut().view_root = traversal.root_index;
state.entries = sorted_entries(
&traversal.tree,
state.navigation().view_root,
state.sorting,
state.glob_root(),
);
state.navigation_mut().selected = state.entries.first().map(|b| b.index);
let app = TerminalApp {
state,
display,
traversal,
window,
};
Ok(app)
}
pub fn traverse(&mut self, input: Vec<PathBuf>) -> Result<()> {
self.state.traverse(&self.traversal, input)?;
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.active_traversal.is_some() {
if let Some(res) = self.state.process_event(
&mut self.window,
&mut self.traversal,
&mut self.display,
terminal,
&events,
)? {
return Ok(res);
}
}
Ok(WalkResult { num_errors: 0 })
}
}
}
|