kc/helix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions1

Merge pull request from helix-editor/lsp

Browse source 
LSP: mk1
This commit is contained in:
Blaž Hrastnik 2020-12-03 13:12:40 +09:00 • committed by GitHub
commit b7a3e525ed
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
25 changed files with 2329 additions and 655 deletions

696
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

1
Cargo.toml
View file

@ -4,6 +4,7 @@ members = [
"helix-view",
"helix-term",
"helix-syntax",
"helix-lsp",
]
# Build helix-syntax in release mode to make the code path faster in development.

7
helix-core/src/diagnostic.rs Normal file
View file

@ -0,0 +1,7 @@
use crate::Range;
pub struct Diagnostic {
pub range: (usize, usize),
pub line: usize,
pub message: String,
}

46
helix-core/src/history.rs
View file

@ -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<Transaction> {
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<Transaction> {
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());
}
}

27
helix-core/src/indent.rs
View file

@ -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", &[]);
let state = State::new(doc);
// TODO: set_language
let language_config = crate::syntax::LOADER
.language_config_for_scope("source.rust")
.unwrap();
let highlight_config = language_config.highlight_config(&[]).unwrap().unwrap();
let syntax = Syntax::new(&state.doc, highlight_config.clone());
assert_eq!(suggested_indent_for_line(&state, 0), 0); // mod
assert_eq!(suggested_indent_for_line(&state, 1), 1); // fn
assert_eq!(suggested_indent_for_line(&state, 2), 2); // 1 + 1
assert_eq!(suggested_indent_for_line(&state, 4), 1); // }
assert_eq!(suggested_indent_for_line(&state, 5), 0); // }
assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 0), 0); // mod
assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 1), 1); // fn
assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 2), 2); // 1 + 1
assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 4), 1); // }
assert_eq!(suggested_indent_for_line(Some(&syntax), &state, 5), 0); // }
}
}

4
helix-core/src/lib.rs
View file

@ -1,4 +1,5 @@
#![allow(unused)]
mod diagnostic;
pub mod graphemes;
mod history;
pub mod indent;
@ -22,7 +23,8 @@ pub use selection::Range;
pub use selection::Selection;
pub use syntax::Syntax;
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};

5
helix-core/src/selection.rs
View file

