refactor status bar

Author: CppCXY

.vscode/settings.json

@@ -0,0 +1 @@
+{}

crates/emmylua_ls/src/context/client_id.rs

@@ -0,0 +1,51 @@
+use lsp_types::ClientInfo;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum ClientId {
+    VSCode,
+    Intellij,
+    Neovim,
+    Other,
+}
+
+impl Default for ClientId {
+    fn default() -> Self {
+        ClientId::Other
+    }
+}
+
+#[allow(unused)]
+impl ClientId {
+    pub fn is_vscode(&self) -> bool {
+        matches!(self, ClientId::VSCode)
+    }
+
+    pub fn is_intellij(&self) -> bool {
+        matches!(self, ClientId::Intellij)
+    }
+
+    pub fn is_neovim(&self) -> bool {
+        matches!(self, ClientId::Neovim)
+    }
+
+    pub fn is_other(&self) -> bool {
+        matches!(self, ClientId::Other)
+    }
+}
+
+pub fn get_client_id(client_info: &Option<ClientInfo>) -> ClientId {
+    match client_info {
+        Some(info) => {
+            if info.name == "Visual Studio Code" {
+                ClientId::VSCode
+            } else if info.name == "IntelliJ" {
+                ClientId::Intellij
+            } else if info.name == "Neovim" {
+                ClientId::Neovim
+            } else {
+                ClientId::Other
+            }
+        }
+        None => ClientId::Other,
+    }
+}

crates/emmylua_ls/src/context/config_manager.rs

@@ -1,6 +1,6 @@
 use std::{path::PathBuf, sync::Arc, time::Duration};
 
-use super::{ClientProxy, VsCodeStatusBar};
+use super::{ClientProxy, StatusBar};
 use crate::handlers::{init_analysis, ClientConfig};
 use code_analysis::{load_configs, EmmyLuaAnalysis, Emmyrc};
 use emmylua_codestyle::update_code_style;
