e1109a5 · helix · git.iko.soy

1−use helix_lsp::lsp;

1+use helix_lsp::{lsp, LspProgressMap};

2use helix_view::{document::Mode, Document, Editor, Theme, View};

3

4use crate::{args::Args, compositor::Compositor, config::Config, keymap::Keymaps, ui};

9 future::Future,

10 io::{self, stdout, Stdout, Write},

11 path::PathBuf,

12+ pin::Pin,

12 sync::Arc,

13 sync::Arc,

13 time::Duration,

14 time::Duration,

14};

15};

23use tui::layout::Rect;

24use tui::layout::Rect;

24

25

25use futures_util::stream::FuturesUnordered;

26use futures_util::stream::FuturesUnordered;

26−use std::pin::Pin;

27

28type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;

29pub type LspCallback =

37 editor: Editor,

38

39 callbacks: LspCallbacks,

40+

41+ lsp_progress: LspProgressMap,

40}

42}

41

43

42impl Application {

44impl Application {

74 editor,

76 editor,

75

77

76 callbacks: FuturesUnordered::new(),

78 callbacks: FuturesUnordered::new(),

79+ lsp_progress: LspProgressMap::new(),

77 };

80 };

78

81

79 Ok(app)

82 Ok(app)

246 log::warn!("unhandled window/logMessage: {:?}", params);

249 log::warn!("unhandled window/logMessage: {:?}", params);

247 }

250 }

248 Notification::ProgressMessage(params) => {

251 Notification::ProgressMessage(params) => {

249− let token = match params.token {

252+ let lsp::ProgressParams { token, value } = params;

250− lsp::NumberOrString::Number(n) => n.to_string(),

253+

251− lsp::NumberOrString::String(s) => s,

252− };

253− let msg = {

254− let lsp::ProgressParamsValue::WorkDone(work) = params.value;

254+ let lsp::ProgressParamsValue::WorkDone(work) = value;

255− let parts = match work {

255+ let parts = match &work {

256 lsp::WorkDoneProgress::Begin(lsp::WorkDoneProgressBegin {

257 title,

258 message,

259 percentage,

260 ..

261− }) => (Some(title), message, percentage.map(|n| n.to_string())),

261+ }) => (Some(title), message, percentage),

262 lsp::WorkDoneProgress::Report(lsp::WorkDoneProgressReport {

263 message,

264 percentage,

265 ..

266− }) => (None, message, percentage.map(|n| n.to_string())),

266+ }) => (None, message, percentage),

267− lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd {

267+ lsp::WorkDoneProgress::End(lsp::WorkDoneProgressEnd { message }) => {

268− message,

269− }) => {

270− if let Some(message) = message {

268+ if message.is_some() {

271− (None, Some(message), None)

269+ (None, message, &None)

272 } else {

270 } else {

271+ self.lsp_progress.end_progress(server_id, &token);

273 self.editor.clear_status();

272 self.editor.clear_status();

274 return;

273 return;

275 }

274 }

276 }

275 }

277 };

276 };

277+ let token_d: &dyn std::fmt::Display = match &token {

278+ lsp::NumberOrString::Number(n) => n,

279+ lsp::NumberOrString::String(s) => s,

280+ };

281+

278− match parts {

282+ let status = match parts {

279 (Some(title), Some(message), Some(percentage)) => {

283 (Some(title), Some(message), Some(percentage)) => {

280− format!("{}% {} - {}", percentage, title, message)

284+ format!("[{}] {}% {} - {}", token_d, percentage, title, message)

281 }

285 }

282 (Some(title), None, Some(percentage)) => {

286 (Some(title), None, Some(percentage)) => {

283− format!("{}% {}", percentage, title)

287+ format!("[{}] {}% {}", token_d, percentage, title)

284 }

288 }

285 (Some(title), Some(message), None) => {

289 (Some(title), Some(message), None) => {

286− format!("{} - {}", title, message)

290+ format!("[{}] {} - {}", token_d, title, message)

287 }

291 }

288 (None, Some(message), Some(percentage)) => {

292 (None, Some(message), Some(percentage)) => {

289− format!("{}% {}", percentage, message)

293+ format!("[{}] {}% {}", token_d, percentage, message)

290 }

294 }

291− (Some(title), None, None) => title,

295+ (Some(title), None, None) => {

296+ format!("[{}] {}", token_d, title)

297+ }

292− (None, Some(message), None) => message,

298+ (None, Some(message), None) => {

299+ format!("[{}] {}", token_d, message)

300+ }

293− (None, None, Some(percentage)) => format!("{}%", percentage),

301+ (None, None, Some(percentage)) => {

294− (None, None, None) => "".into(),

302+ format!("[{}] {}%", token_d, percentage)

295 }

303 }

304+ (None, None, None) => format!("[{}]", token_d),

296 };

305 };

297− let status = format!("[{}] {}", token, msg);

306+

307+ if let lsp::WorkDoneProgress::End(_) = work {

308+ self.lsp_progress.end_progress(server_id, &token);

309+ } else {

310+ self.lsp_progress.update(server_id, token, work);

311+ }

312+

298 self.editor.set_status(status);

313 self.editor.set_status(status);

299 self.render();

314 self.render();

300 }

315 }