@ -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 {

78
helix-core/src/state.rs
View file

@ -1,33 +1,14 @@
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;
#[derive(Copy, Clone, PartialEq, Eq, Hash)]
pub enum Mode {
Normal,
Insert,
Goto,
}
/// 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
/// Path to file on disk.
pub path: Option<PathBuf>,
pub doc: Rope,
pub selection: Selection,
pub mode: Mode,
pub restore_cursor: bool,
//
pub syntax: Option<Syntax>,
/// Pending changes since last history commit.
pub changes: ChangeSet,
pub old_state: Option<(Rope, Selection)>,
}
#[derive(Copy, Clone, PartialEq, Eq)]
@ -46,57 +27,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,
}
}
// TODO: passing scopes here is awkward
pub fn load(path: PathBuf, scopes: &[String]) -> Result<Self, Error> {
use std::{env, fs::File, io::BufReader, path::PathBuf};
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);
};
state.path = Some(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
@ -110,16 +46,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<R>(&self, range: R) -> RopeSlice
// where
// R: std::ops::RangeBounds<usize>,

6
helix-core/src/syntax.rs
View file

@ -62,11 +62,15 @@ impl LanguageConfiguration {
})
.map(Option::as_ref)
}
pub fn scope(&self) -> &str {
&self.scope
}
}
use once_cell::sync::Lazy;
pub(crate) static LOADER: Lazy<Loader> = Lazy::new(Loader::init);
pub static LOADER: Lazy<Loader> = Lazy::new(Loader::init);
pub struct Loader {
// highlight_names ?

45
helix-core/src/transaction.rs
View file

@ -5,8 +5,9 @@ use std::convert::TryFrom;
/// (from, to, replacement)
pub type Change = (usize, usize, Option<Tendril>);
// 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 {
@ -351,22 +358,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<T, F>(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 +367,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

26
helix-lsp/Cargo.toml Normal file
View file

@ -0,0 +1,26 @@
[package]
name = "helix-lsp"
version = "0.1.0"
authors = ["Blaž Hrastnik <blaz@mxxn.io>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
helix-core = { path = "../helix-core" }
helix-view = { path = "../helix-view" }
once_cell = "1.4"
lsp-types = { version = "0.84", features = ["proposed"] }
smol = "1.2"
url = "2"
pathdiff = "0.2"
shellexpand = "2.0"
glob = "0.3"
anyhow = "1"
serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }
jsonrpc-core = "15.1"
futures-util = "0.3"
thiserror = "1"
log = "0.4"

355
helix-lsp/src/client.rs Normal file
View file

@ -0,0 +1,355 @@
use crate::{
transport::{Payload, Transport},
Call, Error,
};
type Result<T> = core::result::Result<T, Error>;
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;
use serde_json::Value;
use smol::{
channel::{Receiver, Sender},
io::{BufReader, BufWriter},
// prelude::*,
process::{Child, ChildStderr, Command, Stdio},
Executor,
};
pub struct Client {
_process: Child,
stderr: BufReader<ChildStderr>,
outgoing: Sender<Payload>,
pub incoming: Receiver<Call>,
pub request_counter: AtomicU64,
capabilities: Option<lsp::ServerCapabilities>,
// TODO: handle PublishDiagnostics Version
// diagnostics: HashMap<lsp::Url, Vec<lsp::Diagnostic>>,
}
impl Client {
pub fn start(ex: &Executor, cmd: &str, args: &[String]) -> Self {
let mut process = Command::new(cmd)
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("Failed to start language server");
// smol makes sure the process is reaped on drop, but using kill_on_drop(true) maybe?
// TODO: do we need bufreader/writer here? or do we use async wrappers on unblock?
let writer = BufWriter::new(process.stdin.take().expect("Failed to open stdin"));
let reader = BufReader::new(process.stdout.take().expect("Failed to open stdout"));
let stderr = BufReader::new(process.stderr.take().expect("Failed to open stderr"));
let (incoming, outgoing) = Transport::start(ex, reader, writer);
Client {
_process: process,
stderr,
outgoing,
incoming,
request_counter: AtomicU64::new(0),
capabilities: None,
// diagnostics: HashMap::new(),
}
}
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<jsonrpc::Params> {
use jsonrpc::Params;
let params = match value {
Value::Null => Params::None,
Value::Bool(_) | Value::Number(_) | Value::String(_) => Params::Array(vec![value]),
Value::Array(vec) => Params::Array(vec),
Value::Object(map) => Params::Map(map),
};
Ok(params)
}
/// Execute a RPC request on the language server.
pub async fn request<R: lsp::request::Request>(&self, params: R::Params) -> Result<R::Result>
where
R::Params: serde::Serialize,
R::Result: core::fmt::Debug, // TODO: temporary
{
let params = serde_json::to_value(params)?;
let request = jsonrpc::MethodCall {
jsonrpc: Some(jsonrpc::Version::V2),
id: self.next_request_id(),
method: R::METHOD.to_string(),
params: Self::to_params(params)?,
};
let (tx, rx) = smol::channel::bounded::<Result<Value>>(1);
self.outgoing
.send(Payload::Request {
chan: tx,
value: request,
})
.await
.map_err(|e| Error::Other(e.into()))?;
let response = rx.recv().await.map_err(|e| Error::Other(e.into()))??;
let response = serde_json::from_value(response)?;
// TODO: we should pass request to a sender thread via a channel
// so it can't be interleaved
// TODO: responses can be out of order, we need to register a single shot response channel
Ok(response)
}
/// Send a RPC notification to the language server.
pub async fn notify<R: lsp::notification::Notification>(&self, params: R::Params) -> Result<()>
where
R::Params: serde::Serialize,
{
let params = serde_json::to_value(params)?;
let notification = jsonrpc::Notification {
jsonrpc: Some(jsonrpc::Version::V2),
method: R::METHOD.to_string(),
params: Self::to_params(params)?,
};
self.outgoing
.send(Payload::Notification(notification))
.await
.map_err(|e| Error::Other(e.into()))?;
Ok(())
}
/// Reply to a language server RPC call.
pub async fn reply(
&self,
id: jsonrpc::Id,
result: core::result::Result<Value, jsonrpc::Error>,
) -> 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
// -------------------------------------------------------------------------------------------
pub async fn initialize(&mut self) -> Result<()> {
// TODO: delay any requests that are triggered prior to initialize
#[allow(deprecated)]
let params = lsp::InitializeParams {
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
initialization_options: None,
capabilities: lsp::ClientCapabilities {
..Default::default()
},
trace: None,
workspace_folders: None,
client_info: None,
locale: None, // TODO
};
let response = self.request::<lsp::request::Initialize>(params).await?;
self.capabilities = Some(response.capabilities);
// next up, notify<initialized>
self.notify::<lsp::notification::Initialized>(lsp::InitializedParams {})
.await?;
Ok(())
}
pub async fn shutdown(&self) -> Result<()> {
self.request::<lsp::request::Shutdown>(()).await
}
pub async fn exit(&self) -> Result<()> {
self.notify::<lsp::notification::Exit>(()).await
}
// -------------------------------------------------------------------------------------------
// Text document
// -------------------------------------------------------------------------------------------
pub async fn text_document_did_open(&mut self, doc: &Document) -> Result<()> {
self.notify::<lsp::notification::DidOpenTextDocument>(lsp::DidOpenTextDocumentParams {
text_document: lsp::TextDocumentItem {
uri: lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
language_id: "rust".to_string(), // TODO: hardcoded for now
version: doc.version,
text: String::from(doc.text()),
},
})
.await
}
fn to_changes(changeset: &ChangeSet) -> Vec<lsp::TextDocumentContentChangeEvent> {
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::notification::DidChangeTextDocument>(lsp::DidChangeTextDocumentParams {
text_document: lsp::VersionedTextDocumentIdentifier::new(
lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
doc.version,
),
content_changes: changes,
})
.await
}
// TODO: impl into() TextDocumentIdentifier / VersionedTextDocumentIdentifier for Document.
pub async fn text_document_did_close(&mut self, doc: &Document) -> Result<()> {
self.notify::<lsp::notification::DidCloseTextDocument>(lsp::DidCloseTextDocumentParams {
text_document: lsp::TextDocumentIdentifier::new(
lsp::Url::from_file_path(doc.path().unwrap()).unwrap(),
),
})
.await
}
// will_save / will_save_wait_until
pub async fn text_document_did_save(&mut self) -> anyhow::Result<()> {
unimplemented!()
}
}

117
helix-lsp/src/lib.rs Normal file
View file

@ -0,0 +1,117 @@
mod client;
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}")]
Rpc(#[from] jsonrpc::Error),
#[error("failed to parse: {0}")]
Parse(#[from] serde_json::Error),
#[error("request timed out")]
Timeout,
#[error(transparent)]
Other(#[from] anyhow::Error),
}
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)
}
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;
lsp::Position::new(line as u32, col as u32)
}
}
#[derive(Debug, PartialEq, Clone)]
pub enum Notification {
PublishDiagnostics(lsp::PublishDiagnosticsParams),
}
impl Notification {
pub fn parse(method: &str, params: jsonrpc::Params) -> Notification {
use lsp::notification::Notification as _;
match method {
lsp::notification::PublishDiagnostics::METHOD => {
let params: lsp::PublishDiagnosticsParams = params
.parse()
.expect("Failed to parse PublishDiagnostics params");
// TODO: need to loop over diagnostics and distinguish them by URI
Notification::PublishDiagnostics(params)
}
_ => unimplemented!("unhandled notification: {}", method),
}
}
}
pub use jsonrpc::Call;
type LanguageId = String;
pub static REGISTRY: Lazy<Registry> = Lazy::new(Registry::init);
pub struct Registry {
inner: HashMap<LanguageId, OnceCell<Arc<Client>>>,
}
impl Registry {
pub fn init() -> Self {
Self {
inner: HashMap::new(),
}
}
pub fn get(&self, id: &str, ex: &smol::Executor) -> Option<Arc<Client>> {
// 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<LanguageId, Lazy/OnceCell<Arc<RwLock<Client>>>
// 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<Arc<RwLock<Client>>> 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

212
helix-lsp/src/transport.rs Normal file
View file

@ -0,0 +1,212 @@
use std::collections::HashMap;
use log::debug;
use crate::{Error, Notification};
type Result<T> = core::result::Result<T, Error>;
use jsonrpc_core as jsonrpc;
use serde_json::Value;
use smol::prelude::*;
use smol::{
channel::{Receiver, Sender},
io::{BufReader, BufWriter},
process::{ChildStderr, ChildStdin, ChildStdout},
Executor,
};
pub(crate) enum Payload {
Request {
chan: Sender<Result<Value>>,
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<jsonrpc::Call>,
outgoing: Receiver<Payload>,
pending_requests: HashMap<jsonrpc::Id, Sender<Result<Value>>>,
headers: HashMap<String, String>,
writer: BufWriter<ChildStdin>,
reader: BufReader<ChildStdout>,
}
impl Transport {
pub fn start(
ex: &Executor,
reader: BufReader<ChildStdout>,
writer: BufWriter<ChildStdin>,
) -> (Receiver<jsonrpc::Call>, Sender<Payload>) {
let (incoming, rx) = smol::channel::unbounded();
let (tx, outgoing) = smol::channel::unbounded();
let transport = Self {
reader,
writer,
incoming,
outgoing,
pending_requests: Default::default(),
headers: Default::default(),
};
ex.spawn(transport.duplex()).detach();
(rx, tx)
}
async fn recv(
reader: &mut (impl AsyncBufRead + Unpin),
headers: &mut HashMap<String, String>,
) -> core::result::Result<Message, std::io::Error> {
// read headers
loop {
let mut header = String::new();
// detect pipe closed if 0
reader.read_line(&mut header).await?;
let header = header.trim();
if header.is_empty() {
break;
}
let parts: Vec<&str> = header.split(": ").collect();
if parts.len() != 2 {
return Err(std::io::Error::new(
std::io::ErrorKind::Other,
"Failed to parse header",
));
}
headers.insert(parts[0].to_string(), parts[1].to_string());
}
// find content-length
let content_length = headers.get("Content-Length").unwrap().parse().unwrap();
let mut content = vec![0; content_length];
reader.read_exact(&mut content).await?;
let msg = String::from_utf8(content).unwrap();
// read data
// try parsing as output (server response) or call (server request)
let output: serde_json::Result<Message> = serde_json::from_str(&msg);
Ok(output?)
}
pub async fn send_payload(&mut self, payload: Payload) -> anyhow::Result<()> {
match payload {
Payload::Request { chan, value } => {
self.pending_requests.insert(value.id.clone(), chan);
let json = serde_json::to_string(&value)?;
self.send(json).await
}
Payload::Notification(value) => {
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
}
}
}
pub async fn send(&mut self, request: String) -> anyhow::Result<()> {
debug!("-> {}", request);
// send the headers
self.writer
.write_all(format!("Content-Length: {}\r\n\r\n", request.len()).as_bytes())
.await?;
// send the body
self.writer.write_all(request.as_bytes()).await?;
self.writer.flush().await?;
Ok(())
}
async fn recv_msg(&mut self, msg: Message) -> anyhow::Result<()> {
match msg {
Message::Output(output) => self.recv_response(output).await?,
Message::Call(call) => {
self.incoming.send(call).await?;
// let notification = Notification::parse(&method, params);
}
};
Ok(())
}
async fn recv_response(&mut self, output: jsonrpc::Output) -> anyhow::Result<()> {
match output {
jsonrpc::Output::Success(jsonrpc::Success { id, result, .. }) => {
debug!("<- {}", result);
let tx = self
.pending_requests
.remove(&id)
.expect("pending_request with id not found!");
tx.send(Ok(result)).await?;
}
jsonrpc::Output::Failure(jsonrpc::Failure { id, error, .. }) => {
let tx = self
.pending_requests
.remove(&id)
.expect("pending_request with id not found!");
tx.send(Err(error.into())).await?;
}
msg => unimplemented!("{:?}", msg),
}
Ok(())
}
pub async fn duplex(mut self) {
use futures_util::{select, FutureExt};
loop {
select! {
// client -> server
msg = self.outgoing.next().fuse() => {
if msg.is_none() {
break;
}
let msg = msg.unwrap();
self.send_payload(msg).await.unwrap();
}
// server <- client
msg = Self::recv(&mut self.reader, &mut self.headers).fuse() => {
if msg.is_err() {
break;
}
let msg = msg.unwrap();
debug!("<- {:?}", msg);
self.recv_msg(msg).await.unwrap();
}
}
}
}
}

10
helix-term/Cargo.toml
View file

@ -14,12 +14,20 @@ path = "src/main.rs"
[dependencies]
helix-core = { path = "../helix-core" }
helix-view = { path = "../helix-view", features = ["term"]}
helix-lsp = { path = "../helix-lsp"}
anyhow = "1"
smol = "1"
num_cpus = "1.13"
num_cpus = "1"
# tui = { version = "0.12", default-features = false, features = ["crossterm"] }
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"
# Logging
fern = "0.6"
chrono = "0.4"
log = "0.4"

452
helix-term/src/application.rs
View file

@ -1,6 +1,14 @@
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_core::{indent::TAB_WIDTH, syntax::HighlightEvent, Position, Range, State};
use helix_view::{
commands,
document::Mode,
keymap::{self, Keymaps},
prompt::Prompt,
Document, Editor, Theme, View,
};
use log::{debug, info};
use std::{
borrow::Cow,
@ -15,8 +23,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},
};
@ -25,21 +32,23 @@ 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<CrosstermBackend<std::io::Stdout>>;
static EX: smol::Executor = smol::Executor::new();
const BASE_WIDTH: u16 = 30;
pub struct Application {
pub struct Application<'a> {
editor: Editor,
prompt: Option<Prompt>,
terminal: Renderer,
keymap: Keymaps,
executor: &'a smol::Executor<'a>,
language_server: helix_lsp::Client,
}
struct Renderer {
@ -75,30 +84,29 @@ 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();
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
};
@ -106,7 +114,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)
@ -122,6 +130,7 @@ impl Renderer {
let mut visual_x = 0;
let mut line = 0u16;
let visible_selections: Vec<Range> = view
.doc
.state
.selection()
.ranges()
@ -142,15 +151,15 @@ 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};
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
};
@ -200,6 +209,16 @@ impl Renderer {
style
};
// ugh, improve with a traverse method
// or interleave highlight spans with selection and diagnostic spans
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)
} else {
style
};
// TODO: paint cursor heads except primary
self.surface
@ -207,23 +226,28 @@ impl Renderer {
visual_x += width;
}
// if grapheme == "\t"
char_index += 1;
}
}
}
}
let style: Style = view.theme.get("ui.linenr");
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.doc.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);
}
}
pub fn render_statusline(&mut self, view: &View) {
let mode = match view.state.mode() {
pub fn render_statusline(&mut self, view: &View, theme: &Theme) {
let mode = match view.doc.mode() {
Mode::Insert => "INS",
Mode::Normal => "NOR",
Mode::Goto => "GOTO",
@ -231,13 +255,20 @@ 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);
self.surface.set_string(
self.size.0 - 10,
self.size.1 - 2,
format!("{}", view.doc.diagnostics.len()),
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
@ -256,7 +287,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()
@ -302,14 +333,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,
@ -318,10 +349,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;
@ -332,8 +363,8 @@ impl Renderer {
}
}
impl Application {
pub fn new(mut args: Args) -> Result<Self, Error> {
impl<'a> Application<'a> {
pub fn new(mut args: Args, executor: &'a smol::Executor<'a>) -> Result<Self, Error> {
let terminal = Renderer::new()?;
let mut editor = Editor::new();
@ -341,11 +372,18 @@ impl Application {
editor.open(file, terminal.size)?;
}
let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]);
let mut app = Self {
editor,
terminal,
// TODO; move to state
prompt: None,
//
keymap: keymap::default(),
executor,
language_server,
};
Ok(app)
@ -354,13 +392,16 @@ 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
if let Some(view) = &mut self.editor.view {
self.terminal.render_view(view, viewport);
// 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, theme_ref);
if let Some(prompt) = &self.prompt {
if prompt.should_close {
self.prompt = None;
} else {
self.terminal.render_prompt(view, prompt);
self.terminal.render_prompt(view, prompt, theme_ref);
}
}
}
@ -368,16 +409,19 @@ impl Application {
self.terminal.draw();
// TODO: drop unwrap
self.terminal.render_cursor(
self.editor.view.as_ref().unwrap(),
self.prompt.as_ref(),
viewport,
);
self.terminal
.render_cursor(self.editor.view().unwrap(), self.prompt.as_ref(), viewport);
}
pub async fn event_loop(&mut self) {
let mut reader = EventStream::new();
let keymap = keymap::default();
// initialize lsp
self.language_server.initialize().await.unwrap();
self.language_server
.text_document_did_open(&self.editor.view().unwrap().doc)
.await
.unwrap();
self.render();
@ -386,125 +430,225 @@ 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
}
call = self.language_server.incoming.next().fuse() => {
self.handle_language_server_message(call).await
}
}
}
}
// TODO: simplistic ensure cursor in view for now
if let Some(view) = &mut self.editor.view {
view.size = self.terminal.size;
view.ensure_cursor_in_view()
};
pub async fn handle_terminal_events(
&mut self,
event: Option<Result<Event, crossterm::ErrorKind>>,
) {
// 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);
} else if let Some(view) = self.editor.view_mut() {
let keys = vec![event];
// TODO: sequences (`gg`)
// TODO: handle count other than 1
match view.doc.mode() {
Mode::Insert => {
if let Some(command) = self.keymap[&Mode::Insert].get(&keys) {
let mut cx = helix_view::commands::Context {
view,
executor: self.executor,
count: 1,
};
self.render();
} else if let Some(view) = &mut self.editor.view {
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);
}
command(&mut cx);
} else if let KeyEvent {
code: KeyCode::Char(c),
..
} = event
{
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();
}
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) {
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();
}
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,
_ => (),
},
);
}
mode => {
if let Some(command) = self.keymap[&mode].get(&keys) {
let mut cx = helix_view::commands::Context {
view,
executor: self.executor,
count: 1,
};
command(&mut cx);
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();
}
}
mode => {
if let Some(command) = 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_language_server_message(&mut self, call: Option<helix_lsp::Call>) {
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;
// TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events
self.render();
}
}
_ => unreachable!(),
}
}
Some(Call::MethodCall(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!(),
}
}

