use std::io::{stdout, Write};
use std::path::Path;
use crossterm::{
cursor::{Hide, MoveTo, Show},
event::{read, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifiers},
queue,
style::{Attribute, Print, SetAttribute},
terminal::{Clear, ClearType},
};
use crate::document::Document;
use crate::folds::{self, Folds};
use crate::snippets::Language;
use crate::terminal::Terminal;
#[cfg(test)]
mod tests;
const TAB: &str = " ";
pub struct Editor {
document: Document,
language: Option<Language>,
folds: Folds,
should_quit: bool,
cursor_x: usize,
cursor_y: usize,
row_offset: usize,
col_offset: usize,
message: String,
quit_pending: bool,
}
impl Editor {
pub fn new(document: Document) -> Self {
Self {
language: document.path.as_deref().and_then(Language::from_path),
document,
folds: Folds::default(),
should_quit: false,
cursor_x: 0,
cursor_y: 0,
row_offset: 0,
col_offset: 0,
message: String::new(),
quit_pending: false,
}
}
pub fn run(&mut self) -> std::io::Result<()> {
while !self.should_quit {
let (width, height) = Terminal::size()?;
let text_rows = height.saturating_sub(1);
self.scroll(width.saturating_sub(self.gutter_width()), text_rows);
self.draw(width, text_rows)?;
match read()? {
Event::Key(key) => self.handle_key(key),
Event::Paste(text) => self.paste(&text),
_ => {}
}
}
Ok(())
}
fn handle_key(&mut self, key: KeyEvent) {
if key.kind == KeyEventKind::Release {
return;
}
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
let alt = key.modifiers.contains(KeyModifiers::ALT);
let quit_was_pending = std::mem::take(&mut self.quit_pending);
self.message.clear();
match key.code {
KeyCode::Char('q') if ctrl => {
if self.document.dirty && !quit_was_pending {
self.quit_pending = true;
self.message = "Unsaved changes! Ctrl+Q again to quit".into();
} else {
self.should_quit = true;
}
}
KeyCode::Char('s') if ctrl => self.save(),
KeyCode::Char('k') if ctrl => self.toggle_fold(),
KeyCode::Char(c) if !ctrl && !alt => self.type_char(c),
KeyCode::Tab => self.tab(),
KeyCode::Enter => {
let indent = self.indent_for_new_line();
self.insert_newline();
indent.chars().for_each(|c| self.insert_char(c));
}
KeyCode::Backspace => self.backspace(),
KeyCode::Delete => self.delete(),
KeyCode::Up => {
if let Some(y) = self.folds.prev_visible(self.cursor_y) {
self.cursor_y = y;
}
}
KeyCode::Down => {
if let Some(y) = self.folds.next_visible(self.cursor_y, self.document.len()) {
self.cursor_y = y;
}
}
KeyCode::Left => {
if self.cursor_x > 0 {
self.cursor_x -= 1;
}
}
KeyCode::Right => {
if self.cursor_x < self.document.line_len(self.cursor_y) {
self.cursor_x += 1;
}
}
KeyCode::Home => self.cursor_x = 0,
KeyCode::End => self.cursor_x = self.document.line_len(self.cursor_y),
_ => {}
}
self.clamp_cursor_x();
}
fn clamp_cursor_x(&mut self) {
let len = self.document.line_len(self.cursor_y);
if self.cursor_x > len {
self.cursor_x = len;
}
}
fn insert_char(&mut self, c: char) {
self.folds.unfold(self.cursor_y);
self.document.insert_char(self.cursor_x, self.cursor_y, c);
self.cursor_x += 1;
}
fn insert_newline(&mut self) {
self.folds.unfold(self.cursor_y);
self.document.insert_newline(self.cursor_x, self.cursor_y);
self.folds.shift_after(self.cursor_y, 1);
self.cursor_y += 1;
self.cursor_x = 0;
}
fn backspace(&mut self) {
self.folds.unfold(self.cursor_y);
if self.cursor_x > 0 {
self.cursor_x -= 1;
self.document.delete_char(self.cursor_x, self.cursor_y);
} else if self.cursor_y > 0 {
self.folds.reveal(self.cursor_y - 1);
self.cursor_y -= 1;
self.cursor_x = self.document.line_len(self.cursor_y);
self.document.delete_char(self.cursor_x, self.cursor_y);
self.folds.shift_after(self.cursor_y, -1);
}
}
fn delete(&mut self) {
self.folds.unfold(self.cursor_y);
if self.cursor_x < self.document.line_len(self.cursor_y) {
self.document.delete_char(self.cursor_x, self.cursor_y);
} else if self.cursor_y + 1 < self.document.len() {
self.folds.unfold(self.cursor_y + 1);
self.document.delete_char(self.cursor_x, self.cursor_y);
self.folds.shift_after(self.cursor_y, -1);
}
}
fn type_char(&mut self, c: char) {
if c == '}' && self.cursor_x > 0 && self.text_before_cursor().chars().all(|c| c == ' ') {
for _ in 0..TAB.len().min(self.cursor_x) {
self.backspace();
}
}
self.insert_char(c);
}
fn paste(&mut self, text: &str) {
self.quit_pending = false;
self.message.clear();
for c in text.chars() {
match c {
'\n' => self.insert_newline(),
'\r' => {}
'\t' => TAB.chars().for_each(|c| self.insert_char(c)),
c => self.insert_char(c),
}
}
}
fn text_before_cursor(&self) -> String {
match self.document.lines.get(self.cursor_y) {
Some(line) => line.chars().take(self.cursor_x).collect(),
None => String::new(),
}
}
fn indent_for_new_line(&self) -> String {
let before = self.text_before_cursor();
let mut indent: String = before.chars().take_while(|c| *c == ' ').collect();
let opens_block = match before.trim_end().chars().last() {
Some('{' | '(' | '[') => true,
Some(':') => self.language == Some(Language::Python),
_ => false,
};
if opens_block {
indent.push_str(TAB);
}
indent
}
fn tab(&mut self) {
let before = self.text_before_cursor();
let word_len = before
.chars()
.rev()
.take_while(|c| c.is_alphanumeric() || *c == '_')
.count();
let word: String = before.chars().skip(before.chars().count() - word_len).collect();
match self.language.and_then(|language| language.snippet(&word)) {
Some(body) => {
self.expand_snippet(word_len, body);
self.message = format!("Expanded snippet: {word}");
}
None => TAB.chars().for_each(|c| self.insert_char(c)),
}
}
fn expand_snippet(&mut self, trigger_len: usize, body: &str) {
for _ in 0..trigger_len {
self.backspace();
}
let indent: String = self
.text_before_cursor()
.chars()
.take_while(|c| *c == ' ')
.collect();
let mut cursor_target = None;
let mut chars = body.chars().peekable();
while let Some(c) = chars.next() {
match c {
'$' if chars.peek() == Some(&'0') => {
chars.next();
cursor_target = Some((self.cursor_x, self.cursor_y));
}
'\n' => {
self.insert_newline();
indent.chars().for_each(|c| self.insert_char(c));
}
c => self.insert_char(c),
}
}
if let Some((x, y)) = cursor_target {
self.cursor_x = x;
self.cursor_y = y;
}
}
fn toggle_fold(&mut self) {
if self.folds.unfold(self.cursor_y) {
self.message = "Unfolded".into();
return;
}
let lines = &self.document.lines;
let block = folds::block_end(lines, self.cursor_y)
.map(|end| (self.cursor_y, end))
.or_else(|| folds::enclosing_block(lines, self.cursor_y));
match block {
Some((start, end)) => {
self.folds.fold(start, end);
self.cursor_y = start;
self.message = format!("Folded {} lines (Ctrl+K unfolds)", end - start);
}
None => self.message = "No { } block to fold here".into(),
}
}
fn save(&mut self) {
self.message = match self.document.save() {
Ok(()) => format!("Saved {} lines", self.document.len()),
Err(error) => format!("Could not save: {error}"),
};
}
fn gutter_width(&self) -> usize {
if self.document.is_empty() {
0
} else {
self.document.len().to_string().len() + 1
}
}
fn scroll(&mut self, width: usize, height: usize) {
self.row_offset = self.folds.header_of(self.row_offset.min(self.cursor_y));
while height > 0 && self.folds.rows_between(self.row_offset, self.cursor_y) >= height {
match self.folds.next_visible(self.row_offset, self.document.len()) {
Some(next) => self.row_offset = next,
None => break,
}
}
if self.cursor_x < self.col_offset {
self.col_offset = self.cursor_x;
}
if width > 0 && self.cursor_x >= self.col_offset + width {
self.col_offset = self.cursor_x - width + 1;
}
}
fn display_line(&self, y: usize) -> String {
let line = &self.document.lines[y];
match self.folds.end_of(y) {
Some(end) => format!("{line} ... {}", self.document.lines[end].trim()),
None => line.clone(),
}
}
fn status_line(&self, width: usize) -> String {
let left = if !self.message.is_empty() {
self.message.clone()
} else {
let name = self
.document
.path
.as_deref()
.and_then(|path| Path::new(path).file_name())
.and_then(|name| name.to_str())
.unwrap_or("[No Name]");
let modified = if self.document.dirty { " [modified]" } else { "" };
format!("{name}{modified}")
};
let right = format!("Ln {}, Col {}", self.cursor_y + 1, self.cursor_x + 1);
let left_len = left.chars().count();
let line = if left_len + 1 + right.len() <= width {
let gap = width - left_len - right.len();
format!("{left}{}{right}", " ".repeat(gap))
} else {
left
};
let mut line: String = line.chars().take(width).collect();
let padding = width - line.chars().count();
line.push_str(&" ".repeat(padding));
line
}
fn draw(&self, width: usize, text_rows: usize) -> std::io::Result<()> {
let mut out = stdout();
let gutter = self.gutter_width();
let text_width = width.saturating_sub(gutter);
queue!(out, Hide, Clear(ClearType::All), MoveTo(0, 0))?;
let mut next_line = Some(self.row_offset).filter(|y| *y < self.document.len());
for row in 0..text_rows {
if let Some(y) = next_line {
let marker = if self.folds.end_of(y).is_some() { '+' } else { ' ' };
let number = format!("{:>1$}{marker}", y + 1, gutter - 1);
let visible: String = self
.display_line(y)
.chars()
.skip(self.col_offset)
.take(text_width)
.collect();
queue!(
out,
SetAttribute(Attribute::Dim),
Print(number),
SetAttribute(Attribute::Reset),
Print(visible)
)?;
next_line = self.folds.next_visible(y, self.document.len());
} else if self.document.is_empty() && row == text_rows / 3 {
let msg = concat!("curd editor -- v", env!("CARGO_PKG_VERSION"));
let padding = width.saturating_sub(msg.len()) / 2;
queue!(out, Print(format!("~{}{}", " ".repeat(padding), msg)))?;
} else {
queue!(out, Print("~"))?;
}
queue!(out, Print("\r\n"))?;
}
queue!(
out,
SetAttribute(Attribute::Reverse),
Print(self.status_line(width)),
SetAttribute(Attribute::Reset)
)?;
let screen_x = (gutter + self.cursor_x - self.col_offset) as u16;
let screen_y = self.folds.rows_between(self.row_offset, self.cursor_y) as u16;
queue!(out, MoveTo(screen_x, screen_y), Show)?;
out.flush()?;
Ok(())
}
}