From 64b5b23315f12125a2c5b2f810fe5ac285bdfa79 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Mon, 19 Oct 2020 17:18:03 +0900 Subject: Move theme from view to editor, support multiple views in editor. --- helix-core/src/state.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'helix-core/src/state.rs') diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 1b0a67ae..35e20aef 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -23,7 +23,7 @@ pub struct State { pub restore_cursor: bool, - // + // TODO: move these to a Document wrapper? pub syntax: Option, /// Pending changes since last history commit. pub changes: ChangeSet, -- cgit v1.2.3-70-g09d2 From f9bfba4d96f80eb41beb91702558f6f165a0e70f Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Tue, 20 Oct 2020 13:58:34 +0900 Subject: Reroute LSP notification events into the main app event loop. --- Cargo.lock | 1 + helix-core/src/diagnostic.rs | 1 + helix-core/src/lib.rs | 2 + helix-core/src/state.rs | 10 +- helix-lsp/src/lib.rs | 33 +++-- helix-lsp/src/transport.rs | 14 +-- helix-term/Cargo.toml | 2 + helix-term/src/application.rs | 281 ++++++++++++++++++++++++------------------ helix-term/src/main.rs | 12 +- helix-view/src/keymap.rs | 4 +- helix-view/src/view.rs | 2 +- 11 files changed, 207 insertions(+), 155 deletions(-) create mode 100644 helix-core/src/diagnostic.rs (limited to 'helix-core/src/state.rs') diff --git a/Cargo.lock b/Cargo.lock index c4beee76..2e329fd1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -472,6 +472,7 @@ dependencies = [ "anyhow", "clap", "crossterm", + "futures-util", "helix-core", "helix-lsp", "helix-view", diff --git a/helix-core/src/diagnostic.rs b/helix-core/src/diagnostic.rs new file mode 100644 index 00000000..aee648aa --- /dev/null +++ b/helix-core/src/diagnostic.rs @@ -0,0 +1 @@ +pub struct Diagnostic {} diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 62d23a10..8458c36f 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -1,4 +1,5 @@ #![allow(unused)] +mod diagnostic; pub mod graphemes; mod history; pub mod indent; @@ -22,6 +23,7 @@ pub use selection::Range; pub use selection::Selection; pub use syntax::Syntax; +pub use diagnostic::Diagnostic; pub use history::History; pub use state::State; diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 35e20aef..0f94f696 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -1,6 +1,6 @@ use crate::graphemes::{nth_next_grapheme_boundary, nth_prev_grapheme_boundary, RopeGraphemes}; use crate::syntax::LOADER; -use crate::{ChangeSet, Position, Range, Rope, RopeSlice, Selection, Syntax}; +use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, Syntax}; use anyhow::Error; use std::path::PathBuf; @@ -28,6 +28,8 @@ pub struct State { /// Pending changes since last history commit. pub changes: ChangeSet, pub old_state: Option<(Rope, Selection)>, + + pub diagnostics: Vec, } #[derive(Copy, Clone, PartialEq, Eq)] @@ -58,12 +60,13 @@ impl State { syntax: None, changes, old_state, + diagnostics: Vec::new(), } } // TODO: passing scopes here is awkward pub fn load(path: PathBuf, scopes: &[String]) -> Result { - use std::{env, fs::File, io::BufReader, path::PathBuf}; + use std::{env, fs::File, io::BufReader}; let _current_dir = env::current_dir()?; let doc = Rope::from_reader(BufReader::new(File::open(path.clone())?))?; @@ -81,7 +84,8 @@ impl State { state.syntax = Some(syntax); }; - state.path = Some(path); + // canonicalize path to absolute value + state.path = Some(std::fs::canonicalize(path)?); Ok(state) } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 41b3fdb2..3598a594 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -2,7 +2,7 @@ mod transport; use transport::{Payload, Transport}; -use std::collections::HashMap; +// use std::collections::HashMap; use jsonrpc_core as jsonrpc; use lsp_types as lsp; @@ -32,10 +32,12 @@ enum Message { } #[derive(Debug, PartialEq, Clone)] -enum Notification {} +pub enum Notification { + PublishDiagnostics(lsp::PublishDiagnosticsParams), +} impl Notification { - pub fn parse(method: &str, params: jsonrpc::Params) { + pub fn parse(method: &str, params: jsonrpc::Params) -> Notification { use lsp::notification::Notification as _; match method { @@ -44,11 +46,10 @@ impl Notification { .parse() .expect("Failed to parse PublishDiagnostics params"); - println!("{:?}", params); - // TODO: need to loop over diagnostics and distinguish them by URI + Notification::PublishDiagnostics(params) } - _ => println!("unhandled notification: {}", method), + _ => unimplemented!("unhandled notification: {}", method), } } } @@ -58,13 +59,13 @@ pub struct Client { stderr: BufReader, outgoing: Sender, - incoming: Receiver, + pub incoming: Receiver, pub request_counter: u64, capabilities: Option, // TODO: handle PublishDiagnostics Version - diagnostics: HashMap>, + // diagnostics: HashMap>, } impl Client { @@ -95,7 +96,7 @@ impl Client { request_counter: 0, capabilities: None, - diagnostics: HashMap::new(), + // diagnostics: HashMap::new(), } } @@ -226,10 +227,7 @@ impl Client { ) -> anyhow::Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { - uri: lsp::Url::from_file_path( - std::fs::canonicalize(state.path.as_ref().unwrap()).unwrap(), - ) - .unwrap(), + uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now version: 0, text: String::from(&state.doc), @@ -243,11 +241,12 @@ impl Client { &mut self, state: &helix_core::State, ) -> anyhow::Result<()> { - self.notify::(lsp::DidSaveTextDocumentParams { - text_document: lsp::TextDocumentIdentifier::new( - lsp::Url::from_file_path(state.path.as_ref().unwrap()).unwrap(), + self.notify::(lsp::DidChangeTextDocumentParams { + text_document: lsp::VersionedTextDocumentIdentifier::new( + lsp::Url::from_file_path(state.path().unwrap()).unwrap(), + 0, // TODO: version ), - text: None, // TODO? + content_changes: vec![], // TODO: }) .await } diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index c44ffa91..8915a925 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -24,7 +24,7 @@ pub(crate) enum Payload { } pub(crate) struct Transport { - incoming: Sender, + incoming: Sender, // TODO Notification | Call outgoing: Receiver, pending_requests: HashMap>>, @@ -39,7 +39,7 @@ impl Transport { ex: &Executor, reader: BufReader, writer: BufWriter, - ) -> (Receiver, Sender) { + ) -> (Receiver, Sender) { let (incoming, rx) = smol::channel::unbounded(); let (tx, outgoing) = smol::channel::unbounded(); @@ -111,7 +111,7 @@ impl Transport { } pub async fn send(&mut self, request: String) -> anyhow::Result<()> { - println!("-> {}", request); + // println!("-> {}", request); // send the headers self.writer @@ -132,11 +132,11 @@ impl Transport { Message::Notification(jsonrpc::Notification { method, params, .. }) => { let notification = Notification::parse(&method, params); - println!("<- {} {:?}", method, notification); - // dispatch + // println!("<- {} {:?}", method, notification); + self.incoming.send(notification).await?; } Message::Call(call) => { - println!("<- {:?}", call); + // println!("<- {:?}", call); // dispatch } _ => unreachable!(), @@ -147,7 +147,7 @@ impl Transport { pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { match output { jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { - println!("<- {}", result); + // println!("<- {}", result); let tx = self .pending_requests diff --git a/helix-term/Cargo.toml b/helix-term/Cargo.toml index aa91a095..db1edee9 100644 --- a/helix-term/Cargo.toml +++ b/helix-term/Cargo.toml @@ -24,3 +24,5 @@ num_cpus = "1.13" tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"] } crossterm = { version = "0.18", features = ["event-stream"] } clap = { version = "3.0.0-beta.2 ", default-features = false, features = ["std", "cargo"] } + +futures-util = "0.3" diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index d65e7e2e..3d5b3459 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,6 +1,11 @@ use clap::ArgMatches as Args; use helix_core::{indent::TAB_WIDTH, state::Mode, syntax::HighlightEvent, Position, Range, State}; -use helix_view::{commands, keymap, prompt::Prompt, Editor, Theme, View}; +use helix_view::{ + commands, + keymap::{self, Keymaps}, + prompt::Prompt, + Editor, Theme, View, +}; use std::{ borrow::Cow, @@ -31,14 +36,16 @@ const OFFSET: u16 = 6; // 5 linenr + 1 gutter type Terminal = tui::Terminal>; -static EX: smol::Executor = smol::Executor::new(); - const BASE_WIDTH: u16 = 30; -pub struct Application { +pub struct Application<'a> { editor: Editor, prompt: Option, terminal: Renderer, + + keymap: Keymaps, + executor: &'a smol::Executor<'a>, + lsp: helix_lsp::Client, } struct Renderer { @@ -235,7 +242,7 @@ impl Renderer { .set_string(1, self.size.1 - 2, mode, self.text_color); } - pub fn render_prompt(&mut self, view: &View, prompt: &Prompt) { + pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) { // completion if !prompt.completion.is_empty() { // TODO: find out better way of clearing individual lines of the screen @@ -254,7 +261,7 @@ impl Renderer { } self.surface.set_style( Rect::new(0, self.size.1 - col_height - 2, self.size.0, col_height), - view.theme.get("ui.statusline"), + theme.get("ui.statusline"), ); for (i, command) in prompt.completion.iter().enumerate() { let color = if prompt.completion_selection_index.is_some() @@ -330,8 +337,8 @@ impl Renderer { } } -impl Application { - pub fn new(mut args: Args) -> Result { +impl<'a> Application<'a> { + pub fn new(mut args: Args, executor: &'a smol::Executor<'a>) -> Result { let terminal = Renderer::new()?; let mut editor = Editor::new(); @@ -339,11 +346,18 @@ impl Application { editor.open(file, terminal.size)?; } + let lsp = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); + let mut app = Self { editor, terminal, // TODO; move to state prompt: None, + + // + keymap: keymap::default(), + executor, + lsp, }; Ok(app) @@ -361,7 +375,7 @@ impl Application { if prompt.should_close { self.prompt = None; } else { - self.terminal.render_prompt(view, prompt); + self.terminal.render_prompt(view, prompt, theme_ref); } } } @@ -375,7 +389,13 @@ impl Application { pub async fn event_loop(&mut self) { let mut reader = EventStream::new(); - let keymap = keymap::default(); + + // initialize lsp + let res = self.lsp.initialize().await; + let res = self + .lsp + .text_document_did_open(&self.editor.view().unwrap().state) + .await; self.render(); @@ -384,126 +404,149 @@ impl Application { break; } - // Handle key events - match reader.next().await { - Some(Ok(Event::Resize(width, height))) => { - self.terminal.resize(width, height); + use futures_util::{select, FutureExt}; + select! { + event = reader.next().fuse() => { + self.handle_terminal_events(event).await + } + notification = self.lsp.incoming.next().fuse() => { + self.handle_lsp_notification(notification).await + } + } + } + } - // TODO: simplistic ensure cursor in view for now - // TODO: loop over views - if let Some(view) = self.editor.view_mut() { - view.size = self.terminal.size; - view.ensure_cursor_in_view() - }; + pub async fn handle_terminal_events( + &mut self, + event: Option>, + ) { + // Handle key events + match event { + Some(Ok(Event::Resize(width, height))) => { + self.terminal.resize(width, height); + + // TODO: simplistic ensure cursor in view for now + // TODO: loop over views + if let Some(view) = self.editor.view_mut() { + view.size = self.terminal.size; + view.ensure_cursor_in_view() + }; + + self.render(); + } + Some(Ok(Event::Key(event))) => { + // if there's a prompt, it takes priority + if let Some(prompt) = &mut self.prompt { + self.prompt + .as_mut() + .unwrap() + .handle_input(event, &mut self.editor); self.render(); - } - Some(Ok(Event::Key(event))) => { - // if there's a prompt, it takes priority - if let Some(prompt) = &mut self.prompt { - self.prompt - .as_mut() - .unwrap() - .handle_input(event, &mut self.editor); - - self.render(); - } else if let Some(view) = self.editor.view_mut() { - let keys = vec![event]; - // TODO: sequences (`gg`) - // TODO: handle count other than 1 - match view.state.mode() { - Mode::Insert => { - if let Some(command) = keymap[&Mode::Insert].get(&keys) { - command(view, 1); - } else if let KeyEvent { - code: KeyCode::Char(c), - .. - } = event - { - commands::insert::insert_char(view, c); - } - view.ensure_cursor_in_view(); + } else if let Some(view) = self.editor.view_mut() { + let keys = vec![event]; + // TODO: sequences (`gg`) + // TODO: handle count other than 1 + match view.state.mode() { + Mode::Insert => { + if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { + command(view, 1); + } else if let KeyEvent { + code: KeyCode::Char(c), + .. + } = event + { + commands::insert::insert_char(view, c); } - Mode::Normal => { - if let &[KeyEvent { - code: KeyCode::Char(':'), - .. - }] = keys.as_slice() - { - let prompt = Prompt::new( - ":".to_owned(), - |_input: &str| { - // TODO: i need this duplicate list right now to avoid borrow checker issues - let command_list = vec![ - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - String::from("q"), - String::from("aaa"), - String::from("bbb"), - String::from("ccc"), - String::from("ddd"), - String::from("eee"), - ]; - command_list - .into_iter() - .filter(|command| command.contains(_input)) - .collect() - }, // completion - |editor: &mut Editor, input: &str| match input { - "q" => editor.should_close = true, - _ => (), - }, - ); - - self.prompt = Some(prompt); - - // HAXX: special casing for command mode - } else if let Some(command) = keymap[&Mode::Normal].get(&keys) { - command(view, 1); - - // TODO: simplistic ensure cursor in view for now - view.ensure_cursor_in_view(); - } + view.ensure_cursor_in_view(); + } + Mode::Normal => { + if let &[KeyEvent { + code: KeyCode::Char(':'), + .. + }] = keys.as_slice() + { + let prompt = Prompt::new( + ":".to_owned(), + |_input: &str| { + // TODO: i need this duplicate list right now to avoid borrow checker issues + let command_list = vec![ + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + String::from("q"), + String::from("aaa"), + String::from("bbb"), + String::from("ccc"), + String::from("ddd"), + String::from("eee"), + ]; + command_list + .into_iter() + .filter(|command| command.contains(_input)) + .collect() + }, // completion + |editor: &mut Editor, input: &str| match input { + "q" => editor.should_close = true, + _ => (), + }, + ); + + self.prompt = Some(prompt); + + // HAXX: special casing for command mode + } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) { + command(view, 1); + + // TODO: simplistic ensure cursor in view for now + view.ensure_cursor_in_view(); } - mode => { - if let Some(command) = keymap[&mode].get(&keys) { - command(view, 1); + } + mode => { + if let Some(command) = self.keymap[&mode].get(&keys) { + command(view, 1); - // TODO: simplistic ensure cursor in view for now - view.ensure_cursor_in_view(); - } + // TODO: simplistic ensure cursor in view for now + view.ensure_cursor_in_view(); } } - self.render(); } + self.render(); } - Some(Ok(Event::Mouse(_))) => (), // unhandled - Some(Err(x)) => panic!(x), - None => break, } + Some(Ok(Event::Mouse(_))) => (), // unhandled + Some(Err(x)) => panic!(x), + None => panic!(), + }; + } + + pub async fn handle_lsp_notification(&mut self, notification: Option) { + use helix_lsp::Notification; + match notification { + Some(Notification::PublishDiagnostics(params)) => unimplemented!("{:?}", params), + _ => unreachable!(), } } diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index 07f1ffff..de3a0175 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -26,15 +26,15 @@ fn main() -> Result<(), Error> { std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>()))); } - let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); + // let mut lsp = helix_lsp::Client::start(&EX, "rust-analyzer", &[]); smol::block_on(async { - let res = lsp.initialize().await; - let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); - let res = lsp.text_document_did_open(&state).await; - loop {} + // let res = lsp.initialize().await; + // let state = helix_core::State::load("test.rs".into(), &[]).unwrap(); + // let res = lsp.text_document_did_open(&state).await; + // loop {} - // Application::new(args).unwrap().run().await; + Application::new(args, &EX).unwrap().run().await; }); Ok(()) diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 69e6cabb..82bdbe21 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -87,8 +87,8 @@ use std::collections::HashMap; pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers}; // TODO: could be trie based -type Keymap = HashMap, Command>; -type Keymaps = HashMap; +pub type Keymap = HashMap, Command>; +pub type Keymaps = HashMap; macro_rules! key { ($ch:expr) => { diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index d2a7d556..817714c8 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -18,7 +18,7 @@ pub struct View { pub first_line: usize, pub size: (u16, u16), - // TODO: Doc<> fields + // TODO: Doc fields pub history: History, } -- cgit v1.2.3-70-g09d2 From ef5e5f9296d27d11ddfddf6d1c7daf93f9464ddb Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Wed, 21 Oct 2020 13:47:20 +0900 Subject: state.version tracking --- helix-core/src/state.rs | 2 ++ helix-lsp/src/lib.rs | 32 +++++++++++++++++++++----------- helix-term/src/application.rs | 33 +++++++-------------------------- helix-view/src/commands.rs | 7 ++++++- 4 files changed, 36 insertions(+), 38 deletions(-) (limited to 'helix-core/src/state.rs') diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 0f94f696..75e5cd40 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -29,6 +29,7 @@ pub struct State { pub changes: ChangeSet, pub old_state: Option<(Rope, Selection)>, + pub version: i64, pub diagnostics: Vec, } @@ -61,6 +62,7 @@ impl State { changes, old_state, diagnostics: Vec::new(), + version: 0, } } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 939f9927..f8c73902 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -2,6 +2,8 @@ mod transport; use transport::{Payload, Transport}; +use helix_core::{State, Transaction}; + // use std::collections::HashMap; use jsonrpc_core as jsonrpc; @@ -13,14 +15,24 @@ use serde::{Deserialize, Serialize}; pub use lsp::Position; pub use lsp::Url; -use smol::prelude::*; use smol::{ channel::{Receiver, Sender}, io::{BufReader, BufWriter}, + // prelude::*, process::{Child, ChildStderr, Command, Stdio}, Executor, }; +pub mod util { + use super::*; + + pub fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: lsp::Position) -> usize { + let line = doc.line_to_char(pos.line as usize); + let line_start = doc.char_to_utf16_cu(line); + doc.utf16_cu_to_char(pos.character as usize + line_start) + } +} + /// A type representing all possible values sent from the server to the client. #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] #[serde(deny_unknown_fields)] @@ -58,7 +70,7 @@ impl Notification { } pub struct Client { - process: Child, + _process: Child, stderr: BufReader, outgoing: Sender, @@ -90,7 +102,7 @@ impl Client { let (incoming, outgoing) = Transport::start(ex, reader, writer); Client { - process, + _process: process, stderr, outgoing, @@ -224,15 +236,12 @@ impl Client { // Text document // ------------------------------------------------------------------------------------------- - pub async fn text_document_did_open( - &mut self, - state: &helix_core::State, - ) -> anyhow::Result<()> { + pub async fn text_document_did_open(&mut self, state: &State) -> anyhow::Result<()> { self.notify::(lsp::DidOpenTextDocumentParams { text_document: lsp::TextDocumentItem { uri: lsp::Url::from_file_path(state.path().unwrap()).unwrap(), language_id: "rust".to_string(), // TODO: hardcoded for now - version: 0, + version: state.version, text: String::from(&state.doc), }, }) @@ -242,14 +251,15 @@ impl Client { // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, - state: &helix_core::State, + state: &State, + transaction: &Transaction, ) -> anyhow::Result<()> { self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( lsp::Url::from_file_path(state.path().unwrap()).unwrap(), - 0, // TODO: version + state.version, ), - content_changes: vec![], // TODO: + content_changes: vec![], // TODO: probably need old_state here too? }) .await } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 5551e26f..a1a6b9ea 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -568,23 +568,12 @@ impl<'a> Application<'a> { use helix_lsp::Notification; match notification { Some(Notification::PublishDiagnostics(params)) => { - let view = self.editor.views.iter_mut().find(|view| { - let path = view - .state - .path - .as_ref() - .map(|path| helix_lsp::Url::from_file_path(path).unwrap()); - - eprintln!("{:?} {} {}", path, params.uri, params.diagnostics.len()); - // HAXX - path == Some(params.uri.clone()) - }); - - fn lsp_pos_to_pos(doc: &helix_core::RopeSlice, pos: helix_lsp::Position) -> usize { - let line = doc.line_to_char(pos.line as usize); - let line_start = doc.char_to_utf16_cu(line); - doc.utf16_cu_to_char(pos.character as usize + line_start) - } + let path = Some(params.uri.to_file_path().unwrap()); + let view = self + .editor + .views + .iter_mut() + .find(|view| view.state.path == path); if let Some(view) = view { let doc = view.state.doc().slice(..); @@ -592,18 +581,10 @@ impl<'a> Application<'a> { .diagnostics .into_iter() .map(|diagnostic| { + use helix_lsp::util::lsp_pos_to_pos; let start = lsp_pos_to_pos(&doc, diagnostic.range.start); let end = lsp_pos_to_pos(&doc, diagnostic.range.end); - // eprintln!( - // "{:?}-{:?} {}-{} {}", - // diagnostic.range.start, - // diagnostic.range.end, - // start, - // end, - // diagnostic.message - // ); - helix_core::Diagnostic { range: (start, end), line: diagnostic.range.start.line as usize, diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 1d7737f0..e29d070e 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -391,6 +391,12 @@ fn append_changes_to_history(view: &mut View) { // annotations either add a new layer or compose into the previous one. let transaction = Transaction::from(changes).with_selection(view.state.selection().clone()); + // increment document version + // TODO: needs to happen on undo/redo too + view.state.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 mut old_state = State::new(doc); @@ -399,7 +405,6 @@ fn append_changes_to_history(view: &mut View) { // TODO: take transaction by value? view.history.commit_revision(&transaction, &old_state); - // TODO: need to start the state with these vals // HAXX view.state.old_state = Some((view.state.doc().clone(), view.state.selection.clone())); } -- cgit v1.2.3-70-g09d2 From b39849dde1b1277d14dbc4e2e1604e5d020db43d Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Thu, 22 Oct 2020 14:35:07 +0900 Subject: Refactor: Document type as a wrapper around barebones State. --- Cargo.lock | 2 + helix-core/src/indent.rs | 29 +++-- 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, 396 insertions(+), 295 deletions(-) create mode 100644 helix-view/src/document.rs (limited to 'helix-core/src/state.rs') diff --git a/Cargo.lock b/Cargo.lock index 1d7857d5..29a86a36 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 2e1a095e..6b9a1ab1 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 @@ mod test { ", ); - let mut state = State::new(doc); - state.set_language("source.rust", &[]); - - 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); // } + 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(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 75e5cd40..7fd620a5 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -3,34 +3,11 @@ use crate::syntax::LOADER; 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 @@ impl State { &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 02903637..f4826fb4 100644 --- a/helix-core/src/syntax.rs +++ b/helix-core/src/syntax.rs @@ -66,7 +66,7 @@ impl LanguageConfiguration { 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 6f3956aa..9bd8c615 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 @@ impl Transaction { } } + 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 e4956f0b..351c3b0e 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 93e137cb..56413768 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -6,6 +6,7 @@ use crate::{ type Result = core::result::Result; use helix_core::{State, Transaction}; +use helix_view::Document; // use std::collections::HashMap; @@ -190,13 +191,13 @@ impl Client { // 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 @@ impl Client { // 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 @@ impl Client { .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 a1a6b9ea..b9594b7e 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 @@ impl Renderer { 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 @@ impl Renderer { // 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 @@ impl Renderer { let mut visual_x = 0; let mut line = 0u16; let visible_selections: Vec = view + .doc .state .selection() .ranges() @@ -147,10 +149,10 @@ impl Renderer { 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 @@ impl Renderer { // 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 @@ impl Renderer { 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 @@ impl Renderer { } 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 @@ impl Renderer { 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 @@ impl Renderer { 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 @@ impl Renderer { ); } - 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 @@ impl<'a> Application<'a> { 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 @@ impl<'a> Application<'a> { 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 @@ impl<'a> Application<'a> { .editor .views .iter_mut() - .find(|view| view.state.path == path); + .find(|view| view.doc.path == path); if let Some(view) = view { - let doc = view.state.doc().slice(..); + let doc = view.doc.text().slice(..); let diagnostics = params .diagnostics .into_iter() @@ -596,7 +598,7 @@ impl<'a> Application<'a> { }) .collect(); - view.state.diagnostics = diagnostics; + view.doc.diagnostics = diagnostics; self.render(); } diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml index 330ae696..9d53f929 100644 --- a/helix-view/Cargo.toml +++ b/helix-view/Cargo.toml @@ -19,3 +19,4 @@ helix-core = { path = "../helix-core" } tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, features = ["crossterm"], optional = true} crossterm = { version = "0.18", features = ["event-stream"], optional = true} once_cell = "1.4" +url = "2" diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index e29d070e..b5350ff4 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -3,12 +3,13 @@ use helix_core::{ indent::TAB_WIDTH, regex::Regex, register, selection, - state::{Direction, Granularity, Mode, State}, + state::{Direction, Granularity, State}, ChangeSet, Range, Selection, Tendril, Transaction, }; use once_cell::sync::Lazy; use crate::{ + document::Mode, prompt::Prompt, view::{View, PADDING}, }; @@ -19,36 +20,40 @@ pub type Command = fn(view: &mut View, count: usize); pub fn move_char_left(view: &mut View, count: usize) { // TODO: use a transaction - let selection = view - .state - .move_selection(Direction::Backward, Granularity::Character, count); - view.state.selection = selection; + let selection = + view.doc + .state + .move_selection(Direction::Backward, Granularity::Character, count); + view.doc.state.selection = selection; } pub fn move_char_right(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = - view.state + view.doc.state.selection = + view.doc + .state .move_selection(Direction::Forward, Granularity::Character, count); } pub fn move_line_up(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = view - .state - .move_selection(Direction::Backward, Granularity::Line, count); + view.doc.state.selection = + view.doc + .state + .move_selection(Direction::Backward, Granularity::Line, count); } pub fn move_line_down(view: &mut View, count: usize) { // TODO: use a transaction - view.state.selection = view - .state - .move_selection(Direction::Forward, Granularity::Line, count); + view.doc.state.selection = + view.doc + .state + .move_selection(Direction::Forward, Granularity::Line, count); } pub fn move_line_end(view: &mut View, _count: usize) { // TODO: use a transaction - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions = lines .into_iter() @@ -57,89 +62,89 @@ pub fn move_line_end(view: &mut View, _count: usize) { // Line end is pos at the start of next line - 1 // subtract another 1 because the line ends with \n - view.state.doc.line_to_char(index + 1).saturating_sub(2) + view.doc.text().line_to_char(index + 1).saturating_sub(2) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.state).with_selection(selection); + let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn move_line_start(view: &mut View, _count: usize) { - let lines = selection_lines(&view.state); + let lines = selection_lines(&view.doc.state); let positions = lines .into_iter() .map(|index| { // adjust all positions to the start of the line. - view.state.doc.line_to_char(index) + view.doc.text().line_to_char(index) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.state).with_selection(selection); + let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - transaction.apply(&mut view.state); + view.doc.apply(&transaction); } pub fn move_next_word_start(view: &mut View, count: usize) { - let pos = view.state.move_pos( - view.state.selection.cursor(), + let pos = view.doc.state.move_pos( + view.doc.state.selection.cursor(), Direction::Forward, Granularity::Word, count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_prev_word_start(view: &mut View, count: usize) { - let pos = view.state.move_pos( - view.state.selection.cursor(), + let pos = view.doc.state.move_pos( + view.doc.state.selection.cursor(), Direction::Backward, Granularity::Word, count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_next_word_end(view: &mut View, count: usize) { let pos = State::move_next_word_end( - &view.state.doc().slice(..), - view.state.selection.cursor(), + &view.doc.text().slice(..), + view.doc.state.selection.cursor(), count, ); // TODO: use a transaction - view.state.selection = Selection::single(pos, pos); + view.doc.state.selection = Selection::single(pos, pos); } pub fn move_file_start(view: &mut View, _count: usize) { // TODO: use a transaction - view.state.selection = Selection::single(0, 0); + view.doc.state.selection = Selection::single(0, 0); - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; } pub fn move_file_end(view: &mut View, _count: usize) { // TODO: use a transaction - let text = &view.state.doc; + let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.state.selection = Selection::single(last_line, last_line); + view.doc.state.selection = Selection::single(last_line, last_line); - view.state.mode = Mode::Normal; + view.doc.mode = Mode::Normal; } pub fn check_cursor_in_view(view: &mut View) -> 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 mod insert { } 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 00000000..c4b9d081 --- /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 61abd482..02199255 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 @@ impl Editor { 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 82bdbe21..347e7d77 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 @@ pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers}; // 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 9abe8a1a..3b923744 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 817714c8..4cf6a2ee 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -2,10 +2,11 @@ use anyhow::Error; 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 @@ pub const PADDING: usize = 5; // 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 @@ impl View { 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 @@ impl View { Some(Position::new(row, col)) } + + pub fn traverse(&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, + } + } } -- cgit v1.2.3-70-g09d2 From efc5aa2016e56e0721d125a20e3573d25af4dd76 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 11:36:46 +0900 Subject: Simplify old_state handling. --- helix-core/src/state.rs | 1 + helix-view/src/commands.rs | 8 +------- helix-view/src/document.rs | 4 ++-- 3 files changed, 4 insertions(+), 9 deletions(-) (limited to 'helix-core/src/state.rs') diff --git a/helix-core/src/state.rs b/helix-core/src/state.rs index 7fd620a5..4d531aa0 100644 --- a/helix-core/src/state.rs +++ b/helix-core/src/state.rs @@ -4,6 +4,7 @@ use crate::{ChangeSet, Diagnostic, Position, Range, Rope, RopeSlice, Selection, use anyhow::Error; /// A state represents the current editor state of a single buffer. +#[derive(Clone)] pub struct State { // TODO: fields should be private but we need to refactor commands.rs first pub doc: Rope, diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 6bf89040..06c4b9e0 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -411,15 +411,9 @@ fn append_changes_to_history(view: &mut View) { // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let (doc, selection) = view.doc.old_state.take().unwrap(); - let mut old_state = State::new(doc); - old_state.selection = selection; - + let old_state = std::mem::replace(&mut view.doc.old_state, view.doc.state.clone()); // TODO: take transaction by value? view.doc.history.commit_revision(&transaction, &old_state); - - // HAXX - view.doc.old_state = Some((view.doc.text().clone(), view.doc.state.selection.clone())); } pub fn normal_mode(view: &mut View, _count: usize) { diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 04018ed6..22438926 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -27,9 +27,9 @@ pub struct Document { /// Pending changes since last history commit. pub changes: ChangeSet, + pub old_state: State, pub history: History, pub version: i64, // should be usize? - pub old_state: Option<(Rope, Selection)>, pub diagnostics: Vec, } @@ -55,7 +55,7 @@ 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))); + let old_state = state.clone(); Self { path: None, -- cgit v1.2.3-70-g09d2