feat(go): add support for gofmt (#47)

README.md

@@ -42,12 +42,14 @@ mdsf init
 
 > \[!NOTE\]
 > mdsf is not a tool for installing formatters.
-> Only formatters that are installed already will be used.
+>
+> Only formatters that are already installed will be used.
 
 | Language   | Formatters          |
 | ---------- | ------------------- |
 | CSS        | `prettier`          |
 | Elixir     | `mix_format`        |
+| Go         | `gofmt`             |
 | Gleam      | `gleam_format`      |
 | HTML       | `prettier`          |
 | JSON       | `prettier`, `biome` |

schemas/v0.0.0/mdsf.schema.json

@@ -36,6 +36,17 @@
         }
       ]
     },
+    "go": {
+      "default": {
+        "enabled": true,
+        "formatter": "gofmt"
+      },
+      "allOf": [
+        {
+          "$ref": "#/definitions/Go"
+        }
+      ]
+    },
     "html": {
       "default": {
         "enabled": true,
@@ -266,6 +277,27 @@
       "type": "string",
       "enum": ["gleam_format"]
     },
+    "Go": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "default": true,
+          "type": "boolean"
+        },
+        "formatter": {
+          "default": "gofmt",
+          "allOf": [
+            {
+              "$ref": "#/definitions/GoFormatter"
+            }
+          ]
+        }
+      }
+    },
+    "GoFormatter": {
+      "type": "string",
+      "enum": ["gofmt"]
+    },
     "Html": {
       "type": "object",
       "properties": {

src/config.rs

@@ -1,7 +1,7 @@
 use schemars::JsonSchema;
 
 use crate::languages::{
-    css::Css, elixir::Elixir, gleam::Gleam, html::Html, javascript::JavaScript, json::Json,
+    css::Css, elixir::Elixir, gleam::Gleam, go::Go, html::Html, javascript::JavaScript, json::Json,
     lua::Lua, markdown::Markdown, nim::Nim, python::Python, ruby::Ruby, rust::Rust, shell::Shell,
     toml::Toml, typescript::TypeScript, vue::Vue, yaml::Yaml, zig::Zig,
 };
@@ -18,6 +18,9 @@ pub struct MdsfConfig {
     #[serde(default)]
     pub elixir: Elixir,
 
+    #[serde(default)]
+    pub go: Go,
+
     #[serde(default)]
     pub gleam: Gleam,
 
@@ -74,6 +77,7 @@ impl Default for MdsfConfig {
             schema: default_schema_location(),
             css: Css::default(),
             elixir: Elixir::default(),
+            go: Go::default(),
             gleam: Gleam::default(),
             html: Html::default(),
             javascript: JavaScript::default(),

src/formatters/gofmt.rs

@@ -0,0 +1,48 @@
+use super::execute_command;
+
+#[inline]
+pub fn format_using_gofmt(
+    snippet_path: &std::path::Path,
+) -> std::io::Result<(bool, Option<String>)> {
+    let mut cmd = std::process::Command::new("gofmt");
+
+    cmd.arg("-w").arg(snippet_path);
+
+    execute_command(&mut cmd, snippet_path)
+}
+
+#[cfg(test)]
+mod test_gofmt {
+    use crate::{
+        formatters::{gofmt::format_using_gofmt, setup_snippet},
+        languages::Language,
+    };
+
+    #[test]
+    fn it_should_format_go() {
+        let input = "package main 
+
+   func add(a int , b int  ) int {
+                return a + b 
+       }
+
+    ";
+
+        let expected_output = "package main
+
+func add(a int, b int) int {
+\treturn a + b
+}
+";
+
+        let snippet =
+            setup_snippet(input, Language::Go.to_file_ext()).expect("it to create a snippet file");
+
+        let output = format_using_gofmt(snippet.path())
+            .expect("it to be successful")
+            .1
+            .expect("it to be some");
+
+        assert_eq!(expected_output, output);
+    }
+}

src/formatters/mix_format.rs

@@ -12,7 +12,7 @@ pub fn format_using_mix_format(
 }
 
 #[cfg(test)]
-mod test_gleam_format {
+mod test_mix_format {
     use crate::{
         formatters::{mix_format::format_using_mix_format, setup_snippet},
         languages::Language,

src/formatters/mod.rs

@@ -12,6 +12,7 @@ use crate::{
 
 pub mod biome;
 pub mod gleam_format;
+pub mod gofmt;
 pub mod mix_format;
 pub mod nimpretty;
 pub mod prettier;
@@ -86,6 +87,7 @@ pub fn format_snippet(config: &MdsfConfig, language: &Language, code: &str) -> S
         if let Ok(Some(formatted_code)) = match language {
             Language::Css => config.css.format(snippet_path),
             Language::Elixir => config.elixir.format(snippet_path),
+            Language::Go => config.go.format(snippet_path),
             Language::Gleam => config.gleam.format(snippet_path),
             Language::Html => config.html.format(snippet_path),
             Language::JavaScript => config.javascript.format(snippet_path),

src/formatters/rubocop.rs

@@ -16,7 +16,7 @@ pub fn format_using_rubocop(
 }
 
 #[cfg(test)]
-mod test_ruff {
+mod test_rubocop {
     use crate::{
         formatters::{rubocop::format_using_rubocop, setup_snippet},
         languages::Language,

src/languages/go.rs

@@ -0,0 +1,43 @@
+use schemars::JsonSchema;
+
+use crate::{config::default_enabled, formatters::gofmt::format_using_gofmt};
+
+use super::LanguageFormatter;
+
+#[derive(Debug, Default, serde::Serialize, serde::Deserialize, JsonSchema)]
+pub enum GoFormatter {
+    #[default]
+    #[serde(rename = "gofmt")]
+    GoFmt,
+}
+
+#[derive(Debug, serde::Serialize, serde::Deserialize, JsonSchema)]
+pub struct Go {
+    #[serde(default = "default_enabled")]
+    pub enabled: bool,
+    #[serde(default)]
+    pub formatter: GoFormatter,
+}
+
+impl Default for Go {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            formatter: GoFormatter::default(),
+        }
+    }
+}
+
+impl LanguageFormatter for Go {
+    #[inline]
+    fn format(&self, snippet_path: &std::path::Path) -> std::io::Result<Option<String>> {
+        if !self.enabled {
+            return Ok(None);
+        }
+
+        match self.formatter {
+            GoFormatter::GoFmt => format_using_gofmt(snippet_path).map(|res| res.1),
+        }
+    }
+}

src/languages/mod.rs

@@ -1,6 +1,7 @@
 pub enum Language {
     Css,
     Elixir,
+    Go,
     Gleam,
     Html,
     JavaScript,
@@ -17,7 +18,6 @@ pub enum Language {
     Vue,
     Yaml,
     Zig,
-    // TODO: Go,
     // TODO: Cpp,
     // TODO: C,
     // TODO: Haskell,
@@ -47,6 +47,7 @@ pub enum Language {
 pub mod css;
 pub mod elixir;
 pub mod gleam;
+pub mod go;
 pub mod html;
 pub mod javascript;
 pub mod json;
@@ -73,6 +74,7 @@ impl Language {
         match input {
             "css" | "scss" => Some(Self::Css),
             "elixir" => Some(Self::Elixir),
+            "go" | "golang" => Some(Self::Go),
             "gleam" => Some(Self::Gleam),
             "html" => Some(Self::Html),
             "javascript" | "js" | "jsx" => Some(Self::JavaScript),
@@ -99,6 +101,7 @@ impl Language {
             // NOTE: since scss is a superset of css we might as well support both at the same time
             Self::Css => ".scss",
             Self::Elixir => ".ex",
+            Self::Go => ".go",
             Self::Gleam => ".gleam",
             Self::Html => ".html",
             Self::JavaScript => ".js",

tests/go.md

@@ -0,0 +1,12 @@
+```go
+
+
+
+  package main
+
+   func add(a int , b int  ) int {
+                return a + b
+       }
+
+
+```