From b2b3083a623ec3dc5e2d1ea9c6ba35970efe19a3 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Mon, 19 Oct 2020 16:20:59 +0900 Subject: Support multiple open views. --- helix-view/src/editor.rs | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) (limited to 'helix-view') diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index c292caed..08fd1f0c 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -5,20 +5,32 @@ use std::path::PathBuf; use anyhow::Error; pub struct Editor { - pub view: Option, + pub views: Vec, + pub focus: usize, pub should_close: bool, } impl Editor { pub fn new() -> Self { Self { - view: None, + views: Vec::new(), + focus: 0, should_close: false, } } pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { - self.view = Some(View::open(path, size)?); + let pos = self.views.len(); + self.views.push(View::open(path, size)?); + self.focus = pos; Ok(()) } + + pub fn view(&self) -> Option<&View> { + self.views.get(self.focus) + } + + pub fn view_mut(&mut self) -> Option<&mut View> { + self.views.get_mut(self.focus) + } } -- cgit v1.2.3-70-g09d2 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 +- helix-term/src/application.rs | 30 ++++++++++++++++-------------- helix-view/src/editor.rs | 9 ++++++++- helix-view/src/lib.rs | 1 + helix-view/src/view.rs | 16 +++++++--------- 5 files changed, 33 insertions(+), 25 deletions(-) (limited to 'helix-view') 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, diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 9c90b6f3..d65e7e2e 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -1,6 +1,6 @@ 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, View}; +use helix_view::{commands, keymap, prompt::Prompt, Editor, Theme, View}; use std::{ borrow::Cow, @@ -15,8 +15,7 @@ use anyhow::Error; use crossterm::{ cursor, - cursor::position, - event::{self, read, Event, EventStream, KeyCode, KeyEvent}, + event::{read, Event, EventStream, KeyCode, KeyEvent}, execute, queue, terminal::{self, disable_raw_mode, enable_raw_mode}, }; @@ -75,19 +74,18 @@ impl Renderer { self.cache = Surface::empty(area); } - pub fn render_view(&mut self, view: &mut View, viewport: Rect) { - self.render_buffer(view, viewport); - self.render_statusline(view); + pub fn render_view(&mut self, view: &mut View, viewport: Rect, theme: &Theme) { + self.render_buffer(view, viewport, theme); + self.render_statusline(view, theme); } // TODO: ideally not &mut View but highlights require it because of cursor cache - pub fn render_buffer(&mut self, view: &mut View, viewport: Rect) { + pub fn render_buffer(&mut self, view: &mut View, viewport: Rect, theme: &Theme) { let area = Rect::new(0, 0, self.size.0, self.size.1); self.surface.reset(); // reset is faster than allocating new empty surface // clear with background color - self.surface - .set_style(area, view.theme.get("ui.background")); + 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(); @@ -150,7 +148,7 @@ impl Renderer { use helix_core::graphemes::{grapheme_width, RopeGraphemes}; let style = match spans.first() { - Some(span) => view.theme.get(view.theme.scopes()[span.0].as_str()), + Some(span) => theme.get(theme.scopes()[span.0].as_str()), None => Style::default().fg(Color::Rgb(164, 160, 232)), // lavender }; @@ -214,7 +212,7 @@ impl Renderer { } } } - let style: Style = view.theme.get("ui.linenr"); + let style: Style = theme.get("ui.linenr"); let last_line = view.last_line(); for (i, line) in (view.first_line..last_line).enumerate() { self.surface @@ -222,7 +220,7 @@ impl Renderer { } } - pub fn render_statusline(&mut self, view: &View) { + pub fn render_statusline(&mut self, view: &View, theme: &Theme) { let mode = match view.state.mode() { Mode::Insert => "INS", Mode::Normal => "NOR", @@ -231,7 +229,7 @@ impl Renderer { // statusline self.surface.set_style( Rect::new(0, self.size.1 - 2, self.size.0, 1), - view.theme.get("ui.statusline"), + theme.get("ui.statusline"), ); self.surface .set_string(1, self.size.1 - 2, mode, self.text_color); @@ -354,8 +352,11 @@ impl Application { fn render(&mut self) { let viewport = Rect::new(OFFSET, 0, self.terminal.size.0, self.terminal.size.1 - 2); // - 2 for statusline and prompt + // SAFETY: we cheat around the view_mut() borrow because it doesn't allow us to also borrow + // theme. Theme is immutable mutating view won't disrupt theme_ref. + let theme_ref = unsafe { &*(&self.editor.theme as *const Theme) }; if let Some(view) = self.editor.view_mut() { - self.terminal.render_view(view, viewport); + self.terminal.render_view(view, viewport, theme_ref); if let Some(prompt) = &self.prompt { if prompt.should_close { self.prompt = None; @@ -389,6 +390,7 @@ impl Application { 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() diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 08fd1f0c..61abd482 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -1,4 +1,6 @@ +use crate::theme::Theme; use crate::View; +use helix_core::State; use std::path::PathBuf; @@ -8,20 +10,25 @@ pub struct Editor { pub views: Vec, pub focus: usize, pub should_close: bool, + pub theme: Theme, // TODO: share one instance } impl Editor { pub fn new() -> Self { + let theme = Theme::default(); + Self { views: Vec::new(), focus: 0, should_close: false, + theme, } } pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> { let pos = self.views.len(); - self.views.push(View::open(path, size)?); + let state = State::load(path, self.theme.scopes())?; + self.views.push(View::new(state, size)?); self.focus = pos; Ok(()) } diff --git a/helix-view/src/lib.rs b/helix-view/src/lib.rs index 8ea634af..9abe8a1a 100644 --- a/helix-view/src/lib.rs +++ b/helix-view/src/lib.rs @@ -6,4 +6,5 @@ pub mod theme; pub mod view; 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 2b68dbc3..d2a7d556 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -1,8 +1,7 @@ use anyhow::Error; -use std::{borrow::Cow, path::PathBuf}; +use std::borrow::Cow; -use crate::theme::Theme; use helix_core::{ graphemes::{grapheme_width, RopeGraphemes}, indent::TAB_WIDTH, @@ -12,24 +11,23 @@ use tui::layout::Rect; 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 history: History, pub first_line: usize, pub size: (u16, u16), - pub theme: Theme, // TODO: share one instance + + // TODO: Doc<> fields + pub history: History, } impl View { - pub fn open(path: PathBuf, size: (u16, u16)) -> Result { - let theme = Theme::default(); - let state = State::load(path, theme.scopes())?; - + pub fn new(state: State, size: (u16, u16)) -> Result { let view = Self { state, first_line: 0, size, - theme, history: History::default(), }; -- 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-view') 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 49254d7180c8b92be5426cab20914b0343c9282c Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Tue, 20 Oct 2020 15:42:53 +0900 Subject: Total mess but it works: diagnostic marking. --- helix-core/src/diagnostic.rs | 8 ++++- helix-lsp/src/lib.rs | 3 ++ helix-term/src/application.rs | 84 ++++++++++++++++++++++++++++++++++++++++--- helix-view/src/theme.rs | 2 ++ 4 files changed, 91 insertions(+), 6 deletions(-) (limited to 'helix-view') diff --git a/helix-core/src/diagnostic.rs b/helix-core/src/diagnostic.rs index aee648aa..96ed6746 100644 --- a/helix-core/src/diagnostic.rs +++ b/helix-core/src/diagnostic.rs @@ -1 +1,7 @@ -pub struct Diagnostic {} +use crate::Range; + +pub struct Diagnostic { + pub range: (usize, usize), + pub line: usize, + pub message: String, +} diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 3598a594..939f9927 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -10,6 +10,9 @@ use serde_json::Value; use serde::{Deserialize, Serialize}; +pub use lsp::Position; +pub use lsp::Url; + use smol::prelude::*; use smol::{ channel::{Receiver, Sender}, diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 3d5b3459..5551e26f 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -29,10 +29,10 @@ use tui::{ backend::CrosstermBackend, buffer::Buffer as Surface, layout::Rect, - style::{Color, Style}, + style::{Color, Modifier, Style}, }; -const OFFSET: u16 = 6; // 5 linenr + 1 gutter +const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter type Terminal = tui::Terminal>; @@ -205,6 +205,16 @@ impl Renderer { style }; + // ugh, improve with a traverse method + // or interleave highlight spans with selection and diagnostic spans + let style = if view.state.diagnostics.iter().any(|diagnostic| { + diagnostic.range.0 <= char_index && diagnostic.range.1 > char_index + }) { + style.clone().add_modifier(Modifier::UNDERLINED) + } else { + style + }; + // TODO: paint cursor heads except primary self.surface @@ -212,18 +222,23 @@ impl Renderer { visual_x += width; } - // if grapheme == "\t" char_index += 1; } } } } + let style: Style = theme.get("ui.linenr"); + 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) { + self.surface.set_stringn(0, i as u16, "●", 1, warning); + } + self.surface - .set_stringn(0, i as u16, format!("{:>5}", line + 1), 5, style); + .set_stringn(1, i as u16, format!("{:>5}", line + 1), 5, style); } } @@ -240,6 +255,13 @@ impl Renderer { ); self.surface .set_string(1, self.size.1 - 2, mode, self.text_color); + + self.surface.set_string( + self.size.0 - 10, + self.size.1 - 2, + format!("{}", view.state.diagnostics.len()), + self.text_color, + ); } pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) { @@ -545,7 +567,59 @@ impl<'a> Application<'a> { pub async fn handle_lsp_notification(&mut self, notification: Option) { use helix_lsp::Notification; match notification { - Some(Notification::PublishDiagnostics(params)) => unimplemented!("{:?}", params), + 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) + } + + if let Some(view) = view { + let doc = view.state.doc().slice(..); + let diagnostics = params + .diagnostics + .into_iter() + .map(|diagnostic| { + 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, + message: diagnostic.message, + // severity + // code + // source + } + }) + .collect(); + + view.state.diagnostics = diagnostics; + + self.render(); + } + } _ => unreachable!(), } } diff --git a/helix-view/src/theme.rs b/helix-view/src/theme.rs index 4cc399ed..809ec05d 100644 --- a/helix-view/src/theme.rs +++ b/helix-view/src/theme.rs @@ -157,6 +157,8 @@ impl Default for Theme { "ui.background" => Style::default().bg(Color::Rgb(59, 34, 76)), // midnight "ui.linenr" => Style::default().fg(Color::Rgb(90, 89, 119)), // comet "ui.statusline" => Style::default().bg(Color::Rgb(40, 23, 51)), // revolver + + "warning" => Style::default().fg(Color::Rgb(255, 205, 28)), }; let scopes = mapping.keys().map(ToString::to_string).collect(); -- 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-view') 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-view') 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 c0e17dd324f016401d56d66b7c113dada0644155 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 11:32:25 +0900 Subject: Fix undo/redo not updating the syntax tree. --- helix-core/src/history.rs | 46 +++++++++++++++++++++++++--------------------- helix-view/src/commands.rs | 8 ++++++-- helix-view/src/document.rs | 1 - 3 files changed, 31 insertions(+), 24 deletions(-) (limited to 'helix-view') diff --git a/helix-core/src/history.rs b/helix-core/src/history.rs index e6d9a738..66445525 100644 --- a/helix-core/src/history.rs +++ b/helix-core/src/history.rs @@ -57,37 +57,31 @@ impl History { self.cursor == 0 } - pub fn undo(&mut self, state: &mut State) { + // TODO: I'd like to pass Transaction by reference but it fights with the borrowck + + pub fn undo(&mut self) -> Option { if self.at_root() { // We're at the root of undo, nothing to do. - return; + return None; } let current_revision = &self.revisions[self.cursor]; - // TODO: pass the return value through? It should always succeed - let success = current_revision.revert.apply(state); - - if !success { - panic!("Failed to apply undo!"); - } - self.cursor = current_revision.parent; + + Some(current_revision.revert.clone()) } - pub fn redo(&mut self, state: &mut State) { + pub fn redo(&mut self) -> Option { let current_revision = &self.revisions[self.cursor]; // for now, simply pick the latest child (linear undo / redo) if let Some((index, transaction)) = current_revision.children.last() { - let success = transaction.apply(state); - - if !success { - panic!("Failed to apply redo!"); - } - self.cursor = *index; + + return Some(transaction.clone()); } + None } } @@ -120,17 +114,27 @@ mod test { assert_eq!("hello 世界!", state.doc()); // --- + fn undo(history: &mut History, state: &mut State) { + if let Some(transaction) = history.undo() { + transaction.apply(state); + } + } + fn redo(history: &mut History, state: &mut State) { + if let Some(transaction) = history.redo() { + transaction.apply(state); + } + } - history.undo(&mut state); + undo(&mut history, &mut state); assert_eq!("hello world!", state.doc()); - history.redo(&mut state); + redo(&mut history, &mut state); assert_eq!("hello 世界!", state.doc()); - history.undo(&mut state); - history.undo(&mut state); + undo(&mut history, &mut state); + undo(&mut history, &mut state); assert_eq!("hello", state.doc()); // undo at root is a no-op - history.undo(&mut state); + undo(&mut history, &mut state); assert_eq!("hello", state.doc()); } } diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index b5350ff4..6bf89040 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -509,13 +509,17 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo pub fn undo(view: &mut View, _count: usize) { - view.doc.history.undo(&mut view.doc.state); + if let Some(revert) = view.doc.history.undo() { + view.doc.apply(&revert); + } // TODO: each command could simply return a Option, then the higher level handles storing it? } pub fn redo(view: &mut View, _count: usize) { - view.doc.history.redo(&mut view.doc.state); + if let Some(transaction) = view.doc.history.redo() { + view.doc.apply(&transaction); + } } // Yank / Paste diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index c4b9d081..04018ed6 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -108,7 +108,6 @@ impl Document { }; } - // TODO: needs to run on undo/redo pub fn apply(&mut self, transaction: &Transaction) -> bool { let old_doc = self.text().clone(); -- 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-view') 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 From e4070d4de0883c3fc979b3d57b1b43ecb0a0d72f Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 11:37:32 +0900 Subject: Bump document version on undo/redo. --- helix-view/src/commands.rs | 2 ++ 1 file changed, 2 insertions(+) (limited to 'helix-view') diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 06c4b9e0..768a717e 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -504,6 +504,7 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { pub fn undo(view: &mut View, _count: usize) { if let Some(revert) = view.doc.history.undo() { + view.doc.version += 1; view.doc.apply(&revert); } @@ -512,6 +513,7 @@ pub fn undo(view: &mut View, _count: usize) { pub fn redo(view: &mut View, _count: usize) { if let Some(transaction) = view.doc.history.redo() { + view.doc.version += 1; view.doc.apply(&transaction); } } -- cgit v1.2.3-70-g09d2 From 55fa86248c77a01900379ec5bca668978fd5c0d3 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 12:06:33 +0900 Subject: Introduce doc.selection()/set_selection() --- helix-view/src/commands.rs | 142 +++++++++++++++++++++------------------------ helix-view/src/document.rs | 11 ++++ 2 files changed, 78 insertions(+), 75 deletions(-) (limited to 'helix-view') diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 768a717e..d31aed31 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -19,40 +19,38 @@ use crate::{ 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.doc .state .move_selection(Direction::Backward, Granularity::Character, count); - view.doc.state.selection = selection; + view.doc.set_selection(selection); } pub fn move_char_right(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = + let selection = view.doc .state .move_selection(Direction::Forward, Granularity::Character, count); + view.doc.set_selection(selection); } pub fn move_line_up(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .move_selection(Direction::Backward, Granularity::Line, count); + let selection = view + .doc + .state + .move_selection(Direction::Backward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn move_line_down(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .move_selection(Direction::Forward, Granularity::Line, count); + let selection = view + .doc + .state + .move_selection(Direction::Forward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn move_line_end(view: &mut View, _count: usize) { - // TODO: use a transaction let lines = selection_lines(&view.doc.state); let positions = lines @@ -68,9 +66,7 @@ pub fn move_line_end(view: &mut View, _count: usize) { let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - - view.doc.apply(&transaction); + view.doc.set_selection(selection); } pub fn move_line_start(view: &mut View, _count: usize) { @@ -86,64 +82,58 @@ pub fn move_line_start(view: &mut View, _count: usize) { let selection = Selection::new(positions.collect(), 0); - let transaction = Transaction::new(&mut view.doc.state).with_selection(selection); - - view.doc.apply(&transaction); + view.doc.set_selection(selection); } pub fn move_next_word_start(view: &mut View, count: usize) { let pos = view.doc.state.move_pos( - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), Direction::Forward, Granularity::Word, count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_prev_word_start(view: &mut View, count: usize) { let pos = view.doc.state.move_pos( - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), Direction::Backward, Granularity::Word, count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_next_word_end(view: &mut View, count: usize) { let pos = State::move_next_word_end( &view.doc.text().slice(..), - view.doc.state.selection.cursor(), + view.doc.selection().cursor(), count, ); - // TODO: use a transaction - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } pub fn move_file_start(view: &mut View, _count: usize) { - // TODO: use a transaction - view.doc.state.selection = Selection::single(0, 0); + view.doc.set_selection(Selection::single(0, 0)); view.doc.mode = Mode::Normal; } pub fn move_file_end(view: &mut View, _count: usize) { - // TODO: use a transaction let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc.state.selection = Selection::single(last_line, last_line); + view.doc + .set_selection(Selection::single(last_line, last_line)); view.doc.mode = Mode::Normal; } pub fn check_cursor_in_view(view: &mut View) -> bool { - let cursor = view.doc.state.selection().cursor(); + let cursor = view.doc.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; @@ -163,7 +153,7 @@ pub fn page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -173,7 +163,7 @@ pub fn page_down(view: &mut View, _count: usize) { 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.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -187,7 +177,7 @@ pub fn half_page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_selection(Selection::single(pos, pos)); } } @@ -199,42 +189,41 @@ pub fn half_page_down(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.state.selection = Selection::single(pos, pos); + view.doc.set_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.doc .state .extend_selection(Direction::Backward, Granularity::Character, count); - view.doc.state.selection = selection; + view.doc.set_selection(selection); } pub fn extend_char_right(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = + let selection = view.doc .state .extend_selection(Direction::Forward, Granularity::Character, count); + view.doc.set_selection(selection); } pub fn extend_line_up(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .extend_selection(Direction::Backward, Granularity::Line, count); + let selection = view + .doc + .state + .extend_selection(Direction::Backward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn extend_line_down(view: &mut View, count: usize) { - // TODO: use a transaction - view.doc.state.selection = - view.doc - .state - .extend_selection(Direction::Forward, Granularity::Line, count); + let selection = view + .doc + .state + .extend_selection(Direction::Forward, Granularity::Line, count); + view.doc.set_selection(selection); } pub fn split_selection_on_newline(view: &mut View, _count: usize) { @@ -242,20 +231,19 @@ pub fn split_selection_on_newline(view: &mut View, _count: usize) { // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); - // TODO: use a transaction - view.doc.state.selection = selection::split_on_matches(text, view.doc.state.selection(), ®EX) + let selection = selection::split_on_matches(text, view.doc.selection(), ®EX); + view.doc.set_selection(selection); } pub fn select_line(view: &mut View, _count: usize) { // TODO: count - let pos = view.doc.state.selection().primary(); + let pos = view.doc.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.doc.state.selection = Selection::single(start, end); + view.doc.set_selection(Selection::single(start, end)); } pub fn delete_selection(view: &mut View, _count: usize) { @@ -273,19 +261,21 @@ pub fn change_selection(view: &mut View, count: usize) { } pub fn collapse_selection(view: &mut View, _count: usize) { - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.head, range.head)) + .selection() + .transform(|range| Range::new(range.head, range.head)); + + view.doc.set_selection(selection); } pub fn flip_selections(view: &mut View, _count: usize) { - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.head, range.anchor)) + .selection() + .transform(|range| Range::new(range.head, range.anchor)); + + view.doc.set_selection(selection); } fn enter_insert_mode(view: &mut View) { @@ -297,11 +287,11 @@ fn enter_insert_mode(view: &mut View) { pub fn insert_mode(view: &mut View, _count: usize) { enter_insert_mode(view); - view.doc.state.selection = view + let selection = view .doc - .state - .selection - .transform(|range| Range::new(range.to(), range.from())) + .selection() + .transform(|range| Range::new(range.to(), range.from())); + view.doc.set_selection(selection); } // inserts at the end of each selection @@ -311,13 +301,14 @@ pub fn append_mode(view: &mut View, _count: usize) { // TODO: as transaction let text = &view.doc.text().slice(..); - view.doc.state.selection = view.doc.state.selection.transform(|range| { + let selection = view.doc.selection().transform(|range| { // TODO: to() + next char Range::new( range.from(), graphemes::next_grapheme_boundary(text, range.to()), ) - }) + }); + view.doc.set_selection(selection); } // TODO: I, A, o and O can share a lot of the primitives. @@ -402,7 +393,7 @@ fn append_changes_to_history(view: &mut View) { 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.doc.state.selection().clone()); + let transaction = Transaction::from(changes).with_selection(view.doc.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too @@ -424,12 +415,13 @@ pub fn normal_mode(view: &mut View, _count: usize) { // if leaving append mode, move cursor back by 1 if view.doc.restore_cursor { let text = &view.doc.text().slice(..); - view.doc.state.selection = view.doc.state.selection.transform(|range| { + let selection = view.doc.selection().transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); + view.doc.set_selection(selection); view.doc.restore_cursor = false; } @@ -587,7 +579,7 @@ fn get_lines(view: &View) -> Vec { let mut lines = Vec::new(); // Get all line numbers - for range in view.doc.state.selection.ranges() { + for range in view.doc.selection().ranges() { let start = view.doc.text().char_to_line(range.from()); let end = view.doc.text().char_to_line(range.to()); diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 22438926..a313b281 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -108,6 +108,11 @@ impl Document { }; } + pub fn set_selection(&mut self, selection: Selection) { + // TODO: use a transaction? + self.state.selection = selection; + } + pub fn apply(&mut self, transaction: &Transaction) -> bool { let old_doc = self.text().clone(); @@ -119,6 +124,8 @@ impl Document { changes.compose(transaction.changes().clone()).unwrap() }); + // TODO: when composing, replace transaction.selection too + // update tree-sitter syntax tree if let Some(syntax) = &mut self.syntax { // TODO: no unwrap @@ -150,6 +157,10 @@ impl Document { &self.state.doc } + pub fn selection(&self) -> &Selection { + &self.state.selection + } + // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { // self.state.doc.slice // } -- cgit v1.2.3-70-g09d2 From f5981f72c256a834845aad0c2947a4a20fa84d1b Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 12:09:40 +0900 Subject: Introduce Selection::point. --- helix-core/src/selection.rs | 5 +++++ helix-view/src/commands.rs | 19 +++++++++---------- 2 files changed, 14 insertions(+), 10 deletions(-) (limited to 'helix-view') diff --git a/helix-core/src/selection.rs b/helix-core/src/selection.rs index 13c820f1..9413fead 100644 --- a/helix-core/src/selection.rs +++ b/helix-core/src/selection.rs @@ -179,6 +179,11 @@ impl Selection { } } + /// Constructs a selection holding a single cursor. + pub fn point(pos: usize) -> Self { + Self::single(pos, pos) + } + #[must_use] pub fn new(ranges: SmallVec<[Range; 1]>, primary_index: usize) -> Self { fn normalize(mut ranges: SmallVec<[Range; 1]>, mut primary_index: usize) -> Selection { diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index d31aed31..52e09dd6 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -93,7 +93,7 @@ pub fn move_next_word_start(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_prev_word_start(view: &mut View, count: usize) { @@ -104,7 +104,7 @@ pub fn move_prev_word_start(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_next_word_end(view: &mut View, count: usize) { @@ -114,11 +114,11 @@ pub fn move_next_word_end(view: &mut View, count: usize) { count, ); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } pub fn move_file_start(view: &mut View, _count: usize) { - view.doc.set_selection(Selection::single(0, 0)); + view.doc.set_selection(Selection::point(0)); view.doc.mode = Mode::Normal; } @@ -126,8 +126,7 @@ pub fn move_file_start(view: &mut View, _count: usize) { pub fn move_file_end(view: &mut View, _count: usize) { let text = &view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc - .set_selection(Selection::single(last_line, last_line)); + view.doc.set_selection(Selection::point(last_line)); view.doc.mode = Mode::Normal; } @@ -153,7 +152,7 @@ pub fn page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -163,7 +162,7 @@ pub fn page_down(view: &mut View, _count: usize) { 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.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -177,7 +176,7 @@ pub fn half_page_up(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = &view.doc.text(); let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } @@ -189,7 +188,7 @@ pub fn half_page_down(view: &mut View, _count: usize) { if !check_cursor_in_view(view) { let text = view.doc.text(); let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::single(pos, pos)); + view.doc.set_selection(Selection::point(pos)); } } // avoid select by default by having a visual mode switch that makes movements into selects -- cgit v1.2.3-70-g09d2 From eff6fac9ece0700f0ed8eb0a230b6816fa7cece7 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 13:51:08 +0900 Subject: clippy lint --- helix-lsp/src/transport.rs | 3 +-- helix-view/src/document.rs | 2 ++ helix-view/src/editor.rs | 6 ++++++ helix-view/src/keymap.rs | 2 +- helix-view/src/view.rs | 40 ++++++++++++++++++++-------------------- 5 files changed, 30 insertions(+), 23 deletions(-) (limited to 'helix-view') diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index 38c3bb57..b30a8a6e 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -138,11 +138,10 @@ impl Transport { // println!("<- {} {:?}", method, notification); self.incoming.send(notification).await?; } - Message::Call(call) => { + Message::Call(_call) => { // println!("<- {:?}", call); // dispatch } - _ => unreachable!(), }; Ok(()) } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index a313b281..710ea4f8 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -164,4 +164,6 @@ impl Document { // pub fn slice(&self, range: R) -> RopeSlice where R: RangeBounds { // self.state.doc.slice // } + + // TODO: transact(Fn) ? } diff --git a/helix-view/src/editor.rs b/helix-view/src/editor.rs index 02199255..9fb2ae36 100644 --- a/helix-view/src/editor.rs +++ b/helix-view/src/editor.rs @@ -12,6 +12,12 @@ pub struct Editor { pub theme: Theme, // TODO: share one instance } +impl Default for Editor { + fn default() -> Self { + Self::new() + } +} + impl Editor { pub fn new() -> Self { let theme = Theme::default(); diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index 347e7d77..aaba34a6 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -1,6 +1,6 @@ use crate::commands::{self, Command}; use crate::document::Mode; -use helix_core::{hashmap, state}; +use helix_core::hashmap; use std::collections::HashMap; // Kakoune-inspired: diff --git a/helix-view/src/view.rs b/helix-view/src/view.rs index 4cf6a2ee..df41e3ae 100644 --- a/helix-view/src/view.rs +++ b/helix-view/src/view.rs @@ -86,24 +86,24 @@ 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, - } - } + // 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 cc6bdf8f66889087223d9a8491479ceecc09a663 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 23 Oct 2020 18:48:03 +0900 Subject: Text change generation, RPC call handling. --- helix-core/src/lib.rs | 2 +- helix-core/src/transaction.rs | 9 ++- helix-lsp/src/client.rs | 137 +++++++++++++++++++++++++++++++++++++++--- helix-lsp/src/lib.rs | 25 +++----- helix-lsp/src/transport.rs | 39 ++++++++---- helix-term/src/application.rs | 87 +++++++++++++++------------ helix-view/src/keymap.rs | 3 + 7 files changed, 225 insertions(+), 77 deletions(-) (limited to 'helix-view') diff --git a/helix-core/src/lib.rs b/helix-core/src/lib.rs index 8458c36f..ddf1439c 100644 --- a/helix-core/src/lib.rs +++ b/helix-core/src/lib.rs @@ -27,4 +27,4 @@ pub use diagnostic::Diagnostic; pub use history::History; pub use state::State; -pub use transaction::{Assoc, Change, ChangeSet, Transaction}; +pub use transaction::{Assoc, Change, ChangeSet, Operation, Transaction}; diff --git a/helix-core/src/transaction.rs b/helix-core/src/transaction.rs index 9bd8c615..f1cb2ca1 100644 --- a/helix-core/src/transaction.rs +++ b/helix-core/src/transaction.rs @@ -5,8 +5,9 @@ use std::convert::TryFrom; /// (from, to, replacement) pub type Change = (usize, usize, Option); +// TODO: pub(crate) #[derive(Debug, Clone, PartialEq, Eq)] -pub(crate) enum Operation { +pub enum Operation { /// Move cursor by n characters. Retain(usize), /// Delete n characters. @@ -40,6 +41,12 @@ impl ChangeSet { } // TODO: from iter + // + + #[doc(hidden)] // used by lsp to convert to LSP changes + pub fn changes(&self) -> &[Operation] { + &self.changes + } #[must_use] fn len_after(&self) -> usize { diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 56413768..3c2c1ce0 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -1,11 +1,11 @@ use crate::{ transport::{Payload, Transport}, - Error, Notification, + Call, Error, }; type Result = core::result::Result; -use helix_core::{State, Transaction}; +use helix_core::{ChangeSet, Transaction}; use helix_view::Document; // use std::collections::HashMap; @@ -27,7 +27,7 @@ pub struct Client { stderr: BufReader, outgoing: Sender, - pub incoming: Receiver, + pub incoming: Receiver, pub request_counter: u64, @@ -87,6 +87,7 @@ impl Client { Ok(params) } + /// Execute a RPC request on the language server. pub async fn request( &mut self, params: R::Params, @@ -126,6 +127,7 @@ impl Client { Ok(response) } + /// Send a RPC notification to the language server. pub async fn notify( &mut self, params: R::Params, @@ -149,6 +151,35 @@ impl Client { Ok(()) } + /// Reply to a language server RPC call. + pub async fn reply( + &mut self, + id: jsonrpc::Id, + result: core::result::Result, + ) -> Result<()> { + use jsonrpc::{Failure, Output, Success, Version}; + + let output = match result { + Ok(result) => Output::Success(Success { + jsonrpc: Some(Version::V2), + id, + result, + }), + Err(error) => Output::Failure(Failure { + jsonrpc: Some(Version::V2), + id, + error, + }), + }; + + self.outgoing + .send(Payload::Response(output)) + .await + .map_err(|e| Error::Other(e.into()))?; + + Ok(()) + } + // ------------------------------------------------------------------------------------------- // General messages // ------------------------------------------------------------------------------------------- @@ -163,7 +194,9 @@ impl Client { // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), root_uri: None, // set to project root in the future initialization_options: None, - capabilities: lsp::ClientCapabilities::default(), + capabilities: lsp::ClientCapabilities { + ..Default::default() + }, trace: None, workspace_folders: None, client_info: None, @@ -203,23 +236,107 @@ impl Client { .await } + fn to_changes(changeset: &ChangeSet) -> Vec { + let mut iter = changeset.changes().iter().peekable(); + let mut old_pos = 0; + + let mut changes = Vec::new(); + + use crate::util::pos_to_lsp_pos; + use helix_core::Operation::*; + + // TEMP + let rope = helix_core::Rope::from(""); + let old_text = rope.slice(..); + + while let Some(change) = iter.next() { + let len = match change { + Delete(i) | Retain(i) => *i, + Insert(_) => 0, + }; + let old_end = old_pos + len; + + match change { + Retain(_) => {} + Delete(_) => { + let start = pos_to_lsp_pos(&old_text, old_pos); + let end = pos_to_lsp_pos(&old_text, old_end); + + // a subsequent ins means a replace, consume it + if let Some(Insert(s)) = iter.peek() { + iter.next(); + + // replacement + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, end)), + text: s.into(), + range_length: None, + }); + } else { + // deletion + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, end)), + text: "".to_string(), + range_length: None, + }); + }; + } + Insert(s) => { + let start = pos_to_lsp_pos(&old_text, old_pos); + + // insert + changes.push(lsp::TextDocumentContentChangeEvent { + range: Some(lsp::Range::new(start, start)), + text: s.into(), + range_length: None, + }); + } + } + old_pos = old_end; + } + + changes + } + // TODO: trigger any time history.commit_revision happens pub async fn text_document_did_change( &mut self, doc: &Document, transaction: &Transaction, ) -> Result<()> { + // figure out what kind of sync the server supports + + let capabilities = self.capabilities.as_ref().unwrap(); // TODO: needs post init + + let sync_capabilities = match capabilities.text_document_sync { + Some(lsp::TextDocumentSyncCapability::Kind(kind)) => kind, + Some(lsp::TextDocumentSyncCapability::Options(lsp::TextDocumentSyncOptions { + change: Some(kind), + .. + })) => kind, + // None | SyncOptions { changes: None } + _ => return Ok(()), + }; + + let changes = match sync_capabilities { + lsp::TextDocumentSyncKind::Full => { + vec![lsp::TextDocumentContentChangeEvent { + // range = None -> whole document + range: None, //Some(Range) + range_length: None, // u64 apparently deprecated + text: "".to_string(), + }] // TODO: probably need old_state here too? + } + lsp::TextDocumentSyncKind::Incremental => Self::to_changes(transaction.changes()), + lsp::TextDocumentSyncKind::None => return Ok(()), + }; + self.notify::(lsp::DidChangeTextDocumentParams { text_document: lsp::VersionedTextDocumentIdentifier::new( lsp::Url::from_file_path(doc.path().unwrap()).unwrap(), doc.version, ), - content_changes: vec![lsp::TextDocumentContentChangeEvent { - // range = None -> whole document - range: None, //Some(Range) - range_length: None, // u64 apparently deprecated - text: "".to_string(), - }], // TODO: probably need old_state here too? + content_changes: changes, }) .await } diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index c37222f1..1ee8199f 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -1,13 +1,12 @@ mod client; mod transport; -use jsonrpc_core as jsonrpc; -use lsp_types as lsp; +pub use jsonrpc_core as jsonrpc; +pub use lsp_types as lsp; pub use client::Client; pub use lsp::{Position, Url}; -use serde::{Deserialize, Serialize}; use thiserror::Error; #[derive(Error, Debug)] @@ -30,19 +29,13 @@ pub mod util { let line_start = doc.char_to_utf16_cu(line); doc.utf16_cu_to_char(pos.character as usize + line_start) } -} + pub fn pos_to_lsp_pos(doc: &helix_core::RopeSlice, pos: usize) -> lsp::Position { + let line = doc.char_to_line(pos); + let line_start = doc.char_to_utf16_cu(line); + let col = doc.char_to_utf16_cu(pos) - 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)] -#[serde(untagged)] -enum Message { - /// A regular JSON-RPC request output (single response). - Output(jsonrpc::Output), - /// A notification. - Notification(jsonrpc::Notification), - /// A JSON-RPC request - Call(jsonrpc::Call), + lsp::Position::new(line as u64, col as u64) + } } #[derive(Debug, PartialEq, Clone)] @@ -67,3 +60,5 @@ impl Notification { } } } + +pub use jsonrpc::Call; diff --git a/helix-lsp/src/transport.rs b/helix-lsp/src/transport.rs index 4ab3d5ec..4c349a13 100644 --- a/helix-lsp/src/transport.rs +++ b/helix-lsp/src/transport.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; use log::debug; -use crate::{Error, Message, Notification}; +use crate::{Error, Notification}; type Result = core::result::Result; @@ -24,10 +24,23 @@ pub(crate) enum Payload { value: jsonrpc::MethodCall, }, Notification(jsonrpc::Notification), + Response(jsonrpc::Output), +} + +use serde::{Deserialize, Serialize}; +/// A type representing all possible values sent from the server to the client. +#[derive(Debug, PartialEq, Clone, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] +#[serde(untagged)] +enum Message { + /// A regular JSON-RPC request output (single response). + Output(jsonrpc::Output), + /// A JSON-RPC request or notification. + Call(jsonrpc::Call), } pub(crate) struct Transport { - incoming: Sender, // TODO Notification | Call + incoming: Sender, outgoing: Receiver, pending_requests: HashMap>>, @@ -42,7 +55,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(); @@ -112,6 +125,10 @@ impl Transport { let json = serde_json::to_string(&value)?; self.send(json).await } + Payload::Response(error) => { + let json = serde_json::to_string(&error)?; + self.send(json).await + } } } @@ -131,24 +148,18 @@ impl Transport { Ok(()) } - pub async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> { + async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> { match msg { Message::Output(output) => self.recv_response(output).await?, - Message::Notification(jsonrpc::Notification { method, params, .. }) => { - let notification = Notification::parse(&method, params); - - debug!("<- {} {:?}", method, notification); - self.incoming.send(notification).await?; - } Message::Call(call) => { - debug!("<- {:?}", call); - // dispatch + self.incoming.send(call).await?; + // let notification = Notification::parse(&method, params); } }; Ok(()) } - pub async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { + async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> { match output { jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => { debug!("<- {}", result); @@ -191,6 +202,8 @@ impl Transport { } let msg = msg.unwrap(); + debug!("<- {:?}", msg); + self.recv_msg(msg).await.unwrap(); } } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index b9594b7e..802dd399 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -433,8 +433,8 @@ impl<'a> Application<'a> { event = reader.next().fuse() => { self.handle_terminal_events(event).await } - notification = self.lsp.incoming.next().fuse() => { - self.handle_lsp_notification(notification).await + call = self.lsp.incoming.next().fuse() => { + self.handle_lsp_message(call).await } } } @@ -566,43 +566,56 @@ impl<'a> Application<'a> { }; } - pub async fn handle_lsp_notification(&mut self, notification: Option) { - use helix_lsp::Notification; - match notification { - Some(Notification::PublishDiagnostics(params)) => { - let path = Some(params.uri.to_file_path().unwrap()); - let view = self - .editor - .views - .iter_mut() - .find(|view| view.doc.path == path); - - if let Some(view) = view { - let doc = view.doc.text().slice(..); - let diagnostics = params - .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); - - helix_core::Diagnostic { - range: (start, end), - line: diagnostic.range.start.line as usize, - message: diagnostic.message, - // severity - // code - // source - } - }) - .collect(); - - view.doc.diagnostics = diagnostics; - - self.render(); + pub async fn handle_lsp_message(&mut self, call: Option) { + use helix_lsp::{Call, Notification}; + match call { + Some(Call::Notification(helix_lsp::jsonrpc::Notification { + method, params, .. + })) => { + let notification = Notification::parse(&method, params); + match notification { + Notification::PublishDiagnostics(params) => { + let path = Some(params.uri.to_file_path().unwrap()); + let view = self + .editor + .views + .iter_mut() + .find(|view| view.doc.path == path); + + if let Some(view) = view { + let doc = view.doc.text().slice(..); + let diagnostics = params + .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); + + helix_core::Diagnostic { + range: (start, end), + line: diagnostic.range.start.line as usize, + message: diagnostic.message, + // severity + // code + // source + } + }) + .collect(); + + view.doc.diagnostics = diagnostics; + + self.render(); + } + } + _ => unreachable!(), } } + Some(Call::MethodCall(call)) => { + // TODO: need to make Result + + unimplemented!("{:?}", call) + } _ => unreachable!(), } } diff --git a/helix-view/src/keymap.rs b/helix-view/src/keymap.rs index aaba34a6..c815911e 100644 --- a/helix-view/src/keymap.rs +++ b/helix-view/src/keymap.rs @@ -82,6 +82,9 @@ use std::collections::HashMap; // = = align? // + = // } +// +// gd = goto definition +// gr = goto reference // } #[cfg(feature = "term")] -- cgit v1.2.3-70-g09d2 From ae8a9e5bac2cb4683015604bb5a431781717c991 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Thu, 29 Oct 2020 14:06:33 +0900 Subject: lsp: Make base request methods take &self instead of &mut self. --- Cargo.lock | 84 +++++++++++++++++++++++-------------------- helix-lsp/Cargo.toml | 2 +- helix-lsp/src/client.rs | 28 ++++++--------- helix-term/src/application.rs | 23 ++++++------ helix-view/src/commands.rs | 2 ++ 5 files changed, 72 insertions(+), 67 deletions(-) (limited to 'helix-view') diff --git a/Cargo.lock b/Cargo.lock index bc3da508..28fc503c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -29,9 +29,9 @@ checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544" [[package]] name = "arrayvec" -version = "0.5.1" +version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cff77d8686867eceff3105329d4698d96c2391c176d5d03adc90c7389162b5b8" +checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b" [[package]] name = "async-channel" @@ -118,7 +118,7 @@ checksum = "4c8cea09c1fb10a317d1b5af8024eeba256d6554763e85ecd90ff8df31c7bbda" dependencies = [ "async-io", "blocking", - "cfg-if", + "cfg-if 0.1.10", "event-listener", "futures-lite", "once_cell", @@ -208,6 +208,12 @@ version = "0.1.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822" +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + [[package]] name = "chrono" version = "0.4.19" @@ -267,15 +273,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" dependencies = [ "autocfg", - "cfg-if", + "cfg-if 0.1.10", "lazy_static", ] [[package]] name = "crossterm" -version = "0.18.0" +version = "0.18.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2fcdc3c9cf8ee446222e8ee8691a6d21b563b8fe1a64b1873080db7b5b23cf0" +checksum = "cef9149b29071d44c9fb98fd9c27fcf74405bbdb761889ad6a03f36be93b0b15" dependencies = [ "bitflags", "crossterm_winapi", @@ -290,9 +296,9 @@ dependencies = [ [[package]] name = "crossterm_winapi" -version = "0.6.1" +version = "0.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "057b7146d02fb50175fd7dbe5158f6097f33d02831f43b4ee8ae4ddf67b68f5c" +checksum = "c2265c3f8e080075d9b6417aa72293fc71662f34b4af2612d8d1b074d29510db" dependencies = [ "winapi", ] @@ -303,7 +309,7 @@ version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "13aea89a5c93364a98e9b37b2fa237effbb694d5cfe01c5b70941f7eb087d5e3" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "dirs-sys", ] @@ -360,15 +366,15 @@ checksum = "4c7e4c2612746b0df8fed4ce0c69156021b704c9aefa360311c04e6e9e002eed" [[package]] name = "futures-core" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d674eaa0056896d5ada519900dbf97ead2e46a7b6621e8160d79e2f2e1e2784b" +checksum = "18eaa56102984bed2c88ea39026cff3ce3b4c7f508ca970cedf2450ea10d4e46" [[package]] name = "futures-io" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5fc94b64bb39543b4e432f1790b6bf18e3ee3b74653c5449f63310e9a74b123c" +checksum = "6e1798854a4727ff944a7b12aa999f58ce7aa81db80d2dfaaf2ba06f065ddd2b" [[package]] name = "futures-lite" @@ -387,9 +393,9 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f57ed14da4603b2554682e9f2ff3c65d7567b53188db96cb71538217fc64581b" +checksum = "e36fccf3fc58563b4a14d265027c627c3b665d7fed489427e88e7cc929559efe" dependencies = [ "proc-macro-hack", "proc-macro2", @@ -399,18 +405,18 @@ dependencies = [ [[package]] name = "futures-task" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dd26820a9f3637f1302da8bceba3ff33adbe53464b54ca24d4e2d4f1db30f94" +checksum = "96d502af37186c4fef99453df03e374683f8a1eec9dcc1e66b3b82dc8278ce3c" dependencies = [ "once_cell", ] [[package]] name = "futures-util" -version = "0.3.6" +version = "0.3.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a894a0acddba51a2d49a6f4263b1e64b8c579ece8af50fa86503d52cd1eea34" +checksum = "abcb44342f62e6f3e8ac427b8aa815f724fd705dfad060b18ac7866c15bb8e34" dependencies = [ "futures-core", "futures-macro", @@ -428,7 +434,7 @@ version = "0.1.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc587bc0ec293155d5bfa6b9891ec18a1e330c234f896ea47fbada4cadbe47e6" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "wasi 0.9.0+wasi-snapshot-preview1", ] @@ -553,11 +559,11 @@ dependencies = [ [[package]] name = "instant" -version = "0.1.7" +version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "63312a18f7ea8760cdd0a7c5aac1a619752a246b833545e3e36d1f81f7cd9e66" +checksum = "cb1fc4429a33e1f80d41dc9fea4d108a88bec1de8053878898ae448a0b52f613" dependencies = [ - "cfg-if", + "cfg-if 1.0.0", ] [[package]] @@ -596,9 +602,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.79" +version = "0.2.80" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2448f6066e80e3bfc792e9c98bf705b4b0fc6e8ef5b43e5889aff0eaa9c58743" +checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614" [[package]] name = "lock_api" @@ -615,14 +621,14 @@ version = "0.4.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fabed175da42fed1fa0746b0ea71f412aa9d35e76e95e59b192c64b9dc2bf8b" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", ] [[package]] name = "lsp-types" -version = "0.82.0" +version = "0.83.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "db895abb8527cf59e3de893ab2acf52cf904faeb65e60ea6f373e11fe86464e8" +checksum = "25e0bd4b95038f2c23bda332ba0ca684e8dda765db1f9bdb63dc4c3e01f3b456" dependencies = [ "base64", "bitflags", @@ -691,9 +697,9 @@ checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" [[package]] name = "ntapi" -version = "0.3.4" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a31937dea023539c72ddae0e3571deadc1414b300483fa7aaec176168cfa9d2" +checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44" dependencies = [ "winapi", ] @@ -762,7 +768,7 @@ version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c361aa727dd08437f2f1447be8b59a33b0edd15e0fcee698f935613d9efbca9b" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "cloudabi", "instant", "libc", @@ -785,18 +791,18 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" [[package]] name = "pin-project" -version = "0.4.27" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ffbc8e94b38ea3d2d8ba92aea2983b503cd75d0888d75b86bb37970b5698e15" +checksum = "ee41d838744f60d959d7074e3afb6b35c7456d0f61cad38a24e35e6553f73841" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "0.4.27" +version = "1.0.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "65ad2ae56b6abe3a1ee25f15ee605bacadb9a764edaba9c2bf4103800d4a1895" +checksum = "81a4ffa594b66bff340084d4081df649a7dc049ac8d7fc458d8e628bfbbb2f86" dependencies = [ "proc-macro2", "quote", @@ -821,7 +827,7 @@ version = "2.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a2a7bc6b2a29e632e45451c941832803a18cce6781db04de8a04696cdca8bde4" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "log", "wepoll-sys", @@ -1034,7 +1040,7 @@ version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44" dependencies = [ - "cfg-if", + "cfg-if 0.1.10", "libc", "redox_syscall", "winapi", @@ -1042,9 +1048,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.46" +version = "1.0.48" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ad5de3220ea04da322618ded2c42233d02baca219d6f160a3e9c87cda16c942" +checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac" dependencies = [ "proc-macro2", "quote", diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index ffd909a4..0c5d8b91 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -10,7 +10,7 @@ edition = "2018" helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } -lsp-types = { version = "0.82", features = ["proposed"] } +lsp-types = { version = "0.83", features = ["proposed"] } smol = "1.2" url = "2" pathdiff = "0.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 3c2c1ce0..1583bfb8 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -9,6 +9,7 @@ use helix_core::{ChangeSet, Transaction}; use helix_view::Document; // use std::collections::HashMap; +use std::sync::atomic::{AtomicU64, Ordering}; use jsonrpc_core as jsonrpc; use lsp_types as lsp; @@ -29,7 +30,7 @@ pub struct Client { outgoing: Sender, pub incoming: Receiver, - pub request_counter: u64, + pub request_counter: AtomicU64, capabilities: Option, // TODO: handle PublishDiagnostics Version @@ -61,17 +62,16 @@ impl Client { outgoing, incoming, - request_counter: 0, + request_counter: AtomicU64::new(0), capabilities: None, // diagnostics: HashMap::new(), } } - fn next_request_id(&mut self) -> jsonrpc::Id { - let id = jsonrpc::Id::Num(self.request_counter); - self.request_counter += 1; - id + fn next_request_id(&self) -> jsonrpc::Id { + let id = self.request_counter.fetch_add(1, Ordering::Relaxed); + jsonrpc::Id::Num(id) } fn to_params(value: Value) -> Result { @@ -88,10 +88,7 @@ impl Client { } /// Execute a RPC request on the language server. - pub async fn request( - &mut self, - params: R::Params, - ) -> Result + pub async fn request(&self, params: R::Params) -> Result where R::Params: serde::Serialize, R::Result: core::fmt::Debug, // TODO: temporary @@ -128,10 +125,7 @@ impl Client { } /// Send a RPC notification to the language server. - pub async fn notify( - &mut self, - params: R::Params, - ) -> Result<()> + pub async fn notify(&self, params: R::Params) -> Result<()> where R::Params: serde::Serialize, { @@ -153,7 +147,7 @@ impl Client { /// Reply to a language server RPC call. pub async fn reply( - &mut self, + &self, id: jsonrpc::Id, result: core::result::Result, ) -> Result<()> { @@ -212,11 +206,11 @@ impl Client { Ok(()) } - pub async fn shutdown(&mut self) -> Result<()> { + pub async fn shutdown(&self) -> Result<()> { self.request::(()).await } - pub async fn exit(&mut self) -> Result<()> { + pub async fn exit(&self) -> Result<()> { self.notify::(()).await } diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index 802dd399..a4a3cf09 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -8,6 +8,8 @@ use helix_view::{ Document, Editor, Theme, View, }; +use log::{debug, info}; + use std::{ borrow::Cow, io::{self, stdout, Stdout, Write}, @@ -46,7 +48,7 @@ pub struct Application<'a> { keymap: Keymaps, executor: &'a smol::Executor<'a>, - lsp: helix_lsp::Client, + language_server: helix_lsp::Client, } struct Renderer { @@ -370,7 +372,7 @@ impl<'a> Application<'a> { editor.open(file, terminal.size)?; } - let lsp = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); + let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]); let mut app = Self { editor, @@ -381,7 +383,7 @@ impl<'a> Application<'a> { // keymap: keymap::default(), executor, - lsp, + language_server, }; Ok(app) @@ -415,11 +417,11 @@ impl<'a> Application<'a> { let mut reader = EventStream::new(); // initialize lsp - let res = self.lsp.initialize().await; - let res = self - .lsp + self.language_server.initialize().await.unwrap(); + self.language_server .text_document_did_open(&self.editor.view().unwrap().doc) - .await; + .await + .unwrap(); self.render(); @@ -433,8 +435,8 @@ impl<'a> Application<'a> { event = reader.next().fuse() => { self.handle_terminal_events(event).await } - call = self.lsp.incoming.next().fuse() => { - self.handle_lsp_message(call).await + call = self.language_server.incoming.next().fuse() => { + self.handle_language_server_message(call).await } } } @@ -566,7 +568,7 @@ impl<'a> Application<'a> { }; } - pub async fn handle_lsp_message(&mut self, call: Option) { + pub async fn handle_language_server_message(&mut self, call: Option) { use helix_lsp::{Call, Notification}; match call { Some(Call::Notification(helix_lsp::jsonrpc::Notification { @@ -605,6 +607,7 @@ impl<'a> Application<'a> { view.doc.diagnostics = diagnostics; + // TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events self.render(); } } diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 52e09dd6..f2e62044 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -404,6 +404,8 @@ fn append_changes_to_history(view: &mut View) { 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); + + // TODO: notify LSP of changes } pub fn normal_mode(view: &mut View, _count: usize) { -- cgit v1.2.3-70-g09d2 From 8f0bcfe286d97dfff67bd924e11ca2b6ae1a63dc Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 30 Oct 2020 14:09:59 +0900 Subject: Introduce a command context that carries the executor and other fields. --- helix-term/src/application.rs | 29 ++- helix-view/src/commands.rs | 454 ++++++++++++++++++++++-------------------- 2 files changed, 264 insertions(+), 219 deletions(-) (limited to 'helix-view') diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index a4a3cf09..cacfde56 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -476,13 +476,24 @@ impl<'a> Application<'a> { match view.doc.mode() { Mode::Insert => { if let Some(command) = self.keymap[&Mode::Insert].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + + command(&mut cx); } else if let KeyEvent { code: KeyCode::Char(c), .. } = event { - commands::insert::insert_char(view, c); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + commands::insert::insert_char(&mut cx, c); } view.ensure_cursor_in_view(); } @@ -544,7 +555,12 @@ impl<'a> Application<'a> { // HAXX: special casing for command mode } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + command(&mut cx); // TODO: simplistic ensure cursor in view for now view.ensure_cursor_in_view(); @@ -552,7 +568,12 @@ impl<'a> Application<'a> { } mode => { if let Some(command) = self.keymap[&mode].get(&keys) { - command(view, 1); + let mut cx = helix_view::commands::Context { + view, + executor: self.executor, + count: 1, + }; + command(&mut cx); // TODO: simplistic ensure cursor in view for now view.ensure_cursor_in_view(); diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index f2e62044..26c7a190 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -14,44 +14,54 @@ use crate::{ view::{View, PADDING}, }; +pub struct Context<'a, 'b> { + pub count: usize, + pub view: &'a mut View, + pub executor: &'a smol::Executor<'b>, +} + /// A command is a function that takes the current state and a count, and does a side-effect on the /// state (usually by creating and applying a transaction). -pub type Command = fn(view: &mut View, count: usize); +pub type Command = fn(cx: &mut Context); -pub fn move_char_left(view: &mut View, count: usize) { +pub fn move_char_left(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .move_selection(Direction::Backward, Granularity::Character, count); - view.doc.set_selection(selection); + .move_selection(Direction::Backward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_char_right(view: &mut View, count: usize) { +pub fn move_char_right(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .move_selection(Direction::Forward, Granularity::Character, count); - view.doc.set_selection(selection); + .move_selection(Direction::Forward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_up(view: &mut View, count: usize) { - let selection = view - .doc - .state - .move_selection(Direction::Backward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn move_line_up(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .move_selection(Direction::Backward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_down(view: &mut View, count: usize) { - let selection = view - .doc - .state - .move_selection(Direction::Forward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn move_line_down(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .move_selection(Direction::Forward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn move_line_end(view: &mut View, _count: usize) { - let lines = selection_lines(&view.doc.state); +pub fn move_line_end(cx: &mut Context) { + let lines = selection_lines(&cx.view.doc.state); let positions = lines .into_iter() @@ -60,78 +70,78 @@ 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.doc.text().line_to_char(index + 1).saturating_sub(2) + cx.view.doc.text().line_to_char(index + 1).saturating_sub(2) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn move_line_start(view: &mut View, _count: usize) { - let lines = selection_lines(&view.doc.state); +pub fn move_line_start(cx: &mut Context) { + let lines = selection_lines(&cx.view.doc.state); let positions = lines .into_iter() .map(|index| { // adjust all positions to the start of the line. - view.doc.text().line_to_char(index) + cx.view.doc.text().line_to_char(index) }) .map(|pos| Range::new(pos, pos)); let selection = Selection::new(positions.collect(), 0); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn move_next_word_start(view: &mut View, count: usize) { - let pos = view.doc.state.move_pos( - view.doc.selection().cursor(), +pub fn move_next_word_start(cx: &mut Context) { + let pos = cx.view.doc.state.move_pos( + cx.view.doc.selection().cursor(), Direction::Forward, Granularity::Word, - count, + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_prev_word_start(view: &mut View, count: usize) { - let pos = view.doc.state.move_pos( - view.doc.selection().cursor(), +pub fn move_prev_word_start(cx: &mut Context) { + let pos = cx.view.doc.state.move_pos( + cx.view.doc.selection().cursor(), Direction::Backward, Granularity::Word, - count, + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_next_word_end(view: &mut View, count: usize) { +pub fn move_next_word_end(cx: &mut Context) { let pos = State::move_next_word_end( - &view.doc.text().slice(..), - view.doc.selection().cursor(), - count, + &cx.view.doc.text().slice(..), + cx.view.doc.selection().cursor(), + cx.count, ); - view.doc.set_selection(Selection::point(pos)); + cx.view.doc.set_selection(Selection::point(pos)); } -pub fn move_file_start(view: &mut View, _count: usize) { - view.doc.set_selection(Selection::point(0)); +pub fn move_file_start(cx: &mut Context) { + cx.view.doc.set_selection(Selection::point(0)); - view.doc.mode = Mode::Normal; + cx.view.doc.mode = Mode::Normal; } -pub fn move_file_end(view: &mut View, _count: usize) { - let text = &view.doc.text(); +pub fn move_file_end(cx: &mut Context) { + let text = &cx.view.doc.text(); let last_line = text.line_to_char(text.len_lines().saturating_sub(2)); - view.doc.set_selection(Selection::point(last_line)); + cx.view.doc.set_selection(Selection::point(last_line)); - view.doc.mode = Mode::Normal; + cx.view.doc.mode = Mode::Normal; } -pub fn check_cursor_in_view(view: &mut View) -> bool { +pub fn check_cursor_in_view(view: &View) -> bool { let cursor = view.doc.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; @@ -142,172 +152,182 @@ pub fn check_cursor_in_view(view: &mut View) -> bool { true } -pub fn page_up(view: &mut View, _count: usize) { - if view.first_line < PADDING { +pub fn page_up(cx: &mut Context) { + if cx.view.first_line < PADDING { return; } - view.first_line = view.first_line.saturating_sub(view.size.1 as usize); + cx.view.first_line = cx.view.first_line.saturating_sub(cx.view.size.1 as usize); - if !check_cursor_in_view(view) { - let text = view.doc.text(); - let pos = text.line_to_char(view.last_line().saturating_sub(PADDING)); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.last_line().saturating_sub(PADDING)); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn page_down(view: &mut View, _count: usize) { - view.first_line += view.size.1 as usize + PADDING; +pub fn page_down(cx: &mut Context) { + cx.view.first_line += cx.view.size.1 as usize + PADDING; - 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.doc.set_selection(Selection::point(pos)); + if cx.view.first_line < cx.view.doc.text().len_lines() { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.first_line as usize); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn half_page_up(view: &mut View, _count: usize) { - if view.first_line < PADDING { +pub fn half_page_up(cx: &mut Context) { + if cx.view.first_line < PADDING { return; } - view.first_line = view.first_line.saturating_sub(view.size.1 as usize / 2); + cx.view.first_line = cx + .view + .first_line + .saturating_sub(cx.view.size.1 as usize / 2); - if !check_cursor_in_view(view) { - let text = &view.doc.text(); - let pos = text.line_to_char(view.last_line() - PADDING); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = &cx.view.doc.text(); + let pos = text.line_to_char(cx.view.last_line() - PADDING); + cx.view.doc.set_selection(Selection::point(pos)); } } -pub fn half_page_down(view: &mut View, _count: usize) { - 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; +pub fn half_page_down(cx: &mut Context) { + let lines = cx.view.doc.text().len_lines(); + if cx.view.first_line < lines.saturating_sub(cx.view.size.1 as usize) { + cx.view.first_line += cx.view.size.1 as usize / 2; } - if !check_cursor_in_view(view) { - let text = view.doc.text(); - let pos = text.line_to_char(view.first_line as usize); - view.doc.set_selection(Selection::point(pos)); + if !check_cursor_in_view(cx.view) { + let text = cx.view.doc.text(); + let pos = text.line_to_char(cx.view.first_line as usize); + cx.view.doc.set_selection(Selection::point(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) { +pub fn extend_char_left(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .extend_selection(Direction::Backward, Granularity::Character, count); - view.doc.set_selection(selection); + .extend_selection(Direction::Backward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_char_right(view: &mut View, count: usize) { +pub fn extend_char_right(cx: &mut Context) { let selection = - view.doc + cx.view + .doc .state - .extend_selection(Direction::Forward, Granularity::Character, count); - view.doc.set_selection(selection); + .extend_selection(Direction::Forward, Granularity::Character, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_line_up(view: &mut View, count: usize) { - let selection = view - .doc - .state - .extend_selection(Direction::Backward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn extend_line_up(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .extend_selection(Direction::Backward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn extend_line_down(view: &mut View, count: usize) { - let selection = view - .doc - .state - .extend_selection(Direction::Forward, Granularity::Line, count); - view.doc.set_selection(selection); +pub fn extend_line_down(cx: &mut Context) { + let selection = + cx.view + .doc + .state + .extend_selection(Direction::Forward, Granularity::Line, cx.count); + cx.view.doc.set_selection(selection); } -pub fn split_selection_on_newline(view: &mut View, _count: usize) { - let text = &view.doc.text().slice(..); +pub fn split_selection_on_newline(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); // only compile the regex once #[allow(clippy::trivial_regex)] static REGEX: Lazy = Lazy::new(|| Regex::new(r"\n").unwrap()); - let selection = selection::split_on_matches(text, view.doc.selection(), ®EX); - view.doc.set_selection(selection); + let selection = selection::split_on_matches(text, cx.view.doc.selection(), ®EX); + cx.view.doc.set_selection(selection); } -pub fn select_line(view: &mut View, _count: usize) { +pub fn select_line(cx: &mut Context) { // TODO: count - let pos = view.doc.selection().primary(); - let text = view.doc.text(); + let pos = cx.view.doc.selection().primary(); + let text = cx.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); - view.doc.set_selection(Selection::single(start, end)); + cx.view.doc.set_selection(Selection::single(start, end)); } -pub fn delete_selection(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { +pub fn delete_selection(cx: &mut Context) { + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { (range.from(), range.to() + 1, None) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); - append_changes_to_history(view); + append_changes_to_history(cx); } -pub fn change_selection(view: &mut View, count: usize) { - delete_selection(view, count); - insert_mode(view, count); +pub fn change_selection(cx: &mut Context) { + delete_selection(cx); + insert_mode(cx); } -pub fn collapse_selection(view: &mut View, _count: usize) { - let selection = view +pub fn collapse_selection(cx: &mut Context) { + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.head, range.head)); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -pub fn flip_selections(view: &mut View, _count: usize) { - let selection = view +pub fn flip_selections(cx: &mut Context) { + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.head, range.anchor)); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } -fn enter_insert_mode(view: &mut View) { - view.doc.mode = Mode::Insert; +fn enter_insert_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Insert; - append_changes_to_history(view); + append_changes_to_history(cx); } // inserts at the start of each selection -pub fn insert_mode(view: &mut View, _count: usize) { - enter_insert_mode(view); +pub fn insert_mode(cx: &mut Context) { + enter_insert_mode(cx); - let selection = view + let selection = cx + .view .doc .selection() .transform(|range| Range::new(range.to(), range.from())); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } // inserts at the end of each selection -pub fn append_mode(view: &mut View, _count: usize) { - enter_insert_mode(view); - view.doc.restore_cursor = true; +pub fn append_mode(cx: &mut Context) { + enter_insert_mode(cx); + cx.view.doc.restore_cursor = true; // TODO: as transaction - let text = &view.doc.text().slice(..); - let selection = view.doc.selection().transform(|range| { + let text = &cx.view.doc.text().slice(..); + let selection = cx.view.doc.selection().transform(|range| { // TODO: to() + next char Range::new( range.from(), graphemes::next_grapheme_boundary(text, range.to()), ) }); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); } // TODO: I, A, o and O can share a lot of the primitives. @@ -332,30 +352,30 @@ fn selection_lines(state: &State) -> Vec { } // I inserts at the start of each line with a selection -pub fn prepend_to_line(view: &mut View, count: usize) { - enter_insert_mode(view); +pub fn prepend_to_line(cx: &mut Context) { + enter_insert_mode(cx); - move_line_start(view, count); + move_line_start(cx); } // A inserts at the end of each line with a selection -pub fn append_to_line(view: &mut View, count: usize) { - enter_insert_mode(view); +pub fn append_to_line(cx: &mut Context) { + enter_insert_mode(cx); - move_line_end(view, count); + move_line_end(cx); } // o inserts a new line after each line with a selection -pub fn open_below(view: &mut View, _count: usize) { - enter_insert_mode(view); +pub fn open_below(cx: &mut Context) { + enter_insert_mode(cx); - let lines = selection_lines(&view.doc.state); + let lines = selection_lines(&cx.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.doc.text().line_to_char(index + 1) + cx.view.doc.text().line_to_char(index + 1) }) .collect(); @@ -376,82 +396,85 @@ pub fn open_below(view: &mut View, _count: usize) { 0, ); - let transaction = Transaction::change(&view.doc.state, changes).with_selection(selection); + let transaction = Transaction::change(&cx.view.doc.state, changes).with_selection(selection); - view.doc.apply(&transaction); + cx.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.doc.changes.is_empty() { +fn append_changes_to_history(cx: &mut Context) { + if cx.view.doc.changes.is_empty() { return; } - let new_changeset = ChangeSet::new(view.doc.text()); - let changes = std::mem::replace(&mut view.doc.changes, new_changeset); + let new_changeset = ChangeSet::new(cx.view.doc.text()); + let changes = std::mem::replace(&mut cx.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.doc.selection().clone()); + let transaction = Transaction::from(changes).with_selection(cx.view.doc.selection().clone()); // increment document version // TODO: needs to happen on undo/redo too - view.doc.version += 1; + cx.view.doc.version += 1; // TODO: trigger lsp/documentDidChange with changes // HAXX: we need to reconstruct the state as it was before the changes.. - let old_state = std::mem::replace(&mut view.doc.old_state, view.doc.state.clone()); + let old_state = std::mem::replace(&mut cx.view.doc.old_state, cx.view.doc.state.clone()); // TODO: take transaction by value? - view.doc.history.commit_revision(&transaction, &old_state); + cx.view + .doc + .history + .commit_revision(&transaction, &old_state); // TODO: notify LSP of changes } -pub fn normal_mode(view: &mut View, _count: usize) { - view.doc.mode = Mode::Normal; +pub fn normal_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Normal; - append_changes_to_history(view); + append_changes_to_history(cx); // if leaving append mode, move cursor back by 1 - if view.doc.restore_cursor { - let text = &view.doc.text().slice(..); - let selection = view.doc.selection().transform(|range| { + if cx.view.doc.restore_cursor { + let text = &cx.view.doc.text().slice(..); + let selection = cx.view.doc.selection().transform(|range| { Range::new( range.from(), graphemes::prev_grapheme_boundary(text, range.to()), ) }); - view.doc.set_selection(selection); + cx.view.doc.set_selection(selection); - view.doc.restore_cursor = false; + cx.view.doc.restore_cursor = false; } } -pub fn goto_mode(view: &mut View, _count: usize) { - view.doc.mode = Mode::Goto; +pub fn goto_mode(cx: &mut Context) { + cx.view.doc.mode = Mode::Goto; } // NOTE: Transactions in this module get appended to history when we switch back to normal mode. pub mod insert { use super::*; // 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) { + pub fn insert_char(cx: &mut Context, c: char) { let c = Tendril::from_char(c); - let transaction = Transaction::insert(&view.doc.state, c); + let transaction = Transaction::insert(&cx.view.doc.state, c); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } - pub fn insert_tab(view: &mut View, _count: usize) { - insert_char(view, '\t'); + pub fn insert_tab(cx: &mut Context) { + insert_char(cx, '\t'); } - pub fn insert_newline(view: &mut View, _count: usize) { - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn insert_newline(cx: &mut Context) { + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { let indent_level = helix_core::indent::suggested_indent_for_pos( - view.doc.syntax.as_ref(), - &view.doc.state, + cx.view.doc.syntax.as_ref(), + &cx.view.doc.state, range.head, ); let indent = " ".repeat(TAB_WIDTH).repeat(indent_level); @@ -460,32 +483,32 @@ pub mod insert { text.push_str(&indent); (range.head, range.head, Some(text.into())) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } // TODO: handle indent-aware delete - pub fn delete_char_backward(view: &mut View, count: usize) { - let text = &view.doc.text().slice(..); - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn delete_char_backward(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { ( - graphemes::nth_prev_grapheme_boundary(text, range.head, count), + graphemes::nth_prev_grapheme_boundary(text, range.head, cx.count), range.head, None, ) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } - pub fn delete_char_forward(view: &mut View, count: usize) { - let text = &view.doc.text().slice(..); - let transaction = Transaction::change_by_selection(&view.doc.state, |range| { + pub fn delete_char_forward(cx: &mut Context) { + let text = &cx.view.doc.text().slice(..); + let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| { ( range.head, - graphemes::nth_next_grapheme_boundary(text, range.head, count), + graphemes::nth_next_grapheme_boundary(text, range.head, cx.count), None, ) }); - view.doc.apply(&transaction); + cx.view.doc.apply(&transaction); } } @@ -495,31 +518,32 @@ pub fn insert_char_prompt(prompt: &mut Prompt, c: char) { // Undo / Redo -pub fn undo(view: &mut View, _count: usize) { - if let Some(revert) = view.doc.history.undo() { - view.doc.version += 1; - view.doc.apply(&revert); +pub fn undo(cx: &mut Context) { + if let Some(revert) = cx.view.doc.history.undo() { + cx.view.doc.version += 1; + cx.view.doc.apply(&revert); } // TODO: each command could simply return a Option, then the higher level handles storing it? } -pub fn redo(view: &mut View, _count: usize) { - if let Some(transaction) = view.doc.history.redo() { - view.doc.version += 1; - view.doc.apply(&transaction); +pub fn redo(cx: &mut Context) { + if let Some(transaction) = cx.view.doc.history.redo() { + cx.view.doc.version += 1; + cx.view.doc.apply(&transaction); } } // Yank / Paste -pub fn yank(view: &mut View, _count: usize) { +pub fn yank(cx: &mut Context) { // TODO: should selections be made end inclusive? - let values = view + let values = cx + .view .doc .state .selection() - .fragments(&view.doc.text().slice(..)) + .fragments(&cx.view.doc.text().slice(..)) .map(|cow| cow.into_owned()) .collect(); @@ -528,7 +552,7 @@ pub fn yank(view: &mut View, _count: usize) { register::set(reg, values); } -pub fn paste(view: &mut View, _count: usize) { +pub fn paste(cx: &mut Context) { // TODO: allow specifying reg let reg = '"'; if let Some(values) = register::get(reg) { @@ -560,19 +584,19 @@ 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.doc.text(); - Transaction::change_by_selection(&view.doc.state, |range| { + let text = cx.view.doc.text(); + Transaction::change_by_selection(&cx.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.doc.state, |range| { + Transaction::change_by_selection(&cx.view.doc.state, |range| { (range.head + 1, range.head + 1, Some(values.next().unwrap())) }) }; - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } } @@ -593,29 +617,29 @@ fn get_lines(view: &View) -> Vec { lines } -pub fn indent(view: &mut View, _count: usize) { - let lines = get_lines(view); +pub fn indent(cx: &mut Context) { + let lines = get_lines(cx.view); // Indent by one level let indent = Tendril::from(" ".repeat(TAB_WIDTH)); let transaction = Transaction::change( - &view.doc.state, + &cx.view.doc.state, lines.into_iter().map(|line| { - let pos = view.doc.text().line_to_char(line); + let pos = cx.view.doc.text().line_to_char(line); (pos, pos, Some(indent.clone())) }), ); - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } -pub fn unindent(view: &mut View, _count: usize) { - let lines = get_lines(view); +pub fn unindent(cx: &mut Context) { + let lines = get_lines(cx.view); let mut changes = Vec::with_capacity(lines.len()); for line_idx in lines { - let line = view.doc.text().line(line_idx); + let line = cx.view.doc.text().line(line_idx); let mut width = 0; for ch in line.chars() { @@ -631,18 +655,18 @@ pub fn unindent(view: &mut View, _count: usize) { } if width > 0 { - let start = view.doc.text().line_to_char(line_idx); + let start = cx.view.doc.text().line_to_char(line_idx); changes.push((start, start + width, None)) } } - let transaction = Transaction::change(&view.doc.state, changes.into_iter()); + let transaction = Transaction::change(&cx.view.doc.state, changes.into_iter()); - view.doc.apply(&transaction); - append_changes_to_history(view); + cx.view.doc.apply(&transaction); + append_changes_to_history(cx); } -pub fn indent_selection(_view: &mut View, _count: usize) { +pub fn indent_selection(_cx: &mut Context) { // loop over each line and recompute proper indentation unimplemented!() } -- cgit v1.2.3-70-g09d2 From 3f707c19f46284d745568c632a57103eb1be4dd4 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Fri, 30 Oct 2020 17:00:30 +0900 Subject: Save command --- Cargo.lock | 1 + helix-term/src/main.rs | 12 +++--------- helix-view/Cargo.toml | 2 ++ helix-view/src/commands.rs | 12 ++++++++++-- helix-view/src/document.rs | 25 +++++++++++++++++++++++++ 5 files changed, 41 insertions(+), 11 deletions(-) (limited to 'helix-view') diff --git a/Cargo.lock b/Cargo.lock index 28fc503c..e89696ad 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -523,6 +523,7 @@ dependencies = [ "crossterm", "helix-core", "once_cell", + "smol", "tui", "url", ] diff --git a/helix-term/src/main.rs b/helix-term/src/main.rs index f91c1c8f..9378d3ee 100644 --- a/helix-term/src/main.rs +++ b/helix-term/src/main.rs @@ -70,16 +70,10 @@ 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 app = Application::new(args, &EX).unwrap(); - 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 {} - - Application::new(args, &EX).unwrap().run().await; - }); + // we use the thread local executor to spawn the application task separately from the work pool + smol::block_on(app.run()); Ok(()) } diff --git a/helix-view/Cargo.toml b/helix-view/Cargo.toml index 9d53f929..0a48b721 100644 --- a/helix-view/Cargo.toml +++ b/helix-view/Cargo.toml @@ -20,3 +20,5 @@ tui = { git = "https://github.com/fdehau/tui-rs", default-features = false, feat crossterm = { version = "0.18", features = ["event-stream"], optional = true} once_cell = "1.4" url = "2" + +smol = "1" diff --git a/helix-view/src/commands.rs b/helix-view/src/commands.rs index 26c7a190..c135a3da 100644 --- a/helix-view/src/commands.rs +++ b/helix-view/src/commands.rs @@ -331,8 +331,7 @@ pub fn append_mode(cx: &mut Context) { } // TODO: I, A, o and O can share a lot of the primitives. - -pub fn command_mode(_view: &mut View, _count: usize) { +pub fn command_mode(_cx: &mut Context) { unimplemented!() } @@ -670,3 +669,12 @@ pub fn indent_selection(_cx: &mut Context) { // loop over each line and recompute proper indentation unimplemented!() } + +// + +pub fn save(cx: &mut Context) { + // Spawns an async task to actually do the saving. This way we prevent blocking. + + // TODO: handle save errors somehow? + cx.executor.spawn(cx.view.doc.save()).detach(); +} diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 710ea4f8..1587de8b 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -1,4 +1,5 @@ use anyhow::Error; +use std::future::Future; use std::path::PathBuf; use helix_core::{ @@ -97,6 +98,30 @@ impl Document { Ok(doc) } + pub fn save(&self) -> impl Future> { + // we clone and move text + path into the future so that we asynchronously save the current + // state without blocking any further edits. + + let text = self.text().clone(); + let path = self.path.clone().expect("Can't save with no path set!"); // TODO: handle no path + + // TODO: mark changes up to now as saved + // TODO: mark dirty false + + async move { + use smol::{fs::File, prelude::*}; + let mut file = File::create(path).await?; + + // write all the rope chunks to file + for chunk in text.chunks() { + file.write_all(chunk.as_bytes()).await?; + } + // TODO: flush? + + Ok(()) + } // and_then(// lsp.send_text_saved_notification()) + } + 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(); -- cgit v1.2.3-70-g09d2 From a7869c728c663f255d5d2544e42f21ccf57b2414 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Thu, 5 Nov 2020 15:15:19 +0900 Subject: wip --- Cargo.lock | 68 ++++++++++++++++++++----------------------- helix-core/src/syntax.rs | 4 +++ helix-lsp/Cargo.toml | 1 + helix-lsp/src/lib.rs | 53 +++++++++++++++++++++++++++++++++ helix-term/src/application.rs | 14 +++++++-- helix-view/src/document.rs | 15 ++++++++++ 6 files changed, 115 insertions(+), 40 deletions(-) (limited to 'helix-view') diff --git a/Cargo.lock b/Cargo.lock index e89696ad..c9e421a2 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2,24 +2,18 @@ # It is not intended for manual editing. [[package]] name = "aho-corasick" -version = "0.7.14" +version = "0.7.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b476ce7103678b0c6d3d395dbbae31d48ff910bd28be979ba5d48c6351131d0d" +checksum = "7404febffaa47dac81aa44dba71523c9d069b1bdc50a77db41195149e17f68e5" dependencies = [ "memchr", ] [[package]] name = "anyhow" -version = "1.0.33" +version = "1.0.34" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1fd36ffbb1fb7c834eac128ea8d0e310c5aeb635548f9d58861e1308d46e71c" - -[[package]] -name = "arc-swap" -version = "0.4.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d25d88fd6b8041580a654f9d0c581a047baee2b3efee13275f2fc392fc75034" +checksum = "bf8dcb5b4bbaa28653b647d8c77bd4ed40183b48882e130c1f1ffb73de069fd7" [[package]] name = "arrayref" @@ -158,9 +152,9 @@ checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693" [[package]] name = "blake2b_simd" -version = "0.5.10" +version = "0.5.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8fb2d74254a3a0b5cac33ac9f8ed0e44aa50378d9dbb2e5d83bd21ed1dc2c8a" +checksum = "afa748e348ad3be8263be728124b24a24f268266f6f5d58af9d75f6a40b5c587" dependencies = [ "arrayref", "arrayvec", @@ -279,9 +273,9 @@ dependencies = [ [[package]] name = "crossterm" -version = "0.18.1" +version = "0.18.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cef9149b29071d44c9fb98fd9c27fcf74405bbdb761889ad6a03f36be93b0b15" +checksum = "4e86d73f2a0b407b5768d10a8c720cf5d2df49a9efc10ca09176d201ead4b7fb" dependencies = [ "bitflags", "crossterm_winapi", @@ -479,6 +473,7 @@ dependencies = [ "jsonrpc-core", "log", "lsp-types", + "once_cell", "pathdiff", "serde", "serde_json", @@ -653,15 +648,15 @@ checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08" [[package]] name = "memchr" -version = "2.3.3" +version = "2.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400" +checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525" [[package]] name = "mio" -version = "0.7.4" +version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8f1c83949125de4a582aa2da15ae6324d91cf6a58a70ea407643941ff98f558" +checksum = "8962c171f57fcfffa53f4df1bb15ec4c8cf26a7569459c9ceb62d94aab0d9584" dependencies = [ "libc", "log", @@ -707,9 +702,9 @@ dependencies = [ [[package]] name = "num-integer" -version = "0.1.43" +version = "0.1.44" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8d59457e662d541ba17869cf51cf177c0b5f0cbf476c66bdc90bf1edac4f875b" +checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db" dependencies = [ "autocfg", "num-traits", @@ -717,9 +712,9 @@ dependencies = [ [[package]] name = "num-traits" -version = "0.2.12" +version = "0.2.14" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac267bcc07f48ee5f8935ab0d24f316fb722d7a1292e2913f0cc196b29ffd611" +checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290" dependencies = [ "autocfg", ] @@ -837,9 +832,9 @@ dependencies = [ [[package]] name = "proc-macro-hack" -version = "0.5.18" +version = "0.5.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "99c605b9a0adc77b7211c6b1f722dcb613d68d66859a44f3d485a6da332b0598" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" [[package]] name = "proc-macro-nested" @@ -884,9 +879,9 @@ dependencies = [ [[package]] name = "regex" -version = "1.4.1" +version = "1.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8963b85b8ce3074fecffde43b4b0dded83ce2f367dc8d363afc56679f3ee820b" +checksum = "38cf2c13ed4745de91a5eb834e11c00bcc3709e773173b2ce4c56c9fbde04b9c" dependencies = [ "aho-corasick", "memchr", @@ -896,9 +891,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.6.20" +version = "0.6.21" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cab7a364d15cde1e505267766a2d3c4e22a843e1a601f0fa7564c0f82ced11c" +checksum = "3b181ba2dcf07aaccad5448e8ead58db5b742cf85dfe035e2227f137a539a189" [[package]] name = "ropey" @@ -997,11 +992,10 @@ dependencies = [ [[package]] name = "signal-hook-registry" -version = "1.2.1" +version = "1.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a3e12110bc539e657a646068aaf5eb5b63af9d0c1f7b29c97113fad80e15f035" +checksum = "ce32ea0c6c56d5eacaeb814fbed9960547021d3edd010ded1425f180536b20ab" dependencies = [ - "arc-swap", "libc", ] @@ -1079,18 +1073,18 @@ dependencies = [ [[package]] name = "thiserror" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "318234ffa22e0920fe9a40d7b8369b5f649d490980cf7aadcf1eb91594869b42" +checksum = "0e9ae34b84616eedaaf1e9dd6026dbe00dcafa92aa0c8077cb69df1fcfe5e53e" dependencies = [ "thiserror-impl", ] [[package]] name = "thiserror-impl" -version = "1.0.21" +version = "1.0.22" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cae2447b6282786c3493999f40a9be2a6ad20cb8bd268b0a0dbf5a065535c0ab" +checksum = "9ba20f23e85b10754cd195504aebf6a27e2e6cbe28c17778a0c930724628dd56" dependencies = [ "proc-macro2", "quote", @@ -1125,9 +1119,9 @@ checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117" [[package]] name = "tree-sitter" -version = "0.17.0" +version = "0.17.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70ee7370fec3aecde3862a7d64c571048f70a7298daef1815e8fc68b9de54b5c" +checksum = "d18dcb776d3affaba6db04d11d645946d34a69b3172e588af96ce9fecd20faac" dependencies = [ "cc", "regex", diff --git a/helix-core/src/syntax.rs b/helix-core/src/syntax.rs index f4826fb4..70d42c47 100644 --- a/helix-core/src/syntax.rs +++ b/helix-core/src/syntax.rs @@ -62,6 +62,10 @@ impl LanguageConfiguration { }) .map(Option::as_ref) } + + pub fn scope(&self) -> &str { + &self.scope + } } use once_cell::sync::Lazy; diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 0c5d8b91..08216f59 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -9,6 +9,7 @@ edition = "2018" [dependencies] helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } +once_cell = "1.4" lsp-types = { version = "0.83", features = ["proposed"] } smol = "1.2" diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 1ee8199f..8353ef7d 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -4,11 +4,15 @@ mod transport; pub use jsonrpc_core as jsonrpc; pub use lsp_types as lsp; +pub use once_cell::sync::{Lazy, OnceCell}; + pub use client::Client; pub use lsp::{Position, Url}; use thiserror::Error; +use std::{collections::HashMap, sync::Arc}; + #[derive(Error, Debug)] pub enum Error { #[error("protocol error: {0}")] @@ -62,3 +66,52 @@ impl Notification { } pub use jsonrpc::Call; + +type LanguageId = String; + +pub static REGISTRY: Lazy = Lazy::new(Registry::init); + +pub struct Registry { + inner: HashMap>>, +} + +impl Registry { + pub fn init() -> Self { + Self { + inner: HashMap::new(), + } + } + + pub fn get(&self, id: &str, ex: &smol::Executor) -> Option> { + // TODO: use get_or_try_init and propagate the error + self.inner + .get(id) + .map(|cell| { + cell.get_or_init(|| { + // TODO: lookup defaults for id (name, args) + + // initialize a new client + let client = Client::start(&ex, "rust-analyzer", &[]); + // TODO: also call initialize().await() + Arc::new(client) + }) + }) + .cloned() + } +} + +// REGISTRY = HashMap>> +// spawn one server per language type, need to spawn one per workspace if server doesn't support +// workspaces +// +// could also be a client per root dir +// +// storing a copy of Option>> on Document would make the LSP client easily +// accessible during edit/save callbacks +// +// the event loop needs to process all incoming streams, maybe we can just have that be a separate +// task that's continually running and store the state on the client, then use read lock to +// retrieve data during render +// -> PROBLEM: how do you trigger an update on the editor side when data updates? +// +// -> The data updates should pull all events until we run out so we don't frequently re-render diff --git a/helix-term/src/application.rs b/helix-term/src/application.rs index cacfde56..141779ec 100644 --- a/helix-term/src/application.rs +++ b/helix-term/src/application.rs @@ -636,9 +636,17 @@ impl<'a> Application<'a> { } } Some(Call::MethodCall(call)) => { - // TODO: need to make Result - - unimplemented!("{:?}", call) + debug!("Method not found {}", call.method); + + self.language_server.reply( + call.id, + // TODO: make a Into trait that can cast to Err(jsonrpc::Error) + Err(helix_lsp::jsonrpc::Error { + code: helix_lsp::jsonrpc::ErrorCode::MethodNotFound, + message: "Method not found".to_string(), + data: None, + }), + ); } _ => unreachable!(), } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index 1587de8b..e8f311c5 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -25,6 +25,8 @@ pub struct Document { /// Tree-sitter AST tree pub syntax: Option, + /// Corresponding language scope name. Usually `source.`. + pub language: Option, /// Pending changes since last history commit. pub changes: ChangeSet, @@ -64,6 +66,7 @@ impl Document { mode: Mode::Normal, restore_cursor: false, syntax: None, + language: None, changes, old_state, diagnostics: Vec::new(), @@ -73,6 +76,7 @@ impl Document { } // TODO: passing scopes here is awkward + // TODO: async fn? pub fn load(path: PathBuf, scopes: &[String]) -> Result { use std::{env, fs::File, io::BufReader}; let _current_dir = env::current_dir()?; @@ -90,6 +94,15 @@ impl Document { let syntax = Syntax::new(&doc.state.doc, highlight_config.clone()); doc.syntax = Some(syntax); + // TODO: maybe just keep an Arc<> pointer to the language_config? + doc.language = Some(language_config.scope().to_string()); + + // TODO: this ties lsp support to tree-sitter enabled languages for now. Language + // config should use Option to let us have non-tree-sitter configs. + + // TODO: circular dep: view <-> lsp + // helix_lsp::REGISTRY; + // view should probably depend on lsp }; // canonicalize path to absolute value @@ -98,6 +111,8 @@ impl Document { Ok(doc) } + // TODO: do we need some way of ensuring two save operations on the same doc can't run at once? + // or is that handled by the OS/async layer pub fn save(&self) -> impl Future> { // we clone and move text + path into the future so that we asynchronously save the current // state without blocking any further edits. -- cgit v1.2.3-70-g09d2 From 39bf1ca82514e1dc56dfebdce2558cce662367d1 Mon Sep 17 00:00:00 2001 From: Blaž Hrastnik Date: Tue, 1 Dec 2020 09:53:17 +0900 Subject: Update deps. --- Cargo.lock | 150 ++++++++++++++++++++++++++------------------- helix-lsp/Cargo.toml | 2 +- helix-lsp/src/client.rs | 3 +- helix-lsp/src/lib.rs | 2 +- helix-view/src/document.rs | 2 +- 5 files changed, 93 insertions(+), 66 deletions(-) (limited to 'helix-view') diff --git a/Cargo.lock b/Cargo.lock index c9e421a2..a3e93bd7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -40,9 +40,9 @@ dependencies = [ [[package]] name = "async-executor" -version = "1.3.0" +version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d373d78ded7d0b3fa8039375718cde0aace493f2e34fb60f51cbf567562ca801" +checksum = "eb877970c7b440ead138f6321a3b5395d6061183af779340b65e20c0fede9146" dependencies = [ "async-task", "concurrent-queue", @@ -65,9 +65,9 @@ dependencies = [ [[package]] name = "async-io" -version = "1.1.10" +version = "1.3.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d54bc4c1c7292475efb2253227dbcfad8fe1ca4c02bc62c510cc2f3da5c4704e" +checksum = "9315f8f07556761c3e48fec2e6b276004acf426e6dc068b2c2251854d65ee0fd" dependencies = [ "concurrent-queue", "fastrand", @@ -144,6 +144,12 @@ version = "0.12.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3441f0f7b02788e948e47f457ca01f1d7e6d92c693bc132c22b087d3141c03ff" +[[package]] +name = "base64" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd" + [[package]] name = "bitflags" version = "1.2.1" @@ -189,9 +195,9 @@ checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53" [[package]] name = "cc" -version = "1.0.61" +version = "1.0.65" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed67cbde08356238e75fc4656be4749481eeffb09e19f320a25237d5221c985d" +checksum = "95752358c8f7552394baf48cd82695b345628ad3f170d607de3ca03b8dacca15" dependencies = [ "jobserver", ] @@ -262,12 +268,12 @@ checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" [[package]] name = "crossbeam-utils" -version = "0.7.2" +version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8" +checksum = "02d96d1e189ef58269ebe5b97953da3274d83a93af647c2ddd6f9dab28cedb8d" dependencies = [ "autocfg", - "cfg-if 0.1.10", + "cfg-if 1.0.0", "lazy_static", ] @@ -342,6 +348,16 @@ dependencies = [ "log", ] +[[package]] +name = "form_urlencoded" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ece68d15c92e84fa4f19d3780f1294e5ca82a78a6d515f1efaabcc144688be00" +dependencies = [ + "matches", + "percent-encoding", +] + [[package]] name = "futf" version = "0.1.4" @@ -360,15 +376,15 @@ checksum = "4c7e4c2612746b0df8fed4ce0c69156021b704c9aefa360311c04e6e9e002eed" [[package]] name = "futures-core" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "18eaa56102984bed2c88ea39026cff3ce3b4c7f508ca970cedf2450ea10d4e46" +checksum = "847ce131b72ffb13b6109a221da9ad97a64cbe48feb1028356b836b47b8f1748" [[package]] name = "futures-io" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e1798854a4727ff944a7b12aa999f58ce7aa81db80d2dfaaf2ba06f065ddd2b" +checksum = "611834ce18aaa1bd13c4b374f5d653e1027cf99b6b502584ff8c9a64413b30bb" [[package]] name = "futures-lite" @@ -387,9 +403,9 @@ dependencies = [ [[package]] name = "futures-macro" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e36fccf3fc58563b4a14d265027c627c3b665d7fed489427e88e7cc929559efe" +checksum = "77408a692f1f97bcc61dc001d752e00643408fbc922e4d634c655df50d595556" dependencies = [ "proc-macro-hack", "proc-macro2", @@ -399,18 +415,18 @@ dependencies = [ [[package]] name = "futures-task" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96d502af37186c4fef99453df03e374683f8a1eec9dcc1e66b3b82dc8278ce3c" +checksum = "7c554eb5bf48b2426c4771ab68c6b14468b6e76cc90996f528c3338d761a4d0d" dependencies = [ "once_cell", ] [[package]] name = "futures-util" -version = "0.3.7" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abcb44342f62e6f3e8ac427b8aa815f724fd705dfad060b18ac7866c15bb8e34" +checksum = "d304cff4a7b99cfb7986f7d43fbe93d175e72e704a8860787cc95e9ffd85cbd2" dependencies = [ "futures-core", "futures-macro", @@ -555,9 +571,9 @@ dependencies = [ [[package]] name = "instant" -version = "0.1.8" +version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb1fc4429a33e1f80d41dc9fea4d108a88bec1de8053878898ae448a0b52f613" +checksum = "61124eeebbd69b8190558df225adf7e4caafce0d743919e5d6b19652314ec5ec" dependencies = [ "cfg-if 1.0.0", ] @@ -604,9 +620,9 @@ checksum = "4d58d1b70b004888f764dfbf6a26a3b0342a1632d33968e4a179d8011c760614" [[package]] name = "lock_api" -version = "0.4.1" +version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28247cc5a5be2f05fbcd76dd0cf2c7d3b5400cb978a28042abcd4fa0b3f8261c" +checksum = "dd96ffd135b2fd7b973ac026d28085defbe8983df057ced3eb4f2130b0831312" dependencies = [ "scopeguard", ] @@ -622,11 +638,11 @@ dependencies = [ [[package]] name = "lsp-types" -version = "0.83.0" +version = "0.84.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25e0bd4b95038f2c23bda332ba0ca684e8dda765db1f9bdb63dc4c3e01f3b456" +checksum = "3b95be71fe205e44de754185bcf86447b65813ce1ceb298f8d3793ade5fff08d" dependencies = [ - "base64", + "base64 0.12.3", "bitflags", "serde", "serde_json", @@ -654,9 +670,9 @@ checksum = "0ee1c47aaa256ecabcaea351eae4a9b01ef39ed810004e298d2511ed284b1525" [[package]] name = "mio" -version = "0.7.5" +version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8962c171f57fcfffa53f4df1bb15ec4c8cf26a7569459c9ceb62d94aab0d9584" +checksum = "f33bc887064ef1fd66020c9adfc45bb9f33d75a42096c81e7c56c65b75dd1a8b" dependencies = [ "libc", "log", @@ -667,9 +683,9 @@ dependencies = [ [[package]] name = "miow" -version = "0.3.5" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "07b88fb9795d4d36d62a012dfbf49a8f5cf12751f36d31a9dbe66d528e58979e" +checksum = "5a33c1b55807fbed163481b5ba66db4b2fa6cde694a5027be10fb724206c5897" dependencies = [ "socket2", "winapi", @@ -731,15 +747,15 @@ dependencies = [ [[package]] name = "once_cell" -version = "1.4.1" +version = "1.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "260e51e7efe62b592207e9e13a68e43692a7a279171d6ba57abd208bf23645ad" +checksum = "13bd41f508810a131401606d54ac32a467c97172d74ba7662562ebba5ad07fa0" [[package]] name = "os_str_bytes" -version = "2.3.2" +version = "2.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2ac6fe3538f701e339953a3ebbe4f39941aababa8a3f6964635b24ab526daeac" +checksum = "afb2e1c3ee07430c2cf76151675e583e0f19985fa6efae47d6848a3e2c824f85" [[package]] name = "parking" @@ -749,9 +765,9 @@ checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72" [[package]] name = "parking_lot" -version = "0.11.0" +version = "0.11.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4893845fa2ca272e647da5d0e46660a314ead9c2fdd9a883aabc32e481a8733" +checksum = "6d7744ac029df22dca6284efe4e898991d28e3085c706c972bcd7da4a27a15eb" dependencies = [ "instant", "lock_api", @@ -787,18 +803,18 @@ checksum = "d4fd5641d01c8f18a23da7b6fe29298ff4b55afcccdf78973b24cf3175fee32e" [[package]] name = "pin-project" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee41d838744f60d959d7074e3afb6b35c7456d0f61cad38a24e35e6553f73841" +checksum = "9ccc2237c2c489783abd8c4c80e5450fc0e98644555b1364da68cc29aa151ca7" dependencies = [ "pin-project-internal", ] [[package]] name = "pin-project-internal" -version = "1.0.1" +version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81a4ffa594b66bff340084d4081df649a7dc049ac8d7fc458d8e628bfbbb2f86" +checksum = "f8e8d2bf0b23038a4424865103a4df472855692821aab4e4f5c3312d461d9e5f" dependencies = [ "proc-macro2", "quote", @@ -906,11 +922,11 @@ dependencies = [ [[package]] name = "rust-argon2" -version = "0.8.2" +version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9dab61250775933275e84053ac235621dfb739556d5c54a2f2e9313b7cf43a19" +checksum = "4b18820d944b33caa75a71378964ac46f58517c92b6ae5f762636247c09e78fb" dependencies = [ - "base64", + "base64 0.13.0", "blake2b_simd", "constant_time_eq", "crossbeam-utils", @@ -1007,15 +1023,15 @@ checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8" [[package]] name = "smallvec" -version = "1.4.2" +version = "1.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbee7696b84bbf3d89a1c2eccff0850e3047ed46bfcd2e92c29a2d074d57e252" +checksum = "7acad6f34eb9e8a259d3283d1e8c1d34d7415943d4895f65cc73813c7396fc85" [[package]] name = "smol" -version = "1.2.4" +version = "1.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aaf8ded16994c0ae59596c6e4733c76faeb0533c26fd5ca1b1bc89271a049a66" +checksum = "85cf3b5351f3e783c1d79ab5fc604eeed8b8ae9abd36b166e8b87a089efd85e4" dependencies = [ "async-channel", "async-executor", @@ -1031,11 +1047,11 @@ dependencies = [ [[package]] name = "socket2" -version = "0.3.15" +version = "0.3.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1fa70dc5c8104ec096f4fe7ede7a221d35ae13dcd19ba1ad9a81d2cab9a1c44" +checksum = "2c29947abdee2a218277abeca306f25789c938e500ea5a9d4b12a5a504466902" dependencies = [ - "cfg-if 0.1.10", + "cfg-if 1.0.0", "libc", "redox_syscall", "winapi", @@ -1043,9 +1059,9 @@ dependencies = [ [[package]] name = "syn" -version = "1.0.48" +version = "1.0.53" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cc371affeffc477f42a221a1e4297aedcea33d47d19b61455588bd9d8f6b19ac" +checksum = "8833e20724c24de12bbaba5ad230ea61c3eafb05b881c7c9d3cfe8638b187e68" dependencies = [ "proc-macro2", "quote", @@ -1113,9 +1129,18 @@ dependencies = [ [[package]] name = "tinyvec" -version = "0.3.4" +version = "1.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ccf8dbc19eb42fba10e8feaaec282fb50e2c14b2726d6301dbfeed0f73306a6f" +dependencies = [ + "tinyvec_macros", +] + +[[package]] +name = "tinyvec_macros" +version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117" +checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c" [[package]] name = "tree-sitter" @@ -1129,8 +1154,8 @@ dependencies = [ [[package]] name = "tui" -version = "0.12.0" -source = "git+https://github.com/fdehau/tui-rs#25ff2e5e61f8902101e485743992db2412f77aad" +version = "0.13.0" +source = "git+https://github.com/fdehau/tui-rs#efdd6bfb193dafcb5e3bdc75e7d2d314065da1d7" dependencies = [ "bitflags", "cassowary", @@ -1150,18 +1175,18 @@ dependencies = [ [[package]] name = "unicode-normalization" -version = "0.1.13" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6fb19cf769fa8c6a80a162df694621ebeb4dafb606470b2b2fce0be40a98a977" +checksum = "a13e63ab62dbe32aeee58d1c5408d35c36c392bba5d9d3142287219721afe606" dependencies = [ "tinyvec", ] [[package]] name = "unicode-segmentation" -version = "1.6.0" +version = "1.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e83e153d1053cbb5a118eeff7fd5be06ed99153f00dbcd8ae310c5fb2b22edc0" +checksum = "bb0d2e7be6ae3a5fa87eed5fb451aff96f2573d2694942e40543ae0bbe19c796" [[package]] name = "unicode-width" @@ -1177,10 +1202,11 @@ checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564" [[package]] name = "url" -version = "2.1.1" +version = "2.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "829d4a8476c35c9bf0bbce5a3b23f4106f79728039b726d292bb93bc106787cb" +checksum = "5909f2b0817350449ed73e8bcd81c8c3c8d9a7a5d8acba4b27db277f1868976e" dependencies = [ + "form_urlencoded", "idna", "matches", "percent-encoding", diff --git a/helix-lsp/Cargo.toml b/helix-lsp/Cargo.toml index 08216f59..2ecd0cc1 100644 --- a/helix-lsp/Cargo.toml +++ b/helix-lsp/Cargo.toml @@ -11,7 +11,7 @@ helix-core = { path = "../helix-core" } helix-view = { path = "../helix-view" } once_cell = "1.4" -lsp-types = { version = "0.83", features = ["proposed"] } +lsp-types = { version = "0.84", features = ["proposed"] } smol = "1.2" url = "2" pathdiff = "0.2" diff --git a/helix-lsp/src/client.rs b/helix-lsp/src/client.rs index 1583bfb8..1f07cf89 100644 --- a/helix-lsp/src/client.rs +++ b/helix-lsp/src/client.rs @@ -183,7 +183,7 @@ impl Client { #[allow(deprecated)] let params = lsp::InitializeParams { - process_id: Some(u64::from(std::process::id())), + process_id: Some(std::process::id()), root_path: None, // root_uri: Some(lsp_types::Url::parse("file://localhost/")?), root_uri: None, // set to project root in the future @@ -194,6 +194,7 @@ impl Client { trace: None, workspace_folders: None, client_info: None, + locale: None, // TODO }; let response = self.request::(params).await?; diff --git a/helix-lsp/src/lib.rs b/helix-lsp/src/lib.rs index 8353ef7d..eae6fa86 100644 --- a/helix-lsp/src/lib.rs +++ b/helix-lsp/src/lib.rs @@ -38,7 +38,7 @@ pub mod util { let line_start = doc.char_to_utf16_cu(line); let col = doc.char_to_utf16_cu(pos) - line_start; - lsp::Position::new(line as u64, col as u64) + lsp::Position::new(line as u32, col as u32) } } diff --git a/helix-view/src/document.rs b/helix-view/src/document.rs index e8f311c5..7c4596ad 100644 --- a/helix-view/src/document.rs +++ b/helix-view/src/document.rs @@ -32,7 +32,7 @@ pub struct Document { pub changes: ChangeSet, pub old_state: State, pub history: History, - pub version: i64, // should be usize? + pub version: i32, // should be usize? pub diagnostics: Vec, } -- cgit v1.2.3-70-g09d2