add an XMakeInfo abstraction to probe the specifications of the xmake executable

build.gradle.kts

@@ -46,6 +46,7 @@ plugins {
     id("org.jetbrains.intellij") version "1.17.1"
     id("org.jetbrains.kotlin.jvm") version "1.9.22"
     id("org.jetbrains.changelog") version "2.2.0"
+    kotlin("plugin.serialization") version "1.9.22"
 }
 
 group = "io.xmake"
@@ -136,6 +137,7 @@ tasks {
 
 dependencies {
     implementation("org.jetbrains.kotlin:kotlin-stdlib:2.0.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
     testImplementation("io.mockk:mockk:1.13.12")
 }
 

src/main/kotlin/io/xmake/utils/info/XMakeInfo.kt

@@ -0,0 +1,73 @@
+package io.xmake.utils.info
+
+import com.intellij.openapi.diagnostic.logger
+import kotlinx.serialization.json.Json
+
+class XMakeInfo {
+
+    var apis: XMakeApis? = null
+    var architectures: XMakeArchitectures = emptyMap()
+    var buildModes: XMakeBuildModes = emptyList()
+    var envs: XMakeEnvs = emptyMap()
+    var packages: XMakePackages = emptyList()
+    var platforms: XMakePlatforms = emptyList()
+    var policies: XMakePolicies = emptyMap()
+    var rules: XMakeRules = emptyList()
+    var targets: XMakeTargets = emptyList()
+    var toolchains: XMakeToolchains = emptyMap()
+
+    fun parseApis(apiString: String): XMakeApis? {
+        return Json.decodeFromString(apiString)
+    }
+
+    fun parseArchitectures(archString: String): XMakeArchitectures {
+        return Json.decodeFromString(archString)
+    }
+
+    fun parseBuildModes(buildModeString: String): XMakeBuildModes {
+        return Json.decodeFromString(buildModeString)
+    }
+
+    fun parseEnvs(envString: String): XMakeEnvs {
+        // Todo
+        return emptyMap()
+    }
+
+    fun parsePackages(packageString: String): XMakePackages {
+        // Todo
+        return emptyList()
+    }
+
+    fun parsePlatforms(platformString: String): XMakePlatforms {
+        return Json.decodeFromString(platformString)
+    }
+
+    fun parsePolicies(policyString: String): XMakePolicies {
+        // Todo
+        return emptyMap()
+    }
+
+    fun parseRules(ruleString: String): XMakeRules {
+        return Json.decodeFromString(ruleString)
+    }
+
+    fun parseTargets(targetString: String): XMakeTargets {
+        return Json.decodeFromString(targetString)
+    }
+
+    fun parseToolchains(toolchainString: String): XMakeToolchains {
+        return toolchainString.split("\n").associate {
+            it.split(" ", limit = 2).map { s ->
+                s.replace(Regex("\u001B\\[[0-9;]*[A-Za-z]"), "")
+            }.let { (toolchain, description) ->
+                toolchain to description
+            }
+        }.also { Log.info("Parsed XMake Supported Toolchains: ${it.keys}") }
+    }
+
+    companion object {
+        val Log = logger<XMakeInfo>()
+
+    }
+}
+

src/main/kotlin/io/xmake/utils/info/XMakeInfoInstance.kt

@@ -0,0 +1,6 @@
+package io.xmake.utils.info
+
+import com.intellij.openapi.project.Project
+
+val Project.xmakeInfo: XMakeInfo
+    get() = XMakeInfoManager.getInstance(this).xmakeInfo

src/main/kotlin/io/xmake/utils/info/XMakeInfoManager.kt

@@ -0,0 +1,117 @@
+package io.xmake.utils.info
+
+import com.intellij.execution.configurations.GeneralCommandLine
+import com.intellij.openapi.components.Service
+import com.intellij.openapi.components.serviceOrNull
+import com.intellij.openapi.diagnostic.logger
+import com.intellij.openapi.project.Project
+import io.xmake.project.toolkit.Toolkit
+import io.xmake.utils.execute.createProcess
+import io.xmake.utils.execute.runProcess
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+
+@Service(Service.Level.PROJECT)
+class XMakeInfoManager(val project: Project, private val scope: CoroutineScope) {
+
+    val xmakeInfo: XMakeInfo = XMakeInfo()
+
+    // Todo
+    val cachedXMakeInfoMap: MutableMap<Toolkit, XMakeInfo> = mutableMapOf()
+
+    fun probeXMakeInfo(toolkit: Toolkit?) {
+        scope.launch {
+            toolkit?.let {
+                val apisString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l apis --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val architecturesString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l architectures --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val buildModesString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l buildmodes --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val envsString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l envs --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val packagesString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l packages --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val platformsString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l platforms --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val policiesString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l policies --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val rulesString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l rules --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val targetsString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l targets --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                val toolchainsString = runProcess(
+                    GeneralCommandLine(
+                        "xmake show -l toolchains --json".split(" ")
+                    ).createProcess(it)
+                ).first.getOrDefault("")
+
+                with(xmakeInfo) {
+                    apis = parseApis(apisString)
+                    architectures = parseArchitectures(architecturesString)
+                    buildModes = parseBuildModes(buildModesString)
+                    platforms = parsePlatforms(platformsString)
+                    policies = parsePolicies(policiesString)
+                    rules = parseRules(rulesString)
+//                    targets = parseTargets(targetsString)
+                    toolchains = parseToolchains(toolchainsString)
+
+                    Log.info(
+                        "XMake Info: " +
+                                "$apis, " +
+                                "$architectures, " +
+                                "$platforms, " +
+                                "$policies, " +
+                                "$rules, " +
+                                "$targets, " +
+                                "$toolchains"
+                    )
+                }
+
+                println(xmakeInfo)
+
+            }
+        }
+    }
+
+    companion object {
+        val Log = logger<XMakeInfoManager>()
+        fun getInstance(project: Project): XMakeInfoManager = project.serviceOrNull() ?: throw IllegalStateException()
+    }
+}

src/main/kotlin/io/xmake/utils/info/XMakeInfoTypes.kt

@@ -0,0 +1,31 @@
+package io.xmake.utils.info
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class XMakeApis(
+    @SerialName("description_builtin_apis")
+    val descriptionBuiltinApis: List<String>,
+    @SerialName("description_builtin_module_apis")
+    val descriptionBuiltinModuleApis: List<String>,
+    @SerialName("script_instance_apis")
+    val scriptInstanceApis: List<String>,
+    @SerialName("script_extension_module_apis")
+    val scriptExtensionModuleApis: List<String>,
+    @SerialName("description_scope_apis")
+    val descriptionScopeApis: List<String>,
+    @SerialName("script_builtin_apis")
+    val scriptBuiltinApis: List<String>,
+    @SerialName("script_builtin_module_apis")
+    val scriptBuiltinModuleApis: List<String>,
+)
+typealias XMakeArchitectures = Map<String, List<String>>
+typealias XMakeBuildModes = List<String>
+typealias XMakeEnvs = Map<String, String>
+typealias XMakePackages = List<String>
+typealias XMakePlatforms = List<String>
+typealias XMakePolicies = Map<String, Any>
+typealias XMakeRules = List<String>
+typealias XMakeTargets = List<String>
+typealias XMakeToolchains = Map<String, String>

src/main/resources/META-INF/plugin.xml

@@ -52,6 +52,8 @@
         <!-- notifications -->
         <notificationGroup id="XMake.NotificationGroup" displayType="BALLOON"/>
 
+        <postStartupActivity implementation="io.xmake.utils.info.XMakeInfoActivity"/>
+
         <fileType name="xmake.lua" language="xmake.lua" fieldName="INSTANCE"
                   fileNames="xmake.lua" fileNamesCaseInsensitive="xmake.lua"
                   implementationClass="io.xmake.file.XMakeLuaFileType"/>