Change default formatter for any language

helix-core/src/syntax.rs

@@ -79,6 +79,9 @@ pub struct LanguageConfiguration {
     #[serde(default)]
     pub auto_format: bool,
 
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub formatter: Option<FormatterConfiguration>,
+
     #[serde(default)]
     pub diagnostic_severity: Severity,
 
@@ -126,6 +129,22 @@ pub struct LanguageServerConfiguration {
     pub language_id: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub struct FormatterConfiguration {
+    pub command: String,
+    #[serde(default)]
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub args: Vec<String>,
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Deserialize, Serialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum FormatterType {
+    Stdio,
+    File,
+}
+
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct AdvancedCompletion {

helix-lsp/src/lib.rs

@@ -205,22 +205,6 @@ pub mod util {
             }),
         )
     }
-
-    /// The result of asking the language server to format the document. This can be turned into a
-    /// `Transaction`, but the advantage of not doing that straight away is that this one is
-    /// `Send` and `Sync`.
-    #[derive(Clone, Debug)]
-    pub struct LspFormatting {
-        pub doc: Rope,
-        pub edits: Vec<lsp::TextEdit>,
-        pub offset_encoding: OffsetEncoding,
-    }
-
-    impl From<LspFormatting> for Transaction {
-        fn from(fmt: LspFormatting) -> Transaction {
-            generate_transaction_from_edits(&fmt.doc, fmt.edits, fmt.offset_encoding)
-        }
-    }
 }
 
 #[derive(Debug, PartialEq, Clone)]

helix-term/src/commands.rs

