forked from mars/breed
287 lines
9.3 KiB
Rust
287 lines
9.3 KiB
Rust
/*
|
|
* Copyright (c) 2023 Marceline Cramer
|
|
* Copyright (c) 2023 Emma Tebibyte <emma@tebibyte.media>
|
|
* SPDX-License-Identifier: AGPL-3.0-or-later
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU Affero General Public License as published by the Free
|
|
* Software Foundation, either version 3 of the License, or (at your option) any
|
|
* later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
|
* details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see https://www.gnu.org/licenses/.
|
|
*/
|
|
|
|
use std::io::Write;
|
|
use std::ops::Range;
|
|
use std::sync::Arc;
|
|
|
|
use crossterm::{cursor, ExecutableCommand, QueueableCommand};
|
|
use parking_lot::Mutex;
|
|
use ropey::Rope;
|
|
use syntect::easy::ScopeRangeIterator;
|
|
use syntect::parsing::{BasicScopeStackOp, ParseState, Scope, ScopeStack, SyntaxSet};
|
|
|
|
use crate::theme::{Style, StyleStore};
|
|
use crate::{Cursor, Direction};
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub struct Buffer {
|
|
styles: Arc<Mutex<StyleStore>>,
|
|
text: Rope,
|
|
syntax_set: Arc<SyntaxSet>,
|
|
parser: ParseState,
|
|
style_dirty: bool,
|
|
style_generation: usize,
|
|
styled: Vec<Vec<(Style, Range<usize>)>>,
|
|
}
|
|
|
|
impl AsRef<Rope> for Buffer {
|
|
fn as_ref(&self) -> &Rope {
|
|
&self.text
|
|
}
|
|
}
|
|
|
|
impl Buffer {
|
|
pub fn from_str(styles: Arc<Mutex<StyleStore>>, text: &str) -> Self {
|
|
let syntax_set = SyntaxSet::load_defaults_nonewlines();
|
|
// TODO load non-Rust syntax highlighting
|
|
let syntax_ref = syntax_set.find_syntax_by_extension("rs").unwrap();
|
|
let parser = ParseState::new(syntax_ref);
|
|
|
|
let mut buf = Self {
|
|
styles,
|
|
text: Rope::from_str(text),
|
|
syntax_set: Arc::new(SyntaxSet::load_defaults_newlines()),
|
|
parser,
|
|
style_dirty: true,
|
|
style_generation: 0,
|
|
styled: Vec::new(),
|
|
};
|
|
|
|
buf.parse();
|
|
|
|
buf
|
|
}
|
|
|
|
pub fn draw(
|
|
&mut self,
|
|
cols: u16,
|
|
rows: u16,
|
|
scroll: Cursor,
|
|
cursor: Cursor,
|
|
out: &mut impl Write,
|
|
) -> crossterm::Result<u32> {
|
|
self.parse();
|
|
|
|
let mut styles = self.styles.lock();
|
|
let linenr_style = styles.get_scope("ui.linenr").clone();
|
|
let linenr_width = self.text.len_lines().ilog10() + 1;
|
|
let gutter_width = linenr_width + 1;
|
|
let text_width = cols as usize - gutter_width as usize;
|
|
let line_padding: String = std::iter::repeat(' ').take(text_width).collect();
|
|
|
|
out.queue(cursor::MoveTo(0, 0))?;
|
|
|
|
let mut line_buf = Vec::<u8>::with_capacity(text_width);
|
|
for (row, line) in (0..rows).zip(self.text.lines_at(scroll.line)) {
|
|
// only the last line is empty and should be skipped
|
|
if line.len_chars() == 0 {
|
|
break;
|
|
}
|
|
|
|
let row = row as usize + scroll.line;
|
|
let is_selected = row == cursor.line;
|
|
|
|
let linenr_style = if is_selected {
|
|
styles.get_scope("ui.linenr.selected").clone()
|
|
} else {
|
|
linenr_style
|
|
};
|
|
|
|
let line_style = if is_selected {
|
|
styles.get_scope("ui.cursorline.primary").clone()
|
|
} else {
|
|
Default::default()
|
|
};
|
|
|
|
let linenr = format!("{:width$} ", row, width = linenr_width as usize);
|
|
linenr_style.print_styled(out, &linenr)?;
|
|
|
|
let lhs = scroll.column;
|
|
let width = line.len_chars();
|
|
let mut remaining = text_width;
|
|
line_buf.clear();
|
|
if lhs < width {
|
|
let window = text_width.min(width - lhs);
|
|
let rhs = lhs + window;
|
|
let styled = &self.styled[row];
|
|
for (chunk_style, range) in styled.iter() {
|
|
let range = range.start.max(lhs)..range.end.min(rhs);
|
|
if range.start < range.end {
|
|
// this range is in view so display
|
|
let content = line.slice(range.clone());
|
|
let mut style = line_style.clone();
|
|
style.apply(chunk_style);
|
|
style.print_styled(&mut line_buf, content)?;
|
|
remaining = text_width.saturating_sub(range.end);
|
|
}
|
|
|
|
if range.end >= rhs {
|
|
// past the end of the window so we're done
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
let padding = &line_padding[0..remaining];
|
|
line_style.print_styled(&mut line_buf, padding)?;
|
|
|
|
out.write_all(&line_buf)?;
|
|
out.queue(cursor::MoveToNextLine(1))?;
|
|
}
|
|
|
|
Ok(gutter_width)
|
|
}
|
|
|
|
pub fn remove(&mut self, cursor: Cursor) {
|
|
let index = self.cursor_to_char(cursor);
|
|
self.text.remove(index..=index);
|
|
self.style_dirty = true;
|
|
}
|
|
|
|
pub fn insert_char(&mut self, cursor: Cursor, c: char) {
|
|
let index = self.cursor_to_char(cursor);
|
|
self.text.insert_char(index, c);
|
|
self.style_dirty = true;
|
|
}
|
|
|
|
fn parse(&mut self) {
|
|
use std::fmt::Write;
|
|
let mut styles = self.styles.lock();
|
|
|
|
if styles.generation() == self.style_generation && !self.style_dirty {
|
|
return;
|
|
}
|
|
|
|
self.styled.clear();
|
|
let mut parser = self.parser.clone();
|
|
let mut line_buf = String::new();
|
|
let mut stack = ScopeStack::new();
|
|
let mut styled_buf = Vec::new();
|
|
|
|
let mut style_stack = Vec::<Style>::new();
|
|
style_stack.push(Default::default());
|
|
|
|
for line in self.text.lines() {
|
|
// display line to a pre-allocated buffer for fast parsing
|
|
line_buf.clear();
|
|
write!(line_buf, "{}", line).unwrap();
|
|
let end = line_buf.trim_end().len();
|
|
line_buf.truncate(end);
|
|
|
|
// parse the line into a sequence of stack operations
|
|
let stack_ops = parser.parse_line(&line_buf, &self.syntax_set).unwrap();
|
|
|
|
// queue the operations on the stack
|
|
let range_iter = ScopeRangeIterator::new(&stack_ops, &line_buf);
|
|
styled_buf.clear();
|
|
for (range, op) in range_iter {
|
|
stack
|
|
.apply_with_hook(&op, |op, _scopes| match op {
|
|
BasicScopeStackOp::Push(scope) => {
|
|
let style = styles.get_syntect_scope(&scope);
|
|
let mut top_style = style_stack.last().unwrap().clone();
|
|
top_style.apply(style);
|
|
style_stack.push(top_style);
|
|
}
|
|
BasicScopeStackOp::Pop => {
|
|
style_stack.pop();
|
|
}
|
|
})
|
|
.unwrap();
|
|
|
|
if range.start == range.end {
|
|
continue;
|
|
}
|
|
|
|
let style = style_stack.last().cloned().unwrap_or_default();
|
|
styled_buf.push((style, range));
|
|
}
|
|
|
|
self.styled.push(styled_buf.clone());
|
|
}
|
|
|
|
self.style_dirty = false;
|
|
self.style_generation = styles.generation();
|
|
}
|
|
|
|
pub fn clamped_cursor(&self, cursor: Cursor) -> Cursor {
|
|
let line_end = self.text.line(cursor.line).len_chars().saturating_sub(1);
|
|
|
|
Cursor {
|
|
line: cursor.line,
|
|
column: cursor.column.min(line_end),
|
|
}
|
|
}
|
|
|
|
pub fn cursor_to_char(&self, cursor: Cursor) -> usize {
|
|
let cursor = self.clamped_cursor(cursor);
|
|
self.text.line_to_char(cursor.line) + cursor.column
|
|
}
|
|
|
|
pub fn move_cursor(&self, cursor: &mut Cursor, direction: Direction, enable_linewrap: bool) {
|
|
*cursor = self.clamped_cursor(*cursor);
|
|
match direction {
|
|
Direction::Left => {
|
|
if cursor.column > 0 {
|
|
cursor.column -= 1;
|
|
} else if enable_linewrap && cursor.line > 0 {
|
|
cursor.line -= 1;
|
|
let line = self.text.line(cursor.line);
|
|
cursor.column = line.len_chars() - 1;
|
|
}
|
|
}
|
|
Direction::Down => {
|
|
if cursor.line + 2 < self.text.len_lines() {
|
|
cursor.line += 1;
|
|
}
|
|
}
|
|
Direction::Up => {
|
|
if cursor.line > 0 {
|
|
cursor.line -= 1;
|
|
}
|
|
}
|
|
Direction::Right => {
|
|
let line = self.text.line(cursor.line);
|
|
if cursor.column + 2 > line.len_chars() {
|
|
if enable_linewrap && cursor.line + 2 < self.text.len_lines() {
|
|
cursor.line += 1;
|
|
cursor.column = 0;
|
|
}
|
|
} else {
|
|
cursor.column += 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn style_scopes() {
|
|
let text = include_str!("buffer.rs");
|
|
let mut buffer = Buffer::from_str(Default::default(), text);
|
|
buffer.parse();
|
|
println!("{:#?}", buffer.styled);
|
|
}
|
|
}
|