use ratatui::{
prelude::*,
text::Line,
widgets::{Block, Borders, Clear, Paragraph},
};
use super::app::{App, ConfirmAction, Mode};
pub fn render(app: &App, frame: &mut Frame) {
let chunks = Layout::default()
.direction(Direction::Vertical)
.constraints([
Constraint::Length(3), Constraint::Min(1), Constraint::Length(2), ])
.split(frame.area());
render_header(app, frame, chunks[0]);
render_tree_area(app, frame, chunks[1]);
render_footer(app, frame, chunks[2]);
match app.mode {
Mode::Search => render_search_overlay(app, frame),
Mode::Confirm(action) => render_confirm_dialog(app, frame, action),
Mode::Help => render_help_overlay(frame),
Mode::Normal => {}
}
}
fn render_header(app: &App, frame: &mut Frame, area: Rect) {
let path_display = app.root.display().to_string();
let size_display = app
.tree
.as_ref()
.map(|t| humansize::format_size(t.size, humansize::BINARY))
.unwrap_or_else(|| "...".to_string());
let disk_info = app.get_disk_usage().map(|(total, used, avail)| {
let total_str = humansize::format_size(total, humansize::BINARY);
let used_str = humansize::format_size(used, humansize::BINARY);
let avail_str = humansize::format_size(avail, humansize::BINARY);
let percent = if total > 0 {
(used as f64 / total as f64 * 100.0) as u32
} else {
0
};
format!(
"Disk: {} / {} ({}% used, {} free)",
used_str, total_str, percent, avail_str
)
});
let header_text = match disk_info {
Some(disk) => format!(" {} {} │ {}", path_display, size_display, disk),
None => format!(" {} {}", path_display, size_display),
};
let title = " Rusty Sweeper ";
let block = Block::default()
.title(title)
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Cyan));
let paragraph = Paragraph::new(header_text)
.block(block)
.style(Style::default().fg(Color::White));
frame.render_widget(paragraph, area);
}
fn render_tree_area(app: &App, frame: &mut Frame, area: Rect) {
let block = Block::default()
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Gray));
if app.visible_entries.is_empty() {
let message = if app.scanning {
"Scanning..."
} else if !app.search_query.is_empty() {
"No matches found"
} else if app.tree.is_none() {
"No data"
} else {
"Empty directory"
};
let paragraph = Paragraph::new(message)
.block(block)
.alignment(Alignment::Center)
.style(Style::default().fg(Color::DarkGray));
frame.render_widget(paragraph, area);
return;
}
let inner_area = block.inner(area);
frame.render_widget(block, area);
let max_size = app.tree.as_ref().map(|t| t.size).unwrap_or(1);
let visible_height = inner_area.height as usize;
let scroll_offset =
calculate_scroll_offset(app.selected, visible_height, app.visible_entries.len());
for (i, visible_entry) in app
.visible_entries
.iter()
.skip(scroll_offset)
.take(visible_height)
.enumerate()
{
let y = inner_area.y + i as u16;
let is_selected = scroll_offset + i == app.selected;
render_entry(
frame,
visible_entry,
inner_area.x,
y,
inner_area.width,
max_size,
is_selected,
);
}
}
fn calculate_scroll_offset(selected: usize, visible_height: usize, total: usize) -> usize {
if total <= visible_height {
return 0;
}
let padding = 3.min(visible_height / 4);
if selected < padding {
0
} else if selected >= total - padding {
total.saturating_sub(visible_height)
} else {
selected.saturating_sub(padding)
}
}
fn size_color(size: u64, max_size: u64) -> Color {
if max_size == 0 {
return Color::Gray;
}
let ratio = size as f64 / max_size as f64;
if ratio < 0.25 {
Color::Green
} else if ratio < 0.50 {
Color::Yellow
} else if ratio < 0.75 {
Color::Rgb(255, 165, 0) } else {
Color::Red
}
}
fn render_entry(
frame: &mut Frame,
entry: &super::app::VisibleEntry,
x: u16,
y: u16,
width: u16,
max_size: u64,
is_selected: bool,
) {
let area = Rect::new(x, y, width, 1);
if entry.is_separator {
let separator = "─".repeat(width as usize);
let line = Line::from(Span::styled(
separator,
Style::default().fg(Color::DarkGray),
));
frame.render_widget(Paragraph::new(line), area);
return;
}
if let Some(resource) = &entry.system_resource {
let icon = "⚙ ";
let item_info = resource
.item_count
.map(|n| format!(" ({} items)", n))
.unwrap_or_default();
let size_width = 10;
let size_str = humansize::format_size(resource.size, humansize::BINARY);
let size_str_padded = format!("{:>width$}", size_str, width = size_width);
let suffix_len = size_width + 1; let prefix_len = icon.chars().count();
let name_area_width = (width as usize).saturating_sub(prefix_len + suffix_len);
let display_name = &resource.display_name;
let used = display_name.chars().count() + item_info.chars().count();
let padding = " ".repeat(name_area_width.saturating_sub(used));
let name_style = Style::default().fg(Color::Cyan).bold();
let info_style = Style::default().fg(Color::DarkGray);
let size_style = Style::default().fg(Color::Yellow);
let spans = vec![
Span::styled(icon, name_style),
Span::styled(display_name.clone(), name_style),
Span::styled(item_info, info_style),
Span::raw(padding),
Span::raw(" "),
Span::styled(size_str_padded, size_style),
];
let mut line = Line::from(spans);
if is_selected {
line = line.style(Style::default().bg(Color::DarkGray));
}
frame.render_widget(Paragraph::new(line), area);
return;
}
let indent = " ".repeat(entry.depth);
let icon = if entry.entry.is_dir {
if entry.is_expanded {
"▼ "
} else {
"► "
}
} else {
" "
};
let bar_width = 10;
let fill = if max_size > 0 {
((entry.entry.size as f64 / max_size as f64) * bar_width as f64) as usize
} else {
0
};
let bar_filled = "█".repeat(fill);
let bar_empty = "░".repeat(bar_width - fill);
let size_width = 10;
let size_str = humansize::format_size(entry.entry.size, humansize::BINARY);
let size_str_padded = format!("{:>width$}", size_str, width = size_width);
let size_style_color = size_color(entry.entry.size, max_size);
let project_indicator = entry
.project_type
.as_ref()
.map(|t| format!(" [{}]", t))
.unwrap_or_default();
let prefix_len = indent.chars().count() + icon.chars().count();
let suffix_len = (bar_width + 2) + size_width + 2;
let name_area_width = (width as usize).saturating_sub(prefix_len + suffix_len);
let name_width = name_area_width.saturating_sub(project_indicator.chars().count());
let name = &entry.entry.name;
let name_char_count = name.chars().count();
let display_name = if name_char_count > name_width && name_width > 1 {
let truncated: String = name.chars().take(name_width.saturating_sub(1)).collect();
format!("{}…", truncated)
} else {
name.clone()
};
let used_in_name_area = display_name.chars().count() + project_indicator.chars().count();
let padding = " ".repeat(name_area_width.saturating_sub(used_in_name_area));
let name_style = if entry.entry.is_dir {
Style::default().fg(Color::Blue).bold()
} else {
Style::default().fg(Color::White)
};
let project_style = Style::default().fg(Color::Cyan);
let size_style = Style::default().fg(size_style_color);
let mut spans = vec![
Span::styled(format!("{}{}", indent, icon), name_style),
Span::styled(display_name.clone(), name_style),
];
if !project_indicator.is_empty() {
spans.push(Span::styled(project_indicator.clone(), project_style));
}
spans.push(Span::raw(padding));
spans.push(Span::raw(" "));
spans.push(Span::styled("[", Style::default().fg(Color::DarkGray)));
spans.push(Span::styled(bar_filled, size_style));
spans.push(Span::styled(
bar_empty,
Style::default().fg(Color::DarkGray),
));
spans.push(Span::styled("]", Style::default().fg(Color::DarkGray)));
spans.push(Span::raw(" "));
spans.push(Span::styled(size_str_padded, size_style));
let mut line = Line::from(spans);
if is_selected {
line = line.style(Style::default().bg(Color::DarkGray));
}
frame.render_widget(Paragraph::new(line), area);
}
fn render_footer(app: &App, frame: &mut Frame, area: Rect) {
let hints = match app.mode {
Mode::Normal => {
"[↑↓] Navigate [←→] Expand [d] Delete [c] Clean [/] Search [?] Help [q] Quit"
}
Mode::Search => "[Enter] Confirm [Esc] Cancel",
Mode::Confirm(_) => "[y] Yes [n] No",
Mode::Help => "[Esc] Close",
};
let text = app.status_message.as_deref().unwrap_or(hints);
let paragraph = Paragraph::new(text)
.style(Style::default().fg(Color::DarkGray))
.alignment(Alignment::Center);
frame.render_widget(paragraph, area);
}
fn render_search_overlay(app: &App, frame: &mut Frame) {
let area = frame.area();
let search_area = Rect {
x: 2,
y: area.height.saturating_sub(6),
width: area.width.saturating_sub(4).min(60),
height: 3,
};
frame.render_widget(Clear, search_area);
let block = Block::default()
.title(" Search ")
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Yellow));
let input = format!("/{}", app.search_query);
let paragraph = Paragraph::new(input)
.block(block)
.style(Style::default().fg(Color::White));
frame.render_widget(paragraph, search_area);
frame.set_cursor_position(Position::new(
search_area.x + app.search_query.len() as u16 + 2, search_area.y + 1,
));
}
fn render_confirm_dialog(app: &App, frame: &mut Frame, action: ConfirmAction) {
let area = frame.area();
let (title, message, dialog_height) = match action {
ConfirmAction::Delete => {
let path = app
.confirmation_target
.as_ref()
.or_else(|| app.selected_entry())
.map(|e| {
let p = e.entry.path.display().to_string();
if p.chars().count() > 35 {
let suffix: String = p
.chars()
.rev()
.take(32)
.collect::<Vec<_>>()
.into_iter()
.rev()
.collect();
format!("...{suffix}")
} else {
p
}
})
.unwrap_or_default();
let size = app
.confirmation_target
.as_ref()
.or_else(|| app.selected_entry())
.map(|e| humansize::format_size(e.entry.size, humansize::BINARY))
.unwrap_or_default();
(
" Delete ",
format!("Delete '{}'?\n\nSize: {}\n\n[y]es [n]o", path, size),
7u16,
)
}
ConfirmAction::Clean => {
if let Some(preview) = &app.clean_preview {
let total_str = humansize::format_size(preview.total_size, humansize::BINARY);
let is_system_resource = app
.confirmation_target
.as_ref()
.or_else(|| app.selected_entry())
.is_some_and(|e| e.system_resource.is_some());
let mut artifact_lines = String::new();
for (name, size) in &preview.artifacts {
let size_str = humansize::format_size(*size, humansize::BINARY);
artifact_lines.push_str(&format!(" {} ({})\n", name, size_str));
}
let (title, message) = if is_system_resource {
(
" Clean Resource ",
format!(
"Clean {}?\n\n{}\nTotal: {}\n\n[y]es [n]o",
preview.project_name, artifact_lines, total_str
),
)
} else {
(
" Clean Project ",
format!(
"Clean {} project?\n\nArtifacts to remove:\n{}\nTotal: {}\n\n[y]es [n]o",
preview.project_name, artifact_lines, total_str
),
)
};
let height = (7 + preview.artifacts.len()).min(15) as u16;
(title, message, height)
} else {
(" Clean Project ", "No preview available".to_string(), 5u16)
}
}
};
let dialog_width = 50u16.min(area.width.saturating_sub(4));
let dialog_area = Rect {
x: (area.width.saturating_sub(dialog_width)) / 2,
y: (area.height.saturating_sub(dialog_height)) / 2,
width: dialog_width,
height: dialog_height,
};
frame.render_widget(Clear, dialog_area);
let block = Block::default()
.title(title)
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Yellow));
let paragraph = Paragraph::new(message)
.block(block)
.style(Style::default().fg(Color::White))
.alignment(Alignment::Center);
frame.render_widget(paragraph, dialog_area);
}
fn render_help_overlay(frame: &mut Frame) {
let area = frame.area();
let help_width = 60u16.min(area.width.saturating_sub(8));
let help_height = 22u16.min(area.height.saturating_sub(4));
let help_area = Rect {
x: (area.width.saturating_sub(help_width)) / 2,
y: (area.height.saturating_sub(help_height)) / 2,
width: help_width,
height: help_height,
};
frame.render_widget(Clear, help_area);
let help_text = r#"
NAVIGATION
─────────────────────────────────
↑/k Move up
↓/j Move down
→/l/Enter Expand directory
←/h/Bksp Collapse / Go to parent
Space Toggle expand/collapse
g Go to top
G Go to bottom
ACTIONS
─────────────────────────────────
d Delete selected
c Clean project artifacts
r Refresh / Rescan
VIEW
─────────────────────────────────
/ Search / Filter
s Cycle sort order
. Toggle hidden files
? Toggle this help
q/Esc Quit
"#;
let block = Block::default()
.title(" Help ")
.borders(Borders::ALL)
.border_style(Style::default().fg(Color::Cyan));
let paragraph = Paragraph::new(help_text)
.block(block)
.style(Style::default().fg(Color::White));
frame.render_widget(paragraph, help_area);
}
#[cfg(test)]
mod tests {
use super::*;
use ratatui::backend::TestBackend;
use std::path::PathBuf;
#[test]
fn test_render_does_not_panic() {
let app = App::new(PathBuf::from("/"));
let backend = TestBackend::new(80, 24);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_render_with_tree() {
use crate::scanner::DirEntry;
let mut app = App::new(PathBuf::from("/test"));
app.tree = Some(DirEntry::new_dir(PathBuf::from("/test"), None));
app.rebuild_visible_entries();
let backend = TestBackend::new(80, 24);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_calculate_scroll_offset() {
assert_eq!(calculate_scroll_offset(0, 20, 10), 0);
assert_eq!(calculate_scroll_offset(5, 20, 10), 0);
assert_eq!(calculate_scroll_offset(0, 10, 100), 0);
assert_eq!(calculate_scroll_offset(2, 10, 100), 0);
let offset = calculate_scroll_offset(50, 10, 100);
assert!(offset <= 50);
assert!(offset + 10 > 50);
let offset = calculate_scroll_offset(99, 10, 100);
assert_eq!(offset, 90); }
#[test]
fn test_render_search_overlay() {
let mut app = App::new(PathBuf::from("/"));
app.mode = Mode::Search;
app.search_query = "test".to_string();
let backend = TestBackend::new(80, 24);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_render_confirm_dialog() {
use crate::scanner::DirEntry;
let mut app = App::new(PathBuf::from("/test"));
app.tree = Some(DirEntry::new_dir(PathBuf::from("/test"), None));
app.rebuild_visible_entries();
app.mode = Mode::Confirm(ConfirmAction::Delete);
let backend = TestBackend::new(80, 24);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_render_delete_dialog_with_long_unicode_path() {
let path = PathBuf::from(format!("/{}", "界".repeat(40)));
let entry = crate::scanner::DirEntry::new_file(path.clone(), 10, 10, None);
let mut app = App::new(PathBuf::from("/"));
app.tree = Some(entry);
app.rebuild_visible_entries();
app.confirmation_target = app.selected_entry().cloned();
app.mode = Mode::Confirm(ConfirmAction::Delete);
let backend = TestBackend::new(80, 24);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_render_help_overlay() {
let mut app = App::new(PathBuf::from("/"));
app.mode = Mode::Help;
let backend = TestBackend::new(80, 30);
let mut terminal = Terminal::new(backend).unwrap();
terminal.draw(|frame| render(&app, frame)).unwrap();
}
#[test]
fn test_size_color_gradient() {
let max_size = 1000;
assert_eq!(size_color(100, max_size), Color::Green);
assert_eq!(size_color(249, max_size), Color::Green);
assert_eq!(size_color(250, max_size), Color::Yellow);
assert_eq!(size_color(499, max_size), Color::Yellow);
assert_eq!(size_color(500, max_size), Color::Rgb(255, 165, 0));
assert_eq!(size_color(749, max_size), Color::Rgb(255, 165, 0));
assert_eq!(size_color(750, max_size), Color::Red);
assert_eq!(size_color(1000, max_size), Color::Red);
}
#[test]
fn test_size_color_zero_max() {
assert_eq!(size_color(100, 0), Color::Gray);
}
#[test]
fn test_size_color_edge_cases() {
assert_eq!(size_color(1000, 1000), Color::Red);
assert_eq!(size_color(0, 1000), Color::Green);
assert_eq!(size_color(1_000_000_000, 1_000_000_000), Color::Red);
}
}