2021-06-11 05:42:16 +02:00
|
|
|
use helix_lsp::lsp;
|
2020-12-10 10:13:42 +01:00
|
|
|
use helix_view::{document::Mode, Document, Editor, Theme, View};
|
2020-09-11 07:14:44 +02:00
|
|
|
|
2021-06-07 06:40:21 +02:00
|
|
|
use crate::{args::Args, compositor::Compositor, ui};
|
2020-12-06 03:53:58 +01:00
|
|
|
|
2021-02-15 13:16:25 +01:00
|
|
|
use log::{error, info};
|
2020-10-29 06:06:33 +01:00
|
|
|
|
2020-09-11 07:14:44 +02:00
|
|
|
use std::{
|
2021-05-06 06:56:34 +02:00
|
|
|
future::Future,
|
2020-10-09 22:05:57 +02:00
|
|
|
io::{self, stdout, Stdout, Write},
|
2020-09-11 07:14:44 +02:00
|
|
|
path::PathBuf,
|
2020-12-23 07:50:16 +01:00
|
|
|
sync::Arc,
|
2020-09-11 07:14:44 +02:00
|
|
|
time::Duration,
|
|
|
|
};
|
|
|
|
|
2020-06-24 21:03:38 +02:00
|
|
|
use anyhow::Error;
|
2020-09-11 07:14:44 +02:00
|
|
|
|
2020-06-04 01:05:01 +02:00
|
|
|
use crossterm::{
|
2020-12-13 05:35:30 +01:00
|
|
|
event::{Event, EventStream},
|
|
|
|
execute, terminal,
|
2020-06-04 01:05:01 +02:00
|
|
|
};
|
2020-09-08 07:32:20 +02:00
|
|
|
|
2021-03-08 09:00:32 +01:00
|
|
|
use tui::layout::Rect;
|
2020-11-02 10:41:27 +01:00
|
|
|
|
2021-03-26 08:02:13 +01:00
|
|
|
use futures_util::stream::FuturesUnordered;
|
|
|
|
use std::pin::Pin;
|
|
|
|
|
|
|
|
type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
|
|
|
|
pub type LspCallback =
|
|
|
|
BoxFuture<Result<Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>, anyhow::Error>>;
|
|
|
|
|
|
|
|
pub type LspCallbacks = FuturesUnordered<LspCallback>;
|
|
|
|
pub type LspCallbackWrapper = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
|
|
|
|
|
2020-12-13 04:23:50 +01:00
|
|
|
pub struct Application {
|
2020-12-06 03:53:58 +01:00
|
|
|
compositor: Compositor,
|
2020-12-11 10:25:09 +01:00
|
|
|
editor: Editor,
|
2020-12-06 03:53:58 +01:00
|
|
|
|
2021-03-26 08:02:13 +01:00
|
|
|
callbacks: LspCallbacks,
|
2020-10-16 05:29:22 +02:00
|
|
|
}
|
|
|
|
|
2020-12-13 04:23:50 +01:00
|
|
|
impl Application {
|
2021-05-06 06:56:34 +02:00
|
|
|
pub fn new(mut args: Args) -> Result<Self, Error> {
|
2021-04-06 12:02:22 +02:00
|
|
|
use helix_view::editor::Action;
|
2021-03-08 09:00:32 +01:00
|
|
|
let mut compositor = Compositor::new()?;
|
|
|
|
let size = compositor.size();
|
2021-05-06 06:56:34 +02:00
|
|
|
let mut editor = Editor::new(size);
|
2020-12-06 03:53:58 +01:00
|
|
|
|
2021-06-02 16:20:41 +02:00
|
|
|
compositor.push(Box::new(ui::EditorView::new()));
|
|
|
|
|
2021-05-31 10:07:43 +02:00
|
|
|
if !args.files.is_empty() {
|
2021-06-02 16:20:41 +02:00
|
|
|
let first = &args.files[0]; // we know it's not empty
|
|
|
|
if first.is_dir() {
|
|
|
|
editor.new_file(Action::VerticalSplit);
|
|
|
|
compositor.push(Box::new(ui::file_picker(first.clone())));
|
|
|
|
} else {
|
|
|
|
for file in args.files {
|
|
|
|
if file.is_dir() {
|
|
|
|
return Err(anyhow::anyhow!(
|
|
|
|
"expected a path to file, found a directory. (to open a directory pass it as first argument)"
|
|
|
|
));
|
|
|
|
} else {
|
|
|
|
editor.open(file, Action::VerticalSplit)?;
|
|
|
|
}
|
|
|
|
}
|
2021-04-06 12:02:22 +02:00
|
|
|
}
|
|
|
|
} else {
|
2021-05-07 07:40:11 +02:00
|
|
|
editor.new_file(Action::VerticalSplit);
|
2020-12-06 03:53:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
let mut app = Self {
|
|
|
|
compositor,
|
2021-03-22 04:26:04 +01:00
|
|
|
editor,
|
2020-12-06 03:53:58 +01:00
|
|
|
|
2021-03-26 08:02:13 +01:00
|
|
|
callbacks: FuturesUnordered::new(),
|
2020-12-06 03:53:58 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
Ok(app)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn render(&mut self) {
|
2020-12-13 04:23:50 +01:00
|
|
|
let editor = &mut self.editor;
|
2021-03-08 09:00:32 +01:00
|
|
|
let compositor = &mut self.compositor;
|
2021-03-26 08:02:13 +01:00
|
|
|
let callbacks = &mut self.callbacks;
|
2020-12-13 04:23:50 +01:00
|
|
|
|
2021-03-08 09:32:13 +01:00
|
|
|
let mut cx = crate::compositor::Context {
|
|
|
|
editor,
|
2021-03-26 08:02:13 +01:00
|
|
|
callbacks,
|
2021-03-08 09:32:13 +01:00
|
|
|
scroll: None,
|
|
|
|
};
|
2020-12-13 04:23:50 +01:00
|
|
|
|
2021-03-08 09:00:32 +01:00
|
|
|
compositor.render(&mut cx);
|
2020-12-06 03:53:58 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
pub async fn event_loop(&mut self) {
|
|
|
|
let mut reader = EventStream::new();
|
|
|
|
|
|
|
|
self.render();
|
|
|
|
|
|
|
|
loop {
|
2021-02-19 09:46:43 +01:00
|
|
|
if self.editor.should_close() {
|
2020-12-11 10:25:09 +01:00
|
|
|
break;
|
|
|
|
}
|
2020-12-06 03:53:58 +01:00
|
|
|
|
2021-05-06 07:33:53 +02:00
|
|
|
use futures_util::StreamExt;
|
|
|
|
|
|
|
|
tokio::select! {
|
|
|
|
event = reader.next() => {
|
2020-12-06 03:53:58 +01:00
|
|
|
self.handle_terminal_events(event)
|
|
|
|
}
|
2021-05-06 07:33:53 +02:00
|
|
|
Some(call) = self.editor.language_servers.incoming.next() => {
|
2020-12-06 03:53:58 +01:00
|
|
|
self.handle_language_server_message(call).await
|
|
|
|
}
|
2021-05-06 07:33:53 +02:00
|
|
|
Some(callback) = &mut self.callbacks.next() => {
|
2021-03-26 08:02:13 +01:00
|
|
|
self.handle_language_server_callback(callback)
|
|
|
|
}
|
2020-12-06 03:53:58 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-03-26 08:02:13 +01:00
|
|
|
pub fn handle_language_server_callback(
|
|
|
|
&mut self,
|
2021-03-30 09:39:24 +02:00
|
|
|
callback: Result<LspCallbackWrapper, anyhow::Error>,
|
2021-03-26 08:02:13 +01:00
|
|
|
) {
|
2021-03-30 09:39:24 +02:00
|
|
|
if let Ok(callback) = callback {
|
2021-03-26 08:02:13 +01:00
|
|
|
// TODO: handle Err()
|
|
|
|
callback(&mut self.editor, &mut self.compositor);
|
|
|
|
self.render();
|
|
|
|
}
|
|
|
|
}
|
2020-12-06 03:53:58 +01:00
|
|
|
|
|
|
|
pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {
|
2020-12-11 10:25:09 +01:00
|
|
|
let mut cx = crate::compositor::Context {
|
|
|
|
editor: &mut self.editor,
|
2021-03-26 08:02:13 +01:00
|
|
|
callbacks: &mut self.callbacks,
|
2021-03-08 09:32:13 +01:00
|
|
|
scroll: None,
|
2020-12-11 10:25:09 +01:00
|
|
|
};
|
2020-12-06 03:53:58 +01:00
|
|
|
// Handle key events
|
2020-12-11 10:25:09 +01:00
|
|
|
let should_redraw = match event {
|
2020-12-06 03:53:58 +01:00
|
|
|
Some(Ok(Event::Resize(width, height))) => {
|
2021-03-08 09:00:32 +01:00
|
|
|
self.compositor.resize(width, height);
|
2020-12-06 03:53:58 +01:00
|
|
|
|
|
|
|
self.compositor
|
2020-12-11 10:25:09 +01:00
|
|
|
.handle_event(Event::Resize(width, height), &mut cx)
|
2020-12-06 03:53:58 +01:00
|
|
|
}
|
2020-12-11 10:25:09 +01:00
|
|
|
Some(Ok(event)) => self.compositor.handle_event(event, &mut cx),
|
2021-02-09 07:40:30 +01:00
|
|
|
Some(Err(x)) => panic!("{}", x),
|
2020-10-20 06:58:34 +02:00
|
|
|
None => panic!(),
|
|
|
|
};
|
2020-12-11 10:25:09 +01:00
|
|
|
|
2021-02-19 09:46:43 +01:00
|
|
|
if should_redraw && !self.editor.should_close() {
|
2020-12-11 10:25:09 +01:00
|
|
|
self.render();
|
|
|
|
}
|
2020-10-20 06:58:34 +02:00
|
|
|
}
|
|
|
|
|
2021-03-30 09:39:24 +02:00
|
|
|
pub async fn handle_language_server_message(&mut self, call: helix_lsp::Call) {
|
2020-10-23 11:48:03 +02:00
|
|
|
use helix_lsp::{Call, Notification};
|
|
|
|
match call {
|
2021-03-30 09:39:24 +02:00
|
|
|
Call::Notification(helix_lsp::jsonrpc::Notification { method, params, .. }) => {
|
2021-05-08 11:17:13 +02:00
|
|
|
let notification = match Notification::parse(&method, params) {
|
|
|
|
Some(notification) => notification,
|
|
|
|
None => return,
|
|
|
|
};
|
|
|
|
|
2021-04-15 10:34:38 +02:00
|
|
|
// TODO: parse should return Result/Option
|
2020-10-23 11:48:03 +02:00
|
|
|
match notification {
|
|
|
|
Notification::PublishDiagnostics(params) => {
|
|
|
|
let path = Some(params.uri.to_file_path().unwrap());
|
2020-12-22 08:58:00 +01:00
|
|
|
|
2021-03-16 10:27:57 +01:00
|
|
|
let doc = self
|
2021-02-05 09:50:31 +01:00
|
|
|
.editor
|
2021-03-16 10:27:57 +01:00
|
|
|
.documents
|
|
|
|
.iter_mut()
|
2021-03-23 09:47:40 +01:00
|
|
|
.find(|(_, doc)| doc.path() == path.as_ref());
|
2021-03-16 10:27:57 +01:00
|
|
|
|
|
|
|
if let Some((_, doc)) = doc {
|
|
|
|
let text = doc.text();
|
2020-10-23 11:48:03 +02:00
|
|
|
|
|
|
|
let diagnostics = params
|
|
|
|
.diagnostics
|
|
|
|
.into_iter()
|
|
|
|
.map(|diagnostic| {
|
2021-03-15 08:19:31 +01:00
|
|
|
use helix_core::{
|
2021-03-22 04:40:07 +01:00
|
|
|
diagnostic::{Range, Severity, Severity::*},
|
2021-03-15 08:19:31 +01:00
|
|
|
Diagnostic,
|
|
|
|
};
|
2021-03-11 08:31:49 +01:00
|
|
|
use helix_lsp::{lsp, util::lsp_pos_to_pos};
|
|
|
|
use lsp::DiagnosticSeverity;
|
2021-04-14 08:30:15 +02:00
|
|
|
|
|
|
|
let language_server = doc.language_server().unwrap();
|
|
|
|
|
|
|
|
// TODO: convert inside server
|
|
|
|
let start = lsp_pos_to_pos(
|
|
|
|
text,
|
|
|
|
diagnostic.range.start,
|
|
|
|
language_server.offset_encoding(),
|
|
|
|
);
|
|
|
|
let end = lsp_pos_to_pos(
|
|
|
|
text,
|
|
|
|
diagnostic.range.end,
|
|
|
|
language_server.offset_encoding(),
|
|
|
|
);
|
2020-10-23 11:48:03 +02:00
|
|
|
|
2021-03-11 08:31:49 +01:00
|
|
|
Diagnostic {
|
2021-03-15 08:19:31 +01:00
|
|
|
range: Range { start, end },
|
2020-10-23 11:48:03 +02:00
|
|
|
line: diagnostic.range.start.line as usize,
|
|
|
|
message: diagnostic.message,
|
2021-03-11 08:31:49 +01:00
|
|
|
severity: diagnostic.severity.map(
|
|
|
|
|severity| match severity {
|
|
|
|
DiagnosticSeverity::Error => Error,
|
|
|
|
DiagnosticSeverity::Warning => Warning,
|
|
|
|
DiagnosticSeverity::Information => Info,
|
|
|
|
DiagnosticSeverity::Hint => Hint,
|
|
|
|
},
|
|
|
|
),
|
2020-10-23 11:48:03 +02:00
|
|
|
// code
|
|
|
|
// source
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect();
|
|
|
|
|
2021-06-06 11:59:32 +02:00
|
|
|
doc.set_diagnostics(diagnostics);
|
2020-10-29 06:06:33 +01:00
|
|
|
// TODO: we want to process all the events in queue, then render. publishDiagnostic tends to send a whole bunch of events
|
2020-10-23 11:48:03 +02:00
|
|
|
self.render();
|
|
|
|
}
|
|
|
|
}
|
2021-04-15 10:34:38 +02:00
|
|
|
Notification::ShowMessage(params) => {
|
|
|
|
log::warn!("unhandled window/showMessage: {:?}", params);
|
|
|
|
}
|
|
|
|
Notification::LogMessage(params) => {
|
|
|
|
log::warn!("unhandled window/logMessage: {:?}", params);
|
|
|
|
}
|
2021-06-11 05:42:16 +02:00
|
|
|
Notification::ProgressMessage(params) => {
|
|
|
|
let token = match params.token {
|
|
|
|
lsp::NumberOrString::Number(n) => n.to_string(),
|
|
|
|
lsp::NumberOrString::String(s) => s,
|
|
|
|
};
|
|
|
|
let msg = {
|
|
|
|
let lsp::ProgressParamsValue::WorkDone(work) = params.value;
|
|
|
|
let parts = match work {
|
|
|
|
lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {
|
|
|
|
title,
|
|
|
|
message,
|
|
|
|
percentage,
|
|
|
|
..
|
|
|
|
}) => (Some(title), message, percentage.map(|n| n.to_string())),
|
|
|
|
lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {
|
|
|
|
message,
|
|
|
|
percentage,
|
|
|
|
..
|
|
|
|
}) => (None, message, percentage.map(|n| n.to_string())),
|
|
|
|
lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd {
|
|
|
|
message,
|
|
|
|
}) => {
|
|
|
|
if let Some(message) = message {
|
|
|
|
(None, Some(message), None)
|
|
|
|
} else {
|
|
|
|
self.editor.clear_status();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
match parts {
|
|
|
|
(Some(title), Some(message), Some(percentage)) => {
|
|
|
|
format!("{}% {} - {}", percentage, title, message)
|
|
|
|
}
|
|
|
|
(Some(title), None, Some(percentage)) => {
|
|
|
|
format!("{}% {}", percentage, title)
|
|
|
|
}
|
|
|
|
(Some(title), Some(message), None) => {
|
|
|
|
format!("{} - {}", title, message)
|
|
|
|
}
|
|
|
|
(None, Some(message), Some(percentage)) => {
|
|
|
|
format!("{}% {}", percentage, message)
|
|
|
|
}
|
|
|
|
(Some(title), None, None) => title,
|
|
|
|
(None, Some(message), None) => message,
|
|
|
|
(None, None, Some(percentage)) => format!("{}%", percentage),
|
|
|
|
(None, None, None) => "".into(),
|
|
|
|
}
|
|
|
|
};
|
|
|
|
let status = format!("[{}] {}", token, msg);
|
|
|
|
self.editor.set_status(status);
|
|
|
|
self.render();
|
|
|
|
}
|
2020-10-23 11:48:03 +02:00
|
|
|
_ => unreachable!(),
|
2020-10-20 08:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
2021-03-30 09:39:24 +02:00
|
|
|
Call::MethodCall(call) => {
|
2021-02-15 13:16:25 +01:00
|
|
|
error!("Method not found {}", call.method);
|
2020-11-05 07:15:19 +01:00
|
|
|
|
2021-01-21 08:55:46 +01:00
|
|
|
// 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,
|
|
|
|
// }),
|
|
|
|
// );
|
2020-10-23 11:48:03 +02:00
|
|
|
}
|
2020-12-25 09:42:50 +01:00
|
|
|
e => unreachable!("{:?}", e),
|
2020-05-25 06:02:21 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-04 11:18:40 +02:00
|
|
|
pub async fn run(&mut self) -> Result<(), Error> {
|
2020-12-13 05:35:30 +01:00
|
|
|
terminal::enable_raw_mode()?;
|
2020-05-25 06:02:21 +02:00
|
|
|
|
2020-06-04 01:05:01 +02:00
|
|
|
let mut stdout = stdout();
|
2020-06-05 12:21:27 +02:00
|
|
|
|
|
|
|
execute!(stdout, terminal::EnterAlternateScreen)?;
|
|
|
|
|
2020-09-19 04:57:22 +02:00
|
|
|
// Exit the alternate screen and disable raw mode before panicking
|
|
|
|
let hook = std::panic::take_hook();
|
|
|
|
std::panic::set_hook(Box::new(move |info| {
|
|
|
|
execute!(std::io::stdout(), terminal::LeaveAlternateScreen);
|
2020-12-13 05:35:30 +01:00
|
|
|
terminal::disable_raw_mode();
|
2020-09-19 04:57:22 +02:00
|
|
|
hook(info);
|
|
|
|
}));
|
|
|
|
|
2020-09-13 04:32:37 +02:00
|
|
|
self.event_loop().await;
|
2020-06-05 12:21:27 +02:00
|
|
|
|
2020-09-05 15:01:05 +02:00
|
|
|
// reset cursor shape
|
|
|
|
write!(stdout, "\x1B[2 q");
|
|
|
|
|
2020-06-07 14:11:08 +02:00
|
|
|
execute!(stdout, terminal::LeaveAlternateScreen)?;
|
|
|
|
|
2020-12-13 05:35:30 +01:00
|
|
|
terminal::disable_raw_mode()?;
|
2020-06-16 11:00:34 +02:00
|
|
|
|
|
|
|
Ok(())
|
2020-06-01 10:42:28 +02:00
|
|
|
}
|
2020-05-25 06:02:21 +02:00
|
|
|
}
|