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, 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>,
+    pub formatter_type: FormatterType,
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Deserialize, Serialize)]
+pub enum FormatterType {
+    Stdio,
+    File,
+}
+
 #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
 #[serde(rename_all = "kebab-case")]
 pub struct AdvancedCompletion {

helix-term/src/commands/typed.rs

@@ -203,7 +203,7 @@ fn write_impl(
 ) -> anyhow::Result<()> {
     let auto_format = cx.editor.config().auto_format;
     let jobs = &mut cx.jobs;
-    let doc = doc_mut!(cx.editor);
+    let (view, doc) = current!(cx.editor);
 
     if let Some(ref path) = path {
         doc.set_path(Some(path.as_ref().as_ref()))
@@ -213,7 +213,7 @@ fn write_impl(
         bail!("cannot write a buffer without a filename");
     }
     let fmt = if auto_format {
-        doc.auto_format().map(|fmt| {
+        doc.auto_format(view.id).map(|fmt| {
             let shared = fmt.shared();
             let callback = make_format_callback(
                 doc.id(),
@@ -270,8 +270,8 @@ fn format(
     _args: &[Cow<str>],
     _event: PromptEvent,
 ) -> anyhow::Result<()> {
-    let doc = doc!(cx.editor);
-    if let Some(format) = doc.format() {
+    let (view, doc) = current!(cx.editor);
+    if let Some(format) = doc.format(view.id) {
         let callback =
             make_format_callback(doc.id(), doc.version(), Modified::LeaveModified, format);
         cx.jobs.callback(callback);
@@ -471,7 +471,11 @@ fn write_all_impl(
     let auto_format = cx.editor.config().auto_format;
     let jobs = &mut cx.jobs;
     // save all documents
-    for doc in &mut cx.editor.documents.values_mut() {
+    // Saves only visible buffers? How do we reload the not visible ones?
+    for (view, _) in cx.editor.tree.views() {
+        let id = view.doc;
+        let doc = cx.editor.documents.get_mut(&id).unwrap();
+
         if doc.path().is_none() {
             errors.push_str("cannot write a buffer without a filename\n");
             continue;
@@ -482,7 +486,7 @@ fn write_all_impl(
         }
 
         let fmt = if auto_format {
-            doc.auto_format().map(|fmt| {
+            doc.auto_format(view.id).map(|fmt| {
                 let shared = fmt.shared();
                 let callback = make_format_callback(
                     doc.id(),

helix-view/src/document.rs

@@ -1,5 +1,6 @@
 use anyhow::{anyhow, bail, Context, Error};
 use helix_core::auto_pairs::AutoPairs;
+use helix_core::syntax::FormatterType;
 use helix_core::Range;
 use serde::de::{self, Deserialize, Deserializer};
 use serde::Serialize;
@@ -397,17 +398,103 @@ 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(
+        &mut self,
+        view_id: ViewId,
+    ) -> Option<impl Future<Output = LspFormatting> + 'static> {
         if self.language_config()?.auto_format {
-            self.format()
+            self.format(view_id)
         } else {
             None
         }
     }
 
     /// 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> {
+    pub fn format(
+        &mut self,
+        view_id: ViewId,
+    ) -> Option<impl Future<Output = LspFormatting> + 'static> {
+        if let Some(language_config) = self.language_config() {
+            if let Some(formatter) = &language_config.formatter {
+                use std::process::{Command, Stdio};
+                match formatter.formatter_type {
+                    FormatterType::Stdio => {
+                        use std::io::Write;
+                        let mut process = match Command::new(&formatter.command)
+                            .args(&formatter.args)
+                            .stdin(Stdio::piped())
+                            .stdout(Stdio::piped())
+                            .stderr(Stdio::piped())
+                            .spawn()
+                        {
+                            Ok(process) => process,
+                            Err(e) => {
+                                log::error!("Failed to format with {}. {}", formatter.command, e);
+                                return None;
+                            }
+                        };
+
+                        {
+                            let mut stdin = process.stdin.take().unwrap();
+                            // let mut text = self.text().bytes().collect::<Vec<u8>>();
+                            // text.push(0);
+                            stdin
+                                .write_all(&self.text().bytes().collect::<Vec<u8>>())
+                                .unwrap();
+                        }
+
+                        let output = process.wait_with_output().ok()?;
+
+                        if !output.stderr.is_empty() {
+                            log::error!("Formatter {}", String::from_utf8_lossy(&output.stderr));
+                        }
+
+                        let str = std::str::from_utf8(&output.stdout)
+                            .map_err(|_| anyhow!("Process did not output valid UTF-8"))
+                            .ok()?;
+                        self.apply(
+                            &helix_core::diff::compare_ropes(self.text(), &Rope::from_str(str)),
+                            view_id,
+                        );
+                    }
+                    FormatterType::File => {
+                        if let Some(path) = self.path() {
+                            let process = match Command::new(&formatter.command)
+                                .args(&formatter.args)
+                                .arg(path.to_str().unwrap_or(""))
+                                .stderr(Stdio::piped())
+                                .spawn()
+                            {
+                                Ok(process) => process,
+                                Err(e) => {
+                                    log::error!(
+                                        "Failed to format with {}. {}",
+                                        formatter.command,
+                                        e
+                                    );
+                                    return None;
+                                }
+                            };
+
+                            let output = process.wait_with_output().ok()?;
+
+                            if !output.stderr.is_empty() {
+                                log::error!(
+                                    "Formatter {}",
+                                    String::from_utf8_lossy(&output.stderr)
+                                );
+                            } else if let Err(e) = self.reload(view_id) {
+                                log::error!("Error reloading after formatting {}", e);
+                            }
+                        } else {
+                            log::error!("Cannot format file without filepath");
+                        }
+                    }
+                }
+                return None;
+            }
+        }
         let language_server = self.language_server()?;
         let text = self.text.clone();
         let offset_encoding = language_server.offset_encoding();