51
helix-term/src/main.rs
View file

@ -11,6 +11,39 @@ use anyhow::Error;
static EX: smol::Executor = smol::Executor::new();
fn setup_logging(verbosity: u64) -> Result<(), fern::InitError> {
let mut base_config = fern::Dispatch::new();
// Let's say we depend on something which whose "info" level messages are too
// verbose to include in end-user output. If we don't need them,
// let's not include them.
// .level_for("overly-verbose-target", log::LevelFilter::Warn)
base_config = match verbosity {
0 => base_config.level(log::LevelFilter::Warn),
1 => base_config.level(log::LevelFilter::Info),
2 => base_config.level(log::LevelFilter::Debug),
_3_or_more => base_config.level(log::LevelFilter::Trace),
};
// Separate file config so we can include year, month and day in file logs
let file_config = fern::Dispatch::new()
.format(|out, message, record| {
out.finish(format_args!(
"{} {} [{}] {}",
chrono::Local::now().format("%Y-%m-%dT%H:%M:%S%.3f"),
record.target(),
record.level(),
message
))
})
.chain(fern::log_file("helix.log")?);
base_config.chain(file_config).apply()?;
Ok(())
}
fn main() -> Result<(), Error> {
let args = clap::app_from_crate!()
.arg(
@ -20,15 +53,27 @@ fn main() -> Result<(), Error> {
.multiple(true)
.index(1),
)
.arg(
Arg::new("verbose")
.about("Increases logging verbosity each use for up to 3 times")
.short('v')
.takes_value(false)
.multiple_occurrences(true),
)
.get_matches();
let verbosity: u64 = args.occurrences_of("verbose");
setup_logging(verbosity).expect("failed to initialize logging.");
for _ in 0..num_cpus::get() {
std::thread::spawn(move || smol::block_on(EX.run(smol::future::pending::<()>())));
}
smol::block_on(EX.run(async {
Application::new(args).unwrap().run().await;
}));
let mut app = Application::new(args, &EX).unwrap();
// we use the thread local executor to spawn the application task separately from the work pool
smol::block_on(app.run());
Ok(())
}

3
helix-view/Cargo.toml
View file

@ -19,3 +19,6 @@ 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"
smol = "1"

533
helix-view/src/commands.rs
View file

@ -3,52 +3,65 @@ 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},
};
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) {
// TODO: use a transaction
let selection = view
.state
.move_selection(Direction::Backward, Granularity::Character, count);
view.state.selection = selection;
pub fn move_char_left(cx: &mut Context) {
let selection =
cx.view
.doc
.state
.move_selection(Direction::Backward, Granularity::Character, cx.count);
cx.view.doc.set_selection(selection);
}
pub fn move_char_right(view: &mut View, count: usize) {
// TODO: use a transaction
view.state.selection =
view.state
.move_selection(Direction::Forward, Granularity::Character, count);
pub fn move_char_right(cx: &mut Context) {
let selection =
cx.view
.doc
.state
.move_selection(Direction::Forward, Granularity::Character, cx.count);
cx.view.doc.set_selection(selection);
}
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);
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) {
// TODO: use a transaction
view.state.selection = view
.state
.move_selection(Direction::Forward, Granularity::Line, count);
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) {
// TODO: use a transaction
let lines = selection_lines(&view.state);
pub fn move_line_end(cx: &mut Context) {
let lines = selection_lines(&cx.view.doc.state);
let positions = lines
.into_iter()
@ -57,89 +70,80 @@ 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)
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);
let transaction = Transaction::new(&mut view.state).with_selection(selection);
transaction.apply(&mut view.state);
cx.view.doc.set_selection(selection);
}
pub fn move_line_start(view: &mut View, _count: usize) {
let lines = selection_lines(&view.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.state.doc.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);
let transaction = Transaction::new(&mut view.state).with_selection(selection);
transaction.apply(&mut view.state);
cx.view.doc.set_selection(selection);
}
pub fn move_next_word_start(view: &mut View, count: usize) {
let pos = view.state.move_pos(
view.state.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,
);
// TODO: use a transaction
view.state.selection = Selection::single(pos, pos);
cx.view.doc.set_selection(Selection::point(pos));
}
pub fn move_prev_word_start(view: &mut View, count: usize) {
let pos = view.state.move_pos(
view.state.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,
);
// TODO: use a transaction
view.state.selection = Selection::single(pos, 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.state.doc().slice(..),
view.state.selection.cursor(),
count,
&cx.view.doc.text().slice(..),
cx.view.doc.selection().cursor(),
cx.count,
);
// TODO: use a transaction
view.state.selection = Selection::single(pos, pos);
cx.view.doc.set_selection(Selection::point(pos));
}
pub fn move_file_start(view: &mut View, _count: usize) {
// TODO: use a transaction
view.state.selection = Selection::single(0, 0);
pub fn move_file_start(cx: &mut Context) {
cx.view.doc.set_selection(Selection::point(0));
view.state.mode = Mode::Normal;
cx.view.doc.mode = Mode::Normal;
}
pub fn move_file_end(view: &mut View, _count: usize) {
// TODO: use a transaction
let text = &view.state.doc;
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.state.selection = Selection::single(last_line, last_line);
cx.view.doc.set_selection(Selection::point(last_line));
view.state.mode = Mode::Normal;
cx.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);
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;
if (line > document_end.saturating_sub(PADDING)) | (line < view.first_line + PADDING) {
@ -148,168 +152,186 @@ 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.state.doc();
let pos = text.line_to_char(view.last_line().saturating_sub(PADDING));
view.state.selection = Selection::single(pos, 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.state.doc().len_lines() {
let text = view.state.doc();
let pos = text.line_to_char(view.first_line as usize);
view.state.selection = Selection::single(pos, 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.state.doc;
let pos = text.line_to_char(view.last_line() - PADDING);
view.state.selection = Selection::single(pos, 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.state.doc().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.state.doc();
let pos = text.line_to_char(view.first_line as usize);
view.state.selection = Selection::single(pos, 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) {
// TODO: use a transaction
let selection = view
.state
.extend_selection(Direction::Backward, Granularity::Character, count);
view.state.selection = selection;
pub fn extend_char_left(cx: &mut Context) {
let selection =
cx.view
.doc
.state
.extend_selection(Direction::Backward, Granularity::Character, cx.count);
cx.view.doc.set_selection(selection);
}
pub fn extend_char_right(view: &mut View, count: usize) {
// TODO: use a transaction
view.state.selection =
view.state
.extend_selection(Direction::Forward, Granularity::Character, count);
pub fn extend_char_right(cx: &mut Context) {
let selection =
cx.view
.doc
.state
.extend_selection(Direction::Forward, Granularity::Character, cx.count);
cx.view.doc.set_selection(selection);
}
pub fn extend_line_up(view: &mut View, count: usize) {
// TODO: use a transaction
view.state.selection =
view.state
.extend_selection(Direction::Backward, Granularity::Line, count);
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) {
// TODO: use a transaction
view.state.selection =
view.state
.extend_selection(Direction::Forward, Granularity::Line, count);
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.state.doc.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<Regex> = Lazy::new(|| Regex::new(r"\n").unwrap());
// TODO: use a transaction
view.state.selection = selection::split_on_matches(text, view.state.selection(), &REGEX)
let selection = selection::split_on_matches(text, cx.view.doc.selection(), &REGEX);
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.state.selection().primary();
let text = view.state.doc();
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);
// TODO: use a transaction
view.state.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.state, |range| (range.from(), range.to() + 1, None));
transaction.apply(&mut view.state);
pub fn delete_selection(cx: &mut Context) {
let transaction = Transaction::change_by_selection(&cx.view.doc.state, |range| {
(range.from(), range.to() + 1, None)
});
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) {
view.state.selection = view
.state
.selection
.transform(|range| Range::new(range.head, range.head))
pub fn collapse_selection(cx: &mut Context) {
let selection = cx
.view
.doc
.selection()
.transform(|range| Range::new(range.head, range.head));
cx.view.doc.set_selection(selection);
}
pub fn flip_selections(view: &mut View, _count: usize) {
view.state.selection = view
.state
.selection
.transform(|range| Range::new(range.head, range.anchor))
pub fn flip_selections(cx: &mut Context) {
let selection = cx
.view
.doc
.selection()
.transform(|range| Range::new(range.head, range.anchor));
cx.view.doc.set_selection(selection);
}
fn enter_insert_mode(view: &mut View) {
view.state.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);
view.state.selection = view
.state
.selection
.transform(|range| Range::new(range.to(), range.from()))
let selection = cx
.view
.doc
.selection()
.transform(|range| Range::new(range.to(), range.from()));
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.state.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.state.doc.slice(..);
view.state.selection = view.state.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()),
)
})
});
cx.view.doc.set_selection(selection);
}
// 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!()
}
@ -329,30 +351,30 @@ fn selection_lines(state: &State) -> Vec<usize> {
}
// 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.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.state.doc.line_to_char(index + 1)
cx.view.doc.text().line_to_char(index + 1)
})
.collect();
@ -373,111 +395,119 @@ pub fn open_below(view: &mut View, _count: usize) {
0,
);
let transaction = Transaction::change(&view.state, changes).with_selection(selection);
let transaction = Transaction::change(&cx.view.doc.state, changes).with_selection(selection);
transaction.apply(&mut view.state);
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.state.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.state.doc());
let changes = std::mem::replace(&mut view.state.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.state.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
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 (doc, selection) = view.state.old_state.take().unwrap();
let mut old_state = State::new(doc);
old_state.selection = selection;
let old_state = std::mem::replace(&mut cx.view.doc.old_state, cx.view.doc.state.clone());
// TODO: take transaction by value?
view.history.commit_revision(&transaction, &old_state);
cx.view
.doc
.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()));
// TODO: notify LSP of changes
}
pub fn normal_mode(view: &mut View, _count: usize) {
view.state.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.state.restore_cursor {
let text = &view.state.doc.slice(..);
view.state.selection = view.state.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()),
)
});
cx.view.doc.set_selection(selection);
view.state.restore_cursor = false;
cx.view.doc.restore_cursor = false;
}
}
pub fn goto_mode(view: &mut View, _count: usize) {
view.state.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.state, c);
let transaction = Transaction::insert(&cx.view.doc.state, c);
transaction.apply(&mut view.state);
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.state, |range| {
let indent_level =
helix_core::indent::suggested_indent_for_pos(&view.state, range.head);
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(
cx.view.doc.syntax.as_ref(),
&cx.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);
cx.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| {
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,
)
});
transaction.apply(&mut view.state);
cx.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| {
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,
)
});
transaction.apply(&mut view.state);
cx.view.doc.apply(&transaction);
}
}
@ -487,24 +517,32 @@ 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);
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<transaction>, then the higher level handles storing it?
}
pub fn redo(view: &mut View, _count: usize) {
view.history.redo(&mut view.state);
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.state.doc().slice(..))
.fragments(&cx.view.doc.text().slice(..))
.map(|cow| cow.into_owned())
.collect();
@ -513,7 +551,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) {
@ -545,19 +583,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.state.doc();
Transaction::change_by_selection(&view.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.state, |range| {
Transaction::change_by_selection(&cx.view.doc.state, |range| {
(range.head + 1, range.head + 1, Some(values.next().unwrap()))
})
};
transaction.apply(&mut view.state);
append_changes_to_history(view);
cx.view.doc.apply(&transaction);
append_changes_to_history(cx);
}
}
@ -565,9 +603,9 @@ fn get_lines(view: &View) -> Vec<usize> {
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.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)
@ -578,29 +616,29 @@ fn get_lines(view: &View) -> Vec<usize> {
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.state,
&cx.view.doc.state,
lines.into_iter().map(|line| {
let pos = view.state.doc.line_to_char(line);
let pos = cx.view.doc.text().line_to_char(line);
(pos, pos, Some(indent.clone()))
}),
);
transaction.apply(&mut view.state);
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.state.doc.line(line_idx);
let line = cx.view.doc.text().line(line_idx);
let mut width = 0;
for ch in line.chars() {
@ -616,18 +654,27 @@ pub fn unindent(view: &mut View, _count: usize) {
}
if width > 0 {
let start = view.state.doc.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.state, changes.into_iter());
let transaction = Transaction::change(&cx.view.doc.state, changes.into_iter());
transaction.apply(&mut view.state);
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!()
}
//
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();
}

