From b39849dde1b1277d14dbc4e2e1604e5d020db43d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bla=C5=BE=20Hrastnik?= Date: Thu, 22 Oct 2020 14:35:07 +0900 Subject: [PATCH] Refactor: Document type as a wrapper around barebones State. --- Cargo.lock | 2 + helix-core/src/indent.rs | 27 ++-- helix-core/src/state.rs | 81 ----------- helix-core/src/syntax.rs | 2 +- helix-core/src/transaction.rs | 36 +---- helix-lsp/Cargo.toml | 1 + helix-lsp/src/client.rs | 21 +-- helix-term/src/application.rs | 48 ++++--- helix-view/Cargo.toml | 1 + helix-view/src/commands.rs | 255 ++++++++++++++++++---------------- helix-view/src/document.rs | 157 +++++++++++++++++++++ helix-view/src/editor.rs | 7 +- helix-view/src/keymap.rs | 9 +- helix-view/src/lib.rs | 2 + helix-view/src/view.rs | 40 ++++-- 15 files changed, 395 insertions(+), 294 deletions(-) create mode 100644 helix-view/src/document.rs diff --git a/Cargo.lock b/Cargo.lock index 1d7857d58..29a86a36c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -447,6 +447,7 @@ dependencies = [ "futures-util", "glob", "helix-core", + "helix-view", "jsonrpc-core", "lsp-types", "pathdiff", @@ -491,6 +492,7 @@ dependencies = [ "helix-core", "once_cell", "tui", + "url", ] [[package]] diff --git a/helix-core/src/indent.rs b/helix-core/src/indent.rs index 2e1a095ef..6b9a1ab17 100644 --- a/helix-core/src/indent.rs +++ b/helix-core/src/indent.rs @@ -111,17 +111,17 @@ fn find_first_non_whitespace_char(state: &State, line_num: usize) -> usize { start } -fn suggested_indent_for_line(state: &State, line_num: usize) -> usize { +fn suggested_indent_for_line(syntax: Option<&Syntax>, state: &State, line_num: usize) -> usize { let line = state.doc.line(line_num); let current = indent_level_for_line(line); let start = find_first_non_whitespace_char(state, line_num); - suggested_indent_for_pos(state, start) + suggested_indent_for_pos(syntax, state, start) } -pub fn suggested_indent_for_pos(state: &State, pos: usize) -> usize { - if let Some(syntax) = &state.syntax { +pub fn suggested_indent_for_pos(syntax: Option<&Syntax>, state: &State, pos: usize) -> usize { + if let Some(syntax) = syntax { let byte_start = state.doc.char_to_byte(pos); let node = get_highest_syntax_node_at_bytepos(syntax, byte_start); @@ -163,13 +163,18 @@ fn hello_world() { ", ); - let mut state = State::new(doc); - state.set_language("source.rust", &[]); + let state = State::new(doc); + // TODO: set_language + let language_config = crate::syntax::LOADER + .language_config_for_scope("source.rust") + .unwrap(); + let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap(); + let syntax = Syntax::new(&state.doc, highlight_config.clone()); - assert_eq!(suggested_indent_for_line(&state, 0), 0); // mod - assert_eq!(suggested_indent_for_line(&state, 1), 1); // fn - assert_eq!(suggested_indent_for_line(&state, 2), 2); // 1 + 1 - assert_eq!(suggested_indent_for_line(&state, 4), 1); // } - assert_eq!(suggested_indent_for_line(&state, 5), 0); // } + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 0), 0); // mod + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 1); // fn + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 2); // 1 + 1 + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 1); // } + assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 0); // } } } diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 75e5cd40e..7fd620a52 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -3,34 +3,11 @@ use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, Syntax}; use anyhow::Error; -use std::path::PathBuf; - -#[derive(Copy, Clone, PartialEq, Eq, Hash)] -pub enum Mode { - Normal, - Insert, - Goto, -} - /// A state represents the current editor state of a single buffer. pub struct State { // TODO: fields should be private but we need to refactor commands.rs first - /// Path to file on disk. - pub path: Option, pub doc: Rope, pub selection: Selection, - pub mode: Mode, - - pub restore_cursor: bool, - - // TODO: move these to a Document wrapper? - pub syntax: Option, - /// Pending changes since last history commit. - pub changes: ChangeSet, - pub old_state: Option<(Rope, Selection)>, - - pub version: i64, - pub diagnostics: Vec, } #[derive(Copy, Clone, PartialEq, Eq)] @@ -49,60 +26,12 @@ pub enum Granularity { impl State { #[must_use] pub fn new(doc: Rope) -> Self { - let changes = ChangeSet::new(&doc); - let old_state = Some((doc.clone(), Selection::single(0, 0))); - Self { - path: None, doc, selection: Selection::single(0, 0), - mode: Mode::Normal, - restore_cursor: false, - syntax: None, - changes, - old_state, - diagnostics: Vec::new(), - version: 0, } } - // TODO: passing scopes here is awkward - pub fn load(path: PathBuf, scopes: &[String]) -> Result { - use std::{env, fs::File, io::BufReader}; - let _current_dir = env::current_dir()?; - - let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; - - // TODO: create if not found - - let mut state = Self::new(doc); - - if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) { - let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); - // TODO: config.configure(scopes) is now delayed, is that ok? - - let syntax = Syntax::new(&state.doc, highlight_config.clone()); - - state.syntax = Some(syntax); - }; - - // canonicalize path to absolute value - state.path = Some(std::fs::canonicalize(path)?); - - Ok(state) - } - - pub fn set_language(&mut self, scope: &str, scopes: &[String]) { - if let Some(language_config) = LOADER.language_config_for_scope(scope) { - let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); - // TODO: config.configure(scopes) is now delayed, is that ok? - - let syntax = Syntax::new(&self.doc, highlight_config.clone()); - - self.syntax = Some(syntax); - }; - } - // TODO: doc/selection accessors // TODO: be able to take either Rope or RopeSlice @@ -116,16 +45,6 @@ pub fn selection(&self) -> &Selection { &self.selection } - #[inline] - pub fn mode(&self) -> Mode { - self.mode - } - - #[inline] - pub fn path(&self) -> Option<&PathBuf> { - self.path.as_ref() - } - // pub fn doc(&self, range: R) -> RopeSlice // where // R: std::ops::RangeBounds, diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs index 029036379..f4826fb45 100644 --- a/helix-core/src/syntax.rs +++ b/helix-core/src/syntax.rs @@ -66,7 +66,7 @@ pub fn highlight_config( use once_cell::sync::Lazy; -pub(crate) static LOADER: Lazy = Lazy::new(Loader::init); +pub static LOADER: Lazy = Lazy::new(Loader::init); pub struct Loader { // highlight_names ? diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs index 6f3956aa4..9bd8c6152 100644 --- a/helix-core/src/transaction.rs +++ b/helix-core/src/transaction.rs @@ -351,22 +351,6 @@ pub struct Transaction { // scroll_into_view } -/// Like std::mem::replace() except it allows the replacement value to be mapped from the -/// original value. -pub fn take_with(mut_ref: &mut T, closure: F) -where - F: FnOnce(T) -> T, -{ - use std::{panic, ptr}; - - unsafe { - let old_t = ptr::read(mut_ref); - let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t))) - .unwrap_or_else(|_| ::std::process::abort()); - ptr::write(mut_ref, new_t); - } -} - impl Transaction { /// Create a new, empty transaction. pub fn new(state: &mut State) -> Self { @@ -376,29 +360,21 @@ pub fn new(state: &mut State) -> Self { } } + pub fn changes(&self) -> &ChangeSet { + &self.changes + } + /// Returns true if applied successfully. pub fn apply(&self, state: &mut State) -> bool { if !self.changes.is_empty() { - // TODO: also avoid mapping the selection if not necessary - - let old_doc = state.doc().clone(); - // apply changes to the document if !self.changes.apply(&mut state.doc) { return false; } - - // Compose this transaction with the previous one - take_with(&mut state.changes, |changes| { - changes.compose(self.changes.clone()).unwrap() - }); - - if let Some(syntax) = &mut state.syntax { - // TODO: no unwrap - syntax.update(&old_doc, &state.doc, &self.changes).unwrap(); - } } + // TODO: also avoid mapping the selection if not necessary + // update the selection: either take the selection specified in the transaction, or map the // current selection through changes. state.selection = self diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index e4956f0b6..351c3b0e2 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -8,6 +8,7 @@ edition = "2018" [dependencies] helix-core = { path = "../helix-core" } +helix-view = { path = "../helix-view" } lsp-types = { version = "0.82", features = ["proposed"] } smol = "1.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 93e137cb9..56413768d 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -6,6 +6,7 @@ type Result = core::result::Result; use helix_core::{State, Transaction}; +use helix_view::Document; // use std::collections::HashMap; @@ -190,13 +191,13 @@ pub async fn exit(&mut self) -> Result<()> { // Text document // ------------------------------------------------------------------------------------------- - pub async fn text_document_did_open(&mut self, state: &State) -> Result<()> { + pub async fn text_document_did_open(&mut self, doc: &Document) -> Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { - uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + uri: lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now - version: state.version, - text: String::from(&state.doc), + version: doc.version, + text: String::from(doc.text()), }, }) .await @@ -205,13 +206,13 @@ pub async fn text_document_did_open(&mut self, state: &State) -> Result<()> { // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, - state: &State, + doc: &Document, transaction: &Transaction, ) -> Result<()> { self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - state.version, + lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), + doc.version, ), content_changes: vec![lsp::TextDocumentContentChangeEvent { // range = None -> whole document @@ -223,12 +224,12 @@ pub async fn text_document_did_change( .await } - // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for State. + // TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for Document. - pub async fn text_document_did_close(&mut self, state: &State) -> Result<()> { + pub async fn text_document_did_close(&mut self, doc: &Document) -> Result<()> { self.notify::(lsp::DidCloseTextDocumentParams { text_document: lsp::TextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), ), }) .await diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index a1a6b9ea7..b9594b7ea 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,10 +1,11 @@ use clap::ArgMatches as Args; -use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State}; +use helix_core::{indent::TAB_WIDTH, syntax::HighlightEvent, Position, Range, State}; use helix_view::{ commands, + document::Mode, keymap::{self, Keymaps}, prompt::Prompt, - Editor, Theme, View, + Document, Editor, Theme, View, }; use std::{ @@ -95,15 +96,15 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) self.surface.set_style(area, theme.get("ui.background")); // TODO: inefficient, should feed chunks.iter() to tree_sitter.parse_with(|offset, pos|) - let source_code = view.state.doc().to_string(); + let source_code = view.doc.text().to_string(); let last_line = view.last_line(); let range = { // calculate viewport byte ranges - let start = view.state.doc().line_to_byte(view.first_line); - let end = view.state.doc().line_to_byte(last_line) - + view.state.doc().line(last_line).len_bytes(); + let start = view.doc.text().line_to_byte(view.first_line); + let end = view.doc.text().line_to_byte(last_line) + + view.doc.text().line(last_line).len_bytes(); start..end }; @@ -111,7 +112,7 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) // TODO: range doesn't actually restrict source, just highlight range // TODO: cache highlight results // TODO: only recalculate when state.doc is actually modified - let highlights: Vec<_> = match view.state.syntax.as_mut() { + let highlights: Vec<_> = match view.doc.syntax.as_mut() { Some(syntax) => { syntax .highlight_iter(source_code.as_bytes(), Some(range), None, |_| None) @@ -127,6 +128,7 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) let mut visual_x = 0; let mut line = 0u16; let visible_selections: Vec = view + .doc .state .selection() .ranges() @@ -147,10 +149,10 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) HighlightEvent::Source { start, end } => { // TODO: filter out spans out of viewport for now.. - let start = view.state.doc().byte_to_char(start); - let end = view.state.doc().byte_to_char(end); // <-- index 744, len 743 + let start = view.doc.text().byte_to_char(start); + let end = view.doc.text().byte_to_char(end); // <-- index 744, len 743 - let text = view.state.doc().slice(start..end); + let text = view.doc.text().slice(start..end); use helix_core::graphemes::{grapheme_width, RopeGraphemes}; @@ -207,7 +209,7 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) // ugh, improve with a traverse method // or interleave highlight spans with selection and diagnostic spans - let style = if view.state.diagnostics.iter().any(|diagnostic| { + let style = if view.doc.diagnostics.iter().any(|diagnostic| { diagnostic.range.0 <= char_index && diagnostic.range.1 > char_index }) { style.clone().add_modifier(Modifier::UNDERLINED) @@ -233,7 +235,7 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) let warning: Style = theme.get("warning"); let last_line = view.last_line(); for (i, line) in (view.first_line..last_line).enumerate() { - if view.state.diagnostics.iter().any(|d| d.line == line) { + if view.doc.diagnostics.iter().any(|d| d.line == line) { self.surface.set_stringn(0, i as u16, "●", 1, warning); } @@ -243,7 +245,7 @@ pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) } pub fn render_statusline(&mut self, view: &View, theme: &Theme) { - let mode = match view.state.mode() { + let mode = match view.doc.mode() { Mode::Insert => "INS", Mode::Normal => "NOR", Mode::Goto => "GOTO", @@ -259,7 +261,7 @@ pub fn render_statusline(&mut self, view: &View, theme: &Theme) { self.surface.set_string( self.size.0 - 10, self.size.1 - 2, - format!("{}", view.state.diagnostics.len()), + format!("{}", view.doc.diagnostics.len()), self.text_color, ); } @@ -329,14 +331,14 @@ pub fn draw(&mut self) { pub fn render_cursor(&mut self, view: &View, prompt: Option<&Prompt>, viewport: Rect) { let mut stdout = stdout(); - match view.state.mode() { + match view.doc.mode() { Mode::Insert => write!(stdout, "\x1B[6 q"), mode => write!(stdout, "\x1B[2 q"), }; let pos = if let Some(prompt) = prompt { Position::new(self.size.0 as usize, 2 + prompt.cursor) } else { - if let Some(path) = view.state.path() { + if let Some(path) = view.doc.path() { self.surface.set_string( 6, self.size.1 - 1, @@ -345,10 +347,10 @@ pub fn render_cursor(&mut self, view: &View, prompt: Option<&Prompt>, viewport: ); } - let cursor = view.state.selection().cursor(); + let cursor = view.doc.state.selection().cursor(); let mut pos = view - .screen_coords_at_pos(&view.state.doc().slice(..), cursor) + .screen_coords_at_pos(&view.doc.text().slice(..), cursor) .expect("Cursor is out of bounds."); pos.col += viewport.x as usize; pos.row += viewport.y as usize; @@ -416,7 +418,7 @@ pub async fn event_loop(&mut self) { let res = self.lsp.initialize().await; let res = self .lsp - .text_document_did_open(&self.editor.view().unwrap().state) + .text_document_did_open(&self.editor.view().unwrap().doc) .await; self.render(); @@ -469,7 +471,7 @@ pub async fn handle_terminal_events( let keys = vec![event]; // TODO: sequences (`gg`) // TODO: handle count other than 1 - match view.state.mode() { + match view.doc.mode() { Mode::Insert => { if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { command(view, 1); @@ -573,10 +575,10 @@ pub async fn handle_lsp_notification(&mut self, notification: Option bool { - let cursor = view.state.selection().cursor(); - let line = view.state.doc().char_to_line(cursor); + let cursor = view.doc.state.selection().cursor(); + let line = view.doc.text().char_to_line(cursor); let document_end = view.first_line + view.size.1.saturating_sub(1) as usize; if (line > document_end.saturating_sub(PADDING)) | (line < view.first_line + PADDING) { @@ -156,19 +161,19 @@ pub fn page_up(view: &mut View, _count: usize) { view.first_line = view.first_line.saturating_sub(view.size.1 as usize); if !check_cursor_in_view(view) { - let text = view.state.doc(); + let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } pub fn page_down(view: &mut View, _count: usize) { view.first_line += view.size.1 as usize + PADDING; - if view.first_line < view.state.doc().len_lines() { - let text = view.state.doc(); + if view.first_line < view.doc.text().len_lines() { + let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } @@ -180,79 +185,84 @@ pub fn half_page_up(view: &mut View, _count: usize) { view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2); if !check_cursor_in_view(view) { - let text = &view.state.doc; + let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } pub fn half_page_down(view: &mut View, _count: usize) { - let lines = view.state.doc().len_lines(); + let lines = view.doc.text().len_lines(); if view.first_line < lines.saturating_sub(view.size.1 as usize) { view.first_line += view.size.1 as usize / 2; } if !check_cursor_in_view(view) { - let text = view.state.doc(); + let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } } // avoid select by default by having a visual mode switch that makes movements into selects pub fn extend_char_left(view: &mut View, count: usize) { // TODO: use a transaction - let selection = view - .state - .extend_selection(Direction::Backward, Granularity::Character, count); - view.state.selection = selection; + let selection = + view.doc + .state + .extend_selection(Direction::Backward, Granularity::Character, count); + view.doc.state.selection = selection; } pub fn extend_char_right(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Forward, Granularity::Character, count); } pub fn extend_line_up(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Backward, Granularity::Line, count); } pub fn extend_line_down(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .extend_selection(Direction::Forward, Granularity::Line, count); } pub fn split_selection_on_newline(view: &mut View, _count: usize) { - let text = &view.state.doc.slice(..); + let text = &view.doc.text().slice(..); // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); // TODO: use a transaction - view.state.selection = selection::split_on_matches(text, view.state.selection(), ®EX) + view.doc.state.selection = selection::split_on_matches(text, view.doc.state.selection(), ®EX) } pub fn select_line(view: &mut View, _count: usize) { // TODO: count - let pos = view.state.selection().primary(); - let text = view.state.doc(); + let pos = view.doc.state.selection().primary(); + let text = view.doc.text(); let line = text.char_to_line(pos.head); let start = text.line_to_char(line); let end = text.line_to_char(line + 1).saturating_sub(1); // TODO: use a transaction - view.state.selection = Selection::single(start, end); + view.doc.state.selection = Selection::single(start, end); } pub fn delete_selection(view: &mut View, _count: usize) { - let transaction = - Transaction::change_by_selection(&view.state, |range| (range.from(), range.to() + 1, None)); - transaction.apply(&mut view.state); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + (range.from(), range.to() + 1, None) + }); + view.doc.apply(&transaction); append_changes_to_history(view); } @@ -263,21 +273,23 @@ pub fn change_selection(view: &mut View, count: usize) { } pub fn collapse_selection(view: &mut View, _count: usize) { - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.head, range.head)) } pub fn flip_selections(view: &mut View, _count: usize) { - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.head, range.anchor)) } fn enter_insert_mode(view: &mut View) { - view.state.mode = Mode::Insert; + view.doc.mode = Mode::Insert; append_changes_to_history(view); } @@ -285,7 +297,8 @@ fn enter_insert_mode(view: &mut View) { pub fn insert_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.state.selection = view + view.doc.state.selection = view + .doc .state .selection .transform(|range| Range::new(range.to(), range.from())) @@ -294,11 +307,11 @@ pub fn insert_mode(view: &mut View, _count: usize) { // inserts at the end of each selection pub fn append_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.state.restore_cursor = true; + view.doc.restore_cursor = true; // TODO: as transaction - let text = &view.state.doc.slice(..); - view.state.selection = view.state.selection.transform(|range| { + let text = &view.doc.text().slice(..); + view.doc.state.selection = view.doc.state.selection.transform(|range| { // TODO: to() + next char Range::new( range.from(), @@ -346,13 +359,13 @@ pub fn append_to_line(view: &mut View, count: usize) { pub fn open_below(view: &mut View, _count: usize) { enter_insert_mode(view); - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions: Vec<_> = lines .into_iter() .map(|index| { // adjust all positions to the end of the line/start of the next one. - view.state.doc.line_to_char(index + 1) + view.doc.text().line_to_char(index + 1) }) .collect(); @@ -373,63 +386,63 @@ pub fn open_below(view: &mut View, _count: usize) { 0, ); - let transaction = Transaction::change(&view.state, changes).with_selection(selection); + let transaction = Transaction::change(&view.doc.state, changes).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } // O inserts a new line before each line with a selection fn append_changes_to_history(view: &mut View) { - if view.state.changes.is_empty() { + if view.doc.changes.is_empty() { return; } - let new_changeset = ChangeSet::new(view.state.doc()); - let changes = std::mem::replace(&mut view.state.changes, new_changeset); + let new_changeset = ChangeSet::new(view.doc.text()); + let changes = std::mem::replace(&mut view.doc.changes, new_changeset); // Instead of doing this messy merge we could always commit, and based on transaction // annotations either add a new layer or compose into the previous one. - let transaction = Transaction::from(changes).with_selection(view.state.selection().clone()); + let transaction = Transaction::from(changes).with_selection(view.doc.state.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too - view.state.version += 1; + view.doc.version += 1; // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let (doc, selection) = view.state.old_state.take().unwrap(); + let (doc, selection) = view.doc.old_state.take().unwrap(); let mut old_state = State::new(doc); old_state.selection = selection; // TODO: take transaction by value? - view.history.commit_revision(&transaction, &old_state); + view.doc.history.commit_revision(&transaction, &old_state); // HAXX - view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone())); + view.doc.old_state = Some((view.doc.text().clone(), view.doc.state.selection.clone())); } pub fn normal_mode(view: &mut View, _count: usize) { - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; append_changes_to_history(view); // if leaving append mode, move cursor back by 1 - if view.state.restore_cursor { - let text = &view.state.doc.slice(..); - view.state.selection = view.state.selection.transform(|range| { + if view.doc.restore_cursor { + let text = &view.doc.text().slice(..); + view.doc.state.selection = view.doc.state.selection.transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); - view.state.restore_cursor = false; + view.doc.restore_cursor = false; } } pub fn goto_mode(view: &mut View, _count: usize) { - view.state.mode = Mode::Goto; + view.doc.mode = Mode::Goto; } // NOTE: Transactions in this module get appended to history when we switch back to normal mode. @@ -438,9 +451,9 @@ pub mod insert { // TODO: insert means add text just before cursor, on exit we should be on the last letter. pub fn insert_char(view: &mut View, c: char) { let c = Tendril::from_char(c); - let transaction = Transaction::insert(&view.state, c); + let transaction = Transaction::insert(&view.doc.state, c); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn insert_tab(view: &mut View, _count: usize) { @@ -448,41 +461,44 @@ pub fn insert_tab(view: &mut View, _count: usize) { } pub fn insert_newline(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.state, |range| { - let indent_level = - helix_core::indent::suggested_indent_for_pos(&view.state, range.head); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + let indent_level = helix_core::indent::suggested_indent_for_pos( + view.doc.syntax.as_ref(), + &view.doc.state, + range.head, + ); let indent = " ".repeat(TAB_WIDTH).repeat(indent_level); let mut text = String::with_capacity(1 + indent.len()); text.push('\n'); text.push_str(&indent); (range.head, range.head, Some(text.into())) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } // TODO: handle indent-aware delete pub fn delete_char_backward(view: &mut View, count: usize) { - let text = &view.state.doc.slice(..); - let transaction = Transaction::change_by_selection(&view.state, |range| { + let text = &view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { ( graphemes::nth_prev_grapheme_boundary(text, range.head, count), range.head, None, ) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn delete_char_forward(view: &mut View, count: usize) { - let text = &view.state.doc.slice(..); - let transaction = Transaction::change_by_selection(&view.state, |range| { + let text = &view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&view.doc.state, |range| { ( range.head, graphemes::nth_next_grapheme_boundary(text, range.head, count), None, ) }); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } } @@ -493,13 +509,13 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo pub fn undo(view: &mut View, _count: usize) { - view.history.undo(&mut view.state); + view.doc.history.undo(&mut view.doc.state); // TODO: each command could simply return a Option, then the higher level handles storing it? } pub fn redo(view: &mut View, _count: usize) { - view.history.redo(&mut view.state); + view.doc.history.redo(&mut view.doc.state); } // Yank / Paste @@ -507,9 +523,10 @@ pub fn redo(view: &mut View, _count: usize) { pub fn yank(view: &mut View, _count: usize) { // TODO: should selections be made end inclusive? let values = view + .doc .state .selection() - .fragments(&view.state.doc().slice(..)) + .fragments(&view.doc.text().slice(..)) .map(|cow| cow.into_owned()) .collect(); @@ -550,18 +567,18 @@ pub fn paste(view: &mut View, _count: usize) { let transaction = if linewise { // paste on the next line // TODO: can simply take a range + modifier and compute the right pos without ifs - let text = view.state.doc(); - Transaction::change_by_selection(&view.state, |range| { + let text = view.doc.text(); + Transaction::change_by_selection(&view.doc.state, |range| { let line_end = text.line_to_char(text.char_to_line(range.head) + 1); (line_end, line_end, Some(values.next().unwrap())) }) } else { - Transaction::change_by_selection(&view.state, |range| { + Transaction::change_by_selection(&view.doc.state, |range| { (range.head + 1, range.head + 1, Some(values.next().unwrap())) }) }; - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } } @@ -570,9 +587,9 @@ fn get_lines(view: &View) -> Vec { let mut lines = Vec::new(); // Get all line numbers - for range in view.state.selection.ranges() { - let start = view.state.doc.char_to_line(range.from()); - let end = view.state.doc.char_to_line(range.to()); + for range in view.doc.state.selection.ranges() { + let start = view.doc.text().char_to_line(range.from()); + let end = view.doc.text().char_to_line(range.to()); for line in start..=end { lines.push(line) @@ -590,13 +607,13 @@ pub fn indent(view: &mut View, _count: usize) { let indent = Tendril::from(" ".repeat(TAB_WIDTH)); let transaction = Transaction::change( - &view.state, + &view.doc.state, lines.into_iter().map(|line| { - let pos = view.state.doc.line_to_char(line); + let pos = view.doc.text().line_to_char(line); (pos, pos, Some(indent.clone())) }), ); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } @@ -605,7 +622,7 @@ pub fn unindent(view: &mut View, _count: usize) { let mut changes = Vec::with_capacity(lines.len()); for line_idx in lines { - let line = view.state.doc.line(line_idx); + let line = view.doc.text().line(line_idx); let mut width = 0; for ch in line.chars() { @@ -621,14 +638,14 @@ pub fn unindent(view: &mut View, _count: usize) { } if width > 0 { - let start = view.state.doc.line_to_char(line_idx); + let start = view.doc.text().line_to_char(line_idx); changes.push((start, start + width, None)) } } - let transaction = Transaction::change(&view.state, changes.into_iter()); + let transaction = Transaction::change(&view.doc.state, changes.into_iter()); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); append_changes_to_history(view); } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs new file mode 100644 index 000000000..c4b9d0819 --- /dev/null +++ b/helix-view/src/document.rs @@ -0,0 +1,157 @@ +use anyhow::Error; +use std::path::PathBuf; + +use helix_core::{ + syntax::LOADER, ChangeSet, Diagnostic, History, Position, Range, Rope, RopeSlice, Selection, + State, Syntax, Transaction, +}; + +#[derive(Copy, Clone, PartialEq, Eq, Hash)] +pub enum Mode { + Normal, + Insert, + Goto, +} + +pub struct Document { + pub state: State, // rope + selection + /// File path on disk. + pub path: Option, + + /// Current editing mode. + pub mode: Mode, + pub restore_cursor: bool, + + /// Tree-sitter AST tree + pub syntax: Option, + + /// Pending changes since last history commit. + pub changes: ChangeSet, + pub history: History, + pub version: i64, // should be usize? + pub old_state: Option<(Rope, Selection)>, + + pub diagnostics: Vec, +} + +/// Like std::mem::replace() except it allows the replacement value to be mapped from the +/// original value. +fn take_with(mut_ref: &mut T, closure: F) +where + F: FnOnce(T) -> T, +{ + use std::{panic, ptr}; + + unsafe { + let old_t = ptr::read(mut_ref); + let new_t = panic::catch_unwind(panic::AssertUnwindSafe(|| closure(old_t))) + .unwrap_or_else(|_| ::std::process::abort()); + ptr::write(mut_ref, new_t); + } +} + +use url::Url; + +impl Document { + fn new(state: State) -> Self { + let changes = ChangeSet::new(&state.doc); + let old_state = Some((state.doc.clone(), Selection::single(0, 0))); + + Self { + path: None, + state, + mode: Mode::Normal, + restore_cursor: false, + syntax: None, + changes, + old_state, + diagnostics: Vec::new(), + version: 0, + history: History::default(), + } + } + + // TODO: passing scopes here is awkward + pub fn load(path: PathBuf, scopes: &[String]) -> Result { + use std::{env, fs::File, io::BufReader}; + let _current_dir = env::current_dir()?; + + let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; + + // TODO: create if not found + + let mut doc = Self::new(State::new(doc)); + + if let Some(language_config) = LOADER.language_config_for_file_name(path.as_path()) { + let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); + // TODO: config.configure(scopes) is now delayed, is that ok? + + let syntax = Syntax::new(&doc.state.doc, highlight_config.clone()); + + doc.syntax = Some(syntax); + }; + + // canonicalize path to absolute value + doc.path = Some(std::fs::canonicalize(path)?); + + Ok(doc) + } + + pub fn set_language(&mut self, scope: &str, scopes: &[String]) { + if let Some(language_config) = LOADER.language_config_for_scope(scope) { + let highlight_config = language_config.highlight_config(scopes).unwrap().unwrap(); + // TODO: config.configure(scopes) is now delayed, is that ok? + + let syntax = Syntax::new(&self.state.doc, highlight_config.clone()); + + self.syntax = Some(syntax); + }; + } + + // TODO: needs to run on undo/redo + pub fn apply(&mut self, transaction: &Transaction) -> bool { + let old_doc = self.text().clone(); + + let success = transaction.apply(&mut self.state); + + if !transaction.changes().is_empty() { + // Compose this transaction with the previous one + take_with(&mut self.changes, |changes| { + changes.compose(transaction.changes().clone()).unwrap() + }); + + // update tree-sitter syntax tree + if let Some(syntax) = &mut self.syntax { + // TODO: no unwrap + syntax + .update(&old_doc, &self.state.doc, transaction.changes()) + .unwrap(); + } + + // TODO: map state.diagnostics over changes::map_pos too + } + success + } + + #[inline] + pub fn mode(&self) -> Mode { + self.mode + } + + #[inline] + pub fn path(&self) -> Option<&PathBuf> { + self.path.as_ref() + } + + pub fn url(&self) -> Option { + self.path().map(|path| Url::from_file_path(path).unwrap()) + } + + pub fn text(&self) -> &Rope { + &self.state.doc + } + + // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { + // self.state.doc.slice + // } +} diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 61abd4829..02199255c 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -1,6 +1,5 @@ use crate::theme::Theme; -use crate::View; -use helix_core::State; +use crate::{Document, View}; use std::path::PathBuf; @@ -27,8 +26,8 @@ pub fn new() -> Self { pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { let pos = self.views.len(); - let state = State::load(path, self.theme.scopes())?; - self.views.push(View::new(state, size)?); + let doc = Document::load(path, self.theme.scopes())?; + self.views.push(View::new(doc, size)?); self.focus = pos; Ok(()) } diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 82bdbe21f..347e7d779 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -1,4 +1,5 @@ use crate::commands::{self, Command}; +use crate::document::Mode; use helix_core::{hashmap, state}; use std::collections::HashMap; @@ -88,7 +89,7 @@ // TODO: could be trie based pub type Keymap = HashMap, Command>; -pub type Keymaps = HashMap; +pub type Keymaps = HashMap; macro_rules! key { ($ch:expr) => { @@ -128,7 +129,7 @@ macro_rules! ctrl { pub fn default() -> Keymaps { hashmap!( - state::Mode::Normal => + Mode::Normal => // as long as you cast the first item, rust is able to infer the other cases hashmap!( vec![key!('h')] => commands::move_char_left as Command, @@ -179,7 +180,7 @@ pub fn default() -> Keymaps { vec![ctrl!('u')] => commands::half_page_up, vec![ctrl!('d')] => commands::half_page_down, ), - state::Mode::Insert => hashmap!( + Mode::Insert => hashmap!( vec![Key { code: KeyCode::Esc, modifiers: Modifiers::NONE @@ -201,7 +202,7 @@ pub fn default() -> Keymaps { modifiers: Modifiers::NONE }] => commands::insert::insert_tab, ), - state::Mode::Goto => hashmap!( + Mode::Goto => hashmap!( vec![Key { code: KeyCode::Esc, modifiers: Modifiers::NONE diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs index 9abe8a1aa..3b9237441 100644 --- a/helix-view/src/lib.rs +++ b/helix-view/src/lib.rs @@ -1,10 +1,12 @@ pub mod commands; +pub mod document; pub mod editor; pub mod keymap; pub mod prompt; pub mod theme; pub mod view; +pub use document::Document; pub use editor::Editor; pub use theme::Theme; pub use view::View; diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index 817714c8e..4cf6a2ee1 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -2,10 +2,11 @@ use std::borrow::Cow; +use crate::Document; use helix_core::{ graphemes::{grapheme_width, RopeGraphemes}, indent::TAB_WIDTH, - History, Position, RopeSlice, State, + Position, RopeSlice, }; use tui::layout::Rect; @@ -14,29 +15,25 @@ // TODO: view should be View { doc: Document(state, history,..) } // since we can have multiple views into the same file pub struct View { - pub state: State, + pub doc: Document, pub first_line: usize, pub size: (u16, u16), - - // TODO: Doc fields - pub history: History, } impl View { - pub fn new(state: State, size: (u16, u16)) -> Result { + pub fn new(doc: Document, size: (u16, u16)) -> Result { let view = Self { - state, + doc, first_line: 0, size, - history: History::default(), }; Ok(view) } pub fn ensure_cursor_in_view(&mut self) { - let cursor = self.state.selection().cursor(); - let line = self.state.doc().char_to_line(cursor); + let cursor = self.doc.state.selection().cursor(); + let line = self.doc.text().char_to_line(cursor); let document_end = self.first_line + (self.size.1 as usize).saturating_sub(2); // TODO: side scroll @@ -56,7 +53,7 @@ pub fn last_line(&self) -> usize { let viewport = Rect::new(6, 0, self.size.0, self.size.1 - 2); // - 2 for statusline and prompt std::cmp::min( self.first_line + (viewport.height as usize), - self.state.doc().len_lines() - 1, + self.doc.text().len_lines() - 1, ) } @@ -88,4 +85,25 @@ pub fn screen_coords_at_pos(&self, text: &RopeSlice, pos: usize) -> Option(&self, text: &RopeSlice, start: usize, end: usize, fun: F) + where + F: Fn(usize, usize), + { + let start = self.screen_coords_at_pos(text, start); + let end = self.screen_coords_at_pos(text, end); + + match (start, end) { + // fully on screen + (Some(start), Some(end)) => { + // we want to calculate ends of lines for each char.. + } + // from start to end of screen + (Some(start), None) => {} + // from start of screen to end + (None, Some(end)) => {} + // not on screen + (None, None) => return, + } + } }