feat(assembly): support asmfmt (#250)

README.md

@@ -62,6 +62,7 @@ mdsf init
 
 | Language         | Formatters                                                                                           |
 | ---------------- | ---------------------------------------------------------------------------------------------------- |
+| Assembly         | `asmfmt`                                                                                             |
 | Blade            | `blade-formatter`                                                                                    |
 | C                | `clang-format`                                                                                       |
 | CSharp           | `clang-format`, `csharpier`                                                                          |

mdsf.json

@@ -2,6 +2,10 @@
   "$schema": "https://raw.githubusercontent.com/hougesen/mdsf/main/schemas/v0.0.7/mdsf.schema.json",
   "format_finished_document": false,
   "javascript_runtime": "node",
+  "assembly": {
+    "enabled": true,
+    "formatter": "asmfmt"
+  },
   "blade": {
     "enabled": true,
     "formatter": "blade-formatter"

schemas/v0.0.7/mdsf.schema.json

@@ -7,6 +7,17 @@
       "default": "https://raw.githubusercontent.com/hougesen/mdsf/main/schemas/v0.0.7/mdsf.schema.json",
       "type": "string"
     },
+    "assembly": {
+      "default": {
+        "enabled": true,
+        "formatter": "asmfmt"
+      },
+      "allOf": [
+        {
+          "$ref": "#/definitions/Lang_for_Assembly"
+        }
+      ]
+    },
     "blade": {
       "default": {
         "enabled": true,
@@ -692,6 +703,10 @@
   },
   "additionalProperties": false,
   "definitions": {
+    "Assembly": {
+      "type": "string",
+      "enum": ["asmfmt"]
+    },
     "Blade": {
       "type": "string",
       "enum": ["blade-formatter"]
@@ -828,6 +843,19 @@
       "type": "string",
       "enum": ["ktlint", "ktfmt"]
     },
+    "Lang_for_Assembly": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "default": true,
+          "type": "boolean"
+        },
+        "formatter": {
+          "$ref": "#/definitions/MdsfFormatter_for_Assembly"
+        }
+      },
+      "additionalProperties": false
+    },
     "Lang_for_Blade": {
       "type": "object",
       "properties": {
@@ -1623,6 +1651,19 @@
         "misspell"
       ]
     },