209
helix-view/src/document.rs Normal file
View file

@ -0,0 +1,209 @@
use anyhow::Error;
use std::future::Future;
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<PathBuf>,
/// Current editing mode.
pub mode: Mode,
pub restore_cursor: bool,
/// Tree-sitter AST tree
pub syntax: Option<Syntax>,
/// Corresponding language scope name. Usually `source.<lang>`.
pub language: Option<String>,
/// Pending changes since last history commit.
pub changes: ChangeSet,
pub old_state: State,
pub history: History,
pub version: i32, // should be usize?
pub diagnostics: Vec<Diagnostic>,
}
/// Like std::mem::replace() except it allows the replacement value to be mapped from the
/// original value.
fn take_with<T, F>(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 = state.clone();
Self {
path: None,
state,
mode: Mode::Normal,
restore_cursor: false,
syntax: None,
language: None,
changes,
old_state,
diagnostics: Vec::new(),
version: 0,
history: History::default(),
}
}
// TODO: passing scopes here is awkward
// TODO: async fn?
pub fn load(path: PathBuf, scopes: &[String]) -> Result<Self, Error> {
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);
// 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<HighlightConfig> 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
doc.path = Some(std::fs::canonicalize(path)?);
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<Output = Result<(), anyhow::Error>> {
// 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();
// TODO: config.configure(scopes) is now delayed, is that ok?
let syntax = Syntax::new(&self.state.doc, highlight_config.clone());
self.syntax = Some(syntax);
};
}
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();
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()
});
// TODO: when composing, replace transaction.selection too
// 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<Url> {
self.path().map(|path| Url::from_file_path(path).unwrap())
}
pub fn text(&self) -> &Rope {
&self.state.doc
}
pub fn selection(&self) -> &Selection {
&self.state.selection
}
// pub fn slice<R>(&self, range: R) -> RopeSlice where R: RangeBounds {
// self.state.doc.slice
// }
// TODO: transact(Fn) ?
}

