feat(bazel): support buildifier (#251)

* feat(bazel): support buildifier

* fix: correct enum name

src/config.rs

@@ -4,9 +4,9 @@ use schemars::JsonSchema;
 use crate::{
     error::MdsfError,
     languages::{
-        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,
+        assembly::Assembly, bazel::Bazel, 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,
@@ -46,6 +46,9 @@ pub struct MdsfConfig {
     #[serde(default)]
     pub assembly: Lang<Assembly>,
 
+    #[serde(default)]
+    pub bazel: Lang<Bazel>,
+
     #[serde(default)]
     pub blade: Lang<Blade>,
 
@@ -236,6 +239,7 @@ impl Default for MdsfConfig {
             javascript_runtime: JavaScriptRuntime::default(),
 
             assembly: Lang::<Assembly>::default(),
+            bazel: Lang::<Bazel>::default(),
             blade: Lang::<Blade>::default(),
             c: Lang::<C>::default(),
             cabal: Lang::<Cabal>::default(),

src/formatters/buildifier.rs

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

src/formatters/mod.rs

@@ -17,6 +17,7 @@ pub mod black;
 pub mod blade_formatter;
 pub mod blue;
 pub mod buf;
+pub mod buildifier;
 pub mod cabal_format;
 pub mod clang_format;
 pub mod cljstyle;
@@ -189,6 +190,7 @@ pub fn format_snippet(config: &MdsfConfig, info: &LineInfo, code: &str) -> Strin
 
         if let Ok(Some(formatted_code)) = match info.language {
             Language::Assembly => config.assembly.format(snippet_path, info),
+            Language::Bazel => config.bazel.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/bazel.rs

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

src/languages/mod.rs

@@ -11,6 +11,7 @@ use crate::{
 };
 
 pub mod assembly;
+pub mod bazel;
 pub mod blade;
 pub mod c;
 pub mod cabal;
@@ -163,6 +164,7 @@ impl core::fmt::Display for TypeScriptFlavor {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum Language {
     Assembly,
+    Bazel,
     Blade,
     C,
     CSharp,
@@ -230,6 +232,7 @@ impl core::fmt::Display for Language {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::Assembly => f.write_str("assembly"),
+            Self::Bazel => f.write_str("bazel"),
             Self::Blade => f.write_str("blade"),
             Self::C => f.write_str("c"),
             Self::CSharp => f.write_str("c#"),
@@ -306,6 +309,7 @@ impl Language {
     pub fn maybe_from_str(input: &str) -> Option<Self> {
         match input.to_ascii_lowercase().as_str() {
             "assembly" | "asm" => Some(Self::Assembly),
+            "bazel" => Some(Self::Bazel),
             "bash" => Some(Self::Shell(ShellFlavor::Bash)),
             "blade" => Some(Self::Blade),
             "c" | "clang" => Some(Self::C),
@@ -385,6 +389,7 @@ impl Language {
     pub const fn to_file_ext(&self) -> &'static str {
         match self {
             Self::Assembly => ".s",
+            Self::Bazel => ".bzl",
             Self::Blade => ".blade.php",
             Self::C => ".c",
             Self::CSharp => ".cs",