@@ -14,7 +14,7 @@ use tokio_util::sync::CancellationToken;
 pub struct ConfigManager {
     analysis: Arc<RwLock<EmmyLuaAnalysis>>,
     client: Arc<ClientProxy>,
-    status_bar: Arc<VsCodeStatusBar>,
+    status_bar: Arc<StatusBar>,
     pub client_config: ClientConfig,
     pub workspace_folders: Vec<PathBuf>,
     config_update_token: Arc<Mutex<Option<CancellationToken>>>,
@@ -25,7 +25,7 @@ impl ConfigManager {
     pub fn new(
         analysis: Arc<RwLock<EmmyLuaAnalysis>>,
         client: Arc<ClientProxy>,
-        status_bar: Arc<VsCodeStatusBar>,
+        status_bar: Arc<StatusBar>,
     ) -> Self {
         Self {
             analysis,

crates/emmylua_ls/src/context/file_diagnostic.rs

@@ -5,21 +5,21 @@ use log::{debug, info};
 use tokio::sync::{Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
 
-use super::{status_bar::VsCodeStatusBar, ClientProxy};
+use super::{status_bar::StatusBar, ClientProxy};
 
 pub struct FileDiagnostic {
     analysis: Arc<RwLock<EmmyLuaAnalysis>>,
     client: Arc<ClientProxy>,
     #[allow(unused)]
-    status_bar: Arc<VsCodeStatusBar>,
+    status_bar: Arc<StatusBar>,
     diagnostic_tokens: Arc<Mutex<HashMap<FileId, CancellationToken>>>,
 }
 
 impl FileDiagnostic {
     pub fn new(
         analysis: Arc<RwLock<EmmyLuaAnalysis>>,
         client: Arc<ClientProxy>,
-        status_bar: Arc<VsCodeStatusBar>,
+        status_bar: Arc<StatusBar>,
     ) -> Self {
         Self {
             analysis,

crates/emmylua_ls/src/context/mod.rs

@@ -1,18 +1,20 @@
 mod client;
+mod client_id;
 mod config_manager;
 mod file_diagnostic;
 mod snapshot;
 mod status_bar;
 
 pub use client::ClientProxy;
+pub use client_id::{get_client_id, ClientId};
 use code_analysis::EmmyLuaAnalysis;
 pub use config_manager::load_emmy_config;
 pub use config_manager::ConfigManager;
 pub use file_diagnostic::FileDiagnostic;
 use lsp_server::{Connection, ErrorCode, Message, RequestId, Response};
 pub use snapshot::ServerContextSnapshot;
-pub use status_bar::VsCodeStatusBar;
-pub use status_bar::Task;
+pub use status_bar::StatusBar;
+pub use status_bar::ProgressTask;
 use std::{collections::HashMap, future::Future, sync::Arc};
 use tokio::sync::{Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
@@ -25,7 +27,7 @@ pub struct ServerContext {
     cancllations: Arc<Mutex<HashMap<RequestId, CancellationToken>>>,
     file_diagnostic: Arc<FileDiagnostic>,
     config_manager: Arc<RwLock<ConfigManager>>,
-    status_bar: Arc<VsCodeStatusBar>,
+    status_bar: Arc<StatusBar>,
 }
 
 impl ServerContext {
@@ -39,7 +41,7 @@ impl ServerContext {
         analysis.init_std_lib();
 
         let analysis = Arc::new(RwLock::new(analysis));
-        let status_bar = Arc::new(VsCodeStatusBar::new(client.clone()));
+        let status_bar = Arc::new(StatusBar::new(client.clone()));
         let file_diagnostic = Arc::new(FileDiagnostic::new(
             analysis.clone(),
             client.clone(),

crates/emmylua_ls/src/context/snapshot.rs

@@ -5,7 +5,7 @@ use code_analysis::EmmyLuaAnalysis;
 
 use super::{
     client::ClientProxy, config_manager::ConfigManager, file_diagnostic::FileDiagnostic,
-    status_bar::VsCodeStatusBar,
+    status_bar::StatusBar,
 };
 
 #[derive(Clone)]
@@ -14,5 +14,5 @@ pub struct ServerContextSnapshot {
     pub client: Arc<ClientProxy>,
     pub file_diagnostic: Arc<FileDiagnostic>,
     pub config_manager: Arc<RwLock<ConfigManager>>,
-    pub status_bar: Arc<VsCodeStatusBar>,
+    pub status_bar: Arc<StatusBar>,
 }

crates/emmylua_ls/src/context/status_bar.rs

@@ -6,93 +6,135 @@ use lsp_types::{
 };
 use serde::{Deserialize, Serialize};
 
-use super::ClientProxy;
+use super::{ClientId, ClientProxy};
 
-pub struct VsCodeStatusBar {
+pub struct StatusBar {
     client: Arc<ClientProxy>,
 }
 
 #[derive(Clone, Copy)]
-pub enum Task {
+pub enum ProgressTask {
     LoadWorkspace = 0,
     DiagnoseWorkspace = 1,
 }
 
-fn get_task_name(task: &Task) -> &'static str {
-    match task {
-        Task::LoadWorkspace => "Load workspace",
-        Task::DiagnoseWorkspace => "Diagnose workspace",
+impl ProgressTask {
+    pub fn as_i32(&self) -> i32 {
+        *self as i32
+    }
+
+    pub fn get_task_name(&self) -> &'static str {
+        match self {
+            ProgressTask::LoadWorkspace => "Load workspace",
+            ProgressTask::DiagnoseWorkspace => "Diagnose workspace",
+        }
     }
 }
 
-impl VsCodeStatusBar {
+impl StatusBar {
     pub fn new(client: Arc<ClientProxy>) -> Self {
         Self { client }
     }
 
-    pub fn set_server_status(&self, health: &str, loading: bool, message: &str) {
-        self.client.send_notification(
-            "emmy/setServerStatus",
-            EmmyServerStatus {
-                health: health.to_string(),
-                loading,
-                message: message.to_string(),
-            },
-        );
+    pub fn create_progress_task(&self, client_id: ClientId, task: ProgressTask) {
+        match client_id {
+            ClientId::VSCode => {
+                self.vscode_set_server_status("ok", true, task.get_task_name());
+            }
+            _ => {
+                self.client.send_notification(
+                    "window/workDoneProgress/create",
+                    WorkDoneProgressCreateParams {
+                        token: NumberOrString::Number(task.as_i32()),
+                    },
+                );
+                self.client.send_notification(
+                    "$/progress",
+                    ProgressParams {
+                        token: NumberOrString::Number(task as i32),
+                        value: ProgressParamsValue::WorkDone(WorkDoneProgress::Begin(
+                            WorkDoneProgressBegin {
+                                title: task.get_task_name().to_string(),
+                                cancellable: Some(false),
+                                message: Some(task.get_task_name().to_string()),
+                                percentage: None,
+                            },
+                        )),
+                    },
+                )
+            }
+        }
     }
 
-    pub fn start_task(&self, task: Task) {
-        self.client.send_notification(
-            "window/workDoneProgress/create",
-            WorkDoneProgressCreateParams {
-                token: NumberOrString::Number(task as i32),
-            },
-        );
-        self.client.send_notification(
-            "$/progress",
-            ProgressParams {
-                token: NumberOrString::Number(task as i32),
-                value: ProgressParamsValue::WorkDone(WorkDoneProgress::Begin(
-                    WorkDoneProgressBegin {
-                        title: get_task_name(&task).to_string(),
-                        cancellable: Some(false),
-                        message: Some(get_task_name(&task).to_string()),
-                        percentage: None,
-                    },
-                )),
-            },
-        )
+    pub fn update_progress_task(
+        &self,
+        client_id: ClientId,
+        task: ProgressTask,
+        percentage: Option<u32>,
+        message: Option<String>,
+    ) {
+        match client_id {
+            ClientId::VSCode => {
+                if let Some(message) = message {
+                    self.vscode_report_progress(&message, percentage.unwrap_or(0) as f64 / 100.0);
+                } else {
+                    self.vscode_report_progress(task.get_task_name(), percentage.unwrap() as f64);
+                }
+            }
+            _ => self.client.send_notification(
+                "$/progress",
+                ProgressParams {
+                    token: NumberOrString::Number(task.as_i32()),
+                    value: ProgressParamsValue::WorkDone(WorkDoneProgress::Report(
+                        WorkDoneProgressReport {
+                            percentage,
+                            cancellable: Some(false),
+                            message,
+                        },
+                    )),
+                },
+            ),
+        }
     }
 
-    pub fn update_task(&self, task: Task, percentage: Option<u32>, message: Option<String>) {
-        self.client.send_notification(
-            "$/progress",
-            ProgressParams {
-                token: NumberOrString::Number(task as i32),
-                value: ProgressParamsValue::WorkDone(WorkDoneProgress::Report(
-                    WorkDoneProgressReport {
-                        percentage,
-                        cancellable: Some(false),
-                        message,
-                    },
-                )),
-            },
-        )
+    pub fn finish_progress_task(
+        &self,
+        client_id: ClientId,
+        task: ProgressTask,
+        message: Option<String>,
+    ) {
+        match client_id {
+            ClientId::VSCode => {
+                if let Some(message) = message {
+                    self.vscode_set_server_status("ok", false, &message);
+                } else {
+                    self.vscode_set_server_status("ok", false, task.get_task_name());
+                }
+            }
+            _ => self.client.send_notification(
+                "$/progress",
+                ProgressParams {
+                    token: NumberOrString::Number(task.as_i32()),
+                    value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(
+                        WorkDoneProgressEnd { message },
+                    )),
+                },
+            ),
+        }
     }
 
-    pub fn finish_task(&self, task: Task, message: Option<String>) {
+    fn vscode_set_server_status(&self, health: &str, loading: bool, message: &str) {
         self.client.send_notification(
-            "$/progress",
-            ProgressParams {
-                token: NumberOrString::Number(task as i32),
-                value: ProgressParamsValue::WorkDone(WorkDoneProgress::End(WorkDoneProgressEnd {
-                    message,
-                })),
+            "emmy/setServerStatus",
+            EmmyServerStatus {
+                health: health.to_string(),
+                loading,
+                message: message.to_string(),
             },
-        )
+        );
     }
 
-    pub fn report_progress(&self, message: &str, percentage: f64) {
+    fn vscode_report_progress(&self, message: &str, percentage: f64) {
         self.client.send_notification(
             "emmy/progressReport",
             EmmyProgress {

crates/emmylua_ls/src/handlers/code_lens/resolve_code_lens.rs

@@ -1,9 +1,9 @@
 use code_analysis::LuaCompilation;
 use lsp_types::{CodeLens, Command, Location, Range, Uri};
 
-use crate::handlers::{
-    initialized::ClientId,
-    references::{search_decl_references, search_member_references},
+use crate::{
+    context::ClientId,
+    handlers::references::{search_decl_references, search_member_references},
 };
 
 use super::CodeLensData;