use std::collections::{BTreeMap, hash_map::DefaultHasher};
use std::hash::{Hash, Hasher};
use std::path::PathBuf;
use std::sync::Arc;
use rustik_highlight as syntax;
use rustik_tui as tui;
use rustik_tui::{Color, Label, Line, Style};
use crate::{DiffLine, FileDiff, FileId, Hunk, HunkId, RowId};
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum DiffSide {
Old,
New,
}
#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct HighlightKey {
pub file: FileId,
pub side: DiffSide,
pub source_line: u32,
pub text_hash: u64,
pub syntax: String,
pub theme: String,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct HighlightRequest {
pub key: HighlightKey,
pub hunk: HunkId,
pub row: RowId,
pub path: Option<PathBuf>,
pub source: HighlightSource,
}
#[derive(Clone, Debug)]
pub struct HighlightResult {
pub key: HighlightKey,
pub hunk: HunkId,
pub row: RowId,
pub line: tui::Line,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct HighlightSource {
pub text: Arc<str>,
pub head: u32,
}
#[derive(Debug)]
pub struct BuiltinHighlighter {
registry: syntax::Registry,
default_theme: String,
blob_caches: BTreeMap<BlobCacheKey, BlobCacheEntry>,
}
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct BlobCacheKey {
grammar: String,
text_ptr: usize,
text_len: usize,
}
#[derive(Debug)]
struct BlobCacheEntry {
_source: Arc<str>,
cache: syntax::BlobCache,
}
pub trait DiffHighlighter {
fn highlight_batch(&mut self, requests: Vec<HighlightRequest>) -> Vec<HighlightResult>;
}
#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct HighlightBatchKey {
file: FileId,
side: DiffSide,
syntax: String,
theme: String,
path: Option<PathBuf>,
source: HighlightSourceId,
}
#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
struct HighlightSourceId {
ptr: usize,
len: usize,
head: u32,
}
impl HighlightKey {
pub fn new(input: HighlightKeyInput<'_>) -> Self {
let mut hasher = DefaultHasher::new();
input.text.hash(&mut hasher);
Self {
file: input.file,
side: input.side,
source_line: input.source_line,
text_hash: hasher.finish(),
syntax: input.syntax.unwrap_or("auto").to_owned(),
theme: input.theme.to_owned(),
}
}
}
impl HighlightSource {
pub fn new(text: impl Into<Arc<str>>, head: u32) -> Self {
Self {
text: text.into(),
head,
}
}
pub fn line_index(&self, source_line: u32) -> Option<usize> {
source_line.checked_sub(self.head).map(|line| line as usize)
}
pub fn line(&self, source_line: u32) -> Option<&str> {
self.line_index(source_line)
.and_then(|index| self.text.lines().nth(index))
}
fn id(&self) -> HighlightSourceId {
HighlightSourceId {
ptr: self.text.as_ptr() as usize,
len: self.text.len(),
head: self.head,
}
}
}
impl Hunk {
pub fn highlight_source(&self, side: DiffSide) -> HighlightSource {
let text = side_lines(self, side).collect::<Vec<_>>().join("\n");
HighlightSource::new(text, hunk_head(self, side))
}
}
impl FileDiff {
pub fn source_path(&self, side: DiffSide) -> Option<PathBuf> {
let (primary, fallback) = match side {
DiffSide::Old => (&self.header.old_path, &self.header.new_path),
DiffSide::New => (&self.header.new_path, &self.header.old_path),
};
primary.clone().or_else(|| fallback.clone())
}
pub fn highlight_source(&self, side: DiffSide) -> Option<HighlightSource> {
let mut lines: Vec<&str> = Vec::new();
let mut head = None;
let mut next_line = None;
for hunk in &self.hunks {
let hunk_head = hunk_head(hunk, side);
if next_line.is_some_and(|line| line != hunk_head) {
return None;
}
head.get_or_insert(hunk_head);
lines.extend(side_lines(hunk, side));
let len = hunk
.lines
.iter()
.map(|line| source_len(line, side))
.sum::<u32>();
next_line = Some(hunk_head + len);
}
head.map(|head| HighlightSource::new(lines.join("\n"), head))
}
}
fn side_lines(hunk: &Hunk, side: DiffSide) -> impl Iterator<Item = &str> {
hunk.lines
.iter()
.filter(move |line| source_len(line, side) != 0)
.map(|line| line.text.as_str())
}
fn hunk_head(hunk: &Hunk, side: DiffSide) -> u32 {
match side {
DiffSide::Old => hunk.header.old_line_no,
DiffSide::New => hunk.header.new_line_no,
}
}
fn source_len(line: &DiffLine, side: DiffSide) -> u32 {
match side {
DiffSide::Old => line.kind.old_len(),
DiffSide::New => line.kind.new_len(),
}
}
impl BuiltinHighlighter {
pub fn new(registry: syntax::Registry, default_theme: impl Into<String>) -> Self {
Self {
registry,
default_theme: default_theme.into(),
blob_caches: BTreeMap::new(),
}
}
pub fn ensure_grammar(&mut self, grammar: syntax::Grammar) {
if self.registry.grammar_by_name(&grammar.name).is_err() {
self.registry.add_grammar(grammar);
}
}
pub fn highlight(&mut self, request: HighlightRequest) -> HighlightResult {
self.highlight_group(vec![request]).remove(0)
}
pub fn highlight_requests<I>(&mut self, requests: I) -> Vec<HighlightResult>
where
I: IntoIterator<Item = HighlightRequest>,
{
let mut batches: BTreeMap<HighlightBatchKey, Vec<HighlightRequest>> = BTreeMap::new();
for request in requests {
batches
.entry(HighlightBatchKey::from(&request))
.or_default()
.push(request);
}
batches
.into_values()
.flat_map(|requests| self.highlight_group(requests))
.collect()
}
fn highlight_group(&mut self, requests: Vec<HighlightRequest>) -> Vec<HighlightResult> {
let Some(first) = requests.first() else {
return Vec::new();
};
let Ok(grammar) = self.registry.query(syntax::GrammarQuery {
syntax: (first.key.syntax != "auto").then_some(first.key.syntax.as_str()),
path: first.path.as_deref(),
head: first.source.text.lines().next(),
}) else {
return requests.into_iter().map(HighlightResult::plain).collect();
};
let theme_name = if first.key.theme == "auto" {
self.default_theme.as_str()
} else {
&first.key.theme
};
let Ok(theme) = self.registry.theme_by_name(theme_name) else {
return requests.into_iter().map(HighlightResult::plain).collect();
};
let range = requests.iter().filter_map(|request| {
request
.source
.line_index(request.key.source_line)
.map(|line| line..line.saturating_add(1))
});
let mut start = usize::MAX;
let mut end = 0;
for range in range {
start = start.min(range.start);
end = end.max(range.end);
}
if start >= end {
return requests.into_iter().map(HighlightResult::plain).collect();
}
let source = first.source.text.clone();
let cache_key = BlobCacheKey {
grammar: grammar.name.clone(),
text_ptr: source.as_ptr() as usize,
text_len: source.len(),
};
let cache = self
.blob_caches
.remove(&cache_key)
.map(|entry| entry.cache)
.unwrap_or_default();
let mut lines = BTreeMap::new();
let cache = {
let mut blob = syntax::BlobHighlighter::with_cache(grammar, source.as_ref(), cache);
blob.highlight_styled_range(theme, start..end, |line| {
lines.insert(line.line_index, line_from_spans(line.text, line.styles));
});
blob.into_cache()
};
self.blob_caches.insert(
cache_key,
BlobCacheEntry {
_source: source,
cache,
},
);
requests
.into_iter()
.map(|request| {
let line = request
.source
.line_index(request.key.source_line)
.and_then(|index| lines.remove(&index))
.unwrap_or_else(|| request.plain_line());
HighlightResult::new(request, line)
})
.collect()
}
}
impl DiffHighlighter for BuiltinHighlighter {
fn highlight_batch(&mut self, requests: Vec<HighlightRequest>) -> Vec<HighlightResult> {
self.highlight_requests(requests)
}
}
impl HighlightRequest {
fn plain_line(&self) -> Line {
self.source
.line(self.key.source_line)
.map(Line::new)
.unwrap_or_default()
}
}
impl HighlightResult {
pub fn new(request: HighlightRequest, line: Line) -> Self {
Self {
key: request.key,
hunk: request.hunk,
row: request.row,
line,
}
}
fn plain(request: HighlightRequest) -> Self {
let line = request.plain_line();
Self::new(request, line)
}
}
impl From<&HighlightRequest> for HighlightBatchKey {
fn from(request: &HighlightRequest) -> Self {
Self {
file: request.key.file,
side: request.key.side,
syntax: request.key.syntax.clone(),
theme: request.key.theme.clone(),
path: request.path.clone(),
source: request.source.id(),
}
}
}
fn line_from_spans(text: &str, spans: &[syntax::StyleSpan]) -> Line {
if text.is_empty() || spans.is_empty() {
return Line::new(text);
}
let mut line = Line::blank();
let mut cursor = 0;
for span in spans {
if cursor < span.start {
line.push(Label::new(&text[cursor..span.start]));
}
if span.start < span.end {
line.push(Label::new(&text[span.start..span.end]).style(span.style.tui_style()));
}
cursor = span.end;
}
if cursor < text.len() {
line.push(Label::new(&text[cursor..]));
}
line
}
#[derive(Clone, Copy, Debug)]
pub struct HighlightKeyInput<'a> {
pub file: FileId,
pub side: DiffSide,
pub source_line: u32,
pub text: &'a str,
pub syntax: Option<&'a str>,
pub theme: &'a str,
}
trait SyntaxStyleExt {
fn tui_style(self) -> Style;
}
impl SyntaxStyleExt for syntax::Style {
fn tui_style(self) -> Style {
let mut out = Style::default();
if let Some(color) = self.foreground {
out = out.fg(Color::RGB(color.r, color.g, color.b));
}
if self.font_style.contains(syntax::FontStyle::BOLD) {
out = out.bold();
}
if self.font_style.contains(syntax::FontStyle::ITALIC) {
out = out.italic();
}
if self.font_style.contains(syntax::FontStyle::UNDERLINE) {
out = out.underline();
}
if self.font_style.contains(syntax::FontStyle::STRIKETHROUGH) {
out = out.strikethrough();
}
out
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Decode;
use std::str::FromStr;
#[test]
fn source_lines_before_head_are_absent() {
let source = HighlightSource::new("two\nthree\n", 2);
assert_eq!(source.line_index(1), None);
assert_eq!(source.line(1), None);
assert_eq!(source.line_index(2), Some(0));
assert_eq!(source.line(2), Some("two"));
}
#[test]
fn file_highlight_source_spans_the_new_side() {
let document = crate::DiffDocument::decode_str(
"\
diff --git a/a.css b/a.css
index 1111111..2222222 100644
--- a/a.css
+++ b/a.css
@@ -1,3 +1,3 @@
.x {
-background: url(old.svg);
+background: url(new.svg);
}
",
)
.unwrap();
let source = document.files[0].highlight_source(DiffSide::New).unwrap();
assert_eq!(source.head, 1);
assert_eq!(source.line(1), Some(".x {"));
assert_eq!(source.line(2), Some("background: url(new.svg);"));
assert_eq!(source.line(3), Some("}"));
}
#[test]
fn highlight_source_keeps_a_leading_blank_line() {
let document = crate::DiffDocument::decode_str(concat!(
"diff --git a/a.rs b/a.rs\n",
"index 1111111..2222222 100644\n",
"--- a/a.rs\n",
"+++ b/a.rs\n",
"@@ -2,3 +2,3 @@\n",
" \n",
"-old\n",
"+new\n",
" tail\n",
))
.unwrap();
let hunk = &document.files[0].hunks[0];
let source = hunk.highlight_source(DiffSide::New);
assert_eq!(source.head, 2);
assert_eq!(source.line(2), Some(""));
assert_eq!(source.line(3), Some("new"));
assert_eq!(source.line(4), Some("tail"));
let file = document.files[0].highlight_source(DiffSide::New).unwrap();
assert_eq!(file.line(2), Some(""));
assert_eq!(file.line(3), Some("new"));
}
#[test]
fn css_custom_properties_use_variable_theme_style() {
let grammar = syntax::Grammar::from_str(syntax::syntaxes::CSS).unwrap();
let theme =
syntax::Theme::parse(include_str!("themes/rustik-catppuccin-mocha.json")).unwrap();
let line = " --color-background-light: #dad8d8;";
let mut state = syntax::LineState::default();
let mut tokenizer = syntax::LineTokenizer::new(&grammar);
let _ = tokenizer.tokenize_line(&mut state, ":root {");
let spans = tokenizer.tokenize_line(&mut state, line);
let styles = theme.style_spans(&grammar, line, &spans);
let custom_property = line.find("--color-background-light").unwrap();
let style = styles
.iter()
.find(|style| style.start <= custom_property && style.end > custom_property)
.unwrap();
assert!(scopes_for_byte(&grammar, &spans, custom_property).contains(&"variable.css"));
assert_eq!(
style.style.foreground,
Some(syntax::Rgb {
r: 137,
g: 180,
b: 250
})
);
}
#[test]
fn css_var_references_use_variable_theme_style() {
let grammar = syntax::Grammar::from_str(syntax::syntaxes::CSS).unwrap();
let theme =
syntax::Theme::parse(include_str!("themes/rustik-catppuccin-mocha.json")).unwrap();
let line = " color: var(--color-dimmer);";
let mut state = syntax::LineState::default();
let mut tokenizer = syntax::LineTokenizer::new(&grammar);
let _ = tokenizer.tokenize_line(&mut state, ".note-meta {");
let spans = tokenizer.tokenize_line(&mut state, line);
let styles = theme.style_spans(&grammar, line, &spans);
let variable = line.find("--color-dimmer").unwrap();
let style = styles
.iter()
.find(|style| style.start <= variable && style.end > variable)
.unwrap();
assert!(scopes_for_byte(&grammar, &spans, variable).contains(&"variable.argument.css"));
assert_eq!(
style.style.foreground,
Some(syntax::Rgb {
r: 235,
g: 160,
b: 172
})
);
}
fn scopes_for_byte<'a>(
grammar: &'a syntax::Grammar,
spans: &'a [syntax::ScopeSpan],
byte: usize,
) -> Vec<&'a str> {
spans
.iter()
.filter(|span| span.start <= byte && span.end > byte)
.filter_map(|span| grammar.scopes.get(span.scope.index()))
.map(String::as_str)
.collect()
}
}