32
helix-view/src/editor.rs
View file

@ -1,24 +1,48 @@
use crate::View;
use crate::theme::Theme;
use crate::{Document, View};
use std::path::PathBuf;
use anyhow::Error;
pub struct Editor {
pub view: Option<View>,
pub views: Vec<View>,
pub focus: usize,
pub should_close: bool,
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();
Self {
view: None,
views: Vec::new(),
focus: 0,
should_close: false,
theme,
}
}
pub fn open(&mut self, path: PathBuf, size: (u16, u16)) -> Result<(), Error> {
self.view = Some(View::open(path, size)?);
let pos = self.views.len();
let doc = Document::load(path, self.theme.scopes())?;
self.views.push(View::new(doc, 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)
}
}

16
helix-view/src/keymap.rs
View file

@ -1,5 +1,6 @@
use crate::commands::{self, Command};
use helix_core::{hashmap, state};
use crate::document::Mode;
use helix_core::hashmap;
use std::collections::HashMap;
// Kakoune-inspired:
@ -81,14 +82,17 @@ use std::collections::HashMap;
// = = align?
// + =
// }
//
// gd = goto definition
// gr = goto reference
// }
#[cfg(feature = "term")]
pub use crossterm::event::{KeyCode, KeyEvent as Key, KeyModifiers as Modifiers};
// TODO: could be trie based
type Keymap = HashMap<Vec<Key>, Command>;
type Keymaps = HashMap<state::Mode, Keymap>;
pub type Keymap = HashMap<Vec<Key>, Command>;
pub type Keymaps = HashMap<Mode, Keymap>;
macro_rules! key {
($ch:expr) => {
@ -128,7 +132,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 +183,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 +205,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

3
helix-view/src/lib.rs
View file

@ -1,9 +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;

2
helix-view/src/theme.rs
View file

@ -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();

48
helix-view/src/view.rs
View file

@ -1,44 +1,39 @@
use anyhow::Error;
use std::{borrow::Cow, path::PathBuf};
use std::borrow::Cow;
use crate::theme::Theme;
use crate::Document;
use helix_core::{
graphemes::{grapheme_width, RopeGraphemes},
indent::TAB_WIDTH,
History, Position, RopeSlice, State,
Position, RopeSlice,
};
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 doc: Document,
pub first_line: usize,
pub size: (u16, u16),
pub theme: Theme, // TODO: share one instance
}
impl View {
pub fn open(path: PathBuf, size: (u16, u16)) -> Result<Self, Error> {
let theme = Theme::default();
let state = State::load(path, theme.scopes())?;
pub fn new(doc: Document, size: (u16, u16)) -> Result<Self, Error> {
let view = Self {
state,
doc,
first_line: 0,
size,
theme,
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
@ -58,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,
)
}
@ -90,4 +85,25 @@ impl View {
Some(Position::new(row, col))
}
// pub fn traverse<F>(&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,
// }
// }
}