support external tool range format

Author: CppCXY

crates/emmylua_code_analysis/resources/schema.json

@@ -64,6 +64,7 @@
       "$ref": "#/$defs/EmmyrcReformat",
       "default": {
         "externalTool": null,
+        "externalToolRangeFormat": null,
         "useDiff": false
       }
     },
@@ -678,6 +679,7 @@
           "default": ""
         },
         "timeout": {
+          "description": "The timeout for the external tool in milliseconds.",
           "type": "integer",
           "format": "uint64",
           "default": 5000,
@@ -873,7 +875,19 @@
       "type": "object",
       "properties": {
         "externalTool": {
-          "description": "Whether to enable internal code reformatting.",
+          "description": "Whether to enable external tool formatting.",
+          "anyOf": [
+            {
+              "$ref": "#/$defs/EmmyrcExternalTool"
+            },
+            {
+              "type": "null"
+            }
+          ],
+          "default": null
+        },
+        "externalToolRangeFormat": {
+          "description": "Whether to enable external tool range formatting.",
           "anyOf": [
             {
               "$ref": "#/$defs/EmmyrcExternalTool"

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

@@ -4,10 +4,14 @@ use serde::{Deserialize, Serialize};
 #[derive(Serialize, Deserialize, Debug, JsonSchema, Clone, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct EmmyrcReformat {
-    /// Whether to enable internal code reformatting.
+    /// Whether to enable external tool formatting.
     #[serde(default)]
     pub external_tool: Option<EmmyrcExternalTool>,
 
+    /// Whether to enable external tool range formatting.
+    #[serde(default)]
+    pub external_tool_range_format: Option<EmmyrcExternalTool>,
+
     /// Whether to use the diff algorithm for formatting.
     #[serde(default = "default_false")]
     pub use_diff: bool,
@@ -22,6 +26,7 @@ pub struct EmmyrcExternalTool {
     /// The arguments to pass to the external tool.
     #[serde(default)]
     pub args: Vec<String>,
+    /// The timeout for the external tool in milliseconds.
     #[serde(default = "default_timeout")]
     pub timeout: u64,
 }

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

@@ -1,14 +1,23 @@
 use emmylua_code_analysis::{EmmyrcExternalTool, FormattingOptions};
+use rowan::TextSize;
 use std::process::Stdio;
 use std::time::Duration;
 use tokio::io::AsyncWriteExt;
 use tokio::process::Command;
 use tokio::time::timeout;
 
+pub struct FormattingRange {
+    pub start_offset: TextSize,
+    pub end_offset: TextSize,
+    pub start_line: u32,
+    pub end_line: u32,
+}
+
 pub async fn external_tool_format(
     emmyrc_external_tool: &EmmyrcExternalTool,
     text: &str,
     file_path: &str,
+    range: Option<FormattingRange>,
     options: FormattingOptions,
 ) -> Option<String> {
     let exe_path = &emmyrc_external_tool.program;
@@ -18,7 +27,7 @@ pub async fn external_tool_format(
     let mut cmd = Command::new(exe_path);
 
     for arg in args {
-        if let Some(processed_arg) = parse_macro_arg(arg, file_path, &options) {
+        if let Some(processed_arg) = parse_macro_arg(arg, file_path, &range, &options) {
             cmd.arg(processed_arg);
         }
     }
@@ -82,7 +91,12 @@ pub async fn external_tool_format(
     }
 }
 
-fn parse_macro_arg(arg: &str, file_path: &str, options: &FormattingOptions) -> Option<String> {
+fn parse_macro_arg(
+    arg: &str,
+    file_path: &str,
+    range: &Option<FormattingRange>,
+    options: &FormattingOptions,
+) -> Option<String> {
     let mut result = String::new();
     let mut chars = arg.chars().peekable();
 
@@ -160,6 +174,34 @@ fn parse_macro_arg(arg: &str, file_path: &str, options: &FormattingOptions) -> O
                 match content.trim() {
                     "file" => file_path.to_string(),
                     "indent_size" => options.indent_size.to_string(),
+                    "start_offset" => {
+                        if let Some(r) = range {
+                            u32::from(r.start_offset).to_string()
+                        } else {
+                            "".to_string()
+                        }
+                    }
+                    "end_offset" => {
+                        if let Some(r) = range {
+                            u32::from(r.end_offset).to_string()
+                        } else {
+                            "".to_string()
+                        }
+                    }
+                    "start_line" => {
+                        if let Some(r) = range {
+                            r.start_line.to_string()
+                        } else {
+                            "".to_string()
+                        }
+                    }
+                    "end_line" => {
+                        if let Some(r) = range {
+                            r.end_line.to_string()
+                        } else {
+                            "".to_string()
+                        }
+                    }
                     _ => "".to_string(),
                 }
             };

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

@@ -8,11 +8,9 @@ use lsp_types::{
 use tokio_util::sync::CancellationToken;
 
 use crate::{
-    context::ServerContextSnapshot,
-    handlers::document_formatting::{
-        external_format::external_tool_format, format_diff::format_diff,
-    },
+    context::ServerContextSnapshot, handlers::document_formatting::format_diff::format_diff,
 };
+pub use external_format::{FormattingRange, external_tool_format};
 
 use super::RegisterCapabilities;
 
@@ -54,7 +52,14 @@ pub async fn on_formatting_handler(
     };
 
     let mut formatted_text = if let Some(external_config) = &emmyrc.format.external_tool {
-        external_tool_format(&external_config, text, &normalized_path, formatting_options).await?
+        external_tool_format(
+            &external_config,
+            text,
+            &normalized_path,
+            None,
+            formatting_options,
+        )
+        .await?
     } else {
         reformat_code(text, &normalized_path, formatting_options)
     };

crates/emmylua_ls/src/handlers/document_range_formatting/external_range_format.rs

@@ -0,0 +1,42 @@
+use crate::handlers::document_formatting::{FormattingRange, external_tool_format};
+use emmylua_code_analysis::{
+    EmmyrcExternalTool, FormattingOptions, LuaDocument, RangeFormatResult,
+};
+
+pub async fn external_tool_range_format<'a>(
+    emmyrc_external_tool: &EmmyrcExternalTool,
+    document: &'a LuaDocument<'_>,
+    range: &lsp_types::Range,
+    file_path: &str,
+    options: FormattingOptions,
+) -> Option<RangeFormatResult> {
+    let start_offset =
+        document.get_offset(range.start.line as usize, range.start.character as usize)?;
+    let end_offset = document.get_offset(range.end.line as usize, range.end.character as usize)?;
+
+    let formatting_range = FormattingRange {
+        start_offset,
+        end_offset,
+        start_line: range.start.line,
+        end_line: range.end.line,
+    };
+
+    let text = document.get_text();
+    let document_range = document.get_document_lsp_range();
+    let formatted_text = external_tool_format(
+        emmyrc_external_tool,
+        &text,
+        file_path,
+        Some(formatting_range),
+        options,
+    )
+    .await?;
+
+    Some(RangeFormatResult {
+        text: formatted_text,
+        start_line: document_range.start.line as i32,
+        start_col: document_range.start.character as i32,
+        end_line: document_range.end.line as i32,
+        end_col: document_range.end.character as i32,
+    })
+}

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

@@ -1,11 +1,16 @@
+mod external_range_format;
+
 use emmylua_code_analysis::{FormattingOptions, range_format_code};
 use lsp_types::{
     ClientCapabilities, DocumentRangeFormattingParams, OneOf, Position, Range, ServerCapabilities,
     TextEdit,
 };
 use tokio_util::sync::CancellationToken;
 
-use crate::context::ServerContextSnapshot;
+use crate::{
+    context::ServerContextSnapshot,
+    handlers::document_range_formatting::external_range_format::external_tool_range_format,
+};
 
 use super::RegisterCapabilities;
 
@@ -44,18 +49,28 @@ pub async fn on_range_formatting_handler(
         insert_final_newline: params.options.insert_final_newline.unwrap_or(true),
         non_standard_symbol: !emmyrc.runtime.nonstandard_symbol.is_empty(),
     };
-    let formatted_result = range_format_code(
-        text,
-        &normalized_path,
-        request_range.start.line as i32,
-        0,
-        request_range.end.line as i32 + 1,
-        0,
-        formatting_options,
-    )?;
+    let formatted_result = if let Some(external_tool) = &emmyrc.format.external_tool_range_format {
+        external_tool_range_format(
+            external_tool,
+            &document,
+            &request_range,
+            &normalized_path,
+            formatting_options,
+        )
+        .await?
+    } else {
+        range_format_code(
+            text,
+            &normalized_path,
+            request_range.start.line as i32,
+            0,
+            request_range.end.line as i32 + 1,
+            0,
+            formatting_options,
+        )?
+    };
 
     let mut formatted_text = formatted_result.text;
-
     if client_id.is_intellij() || client_id.is_other() {
         formatted_text = formatted_text.replace("\r\n", "\n");
     }