use std::collections::BTreeSet;
use std::path::PathBuf;
use rustik_tui as tui;
use tui::{
Buffer, Color, Label, Line, Placement, Point, Rect, Style, Table, TableOptions, Tree,
TreeModel, TreeNodeKind, TreeRow, TreeState, TreeStyle, View, Widget, colors,
};
use super::{DiffPalette, FILE_KIND_BADGE_FG, MIN_RENDER_COLS};
use crate::{DiffDocument, FileId, FileKind, Stats};
const DEFAULT_COLS: usize = 28;
const TOP_PADDING_ROWS: usize = 1;
const INFO_BOX_ROWS: usize = 4;
const INFO_BOX_GAP_ROWS: usize = 1;
const MIN_TREE_ROWS_WITH_INFO: usize = 3;
const TREE_INDENT_COLS: usize = 2;
const SELECTED_FILE_BG: Color = Color::Fixed(235);
const SELECTED_FOLDER_BG: Color = Color::Fixed(234);
const SELECTED_FG: Color = Color::Fixed(252);
const FOLDER_FG: Color = Color::Fixed(245);
const SELECTED_FOLDER_FG: Color = Color::Fixed(246);
const FILE_TREE_STYLE: TreeStyle =
TreeStyle::new(Style::new(Color::Unset), Style::new(Color::Unset));
const SELECTED_FILE_STYLE: Style = Style::new(SELECTED_FG).bg(SELECTED_FILE_BG);
const SELECTED_FOLDER_STYLE: Style = Style::new(SELECTED_FOLDER_FG).bg(SELECTED_FOLDER_BG);
pub(super) const GAP_COLS: usize = 1;
pub(super) const MIN_VIEW_COLS: usize = 80;
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum FileTreeTarget {
Root,
Directory(PathBuf),
File(FileId),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum FileTreeClick {
Disclosure,
Row,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum FileTreeMode {
#[default]
Hidden,
Auto,
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct FileTreeNode {
name: String,
children: Vec<usize>,
file: Option<FileTreeFile>,
target: FileTreeTarget,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct FileTreeFile {
id: FileId,
kind: FileKind,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct FileTreeViewer {
model: FileTreeModel,
state: TreeState<usize>,
}
impl FileTreeViewer {
pub(super) fn new(document: &DiffDocument, root: String) -> Self {
let model = FileTreeModel::new(document, root);
let state = model.initial_state();
Self { model, state }
}
pub(super) fn state(&self) -> &TreeState<usize> {
&self.state
}
#[cfg(test)]
pub(super) fn target(&self) -> Option<FileTreeTarget> {
self.state
.selected()
.and_then(|id| self.model.target_for(id))
}
pub(super) fn cols(&self, view_cols: usize) -> usize {
let available = view_cols.saturating_sub(GAP_COLS + MIN_RENDER_COLS);
Tree::new(&self.model, &self.state)
.content_cols(DEFAULT_COLS)
.min(available)
}
pub(super) fn render(
&mut self,
active_file: Option<FileId>,
palette: DiffPalette,
area: Rect,
buf: &mut Buffer,
) {
let Some((tree_area, info_area)) = Self::areas(area) else {
return;
};
let collapsed = self
.model
.branch_ids()
.filter(|id| !self.state.is_expanded(*id))
.collect();
let styled = StyledFileTree {
model: &self.model,
selected: self.state.selected(),
active_file,
collapsed,
palette,
};
let tree = Tree::new(&styled, &self.state).style(FILE_TREE_STYLE);
let rows = tree.visible_rows();
let row = tree.selected_row(&rows).unwrap_or_default();
let view =
View::new(0, rows.len(), tree_area.rows).with_row_visible(row, Placement::Minimal);
view.render_rows(tree_area, buf, |row, cols| tree.render_row(rows[row], cols));
if let Some(area) = info_area {
let mut table = Table::new(TableOptions {
border: Some(tui::Border::new(colors::FAINT)),
spacing: 2,
..TableOptions::default()
});
let stats = self.model.stats;
table.push([
Line::new(Label::new("lines changed").fg(FOLDER_FG)),
Line::spaced([
Label::from(format!("+{}", stats.insertions)).fg(palette.positive_fg),
Label::from(format!("-{}", stats.deletions)).fg(palette.negative_fg),
]),
]);
table.push([
Line::new(Label::new("files changed").fg(FOLDER_FG)),
Line::new(Label::from(format!(" {}", stats.files_changed)).fg(Color::White)),
]);
table.render(area, buf);
}
}
pub(super) fn enter(&mut self, active_file: Option<FileId>) {
let chosen = active_file
.and_then(|file| self.visible_node_for_file(file))
.or_else(|| self.first_visible_node());
if let Some(id) = chosen {
self.state.select(id);
}
}
pub(super) fn select(&mut self, delta: isize) -> Option<FileId> {
self.state.select_next(&self.model, delta);
self.selected_file()
}
pub(super) fn select_file(&mut self, file: FileId) -> bool {
let Some(id) = self.visible_node_for_file(file) else {
return false;
};
self.state.select(id)
}
pub(super) fn select_at(&mut self, area: Rect, point: Point) -> Option<FileTreeClick> {
let (tree_area, _) = Self::areas(area)?;
let tree = Tree::new(&self.model, &self.state);
let rows = tree.visible_rows();
let row = tree.selected_row(&rows).unwrap_or_default();
let view =
View::new(0, rows.len(), tree_area.rows).with_row_visible(row, Placement::Minimal);
let row = view.row_at(tree_area, point)?;
let row = rows.get(row)?;
if self.model.kind(row.id) == TreeNodeKind::Branch
&& point.x.saturating_sub(tree_area.x) == row.depth.saturating_mul(TREE_INDENT_COLS)
{
self.state.toggle(&self.model, row.id);
Some(FileTreeClick::Disclosure)
} else {
self.state.select(row.id);
Some(FileTreeClick::Row)
}
}
pub(super) fn activate_target(&mut self) -> Option<FileId> {
let id = self.state.selected()?;
if self.model.kind(id) == TreeNodeKind::Branch {
self.state.toggle(&self.model, id);
}
self.selected_file()
}
pub(super) fn selected_file(&self) -> Option<FileId> {
self.state
.selected()
.and_then(|id| self.model.first_file_for(id))
}
pub(super) fn collapse_folder(&mut self) {
let Some(id) = self.state.selected() else {
return;
};
if self.model.kind(id) == TreeNodeKind::Branch {
self.state.collapse(id);
}
}
pub(super) fn expand_folder(&mut self) {
let Some(id) = self.state.selected() else {
return;
};
if self.model.kind(id) == TreeNodeKind::Branch {
self.state.expand(id);
}
}
fn visible_node_for_file(&self, file: FileId) -> Option<usize> {
let mut collapsed_branch = None;
for row in Tree::new(&self.model, &self.state).visible_rows() {
match self.model.target_for(row.id) {
Some(FileTreeTarget::File(candidate)) if candidate == file => {
return Some(row.id);
}
Some(FileTreeTarget::Root | FileTreeTarget::Directory(_))
if !self.state.is_expanded(row.id)
&& self.model.files_for(row.id).contains(&file) =>
{
collapsed_branch = Some(row.id);
}
_ => {}
}
}
collapsed_branch
}
fn first_visible_node(&self) -> Option<usize> {
Tree::new(&self.model, &self.state)
.visible_rows()
.into_iter()
.next()
.map(|row| row.id)
}
fn areas(area: Rect) -> Option<(Rect, Option<Rect>)> {
let body: Rect = Rect::new(
area.x,
area.y.saturating_add(TOP_PADDING_ROWS),
area.cols,
area.rows.saturating_sub(TOP_PADDING_ROWS),
);
if body.is_empty() {
return None;
}
let info_rows = INFO_BOX_ROWS + INFO_BOX_GAP_ROWS + MIN_TREE_ROWS_WITH_INFO;
let info = (body.rows >= info_rows).then(|| {
Rect::new(
body.x,
body.bottom().saturating_sub(INFO_BOX_ROWS),
body.cols,
INFO_BOX_ROWS,
)
});
let tree_rows = if info.is_some() {
body.rows.saturating_sub(INFO_BOX_ROWS + INFO_BOX_GAP_ROWS)
} else {
body.rows
};
Some((Rect::new(body.x, body.y, body.cols, tree_rows), info))
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub(super) struct FileTreeModel {
roots: Vec<usize>,
nodes: Vec<FileTreeNode>,
stats: Stats,
}
impl FileTreeModel {
pub(super) fn new(document: &DiffDocument, root: String) -> Self {
let mut model = Self {
roots: Vec::new(),
nodes: Vec::new(),
stats: document.stats(),
};
let root = model.push_node(None, root, None, FileTreeTarget::Root);
for file in &document.files {
model.insert_file(
root,
Self::path_parts(file.header.display_path()),
file.id,
file.header.kind,
);
}
model
}
pub(super) fn initial_state(&self) -> TreeState<usize> {
let mut state = TreeState::new();
for id in self.branch_ids() {
state.expand(id);
}
state
}
fn target_for(&self, id: usize) -> Option<FileTreeTarget> {
self.nodes.get(id).map(|node| node.target.clone())
}
fn branch_ids(&self) -> impl Iterator<Item = usize> + '_ {
self.nodes
.iter()
.enumerate()
.filter_map(|(id, node)| (!node.children.is_empty()).then_some(id))
}
fn files_for(&self, id: usize) -> BTreeSet<FileId> {
let mut files = BTreeSet::new();
if let Some(file) = self.nodes[id].file {
files.insert(file.id);
}
for child in &self.nodes[id].children {
files.extend(self.files_for(*child));
}
files
}
fn first_file_for(&self, id: usize) -> Option<FileId> {
if let Some(file) = self.nodes[id].file {
return Some(file.id);
}
self.nodes[id]
.children
.iter()
.find_map(|child| self.first_file_for(*child))
}
fn path_parts(path: Option<&PathBuf>) -> Vec<String> {
let Some(path) = path else {
return vec!["<unknown>".to_owned()];
};
let parts: Vec<String> = path
.iter()
.map(|part| part.to_string_lossy().into_owned())
.filter(|part| !part.is_empty())
.collect();
if parts.is_empty() {
vec!["<unknown>".to_owned()]
} else {
parts
}
}
fn insert_file(&mut self, root: usize, parts: Vec<String>, file: FileId, kind: FileKind) {
let mut parent = Some(root);
let mut path = PathBuf::new();
let end = parts.len().saturating_sub(1);
for (index, name) in parts.into_iter().enumerate() {
path.push(&name);
let is_file = index == end;
let target = if is_file {
FileTreeTarget::File(file)
} else {
FileTreeTarget::Directory(path.clone())
};
let existing = self.child(parent, &target);
let node = existing.unwrap_or_else(|| {
let file = is_file.then_some(FileTreeFile { id: file, kind });
self.push_node(parent, name, file, target)
});
parent = Some(node);
}
}
fn child(&self, parent: Option<usize>, target: &FileTreeTarget) -> Option<usize> {
let children = parent.map_or(self.roots.as_slice(), |id| {
self.nodes[id].children.as_slice()
});
children
.iter()
.copied()
.find(|&child| self.nodes[child].target == *target)
}
fn push_node(
&mut self,
parent: Option<usize>,
name: String,
file: Option<FileTreeFile>,
target: FileTreeTarget,
) -> usize {
let id = self.nodes.len();
self.nodes.push(FileTreeNode {
name,
children: Vec::new(),
file,
target,
});
if let Some(parent) = parent {
self.nodes[parent].children.push(id);
} else {
self.roots.push(id);
}
id
}
fn folder_row(&self, id: usize, fg: Color, style: Style) -> TreeRow {
let node = &self.nodes[id];
let label = if node.name == "/" {
node.name.to_owned()
} else {
format!("{}/", node.name)
};
TreeRow::new(Label::from(label).fg(fg))
.marker_style(Style::new(fg))
.style(style)
}
}
impl TreeModel for FileTreeModel {
type Id = usize;
fn roots(&self) -> &[Self::Id] {
&self.roots
}
fn children(&self, id: Self::Id) -> &[Self::Id] {
&self.nodes[id].children
}
fn kind(&self, id: Self::Id) -> TreeNodeKind {
if self.nodes[id].file.is_some() {
TreeNodeKind::Leaf
} else {
TreeNodeKind::Branch
}
}
fn row(&self, id: Self::Id) -> TreeRow {
let node = &self.nodes[id];
let Some(file) = node.file else {
return self.folder_row(id, FOLDER_FG, Style::default());
};
TreeRow::new(Label::new(&node.name).fg(Color::White))
.marker(file.kind.marker())
.marker_style(Style::new(Color::Unset))
}
}
struct StyledFileTree<'a> {
model: &'a FileTreeModel,
selected: Option<usize>,
active_file: Option<FileId>,
collapsed: BTreeSet<usize>,
palette: DiffPalette,
}
impl StyledFileTree<'_> {
fn is_active(&self, id: usize) -> bool {
if self.selected == Some(id) {
return true;
}
let Some(node) = self.model.nodes.get(id) else {
return false;
};
let Some(active_file) = self.active_file else {
return false;
};
match &node.target {
FileTreeTarget::File(file) => *file == active_file,
FileTreeTarget::Root | FileTreeTarget::Directory(_) => {
self.collapsed.contains(&id) && self.model.files_for(id).contains(&active_file)
}
}
}
fn row_style(&self, id: usize) -> Style {
if !self.is_active(id) {
return Style::default();
}
match self.model.nodes[id].target {
FileTreeTarget::Root | FileTreeTarget::Directory(_) => SELECTED_FOLDER_STYLE,
FileTreeTarget::File(_) => SELECTED_FILE_STYLE,
}
}
}
impl TreeModel for StyledFileTree<'_> {
type Id = usize;
fn roots(&self) -> &[Self::Id] {
self.model.roots()
}
fn children(&self, id: Self::Id) -> &[Self::Id] {
self.model.children(id)
}
fn kind(&self, id: Self::Id) -> TreeNodeKind {
self.model.kind(id)
}
fn row(&self, id: Self::Id) -> TreeRow {
let node = &self.model.nodes[id];
let active = self.is_active(id);
let Some(file) = node.file else {
let fg = if active {
SELECTED_FOLDER_FG
} else {
FOLDER_FG
};
return self.model.folder_row(id, fg, self.row_style(id));
};
let fg = if active { SELECTED_FG } else { Color::White };
let kind_fg = match file.kind {
FileKind::Added => self.palette.positive_fg,
FileKind::Deleted => self.palette.negative_fg,
FileKind::Renamed => FILE_KIND_BADGE_FG,
FileKind::Modified | FileKind::Copied | FileKind::ModeChanged | FileKind::Binary => {
Color::Yellow
}
};
TreeRow::new(Label::new(&node.name).fg(fg))
.marker(file.kind.marker())
.marker_style(Style::new(kind_fg))
.style(self.row_style(id))
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use crate::{Decode, DiffDocument, DiffOptions, DiffViewer};
fn two_file_viewer() -> DiffViewer {
let document = DiffDocument::decode_str(
"\
diff --git a/a.rs b/a.rs
index 1111111..2222222 100644
--- a/a.rs
+++ b/a.rs
@@ -1,3 +1,4 @@ fn a
context
-old
+new
+extra
tail
diff --git a/b.rs b/b.rs
index 3333333..4444444 100644
--- a/b.rs
+++ b/b.rs
@@ -1,2 +1,2 @@ fn b
keep
-before
+after
",
)
.unwrap();
DiffViewer::new(document, DiffOptions::default())
}
#[test]
fn file_tree_keeps_all_files_in_main_diff_rows() {
let viewer = two_file_viewer();
assert_eq!(viewer.index.files.len(), 2);
assert_eq!(viewer.index.rows, 16);
}
}