use std::collections::{BTreeMap, BTreeSet};
use std::path::PathBuf;
use std::sync::mpsc::{self, SyncSender, TrySendError};
use std::thread;
use rustik_repo::{DiffRepository, git};
use crate::builtins::Builtins;
use crate::{
BuiltinHighlighter, ContextRequest, ContextUpdate, Decode, DiffDocument, DiffHighlighter,
DiffSide, FileId, HighlightRequest, HighlightResult, HighlightSource, Oid,
};
const HIGHLIGHT_CONTEXT_LINES: usize = 256;
const COMMAND_QUEUE: usize = 4;
pub struct Highlighter {
commands: SyncSender<Command>,
}
impl Highlighter {
pub fn highlight(&self, requests: Vec<HighlightRequest>) -> Option<Vec<HighlightRequest>> {
match self.commands.try_send(Command::Highlight(requests)) {
Ok(()) => None,
Err(
TrySendError::Full(Command::Highlight(requests))
| TrySendError::Disconnected(Command::Highlight(requests)),
) => Some(requests),
Err(_) => None,
}
}
pub fn context(&self, request: ContextRequest) -> bool {
self.commands.try_send(Command::Context(request)).is_ok()
}
}
pub enum HighlightOutput {
Highlights(Vec<HighlightResult>),
Context(Option<ContextUpdate>),
}
enum Command {
Highlight(Vec<HighlightRequest>),
Context(ContextRequest),
}
pub fn spawn_highlighter(
document: &DiffDocument,
repo: Option<git::Repository>,
output: impl Fn(HighlightOutput) + Send + 'static,
) -> Highlighter {
let (commands, requests) = mpsc::sync_channel::<Command>(COMMAND_QUEUE);
let seed = Seed::new(document);
thread::spawn(move || {
let mut worker = HighlightWorker::new(seed, repo);
while let Ok(command) = requests.recv() {
match command {
Command::Highlight(requests) => {
if requests.is_empty() {
continue;
}
output(HighlightOutput::Highlights(worker.highlight(requests)));
}
Command::Context(request) => {
output(HighlightOutput::Context(worker.context(request)));
}
}
}
});
Highlighter { commands }
}
struct Seed {
paths: Vec<PathBuf>,
head_oids: BTreeMap<(FileId, DiffSide), Oid>,
}
impl Seed {
fn new(document: &DiffDocument) -> Self {
let mut head_oids = BTreeMap::new();
for file in &document.files {
if let Some(oid) = file.header.old_oid {
head_oids.insert((file.id, DiffSide::Old), oid);
}
if let Some(oid) = file.header.new_oid {
head_oids.insert((file.id, DiffSide::New), oid);
}
}
Self {
paths: Builtins::document_paths(document),
head_oids,
}
}
}
struct HighlightWorker {
highlighter: BuiltinHighlighter,
repo: Option<git::Repository>,
context_sources: BTreeMap<(FileId, DiffSide), Vec<HighlightSource>>,
head_oids: BTreeMap<(FileId, DiffSide), Oid>,
loaded_heads: BTreeSet<(FileId, DiffSide)>,
}
impl HighlightWorker {
fn new(seed: Seed, repo: Option<git::Repository>) -> Self {
Self {
highlighter: Builtins::highlighter_for_paths(&seed.paths)
.unwrap_or_else(|_| BuiltinHighlighter::new(Default::default(), "")),
repo,
context_sources: BTreeMap::new(),
head_oids: seed.head_oids,
loaded_heads: BTreeSet::new(),
}
}
fn highlight(&mut self, mut requests: Vec<HighlightRequest>) -> Vec<HighlightResult> {
self.load_context_sources(&requests);
for request in &mut requests {
if let Some(source) = self.context_source_for(request) {
request.source = source.clone();
}
self.load_head_grammar(request);
}
self.highlighter.highlight_batch(requests)
}
fn load_head_grammar(&mut self, request: &HighlightRequest) {
let key = (request.key.file, request.key.side);
if !self.loaded_heads.insert(key) {
return;
}
if request.source.head == 1
&& let Some(head) = request.source.text.lines().next()
{
let _ = Builtins::load_head_grammars(&mut self.highlighter, head);
return;
}
let Some(repo) = self.repo.as_ref() else {
return;
};
let Some(path) = request.path.as_deref() else {
return;
};
if self.highlighter.has_path_grammar(path) {
return;
}
let Some(oid) = self.head_oids.get(&key) else {
return;
};
let head = repo.head_line(*oid);
if let Ok(Some(head)) = head {
let _ = Builtins::load_head_grammars(&mut self.highlighter, &head);
}
}
fn load_context_sources(&mut self, requests: &[HighlightRequest]) {
let Some(repo) = self.repo.as_ref() else {
return;
};
let mut targets = BTreeMap::new();
for request in requests {
let key = (request.key.file, request.key.side);
if self.context_sources.contains_key(&key) || request.source.head == 1 {
continue;
}
if let Some(path) = request.path.as_deref() {
targets.insert((path.to_path_buf(), request.key.side), request.key.file);
}
}
if targets.is_empty() {
return;
}
let paths = targets
.keys()
.map(|(path, _)| path.as_path())
.collect::<BTreeSet<_>>()
.into_iter()
.collect::<Vec<_>>();
let Ok(patch) = repo.diff(HIGHLIGHT_CONTEXT_LINES, &paths) else {
return;
};
let Ok(document) = DiffDocument::decode_bytes(&patch) else {
return;
};
for file in &document.files {
for side in [DiffSide::Old, DiffSide::New] {
let Some(path) = file.source_path(side) else {
continue;
};
let Some(file_id) = targets.get(&(path, side)).copied() else {
continue;
};
let sources = file
.hunks
.iter()
.map(|hunk| hunk.highlight_source(side))
.collect::<Vec<_>>();
self.context_sources.insert((file_id, side), sources);
}
}
}
fn context_source_for(&self, request: &HighlightRequest) -> Option<&HighlightSource> {
if request.source.head == 1 {
return None;
}
let key = (request.key.file, request.key.side);
let expected = request.source.line(request.key.source_line)?;
self.context_sources
.get(&key)?
.iter()
.find(|source| source.line(request.key.source_line) == Some(expected))
}
fn context(&mut self, request: ContextRequest) -> Option<ContextUpdate> {
let repo = self.repo.as_ref()?;
let paths = request.paths().collect::<Vec<_>>();
let patch = repo.diff(request.context_lines(), &paths).ok()?;
drop(paths);
request.decode(&patch).ok().flatten()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{HighlightKey, HighlightKeyInput, HunkId, RowId};
fn request(source: HighlightSource) -> HighlightRequest {
HighlightRequest {
key: HighlightKey::new(HighlightKeyInput {
file: FileId::new(0),
side: DiffSide::New,
source_line: 5,
text: "row",
syntax: None,
theme: "auto",
}),
hunk: HunkId::new(0),
row: RowId::new(0),
path: None,
source,
}
}
#[test]
fn whole_file_sources_are_not_narrowed_to_bounded_context() {
let mut worker = HighlightWorker::new(
Seed {
paths: Vec::new(),
head_oids: BTreeMap::new(),
},
None,
);
worker.context_sources.insert(
(FileId::new(0), DiffSide::New),
vec![HighlightSource::new("row\n", 5)],
);
let hunk_only = request(HighlightSource::new("row\n", 5));
assert!(worker.context_source_for(&hunk_only).is_some());
let whole_file = request(HighlightSource::new("a\nb\nc\nd\nrow\n", 1));
assert!(worker.context_source_for(&whole_file).is_none());
}
}