get xmake version from cmd

Author: CppCXY

Cargo.lock

@@ -13,6 +13,7 @@ use tokio_util::sync::CancellationToken;
 use wax::Pattern;
 use xmake_code_analysis::uri_to_file_path;
 use xmake_code_analysis::{Emmyrc, XmakeAnalysis, load_configs};
+use xmake_wrapper::XmakeVersion;
 
 pub struct WorkspaceManager {
     analysis: Arc<RwLock<XmakeAnalysis>>,
@@ -28,6 +29,7 @@ pub struct WorkspaceManager {
     pub match_file_pattern: WorkspaceFileMatcher,
     // 原子变量
     pub workspace_initialized: Arc<AtomicBool>,
+    pub xmake_version: XmakeVersion,
 }
 
 impl WorkspaceManager {
@@ -49,6 +51,7 @@ impl WorkspaceManager {
             current_open_files: HashSet::new(),
             match_file_pattern: WorkspaceFileMatcher::default(),
             workspace_initialized: Arc::new(AtomicBool::new(false)),
+            xmake_version: XmakeVersion::default(),
         }
     }
 

crates/xmake_ls/src/context/workspace_manager.rs

@@ -22,7 +22,30 @@ pub async fn init_xmake(context: &ServerContextSnapshot) {
         return;
     }
 
-    // donot need load xmake lib files for now
+    let xmake_version = match context.xmake().get_xmake_version().await {
+        Ok(version) => {
+            log::info!("xmake version: {}", version);
+            version
+        }
+        Err(err) => {
+            log::warn!("failed to get xmake version: {}", err);
+            let message = ShowMessageParams {
+                typ: lsp_types::MessageType::ERROR,
+                message: format!(
+                    "Failed to get xmake version: {}. Please ensure xmake is properly installed.",
+                    err
+                ),
+            };
+            context.client().show_message(message);
+            return;
+        }
+    };
+
+    // set version to workspace
+    {
+        let mut workspace = context.workspace_manager().write().await;
+        workspace.xmake_version = xmake_version;
+    }
 
     let Some(xmake_path) = context.xmake().get_xmake_path().await else {
         log::warn!("xmake directory not found");

crates/xmake_ls/src/handlers/initialized/xmake_initialize.rs

@@ -1,34 +1,34 @@
 use crate::{XmakeCommand, XmakeCommandType, XmakeError, XmakeOutput, XmakeWrapper};
 
-/// xmake命令构建器
+/// xmake command builder
 #[derive(Debug, Clone)]
 pub struct XmakeCommandBuilder {
     wrapper: XmakeWrapper,
     pub(crate) command: XmakeCommand,
 }
 
 impl XmakeCommandBuilder {
-    /// 创建新的命令构建器
+    /// Create a new command builder
     pub fn new(wrapper: XmakeWrapper) -> Self {
         Self {
             wrapper,
-            command: XmakeCommand::new(XmakeCommandType::Build), // 默认命令
+            command: XmakeCommand::new(XmakeCommandType::Build), // default command
         }
     }
 
-    /// 设置命令类型
+    /// Set command type
     pub fn command_type(mut self, cmd_type: XmakeCommandType) -> Self {
         self.command.command_type = cmd_type;
         self
     }
 
-    /// 添加参数
+    /// Add an argument
     pub fn arg<S: Into<String>>(mut self, arg: S) -> Self {
         self.command = self.command.arg(arg);
         self
     }
 
-    /// 添加多个参数
+    /// Add multiple arguments
     pub fn args<I, S>(mut self, args: I) -> Self
     where
         I: IntoIterator<Item = S>,
@@ -38,7 +38,7 @@ impl XmakeCommandBuilder {
         self
     }
 
-    /// 添加环境变量
+    /// Add an environment variable
     pub fn env<K, V>(mut self, key: K, value: V) -> Self
     where
         K: Into<String>,
@@ -48,73 +48,73 @@ impl XmakeCommandBuilder {
         self
     }
 
-    /// 设置是否继承父进程环境变量
+    /// Set whether to inherit parent environment variables
     pub fn inherit_env(mut self, inherit: bool) -> Self {
         self.command = self.command.inherit_env(inherit);
         self
     }
 
-    /// 执行命令
+    /// Execute the command
     pub async fn execute(self) -> Result<XmakeOutput, XmakeError> {
         self.wrapper.execute(&self.command).await
     }
 
-    /// 构建项目
+    /// Build project
     pub fn build() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Build)
     }
 
-    /// 清理项目
+    /// Clean project
     pub fn clean() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Clean)
     }
 
-    /// 配置项目
+    /// Configure project
     pub fn config() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Config)
     }
 
-    /// 安装项目
+    /// Install project
     pub fn install() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Install)
     }
 
-    /// 创建新项目
+    /// Create new project
     pub fn create() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Create)
     }
 
-    /// 运行项目
+    /// Run project
     pub fn run() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Run)
     }
 
-    /// 显示版本信息
+    /// Show version info
     pub fn version() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Version)
     }
 
-    /// 显示帮助信息
+    /// Show help info
     pub fn help() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Help)
     }
 
-    /// 显示项目信息
+    /// Show project info
     pub fn show() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Show)
     }
 
-    /// 包管理命令
+    /// Package management command
     pub fn package() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Package)
     }
 
-    /// 测试项目
+    /// Test project
     pub fn test() -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         |wrapper| XmakeCommandBuilder::new(wrapper).command_type(XmakeCommandType::Test)
     }
 
-    /// 自定义命令
+    /// Custom command
     pub fn custom<S: Into<String>>(cmd: S) -> impl Fn(XmakeWrapper) -> XmakeCommandBuilder {
         let cmd = cmd.into();
         move |wrapper| {
@@ -123,64 +123,64 @@ impl XmakeCommandBuilder {
     }
 }
 
-/// 便捷的命令构建函数
+/// Convenience command builder helpers
 impl XmakeWrapper {
-    /// 构建项目
+    /// Build project
     pub fn build(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::build()(self.clone())
     }
 
-    /// 清理项目
+    /// Clean project
     pub fn clean(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::clean()(self.clone())
     }
 
-    /// 配置项目
+    /// Configure project
     pub fn config(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::config()(self.clone())
     }
 
-    /// 安装项目
+    /// Install project
     pub fn install(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::install()(self.clone())
     }
 
-    /// 创建新项目
+    /// Create new project
     pub fn create(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::create()(self.clone())
     }
 
-    /// 运行项目
+    /// Run project
     pub fn run(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::run()(self.clone())
     }
 
-    /// 显示版本信息
+    /// Show version info
     pub fn version(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::version()(self.clone())
     }
 
-    /// 显示帮助信息
+    /// Show help info
     pub fn help(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::help()(self.clone())
     }
 
-    /// 显示项目信息
+    /// Show project info
     pub fn show(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::show()(self.clone())
     }
 
-    /// 包管理命令
+    /// Package management command
     pub fn package(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::package()(self.clone())
     }
 
-    /// 测试项目
+    /// Test project
     pub fn test(&self) -> XmakeCommandBuilder {
         XmakeCommandBuilder::test()(self.clone())
     }
 
-    /// 自定义命令
+    /// Custom command
     pub fn custom<S: Into<String>>(&self, cmd: S) -> XmakeCommandBuilder {
         XmakeCommandBuilder::custom(cmd)(self.clone())
     }