mod tree;
use std::collections::btree_map::Entry;
use std::collections::{BTreeMap, BTreeSet};
use std::convert::Infallible;
use std::path::{Path, PathBuf};
use rustik_highlight as syntax;
use rustik_tui as tui;
use tui::{
Buffer, Cell, Color, Constraint, Control, Event, HStack, Key, Label, Line, Mouse, MouseButton,
Placement, Rect, Scroll, ScrollView, ScrollbarStyle, Size, Style, Table, TableOptions, Text,
VStack, View, Viewport, Widget, colors,
};
use crate::context::{self, ContextChange, ContextState};
use crate::highlight::{DiffHighlighter, HighlightKeyInput, HighlightResult};
use crate::word;
use crate::{
Commit, Decode, DecodeError, DiffDocument, DiffLine, DiffLineKind, DiffSide, FileDiff, FileId,
FileKind, HighlightKey, HighlightRequest, HighlightSource, Hunk, HunkId, RowId,
};
pub use tree::{FileTreeMode, FileTreeTarget};
const MIN_RENDER_COLS: usize = 12;
const LINE_NUMBER_WIDTH: usize = 5;
const LINE_NUMBER_FG: Color = colors::fixed::DIM;
const MARKER_WIDTH: usize = 3;
const SCROLLBAR_TRACK: char = '🮘';
const SCROLLBAR_THUMB: char = '▐';
const SCROLLBAR_THUMB_COLOR: Color = Color::Fixed(237);
const DIVIDER: char = '─';
const FILE_KIND_BADGE_FG: Color = colors::rgb::PURPLE;
const FILE_KIND_BADGE_BG: Color = Color::RGB(32, 22, 42);
const FILE_BORDER: tui::Border = tui::Border::new(colors::FAINT);
const STICKY_DIVIDER: char = '╴';
const RENAME_ARROW: &str = "→";
const NO_NEWLINE_MARKER: &str = "\\ No newline at end of file";
const HUNK_GAP_MARKER_CELL: &str = " ⋮ ";
const DEFAULT_HIGHLIGHT_LOOKAHEAD: usize = 4;
const DEFAULT_THEME: &str = "auto";
const STICKY_HEADER_ROWS: usize = 3;
const LINE_SCROLL_ROWS: isize = 1;
const WHEEL_SCROLL_ROWS: isize = 3;
const FILE_TOP_ROW: usize = 0;
const FILE_HEADER_ROW: usize = 1;
const FILE_DIVIDER_ROW: usize = 2;
const HUNK_BODY_START: usize = FILE_DIVIDER_ROW + 1;
const EMPTY_CARD_ROWS: usize = FILE_DIVIDER_ROW + 1;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct DiffState {
pub scroll: usize,
pub focus: Option<DiffFocus>,
pub collapsed_files: BTreeSet<FileId>,
}
impl DiffState {
fn invalidates_index(&self, next: &Self) -> bool {
self.collapsed_files != next.collapsed_files
}
}
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DiffFocus {
File(FileId),
Hunk(HunkId),
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum DiffAction {
Scroll(Scroll),
Resize,
FocusNext,
FocusPrevious,
NextHunk,
PreviousHunk,
ToggleFocusedFile,
CollapseFocusedFile,
ToggleFileTree,
MoveFileTree(isize),
ShowFileTreeTarget,
ActivateFileTreeTarget,
CollapseFileTreeFolder,
ExpandFileTreeFolder,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ViewChange {
Changed,
Unchanged,
}
#[derive(Clone, Debug)]
pub struct DiffOptions {
pub highlight_lookahead: usize,
pub syntax: Option<String>,
pub theme: String,
pub diff_palette: DiffPalette,
pub file_tree: FileTreeMode,
pub file_tree_root: String,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct DiffPalette {
pub negative_row_bg: Color,
pub positive_row_bg: Color,
pub negative_word_bg: Color,
pub positive_word_bg: Color,
pub negative_fg: Color,
pub positive_fg: Color,
}
#[derive(Clone, Debug)]
pub struct ContextRequest {
next_context: ContextState,
active: Option<FileId>,
files: Vec<(PathBuf, FileId)>,
context_lines: usize,
next_ids: (usize, usize),
}
#[derive(Clone, Debug)]
pub struct ContextUpdate {
next_context: ContextState,
active: Option<FileId>,
files: Vec<FileDiff>,
}
#[derive(Clone, Debug)]
pub struct DiffViewer {
document: DiffDocument,
options: DiffOptions,
state: DiffState,
highlights: BTreeMap<HighlightKey, Line>,
pending_highlights: BTreeSet<HighlightKey>,
hunk_highlight_sources: BTreeMap<(FileId, HunkId, DiffSide), HighlightSource>,
word_diffs: BTreeMap<HunkId, word::WordChanges>,
preamble: Vec<Line>,
file_tree: tree::FileTreeViewer,
file_tree_visibility: FileTreeVisibility,
index: RowIndex,
context: ContextState,
}
#[derive(Clone, Debug, Default)]
struct RowIndex {
files: Vec<IndexedFileRows>,
rows: usize,
}
#[derive(Clone, Copy, Debug)]
struct IndexedFileRows {
file_index: usize,
start: usize,
}
#[derive(Clone, Debug)]
struct RenderRow {
line: Line,
diff: Option<DiffLineMeta>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct FileRowLocation<'a> {
file: &'a FileDiff,
start: usize,
end: usize,
local: usize,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct StickyHeaderRows {
start: usize,
rows: usize,
}
#[derive(Clone, Debug, Eq, PartialEq)]
struct DiffLineMeta {
file: FileId,
hunk: HunkId,
row: RowId,
kind: DiffLineKind,
side: DiffSide,
source_line: u32,
text: String,
path: Option<PathBuf>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct DiffLayout {
diff: Rect,
tree: Option<Rect>,
}
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
enum FileTreeVisibility {
#[default]
Auto,
Hidden,
}
impl Default for DiffOptions {
fn default() -> Self {
Self {
highlight_lookahead: DEFAULT_HIGHLIGHT_LOOKAHEAD,
syntax: None,
theme: DEFAULT_THEME.to_owned(),
diff_palette: DiffPalette::default(),
file_tree: FileTreeMode::default(),
file_tree_root: ".".to_owned(),
}
}
}
impl Default for DiffPalette {
fn default() -> Self {
Self {
negative_row_bg: colors::rgb::NEGATIVE_DARK,
positive_row_bg: colors::rgb::POSITIVE_DARK,
negative_word_bg: colors::rgb::NEGATIVE,
positive_word_bg: colors::rgb::POSITIVE,
negative_fg: colors::rgb::NEGATIVE_LIGHT,
positive_fg: colors::rgb::POSITIVE_LIGHT,
}
}
}
impl From<&syntax::RawTheme> for DiffPalette {
fn from(theme: &syntax::RawTheme) -> Self {
let mut palette = Self::default();
if theme.colors.is_empty() {
return palette;
};
palette.positive_fg =
Self::theme_color(&theme.colors, "gitDecoration.addedResourceForeground")
.or_else(|| Self::theme_color(&theme.colors, "editorGutter.addedBackground"))
.unwrap_or(palette.positive_fg);
palette.negative_fg =
Self::theme_color(&theme.colors, "gitDecoration.deletedResourceForeground")
.or_else(|| Self::theme_color(&theme.colors, "editorGutter.deletedBackground"))
.unwrap_or(palette.negative_fg);
palette.positive_row_bg =
Self::theme_color(&theme.colors, "diffEditor.insertedLineBackground")
.unwrap_or(palette.positive_row_bg);
palette.negative_row_bg =
Self::theme_color(&theme.colors, "diffEditor.removedLineBackground")
.unwrap_or(palette.negative_row_bg);
palette.positive_word_bg =
Self::theme_color(&theme.colors, "diffEditor.insertedTextBackground")
.unwrap_or(palette.positive_word_bg);
palette.negative_word_bg =
Self::theme_color(&theme.colors, "diffEditor.removedTextBackground")
.unwrap_or(palette.negative_word_bg);
palette
}
}
impl DiffPalette {
fn theme_color(colors: &BTreeMap<String, String>, key: &str) -> Option<Color> {
let color = colors.get(key)?.parse::<syntax::Rgb>().ok()?;
Some(Color::RGB(color.r, color.g, color.b))
}
}
impl ContextRequest {
pub const fn context_lines(&self) -> usize {
self.context_lines
}
pub fn paths(&self) -> impl Iterator<Item = &Path> {
self.files.iter().map(|(path, _)| path.as_path())
}
pub fn decode(self, patch: &[u8]) -> Result<Option<ContextUpdate>, DecodeError> {
let document = DiffDocument::decode_bytes(patch)?;
let result: Result<Option<Vec<FileDiff>>, Infallible> =
context::rebuild(self.next_ids, &self.files, self.context_lines, |_, _| {
Ok(document.files)
});
let files = match result {
Ok(Some(files)) => files,
Ok(None) => return Ok(None),
Err(error) => match error {},
};
Ok(Some(ContextUpdate {
next_context: self.next_context,
active: self.active,
files,
}))
}
}
impl DiffViewer {
pub fn new(document: DiffDocument, options: DiffOptions) -> Self {
let preamble = Self::preamble(document.commit.as_ref(), MIN_RENDER_COLS);
let file_tree = tree::FileTreeViewer::new(&document, options.file_tree_root.clone());
let state = DiffState::default();
let mut viewer = Self {
document,
options,
state,
highlights: BTreeMap::new(),
pending_highlights: BTreeSet::new(),
hunk_highlight_sources: BTreeMap::new(),
word_diffs: BTreeMap::new(),
preamble,
file_tree,
file_tree_visibility: FileTreeVisibility::default(),
index: RowIndex::default(),
context: ContextState::new(),
};
viewer.rebuild_index();
viewer
}
pub const fn document(&self) -> &DiffDocument {
&self.document
}
pub const fn state(&self) -> &DiffState {
&self.state
}
pub fn set_state(&mut self, state: DiffState) {
let rebuild = self.state.invalidates_index(&state);
self.state = state;
if rebuild {
self.rebuild_index();
}
}
pub fn replace_file_diffs(&mut self, files: impl IntoIterator<Item = FileDiff>) {
for replacement in files {
let existing = match self.document.files.get_mut(*replacement.id) {
Some(existing) if existing.id == replacement.id => Some(existing),
_ => self
.document
.files
.iter_mut()
.find(|file| file.id == replacement.id),
};
if let Some(existing) = existing {
*existing = replacement;
}
}
self.pending_highlights.clear();
self.hunk_highlight_sources.clear();
self.word_diffs.clear();
self.rebuild_index();
}
pub fn context_request(&self, change: ContextChange) -> Option<ContextRequest> {
let active = self.active_context_file();
let file_ids = self.context_file_ids(active);
let plan = self.context.plan(change, &file_ids, &self.document)?;
if plan.files.is_empty() {
return None;
}
Some(ContextRequest {
next_context: plan.state,
active,
files: plan.files,
context_lines: plan.context_lines,
next_ids: context::next_ids(&self.document.files),
})
}
pub fn apply_context_update(&mut self, update: ContextUpdate, area: Rect) -> bool {
if update.files.is_empty() {
return false;
}
let mut state = self.state.clone();
if update.active.is_some() {
state.focus = update.active.map(DiffFocus::File);
}
self.context = update.next_context;
self.replace_file_diffs(update.files);
self.set_state(state);
self.apply(DiffAction::Resize, area) == ViewChange::Changed
}
fn active_context_file(&self) -> Option<FileId> {
self.focused_file().or_else(|| self.visible_file())
}
fn context_file_ids(&self, active: Option<FileId>) -> Vec<FileId> {
active
.filter(|id| self.document.files.iter().any(|file| file.id == *id))
.or_else(|| self.document.files.first().map(|file| file.id))
.into_iter()
.collect()
}
pub fn set_scroll(&mut self, scroll: usize) {
self.state.scroll = scroll;
}
pub fn set_focus(&mut self, focus: Option<DiffFocus>) {
self.state.focus = focus;
}
pub fn set_collapsed_files(&mut self, collapsed_files: BTreeSet<FileId>) {
self.state.collapsed_files = collapsed_files;
self.rebuild_index();
}
pub fn focused_file(&self) -> Option<FileId> {
match self.state.focus? {
DiffFocus::File(file) => Some(file),
DiffFocus::Hunk(hunk) => self
.document
.files
.iter()
.find(|file| file.hunks.iter().any(|candidate| candidate.id == hunk))
.map(|file| file.id),
}
}
fn visible_file(&self) -> Option<FileId> {
self.file_row_location(self.state.scroll)
.map(|location| location.file.id)
.or_else(|| self.document.files.first().map(|file| file.id))
}
fn scroll_rows(&self, visible_rows: usize) -> usize {
let last_file_start = self.index.files.last().map_or(0, |file| file.start);
self.index
.rows
.max(last_file_start.saturating_add(visible_rows))
}
fn render_rows_for(&self, scroll: usize, visible_rows: usize) -> usize {
self.index.rows.max(scroll.saturating_add(visible_rows))
}
fn show_file(&mut self, file: FileId, visible_rows: usize) {
let Some(row) = self.index.files.iter().find_map(|indexed| {
let candidate = self.document.files.get(indexed.file_index)?;
(candidate.id == file).then_some(indexed.start)
}) else {
return;
};
self.state.focus = Some(DiffFocus::File(file));
self.state.scroll = View::new(row, self.scroll_rows(visible_rows), visible_rows).offset;
}
fn sync_file_tree(&mut self) {
if let Some(file) = self.visible_file() {
self.file_tree.select_file(file);
}
}
pub fn render(&mut self, area: Rect, buf: &mut Buffer) {
if area.is_empty() {
return;
}
let layout = self.layout(area);
if let Some(tree) = layout.tree {
self.render_file_tree(tree, buf);
}
self.render_diff(layout.diff, buf);
}
fn layout(&self, area: Rect) -> DiffLayout {
if self.options.file_tree != FileTreeMode::Auto
|| self.file_tree_visibility == FileTreeVisibility::Hidden
|| area.cols <= tree::MIN_VIEW_COLS
|| self.document.files.is_empty()
{
return DiffLayout {
diff: area,
tree: None,
};
}
let [tree, _, diff] = tui::layout::Layout::new(tui::Direction::Horizontal)
.child(tui::Length::Fixed(self.file_tree.cols(area.cols)))
.child(tui::Length::Fixed(tree::GAP_COLS))
.child(tui::Length::Fill(1))
.areas(area);
DiffLayout {
diff,
tree: Some(tree),
}
}
fn render_file_tree(&mut self, area: Rect, buf: &mut Buffer) {
let active_file = self.visible_file();
self.file_tree
.render(active_file, self.options.diff_palette, area, buf);
}
fn render_diff(&mut self, area: Rect, buf: &mut Buffer) {
let body_cols = ScrollView::body_cols(area);
let preamble_rows = self.preamble.len();
self.preamble = Self::preamble(self.document.commit.as_ref(), body_cols);
if self.preamble.len() != preamble_rows {
self.rebuild_index();
}
let scroll = self.state.scroll;
let sticky = self.sticky_rows(scroll, area.rows, body_cols);
let body_offset = scroll.saturating_add(sticky.len().min(area.rows));
let render_rows = self.render_rows_for(scroll, area.rows);
ScrollView::virtualized(render_rows, body_offset, |row, cols| {
self.render_row(row, cols)
.map(|row| row.line)
.unwrap_or_default()
})
.sticky(sticky)
.scrollbar_view(View::new(scroll, render_rows, area.rows))
.scrollbar(Self::scrollbar_style())
.render(area, buf);
}
pub fn apply(&mut self, action: DiffAction, area: Rect) -> ViewChange {
let before = self.state.clone();
let before_visibility = self.file_tree_visibility;
let before_file_tree = self.file_tree.state().clone();
let layout = self.layout(area);
let diff = layout.diff;
if layout.tree.is_none()
&& matches!(
action,
DiffAction::MoveFileTree(_)
| DiffAction::ShowFileTreeTarget
| DiffAction::ActivateFileTreeTarget
| DiffAction::CollapseFileTreeFolder
| DiffAction::ExpandFileTreeFolder,
)
{
return ViewChange::Unchanged;
}
match action {
DiffAction::Scroll(scroll) => {
let mut viewport = Viewport::from_offset(self.state.scroll);
let previous = self.state.scroll;
viewport.scroll(scroll, self.scroll_rows(diff.rows), diff.rows);
self.state.scroll = viewport.offset;
if self.state.scroll != previous
&& layout.tree.is_some()
&& let Some(file) = self.visible_file()
{
self.state.focus = Some(DiffFocus::File(file));
self.file_tree.select_file(file);
}
}
DiffAction::Resize => {
let mut viewport = Viewport::from_offset(self.state.scroll);
viewport.clamp(self.scroll_rows(diff.rows), diff.rows);
self.state.scroll = viewport.offset;
if layout.tree.is_some() {
self.sync_file_tree();
}
}
DiffAction::FocusNext => {
self.focus(diff.rows, 1, FocusFilter::File);
self.sync_file_tree();
}
DiffAction::FocusPrevious => {
self.focus(diff.rows, -1, FocusFilter::File);
self.sync_file_tree();
}
DiffAction::NextHunk => {
self.focus(diff.rows, 1, FocusFilter::Hunk);
self.sync_file_tree();
}
DiffAction::PreviousHunk => {
self.focus(diff.rows, -1, FocusFilter::Hunk);
self.sync_file_tree();
}
DiffAction::ToggleFocusedFile => {
let had_focus = self.focused_file().is_some();
self.toggle_focused_file();
if had_focus {
self.sync_file_tree();
}
}
DiffAction::CollapseFocusedFile => {
let had_focus = self.focused_file().is_some();
self.collapse_focused_file();
if had_focus {
self.sync_file_tree();
}
}
DiffAction::ToggleFileTree => match self.file_tree_visibility {
FileTreeVisibility::Hidden => {
self.file_tree_visibility = FileTreeVisibility::Auto;
if self.layout(area).tree.is_some() {
self.sync_file_tree();
}
}
FileTreeVisibility::Auto if layout.tree.is_some() => {
self.file_tree_visibility = FileTreeVisibility::Hidden;
}
FileTreeVisibility::Auto => {}
},
DiffAction::MoveFileTree(delta) => {
if self.file_tree.state().selected().is_none() {
self.file_tree.enter(self.visible_file());
}
if let Some(file) = self.file_tree.select(delta) {
self.show_file(file, diff.rows);
}
}
DiffAction::ShowFileTreeTarget => {
if let Some(file) = self.file_tree.selected_file() {
self.show_file(file, diff.rows);
}
}
DiffAction::ActivateFileTreeTarget => {
if let Some(file) = self.file_tree.activate_target() {
self.show_file(file, diff.rows);
}
}
DiffAction::CollapseFileTreeFolder => {
self.file_tree.collapse_folder();
}
DiffAction::ExpandFileTreeFolder => {
self.file_tree.expand_folder();
}
}
if before.invalidates_index(&self.state) {
self.rebuild_index();
self.state.scroll =
View::new(self.state.scroll, self.scroll_rows(diff.rows), diff.rows).offset;
}
if self.state == before
&& self.file_tree_visibility == before_visibility
&& *self.file_tree.state() == before_file_tree
{
ViewChange::Unchanged
} else {
ViewChange::Changed
}
}
pub fn handle_input(&mut self, event: Event<()>, area: Rect) -> Control {
let action = match event {
Event::Key(Key::Char('q')) => return Control::Quit,
Event::Key(Key::Char('`')) => DiffAction::ToggleFileTree,
Event::Resize(_) => DiffAction::Resize,
Event::Mouse(Mouse::Press {
button: MouseButton::WheelDown,
..
}) => DiffAction::Scroll(Scroll::Lines(WHEEL_SCROLL_ROWS)),
Event::Mouse(Mouse::Press {
button: MouseButton::WheelUp,
..
}) => DiffAction::Scroll(Scroll::Lines(-WHEEL_SCROLL_ROWS)),
Event::Mouse(Mouse::Press {
button: MouseButton::Left,
at,
..
}) => {
let Some(tree) = self.layout(area).tree else {
return Control::Continue;
};
let action = match self.file_tree.select_at(tree, at) {
Some(tree::FileTreeClick::Disclosure) => return Control::Redraw,
Some(tree::FileTreeClick::Row) => DiffAction::ShowFileTreeTarget,
None => return Control::Continue,
};
self.apply(action, area);
return Control::Redraw;
}
Event::Key(Key::Esc) => {
if self.apply(DiffAction::CollapseFocusedFile, area) == ViewChange::Changed {
return Control::Redraw;
}
return Control::Quit;
}
Event::Key(Key::Char('j') | Key::Down) => {
DiffAction::Scroll(Scroll::Lines(LINE_SCROLL_ROWS))
}
Event::Key(Key::Char('k') | Key::Up) => {
DiffAction::Scroll(Scroll::Lines(-LINE_SCROLL_ROWS))
}
Event::Key(Key::Char('J')) => DiffAction::MoveFileTree(1),
Event::Key(Key::Char('K')) => DiffAction::MoveFileTree(-1),
Event::Key(Key::Char('H')) => DiffAction::ExpandFileTreeFolder,
Event::Key(Key::Char('L')) => DiffAction::CollapseFileTreeFolder,
Event::Key(Key::Char(' ') | Key::PageDown) => DiffAction::Scroll(Scroll::Pages(1)),
Event::Key(Key::PageUp) => DiffAction::Scroll(Scroll::Pages(-1)),
Event::Key(Key::Ctrl('d')) => {
DiffAction::Scroll(Scroll::Lines((area.rows / 2).max(1) as isize))
}
Event::Key(Key::Ctrl('u')) => {
DiffAction::Scroll(Scroll::Lines(-((area.rows / 2).max(1) as isize)))
}
Event::Key(Key::Char('g') | Key::Home) => DiffAction::Scroll(Scroll::Top),
Event::Key(Key::Char('G') | Key::End) => DiffAction::Scroll(Scroll::Bottom),
Event::Key(Key::Char('n')) => DiffAction::FocusNext,
Event::Key(Key::Char('p')) => DiffAction::FocusPrevious,
Event::Key(Key::Enter) => DiffAction::ToggleFocusedFile,
_ => return Control::Continue,
};
match self.apply(action, area) {
ViewChange::Changed => Control::Redraw,
ViewChange::Unchanged => Control::Continue,
}
}
pub fn highlight_requests(&mut self, area: Rect) -> Vec<HighlightRequest> {
let diff = self.layout(area).diff;
let take = diff.rows.saturating_add(self.options.highlight_lookahead);
let view = View::new(
self.state.scroll,
self.render_rows_for(self.state.scroll, diff.rows),
diff.rows,
);
let start = view
.offset
.saturating_add(self.sticky_row_count(view.offset, diff.rows));
let mut requests = Vec::new();
for row in start..start.saturating_add(take) {
let Some(meta) = self.diff_meta_at(row) else {
continue;
};
let key = self.key_for(&meta);
if self.highlights.contains_key(&key) || self.pending_highlights.contains(&key) {
continue;
}
self.pending_highlights.insert(key.clone());
let source = self.highlight_source_for(&meta);
requests.push(HighlightRequest {
key,
hunk: meta.hunk,
row: meta.row,
path: meta.path,
source,
});
}
requests
}
pub fn cancel_highlights(&mut self, requests: impl IntoIterator<Item = HighlightRequest>) {
for request in requests {
self.pending_highlights.remove(&request.key);
}
}
fn key_for(&self, meta: &DiffLineMeta) -> HighlightKey {
HighlightKey::new(HighlightKeyInput {
file: meta.file,
side: meta.side,
source_line: meta.source_line,
text: &meta.text,
syntax: self.options.syntax.as_deref(),
theme: &self.options.theme,
})
}
fn highlight_source_for(&mut self, meta: &DiffLineMeta) -> HighlightSource {
if meta.kind == DiffLineKind::NoNewline {
return meta.single_row_source();
}
let key = (meta.file, meta.hunk, meta.side);
if let Some(source) = self.hunk_highlight_sources.get(&key) {
return source.clone();
}
let source = self.build_highlight_source(meta);
self.hunk_highlight_sources.insert(key, source.clone());
source
}
fn build_highlight_source(&self, meta: &DiffLineMeta) -> HighlightSource {
let Some(file) = self.document.files.get(*meta.file) else {
return meta.single_row_source();
};
let Some(hunk) = file.hunks.iter().find(|hunk| hunk.id == meta.hunk) else {
return meta.single_row_source();
};
hunk.highlight_source(meta.side)
}
pub fn apply_highlights(&mut self, results: impl IntoIterator<Item = HighlightResult>) -> bool {
let mut changed = false;
for result in results {
self.pending_highlights.remove(&result.key);
if let Entry::Vacant(slot) = self.word_diffs.entry(result.hunk)
&& let Some(hunk) = self
.document
.files
.iter()
.find(|f| f.id == result.key.file)
.and_then(|f| f.hunks.iter().find(|h| h.id == result.hunk))
{
slot.insert(crate::word::compute(hunk));
}
let bg = match result.key.side {
DiffSide::New => self.options.diff_palette.positive_word_bg,
DiffSide::Old => self.options.diff_palette.negative_word_bg,
};
let line = if let Some(ranges) = self
.word_diffs
.get(&result.hunk)
.and_then(|changes| changes.get(&result.row))
{
result.line.overlay_ranges(ranges, Style::default().bg(bg))
} else {
result.line
};
self.highlights.insert(result.key, line);
changed = true;
}
changed
}
pub fn apply_visible_highlights<H>(&mut self, area: Rect, highlighter: &mut H) -> bool
where
H: DiffHighlighter + ?Sized,
{
let requests = self.highlight_requests(area);
if requests.is_empty() {
return false;
}
self.apply_highlights(highlighter.highlight_batch(requests))
}
fn file_rows(&self, file: &FileDiff) -> usize {
file.rendered_rows(self.state.collapsed_files.contains(&file.id))
}
fn render_row(&self, row: usize, cols: usize) -> Option<RenderRow> {
let cols = cols.max(MIN_RENDER_COLS);
if let Some(line) = self.preamble.get(row) {
return Some(RenderRow {
line: line.clone(),
diff: None,
});
}
self.file_row_location(row)
.map(|location| self.render_file_row(location, cols))
}
fn render_file_row(&self, location: FileRowLocation<'_>, cols: usize) -> RenderRow {
let file = location.file;
let border = FILE_BORDER;
let inner_cols = cols.saturating_sub(2);
let child_cols = cols.saturating_sub(4);
let collapsed = self.state.collapsed_files.contains(&file.id);
let local = location.local;
let bottom = location.end - location.start - 1;
let wrap_child = |mut line: Line| {
Line::truncate(&mut line, child_cols, "…");
Line::pad(&mut line, child_cols);
Line::new(border.left(1)).extend(line).item(border.right(1))
};
let hunk_gap_line = Line::blank()
.extend(Line::blank().padded(LINE_NUMBER_WIDTH))
.extend(Line::blank().padded(LINE_NUMBER_WIDTH))
.extend(Self::marker_cell(HUNK_GAP_MARKER_CELL, colors::rgb::DIM));
match local {
FILE_TOP_ROW => {
return RenderRow {
line: border.top(inner_cols),
diff: None,
};
}
FILE_HEADER_ROW => {
return RenderRow {
line: wrap_child(file.header_line(child_cols, self.options.diff_palette)),
diff: None,
};
}
row if row == bottom => {
return RenderRow {
line: border.bottom(inner_cols),
diff: None,
};
}
_ if !file.has_body(collapsed) => {
return RenderRow {
line: border.bottom(inner_cols),
diff: None,
};
}
FILE_DIVIDER_ROW => {
return RenderRow {
line: border.divider(inner_cols, DIVIDER),
diff: None,
};
}
_ => {}
}
let mut body_rows = file.hunk_body_rows(collapsed).peekable();
while let Some(&(hunk, body_start)) = body_rows.peek() {
let body_end = body_start + hunk.lines.len();
if local < body_start {
return RenderRow {
line: wrap_child(hunk_gap_line),
diff: None,
};
}
if local < body_end {
let row = self.hunk_row_at(file, hunk, local - body_start, child_cols);
return RenderRow {
line: wrap_child(row.line),
diff: row.diff,
};
}
body_rows.next();
}
RenderRow {
line: border.bottom(inner_cols),
diff: None,
}
}
fn diff_meta_at(&self, row: usize) -> Option<DiffLineMeta> {
let location = self.file_row_location(row)?;
let collapsed = self.state.collapsed_files.contains(&location.file.id);
for (hunk, body_start) in location.file.hunk_body_rows(collapsed) {
let body_end = body_start + hunk.lines.len();
if location.local < body_start {
return None;
}
if location.local < body_end {
return Some(self.hunk_meta_at(location.file, hunk, location.local - body_start));
}
}
None
}
fn file_row_location(&self, row: usize) -> Option<FileRowLocation<'_>> {
let files = &self.index.files;
let index = files
.partition_point(|indexed| indexed.start <= row)
.checked_sub(1)?;
let indexed = files[index];
let end = files
.get(index + 1)
.map_or(self.index.rows, |next| next.start);
if row >= end {
return None;
}
let file = self.document.files.get(indexed.file_index)?;
Some(FileRowLocation {
file,
start: indexed.start,
end,
local: row - indexed.start,
})
}
fn rebuild_index(&mut self) {
let mut rows = self.preamble.len();
let mut files = Vec::new();
for (file_index, file) in self.document.files.iter().enumerate() {
files.push(IndexedFileRows {
file_index,
start: rows,
});
rows += self.file_rows(file);
}
self.index = RowIndex { files, rows };
}
fn preamble(commit: Option<&Commit>, cols: usize) -> Vec<Line> {
let Some(commit) = commit else {
return Vec::new();
};
let message_lines = commit
.message
.split('\n')
.map(|raw| {
let trimmed = raw.trim_end();
trimmed.strip_prefix(" ").unwrap_or(trimmed)
})
.collect::<Vec<_>>();
let message = {
let first_non_empty = message_lines.iter().position(|text| !text.is_empty());
let last_non_empty = message_lines.iter().rposition(|text| !text.is_empty());
if let (Some(start), Some(end)) = (first_non_empty, last_non_empty) {
message_lines[start..=end]
.iter()
.enumerate()
.map(|(index, &text)| {
let line = if text.is_empty() {
Line::blank()
} else {
Line::new(text.to_owned())
};
if index == 0 {
line.style(Style::default().bold())
} else {
line
}
})
.collect()
} else {
Vec::new()
}
};
let hash_width = commit.hash.as_str().width()
+ commit.decoration.as_deref().map_or(0, |d| 1 + d.width());
let value_width = std::iter::once(hash_width)
.chain(commit.headers.iter().map(|h| h.value.as_str().width()))
.max()
.unwrap_or_default();
let hash_line = Line::new(Label::new(commit.hash.as_str()).fg(colors::rgb::ORANGE));
let hash_value = if let Some(decoration) = commit.decoration.as_deref() {
HStack::default()
.child(hash_line)
.spacer()
.child(Line::new(Label::new(decoration).fg(colors::rgb::DIM)))
.to_line(Constraint::tight(value_width))
} else {
hash_line
};
let mut table = Table::<2, Line>::new(TableOptions {
overflow: true,
spacing: 2,
..TableOptions::default()
});
table.push([
Line::new(Label::new("commit").fg(colors::rgb::DIM)),
hash_value,
]);
for header in &commit.headers {
let key = header.key.to_ascii_lowercase();
let header_value = if header.key.eq_ignore_ascii_case("date") {
Line::new(header.value.as_str()).style(Style::new(colors::rgb::DIM))
} else {
Line::new(header.value.as_str())
};
table.push([
Line::new(Label::new(&key).fg(colors::rgb::DIM)),
header_value,
]);
}
let mut stack = VStack::default()
.border(Some(tui::Border::new(colors::FAINT)))
.padding(1)
.child(table);
if !message.is_empty() {
stack = stack.divider_cell(Cell::new(DIVIDER, Style::new(colors::FAINT)));
for line in message {
stack.push(line);
}
}
stack.lines(Constraint::tight(cols))
}
fn sticky_rows(&self, scroll: usize, visible_rows: usize, cols: usize) -> Vec<Line> {
self.sticky_header_rows(scroll, visible_rows)
.map(|sticky| {
(STICKY_HEADER_ROWS - sticky.rows..STICKY_HEADER_ROWS)
.map(|index| {
if index == STICKY_HEADER_ROWS - 1 {
FILE_BORDER.divider(cols.saturating_sub(2), STICKY_DIVIDER)
} else {
self.render_row(sticky.start + index, cols)
.map(|row| row.line)
.unwrap_or_default()
}
})
.collect()
})
.unwrap_or_default()
}
fn sticky_row_count(&self, scroll: usize, visible_rows: usize) -> usize {
self.sticky_header_rows(scroll, visible_rows)
.map_or(0, |sticky| sticky.rows)
}
#[cfg(test)]
fn sticky_start(&self, scroll: usize, visible_rows: usize) -> Option<usize> {
self.sticky_header_rows(scroll, visible_rows)
.map(|sticky| sticky.start)
}
fn sticky_header_rows(&self, scroll: usize, visible_rows: usize) -> Option<StickyHeaderRows> {
let scroll = scroll.min(
self.render_rows_for(scroll, visible_rows)
.saturating_sub(visible_rows),
);
if scroll == 0 {
return None;
}
let location = self.file_row_location(scroll)?;
if scroll <= location.start {
return None;
}
let file_bottom = location.end.saturating_sub(location.start + 1);
let rows = file_bottom
.saturating_sub(location.local)
.min(STICKY_HEADER_ROWS)
.min(visible_rows);
if rows == 0 {
return None;
}
Some(StickyHeaderRows {
start: location.start,
rows,
})
}
fn focus(&mut self, visible_rows: usize, delta: isize, filter: FocusFilter) {
let targets = self.focus_targets(filter);
if targets.is_empty() {
return;
}
let current = self
.state
.focus
.and_then(|focus| targets.iter().position(|target| target.focus == focus));
let next = match (current, delta.is_negative()) {
(Some(index), true) => index.saturating_sub(1),
(Some(index), false) => index.saturating_add(1).min(targets.len() - 1),
(None, true) => targets.len() - 1,
(None, false) => 0,
};
let Some(target) = targets.get(next) else {
return;
};
self.state.focus = Some(target.focus);
if filter == FocusFilter::File {
self.state.scroll =
View::new(target.row, self.scroll_rows(visible_rows), visible_rows).offset;
return;
}
let mut viewport = Viewport::from_offset(self.state.scroll);
let margin = visible_rows / 4;
viewport.scroll_to_row(
target.row,
self.scroll_rows(visible_rows),
visible_rows,
Placement::Margin {
before: margin.max(self.sticky_row_count(self.state.scroll, visible_rows)),
after: margin,
},
);
self.state.scroll = viewport.offset;
}
fn focus_targets(&self, filter: FocusFilter) -> Vec<FocusTarget> {
let mut targets = Vec::new();
for indexed in &self.index.files {
let Some(file) = self.document.files.get(indexed.file_index) else {
continue;
};
let collapsed = self.state.collapsed_files.contains(&file.id);
if filter == FocusFilter::File {
targets.push(FocusTarget {
focus: DiffFocus::File(file.id),
row: indexed.start,
});
}
if filter == FocusFilter::Hunk {
for (hunk, local) in file.hunk_body_rows(collapsed) {
targets.push(FocusTarget {
focus: DiffFocus::Hunk(hunk.id),
row: indexed.start + local,
});
}
}
}
targets
}
fn toggle_focused_file(&mut self) {
let Some(file) = self.focused_file() else {
return;
};
if !self.state.collapsed_files.remove(&file) {
self.state.collapsed_files.insert(file);
self.state.focus = Some(DiffFocus::File(file));
}
}
fn collapse_focused_file(&mut self) {
let Some(file) = self.focused_file() else {
return;
};
self.state.collapsed_files.insert(file);
self.state.focus = Some(DiffFocus::File(file));
}
fn hunk_row_at(
&self,
file: &FileDiff,
hunk: &crate::Hunk,
line_index: usize,
inner: usize,
) -> RenderRow {
let source_cols = inner.saturating_sub(LINE_NUMBER_WIDTH * 2 + MARKER_WIDTH);
let (old_line, new_line) = Self::hunk_line_numbers(hunk, line_index);
let line = &hunk.lines[line_index];
let meta = DiffLineMeta::new(file, hunk.id, line, old_line, new_line);
self.hunk_row(meta, line, old_line, source_cols)
}
fn hunk_meta_at(&self, file: &FileDiff, hunk: &crate::Hunk, line_index: usize) -> DiffLineMeta {
let (old_line, new_line) = Self::hunk_line_numbers(hunk, line_index);
DiffLineMeta::new(file, hunk.id, &hunk.lines[line_index], old_line, new_line)
}
fn hunk_line_numbers(hunk: &crate::Hunk, line_index: usize) -> (u32, u32) {
let mut old_line = hunk.header.old_line_no;
let mut new_line = hunk.header.new_line_no;
for line in &hunk.lines[..line_index] {
old_line = old_line.saturating_add(line.kind.old_len());
new_line = new_line.saturating_add(line.kind.new_len());
}
(old_line, new_line)
}
fn hunk_row(
&self,
meta: DiffLineMeta,
line: &DiffLine,
old_line: u32,
source_cols: usize,
) -> RenderRow {
let (cells, source, row_style, source_style) = match line.kind {
DiffLineKind::Addition => (
[
Self::blank_number(self.options.diff_palette.positive_row_bg),
Self::number_cell(
meta.source_line,
LINE_NUMBER_FG,
self.options.diff_palette.positive_row_bg,
),
Self::marker_cell(" + ", self.options.diff_palette.positive_fg),
],
self.rendered_source(&meta, source_cols),
Style::default().bg(self.options.diff_palette.positive_row_bg),
Style::default().bg(self.options.diff_palette.positive_row_bg),
),
DiffLineKind::Deletion => (
[
Self::number_cell(
meta.source_line,
LINE_NUMBER_FG,
self.options.diff_palette.negative_row_bg,
),
Self::blank_number(self.options.diff_palette.negative_row_bg),
Self::marker_cell(" - ", self.options.diff_palette.negative_fg),
],
self.rendered_source(&meta, source_cols),
Style::default().bg(self.options.diff_palette.negative_row_bg),
Style::default()
.bg(self.options.diff_palette.negative_row_bg)
.dim(),
),
DiffLineKind::Context => (
[
Self::number_cell(old_line, LINE_NUMBER_FG, Color::Unset),
Self::number_cell(meta.source_line, LINE_NUMBER_FG, Color::Unset),
Self::marker_cell(" ", Color::Unset),
],
self.rendered_source(&meta, source_cols),
Style::default(),
Style::default(),
),
DiffLineKind::NoNewline => (
[
Line::blank().padded(LINE_NUMBER_WIDTH),
Line::blank().padded(LINE_NUMBER_WIDTH),
Self::marker_cell(" ", Color::Unset),
],
Line::new(NO_NEWLINE_MARKER).style(Style::default().fg(colors::rgb::DIM)),
Style::default(),
Style::default(),
),
};
let rendered = self.hunk_line(cells, source, source_cols, row_style, source_style);
RenderRow {
line: rendered,
diff: Some(meta),
}
}
fn hunk_line(
&self,
cells: [Line; 3],
mut source: Line,
source_cols: usize,
row_style: Style,
source_style: Style,
) -> Line {
let inner = source_cols.saturating_add(LINE_NUMBER_WIDTH * 2 + MARKER_WIDTH);
Line::truncate(&mut source, source_cols, "…");
Line::pad(&mut source, source_cols);
let source = source.style(source_style);
let mut line = Line::blank()
.extend(cells[0].clone())
.extend(cells[1].clone())
.extend(cells[2].clone())
.extend(source);
Line::pad(&mut line, inner);
Line::truncate(&mut line, inner, "…");
line.style(row_style)
}
fn rendered_source(&self, meta: &DiffLineMeta, cols: usize) -> Line {
self.highlights
.get(&self.key_for(meta))
.cloned()
.unwrap_or_else(|| Line::new(Text::truncate(meta.text.as_str(), cols, "…")))
}
fn number_cell(value: u32, foreground: Color, background: Color) -> Line {
Line::new(Label::new(&value.to_string()).fg(foreground).bg(background))
.padded(LINE_NUMBER_WIDTH)
}
fn blank_number(background: Color) -> Line {
Line::new(Label::space().bg(background)).padded(LINE_NUMBER_WIDTH)
}
fn marker_cell(marker: &str, foreground: Color) -> Line {
Line::new(Label::new(marker).fg(foreground)).padded(MARKER_WIDTH)
}
fn scrollbar_style() -> ScrollbarStyle {
ScrollbarStyle::new(
Cell::new(SCROLLBAR_TRACK, Style::default().fg(colors::FAINT)),
Cell::new(SCROLLBAR_THUMB, Style::default().fg(SCROLLBAR_THUMB_COLOR)),
)
}
}
impl Widget for DiffViewer {
fn size(&self, parent: Constraint) -> Size {
let cols = if parent.max.cols == usize::MAX {
MIN_RENDER_COLS
} else {
parent.max.cols
};
Size::new(cols, self.index.rows).constrain(parent)
}
fn render(&mut self, area: Rect, buf: &mut Buffer) {
DiffViewer::render(self, area, buf);
}
fn to_buffer(&mut self, constraints: Constraint) -> Buffer {
let size = self.size(constraints);
let area = Rect::from_size(size);
let mut buffer = Buffer::empty(area);
DiffViewer::render(self, area, &mut buffer);
buffer
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
struct FocusTarget {
focus: DiffFocus,
row: usize,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum FocusFilter {
File,
Hunk,
}
impl FileDiff {
fn has_body(&self, collapsed: bool) -> bool {
!collapsed && !self.hunks.is_empty()
}
fn rendered_rows(&self, collapsed: bool) -> usize {
if !self.has_body(collapsed) {
return EMPTY_CARD_ROWS;
}
let hunks = self.hunks.len();
let body: usize = self.hunks.iter().map(|hunk| hunk.lines.len()).sum();
HUNK_BODY_START + body + hunks.saturating_sub(1) + 1
}
fn hunk_body_rows(&self, collapsed: bool) -> impl Iterator<Item = (&Hunk, usize)> + '_ {
let has_body = self.has_body(collapsed);
self.hunks
.iter()
.enumerate()
.scan(HUNK_BODY_START, move |local, (index, hunk)| {
if !has_body {
return None;
}
if index > 0 {
*local += 1;
}
let row = *local;
*local += hunk.lines.len();
Some((hunk, row))
})
}
fn header_line(&self, cols: usize, palette: DiffPalette) -> Line {
let mut left = Line::blank();
left.push(Label::from_char(self.header.kind.marker()).fg(LINE_NUMBER_FG));
left.push(Label::space());
left = left.extend(self.path_line());
if let Some(badge) = self.badge(palette) {
left.push(Label::space());
left.push(badge);
}
let mut header = HStack::default().child(left).spacer();
let stats = self.stats();
if let Some(side) = Self::diffstat_line(stats.additions, stats.deletions, palette) {
header = header.child(side);
}
header.to_line(Constraint::tight(cols))
}
fn path_line(&self) -> Line {
match self.header.kind {
FileKind::Renamed | FileKind::Copied => Line::spaced([
Label::from(Self::display_path(self.header.old_path.as_ref())),
Label::from(RENAME_ARROW),
Label::from(Self::display_path(self.header.new_path.as_ref())),
]),
_ => Line::new(Self::display_path(self.header.display_path())),
}
}
fn diffstat_line(additions: usize, deletions: usize, palette: DiffPalette) -> Option<Line> {
if additions == 0 && deletions == 0 {
return None;
}
let mut line = Line::blank();
if additions > 0 {
line.push(Label::new(&format!("+{additions}")).fg(palette.positive_fg));
}
if deletions > 0 {
if additions > 0 {
line.push(Label::space());
}
line.push(Label::new(&format!("-{deletions}")).fg(palette.negative_fg));
}
Some(line)
}
fn badge(&self, palette: DiffPalette) -> Option<Label> {
match self.header.kind {
FileKind::Added => Some(Self::change_badge(
"created",
palette.positive_fg,
palette.positive_row_bg,
)),
FileKind::Deleted => Some(Self::change_badge(
"deleted",
palette.negative_fg,
palette.negative_row_bg,
)),
FileKind::Renamed => Some(Self::change_badge(
"moved",
FILE_KIND_BADGE_FG,
FILE_KIND_BADGE_BG,
)),
FileKind::Copied => Some(Self::change_badge(
"copied",
FILE_KIND_BADGE_FG,
FILE_KIND_BADGE_BG,
)),
FileKind::ModeChanged => Some(Self::change_badge(
"mode changed",
FILE_KIND_BADGE_FG,
FILE_KIND_BADGE_BG,
)),
FileKind::Binary => Some(Self::change_badge(
"binary",
Color::Yellow,
Color::Fixed(236),
)),
FileKind::Modified => None,
}
}
fn change_badge(text: &str, foreground: Color, background: Color) -> Label {
Label::new(&format!(" {text} "))
.fg(foreground)
.bg(background)
}
fn display_path(path: Option<&PathBuf>) -> String {
path.map_or_else(|| "<unknown>".to_owned(), |path| path.display().to_string())
}
}
impl DiffLineMeta {
fn new(file: &FileDiff, hunk: HunkId, line: &DiffLine, old_line: u32, new_line: u32) -> Self {
let side = match line.kind {
DiffLineKind::Deletion => DiffSide::Old,
_ => DiffSide::New,
};
let source_line = match side {
DiffSide::Old => old_line,
DiffSide::New => new_line,
};
Self {
file: file.id,
hunk,
row: line.id,
kind: line.kind,
side,
source_line,
text: line.text.clone(),
path: file.source_path(side),
}
}
fn single_row_source(&self) -> HighlightSource {
HighlightSource::new(self.text.clone(), self.source_line)
}
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use std::path::PathBuf;
use std::str::FromStr;
use super::*;
use crate::Decode;
use crate::DiffDocument;
use rustik_repo::{Repo, RepoError};
use rustik_tui::{Modifiers, Point};
fn left_click(x: usize, y: usize, modifiers: Modifiers) -> Event<()> {
Event::Mouse(Mouse::Press {
button: MouseButton::Left,
at: Point::new(x, y),
modifiers,
})
}
fn sample_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 main
context
-old
+new
+extra
tail
",
)
.unwrap();
DiffViewer::new(document, DiffOptions::default())
}
#[derive(Default)]
struct RecordingHighlighter {
batches: usize,
}
impl DiffHighlighter for RecordingHighlighter {
fn highlight_batch(&mut self, requests: Vec<HighlightRequest>) -> Vec<HighlightResult> {
self.batches += 1;
requests
.into_iter()
.map(|request| HighlightResult::new(request, Line::new("highlighted")))
.collect()
}
}
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())
}
fn two_hunk_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,2 +1,2 @@ fn first
keep
-old
+new
@@ -10,2 +10,2 @@ fn second
keep
-before
+after
",
)
.unwrap();
DiffViewer::new(document, DiffOptions::default())
}
fn scroll_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,20 +1,20 @@ fn main
line 01
line 02
line 03
line 04
line 05
line 06
line 07
line 08
line 09
line 10
line 11
line 12
line 13
line 14
line 15
line 16
line 17
line 18
line 19
line 20
",
)
.unwrap();
DiffViewer::new(document, DiffOptions::default())
}
fn tree_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 +1 @@
-old
+new
diff --git a/b.rs b/b.rs
index 3333333..4444444 100644
--- a/b.rs
+++ b/b.rs
@@ -1 +1 @@
-before
+after
",
)
.unwrap();
DiffViewer::new(
document,
DiffOptions {
file_tree: FileTreeMode::Auto,
file_tree_root: "rustik".to_owned(),
..DiffOptions::default()
},
)
}
fn nested_tree_viewer() -> DiffViewer {
let document = DiffDocument::decode_str(
"\
diff --git a/src/a.rs b/src/a.rs
index 1111111..2222222 100644
--- a/src/a.rs
+++ b/src/a.rs
@@ -1 +1 @@
-old
+new
diff --git a/src/b.rs b/src/b.rs
index 3333333..4444444 100644
--- a/src/b.rs
+++ b/src/b.rs
@@ -1 +1 @@
-before
+after
diff --git a/README.md b/README.md
index 5555555..6666666 100644
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-old readme
+new readme
",
)
.unwrap();
DiffViewer::new(
document,
DiffOptions {
file_tree: FileTreeMode::Auto,
file_tree_root: "rustik".to_owned(),
..DiffOptions::default()
},
)
}
fn deep_tree_viewer() -> DiffViewer {
let document = DiffDocument::decode_str(
"\
diff --git a/src/app/a.rs b/src/app/a.rs
index 1111111..2222222 100644
--- a/src/app/a.rs
+++ b/src/app/a.rs
@@ -1 +1 @@
-old
+new
diff --git a/src/lib/b.rs b/src/lib/b.rs
index 3333333..4444444 100644
--- a/src/lib/b.rs
+++ b/src/lib/b.rs
@@ -1 +1 @@
-before
+after
diff --git a/README.md b/README.md
index 5555555..6666666 100644
--- a/README.md
+++ b/README.md
@@ -1 +1 @@
-old readme
+new readme
",
)
.unwrap();
DiffViewer::new(
document,
DiffOptions {
file_tree: FileTreeMode::Auto,
file_tree_root: "rustik".to_owned(),
..DiffOptions::default()
},
)
}
#[test]
fn collapsing_focused_file_hides_hunk_rows() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 6);
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(
viewer.apply(DiffAction::ToggleFocusedFile, area),
ViewChange::Changed
);
assert!(viewer.state().collapsed_files.contains(&FileId::new(0)));
}
#[test]
fn hunk_focus_does_not_change_rendered_row_count() {
let viewer = sample_viewer();
let mut focused = sample_viewer();
focused.set_focus(Some(DiffFocus::Hunk(HunkId::new(0))));
assert_eq!(focused.index.rows, viewer.index.rows);
}
#[test]
fn multi_hunk_file_counts_gap_row() {
let viewer = two_hunk_viewer();
assert_eq!(viewer.index.rows, 11);
}
#[test]
fn collapsed_file_clamps_scroll() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 6);
viewer.apply(DiffAction::Scroll(Scroll::Bottom), area);
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(
viewer.apply(DiffAction::ToggleFocusedFile, area),
ViewChange::Changed
);
assert_eq!(viewer.state().scroll, 0);
}
#[test]
fn focus_next_and_previous_visit_files_only() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 6);
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(0))));
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
viewer.apply(DiffAction::FocusPrevious, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(0))));
}
#[test]
fn file_navigation_anchors_file_to_viewport_top() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 6);
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(viewer.state().scroll, 0);
viewer.apply(DiffAction::FocusNext, area);
assert_eq!(viewer.state().scroll, 9);
}
#[test]
fn next_hunk_visits_hunks_only() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 6);
viewer.apply(DiffAction::NextHunk, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::Hunk(HunkId::new(0))));
viewer.apply(DiffAction::NextHunk, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::Hunk(HunkId::new(1))));
}
#[test]
fn scroll_clamps_after_resize() {
let mut viewer = sample_viewer();
let small = Rect::new(0, 0, 64, 3);
let large = Rect::new(0, 0, 64, 30);
viewer.apply(DiffAction::Scroll(Scroll::Bottom), small);
assert!(viewer.state().scroll > 0);
viewer.apply(DiffAction::Resize, large);
assert_eq!(viewer.state().scroll, 0);
}
#[test]
fn sticky_header_renders_when_scrolled_inside_file() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(4)), area);
assert_eq!(viewer.sticky_row_count(viewer.state().scroll, area.rows), 3);
}
#[test]
fn sticky_header_starts_before_header_scrolls_off() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(1)), area);
assert_eq!(
viewer.sticky_start(viewer.state().scroll, area.rows),
Some(0)
);
}
#[test]
fn sticky_header_replaces_scrolled_file_chrome() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(3)), area);
assert_eq!(
viewer.sticky_start(viewer.state().scroll, area.rows),
Some(0)
);
}
#[test]
fn sticky_header_cuts_before_next_file_card() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(8)), area);
assert_eq!(viewer.sticky_start(viewer.state().scroll, area.rows), None);
}
#[test]
fn sticky_header_stays_visible_until_next_file_reaches_body() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(5)), area);
assert_eq!(
viewer.sticky_start(viewer.state().scroll, area.rows),
Some(0)
);
}
#[test]
fn sticky_header_stays_visible_at_file_end_boundary() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Lines(6)), area);
assert_eq!(
viewer.sticky_start(viewer.state().scroll, area.rows),
Some(0)
);
assert_eq!(viewer.sticky_row_count(viewer.state().scroll, area.rows), 2);
}
#[test]
fn sticky_header_stays_visible_at_file_bottom() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.apply(DiffAction::Scroll(Scroll::Bottom), area);
assert_eq!(
viewer.sticky_start(viewer.state().scroll, area.rows),
Some(0)
);
}
#[test]
fn hunk_navigation_scrolls_focus_out_of_viewport_edge() {
let mut viewer = two_file_viewer();
let area = Rect::new(0, 0, 64, 5);
viewer.set_focus(Some(DiffFocus::Hunk(HunkId::new(0))));
viewer.set_scroll(6);
viewer.apply(DiffAction::NextHunk, area);
assert_eq!(viewer.state().focus, Some(DiffFocus::Hunk(HunkId::new(1))));
assert_eq!(viewer.state().scroll, 9);
}
#[test]
fn keyboard_line_scroll_inputs_move_one_row() {
let area = Rect::new(0, 0, 80, 9);
let mut viewer = scroll_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('j')), area),
Control::Redraw
);
assert_eq!(viewer.state().scroll, 1);
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('j')), area),
Control::Redraw
);
assert_eq!(viewer.state().scroll, 2);
assert_eq!(
viewer.handle_input(Event::Key(Key::Down), area),
Control::Redraw
);
assert_eq!(viewer.state().scroll, 3);
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('k')), area),
Control::Redraw
);
assert_eq!(viewer.state().scroll, 2);
assert_eq!(
viewer.handle_input(Event::Key(Key::Up), area),
Control::Redraw
);
assert_eq!(viewer.state().scroll, 1);
}
#[test]
fn boundary_scroll_inputs_do_not_redraw() {
let area = Rect::new(0, 0, 80, 9);
let mut viewer = scroll_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('k')), area),
Control::Continue
);
assert_eq!(viewer.state().scroll, 0);
viewer.apply(DiffAction::Scroll(Scroll::Bottom), area);
let bottom = viewer.state().scroll;
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('j')), area),
Control::Continue
);
assert_eq!(viewer.state().scroll, bottom);
}
#[test]
fn escape_quits_when_no_file_is_focused() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Esc), area),
Control::Quit
);
assert_eq!(viewer.file_tree.target(), None);
}
#[test]
fn plain_h_and_l_are_unmapped() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('h')), area),
Control::Continue
);
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('l')), area),
Control::Continue
);
assert_eq!(viewer.file_tree.target(), None);
}
#[test]
fn shift_j_moves_file_tree_cursor_and_jumps_to_file() {
let area = Rect::new(0, 0, 100, 4);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('J')), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
assert_eq!(viewer.state().scroll, 6);
}
#[test]
fn shift_k_moves_file_tree_cursor_to_folder_first_file() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('K')), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src")))
);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(0))));
assert_eq!(viewer.state().scroll, 0);
}
#[test]
fn j_scrolls_after_file_tree_mouse_selection() {
let area = Rect::new(0, 0, 100, 4);
let mut viewer = tree_viewer();
viewer.handle_input(left_click(2, 3, Modifiers::NONE), area);
assert_eq!(viewer.state().scroll, 6);
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('j')), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
assert_eq!(viewer.state().scroll, 7);
}
#[test]
fn mouse_wheel_scroll_updates_file_tree_cursor() {
let area = Rect::new(0, 0, 100, 4);
let mut viewer = tree_viewer();
let down = Event::Mouse(Mouse::Press {
button: MouseButton::WheelDown,
at: Point::new(50, 1),
modifiers: Modifiers::NONE,
});
viewer.handle_input(down.clone(), area);
viewer.handle_input(down, area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
}
#[test]
fn left_click_on_file_tree_file_keeps_all_files_visible() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
let rows = viewer.index.rows;
assert_eq!(
viewer.handle_input(left_click(2, 3, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(viewer.index.rows, rows);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
}
#[test]
fn file_navigation_updates_file_tree_cursor() {
let area = Rect::new(0, 0, 100, 4);
let mut viewer = tree_viewer();
viewer.handle_input(Event::Key(Key::Char('n')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(0)))
);
}
#[test]
fn backtick_toggles_file_tree_visibility() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
assert!(viewer.layout(area).tree.is_some());
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('`')), area),
Control::Redraw
);
assert!(viewer.layout(area).tree.is_none());
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('`')), area),
Control::Redraw
);
assert!(viewer.layout(area).tree.is_some());
}
#[test]
fn file_tree_resyncs_when_shown_after_hidden_scroll() {
let area = Rect::new(0, 0, 100, 4);
let mut viewer = tree_viewer();
viewer.handle_input(Event::Key(Key::Char('`')), area);
viewer.apply(DiffAction::Scroll(Scroll::Lines(6)), area);
assert_eq!(viewer.file_tree.target(), None);
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('`')), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
}
#[test]
fn escape_keeps_quit_behavior_when_tree_is_hidden() {
let area = Rect::new(0, 0, 80, 9);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Esc), area),
Control::Quit
);
}
#[test]
fn enter_toggles_focused_file_instead_of_file_tree_cursor() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
assert!(!viewer.state().collapsed_files.contains(&FileId::new(1)));
assert_eq!(
viewer.handle_input(Event::Key(Key::Enter), area),
Control::Redraw
);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
assert!(viewer.state().collapsed_files.contains(&FileId::new(1)));
}
#[test]
fn shift_l_and_shift_h_collapse_and_expand_file_tree_folders() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
viewer.handle_input(Event::Key(Key::Char('K')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src")))
);
viewer.handle_input(Event::Key(Key::Char('L')), area);
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(2)))
);
viewer.handle_input(Event::Key(Key::Char('K')), area);
viewer.handle_input(Event::Key(Key::Char('H')), area);
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(0)))
);
}
#[test]
fn arrow_keys_do_not_operate_file_tree_folders() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
viewer.handle_input(Event::Key(Key::Char('K')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src")))
);
assert_eq!(
viewer.handle_input(Event::Key(Key::Left), area),
Control::Continue
);
assert_eq!(
viewer.handle_input(Event::Key(Key::Right), area),
Control::Continue
);
}
#[test]
fn left_click_on_file_tree_file_activates_it() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(left_click(2, 3, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(viewer.index.rows, 12);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
}
#[test]
fn file_tree_selection_can_anchor_final_file() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(Event::Key(Key::Char('J')), area),
Control::Redraw
);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
assert_eq!(viewer.state().scroll, 6);
}
#[test]
fn control_left_click_on_file_tree_file_jumps_to_it() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = tree_viewer();
let rows = viewer.index.rows;
assert_eq!(
viewer.handle_input(left_click(2, 3, Modifiers::CONTROL), area),
Control::Redraw
);
assert_eq!(viewer.index.rows, rows);
assert_eq!(viewer.state().focus, Some(DiffFocus::File(FileId::new(1))));
}
#[test]
fn left_click_outside_visible_file_tree_is_ignored() {
let mut viewer = tree_viewer();
assert_eq!(
viewer.handle_input(left_click(50, 1, Modifiers::NONE), Rect::new(0, 0, 100, 9)),
Control::Continue
);
assert_eq!(
viewer.handle_input(left_click(2, 1, Modifiers::NONE), Rect::new(0, 0, 80, 9)),
Control::Continue
);
assert_eq!(viewer.state().focus, None);
}
#[test]
fn left_click_on_file_tree_folder_selects_without_toggling() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
assert_eq!(
viewer.handle_input(left_click(4, 2, Modifiers::NONE), area),
Control::Redraw
);
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(0)))
);
}
#[test]
fn selected_folder_background_is_dimmer_than_active_file_background() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
let mut buffer = Buffer::empty(area);
viewer.handle_input(left_click(4, 2, Modifiers::NONE), area);
viewer.render(area, &mut buffer);
assert_eq!(
buffer.get(0, 2).map(|cell| cell.style().bg_color()),
Some(Color::Fixed(234))
);
assert_eq!(
buffer.get(0, 3).map(|cell| cell.style().bg_color()),
Some(Color::Fixed(235))
);
}
#[test]
fn left_click_can_select_parent_and_child_folders_after_folder_selection() {
let area = Rect::new(0, 0, 100, 8);
let mut viewer = deep_tree_viewer();
assert_eq!(
viewer.handle_input(left_click(6, 3, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src/app")))
);
assert_eq!(
viewer.handle_input(left_click(4, 2, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src")))
);
assert_eq!(
viewer.handle_input(left_click(6, 5, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::Directory(PathBuf::from("src/lib")))
);
}
#[test]
fn left_click_on_file_tree_disclosure_toggles_folder() {
let area = Rect::new(0, 0, 100, 9);
let mut viewer = nested_tree_viewer();
assert_eq!(
viewer.handle_input(left_click(2, 2, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(viewer.file_tree.target(), None);
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(2)))
);
viewer.handle_input(Event::Key(Key::Char('K')), area);
assert_eq!(
viewer.handle_input(left_click(2, 2, Modifiers::NONE), area),
Control::Redraw
);
viewer.handle_input(Event::Key(Key::Char('J')), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(0)))
);
}
#[test]
fn left_click_on_file_tree_disclosure_keeps_current_selection() {
let area = Rect::new(0, 0, 100, 8);
let mut viewer = nested_tree_viewer();
viewer.handle_input(left_click(4, 4, Modifiers::NONE), area);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
assert_eq!(
viewer.handle_input(left_click(2, 2, Modifiers::NONE), area),
Control::Redraw
);
assert_eq!(
viewer.file_tree.target(),
Some(FileTreeTarget::File(FileId::new(1)))
);
}
#[test]
fn mouse_wheel_inputs_move_three_rows() {
let area = Rect::new(0, 0, 80, 9);
let mut viewer = scroll_viewer();
let down = Event::Mouse(Mouse::Press {
button: MouseButton::WheelDown,
at: Point::new(0, 0),
modifiers: Modifiers::NONE,
});
let up = Event::Mouse(Mouse::Press {
button: MouseButton::WheelUp,
at: Point::new(0, 0),
modifiers: Modifiers::NONE,
});
viewer.handle_input(down.clone(), area);
assert_eq!(viewer.state().scroll, 3);
viewer.handle_input(down, area);
assert_eq!(viewer.state().scroll, 6);
viewer.handle_input(up, area);
assert_eq!(viewer.state().scroll, 3);
}
#[test]
fn control_scrolls_like_vim() {
let area = Rect::new(0, 0, 80, 10);
let mut viewer = scroll_viewer();
viewer.handle_input(Event::Key(Key::Ctrl('d')), area);
assert_eq!(viewer.state().scroll, 5);
viewer.handle_input(Event::Key(Key::Ctrl('u')), area);
assert_eq!(viewer.state().scroll, 0);
}
#[test]
fn space_pages_down_like_less() {
let area = Rect::new(0, 0, 80, 10);
let mut viewer = scroll_viewer();
viewer.handle_input(Event::Key(Key::Char(' ')), area);
assert_eq!(viewer.state().scroll, 10);
}
#[test]
fn visible_highlight_requests_only_visible_uncached_rows() {
let mut viewer = sample_viewer();
viewer.options.highlight_lookahead = 0;
let area = Rect::new(0, 0, 64, 5);
let first = viewer.highlight_requests(area);
let second = viewer.highlight_requests(area);
assert_eq!(first.len(), 2);
assert!(second.is_empty());
assert_eq!(
first[0].source.line(first[0].key.source_line),
Some("context")
);
assert_eq!(first[1].source.line(first[1].key.source_line), Some("old"));
assert_eq!(first[0].key.theme, "auto");
}
#[test]
fn cancelled_highlight_requests_can_be_requested_again() {
let mut viewer = sample_viewer();
viewer.options.highlight_lookahead = 0;
let area = Rect::new(0, 0, 64, 5);
let first = viewer.highlight_requests(area);
assert!(!first.is_empty());
viewer.cancel_highlights(first.clone());
let second = viewer.highlight_requests(area);
assert_eq!(second, first);
}
#[test]
fn highlight_requests_use_hunk_side_sources() {
let mut viewer = two_hunk_viewer();
let request = viewer
.highlight_requests(Rect::new(0, 0, 64, 20))
.into_iter()
.find(|request| request.hunk == HunkId::new(1))
.unwrap();
assert_eq!(request.source.head, 10);
assert_eq!(request.source.text.as_ref(), "keep\nafter");
assert_eq!(request.source.line(10), Some("keep"));
assert_eq!(request.source.line(11), Some("after"));
assert_eq!(request.source.line(12), None);
}
#[test]
fn repo_highlight_results_style_css_custom_properties_from_real_context() {
let document = DiffDocument::decode_str(
"\
diff --git a/assets/css/style.css b/assets/css/style.css
index 1111111..2222222 100644
--- a/assets/css/style.css
+++ b/assets/css/style.css
@@ -12,7 +12,8 @@
--color-foreground: #112;
--color-headers: #222;
--color-background: #d3d1d1;
- --color-background-light: #dedddd;
+ --color-background-light: #dad8d8;
+ --color-background-dark: #cecccc;
--color-dim: #334;
--color-dimmer: #666;
--color-subtle: #888;
",
)
.unwrap();
let mut viewer = DiffViewer::new(document, DiffOptions::default());
let full = DiffDocument::decode_str(
"\
diff --git a/assets/css/style.css b/assets/css/style.css
index 1111111..2222222 100644
--- a/assets/css/style.css
+++ b/assets/css/style.css
@@ -1,19 +1,20 @@
html {
box-sizing: border-box;
}
*, *::before, *::after {
box-sizing: inherit;
}
body {
margin: 0;
}
:root {
color-scheme: light;
--color-foreground: #112;
--color-headers: #222;
--color-background: #d3d1d1;
- --color-background-light: #dedddd;
+ --color-background-light: #dad8d8;
+ --color-background-dark: #cecccc;
--color-dim: #334;
--color-dimmer: #666;
--color-subtle: #888;
}
",
)
.unwrap();
let mut registry = syntax::Registry::default();
registry.add_theme(
syntax::Theme::parse(include_str!("themes/rustik-catppuccin-mocha.json")).unwrap(),
);
registry.add_grammar(syntax::Grammar::from_str(syntax::syntaxes::CSS).unwrap());
let mut highlighter = crate::BuiltinHighlighter::new(registry, "rustik-catppuccin-mocha");
let source = full.files[0].highlight_source(DiffSide::New).unwrap();
let mut requests = viewer.highlight_requests(Rect::new(0, 0, 80, 20));
for request in &mut requests {
if request.key.side == DiffSide::New {
request.source = source.clone();
}
}
let result = highlighter
.highlight_requests(requests)
.into_iter()
.find(|result| {
result.key.text_hash == {
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
let mut hasher = DefaultHasher::new();
" --color-background-light: #dad8d8;".hash(&mut hasher);
hasher.finish()
}
})
.unwrap();
let color = Color::RGB(137, 180, 250);
let variable = result
.line
.labels()
.iter()
.find(|label| label.content().contains("--color-background-light"))
.unwrap();
assert_eq!(variable.paint.style().fg_color(), color);
}
#[test]
fn metadata_lookup_matches_rendered_diff_rows() {
let viewer = sample_viewer();
for row in 0..viewer.index.rows {
assert_eq!(
viewer.diff_meta_at(row),
viewer.render_row(row, 64).and_then(|row| row.diff)
);
}
}
#[test]
fn highlight_results_replace_pending_with_cached_lines() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 5);
let request = viewer.highlight_requests(area).into_iter().next().unwrap();
let fresh = HighlightResult::new(request, Line::new(Label::new("fresh").fg(Color::Red)));
assert!(viewer.apply_highlights([fresh]));
assert_eq!(viewer.highlights.len(), 1);
}
#[test]
fn apply_visible_highlights_runs_one_visible_batch() {
let mut viewer = sample_viewer();
viewer.options.highlight_lookahead = 0;
let area = Rect::new(0, 0, 64, 5);
let mut highlighter = RecordingHighlighter::default();
assert!(viewer.apply_visible_highlights(area, &mut highlighter));
assert_eq!(highlighter.batches, 1);
assert_eq!(viewer.highlights.len(), 2);
assert!(!viewer.apply_visible_highlights(area, &mut highlighter));
assert_eq!(highlighter.batches, 1);
}
#[test]
fn apply_highlights_populates_word_diff_cache() {
let mut viewer = word_diff_viewer();
let area = Rect::new(0, 0, 80, 20);
let request = viewer.highlight_requests(area).into_iter().next().unwrap();
let hunk_id = request.hunk;
let result = HighlightResult::new(request, Line::new(Label::blank()));
viewer.apply_highlights([result]);
let changes = viewer.word_diffs.get(&hunk_id).unwrap();
let added = viewer.document.files[0].hunks[0]
.lines
.iter()
.find(|line| line.kind == DiffLineKind::Addition)
.unwrap()
.id;
assert!(
changes.get(&added).is_some_and(|ranges| !ranges.is_empty()),
"expected new-side row to have changed ranges"
);
}
#[test]
fn apply_highlights_bakes_word_diff_overlay_into_cache() {
let mut viewer = word_diff_viewer();
let area = Rect::new(0, 0, 80, 20);
let request = viewer
.highlight_requests(area)
.into_iter()
.find(|request| request.key.side == DiffSide::New)
.unwrap();
let key = request.key.clone();
let plain_text = viewer
.document
.files
.iter()
.flat_map(|file| file.hunks.iter().flat_map(|hunk| hunk.lines.iter()))
.find(|line| line.id == request.row)
.unwrap()
.text
.clone();
let result = HighlightResult::new(request, Line::new(Label::new(plain_text.as_str())));
assert!(viewer.apply_highlights([result]));
let cached = viewer.highlights.get(&key).unwrap();
let bright = viewer.options.diff_palette.positive_word_bg;
assert!(
cached
.labels()
.iter()
.any(|label| label.paint.style.bg_color() == bright),
"expected the cached line to already include the bright word-diff bg"
);
}
fn word_diff_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 +1 @@
-fn render(view: &View) {
+fn render(view: &mut View, opts: Options) {
",
)
.unwrap();
DiffViewer::new(document, DiffOptions::default())
}
struct FakeRepo {
patch: Vec<u8>,
calls: std::cell::RefCell<Vec<(usize, Vec<PathBuf>)>>,
}
impl FakeRepo {
fn new(patch: &str) -> Self {
Self {
patch: patch.as_bytes().to_vec(),
calls: std::cell::RefCell::new(Vec::new()),
}
}
}
impl Repo for FakeRepo {
fn diff(
&self,
context_lines: usize,
paths: &[&std::path::Path],
) -> Result<Vec<u8>, RepoError> {
let paths = paths.iter().map(|path| path.to_path_buf()).collect();
self.calls.borrow_mut().push((context_lines, paths));
Ok(self.patch.clone())
}
}
#[test]
fn async_context_request_decodes_and_applies_update() {
let mut viewer = sample_viewer();
let area = Rect::new(0, 0, 64, 9);
let repo = FakeRepo::new(
"\
diff --git a/a.rs b/a.rs
index 1111111..2222222 100644
--- a/a.rs
+++ b/a.rs
@@ -1,5 +1,6 @@ fn main
lead
context
-old
+new
+extra
tail
trail
",
);
let request = viewer.context_request(ContextChange::Increase).unwrap();
let paths = request.paths().collect::<Vec<_>>();
let patch = repo.diff(request.context_lines(), &paths).unwrap();
drop(paths);
let update = request.decode(&patch).unwrap().unwrap();
viewer.apply_context_update(update, area);
let calls = repo.calls.borrow();
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].0, 4);
assert_eq!(calls[0].1, vec![PathBuf::from("a.rs")]);
assert_eq!(viewer.document.files[0].hunks[0].header.old_size, 5);
}
#[test]
fn context_request_targets_focused_file() {
let mut viewer = two_file_viewer();
viewer.set_focus(Some(DiffFocus::File(FileId::new(1))));
let repo = FakeRepo::new(
"\
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,3 +1,3 @@ fn b
keep
-before
+after
trail
",
);
let request = viewer.context_request(ContextChange::Increase).unwrap();
let paths = request.paths().collect::<Vec<_>>();
let patch = repo.diff(request.context_lines(), &paths).unwrap();
drop(paths);
let update = request.decode(&patch).unwrap().unwrap();
viewer.apply_context_update(update, Rect::new(0, 0, 64, 20));
let calls = repo.calls.borrow();
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].1, vec![PathBuf::from("b.rs")]);
}
}