Lightweight coding agent that runs in your terminal
Rust
//! Renders unified diffs with line numbers, gutter signs, and optional syntax
//! highlighting.
//!
//! Each `FileChange` variant (Add / Delete / Update) is rendered as a block of
//! diff lines, each prefixed by a right-aligned line number, a gutter sign
//! (`+` / `-` / ` `), and the content text. When a recognized file extension
//! is present, the content text is syntax-highlighted using
//! [`crate::render::highlight`].
//!
//! **Theme-aware styling:** diff backgrounds adapt to the terminal's
//! background lightness via [`DiffTheme`]. Dark terminals get muted tints
//! (`#212922` green, `#3C170F` red); light terminals get GitHub-style pastels
//! with distinct gutter backgrounds for contrast. The renderer uses fixed
//! palettes for truecolor / 256-color / 16-color terminals so add/delete lines
//! remain visually distinct even when quantizing to limited palettes.
//!
//! **Syntax-theme scope backgrounds:** when the active syntax theme defines
//! background colors for `markup.inserted` / `markup.deleted` (or fallback
//! `diff.inserted` / `diff.deleted`) scopes, those colors override the
//! hardcoded palette for rich color levels. ANSI-16 mode always uses
//! foreground-only styling regardless of theme scope backgrounds.
//!
//! **Highlighting strategy for `Update` diffs:** the renderer highlights each
//! hunk as a single concatenated block rather than line-by-line. This
//! preserves syntect's parser state across consecutive lines within a hunk
//! (important for multi-line strings, block comments, etc.). Cross-hunk state
//! is intentionally *not* preserved because hunks are visually separated and
//! re-synchronize at context boundaries anyway.
//!
//! **Wrapping:** long lines are hard-wrapped at the available column width.
//! Syntax-highlighted spans are split at character boundaries with styles
//! preserved across the split so that no color information is lost. Theme foregrounds
//! are resolved against the painted diff fill, without dimming corrected syntax colors.
use diffy::Hunk;
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::style::Color;
use ratatui::style::Modifier;
use ratatui::style::Style;
use ratatui::style::Stylize;
use ratatui::text::Line as RtLine;
use ratatui::text::Span as RtSpan;
use ratatui::widgets::Paragraph;
use std::collections::HashMap;
use std::path::Path;
use std::path::PathBuf;
use codex_utils_absolute_path::AbsolutePathBuf;
use unicode_segmentation::UnicodeSegmentation;
/// Replacement for a tab character in rendered diff content.
const TAB_REPLACEMENT: &str = " ";
/// Display width of a tab character in columns.
const TAB_WIDTH: usize = TAB_REPLACEMENT.len();
// -- Diff background palette --------------------------------------------------
//
// Dark-theme tints are subtle enough to avoid clashing with syntax colors.
// Light-theme values match GitHub's diff colors for familiarity. The gutter
// (line-number column) uses slightly more saturated variants on light
// backgrounds so the numbers remain readable against the pastel line background.
// Truecolor palette.
const DARK_TC_ADD_LINE_BG_RGB: (u8, u8, u8) = (33, 58, 43); // #213A2B
const DARK_TC_DEL_LINE_BG_RGB: (u8, u8, u8) = (74, 34, 29); // #4A221D
const LIGHT_TC_ADD_LINE_BG_RGB: (u8, u8, u8) = (218, 251, 225); // #dafbe1
const LIGHT_TC_DEL_LINE_BG_RGB: (u8, u8, u8) = (255, 235, 233); // #ffebe9
const LIGHT_TC_ADD_NUM_BG_RGB: (u8, u8, u8) = (172, 238, 187); // #aceebb
const LIGHT_TC_DEL_NUM_BG_RGB: (u8, u8, u8) = (255, 206, 203); // #ffcecb
const LIGHT_TC_GUTTER_FG_RGB: (u8, u8, u8) = (31, 35, 40); // #1f2328
// 256-color palette.
const DARK_256_ADD_LINE_BG_IDX: u8 = 22;
const DARK_256_DEL_LINE_BG_IDX: u8 = 52;
const LIGHT_256_ADD_LINE_BG_IDX: u8 = 194;
const LIGHT_256_DEL_LINE_BG_IDX: u8 = 224;
const LIGHT_256_ADD_NUM_BG_IDX: u8 = 157;
const LIGHT_256_DEL_NUM_BG_IDX: u8 = 217;
const LIGHT_256_GUTTER_FG_IDX: u8 = 236;
use crate::color::is_light;
use crate::color::perceptual_distance;
use crate::diff_model::FileChange;
use crate::exec_command::relativize_to_home;
use crate::render::Insets;
use crate::render::highlight::DiffScopeBackground;
use crate::render::highlight::DiffScopeBackgrounds;
use crate::render::highlight::diff_scope_backgrounds;
use crate::render::highlight::exceeds_highlight_limits;
use crate::render::highlight::highlight_code_to_styled_spans;
use crate::render::renderable::ColumnRenderable;
use crate::render::renderable::InsetRenderable;
use crate::render::renderable::Renderable;
use crate::terminal_hyperlinks::HyperlinkLine;
use crate::terminal_hyperlinks::LineWrapPolicy;
use crate::terminal_hyperlinks::LogicalLineSource;
use crate::terminal_hyperlinks::prefix_hyperlink_lines;
use crate::terminal_hyperlinks::visible_lines;
use crate::terminal_palette::StdoutColorLevel;
use crate::terminal_palette::XTERM_COLORS;
use crate::terminal_palette::default_bg;
use crate::terminal_palette::indexed_color;
use crate::terminal_palette::rgb_color;
use crate::terminal_palette::stdout_color_level;
use crate::width::display_width;
use codex_git_utils::get_git_repo_root;
use codex_terminal_detection::TerminalName;
use codex_terminal_detection::terminal_info;
/// Classifies a diff line for gutter sign rendering and style selection.
///
/// `Insert` renders with a `+` sign and green text, `Delete` with `-` and red
/// text (plus dim overlay when syntax-highlighted), and `Context` with a space
/// and default styling.
#[derive(Clone, Copy)]
pub(crate) enum DiffLineType {
Insert,
Delete,
Context,
}
/// Controls which color palette the diff renderer uses for backgrounds and
/// gutter styling.
///
/// Determined once per `render_change` call via [`diff_theme`], which probes
/// the terminal's queried background color. When the background cannot be
/// determined (common in CI or piped output), `Dark` is used as the safe
/// default.
#[derive(Clone, Copy, Debug)]
enum DiffTheme {
Dark,
Light,
}
/// Palette depth the diff renderer will target.
///
/// This is the *renderer's own* notion of color depth, derived from — but not
/// identical to — the raw [`StdoutColorLevel`] reported by `supports-color`.
/// The indirection exists because some terminals (notably Windows Terminal)
/// advertise only ANSI-16 support while actually rendering truecolor sequences
/// correctly; [`diff_color_level_for_terminal`] promotes those cases so the
/// diff output uses the richer palette.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum DiffColorLevel {
TrueColor,
Ansi256,
Ansi16,
}
/// Subset of [`DiffColorLevel`] that supports tinted backgrounds.
///
/// ANSI-16 terminals render backgrounds with bold, saturated palette entries
/// that overpower syntax tokens. This type encodes the invariant "we have
/// enough color depth for pastel tints" so that background-producing helpers
/// (`add_line_bg`, `del_line_bg`, `light_add_num_bg`, `light_del_num_bg`)
/// never need an unreachable ANSI-16 arm.
///
/// Construct via [`RichDiffColorLevel::from_diff_color_level`], which returns
/// `None` for ANSI-16 — callers branch on the `Option` and skip backgrounds
/// entirely when `None`.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum RichDiffColorLevel {
TrueColor,
Ansi256,
}
impl RichDiffColorLevel {
/// Extract a rich level, returning `None` for ANSI-16.
fn from_diff_color_level(level: DiffColorLevel) -> Option<Self> {
match level {
DiffColorLevel::TrueColor => Some(Self::TrueColor),
DiffColorLevel::Ansi256 => Some(Self::Ansi256),
DiffColorLevel::Ansi16 => None,
}
}
}
/// Pre-resolved background colors for insert and delete diff lines.
///
/// Computed once per `render_change` call from the active syntax theme's
/// scope backgrounds (via [`resolve_diff_backgrounds`]) and then threaded
/// through every style helper so individual lines never re-query the theme.
///
/// Both fields are `None` when the color level is ANSI-16 — callers fall
/// back to foreground-only styling in that case.
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
struct ResolvedDiffBackgrounds {
add: Option<Color>,
del: Option<Color>,
}
/// Precomputed render state for diff line styling.
///
/// This bundles the terminal-derived theme and color depth plus theme-resolved
/// diff backgrounds so callers rendering many lines can compute once per render
/// pass and reuse it across all line calls.
#[derive(Clone, Copy, Debug)]
pub(crate) struct DiffRenderStyleContext {
theme: DiffTheme,
color_level: DiffColorLevel,
diff_backgrounds: ResolvedDiffBackgrounds,
}
/// Resolve diff backgrounds for production rendering.
///
/// Queries the active syntax theme for `markup.inserted` / `markup.deleted`
/// (and `diff.*` fallbacks), then delegates to [`resolve_diff_backgrounds_for`].
fn resolve_diff_backgrounds(
theme: DiffTheme,
color_level: DiffColorLevel,
) -> ResolvedDiffBackgrounds {
resolve_diff_backgrounds_for(theme, color_level, diff_scope_backgrounds())
}
/// Snapshot the current terminal environment into a reusable style context.
///
/// Queries `diff_theme`, `diff_color_level`, and the active syntax theme's
/// scope backgrounds once, bundling them into a [`DiffRenderStyleContext`]
/// that callers thread through every line-rendering call in a single pass.
///
/// Call this at the top of each render frame — not per line — so the diff
/// palette stays consistent within a frame even if the user swaps themes
/// mid-render (theme picker live preview).
pub(crate) fn current_diff_render_style_context() -> DiffRenderStyleContext {
let theme = diff_theme();
let color_level = diff_color_level();
let diff_backgrounds = resolve_diff_backgrounds(theme, color_level);
DiffRenderStyleContext {
theme,
color_level,
diff_backgrounds,
}
}
/// Core background-resolution logic, kept pure for testability.
///
/// Starts from the hardcoded fallback palette and then overrides with theme
/// scope backgrounds when both (a) the color level is rich enough and (b) the
/// theme defines a matching scope. This means the fallback palette is always
/// the baseline. An explicit terminal-default marker disables that scope's fill.
fn resolve_diff_backgrounds_for(
theme: DiffTheme,
color_level: DiffColorLevel,
scope_backgrounds: DiffScopeBackgrounds,
) -> ResolvedDiffBackgrounds {
let mut resolved = fallback_diff_backgrounds(theme, color_level);
let Some(level) = RichDiffColorLevel::from_diff_color_level(color_level) else {
return resolved;
};
for (target, background) in [
(&mut resolved.add, scope_backgrounds.inserted),
(&mut resolved.del, scope_backgrounds.deleted),
] {
match background {
Some(DiffScopeBackground::Rgb(rgb)) => {
*target = Some(color_from_rgb_for_level(rgb, level))
}
Some(DiffScopeBackground::TerminalDefault) => *target = None,
None => {}
}
}
resolved
}
/// Hardcoded palette backgrounds, used when the syntax theme provides no
/// diff-specific scope backgrounds. Returns empty backgrounds for ANSI-16.
fn fallback_diff_backgrounds(
theme: DiffTheme,
color_level: DiffColorLevel,
) -> ResolvedDiffBackgrounds {
match RichDiffColorLevel::from_diff_color_level(color_level) {
Some(level) => ResolvedDiffBackgrounds {
add: Some(add_line_bg(theme, level)),
del: Some(del_line_bg(theme, level)),
},
None => ResolvedDiffBackgrounds::default(),
}
}
/// Convert an RGB triple to the appropriate ratatui `Color` for the given
/// rich color level — passthrough for truecolor, quantized for ANSI-256.
fn color_from_rgb_for_level(rgb: (u8, u8, u8), color_level: RichDiffColorLevel) -> Color {
match color_level {
RichDiffColorLevel::TrueColor => rgb_color(rgb),
RichDiffColorLevel::Ansi256 => quantize_rgb_to_ansi256(rgb),
}
}
/// Find the closest ANSI-256 color (indices 16–255) to `target` using
/// perceptual distance.
///
/// Skips the first 16 entries (system colors) because their actual RGB
/// values depend on the user's terminal configuration and are unreliable
/// for distance calculations.
fn quantize_rgb_to_ansi256(target: (u8, u8, u8)) -> Color {
let best_index = XTERM_COLORS
.iter()
.enumerate()
.skip(16)
.min_by(|(_, a), (_, b)| {
perceptual_distance(**a, target).total_cmp(&perceptual_distance(**b, target))
})
.map(|(index, _)| index as u8);
match best_index {
Some(index) => indexed_color(index),
None => indexed_color(DARK_256_ADD_LINE_BG_IDX),
}
}
pub struct DiffSummary {
changes: HashMap<PathBuf, FileChange>,
cwd: AbsolutePathBuf,
}
impl DiffSummary {
pub(crate) fn new(changes: HashMap<PathBuf, FileChange>, cwd: AbsolutePathBuf) -> Self {
Self { changes, cwd }
}
}
impl Renderable for FileChange {
fn render(&self, area: Rect, buf: &mut Buffer) {
let mut lines = vec![];
render_change(self, &mut lines, area.width as usize, /*lang*/ None);
Paragraph::new(visible_lines(lines)).render(area, buf);
}
fn desired_height(&self, width: u16) -> u16 {
let mut lines = vec![];
render_change(self, &mut lines, width as usize, /*lang*/ None);
lines.len() as u16
}
}
impl From<DiffSummary> for Box<dyn Renderable> {
fn from(val: DiffSummary) -> Self {
let mut rows: Vec<Box<dyn Renderable>> = vec![];
let mut changes: Vec<_> = val.changes.into_iter().collect();
changes.sort_by(|left, right| left.0.cmp(&right.0));
for (i, (path, change)) in changes.into_iter().enumerate() {
if i > 0 {
rows.push(Box::new(RtLine::from("")));
}
let (added, removed) = line_counts(&change);
let mut path = RtLine::from(display_path_for(&path, val.cwd.as_path()));
path.push_span(" ");
path.extend(render_line_count_summary(added, removed));
rows.push(Box::new(path));
rows.push(Box::new(RtLine::from("")));
rows.push(Box::new(InsetRenderable::new(
Box::new(change) as Box<dyn Renderable>,
Insets::tlbr(
/*top*/ 0, /*left*/ 2, /*bottom*/ 0, /*right*/ 0,
),
)));
}
Box::new(ColumnRenderable::with(rows))
}
}
pub(crate) fn create_diff_summary(
changes: &HashMap<PathBuf, FileChange>,
cwd: &Path,
wrap_cols: usize,
) -> Vec<RtLine<'static>> {
visible_lines(create_diff_summary_with_links(changes, cwd, wrap_cols))
}
/// Render the same diff while retaining logical code lines across display wrapping and gutters.
pub(crate) fn create_diff_summary_with_links(
changes: &HashMap<PathBuf, FileChange>,
cwd: &Path,
wrap_cols: usize,
) -> Vec<HyperlinkLine> {
let rows = collect_rows(changes);
render_changes_block(rows, wrap_cols, cwd, /*preview_lines*/ None)
}
/// Preserve each file's path and change counts while bounding its preview body.
pub(crate) fn create_diff_preview_with_links(
changes: &HashMap<PathBuf, FileChange>,
cwd: &Path,
wrap_cols: usize,
preview_lines: usize,
) -> Vec<HyperlinkLine> {
render_changes_block(collect_rows(changes), wrap_cols, cwd, Some(preview_lines))
}
// Shared row for per-file presentation
struct Row<'a> {
path: &'a Path,
move_path: Option<&'a Path>,
added: usize,
removed: usize,
change: &'a FileChange,
}
fn collect_rows(changes: &HashMap<PathBuf, FileChange>) -> Vec<Row<'_>> {
let mut rows = Vec::with_capacity(changes.len());
for (path, change) in changes.iter() {
let (added, removed) = line_counts(change);
let move_path = match change {
FileChange::Update {
move_path: Some(new),
..
} => Some(new.as_path()),
_ => None,
};
rows.push(Row {
path: path.as_path(),
move_path,
added,
removed,
change,
});
}
rows.sort_by(|left, right| left.path.cmp(right.path));
rows
}
fn line_counts(change: &FileChange) -> (usize, usize) {
match change {
FileChange::Add { content } => (content.lines().count(), 0),
FileChange::Delete { content } => (0, content.lines().count()),
FileChange::Update { unified_diff, .. } => calculate_add_remove_from_diff(unified_diff),
}
}
fn render_line_count_summary(added: usize, removed: usize) -> Vec<RtSpan<'static>> {
let mut spans = Vec::new();
spans.push("(".into());
spans.push(format!("+{added}").green());
spans.push(" ".into());
spans.push(format!("-{removed}").red());
spans.push(")".into());
spans
}
fn render_changes_block(
rows: Vec<Row<'_>>,
wrap_cols: usize,
cwd: &Path,
preview_lines: Option<usize>,
) -> Vec<HyperlinkLine> {
let mut out: Vec<HyperlinkLine> = Vec::new();
let render_path = |row: &Row<'_>| -> Vec<RtSpan<'static>> {
let mut spans = Vec::new();
spans.push(display_path_for(row.path, cwd).into());
if let Some(move_path) = row.move_path {
spans.push(format!(" → {}", display_path_for(move_path, cwd)).into());
}
spans
};
// Header
let total_added: usize = rows.iter().map(|r| r.added).sum();
let total_removed: usize = rows.iter().map(|r| r.removed).sum();
let file_count = rows.len();
let noun = if file_count == 1 { "file" } else { "files" };
let mut header_spans: Vec<RtSpan<'static>> = vec!["• ".dim()];
if let [row] = &rows[..] {
let verb = match row.change {
FileChange::Add { .. } => "Added",
FileChange::Delete { .. } => "Deleted",
_ => "Edited",
};
header_spans.push(verb.bold());
header_spans.push(" ".into());
header_spans.extend(render_path(row));
header_spans.push(" ".into());
header_spans.extend(render_line_count_summary(row.added, row.removed));
} else {
header_spans.push("Edited".bold());
header_spans.push(format!(" {file_count} {noun} ").into());
header_spans.extend(render_line_count_summary(total_added, total_removed));
}
out.push(RtLine::from(header_spans).into());
for (idx, r) in rows.into_iter().enumerate() {
// Insert a blank separator between file chunks (except before the first)
if idx > 0 {
out.push("".into());
}
// File header line (skip when single-file header already shows the name)
let skip_file_header = file_count == 1;
if !skip_file_header {
let mut header: Vec<RtSpan<'static>> = Vec::new();
header.push(" └ ".dim());
header.extend(render_path(&r));
header.push(" ".into());
header.extend(render_line_count_summary(r.added, r.removed));
out.push(RtLine::from(header).into());
}
// For renames, use the destination extension for highlighting — the
// diff content reflects the new file, not the old one.
let lang_path = r.move_path.unwrap_or(r.path);
let lang = detect_lang_for_path(lang_path);
let mut lines = vec![];
let prefix = " ";
let content_width = wrap_cols.saturating_sub(prefix.len());
render_change_with_preview(
r.change,
&mut lines,
content_width,
lang.as_deref(),
preview_lines,
);
if let Some(limit) = preview_lines {
lines.truncate(limit);
}
out.extend(prefix_hyperlink_lines(lines, prefix.into(), prefix.into()));
}
out
}
/// Detect the programming language for a file path by its extension.
/// Returns the raw extension string for `normalize_lang` / `find_syntax`
/// to resolve downstream.
fn detect_lang_for_path(path: &Path) -> Option<String> {
let ext = path.extension()?.to_str()?;
Some(ext.to_string())
}
fn render_change(
change: &FileChange,
out: &mut Vec<HyperlinkLine>,
width: usize,
lang: Option<&str>,
) {
render_change_with_preview(change, out, width, lang, /*preview_lines*/ None);
}
fn render_change_with_preview(
change: &FileChange,
out: &mut Vec<HyperlinkLine>,
width: usize,
lang: Option<&str>,
preview_lines: Option<usize>,
) {
let style_context = current_diff_render_style_context();
match change {
FileChange::Add { content } => {
// Pre-highlight the entire file content as a whole.
let syntax_lines = lang.and_then(|l| highlight_code_to_styled_spans(content, l));
let line_number_width = line_number_width(content.lines().count());
for (i, raw) in content.lines().enumerate() {
if preview_lines.is_some_and(|limit| out.len() >= limit) {
break;
}
let syn = syntax_lines.as_ref().and_then(|sl| sl.get(i));
if let Some(spans) = syn {
out.extend(render_wrapped_diff_line(
i + 1,
DiffLineType::Insert,
raw,
width,
line_number_width,
Some(spans),
style_context,
));
} else {
out.extend(render_wrapped_diff_line(
i + 1,
DiffLineType::Insert,
raw,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
));
}
}
}
FileChange::Delete { content } => {
let syntax_lines = lang.and_then(|l| highlight_code_to_styled_spans(content, l));
let line_number_width = line_number_width(content.lines().count());
for (i, raw) in content.lines().enumerate() {
if preview_lines.is_some_and(|limit| out.len() >= limit) {
break;
}
let syn = syntax_lines.as_ref().and_then(|sl| sl.get(i));
if let Some(spans) = syn {
out.extend(render_wrapped_diff_line(
i + 1,
DiffLineType::Delete,
raw,
width,
line_number_width,
Some(spans),
style_context,
));
} else {
out.extend(render_wrapped_diff_line(
i + 1,
DiffLineType::Delete,
raw,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
));
}
}
}
FileChange::Update { unified_diff, .. } => {
if let Ok(patch) = diffy::Patch::from_str(unified_diff) {
let mut max_line_number = 0;
let mut total_diff_bytes: usize = 0;
let mut total_diff_lines: usize = 0;
for h in patch.hunks() {
let mut old_ln = h.old_range().start();
let mut new_ln = h.new_range().start();
for l in h.lines() {
let text = match l {
diffy::Line::Insert(t)
| diffy::Line::Delete(t)
| diffy::Line::Context(t) => t,
};
total_diff_bytes += text.len();
total_diff_lines += 1;
match l {
diffy::Line::Insert(_) => {
max_line_number = max_line_number.max(new_ln);
new_ln += 1;
}
diffy::Line::Delete(_) => {
max_line_number = max_line_number.max(old_ln);
old_ln += 1;
}
diffy::Line::Context(_) => {
max_line_number = max_line_number.max(new_ln);
old_ln += 1;
new_ln += 1;
}
}
}
}
// Skip per-line syntax highlighting when the patch is too
// large — avoids thousands of parser initializations that
// would stall rendering on big diffs.
let diff_lang = if exceeds_highlight_limits(total_diff_bytes, total_diff_lines) {
None
} else {
lang
};
let line_number_width = line_number_width(max_line_number);
let mut is_first_hunk = true;
for h in patch.hunks() {
if preview_lines.is_some_and(|limit| out.len() >= limit) {
break;
}
if !is_first_hunk {
let spacer = format!("{:width$} ", "", width = line_number_width.max(1));
let spacer_span = RtSpan::styled(
spacer,
style_gutter_for(
DiffLineType::Context,
style_context.theme,
style_context.color_level,
),
);
out.push(RtLine::from(vec![spacer_span, "⋮".dim()]).into());
}
is_first_hunk = false;
// Highlight each hunk as a single block so syntect parser
// state is preserved across consecutive lines.
let hunk_syntax_lines = diff_lang.and_then(|language| {
let hunk_text: String = h
.lines()
.iter()
.map(|line| match line {
diffy::Line::Insert(text)
| diffy::Line::Delete(text)
| diffy::Line::Context(text) => *text,
})
.collect();
let syntax_lines = highlight_code_to_styled_spans(&hunk_text, language)?;
(syntax_lines.len() == h.lines().len()).then_some(syntax_lines)
});
let mut old_ln = h.old_range().start();
let mut new_ln = h.new_range().start();
for (line_idx, l) in h.lines().iter().enumerate() {
if preview_lines.is_some_and(|limit| out.len() >= limit) {
break;
}
let syntax_spans = hunk_syntax_lines
.as_ref()
.and_then(|syntax_lines| syntax_lines.get(line_idx));
match l {
diffy::Line::Insert(text) => {
let s = text.trim_end_matches('\n');
if let Some(syn) = syntax_spans {
out.extend(render_wrapped_diff_line(
new_ln,
DiffLineType::Insert,
s,
width,
line_number_width,
Some(syn),
style_context,
));
} else {
out.extend(render_wrapped_diff_line(
new_ln,
DiffLineType::Insert,
s,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
));
}
new_ln += 1;
}
diffy::Line::Delete(text) => {
let s = text.trim_end_matches('\n');
if let Some(syn) = syntax_spans {
out.extend(render_wrapped_diff_line(
old_ln,
DiffLineType::Delete,
s,
width,
line_number_width,
Some(syn),
style_context,
));
} else {
out.extend(render_wrapped_diff_line(
old_ln,
DiffLineType::Delete,
s,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
));
}
old_ln += 1;
}
diffy::Line::Context(text) => {
if preview_lines.is_some() {
old_ln += 1;
new_ln += 1;
continue;
}
let s = text.trim_end_matches('\n');
if let Some(syn) = syntax_spans {
out.extend(render_wrapped_diff_line(
new_ln,
DiffLineType::Context,
s,
width,
line_number_width,
Some(syn),
style_context,
));
} else {
out.extend(render_wrapped_diff_line(
new_ln,
DiffLineType::Context,
s,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
));
}
old_ln += 1;
new_ln += 1;
}
}
}
}
}
}
}
}
/// Format a path for display relative to the current working directory when
/// possible, keeping output stable in jj/no-`.git` workspaces (e.g. image
/// tool calls should show `example.png` instead of an absolute path).
pub(crate) fn display_path_for(path: &Path, cwd: &Path) -> String {
if path.is_relative() {
return path.display().to_string();
}
if let Ok(stripped) = path.strip_prefix(cwd) {
return stripped.display().to_string();
}
let path_in_same_repo = match (get_git_repo_root(cwd), get_git_repo_root(path)) {
(Some(cwd_repo), Some(path_repo)) => cwd_repo == path_repo,
_ => false,
};
let chosen = if path_in_same_repo {
pathdiff::diff_paths(path, cwd).unwrap_or_else(|| path.to_path_buf())
} else {
relativize_to_home(path)
.map(|p| PathBuf::from_iter([Path::new("~"), p.as_path()]))
.unwrap_or_else(|| path.to_path_buf())
};
chosen.display().to_string()
}
pub(crate) fn calculate_add_remove_from_diff(diff: &str) -> (usize, usize) {
if let Ok(patch) = diffy::Patch::from_str(diff) {
patch
.hunks()
.iter()
.flat_map(Hunk::lines)
.fold((0, 0), |(a, d), l| match l {
diffy::Line::Insert(_) => (a + 1, d),
diffy::Line::Delete(_) => (a, d + 1),
diffy::Line::Context(_) => (a, d),
})
} else {
// For unparsable diffs, return 0 for both counts.
(0, 0)
}
}
/// Render a single plain-text (non-syntax-highlighted) diff line, wrapped to
/// `width` columns, using a pre-computed [`DiffRenderStyleContext`].
///
/// This is the convenience entry point used by the theme picker preview and
/// any caller that does not have syntax spans. Delegates to the inner
/// rendering core with `syntax_spans = None`.
pub(crate) fn push_wrapped_diff_line_with_style_context(
line_number: usize,
kind: DiffLineType,
text: &str,
width: usize,
line_number_width: usize,
style_context: DiffRenderStyleContext,
) -> Vec<RtLine<'static>> {
visible_lines(render_wrapped_diff_line(
line_number,
kind,
text,
width,
line_number_width,
/*syntax_spans*/ None,
style_context,
))
}
/// Render a syntax-highlighted diff line, wrapped to `width` columns, using
/// a pre-computed [`DiffRenderStyleContext`].
///
/// Like [`push_wrapped_diff_line_with_style_context`] but overlays
/// `syntax_spans` (from [`highlight_code_to_styled_spans`]) onto the diff
/// coloring. Syntax foregrounds stay readable against the painted diff surface;
/// signs and backgrounds distinguish additions and deletions.
pub(crate) fn push_wrapped_diff_line_with_syntax_and_style_context(
line_number: usize,
kind: DiffLineType,
text: &str,
width: usize,
line_number_width: usize,
syntax_spans: &[RtSpan<'static>],
style_context: DiffRenderStyleContext,
) -> Vec<RtLine<'static>> {
visible_lines(render_wrapped_diff_line(
line_number,
kind,
text,
width,
line_number_width,
Some(syntax_spans),
style_context,
))
}
fn render_wrapped_diff_line(
line_number: usize,
kind: DiffLineType,
text: &str,
width: usize,
line_number_width: usize,
syntax_spans: Option<&[RtSpan<'static>]>,
style: DiffRenderStyleContext,
) -> Vec<HyperlinkLine> {
let DiffRenderStyleContext {
theme,
color_level,
diff_backgrounds,
} = style;
let gutter_width = line_number_width.max(/*other*/ 1);
let (sign, sign_style, content_style) = match kind {
DiffLineType::Insert => (
'+',
style_sign_add(theme, color_level, diff_backgrounds),
style_add(theme, color_level, diff_backgrounds),
),
DiffLineType::Delete => (
'-',
style_sign_del(theme, color_level, diff_backgrounds),
style_del(theme, color_level, diff_backgrounds),
),
DiffLineType::Context => (' ', style_context(), style_context()),
};
let line_style = style_line_bg_for(kind, diff_backgrounds);
let styled = match syntax_spans {
Some(spans) => spans
.iter()
.map(|span| {
let style = span
.style
.fg(crate::style::readable_color_on(
span.style.fg.unwrap_or(Color::Reset),
line_style.bg,
))
.remove_modifier(Modifier::DIM);
RtSpan::styled(span.content.clone().into_owned(), style)
})
.collect(),
None => vec![RtSpan::styled(
text.to_string(),
content_style.fg(crate::style::readable_color_on(
content_style.fg.unwrap_or(Color::Reset),
line_style.bg,
)),
)],
};
let source_spans =
std::iter::once(RtSpan::styled(sign.to_string(), sign_style))
.chain(styled.iter().map(|span| {
RtSpan::styled(span.content.replace('\t', TAB_REPLACEMENT), span.style)
}))
.collect::<Vec<_>>();
let mut source = LogicalLineSource::from_line(&RtLine::from(source_spans).style(line_style));
source.wrap_policy = LineWrapPolicy::Hard;
let mut gutter_style = style_gutter_for(kind, theme, color_level);
if line_style.bg.is_none() {
gutter_style.bg = None;
}
let continuation = RtLine::from(RtSpan::styled(
format!("{:gutter_width$} ", ""),
gutter_style,
));
source.continuation_indent = continuation.clone();
let available = width.saturating_sub(gutter_width + 2).max(/*other*/ 1);
let chunks = wrap_styled_spans(&styled, available);
let mut offset = 0;
chunks
.into_iter()
.enumerate()
.map(|(index, chunk)| {
let body_len: usize = chunk.iter().map(|span| span.content.len()).sum();
let prefix = if index == 0 {
RtLine::from(RtSpan::styled(
format!("{line_number:>gutter_width$} "),
gutter_style,
))
} else {
continuation.clone()
};
let mut row_source = source.clone();
row_source.prefix_bytes = prefix.spans.iter().map(|span| span.content.len()).sum();
let mut spans = prefix.spans;
if index == 0 {
spans.push(RtSpan::styled(sign.to_string(), sign_style));
}
spans.extend(chunk);
let end = offset + body_len + usize::from(index == 0);
row_source.range = offset..end;
offset = end;
let mut line = HyperlinkLine::new(RtLine::from(spans).style(line_style));
line.source = Some(row_source);
line
})
.collect()
}
/// Split styled spans into chunks that fit within `max_cols` display columns.
///
/// Returns one `Vec<RtSpan>` per output line. Styles are preserved across
/// split boundaries so that wrapping never loses syntax coloring.
///
/// The algorithm walks graphemes using their Unicode display width (with tabs
/// expanded to [`TAB_WIDTH`] columns). When a character would overflow the
/// current line, the accumulated text is flushed and a new line begins. A
/// single character wider than the remaining space forces a line break *before*
/// the character so that progress is always made (avoiding infinite loops on
/// CJK characters or tabs at the end of a line).
pub(crate) fn wrap_styled_spans(
spans: &[RtSpan<'static>],
max_cols: usize,
) -> Vec<Vec<RtSpan<'static>>> {
let mut result: Vec<Vec<RtSpan<'static>>> = Vec::new();
let mut current_line: Vec<RtSpan<'static>> = Vec::new();
let mut col: usize = 0;
for span in spans {
let style = span.style;
let text = span.content.as_ref();
let mut remaining = text;
while !remaining.is_empty() {
// Accumulate characters until we fill the line.
let mut byte_end = 0;
let mut chars_col = 0;
for grapheme in remaining.graphemes(/*is_extended*/ true) {
// Tabs have no Unicode width; treat them as TAB_WIDTH columns.
let w = if grapheme == "\t" {
TAB_WIDTH
} else {
display_width(grapheme)
};
if col + chars_col + w > max_cols {
// Adding this character would exceed the line width.
// Break here; if this is the first character in `remaining`
// we will flush/start a new line in the `byte_end == 0`
// branch below before consuming it.
break;
}
byte_end += grapheme.len();
chars_col += w;
}
if byte_end == 0 {
// Single character wider than remaining space — force onto a
// new line so we make progress.
if !current_line.is_empty() {
result.push(std::mem::take(&mut current_line));
}
// Take at least one character to avoid an infinite loop.
let Some(grapheme) = remaining.graphemes(/*is_extended*/ true).next() else {
break;
};
let ch_len = grapheme.len();
current_line.push(RtSpan::styled(
remaining[..ch_len].replace('\t', TAB_REPLACEMENT),
style,
));
// Use fallback width 1 (not 0) so this branch always advances
// even if `ch` has unknown/zero display width.
col = if grapheme == "\t" {
TAB_WIDTH
} else {
display_width(grapheme).max(/*other*/ 1)
};
remaining = &remaining[ch_len..];
continue;
}
let (chunk, rest) = remaining.split_at(byte_end);
current_line.push(RtSpan::styled(chunk.replace('\t', TAB_REPLACEMENT), style));
col += chars_col;
remaining = rest;
// If we exactly filled or exceeded the line, start a new one.
// Do not gate on !remaining.is_empty() — the next span in the
// outer loop may still have content that must start on a fresh line.
if col >= max_cols {
result.push(std::mem::take(&mut current_line));
col = 0;
}
}
}
// Push the last line (always at least one, even if empty).
if !current_line.is_empty() || result.is_empty() {
result.push(current_line);
}
result
}
pub(crate) fn line_number_width(max_line_number: usize) -> usize {
if max_line_number == 0 {
1
} else {
max_line_number.to_string().len()
}
}
/// Testable helper: picks `DiffTheme` from an explicit background sample.
fn diff_theme_for_bg(bg: Option<(u8, u8, u8)>) -> DiffTheme {
if let Some(rgb) = bg
&& is_light(rgb)
{
return DiffTheme::Light;
}
DiffTheme::Dark
}
/// Probe the terminal's background and return the appropriate diff palette.
fn diff_theme() -> DiffTheme {
diff_theme_for_bg(default_bg())
}
/// Return the [`DiffColorLevel`] for the current terminal session.
///
/// This is the environment-reading adapter: it samples runtime signals
/// (`supports-color` level, terminal name, `WT_SESSION`, and `FORCE_COLOR`)
/// and forwards them to [`diff_color_level_for_terminal`].
///
/// Keeping env reads in this thin wrapper lets
/// [`diff_color_level_for_terminal`] stay pure and easy to unit test.
fn diff_color_level() -> DiffColorLevel {
diff_color_level_for_terminal(
stdout_color_level(),
terminal_info().name,
std::env::var_os("WT_SESSION").is_some(),
has_force_color_override(),
)
}
/// Returns whether `FORCE_COLOR` is explicitly set.
fn has_force_color_override() -> bool {
std::env::var_os("FORCE_COLOR").is_some()
}
/// Map a raw [`StdoutColorLevel`] to a [`DiffColorLevel`] using
/// Windows Terminal-specific truecolor promotion rules.
///
/// This helper is intentionally pure (no env access) so tests can validate
/// the policy table by passing explicit inputs.
///
/// Windows Terminal fully supports 24-bit color but the `supports-color`
/// crate often reports only ANSI-16 there because no `COLORTERM` variable
/// is set. We detect Windows Terminal two ways — via `terminal_name`
/// (parsed from `WT_SESSION` / `TERM_PROGRAM` by `terminal_info()`) and
/// via the raw `has_wt_session` flag.
///
/// These signals are intentionally not equivalent: `terminal_name` is a
/// derived classification with `TERM_PROGRAM` precedence, so `WT_SESSION`
/// can be present while `terminal_name` is not `WindowsTerminal`.
///
/// When `WT_SESSION` is present, we promote to truecolor unconditionally
/// unless `FORCE_COLOR` is set. This keeps Windows Terminal rendering rich
/// by default while preserving explicit `FORCE_COLOR` user intent.
///
/// Outside `WT_SESSION`, only ANSI-16 is promoted for identified
/// `WindowsTerminal` sessions; `Unknown` stays conservative.
fn diff_color_level_for_terminal(
stdout_level: StdoutColorLevel,
terminal_name: TerminalName,
has_wt_session: bool,
has_force_color_override: bool,
) -> DiffColorLevel {
if has_wt_session && !has_force_color_override {
return DiffColorLevel::TrueColor;
}
let base = match stdout_level {
StdoutColorLevel::TrueColor => DiffColorLevel::TrueColor,
StdoutColorLevel::Ansi256 => DiffColorLevel::Ansi256,
StdoutColorLevel::Ansi16 | StdoutColorLevel::Unknown => DiffColorLevel::Ansi16,
};
// Outside `WT_SESSION`, keep the existing Windows Terminal promotion for
// ANSI-16 sessions that likely support truecolor.
if stdout_level == StdoutColorLevel::Ansi16
&& terminal_name == TerminalName::WindowsTerminal
&& !has_force_color_override
{
DiffColorLevel::TrueColor
} else {
base
}
}
// -- Style helpers ------------------------------------------------------------
//
// Each diff line is composed of three visual regions, styled independently:
//
// ┌──────────┬──────┬──────────────────────────────────────────┐
// │ gutter │ sign │ content │
// │ (line #) │ +/- │ (plain or syntax-highlighted text) │
// └──────────┴──────┴──────────────────────────────────────────┘
//
// A fourth, full-width layer — `line_bg` — is applied via `RtLine::style()`
// so that the background tint extends from the leftmost column to the right
// edge of the terminal, including any padding beyond the content.
//
// On dark terminals, the sign and content share one style (colored fg + tinted
// bg), and the gutter is simply dimmed. On light terminals, sign and content
// are split: the sign gets only a colored foreground (no bg, so the line bg
// shows through), while content relies on the line bg alone; the gutter gets
// an opaque, more-saturated background so line numbers stay readable against
// the pastel line tint.
/// Full-width background applied to the `RtLine` itself (not individual spans).
/// Context lines intentionally leave the background unset so the terminal
/// default shows through.
fn style_line_bg_for(kind: DiffLineType, diff_backgrounds: ResolvedDiffBackgrounds) -> Style {
match kind {
DiffLineType::Insert => diff_backgrounds
.add
.map_or_else(Style::default, |bg| Style::default().bg(bg)),
DiffLineType::Delete => diff_backgrounds
.del
.map_or_else(Style::default, |bg| Style::default().bg(bg)),
DiffLineType::Context => Style::default(),
}
}
fn style_context() -> Style {
Style::default()
}
fn add_line_bg(theme: DiffTheme, color_level: RichDiffColorLevel) -> Color {
match (theme, color_level) {
(DiffTheme::Dark, RichDiffColorLevel::TrueColor) => rgb_color(DARK_TC_ADD_LINE_BG_RGB),
(DiffTheme::Dark, RichDiffColorLevel::Ansi256) => indexed_color(DARK_256_ADD_LINE_BG_IDX),
(DiffTheme::Light, RichDiffColorLevel::TrueColor) => rgb_color(LIGHT_TC_ADD_LINE_BG_RGB),
(DiffTheme::Light, RichDiffColorLevel::Ansi256) => indexed_color(LIGHT_256_ADD_LINE_BG_IDX),
}
}
fn del_line_bg(theme: DiffTheme, color_level: RichDiffColorLevel) -> Color {
match (theme, color_level) {
(DiffTheme::Dark, RichDiffColorLevel::TrueColor) => rgb_color(DARK_TC_DEL_LINE_BG_RGB),
(DiffTheme::Dark, RichDiffColorLevel::Ansi256) => indexed_color(DARK_256_DEL_LINE_BG_IDX),
(DiffTheme::Light, RichDiffColorLevel::TrueColor) => rgb_color(LIGHT_TC_DEL_LINE_BG_RGB),
(DiffTheme::Light, RichDiffColorLevel::Ansi256) => indexed_color(LIGHT_256_DEL_LINE_BG_IDX),
}
}
fn light_gutter_fg(color_level: DiffColorLevel) -> Color {
match color_level {
DiffColorLevel::TrueColor => rgb_color(LIGHT_TC_GUTTER_FG_RGB),
DiffColorLevel::Ansi256 => indexed_color(LIGHT_256_GUTTER_FG_IDX),
DiffColorLevel::Ansi16 => Color::Black,
}
}
fn light_add_num_bg(color_level: RichDiffColorLevel) -> Color {
match color_level {
RichDiffColorLevel::TrueColor => rgb_color(LIGHT_TC_ADD_NUM_BG_RGB),
RichDiffColorLevel::Ansi256 => indexed_color(LIGHT_256_ADD_NUM_BG_IDX),
}
}
fn light_del_num_bg(color_level: RichDiffColorLevel) -> Color {
match color_level {
RichDiffColorLevel::TrueColor => rgb_color(LIGHT_TC_DEL_NUM_BG_RGB),
RichDiffColorLevel::Ansi256 => indexed_color(LIGHT_256_DEL_NUM_BG_IDX),
}
}
/// Line-number gutter style. On light backgrounds the gutter has an opaque
/// tinted background so numbers contrast against the pastel line fill. On
/// dark backgrounds a simple `DIM` modifier is sufficient.
fn style_gutter_for(kind: DiffLineType, theme: DiffTheme, color_level: DiffColorLevel) -> Style {
match (
theme,
kind,
RichDiffColorLevel::from_diff_color_level(color_level),
) {
(DiffTheme::Light, DiffLineType::Insert, None) => {
Style::default().fg(light_gutter_fg(color_level))
}
(DiffTheme::Light, DiffLineType::Delete, None) => {
Style::default().fg(light_gutter_fg(color_level))
}
(DiffTheme::Light, DiffLineType::Insert, Some(level)) => Style::default()
.fg(light_gutter_fg(color_level))
.bg(light_add_num_bg(level)),
(DiffTheme::Light, DiffLineType::Delete, Some(level)) => Style::default()
.fg(light_gutter_fg(color_level))
.bg(light_del_num_bg(level)),
_ => style_gutter_dim(),
}
}
/// Sign character (`+`) for insert lines. On dark terminals it inherits the
/// full content style (green fg + tinted bg). On light terminals it uses only
/// a green foreground and lets the line-level bg show through.
fn style_sign_add(
theme: DiffTheme,
color_level: DiffColorLevel,
diff_backgrounds: ResolvedDiffBackgrounds,
) -> Style {
match theme {
DiffTheme::Light => Style::default().fg(Color::Green),
DiffTheme::Dark => style_add(theme, color_level, diff_backgrounds),
}
}
/// Sign character (`-`) for delete lines. Mirror of [`style_sign_add`].
fn style_sign_del(
theme: DiffTheme,
color_level: DiffColorLevel,
diff_backgrounds: ResolvedDiffBackgrounds,
) -> Style {
match theme {
DiffTheme::Light => Style::default().fg(Color::Red),
DiffTheme::Dark => style_del(theme, color_level, diff_backgrounds),
}
}
/// Content style for insert lines (plain, non-syntax-highlighted text).
///
/// Foreground-only on ANSI-16. On rich levels, uses the pre-resolved
/// background from `diff_backgrounds` — which is the theme scope color when
/// available, or the hardcoded palette otherwise. Dark themes add an
/// explicit green foreground for readability over the tinted background;
/// light themes rely on the default (dark) foreground against the pastel.
///
/// When no background is resolved (e.g. a theme that defines no diff
/// scopes and the fallback palette is somehow empty), the style degrades
/// to foreground-only so the line is still legible.
fn style_add(
theme: DiffTheme,
color_level: DiffColorLevel,
diff_backgrounds: ResolvedDiffBackgrounds,
) -> Style {
match (theme, color_level, diff_backgrounds.add) {
(_, DiffColorLevel::Ansi16, _) => Style::default().fg(Color::Green),
(DiffTheme::Light, DiffColorLevel::TrueColor, Some(bg))
| (DiffTheme::Light, DiffColorLevel::Ansi256, Some(bg)) => Style::default().bg(bg),
(DiffTheme::Dark, DiffColorLevel::TrueColor, Some(bg))
| (DiffTheme::Dark, DiffColorLevel::Ansi256, Some(bg)) => {
Style::default().fg(Color::Green).bg(bg)
}
(DiffTheme::Light, DiffColorLevel::TrueColor, None)
| (DiffTheme::Light, DiffColorLevel::Ansi256, None) => Style::default(),
(DiffTheme::Dark, DiffColorLevel::TrueColor, None)
| (DiffTheme::Dark, DiffColorLevel::Ansi256, None) => Style::default().fg(Color::Green),
}
}
/// Content style for delete lines (plain, non-syntax-highlighted text).
///
/// Mirror of [`style_add`] with red foreground and the delete-side
/// resolved background.
fn style_del(
theme: DiffTheme,
color_level: DiffColorLevel,
diff_backgrounds: ResolvedDiffBackgrounds,
) -> Style {
match (theme, color_level, diff_backgrounds.del) {
(_, DiffColorLevel::Ansi16, _) => Style::default().fg(Color::Red),
(DiffTheme::Light, DiffColorLevel::TrueColor, Some(bg))
| (DiffTheme::Light, DiffColorLevel::Ansi256, Some(bg)) => Style::default().bg(bg),
(DiffTheme::Dark, DiffColorLevel::TrueColor, Some(bg))
| (DiffTheme::Dark, DiffColorLevel::Ansi256, Some(bg)) => {
Style::default().fg(Color::Red).bg(bg)
}
(DiffTheme::Light, DiffColorLevel::TrueColor, None)
| (DiffTheme::Light, DiffColorLevel::Ansi256, None) => Style::default(),
(DiffTheme::Dark, DiffColorLevel::TrueColor, None)
| (DiffTheme::Dark, DiffColorLevel::Ansi256, None) => Style::default().fg(Color::Red),
}
}
fn style_gutter_dim() -> Style {
Style::default().add_modifier(Modifier::DIM)
}
#[cfg(test)]
mod tests {
use super::*;
use insta::assert_debug_snapshot;
use insta::assert_snapshot;
use pretty_assertions::assert_eq;
use ratatui::Terminal;
use ratatui::backend::TestBackend;
use ratatui::text::Text;
use ratatui::widgets::Paragraph;
use ratatui::widgets::Wrap;
use unicode_width::UnicodeWidthChar;
#[test]
fn syntax_colors_follow_the_actual_diff_background() {
use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::widgets::Widget;
let colors = crate::terminal_probe::DefaultColors {
fg: (30, 30, 30),
bg: (255, 255, 255),
};
crate::terminal_palette::with_test_default_colors(colors, || {
let spans = [
RtSpan::from("let value = 1;")
.fg(rgb_color((235, 210, 170)))
.dim(),
RtSpan::from(" plain"),
RtSpan::from(" reset").fg(Color::Reset),
];
let style = DiffRenderStyleContext {
theme: DiffTheme::Light,
color_level: DiffColorLevel::TrueColor,
diff_backgrounds: ResolvedDiffBackgrounds {
add: Some(rgb_color((220, 250, 230))),
del: Some(rgb_color((55, 25, 35))),
},
};
let lines = [DiffLineType::Insert, DiffLineType::Delete]
.into_iter()
.flat_map(|kind| {
render_wrapped_diff_line(
/*line_number*/ 1,
kind,
"let value = 1; plain reset",
/*width*/ 40,
/*line_number_width*/ 1,
Some(&spans),
style,
)
})
.map(|line| line.line)
.collect::<Vec<_>>();
let area = Rect::new(
/*x*/ 0, /*y*/ 0, /*width*/ 40, /*height*/ 2,
);
let mut buffer = Buffer::empty(area);
Paragraph::new(lines).render(area, &mut buffer);
assert!(!buffer[(3, 0)].modifier.contains(Modifier::DIM));
assert!(!buffer[(3, 1)].modifier.contains(Modifier::DIM));
assert_ne!(buffer[(3, 0)].fg, buffer[(3, 1)].fg);
assert_ne!(buffer[(18, 0)].fg, buffer[(18, 1)].fg);
assert_ne!(buffer[(24, 0)].fg, buffer[(24, 1)].fg);
assert_snapshot!(format!("{buffer:?}"));
});
}
#[test]
fn ansi16_add_style_uses_foreground_only() {
let style = style_add(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi16),
);
assert_eq!(style.fg, Some(Color::Green));
assert_eq!(style.bg, None);
}
#[test]
fn ansi16_del_style_uses_foreground_only() {
let style = style_del(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi16),
);
assert_eq!(style.fg, Some(Color::Red));
assert_eq!(style.bg, None);
}
#[test]
fn ansi16_sign_styles_use_foreground_only() {
let add_sign = style_sign_add(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi16),
);
assert_eq!(add_sign.fg, Some(Color::Green));
assert_eq!(add_sign.bg, None);
let del_sign = style_sign_del(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi16),
);
assert_eq!(del_sign.fg, Some(Color::Red));
assert_eq!(del_sign.bg, None);
}
fn diff_summary_for_tests(changes: &HashMap<PathBuf, FileChange>) -> Vec<RtLine<'static>> {
create_diff_summary(changes, &PathBuf::from("/"), /*wrap_cols*/ 80)
}
fn snapshot_lines(name: &str, lines: Vec<RtLine<'static>>, width: u16, height: u16) {
let mut terminal = Terminal::new(TestBackend::new(width, height)).expect("terminal");
terminal
.draw(|f| {
Paragraph::new(Text::from(lines))
.wrap(Wrap { trim: false })
.render(f.area(), f.buffer_mut())
})
.expect("draw");
assert!(
terminal
.backend()
.buffer()
.content()
.iter()
.all(|cell| !cell.symbol().contains('\t')),
"diff buffer should not contain literal tabs"
);
assert_snapshot!(name, terminal.backend());
}
fn display_width(text: &str) -> usize {
text.chars()
.map(|ch| ch.width().unwrap_or(if ch == '\t' { TAB_WIDTH } else { 0 }))
.sum()
}
fn line_display_width(line: &RtLine<'static>) -> usize {
line.spans
.iter()
.map(|span| display_width(span.content.as_ref()))
.sum()
}
fn snapshot_lines_text(name: &str, lines: &[RtLine<'static>]) {
// Convert Lines to plain text rows and trim trailing spaces so it's
// easier to validate indentation visually in snapshots.
let text = lines
.iter()
.map(|l| {
l.spans
.iter()
.map(|s| s.content.as_ref())
.collect::<String>()
})
.map(|s| s.trim_end().to_string())
.collect::<Vec<_>>()
.join("\n");
assert_snapshot!(name, text);
}
fn diff_gallery_changes() -> HashMap<PathBuf, FileChange> {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
let rust_original =
"fn greet(name: &str) {\n println!(\"hello\");\n println!(\"bye\");\n}\n";
let rust_modified = "fn greet(name: &str) {\n println!(\"hello {name}\");\n println!(\"emoji: 🚀✨ and CJK: 你好世界\");\n}\n";
let rust_patch = diffy::create_patch(rust_original, rust_modified).to_string();
changes.insert(
PathBuf::from("src/lib.rs"),
FileChange::Update {
unified_diff: rust_patch,
move_path: None,
},
);
let py_original = "def add(a, b):\n\treturn a + b\n\nprint(add(1, 2))\n";
let py_modified = "def add(a, b):\n\treturn a + b + 42\n\nprint(add(1, 2))\n";
let py_patch = diffy::create_patch(py_original, py_modified).to_string();
changes.insert(
PathBuf::from("scripts/calc.txt"),
FileChange::Update {
unified_diff: py_patch,
move_path: Some(PathBuf::from("scripts/calc.py")),
},
);
changes.insert(
PathBuf::from("assets/banner.txt"),
FileChange::Add {
content: "HEADER\tVALUE\nrocket\t🚀\ncity\t東京\n".to_string(),
},
);
changes.insert(
PathBuf::from("examples/new_sample.rs"),
FileChange::Add {
content: "pub fn greet(name: &str) {\n println!(\"Hello, {name}!\");\n}\n"
.to_string(),
},
);
changes.insert(
PathBuf::from("tmp/obsolete.log"),
FileChange::Delete {
content: "old line 1\nold line 2\nold line 3\n".to_string(),
},
);
changes.insert(
PathBuf::from("legacy/old_script.py"),
FileChange::Delete {
content: "def legacy(x):\n return x + 1\nprint(legacy(3))\n".to_string(),
},
);
changes
}
fn snapshot_diff_gallery(name: &str, width: u16, height: u16) {
let lines = create_diff_summary(
&diff_gallery_changes(),
&PathBuf::from("/"),
usize::from(width),
);
snapshot_lines(name, lines, width, height);
}
#[test]
fn display_path_prefers_cwd_without_git_repo() {
let cwd = if cfg!(windows) {
PathBuf::from(r"C:\workspace\codex")
} else {
PathBuf::from("/workspace/codex")
};
let path = cwd.join("tui").join("example.png");
let rendered = display_path_for(&path, &cwd);
assert_eq!(
rendered,
PathBuf::from("tui")
.join("example.png")
.display()
.to_string()
);
}
#[test]
fn ui_snapshot_wrap_behavior_insert() {
// Narrow width to force wrapping within our diff line rendering
let long_line = "this is a very long line that should wrap across multiple terminal columns and continue";
// Call the wrapping function directly so we can precisely control the width
let lines = push_wrapped_diff_line_with_style_context(
/*line_number*/ 1,
DiffLineType::Insert,
long_line,
/*width*/ 80,
line_number_width(/*max_line_number*/ 1),
current_diff_render_style_context(),
);
// Render into a small terminal to capture the visual layout
snapshot_lines(
"wrap_behavior_insert",
lines,
/*width*/ 90,
/*height*/ 8,
);
}
#[test]
fn ui_snapshot_apply_update_block() {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
let original = "line one\nline two\nline three\n";
let modified = "line one\nline two changed\nline three\n";
let patch = diffy::create_patch(original, modified).to_string();
changes.insert(
PathBuf::from("example.txt"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
let lines = diff_summary_for_tests(&changes);
snapshot_lines(
"apply_update_block",
lines,
/*width*/ 80,
/*height*/ 12,
);
}
#[test]
fn ui_snapshot_apply_update_with_rename_block() {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
let original = "A\nB\nC\n";
let modified = "A\nB changed\nC\n";
let patch = diffy::create_patch(original, modified).to_string();
changes.insert(
PathBuf::from("old_name.rs"),
FileChange::Update {
unified_diff: patch,
move_path: Some(PathBuf::from("new_name.rs")),
},
);
let lines = diff_summary_for_tests(&changes);
snapshot_lines(
"apply_update_with_rename_block",
lines,
/*width*/ 80,
/*height*/ 12,
);
}
#[test]
fn ui_snapshot_apply_multiple_files_block() {
// Two files: one update and one add, to exercise combined header and per-file rows
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
// File a.txt: single-line replacement (one delete, one insert)
let patch_a = diffy::create_patch("one\n", "one changed\n").to_string();
changes.insert(
PathBuf::from("a.txt"),
FileChange::Update {
unified_diff: patch_a,
move_path: None,
},
);
// File b.txt: newly added with one line
changes.insert(
PathBuf::from("b.txt"),
FileChange::Add {
content: "new\n".to_string(),
},
);
let lines = diff_summary_for_tests(&changes);
snapshot_lines(
"apply_multiple_files_block",
lines,
/*width*/ 80,
/*height*/ 14,
);
}
#[test]
fn ui_snapshot_apply_add_block() {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("new_file.txt"),
FileChange::Add {
content: "alpha\nbeta\n".to_string(),
},
);
let lines = diff_summary_for_tests(&changes);
snapshot_lines(
"apply_add_block",
lines,
/*width*/ 80,
/*height*/ 10,
);
let narrow = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 3);
assert_snapshot!(format!("{}\n{}", narrow[1], narrow[2]), @r"
1 +a
l
");
}
#[test]
fn ui_snapshot_apply_delete_block() {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("tmp_delete_example.txt"),
FileChange::Delete {
content: "first\nsecond\nthird\n".to_string(),
},
);
let lines = diff_summary_for_tests(&changes);
snapshot_lines(
"apply_delete_block",
lines,
/*width*/ 80,
/*height*/ 12,
);
}
#[test]
fn ui_snapshot_apply_update_block_wraps_long_lines() {
// Create a patch with a long modified line to force wrapping
let original = "line 1\nshort\nline 3\n";
let modified = "line 1\nshort this_is_a_very_long_modified_line_that_should_wrap_across_multiple_terminal_columns_and_continue_even_further_beyond_eighty_columns_to_force_multiple_wraps\nline 3\n";
let patch = diffy::create_patch(original, modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("long_example.txt"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 72);
// Render with backend width wider than wrap width to avoid Paragraph auto-wrap.
snapshot_lines(
"apply_update_block_wraps_long_lines",
lines,
/*width*/ 80,
/*height*/ 12,
);
}
#[test]
fn ui_snapshot_apply_update_block_wraps_long_lines_text() {
// This mirrors the desired layout example: sign only on first inserted line,
// subsequent wrapped pieces start aligned under the line number gutter.
let original = "1\n2\n3\n4\n";
let modified = "1\nadded long line which wraps and_if_there_is_a_long_token_it_will_be_broken\n3\n4 context line which also wraps across\n";
let patch = diffy::create_patch(original, modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("wrap_demo.txt"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 28);
snapshot_lines_text("apply_update_block_wraps_long_lines_text", &lines);
}
#[test]
fn ui_snapshot_apply_update_block_line_numbers_three_digits_text() {
let original = (1..=110).map(|i| format!("line {i}\n")).collect::<String>();
let modified = (1..=110)
.map(|i| {
if i == 100 {
format!("line {i} changed\n")
} else {
format!("line {i}\n")
}
})
.collect::<String>();
let patch = diffy::create_patch(&original, &modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("hundreds.txt"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
snapshot_lines_text("apply_update_block_line_numbers_three_digits_text", &lines);
}
#[test]
fn ui_snapshot_apply_update_block_relativizes_path() {
let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("/"));
let abs_old = cwd.join("abs_old.rs");
let abs_new = cwd.join("abs_new.rs");
let original = "X\nY\n";
let modified = "X changed\nY\n";
let patch = diffy::create_patch(original, modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
abs_old,
FileChange::Update {
unified_diff: patch,
move_path: Some(abs_new),
},
);
let lines = create_diff_summary(&changes, &cwd, /*wrap_cols*/ 80);
snapshot_lines(
"apply_update_block_relativizes_path",
lines,
/*width*/ 80,
/*height*/ 10,
);
}
#[test]
fn ui_snapshot_syntax_highlighted_insert_wraps() {
// A long Rust line that exceeds 80 cols with syntax highlighting should
// wrap to multiple output lines rather than being clipped.
let long_rust = "fn very_long_function_name(arg_one: String, arg_two: String, arg_three: String, arg_four: String) -> Result<String, Box<dyn std::error::Error>> { Ok(arg_one) }";
let syntax_spans =
highlight_code_to_styled_spans(long_rust, "rust").expect("rust highlighting");
let spans = &syntax_spans[0];
let lines = render_wrapped_diff_line(
/*line_number*/ 1,
DiffLineType::Insert,
long_rust,
/*width*/ 80,
line_number_width(/*max_line_number*/ 1),
Some(spans),
current_diff_render_style_context(),
);
assert!(
lines.len() > 1,
"syntax-highlighted long line should wrap to multiple lines, got {}",
lines.len()
);
for line in &lines {
let source = line.source.as_ref().expect("diff source");
let restored = source.styled_range(source.range.clone());
let visible = RtLine::from(line.line.spans[1..].to_vec()).style(line.line.style);
let area = Rect::new(
/*x*/ 0,
/*y*/ 0,
restored.width() as u16,
/*height*/ 1,
);
let mut restored_buffer = Buffer::empty(area);
let mut visible_buffer = Buffer::empty(area);
Paragraph::new(restored).render(area, &mut restored_buffer);
Paragraph::new(visible).render(area, &mut visible_buffer);
assert_eq!(restored_buffer, visible_buffer);
}
snapshot_lines(
"syntax_highlighted_insert_wraps",
visible_lines(lines),
/*width*/ 90,
/*height*/ 10,
);
}
#[test]
fn ui_snapshot_diff_gallery_80x24() {
snapshot_diff_gallery("diff_gallery_80x24", /*width*/ 80, /*height*/ 24);
}
#[test]
fn ui_snapshot_diff_gallery_94x35() {
snapshot_diff_gallery("diff_gallery_94x35", /*width*/ 94, /*height*/ 35);
}
#[test]
fn ui_snapshot_diff_gallery_120x40() {
snapshot_diff_gallery(
"diff_gallery_120x40",
/*width*/ 120,
/*height*/ 40,
);
}
#[test]
fn ui_snapshot_ansi16_insert_delete_no_background() {
let mut lines = push_wrapped_diff_line_with_style_context(
/*line_number*/ 1,
DiffLineType::Insert,
"added in ansi16 mode",
/*width*/ 80,
line_number_width(/*max_line_number*/ 2),
DiffRenderStyleContext {
theme: DiffTheme::Dark,
color_level: DiffColorLevel::Ansi16,
diff_backgrounds: fallback_diff_backgrounds(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
),
},
);
lines.extend(push_wrapped_diff_line_with_style_context(
/*line_number*/ 2,
DiffLineType::Delete,
"deleted in ansi16 mode",
/*width*/ 80,
line_number_width(/*max_line_number*/ 2),
DiffRenderStyleContext {
theme: DiffTheme::Dark,
color_level: DiffColorLevel::Ansi16,
diff_backgrounds: fallback_diff_backgrounds(
DiffTheme::Dark,
DiffColorLevel::Ansi16,
),
},
));
snapshot_lines(
"ansi16_insert_delete_no_background",
lines,
/*width*/ 40,
/*height*/ 4,
);
}
#[test]
fn truecolor_dark_theme_uses_configured_backgrounds() {
assert_eq!(
style_line_bg_for(
DiffLineType::Insert,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::TrueColor)
),
Style::default().bg(rgb_color(DARK_TC_ADD_LINE_BG_RGB))
);
assert_eq!(
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::TrueColor)
),
Style::default().bg(rgb_color(DARK_TC_DEL_LINE_BG_RGB))
);
assert_eq!(
style_gutter_for(
DiffLineType::Insert,
DiffTheme::Dark,
DiffColorLevel::TrueColor
),
style_gutter_dim()
);
assert_eq!(
style_gutter_for(
DiffLineType::Delete,
DiffTheme::Dark,
DiffColorLevel::TrueColor
),
style_gutter_dim()
);
}
#[test]
fn ansi256_dark_theme_uses_distinct_add_and_delete_backgrounds() {
assert_eq!(
style_line_bg_for(
DiffLineType::Insert,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi256)
),
Style::default().bg(indexed_color(DARK_256_ADD_LINE_BG_IDX))
);
assert_eq!(
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi256)
),
Style::default().bg(indexed_color(DARK_256_DEL_LINE_BG_IDX))
);
assert_ne!(
style_line_bg_for(
DiffLineType::Insert,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi256)
),
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi256)
),
"256-color mode should keep add/delete backgrounds distinct"
);
}
#[test]
fn theme_scope_backgrounds_override_truecolor_fallback_when_available() {
let backgrounds = resolve_diff_backgrounds_for(
DiffTheme::Dark,
DiffColorLevel::TrueColor,
DiffScopeBackgrounds {
inserted: Some(DiffScopeBackground::Rgb((1, 2, 3))),
deleted: Some(DiffScopeBackground::Rgb((4, 5, 6))),
},
);
assert_eq!(
style_line_bg_for(DiffLineType::Insert, backgrounds),
Style::default().bg(rgb_color((1, 2, 3)))
);
assert_eq!(
style_line_bg_for(DiffLineType::Delete, backgrounds),
Style::default().bg(rgb_color((4, 5, 6)))
);
}
#[test]
fn explicit_default_scope_disables_only_its_diff_fill() {
for theme in [DiffTheme::Light, DiffTheme::Dark] {
for color_level in [
DiffColorLevel::TrueColor,
DiffColorLevel::Ansi256,
DiffColorLevel::Ansi16,
] {
let backgrounds = resolve_diff_backgrounds_for(
theme,
color_level,
DiffScopeBackgrounds {
inserted: Some(DiffScopeBackground::TerminalDefault),
deleted: None,
},
);
assert_eq!(
style_line_bg_for(DiffLineType::Insert, backgrounds),
Style::default()
);
assert_eq!(
style_line_bg_for(DiffLineType::Delete, backgrounds),
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(theme, color_level)
)
);
}
}
}
#[test]
fn theme_scope_backgrounds_quantize_to_ansi256() {
let backgrounds = resolve_diff_backgrounds_for(
DiffTheme::Dark,
DiffColorLevel::Ansi256,
DiffScopeBackgrounds {
inserted: Some(DiffScopeBackground::Rgb((0, 95, 0))),
deleted: None,
},
);
assert_eq!(
style_line_bg_for(DiffLineType::Insert, backgrounds),
Style::default().bg(indexed_color(/*index*/ 22))
);
assert_eq!(
style_line_bg_for(DiffLineType::Delete, backgrounds),
Style::default().bg(indexed_color(DARK_256_DEL_LINE_BG_IDX))
);
}
#[test]
fn ui_snapshot_theme_scope_background_resolution() {
let backgrounds = resolve_diff_backgrounds_for(
DiffTheme::Dark,
DiffColorLevel::TrueColor,
DiffScopeBackgrounds {
inserted: Some(DiffScopeBackground::Rgb((12, 34, 56))),
deleted: None,
},
);
let snapshot = format!(
"insert={:?}\ndelete={:?}",
style_line_bg_for(DiffLineType::Insert, backgrounds).bg,
style_line_bg_for(DiffLineType::Delete, backgrounds).bg,
);
assert_snapshot!("theme_scope_background_resolution", snapshot);
}
#[test]
fn ansi16_disables_line_and_gutter_backgrounds() {
assert_eq!(
style_line_bg_for(
DiffLineType::Insert,
fallback_diff_backgrounds(DiffTheme::Dark, DiffColorLevel::Ansi16)
),
Style::default()
);
assert_eq!(
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(DiffTheme::Light, DiffColorLevel::Ansi16)
),
Style::default()
);
assert_eq!(
style_gutter_for(
DiffLineType::Insert,
DiffTheme::Light,
DiffColorLevel::Ansi16
),
Style::default().fg(Color::Black)
);
assert_eq!(
style_gutter_for(
DiffLineType::Delete,
DiffTheme::Light,
DiffColorLevel::Ansi16
),
Style::default().fg(Color::Black)
);
let themed_backgrounds = resolve_diff_backgrounds_for(
DiffTheme::Light,
DiffColorLevel::Ansi16,
DiffScopeBackgrounds {
inserted: Some(DiffScopeBackground::Rgb((8, 9, 10))),
deleted: Some(DiffScopeBackground::Rgb((11, 12, 13))),
},
);
assert_eq!(
style_line_bg_for(DiffLineType::Insert, themed_backgrounds),
Style::default()
);
assert_eq!(
style_line_bg_for(DiffLineType::Delete, themed_backgrounds),
Style::default()
);
}
#[test]
fn light_truecolor_theme_uses_readable_gutter_and_line_backgrounds() {
assert_eq!(
style_line_bg_for(
DiffLineType::Insert,
fallback_diff_backgrounds(DiffTheme::Light, DiffColorLevel::TrueColor)
),
Style::default().bg(rgb_color(LIGHT_TC_ADD_LINE_BG_RGB))
);
assert_eq!(
style_line_bg_for(
DiffLineType::Delete,
fallback_diff_backgrounds(DiffTheme::Light, DiffColorLevel::TrueColor)
),
Style::default().bg(rgb_color(LIGHT_TC_DEL_LINE_BG_RGB))
);
assert_eq!(
style_gutter_for(
DiffLineType::Insert,
DiffTheme::Light,
DiffColorLevel::TrueColor
),
Style::default()
.fg(rgb_color(LIGHT_TC_GUTTER_FG_RGB))
.bg(rgb_color(LIGHT_TC_ADD_NUM_BG_RGB))
);
assert_eq!(
style_gutter_for(
DiffLineType::Delete,
DiffTheme::Light,
DiffColorLevel::TrueColor
),
Style::default()
.fg(rgb_color(LIGHT_TC_GUTTER_FG_RGB))
.bg(rgb_color(LIGHT_TC_DEL_NUM_BG_RGB))
);
}
#[test]
fn light_theme_wrapped_lines_keep_number_gutter_contrast() {
let lines = push_wrapped_diff_line_with_style_context(
/*line_number*/ 12,
DiffLineType::Insert,
"abcdefghij",
/*width*/ 8,
line_number_width(/*max_line_number*/ 12),
DiffRenderStyleContext {
theme: DiffTheme::Light,
color_level: DiffColorLevel::TrueColor,
diff_backgrounds: fallback_diff_backgrounds(
DiffTheme::Light,
DiffColorLevel::TrueColor,
),
},
);
assert!(
lines.len() > 1,
"expected wrapped output for gutter style verification"
);
assert_eq!(
lines[0].spans[0].style,
Style::default()
.fg(rgb_color(LIGHT_TC_GUTTER_FG_RGB))
.bg(rgb_color(LIGHT_TC_ADD_NUM_BG_RGB))
);
assert_eq!(
lines[1].spans[0].style,
Style::default()
.fg(rgb_color(LIGHT_TC_GUTTER_FG_RGB))
.bg(rgb_color(LIGHT_TC_ADD_NUM_BG_RGB))
);
assert_eq!(lines[0].style.bg, Some(rgb_color(LIGHT_TC_ADD_LINE_BG_RGB)));
assert_eq!(lines[1].style.bg, Some(rgb_color(LIGHT_TC_ADD_LINE_BG_RGB)));
}
#[test]
fn windows_terminal_promotes_ansi16_to_truecolor_for_diffs() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Ansi16,
TerminalName::WindowsTerminal,
/*has_wt_session*/ false,
/*has_force_color_override*/ false,
),
DiffColorLevel::TrueColor
);
}
#[test]
fn wt_session_promotes_ansi16_to_truecolor_for_diffs() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Ansi16,
TerminalName::Unknown,
/*has_wt_session*/ true,
/*has_force_color_override*/ false,
),
DiffColorLevel::TrueColor
);
}
#[test]
fn non_windows_terminal_keeps_ansi16_diff_palette() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Ansi16,
TerminalName::WezTerm,
/*has_wt_session*/ false,
/*has_force_color_override*/ false,
),
DiffColorLevel::Ansi16
);
}
#[test]
fn wt_session_promotes_unknown_color_level_to_truecolor() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Unknown,
TerminalName::WindowsTerminal,
/*has_wt_session*/ true,
/*has_force_color_override*/ false,
),
DiffColorLevel::TrueColor
);
}
#[test]
fn non_wt_windows_terminal_keeps_unknown_color_level_conservative() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Unknown,
TerminalName::WindowsTerminal,
/*has_wt_session*/ false,
/*has_force_color_override*/ false,
),
DiffColorLevel::Ansi16
);
}
#[test]
fn explicit_force_override_keeps_ansi16_on_windows_terminal() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Ansi16,
TerminalName::WindowsTerminal,
/*has_wt_session*/ false,
/*has_force_color_override*/ true,
),
DiffColorLevel::Ansi16
);
}
#[test]
fn explicit_force_override_keeps_ansi256_on_windows_terminal() {
assert_eq!(
diff_color_level_for_terminal(
StdoutColorLevel::Ansi256,
TerminalName::WindowsTerminal,
/*has_wt_session*/ true,
/*has_force_color_override*/ true,
),
DiffColorLevel::Ansi256
);
}
#[test]
fn add_diff_uses_path_extension_for_highlighting() {
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (220, 220, 220),
bg: (20, 20, 20),
},
|| {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("highlight_add.rs"),
FileChange::Add {
content: "pub fn sum(a: i32, b: i32) -> i32 { a + b }\n".to_string(),
},
);
let lines =
create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
let has_rgb = lines.iter().any(|line| {
line.spans
.iter()
.any(|s| matches!(s.style.fg, Some(ratatui::style::Color::Rgb(..))))
});
assert!(
has_rgb,
"add diff for .rs file should produce syntax-highlighted (RGB) spans"
);
},
);
}
#[test]
fn cpp_module_extensions_use_cpp_highlighting() {
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (220, 220, 220),
bg: (20, 20, 20),
},
|| {
let highlighted_tokens = [
"cpp",
// CUDA source and header extensions use C++ highlighting as a fallback.
"cu", "cuh", "cppm", "CPPM", "cxxm", "CxXm", "ixx", "IXX",
]
.into_iter()
.map(|extension| {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from(format!("math.{extension}")),
FileChange::Add {
content:
"export module math;\nexport int sum(int a, int b) { return a + b; }\n"
.to_string(),
},
);
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
let rgb_tokens = lines
.iter()
.flat_map(|line| &line.spans)
.filter(|span| matches!(span.style.fg, Some(ratatui::style::Color::Rgb(..))))
.map(|span| span.content.to_string())
.collect::<Vec<_>>();
assert!(
!rgb_tokens.is_empty(),
"add diff for .{extension} file should produce syntax-highlighted (RGB) spans"
);
(extension, rgb_tokens.join("|"))
})
.collect::<Vec<_>>();
assert_debug_snapshot!("cpp_module_extension_highlighting", highlighted_tokens);
},
);
}
#[test]
fn unknown_extension_falls_back_without_syntax_highlighting() {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("math.unknown-extension"),
FileChange::Add {
content: "export module math;\nexport int value = 42;\n".to_string(),
},
);
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
assert!(lines.iter().all(|line| {
line.spans
.iter()
.all(|span| !matches!(span.style.fg, Some(ratatui::style::Color::Rgb(..))))
}));
}
#[test]
fn delete_diff_uses_path_extension_for_highlighting() {
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (220, 220, 220),
bg: (20, 20, 20),
},
|| {
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("highlight_delete.py"),
FileChange::Delete {
content: "def scale(x):\n return x * 2\n".to_string(),
},
);
let lines =
create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
let has_rgb = lines.iter().any(|line| {
line.spans
.iter()
.any(|s| matches!(s.style.fg, Some(ratatui::style::Color::Rgb(..))))
});
assert!(
has_rgb,
"delete diff for .py file should produce syntax-highlighted (RGB) spans"
);
},
);
}
#[test]
fn detect_lang_for_common_paths() {
// Standard extensions are detected.
assert!(detect_lang_for_path(Path::new("foo.rs")).is_some());
assert!(detect_lang_for_path(Path::new("bar.py")).is_some());
assert!(detect_lang_for_path(Path::new("app.tsx")).is_some());
// Extensionless files return None.
assert!(detect_lang_for_path(Path::new("Makefile")).is_none());
assert!(detect_lang_for_path(Path::new("randomfile")).is_none());
}
#[test]
fn wrap_styled_spans_single_line() {
// Content that fits in one line should produce exactly one chunk.
let spans = vec![RtSpan::raw("short")];
let result = wrap_styled_spans(&spans, /*max_cols*/ 80);
assert_eq!(result.len(), 1);
}
#[test]
fn wrap_styled_spans_splits_long_content() {
// Content wider than max_cols should produce multiple chunks.
let long_text = "a".repeat(100);
let spans = vec![RtSpan::raw(long_text)];
let result = wrap_styled_spans(&spans, /*max_cols*/ 40);
assert!(
result.len() >= 3,
"100 chars at 40 cols should produce at least 3 lines, got {}",
result.len()
);
}
#[test]
fn wrap_styled_spans_flushes_at_span_boundary() {
// When span A fills exactly to max_cols and span B follows, the line
// must be flushed before B starts. Otherwise B's first character lands
// on an already-full line, producing over-width output.
let style_a = Style::default().fg(Color::Red);
let style_b = Style::default().fg(Color::Blue);
let spans = vec![
RtSpan::styled("aaaa", style_a), // 4 cols, fills line exactly at max_cols=4
RtSpan::styled("bb", style_b), // should start on a new line
];
let result = wrap_styled_spans(&spans, /*max_cols*/ 4);
assert_eq!(
result.len(),
2,
"span ending exactly at max_cols should flush before next span: {result:?}"
);
// First line should only contain the 'a' span.
let first_width: usize = result[0].iter().map(|s| s.content.chars().count()).sum();
assert!(
first_width <= 4,
"first line should be at most 4 cols wide, got {first_width}"
);
}
#[test]
fn wrap_styled_spans_preserves_styles() {
// Verify that styles survive split boundaries.
let style = Style::default().fg(Color::Green);
let text = "x".repeat(50);
let spans = vec![RtSpan::styled(text, style)];
let result = wrap_styled_spans(&spans, /*max_cols*/ 20);
for chunk in &result {
for span in chunk {
assert_eq!(span.style, style, "style should be preserved across wraps");
}
}
}
#[test]
fn wrap_styled_spans_tabs_have_visible_width() {
// A tab should count as TAB_WIDTH columns, not zero.
// With max_cols=8, a tab (4 cols) + "abcde" (5 cols) = 9 cols → must wrap.
let style = Style::default().fg(Color::Green);
let spans = vec![RtSpan::styled("\tabcde", style)];
let result = wrap_styled_spans(&spans, /*max_cols*/ 8);
assert_eq!(
result,
vec![
vec![RtSpan::styled(" abcd", style)],
vec![RtSpan::styled("e", style)],
]
);
}
#[test]
fn wrap_styled_spans_wraps_before_first_overflowing_char() {
let spans = vec![RtSpan::raw("abcd\t界")];
let result = wrap_styled_spans(&spans, /*max_cols*/ 5);
let line_text: Vec<String> = result
.iter()
.map(|line| {
line.iter()
.map(|span| span.content.as_ref())
.collect::<String>()
})
.collect();
assert_eq!(line_text, vec!["abcd", " ", "界"]);
let line_width = |line: &[RtSpan<'static>]| -> usize {
line.iter()
.flat_map(|span| span.content.chars())
.map(|ch| ch.width().unwrap_or(if ch == '\t' { TAB_WIDTH } else { 0 }))
.sum()
};
for line in &result {
assert!(
line_width(line) <= 5,
"wrapped line exceeded width 5: {line:?}"
);
}
}
#[test]
fn fallback_wrapping_uses_display_width_for_tabs_and_wide_chars() {
let width = 8;
let lines = push_wrapped_diff_line_with_style_context(
/*line_number*/ 1,
DiffLineType::Insert,
"abcd\t界🙂",
width,
line_number_width(/*max_line_number*/ 1),
current_diff_render_style_context(),
);
assert!(lines.len() >= 2, "expected wrapped output, got {lines:?}");
for line in &lines {
assert!(
line_display_width(line) <= width,
"fallback wrapped line exceeded width {width}: {line:?}"
);
}
}
#[test]
fn large_update_diff_skips_highlighting() {
// Build a patch large enough to exceed MAX_HIGHLIGHT_LINES (10_000).
// Without the pre-check this would attempt 10k+ parser initializations.
let line_count = 10_001;
let patch = format!(
"--- a/huge.rs\n+++ b/huge.rs\n@@ -0,0 +1,{line_count} @@\n{}",
"+let value = 1;\n".repeat(line_count)
);
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("huge.rs"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
// Should complete quickly (no per-line parser init). If guardrails
// are bypassed this would be extremely slow.
let lines = create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
// The diff rendered without timing out — the guardrails prevented
// thousands of per-line parser initializations. Verify we actually
// got output (the patch is non-empty).
assert!(
lines.len() > 100,
"expected many output lines from large diff, got {}",
lines.len(),
);
// No span should contain an RGB foreground color (syntax themes
// produce RGB; plain diff styles only use named Color variants).
for line in &lines {
for span in &line.spans {
if let Some(ratatui::style::Color::Rgb(..)) = span.style.fg {
panic!(
"large diff should not have syntax-highlighted spans, \
got RGB color in style {:?} for {:?}",
span.style, span.content,
);
}
}
}
}
#[test]
fn rename_diff_uses_destination_extension_for_highlighting() {
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (220, 220, 220),
bg: (20, 20, 20),
},
|| {
// A rename from an unknown extension to .rs should highlight as Rust.
// Without the fix, detect_lang_for_path uses the source path (.xyzzy),
// which has no syntax definition, so highlighting is skipped.
let original = "fn main() {}\n";
let modified = "fn main() { println!(\"hi\"); }\n";
let patch = diffy::create_patch(original, modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("foo.xyzzy"),
FileChange::Update {
unified_diff: patch,
move_path: Some(PathBuf::from("foo.rs")),
},
);
let lines =
create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 80);
let has_rgb = lines.iter().any(|line| {
line.spans
.iter()
.any(|s| matches!(s.style.fg, Some(ratatui::style::Color::Rgb(..))))
});
assert!(
has_rgb,
"rename from .xyzzy to .rs should produce syntax-highlighted (RGB) spans"
);
},
);
}
#[test]
fn update_diff_preserves_multiline_highlight_state_within_hunk() {
crate::terminal_palette::with_test_default_colors(
crate::terminal_probe::DefaultColors {
fg: (220, 220, 220),
bg: (20, 20, 20),
},
|| {
let original = "fn demo() {\n let s = \"hello\";\n}\n";
let modified = "fn demo() {\n let s = \"hello\nworld\";\n}\n";
let patch = diffy::create_patch(original, modified).to_string();
let mut changes: HashMap<PathBuf, FileChange> = HashMap::new();
changes.insert(
PathBuf::from("demo.rs"),
FileChange::Update {
unified_diff: patch,
move_path: None,
},
);
let expected_multiline =
highlight_code_to_styled_spans(" let s = \"hello\nworld\";\n", "rust")
.expect("rust highlighting");
let expected_style = expected_multiline
.get(/*index*/ 1)
.and_then(|line| {
line.iter()
.find(|span| span.content.as_ref().contains("world"))
})
.map(|span| span.style)
.expect("expected highlighted span for second multiline string line");
let lines =
create_diff_summary(&changes, &PathBuf::from("/"), /*wrap_cols*/ 120);
let actual_style = lines
.iter()
.flat_map(|line| line.spans.iter())
.find(|span| span.content.as_ref().contains("world"))
.map(|span| span.style)
.expect("expected rendered diff span containing 'world'");
assert!(matches!(expected_style.fg, Some(Color::Rgb(..))));
assert_eq!(actual_style, expected_style.remove_modifier(Modifier::DIM));
},
);
}
}