git.iko.soy/helix
on master help sign in
Extract the merge "operator" into helix-core
1b102d5Blaž Hrastnik
helix-core/src/syntax.rs+119
compare with master
unifiedsplit
@@ -1652,6 +1652,125 @@ fn shrink_and_clear<T>(vec: &mut Vec<T>, capacity: usize) {
1652 vec.clear();
1652 vec.clear();
1653}
1653}
1654
1654
1655+pub struct Merge<I> {
1656+ iter: I,
1657+ spans: Box<dyn Iterator<Item = (usize, std::ops::Range<usize>)>>,
1658+
1659+ next_event: Option<HighlightEvent>,
1660+ next_span: Option<(usize, std::ops::Range<usize>)>,
1661+
1662+ queue: Vec<HighlightEvent>,
1663+}
1664+
1665+/// Merge a list of spans into the highlight event stream.
1666+pub fn merge<I: Iterator<Item = HighlightEvent>>(
1667+ iter: I,
1668+ spans: Vec<(usize, std::ops::Range<usize>)>,
1669+) -> Merge<I> {
1670+ let spans = Box::new(spans.into_iter());
1671+ let mut merge = Merge {
1672+ iter,
1673+ spans,
1674+ next_event: None,
1675+ next_span: None,
1676+ queue: Vec::new(),
1677+ };
1678+ merge.next_event = merge.iter.next();
1679+ merge.next_span = merge.spans.next();
1680+ merge
1681+}
1682+
1683+impl<I: Iterator<Item = HighlightEvent>> Iterator for Merge<I> {
1684+ type Item = HighlightEvent;
1685+ fn next(&mut self) -> Option<Self::Item> {
1686+ use HighlightEvent::*;
1687+ if let Some(event) = self.queue.pop() {
1688+ return Some(event);
1689+ }
1690+
1691+ loop {
1692+ match (self.next_event, &self.next_span) {
1693+ // this happens when range is partially or fully offscreen
1694+ (Some(Source { start, end }), Some((span, range))) if start > range.start => {
1695+ if start > range.end {
1696+ self.next_span = self.spans.next();
1697+ } else {
1698+ self.next_span = Some((*span, start..range.end));
1699+ };
1700+ }
1701+ _ => break,
1702+ }
1703+ }
1704+
1705+ match (self.next_event, &self.next_span) {
1706+ (Some(HighlightStart(i)), _) => {
1707+ self.next_event = self.iter.next();
1708+ Some(HighlightStart(i))
1709+ }
1710+ (Some(HighlightEnd), _) => {
1711+ self.next_event = self.iter.next();
1712+ Some(HighlightEnd)
1713+ }
1714+ (Some(Source { start, end }), Some((span, range))) if start < range.start => {
1715+ let intersect = range.start.min(end);
1716+ let event = Source {
1717+ start,
1718+ end: intersect,
1719+ };
1720+
1721+ if end == intersect {
1722+ // the event is complete
1723+ self.next_event = self.iter.next();
1724+ } else {
1725+ // subslice the event
1726+ self.next_event = Some(Source {
1727+ start: intersect,
1728+ end,
1729+ });
1730+ };
1731+
1732+ Some(event)
1733+ }
1734+ (Some(Source { start, end }), Some((span, range))) if start == range.start => {
1735+ let intersect = range.end.min(end);
1736+ let event = HighlightStart(Highlight(*span));
1737+
1738+ // enqueue in reverse order
1739+ self.queue.push(HighlightEnd);
1740+ self.queue.push(Source {
1741+ start,
1742+ end: intersect,
1743+ });
1744+
1745+ if end == intersect {
1746+ // the event is complete
1747+ self.next_event = self.iter.next();
1748+ } else {
1749+ // subslice the event
1750+ self.next_event = Some(Source {
1751+ start: intersect,
1752+ end,
1753+ });
1754+ };
1755+
1756+ if intersect == range.end {
1757+ self.next_span = self.spans.next();
1758+ } else {
1759+ self.next_span = Some((*span, intersect..range.end));
1760+ }
1761+
1762+ Some(event)
1763+ }
1764+ (Some(event), None) => {
1765+ self.next_event = self.iter.next();
1766+ Some(event)
1767+ }
1768+ (None, None) => None,
1769+ e => unreachable!("{:?}", e),
1770+ }
1771+ }
1772+}
1773+
1655#[test]
1774#[test]
1656fn test_parser() {
1775fn test_parser() {
1657 let highlight_names: Vec<String> = [
1776 let highlight_names: Vec<String> = [
helix-term/src/ui/editor.rs+38−162
@@ -44,124 +44,6 @@ impl Default for EditorView {
44 }
44 }
45}
45}
46
46
47−struct Merge<I> {
48− iter: I,
49− spans: Box<dyn Iterator<Item = (usize, std::ops::Range<usize>)>>,
50−
51− next_event: Option<HighlightEvent>,
52− next_span: Option<(usize, std::ops::Range<usize>)>,
53−
54− queue: Vec<HighlightEvent>,
55−}
56−
57−fn merge<I: Iterator<Item = HighlightEvent>>(
58− iter: I,
59− spans: Vec<(usize, std::ops::Range<usize>)>,
60−) -> impl Iterator<Item = HighlightEvent> {
61− let spans = Box::new(spans.into_iter());
62− let mut merge = Merge {
63− iter,
64− spans,
65− next_event: None,
66− next_span: None,
67− queue: Vec::new(),
68− };
69− merge.next_event = merge.iter.next();
70− merge.next_span = merge.spans.next();
71− merge
72−}
73−
74−impl<I: Iterator<Item = HighlightEvent>> Iterator for Merge<I> {
75− type Item = HighlightEvent;
76− fn next(&mut self) -> Option<Self::Item> {
77− use HighlightEvent::*;
78− if let Some(event) = self.queue.pop() {
79− return Some(event);
80− }
81−
82− loop {
83− match (self.next_event, &self.next_span) {
84− // this happens when range is partially or fully offscreen
85− (Some(Source { start, end }), Some((span, range))) if start > range.start => {
86− if start > range.end {
87− self.next_span = self.spans.next();
88− } else {
89− self.next_span = Some((*span, start..range.end));
90− };
91− }
92− _ => break,
93− }
94− }
95−
96− match (self.next_event, &self.next_span) {
97− (Some(HighlightStart(i)), _) => {
98− self.next_event = self.iter.next();
99− Some(HighlightStart(i))
100− }
101− (Some(HighlightEnd), _) => {
102− self.next_event = self.iter.next();
103− Some(HighlightEnd)
104− }
105− (Some(Source { start, end }), Some((span, range))) if start < range.start => {
106− let intersect = range.start.min(end);
107− let event = Source {
108− start,
109− end: intersect,
110− };
111−
112− if end == intersect {
113− // the event is complete
114− self.next_event = self.iter.next();
115− } else {
116− // subslice the event
117− self.next_event = Some(Source {
118− start: intersect,
119− end,
120− });
121− };
122−
123− Some(event)
124− }
125− (Some(Source { start, end }), Some((span, range))) if start == range.start => {
126− let intersect = range.end.min(end);
127− let event = HighlightStart(Highlight(*span));
128−
129− // enqueue in reverse order
130− self.queue.push(HighlightEnd);
131− self.queue.push(Source {
132− start,
133− end: intersect,
134− });
135−
136− if end == intersect {
137− // the event is complete
138− self.next_event = self.iter.next();
139− } else {
140− // subslice the event
141− self.next_event = Some(Source {
142− start: intersect,
143− end,
144− });
145− };
146−
147− if intersect == range.end {
148− self.next_span = self.spans.next();
149− } else {
150− self.next_span = Some((*span, intersect..range.end));
151− }
152−
153− Some(event)
154− }
155− (Some(event), None) => {
156− self.next_event = self.iter.next();
157− Some(event)
158− }
159− (None, None) => None,
160− e => unreachable!("{:?}", e),
161− }
162− }
163−}
164−
165impl EditorView {
47impl EditorView {
166 pub fn new(keymaps: Keymaps) -> Self {
48 pub fn new(keymaps: Keymaps) -> Self {
167 Self {
49 Self {
@@ -290,27 +172,16 @@ impl EditorView {
290 .find_scope_index("ui.selection.primary")
172 .find_scope_index("ui.selection.primary")
291 .unwrap_or(selection_scope);
173 .unwrap_or(selection_scope);
292
174
293− // TODO: primary + insert mode patching
294− // let primary_cursor_style = theme
295− // .try_get("ui.cursor.primary")
296− // .map(|style| {
297− // if mode != Mode::Normal {
298− // // we want to make sure that the insert and select highlights
299− // // also affect the primary cursor if set
300− // style.patch(cursor_style)
301− // } else {
302− // style
303− // }
304− // })
305− // .unwrap_or(cursor_style);
306−
307− let primary_cursor_scope = theme
308− .find_scope_index("ui.cursor.primary")
309− .unwrap_or(cursor_scope);
310−
311 let highlights: Box<dyn Iterator<Item = HighlightEvent>> = if is_focused {
175 let highlights: Box<dyn Iterator<Item = HighlightEvent>> = if is_focused {
312 // inject selections as highlight scopes
176 // inject selections as highlight scopes
313− let mut spans_: Vec<(usize, std::ops::Range<usize>)> = Vec::new();
177+ let mut spans: Vec<(usize, std::ops::Range<usize>)> = Vec::new();
178+
179+ // TODO: primary + insert mode patching:
180+ // (ui.cursor.primary).patch(mode).unwrap_or(cursor)
181+
182+ let primary_cursor_scope = theme
183+ .find_scope_index("ui.cursor.primary")
184+ .unwrap_or(cursor_scope);
314
185
315 for (i, range) in selections.iter().enumerate() {
186 for (i, range) in selections.iter().enumerate() {
316 let (cursor_scope, selection_scope) = if i == primary_idx {
187 let (cursor_scope, selection_scope) = if i == primary_idx {
@@ -320,39 +191,40 @@ impl EditorView {
320 };
191 };
321
192
322 if range.head == range.anchor {
193 if range.head == range.anchor {
323− spans_.push((cursor_scope, range.head..range.head + 1));
194+ spans.push((cursor_scope, range.head..range.head + 1));
324 continue;
195 continue;
325 }
196 }
326
197
327 let reverse = range.head < range.anchor;
198 let reverse = range.head < range.anchor;
328
199
329 if reverse {
200 if reverse {
330− spans_.push((cursor_scope, range.head..range.head + 1));
201+ spans.push((cursor_scope, range.head..range.head + 1));
331− spans_.push((selection_scope, range.head + 1..range.anchor + 1));
202+ spans.push((selection_scope, range.head + 1..range.anchor + 1));
332 } else {
203 } else {
333− spans_.push((selection_scope, range.anchor..range.head));
204+ spans.push((selection_scope, range.anchor..range.head));
334− spans_.push((cursor_scope, range.head..range.head + 1));
205+ spans.push((cursor_scope, range.head..range.head + 1));
335 }
206 }
336 }
207 }
337
208
338− Box::new(merge(highlights, spans_))
209+ Box::new(syntax::merge(highlights, spans))
339 } else {
210 } else {
340 Box::new(highlights)
211 Box::new(highlights)
341 };
212 };
342
213
343 // diagnostic injection
214 // diagnostic injection
344 let diagnostic_scope = theme.find_scope_index("diagnostic").unwrap_or(cursor_scope);
215 let diagnostic_scope = theme.find_scope_index("diagnostic").unwrap_or(cursor_scope);
345− let spans_ = doc
216+ let highlights = Box::new(syntax::merge(
217+ highlights,
346− .diagnostics()
218+ doc.diagnostics()
347− .iter()
219+ .iter()
348− .map(|diagnostic| {
220+ .map(|diagnostic| {
349− (
221+ (
350− diagnostic_scope,
222+ diagnostic_scope,
351− diagnostic.range.start..diagnostic.range.end,
223+ diagnostic.range.start..diagnostic.range.end,
352− )
224+ )
353− })
225+ })
354− .collect();
226+ .collect(),
355− let highlights = Box::new(merge(highlights, spans_));
227+ ));
356
228
357 'outer: for event in highlights {
229 'outer: for event in highlights {
358 match event {
230 match event {
@@ -403,16 +275,20 @@ impl EditorView {
403 break 'outer;
275 break 'outer;
404 }
276 }
405 } else if grapheme == "\t" {
277 } else if grapheme == "\t" {
406− if !out_of_bounds {
278+ if out_of_bounds {
407− // we still want to render an empty cell with the style
279+ // if we're offscreen just keep going until we hit a new line
408− surface.set_string(
280+ visual_x = visual_x.saturating_add(tab_width as u16);
409− viewport.x + visual_x - view.first_col as u16,
281+ continue;
410− viewport.y + line,
411− " ".repeat(tab_width),
412− style,
413− );
414 }
282 }
415
283
284+ // we still want to render an empty cell with the style
285+ surface.set_string(
286+ viewport.x + visual_x - view.first_col as u16,
287+ viewport.y + line,
288+ " ".repeat(tab_width),
289+ style,
290+ );
291+
416 visual_x = visual_x.saturating_add(tab_width as u16);
292 visual_x = visual_x.saturating_add(tab_width as u16);
417 } else {
293 } else {
418 // Cow will prevent allocations if span contained in a single slice
294 // Cow will prevent allocations if span contained in a single slice