1use std::collections::{BTreeMap, BTreeSet};
12use std::path::PathBuf;
13use std::sync::mpsc::{self, SyncSender, TrySendError};
14use std::thread;
15
16use rustik_repo::{DiffRepository, git};
17
18use crate::builtins::Builtins;
19use crate::{
20 BuiltinHighlighter, ContextRequest, ContextUpdate, Decode, DiffDocument, DiffHighlighter,
21 DiffSide, FileId, HighlightRequest, HighlightResult, HighlightSource, Oid,
22};
23
24const HIGHLIGHT_CONTEXT_LINES: usize = 256;
26const COMMAND_QUEUE: usize = 4;
28
29pub struct Highlighter {
35 commands: SyncSender<Command>,
37}
38
39impl Highlighter {
40 pub fn highlight(&self, requests: Vec<HighlightRequest>) -> Option<Vec<HighlightRequest>> {
47 match self.commands.try_send(Command::Highlight(requests)) {
50 Ok(()) => None,
51 Err(
52 TrySendError::Full(Command::Highlight(requests))
53 | TrySendError::Disconnected(Command::Highlight(requests)),
54 ) => Some(requests),
55 Err(_) => None,
56 }
57 }
58
59 pub fn context(&self, request: ContextRequest) -> bool {
61 self.commands.try_send(Command::Context(request)).is_ok()
62 }
63}
64
65pub enum HighlightOutput {
67 Highlights(Vec<HighlightResult>),
70 Context(Option<ContextUpdate>),
74}
75
76enum Command {
78 Highlight(Vec<HighlightRequest>),
80 Context(ContextRequest),
82}
83
84pub fn spawn_highlighter(
90 document: &DiffDocument,
91 repo: Option<git::Repository>,
92 output: impl Fn(HighlightOutput) + Send + 'static,
93) -> Highlighter {
94 let (commands, requests) = mpsc::sync_channel::<Command>(COMMAND_QUEUE);
95 let seed = Seed::new(document);
96
97 thread::spawn(move || {
98 let mut worker = HighlightWorker::new(seed, repo);
101 while let Ok(command) = requests.recv() {
102 match command {
103 Command::Highlight(requests) => {
104 if requests.is_empty() {
105 continue;
106 }
107 output(HighlightOutput::Highlights(worker.highlight(requests)));
108 }
109 Command::Context(request) => {
110 output(HighlightOutput::Context(worker.context(request)));
111 }
112 }
113 }
114 });
115 Highlighter { commands }
116}
117
118struct Seed {
124 paths: Vec<PathBuf>,
126 head_oids: BTreeMap<(FileId, DiffSide), Oid>,
128}
129
130impl Seed {
131 fn new(document: &DiffDocument) -> Self {
133 let mut head_oids = BTreeMap::new();
134 for file in &document.files {
135 if let Some(oid) = file.header.old_oid {
136 head_oids.insert((file.id, DiffSide::Old), oid);
137 }
138 if let Some(oid) = file.header.new_oid {
139 head_oids.insert((file.id, DiffSide::New), oid);
140 }
141 }
142 Self {
143 paths: Builtins::document_paths(document),
144 head_oids,
145 }
146 }
147}
148
149struct HighlightWorker {
151 highlighter: BuiltinHighlighter,
153 repo: Option<git::Repository>,
155 context_sources: BTreeMap<(FileId, DiffSide), Vec<HighlightSource>>,
157 head_oids: BTreeMap<(FileId, DiffSide), Oid>,
159 loaded_heads: BTreeSet<(FileId, DiffSide)>,
161}
162
163impl HighlightWorker {
164 fn new(seed: Seed, repo: Option<git::Repository>) -> Self {
166 Self {
167 highlighter: Builtins::highlighter_for_paths(&seed.paths)
168 .unwrap_or_else(|_| BuiltinHighlighter::new(Default::default(), "")),
169 repo,
170 context_sources: BTreeMap::new(),
171 head_oids: seed.head_oids,
172 loaded_heads: BTreeSet::new(),
173 }
174 }
175
176 fn highlight(&mut self, mut requests: Vec<HighlightRequest>) -> Vec<HighlightResult> {
178 self.load_context_sources(&requests);
179 for request in &mut requests {
180 if let Some(source) = self.context_source_for(request) {
181 request.source = source.clone();
182 }
183 self.load_head_grammar(request);
184 }
185 self.highlighter.highlight_batch(requests)
186 }
187
188 fn load_head_grammar(&mut self, request: &HighlightRequest) {
190 let key = (request.key.file, request.key.side);
191 if !self.loaded_heads.insert(key) {
192 return;
193 }
194 if request.source.head == 1
195 && let Some(head) = request.source.text.lines().next()
196 {
197 let _ = Builtins::load_head_grammars(&mut self.highlighter, head);
198 return;
199 }
200 let Some(repo) = self.repo.as_ref() else {
201 return;
202 };
203 let Some(path) = request.path.as_deref() else {
204 return;
205 };
206 if self.highlighter.has_path_grammar(path) {
207 return;
208 }
209 let Some(oid) = self.head_oids.get(&key) else {
210 return;
211 };
212 let head = repo.head_line(*oid);
213 if let Ok(Some(head)) = head {
214 let _ = Builtins::load_head_grammars(&mut self.highlighter, &head);
215 }
216 }
217
218 fn load_context_sources(&mut self, requests: &[HighlightRequest]) {
220 let Some(repo) = self.repo.as_ref() else {
221 return;
222 };
223 let mut targets = BTreeMap::new();
224 for request in requests {
225 let key = (request.key.file, request.key.side);
226 if self.context_sources.contains_key(&key) || request.source.head == 1 {
229 continue;
230 }
231 if let Some(path) = request.path.as_deref() {
232 targets.insert((path.to_path_buf(), request.key.side), request.key.file);
233 }
234 }
235 if targets.is_empty() {
236 return;
237 }
238
239 let paths = targets
240 .keys()
241 .map(|(path, _)| path.as_path())
242 .collect::<BTreeSet<_>>()
243 .into_iter()
244 .collect::<Vec<_>>();
245 let Ok(patch) = repo.diff(HIGHLIGHT_CONTEXT_LINES, &paths) else {
246 return;
247 };
248 let Ok(document) = DiffDocument::decode_bytes(&patch) else {
249 return;
250 };
251
252 for file in &document.files {
253 for side in [DiffSide::Old, DiffSide::New] {
254 let Some(path) = file.source_path(side) else {
255 continue;
256 };
257 let Some(file_id) = targets.get(&(path, side)).copied() else {
258 continue;
259 };
260 let sources = file
261 .hunks
262 .iter()
263 .map(|hunk| hunk.highlight_source(side))
264 .collect::<Vec<_>>();
265 self.context_sources.insert((file_id, side), sources);
266 }
267 }
268 }
269
270 fn context_source_for(&self, request: &HighlightRequest) -> Option<&HighlightSource> {
272 if request.source.head == 1 {
276 return None;
277 }
278 let key = (request.key.file, request.key.side);
279 let expected = request.source.line(request.key.source_line)?;
280 self.context_sources
281 .get(&key)?
282 .iter()
283 .find(|source| source.line(request.key.source_line) == Some(expected))
284 }
285
286 fn context(&mut self, request: ContextRequest) -> Option<ContextUpdate> {
288 let repo = self.repo.as_ref()?;
289 let paths = request.paths().collect::<Vec<_>>();
290 let patch = repo.diff(request.context_lines(), &paths).ok()?;
291
292 drop(paths);
293 request.decode(&patch).ok().flatten()
294 }
295}
296
297#[cfg(test)]
298mod tests {
299 use super::*;
300 use crate::{HighlightKey, HighlightKeyInput, HunkId, RowId};
301
302 fn request(source: HighlightSource) -> HighlightRequest {
304 HighlightRequest {
305 key: HighlightKey::new(HighlightKeyInput {
306 file: FileId::new(0),
307 side: DiffSide::New,
308 source_line: 5,
309 text: "row",
310 syntax: None,
311 theme: "auto",
312 }),
313 hunk: HunkId::new(0),
314 row: RowId::new(0),
315 path: None,
316 source,
317 }
318 }
319
320 #[test]
321 fn whole_file_sources_are_not_narrowed_to_bounded_context() {
322 let mut worker = HighlightWorker::new(
323 Seed {
324 paths: Vec::new(),
325 head_oids: BTreeMap::new(),
326 },
327 None,
328 );
329 worker.context_sources.insert(
330 (FileId::new(0), DiffSide::New),
331 vec![HighlightSource::new("row\n", 5)],
332 );
333
334 let hunk_only = request(HighlightSource::new("row\n", 5));
336 assert!(worker.context_source_for(&hunk_only).is_some());
337
338 let whole_file = request(HighlightSource::new("a\nb\nc\nd\nrow\n", 1));
341 assert!(worker.context_source_for(&whole_file).is_none());
342 }
343}