Support external tool as formatter

Author: CppCXY

crates/emmylua_code_analysis/resources/schema.json

@@ -59,6 +59,12 @@
         "enable": true
       }
     },
+    "format": {
+      "$ref": "#/$defs/EmmyrcReformat",
+      "default": {
+        "externalTool": null
+      }
+    },
     "hint": {
       "$ref": "#/$defs/EmmyrcInlayHint",
       "default": {
@@ -618,6 +624,30 @@
         }
       }
     },
+    "EmmyrcExternalTool": {
+      "type": "object",
+      "properties": {
+        "args": {
+          "description": "The arguments to pass to the external tool.",
+          "type": "array",
+          "default": [],
+          "items": {
+            "type": "string"
+          }
+        },
+        "program": {
+          "description": "The command to run the external tool.",
+          "type": "string",
+          "default": ""
+        },
+        "timeout": {
+          "type": "integer",
+          "format": "uint64",
+          "default": 5000,
+          "minimum": 0
+        }
+      }
+    },
     "EmmyrcFilenameConvention": {
       "oneOf": [
         {
@@ -802,6 +832,23 @@
         }
       }
     },
+    "EmmyrcReformat": {
+      "type": "object",
+      "properties": {
+        "externalTool": {
+          "description": "Whether to enable internal code reformatting.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/EmmyrcExternalTool"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
+        }
+      }
+    },
     "EmmyrcResource": {
       "type": "object",
       "properties": {

crates/emmylua_code_analysis/src/config/configs/mod.rs

@@ -8,6 +8,7 @@ mod hover;
 mod inlayhint;
 mod inline_values;
 mod references;
+mod reformat;
 mod resource;
 mod runtime;
 mod semantictoken;
@@ -25,6 +26,7 @@ pub use hover::EmmyrcHover;
 pub use inlayhint::EmmyrcInlayHint;
 pub use inline_values::EmmyrcInlineValues;
 pub use references::EmmyrcReference;
+pub use reformat::{EmmyrcExternalTool, EmmyrcReformat};
 pub use resource::EmmyrcResource;
 pub use runtime::{EmmyrcLuaVersion, EmmyrcRuntime};
 pub use semantictoken::EmmyrcSemanticToken;

crates/emmylua_code_analysis/src/config/configs/reformat.rs

@@ -0,0 +1,27 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct EmmyrcReformat {
+    /// Whether to enable internal code reformatting.
+    #[serde(default)]
+    pub external_tool: Option<EmmyrcExternalTool>,
+}
+
+#[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct EmmyrcExternalTool {
+    /// The command to run the external tool.
+    #[serde(default)]
+    pub program: String,
+    /// The arguments to pass to the external tool.
+    #[serde(default)]
+    pub args: Vec<String>,
+    #[serde(default = "default_timeout")]
+    pub timeout: u64,
+}
+
+fn default_timeout() -> u64 {
+    5000
+}

crates/emmylua_code_analysis/src/config/mod.rs

@@ -7,6 +7,7 @@ use std::{
     path::{Path, PathBuf},
 };
 
+pub use crate::config::configs::{EmmyrcExternalTool, EmmyrcReformat};
 pub use config_loader::{load_configs, load_configs_raw};
 use configs::{
     EmmyrcCodeAction, EmmyrcCodeLens, EmmyrcCompletion, EmmyrcDiagnostic, EmmyrcDoc,
@@ -59,6 +60,8 @@ pub struct Emmyrc {
     pub inline_values: EmmyrcInlineValues,
     #[serde(default)]
     pub doc: EmmyrcDoc,
+    #[serde(default)]
+    pub format: EmmyrcReformat,
 }
 
 impl Emmyrc {

crates/emmylua_ls/src/handlers/document_formatting/external_format.rs

@@ -0,0 +1,81 @@
+use emmylua_code_analysis::EmmyrcExternalTool;
+use std::process::Stdio;
+use std::time::Duration;
+use tokio::io::AsyncWriteExt;
+use tokio::process::Command;
+use tokio::time::timeout;
+
+pub async fn external_tool_format(
+    emmyrc_external_tool: &EmmyrcExternalTool,
+    text: &str,
+    file_path: &str,
+) -> Option<String> {
+    let exe_path = &emmyrc_external_tool.program;
+    let args = &emmyrc_external_tool.args;
+    let timeout_duration = Duration::from_millis(emmyrc_external_tool.timeout as u64);
+
+    let mut cmd = Command::new(exe_path);
+
+    for arg in args {
+        let processed_arg = arg.replace("${file}", file_path);
+        cmd.arg(processed_arg);
+    }
+
+    cmd.stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped());
+
+    let mut child = match cmd.spawn() {
+        Ok(child) => child,
+        Err(e) => {
+            log::error!("Failed to spawn external formatter process: {}", e);
+            return None;
+        }
+    };
+
+    if let Some(mut stdin) = child.stdin.take() {
+        if let Err(e) = stdin.write_all(text.as_bytes()).await {
+            log::error!("Failed to write to external formatter stdin: {}", e);
+            return None;
+        }
+        if let Err(e) = stdin.shutdown().await {
+            log::error!("Failed to close external formatter stdin: {}", e);
+            return None;
+        }
+    }
+
+    let output = match timeout(timeout_duration, child.wait_with_output()).await {
+        Ok(Ok(output)) => output,
+        Ok(Err(e)) => {
+            log::error!("External formatter process error: {}", e);
+            return None;
+        }
+        Err(_) => {
+            log::error!(
+                "External formatter process timed out after {}ms",
+                emmyrc_external_tool.timeout
+            );
+            return None;
+        }
+    };
+
+    if !output.status.success() {
+        log::error!(
+            "External formatter exited with non-zero status: {}. Stderr: {}",
+            output.status,
+            String::from_utf8_lossy(&output.stderr)
+        );
+        return None;
+    }
+
+    match String::from_utf8(output.stdout) {
+        Ok(formatted_text) => {
+            log::debug!("External formatter completed successfully");
+            Some(formatted_text)
+        }
+        Err(e) => {
+            log::error!("External formatter output is not valid UTF-8: {}", e);
+            None
+        }
+    }
+}

crates/emmylua_ls/src/handlers/document_formatting/mod.rs

@@ -1,10 +1,15 @@
+mod external_format;
+
 use emmylua_code_analysis::reformat_code;
 use lsp_types::{
     ClientCapabilities, DocumentFormattingParams, OneOf, ServerCapabilities, TextEdit,
 };
 use tokio_util::sync::CancellationToken;
 
-use crate::context::ServerContextSnapshot;
+use crate::{
+    context::ServerContextSnapshot,
+    handlers::document_formatting::external_format::external_tool_format,
+};
 
 use super::RegisterCapabilities;
 
@@ -15,8 +20,9 @@ pub async fn on_formatting_handler(
 ) -> Option<Vec<TextEdit>> {
     let uri = params.text_document.uri;
     let analysis = context.analysis.read().await;
-    let config_manager = context.workspace_manager.read().await;
-    let client_id = config_manager.client_config.client_id;
+    let workspace_manager = context.workspace_manager.read().await;
+    let client_id = workspace_manager.client_config.client_id;
+    let emmyrc = analysis.get_emmyrc();
 
     let file_id = analysis.get_file_id(&uri)?;
     let syntax_tree = analysis
@@ -37,7 +43,13 @@ pub async fn on_formatting_handler(
     let text = document.get_text();
     let file_path = document.get_file_path();
     let normalized_path = file_path.to_string_lossy().to_string().replace("\\", "/");
-    let mut formatted_text = reformat_code(text, &normalized_path);
+
+    let mut formatted_text = if let Some(external_config) = &emmyrc.format.external_tool {
+        external_tool_format(&external_config, text, &normalized_path).await?
+    } else {
+        reformat_code(text, &normalized_path)
+    };
+
     if client_id.is_intellij() || client_id.is_other() {
         formatted_text = formatted_text.replace("\r\n", "\n");
     }