pub mod app;
pub mod event;
pub mod ui;
pub mod widgets;
pub use app::App;
use std::io::{self, stdout, Stdout};
use std::path::PathBuf;
use std::time::Duration;
use event::handle_events;
use ui::render;
use crossterm::{
execute,
terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use ratatui::prelude::*;
pub fn run(root: PathBuf) -> anyhow::Result<()> {
run_with_scan_options(
root,
crate::scanner::ScanOptions::default().with_one_file_system(true),
)
}
pub fn run_with_scan_options(
root: PathBuf,
scan_options: crate::scanner::ScanOptions,
) -> anyhow::Result<()> {
install_panic_hook();
let mut terminal = init_terminal()?;
let mut app = App::with_scan_options(root, scan_options);
app.detect_system = true;
app.start_initial_scan();
run_with_cleanup(
|| {
while !app.should_quit {
app.poll_background_work();
terminal.draw(|frame| render(&app, frame))?;
handle_events(&mut app, Duration::from_millis(100))?;
}
Ok(())
},
restore_terminal,
)
}
fn run_with_cleanup<T>(
operation: impl FnOnce() -> anyhow::Result<T>,
cleanup: impl FnOnce() -> io::Result<()>,
) -> anyhow::Result<T> {
let operation_result = operation();
let cleanup_result = cleanup();
match (operation_result, cleanup_result) {
(Ok(value), Ok(())) => Ok(value),
(Ok(_), Err(cleanup_error)) => Err(cleanup_error.into()),
(Err(operation_error), _) => Err(operation_error),
}
}
pub type Tui = Terminal<CrosstermBackend<Stdout>>;
pub fn init_terminal() -> io::Result<Tui> {
enable_raw_mode()?;
if let Err(error) = execute!(stdout(), EnterAlternateScreen) {
let _ = disable_raw_mode();
return Err(error);
}
let backend = CrosstermBackend::new(stdout());
match Terminal::new(backend) {
Ok(terminal) => Ok(terminal),
Err(error) => {
let _ = restore_terminal();
Err(error)
}
}
}
pub fn restore_terminal() -> io::Result<()> {
disable_raw_mode()?;
execute!(stdout(), LeaveAlternateScreen)?;
Ok(())
}
pub fn install_panic_hook() {
let original_hook = std::panic::take_hook();
std::panic::set_hook(Box::new(move |panic_info| {
let _ = restore_terminal();
original_hook(panic_info);
}));
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::atomic::{AtomicBool, Ordering};
#[test]
fn test_restore_terminal_without_init_is_safe() {
let _ = restore_terminal();
}
#[test]
fn test_cleanup_runs_when_tui_loop_returns_error() {
let cleaned = AtomicBool::new(false);
let result: anyhow::Result<()> = run_with_cleanup(
|| Err(anyhow::anyhow!("injected event-loop failure")),
|| {
cleaned.store(true, Ordering::SeqCst);
Ok(())
},
);
assert!(result.is_err());
assert!(cleaned.load(Ordering::SeqCst));
}
}