feat: implement grit format command

crates/cli/Cargo.toml

@@ -20,8 +20,9 @@ anyhow = { version = "1.0.70" }
 clap = { version = "4.1.13", features = ["derive"] }
 indicatif = { version = "0.17.5" }
 # Do *NOT* upgrade beyond 1.0.171 until https://github.com/serde-rs/serde/issues/2538 is fixed
-serde = { version = "1.0.164", features = ["derive"] }
+serde = { version = "1.0.217", features = ["derive"] }
 serde_json = { version = "1.0.96" }
+serde_yaml = { version = "0.9.25" }
 uuid = { version = "1.1", features = ["v4", "serde"] }
 tokio = { version = "1", features = ["full"] }
 chrono = { version = "0.4.26", features = ["serde"] }
@@ -88,6 +89,8 @@ tracing-subscriber = { version = "0.3", default-features = false, optional = tru
 tracing-log = { version = "0.2.0", optional = true }
 
 fs-err = { version = "2.11.0" }
+biome_grit_parser = { git = "https://github.com/biomejs/biome" }
+biome_grit_formatter = { git = "https://github.com/biomejs/biome" }
 
 [target.'cfg(not(windows))'.dependencies]
 openssl = { version = "0.10", features = ["vendored"] }

crates/cli/src/commands/format.rs

@@ -0,0 +1,176 @@
+use crate::{
+    resolver::{resolve_from_cwd, Source},
+    ux::format_diff,
+};
+use anyhow::{anyhow, ensure, Context, Result};
+use biome_grit_formatter::context::GritFormatOptions;
+use clap::Args;
+use colored::Colorize;
+use marzano_gritmodule::{config::ResolvedGritDefinition, parser::PatternFileExt};
+use serde::Serialize;
+
+#[derive(Args, Debug, Serialize, Clone)]
+pub struct FormatArgs {
+    /// Write formats to file instead of just showing them
+    #[clap(long)]
+    pub write: bool,
+}
+
+pub async fn run_format(arg: &FormatArgs) -> Result<()> {
+    let (mut resolved, _) = resolve_from_cwd(&Source::Local).await?;
+    // sort to have consistent output for tests
+    resolved.sort();
+
+    let file_path_to_resolved = group_resolved_patterns_by_group(resolved);
+    for (file_path, resovled_patterns) in file_path_to_resolved {
+        if let Err(error) =
+            format_file_resovled_patterns(file_path.clone(), resovled_patterns, arg.clone()).await
+        {
+            eprintln!("couldn't format '{}': {error:?}", file_path)
+        }
+    }
+    Ok(())
+}
+
+fn group_resolved_patterns_by_group(
+    resolved: Vec<ResolvedGritDefinition>,
+) -> Vec<(String, Vec<ResolvedGritDefinition>)> {
+    resolved.into_iter().fold(Vec::new(), |mut acc, resolved| {
+        let file_path = &resolved.config.path;
+        if let Some((_, resolved_patterns)) = acc
+            .iter_mut()
+            .find(|(resolv_file_path, _)| resolv_file_path == file_path)
+        {
+            resolved_patterns.push(resolved);
+        } else {
+            acc.push((file_path.clone(), vec![resolved]));
+        }
+        acc
+    })
+}
+
+async fn format_file_resovled_patterns(
+    file_path: String,
+    patterns: Vec<ResolvedGritDefinition>,
+    arg: FormatArgs,
+) -> Result<()> {
+    // patterns has atleast one resolve so unwrap is safe
+    let first_pattern = patterns.first().unwrap();
+    // currently all patterns has raw data so unwrap is safe
+    let first_pattern_raw_data = first_pattern.config.raw.as_ref().unwrap();
+    let old_file_content = &first_pattern_raw_data.content;
+
+    let new_file_content = match first_pattern_raw_data.format {
+        PatternFileExt::Yaml => format_yaml_file(old_file_content)?,
+        PatternFileExt::Grit => format_grit_code(old_file_content)?,
+        PatternFileExt::Md => {
+            let hunks = patterns
+                .iter()
+                .map(format_pattern_as_hunk_changes)
+                .collect::<Result<Vec<HunkChange>>>()?;
+            apply_hunk_changes(old_file_content, hunks)
+        }
+    };
+
+    if &new_file_content == old_file_content {
+        return Ok(());
+    }
+
+    if arg.write {
+        tokio::fs::write(file_path, new_file_content)
+            .await
+            .with_context(|| "could not write to file")?;
+    } else {
+        println!(
+            "{}:\n{}",
+            file_path.bold(),
+            format_diff(old_file_content, &new_file_content)
+        );
+    }
+
+    Ok(())
+}
+
+fn format_yaml_file(file_content: &str) -> Result<String> {
+    // deserializing manually and not using `SerializedGritConfig` because
+    // i don't want to remove any fields that `SerializedGritConfig` don't have such as 'version'
+    let mut config: serde_yaml::Value =
+        serde_yaml::from_str(file_content).with_context(|| "couldn't parse yaml file")?;
+    let patterns = config
+        .get_mut("patterns")
+        .ok_or_else(|| anyhow!("couldn't find patterns in yaml file"))?
+        .as_sequence_mut()
+        .ok_or_else(|| anyhow!("patterns in yaml file are not sequence"))?;
+    for pattern in patterns {
+        let Some(body) = pattern.get_mut("body") else {
+            continue;
+        };
+        if let serde_yaml::Value::String(body_str) = body {
+            *body_str = format_grit_code(body_str)?;
+            // extra new line at end of grit body looks more readable
+            body_str.push('\n');
+        }
+    }
+    Ok(serde_yaml::to_string(&config)?)
+}
+
+fn format_pattern_as_hunk_changes(pattern: &ResolvedGritDefinition) -> Result<HunkChange> {
+    let formatted_grit_code = format_grit_code(&pattern.body)?;
+    let body_range = pattern
+        .config
+        .range
+        .ok_or_else(|| anyhow!("pattern doesn't have config range"))?;
+    Ok(HunkChange {
+        starting_byte: body_range.start_byte as usize,
+        ending_byte: body_range.end_byte as usize,
+        new_content: formatted_grit_code,
+    })
+}
+
+/// format grit code using `biome`
+fn format_grit_code(source: &str) -> Result<String> {
+    let parsed = biome_grit_parser::parse_grit(source);
+    ensure!(
+        parsed.diagnostics().is_empty(),
+        "biome couldn't parse: {}",
+        parsed
+            .diagnostics()
+            .iter()
+            .map(|diag| diag.message.to_string())
+            .collect::<Vec<_>>()
+            .join("\n")
+    );
+
+    let options = GritFormatOptions::default();
+    let doc = biome_grit_formatter::format_node(options, &parsed.syntax())
+        .with_context(|| "biome couldn't format")?;
+    Ok(doc.print()?.into_code())
+}
+
+/// Represent a hunk of text that needs to be changed
+#[derive(Debug)]
+struct HunkChange {
+    starting_byte: usize,
+    ending_byte: usize,
+    new_content: String,
+}
+
+/// returns a new string that applies hunk changes
+fn apply_hunk_changes(input: &str, mut hunks: Vec<HunkChange>) -> String {
+    if hunks.is_empty() {
+        return input.to_string();
+    }
+    hunks.sort_by_key(|hunk| hunk.starting_byte);
+    let mut buffer = String::new();
+    let mut last_ending_byte = 0;
+    for (index, hunk) in hunks.iter().enumerate() {
+        buffer.push_str(&input[last_ending_byte..hunk.starting_byte]);
+        buffer.push_str(&hunk.new_content);
+        last_ending_byte = hunk.ending_byte;
+
+        if index == hunks.len() - 1 {
+            buffer.push_str(&input[last_ending_byte..]);
+        }
+    }
+    buffer
+}

crates/cli/src/commands/mod.rs

@@ -22,6 +22,7 @@ pub(crate) mod patterns_list;
 pub(crate) mod patterns_test;
 pub(crate) mod plumbing;
 pub(crate) mod version;
+pub(crate) mod format;
 
 #[cfg(feature = "workflows_v2")]
 pub(crate) mod apply_migration;
@@ -84,6 +85,7 @@ use indicatif_log_bridge::LogWrapper;
 use init::InitArgs;
 use install::InstallArgs;
 use list::ListArgs;
+use format::{run_format, FormatArgs};
 use log::LevelFilter;
 use lsp::LspArgs;
 use marzano_messenger::emit::ApplyDetails;
@@ -164,6 +166,8 @@ pub enum Commands {
     Plumbing(PlumbingArgs),
     /// Display version information about the CLI and agents
     Version(VersionArgs),
+    /// Format grit files under current directory
+    Format(FormatArgs),
     /// Generate documentation for the Grit CLI (internal use only)
     #[cfg(feature = "docgen")]
     #[clap(hide = true)]
@@ -204,6 +208,7 @@ impl fmt::Display for Commands {
             },
             Commands::Plumbing(_) => write!(f, "plumbing"),
             Commands::Version(_) => write!(f, "version"),
+            Commands::Format(_) => write!(f, "format"),
             #[cfg(feature = "docgen")]
             Commands::Docgen(_) => write!(f, "docgen"),
             #[cfg(feature = "server")]
@@ -439,6 +444,7 @@ async fn run_command(_use_tracing: bool) -> Result<()> {
                 run_plumbing(arg, multi, &mut apply_details, app.format_flags).await
             }
             Commands::Version(arg) => run_version(arg).await,
+            Commands::Format(arg) => run_format(&arg).await,
             #[cfg(feature = "docgen")]
             Commands::Docgen(arg) => run_docgen(arg).await,
             #[cfg(feature = "server")]

crates/cli/src/ux.rs

@@ -125,7 +125,7 @@ impl fmt::Display for DiffString {
     }
 }
 
-fn format_diff(expected: &str, actual: &str) -> DiffString {
+pub fn format_diff(expected: &str, actual: &str) -> DiffString {
     let mut output = String::new();
     let diff = TextDiff::from_lines(expected, actual);
 

crates/cli_bin/fixtures/unformatted_patterns/.grit/grit.yaml

@@ -0,0 +1,12 @@
+version: 0.0.1
+patterns:
+  - name: aspect_ratio_yaml
+    description: Yaml version of aspect_ratio.md
+    body: |
+      language css
+
+      `a { $props }` where {
+        $props <: contains `aspect-ratio: $x`
+      }
+
+  - file: ./others/test_move_import.md

crates/cli_bin/fixtures/unformatted_patterns/.grit/others/test_move_import.md

@@ -0,0 +1,11 @@
+---
+private: true
+tags: [private]
+---
+```grit
+language js
+
+`sanitizeFilePath` as $s where {
+  move_import(`sanitizeFilePath`, `'@getgrit/universal'`)
+}
+```

crates/cli_bin/fixtures/unformatted_patterns/.grit/patterns/aspect_ratio.md

@@ -0,0 +1,57 @@
+---
+title: Aspect ratio
+---
+
+```grit
+language css
+
+`a { $props }` where {
+  $props <: contains `aspect-ratio: $x`
+}
+```
+
+## Matches the right selector and declaration block
+
+```css
+a {
+  width: calc(100% - 80px);
+  aspect-ratio: 1/2;
+  font-size: calc(10px + (56 - 10) * ((100vw - 320px) / (1920 - 320)));
+}
+
+#some-id {
+  some-property: 5px;
+}
+
+a.b ~ c.d {
+}
+.e.f + .g.h {
+}
+
+@font-face {
+  font-family: 'Open Sans';
+  src: url('/a') format('woff2'), url('/b/c') format('woff');
+}
+```
+
+```css
+a {
+  width: calc(100% - 80px);
+  aspect-ratio: 1/2;
+  font-size: calc(10px + (56 - 10) * ((100vw - 320px) / (1920 - 320)));
+}
+
+#some-id {
+  some-property: 5px;
+}
+
+a.b ~ c.d {
+}
+.e.f + .g.h {
+}
+
+@font-face {
+  font-family: 'Open Sans';
+  src: url('/a') format('woff2'), url('/b/c') format('woff');
+}
+```

crates/cli_bin/fixtures/unformatted_patterns/.grit/patterns/dependency.grit

@@ -0,0 +1,23 @@
+language json
+
+pattern upgrade_dependency($target_dep, $target_version, $dependency_key) {
+    or {
+        `$key: $value` where {
+            $key <: `"$target_dep"`,
+            $value => `"$target_version"`
+        },
+        pair($key, $value) where {
+            $key <: `"$dependency_key"`,
+            $value <: object($properties) where {
+                $properties <: not contains pair(key=$dep_key) where {
+                    $dep_key <: contains `$target_dep`
+                },
+                $properties => `"$target_dep": "$target_version",\n$properties`
+            }
+        }
+    }
+}
+
+pattern console_method_to_info($method) {
+  `console.$method($message)` => `console.info($message)`
+}