+    "MdsfFormatter_for_Assembly": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/Assembly"
+        },
+        {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/MdsfFormatter_for_Assembly"
+          }
+        }
+      ]
+    },
     "MdsfFormatter_for_Blade": {
       "anyOf": [
         {

src/config.rs

@@ -4,16 +4,16 @@ use schemars::JsonSchema;
 use crate::{
     error::MdsfError,
     languages::{
-        blade::Blade, c::C, cabal::Cabal, clojure::Clojure, cpp::Cpp, crystal::Crystal,
-        csharp::CSharp, css::Css, d::D, dart::Dart, elixir::Elixir, elm::Elm, erb::Erb,
-        erlang::Erlang, fortran::Fortran, fsharp::FSharp, gleam::Gleam, go::Go, graphql::GraphQL,
-        groovy::Groovy, handlebars::Handlebars, haskell::Haskell, hcl::Hcl, html::Html, java::Java,
-        javascript::JavaScript, json::Json, julia::Julia, just::Just, kcl::Kcl, kotlin::Kotlin,
-        lua::Lua, markdown::Markdown, mustache::Mustache, nim::Nim, nix::Nix, nunjucks::Nunjucks,
-        objective_c::ObjectiveC, ocaml::OCaml, perl::Perl, protobuf::Protobuf, puppet::Puppet,
-        purescript::PureScript, python::Python, rescript::ReScript,
-        restructuredtext::ReStructuredText, roc::Roc, ruby::Ruby, rust::Rust, scala::Scala,
-        shell::Shell, solidity::Solidity, sql::Sql, swift::Swift, toml::Toml,
+        assembly::Assembly, blade::Blade, c::C, cabal::Cabal, clojure::Clojure, cpp::Cpp,
+        crystal::Crystal, csharp::CSharp, css::Css, d::D, dart::Dart, elixir::Elixir, elm::Elm,
+        erb::Erb, erlang::Erlang, fortran::Fortran, fsharp::FSharp, gleam::Gleam, go::Go,
+        graphql::GraphQL, groovy::Groovy, handlebars::Handlebars, haskell::Haskell, hcl::Hcl,
+        html::Html, java::Java, javascript::JavaScript, json::Json, julia::Julia, just::Just,
+        kcl::Kcl, kotlin::Kotlin, lua::Lua, markdown::Markdown, mustache::Mustache, nim::Nim,
+        nix::Nix, nunjucks::Nunjucks, objective_c::ObjectiveC, ocaml::OCaml, perl::Perl,
+        protobuf::Protobuf, puppet::Puppet, purescript::PureScript, python::Python,
+        rescript::ReScript, restructuredtext::ReStructuredText, roc::Roc, ruby::Ruby, rust::Rust,
+        scala::Scala, shell::Shell, solidity::Solidity, sql::Sql, swift::Swift, toml::Toml,
         typescript::TypeScript, vue::Vue, xml::Xml, yaml::Yaml, zig::Zig, Lang,
     },
     runners::JavaScriptRuntime,
@@ -43,6 +43,9 @@ pub struct MdsfConfig {
     #[serde(default)]
     pub javascript_runtime: JavaScriptRuntime,
 
+    #[serde(default)]
+    pub assembly: Lang<Assembly>,
+
     #[serde(default)]
     pub blade: Lang<Blade>,
 
@@ -232,6 +235,8 @@ impl Default for MdsfConfig {
             format_finished_document: false,
             javascript_runtime: JavaScriptRuntime::default(),
 
+            assembly: Lang::<Assembly>::default(),
+            blade: Lang::<Blade>::default(),
             c: Lang::<C>::default(),
             cabal: Lang::<Cabal>::default(),
             clojure: Lang::<Clojure>::default(),
@@ -291,7 +296,6 @@ impl Default for MdsfConfig {
             xml: Lang::<Xml>::default(),
             yaml: Lang::<Yaml>::default(),
             zig: Lang::<Zig>::default(),
-            blade: Lang::<Blade>::default(),
         }
     }
 }

src/formatters/asmfmt.rs

@@ -0,0 +1,13 @@
+use super::execute_command;
+use crate::error::MdsfError;
+
+#[inline]
+pub fn format_using_asmfmt(
+    file_path: &std::path::Path,
+) -> Result<(bool, Option<String>), MdsfError> {
+    let mut cmd = std::process::Command::new("asmfmt");
+
+    cmd.arg("-w").arg(file_path);
+
+    execute_command(&mut cmd, file_path)
+}

src/formatters/mod.rs

@@ -7,6 +7,7 @@ use which::which;
 use crate::{config::MdsfConfig, error::MdsfError, languages::Language, LineInfo, DEBUG};
 
 pub mod alejandra;
+pub mod asmfmt;
 pub mod auto_optional;
 pub mod autocorrect;
 pub mod autopep8;
@@ -187,6 +188,7 @@ pub fn format_snippet(config: &MdsfConfig, info: &LineInfo, code: &str) -> Strin
         let snippet_path = snippet.path();
 
         if let Ok(Some(formatted_code)) = match info.language {
+            Language::Assembly => config.assembly.format(snippet_path, info),
             Language::Blade => config.blade.format(snippet_path, info),
             Language::C => config.c.format(snippet_path, info),
             Language::CSharp => config.csharp.format(snippet_path, info),

src/languages/assembly.rs

@@ -0,0 +1,64 @@
+use schemars::JsonSchema;
+
+use super::{Lang, LanguageFormatter};
+use crate::{
+    error::MdsfError,
+    formatters::{asmfmt::format_using_asmfmt, MdsfFormatter},
+};
+
+#[derive(Default, serde::Serialize, serde::Deserialize, JsonSchema)]
+#[cfg_attr(test, derive(Debug, PartialEq, Eq))]
+pub enum Assembly {
+    #[default]
+    #[serde(rename = "asmfmt")]
+    Asmfmt,
+}
+
+impl Default for Lang<Assembly> {
+    #[inline]
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            formatter: MdsfFormatter::<Assembly>::default(),
+        }
+    }
+}
+
+impl Default for MdsfFormatter<Assembly> {
+    #[inline]
+    fn default() -> Self {
+        Self::Single(Assembly::Asmfmt)
+    }
+}
+
+impl LanguageFormatter for Assembly {
+    #[inline]
+    fn format_snippet(
+        &self,
+        snippet_path: &std::path::Path,
+    ) -> Result<(bool, Option<String>), MdsfError> {
+        match self {
+            Self::Asmfmt => format_using_asmfmt(snippet_path),
+        }
+    }
+}
+
+impl core::fmt::Display for Assembly {
+    #[inline]
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Asmfmt => write!(f, "asmfmt"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test_assembly {
+    use super::Assembly;
+    use crate::languages::Lang;
+
+    #[test]
+    fn it_should_be_enabled_by_default() {
+        assert!(Lang::<Assembly>::default().enabled);
+    }
+}

src/languages/mod.rs

@@ -10,6 +10,7 @@ use crate::{
     LineInfo,
 };
 
+pub mod assembly;
 pub mod blade;
 pub mod c;
 pub mod cabal;
@@ -161,6 +162,7 @@ impl core::fmt::Display for TypeScriptFlavor {
 
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Language {
+    Assembly,
     Blade,
     C,
     CSharp,
@@ -227,6 +229,7 @@ impl core::fmt::Display for Language {
     #[inline]
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
+            Self::Assembly => f.write_str("assembly"),
             Self::Blade => f.write_str("blade"),
             Self::C => f.write_str("c"),
             Self::CSharp => f.write_str("c#"),
@@ -302,6 +305,7 @@ impl Language {
     #[inline]
     pub fn maybe_from_str(input: &str) -> Option<Self> {
         match input.to_ascii_lowercase().as_str() {
+            "assembly" | "asm" => Some(Self::Assembly),
             "bash" => Some(Self::Shell(ShellFlavor::Bash)),
             "blade" => Some(Self::Blade),
             "c" | "clang" => Some(Self::C),
@@ -380,6 +384,7 @@ impl Language {
     #[inline]
     pub const fn to_file_ext(&self) -> &'static str {
         match self {
+            Self::Assembly => ".s",
             Self::Blade => ".blade.php",
             Self::C => ".c",
             Self::CSharp => ".cs",