@@ -28,7 +28,7 @@ use helix_core::{
 };
 use helix_view::{
     clipboard::ClipboardType,
-    document::{Mode, SCRATCH_BUFFER_NAME},
+    document::{FormatterError, Mode, SCRATCH_BUFFER_NAME},
     editor::{Action, Motion},
     info::Info,
     input::KeyEvent,
@@ -2372,14 +2372,14 @@ async fn make_format_callback(
     doc_id: DocumentId,
     doc_version: i32,
     modified: Modified,
-    format: impl Future<Output = helix_lsp::util::LspFormatting> + Send + 'static,
+    format: impl Future<Output = Result<Transaction, FormatterError>> + Send + 'static,
 ) -> anyhow::Result<job::Callback> {
-    let format = format.await;
+    let format = format.await?;
     let call: job::Callback = Box::new(move |editor, _compositor| {
         let view_id = view!(editor).id;
         if let Some(doc) = editor.document_mut(doc_id) {
             if doc.version() == doc_version {
-                doc.apply(&Transaction::from(format), view_id);
+                doc.apply(&format, view_id);
                 doc.append_changes_to_history(view_id);
                 doc.detect_indent_and_line_ending();
                 if let Modified::SetUnmodified = modified {

helix-term/src/commands/typed.rs

@@ -551,6 +551,7 @@ fn write_all_impl(
     let auto_format = cx.editor.config().auto_format;
     let jobs = &mut cx.jobs;
     // save all documents
+    // Saves only visible buffers? How do we reload the not visible ones?
     for doc in &mut cx.editor.documents.values_mut() {
         if doc.path().is_none() {
             errors.push_str("cannot write a buffer without a filename\n");

helix-view/src/document.rs

@@ -1,4 +1,6 @@
 use anyhow::{anyhow, bail, Context, Error};
+use futures_util::future::BoxFuture;
+use futures_util::FutureExt;
 use helix_core::auto_pairs::AutoPairs;
 use helix_core::Range;
 use serde::de::{self, Deserialize, Deserializer};
@@ -10,6 +12,7 @@ use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use std::sync::Arc;
+use tokio::io::AsyncWriteExt;
 
 use helix_core::{
     encoding,
@@ -20,7 +23,6 @@ use helix_core::{
     ChangeSet, Diagnostic, LineEnding, Rope, RopeBuilder, Selection, State, Syntax, Transaction,
     DEFAULT_LINE_ENDING,
 };
-use helix_lsp::util::LspFormatting;
 
 use crate::{DocumentId, Editor, ViewId};
 
@@ -397,7 +399,7 @@ impl Document {
 
     /// The same as [`format`], but only returns formatting changes if auto-formatting
     /// is configured.
-    pub fn auto_format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {
+    pub fn auto_format(&self) -> Option<BoxFuture<'static, Result<Transaction, FormatterError>>> {
         if self.language_config()?.auto_format {
             self.format()
         } else {
@@ -407,7 +409,53 @@ impl Document {
 
     /// If supported, returns the changes that should be applied to this document in order
     /// to format it nicely.
-    pub fn format(&self) -> Option<impl Future<Output = LspFormatting> + 'static> {
+    // We can't use anyhow::Result here since the output of the future has to be
+    // clonable to be used as shared future. So use a custom error type.
+    pub fn format(&self) -> Option<BoxFuture<'static, Result<Transaction, FormatterError>>> {
+        if let Some(formatter) = self.language_config().and_then(|c| c.formatter.clone()) {
+            use std::process::Stdio;
+            let text = self.text().clone();
+            let mut process = tokio::process::Command::new(&formatter.command);
+            process
+                .args(&formatter.args)
+                .stdin(Stdio::piped())
+                .stdout(Stdio::piped())
+                .stderr(Stdio::piped());
+
+            let formatting_future = async move {
+                let mut process = process
+                    .spawn()
+                    .map_err(|e| FormatterError::SpawningFailed {
+                        command: formatter.command.clone(),
+                        error: e.kind(),
+                    })?;
+                {
+                    let mut stdin = process.stdin.take().ok_or(FormatterError::BrokenStdin)?;
+                    stdin
+                        .write_all(&text.bytes().collect::<Vec<u8>>())
+                        .await
+                        .map_err(|_| FormatterError::BrokenStdin)?;
+                }
+
+                let output = process
+                    .wait_with_output()
+                    .await
+                    .map_err(|_| FormatterError::WaitForOutputFailed)?;
+
+                if !output.stderr.is_empty() {
+                    return Err(FormatterError::Stderr(
+                        String::from_utf8_lossy(&output.stderr).to_string(),
+                    ));
+                }
+
+                let str = String::from_utf8(output.stdout)
+                    .map_err(|_| FormatterError::InvalidUtf8Output)?;
+
+                Ok(helix_core::diff::compare_ropes(&text, &Rope::from(str)))
+            };
+            return Some(formatting_future.boxed());
+        };
+
         let language_server = self.language_server()?;
         let text = self.text.clone();
         let offset_encoding = language_server.offset_encoding();
@@ -427,13 +475,13 @@ impl Document {
                 log::warn!("LSP formatting failed: {}", e);
                 Default::default()
             });
-            LspFormatting {
-                doc: text,
+            Ok(helix_lsp::util::generate_transaction_from_edits(
+                &text,
                 edits,
                 offset_encoding,
-            }
+            ))
         };
-        Some(fut)
+        Some(fut.boxed())
     }
 
     pub fn save(&mut self, force: bool) -> impl Future<Output = Result<(), anyhow::Error>> {
@@ -442,7 +490,7 @@ impl Document {
 
     pub fn format_and_save(
         &mut self,
-        formatting: Option<impl Future<Output = LspFormatting>>,
+        formatting: Option<impl Future<Output = Result<Transaction, FormatterError>>>,
         force: bool,
     ) -> impl Future<Output = anyhow::Result<()>> {
         self.save_impl(formatting, force)
@@ -454,7 +502,7 @@ impl Document {
     /// at its `path()`.
     ///
     /// If `formatting` is present, it supplies some changes that we apply to the text before saving.
-    fn save_impl<F: Future<Output = LspFormatting>>(
+    fn save_impl<F: Future<Output = Result<Transaction, FormatterError>>>(
         &mut self,
         formatting: Option<F>,
         force: bool,
@@ -488,7 +536,8 @@ impl Document {
             }
 
             if let Some(fmt) = formatting {
-                let success = Transaction::from(fmt.await).changes().apply(&mut text);
+                let transaction = fmt.await?;
+                let success = transaction.changes().apply(&mut text);
                 if !success {
                     // This shouldn't happen, because the transaction changes were generated
                     // from the same text we're saving.
@@ -1034,6 +1083,37 @@ impl Default for Document {
     }
 }
 
+#[derive(Clone, Debug)]
+pub enum FormatterError {
+    SpawningFailed {
+        command: String,
+        error: std::io::ErrorKind,
+    },
+    BrokenStdin,
+    WaitForOutputFailed,
+    Stderr(String),
+    InvalidUtf8Output,
+    DiskReloadError(String),
+}
+
+impl std::error::Error for FormatterError {}
+
+impl Display for FormatterError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            Self::SpawningFailed { command, error } => {
+                format!("Failed to spawn formatter {}: {:?}", command, error)
+            }
+            Self::BrokenStdin => "Could not write to formatter stdin".to_string(),
+            Self::WaitForOutputFailed => "Waiting for formatter output failed".to_string(),
+            Self::Stderr(output) => format!("Formatter error: {}", output),
+            Self::InvalidUtf8Output => "Invalid UTF-8 formatter output".to_string(),
+            Self::DiskReloadError(error) => format!("Error reloading file from disk: {}", error),
+        };
+        f.write_str(&s)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

helix-view/src/editor.rs

@@ -531,7 +531,6 @@ impl Editor {
         syn_loader: Arc<syntax::Loader>,
         config: Box<dyn DynAccess<Config>>,
     ) -> Self {
-        let language_servers = helix_lsp::Registry::new();
         let conf = config.load();
         let auto_pairs = (&conf.auto_pairs).into();
 
@@ -547,7 +546,7 @@ impl Editor {
             macro_recording: None,
             macro_replaying: Vec::new(),
             theme: theme_loader.default(),
-            language_servers,
+            language_servers: helix_lsp::Registry::new(),
             diagnostics: BTreeMap::new(),
             debugger: None,
             debugger_events: SelectAll::new(),

languages.toml

@@ -679,6 +679,8 @@ auto-format = true
 comment-token = "//"
 language-server = { command = "zls" }
 indent = { tab-width = 4, unit = "    " }
+formatter = { command = "zig" , args = ["fmt", "--stdin"] }
+
 
 [[grammar]]
 name = "zig"