breed/src/buffer.rs

/*
 * 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, QueueableCommand};
use parking_lot::Mutex;
use ropey::Rope;
use syntect::easy::ScopeRangeIterator;
use syntect::parsing::{BasicScopeStackOp, ParseState, 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)) {
            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 linenr = if line.len_chars() > 0 {
                format!("{:>width$} ", row, width = linenr_width as usize)
            } else {
                // only the last line is empty
                format!("{:>width$}", "~", width = linenr_width as usize)
            };

            let line_style = if is_selected {
                styles.get_scope("ui.cursorline.primary").clone()
            } else {
                Default::default()
            };

            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_char(&mut self, cursor: Cursor) {
        let index = self.cursor_to_char(cursor);
        if index < self.text.len_chars() {
            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_len = self.text.line(cursor.line).len_chars();

        let line_end = if cursor.line + 1 == self.text.len_lines() {
            line_len
        } else {
            line_len.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 + 1 < 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.line + 1 == self.text.len_lines() && cursor.column < line.len_chars() {
                    cursor.column += 1;
                } else if cursor.column + 1 < line.len_chars() {
                    cursor.column += 1
                } else if enable_linewrap && cursor.line + 1 < self.text.len_lines() {
                    cursor.line += 1;
                    cursor.column = 0;
                }
            }
        }
    }

    pub fn cursor_at_first_nonwhitespace(&self, line: usize) -> Cursor {
        if let Some(line_slice) = self.text.get_line(line) {
            let mut column = 0;
            for c in line_slice.chars() {
                if !c.is_whitespace() {
                    break;
                }

                column += 1;
            }

            Cursor { line, column }
        } else {
            Cursor { line, column: 0 }
        }
    }

    pub fn cursor_at_line_end(&self, line: usize) -> Cursor {
        Cursor {
            line,
            column: self
                .text
                .get_line(line)
                .map(|line| line.len_chars().saturating_sub(1))
                .unwrap_or(0),
        }
    }

    pub fn cursor_at_file_end(&self) -> Cursor {
        let last_line = if self.text.len_lines() == 0 {
            0
        } else if self.text.line(self.text.len_lines() - 1).len_chars() == 0 {
            self.text.len_lines().saturating_sub(2)
        } else {
            self.text.len_lines() - 1
        };

        self.cursor_at_line_end(last_line)
    }
}

#[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);
    }
}