WIP - Clarinet format

Cargo.toml

@@ -4,6 +4,7 @@ members = [
     "components/clarinet-cli",
     "components/clarinet-deployments",
     "components/clarinet-files",
+    "components/clarinet-format",
     "components/clarinet-utils",
     "components/clarinet-sdk-wasm",
     "components/clarity-lsp",

components/clarinet-cli/Cargo.toml

@@ -40,6 +40,7 @@ clarity_repl = { package = "clarity-repl", path = "../clarity-repl", features =
 ] }
 clarinet-files = { path = "../clarinet-files", features = ["cli"] }
 clarity-lsp = { path = "../clarity-lsp", features = ["cli"] }
+clarinet-format = { path = "../clarinet-format" }
 clarinet-deployments = { path = "../clarinet-deployments", features = ["cli"] }
 hiro-system-kit = { path = "../hiro-system-kit" }
 stacks-network = { path = "../stacks-network" }

components/clarinet-cli/src/frontend/cli.rs

@@ -27,6 +27,7 @@ use clarinet_files::{
     get_manifest_location, FileLocation, NetworkManifest, ProjectManifest, ProjectManifestFile,
     RequirementConfig,
 };
+use clarinet_format::formatter::{ClarityFormatter, Settings};
 use clarity_repl::analysis::call_checker::ContractAnalysis;
 use clarity_repl::clarity::vm::analysis::AnalysisDatabase;
 use clarity_repl::clarity::vm::costs::LimitedCostTracker;
@@ -39,7 +40,7 @@ use clarity_repl::{analysis, repl, Terminal};
 use stacks_network::{self, DevnetOrchestrator};
 use std::collections::HashMap;
 use std::fs::{self, File};
-use std::io::prelude::*;
+use std::io::{self, prelude::*};
 use std::{env, process};
 use toml;
 
@@ -94,11 +95,26 @@ enum Command {
     /// Get Clarity autocompletion and inline errors from your code editor (VSCode, vim, emacs, etc)
     #[clap(name = "lsp", bin_name = "lsp")]
     LSP,
+    /// Format clarity code files
+    #[clap(name = "format", aliases = &["fmt"], bin_name = "format")]
+    Format(Format),
     /// Step by step debugging and breakpoints from your code editor (VSCode, vim, emacs, etc)
     #[clap(name = "dap", bin_name = "dap")]
     DAP,
 }
 
+#[derive(Parser, PartialEq, Clone, Debug)]
+struct Format {
+    /// Path to clarity files
+    #[clap(long = "path", short = 'p')]
+    pub code_path: Option<String>,
+    /// If specified, format only this file
+    #[clap(long = "file", short = 'f')]
+    pub file: Option<String>,
+    #[clap(long = "dry-run")]
+    pub dry_run: bool,
+}
+
 #[derive(Subcommand, PartialEq, Clone, Debug)]
 enum Devnet {
     /// Generate package of all required devnet artifacts
@@ -1180,6 +1196,18 @@ pub fn main() {
                 process::exit(1);
             }
         },
+        Command::Format(cmd) => {
+            let sources = get_source_with_path(cmd.code_path, cmd.file);
+            let settings = Settings::default();
+            let mut formatter = ClarityFormatter::new(settings);
+
+            for (file_path, source) in &sources {
+                let output = formatter.format(source);
+                if !cmd.dry_run {
+                    let _ = overwrite_formatted(file_path, output);
+                }
+            }
+        }
         Command::Devnet(subcommand) => match subcommand {
             Devnet::Package(cmd) => {
                 let manifest = load_manifest_or_exit(cmd.manifest_path);
@@ -1193,6 +1221,47 @@ pub fn main() {
     };
 }
 
+fn overwrite_formatted(file_path: &String, output: String) -> io::Result<()> {
+    // Open the file in write mode, overwriting existing content
+    let mut file = fs::File::create(file_path)?;
+
+    file.write_all(output.as_bytes())?;
+
+    // flush the contents to ensure it's written immediately
+    file.flush()
+}
+
+fn get_source_with_path(code_path: Option<String>, file: Option<String>) -> Vec<(String, String)> {
+    // look for files at the default code path (./contracts/) if
+    // cmd.code_path is not specified OR if cmd.file is not specified
+    let path = code_path.unwrap_or_else(|| "./contracts/".to_string());
+
+    // Collect file paths and load source code
+    let files: Vec<String> = match file {
+        Some(file_name) => vec![format!("{}/{}", path, file_name)],
+        None => match fs::read_dir(&path) {
+            Ok(entries) => entries
+                .filter_map(Result::ok)
+                .filter(|entry| entry.path().is_file())
+                .map(|entry| entry.path().to_string_lossy().into_owned())
+                .collect(),
+            Err(message) => {
+                eprintln!("{}", format_err!(message));
+                std::process::exit(1)
+            }
+        },
+    };
+    // Map each file to its source code
+    files
+        .into_iter()
+        .map(|file_path| {
+            let source = fs::read_to_string(&file_path)
+                .unwrap_or_else(|_| "// Failed to read file".to_string());
+            (file_path, source)
+        })
+        .collect()
+}
+
 fn get_manifest_location_or_exit(path: Option<String>) -> FileLocation {
     match get_manifest_location(path) {
         Some(manifest_location) => manifest_location,
@@ -1250,6 +1319,14 @@ fn load_manifest_or_warn(path: Option<String>) -> Option<ProjectManifest> {
     }
 }
 
+fn load_clarity_code(
+    code_path: &Option<String>,
+    file: &Option<String>,
+    dry_run: bool,
+) -> (Option<String>) {
+    Some("".to_string())
+}
+
 fn load_deployment_and_artifacts_or_exit(
     manifest: &ProjectManifest,
     deployment_plan_path: &Option<String>,

components/clarinet-format/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "clarinet-format"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+clarinet-files = { path = "../clarinet-files", default-features = false, optional = true }
+clarity-repl = { path = "../clarity-repl" }
+
+[lib]
+name = "clarinet_format"
+path = "src/lib.rs"
+crate-type = ["lib"]

components/clarinet-format/src/formatter/mod.rs

@@ -0,0 +1,220 @@
+use clarity_repl::clarity::ast::build_ast_with_rules;
+use clarity_repl::clarity::vm::functions::{define::DefineFunctions, NativeFunctions};
+use clarity_repl::clarity::vm::types::QualifiedContractIdentifier;
+use clarity_repl::clarity::ClarityVersion;
+use clarity_repl::clarity::StacksEpochId;
+use clarity_repl::clarity::SymbolicExpression;
+
+pub enum Indentation {
+    Space(u8),
+    Tab,
+}
+
+pub struct Settings {
+    pub indentation: Indentation,
+    pub max_line_length: u8,
+}
+impl Settings {
+    pub fn default() -> Settings {
+        Settings {
+            indentation: Indentation::Space(2),
+            max_line_length: 80,
+        }
+    }
+}
+//
+pub struct ClarityFormatter {
+    settings: Settings,
+}
+impl ClarityFormatter {
+    pub fn new(settings: Settings) -> Self {
+        Self { settings }
+    }
+    pub fn format(&mut self, source: &str) -> String {
+        let ast = build_ast_with_rules(
+            &QualifiedContractIdentifier::transient(),
+            source,
+            &mut (),
+            ClarityVersion::Clarity3,
+            StacksEpochId::Epoch30,
+            clarity_repl::clarity::ast::ASTRules::Typical,
+        )
+        .unwrap();
+        let output = format_source_exprs(&self.settings, &ast.expressions, "");
+        println!("output: {}", output);
+        output
+    }
+}
+
+// * functions
+
+// Top level define-<function> should have a line break above and after (except on first line)
+// options always on new lines
+// Functions Always on multiple lines, even if short
+// *begin* never on one line
+// *let* never on one line
+
+// * match *
+// One line if less than max length (unless the original source has line breaks?)
+// Multiple lines if more than max length (should the first arg be on the first line if it fits?)
+pub fn format_source_exprs(
+    settings: &Settings,
+    expressions: &[SymbolicExpression],
+    acc: &str,
+) -> String {
+    if let Some((expr, remaining)) = expressions.split_first() {
+        if let Some(list) = expr.match_list() {
+            let atom = list.split_first().and_then(|(f, _)| f.match_atom());
+            use NativeFunctions::*;
+            let formatted = if let Some(
+                DefineFunctions::PublicFunction
+                | DefineFunctions::ReadOnlyFunction
+                | DefineFunctions::PrivateFunction,
+            ) = atom.and_then(|a| DefineFunctions::lookup_by_name(a))
+            {
+                format_function(settings, list)
+            } else if let Some(Begin) = atom.and_then(|a| NativeFunctions::lookup_by_name(a)) {
+                format_begin(settings, list)
+            } else if let Some(Let) = atom.and_then(|a| NativeFunctions::lookup_by_name(a)) {
+                format_let(settings, list)
+            } else if let Some(TupleCons) = atom.and_then(|a| NativeFunctions::lookup_by_name(a)) {
+                format_tuple(settings, list)
+            } else {
+                format!("({})", format_source_exprs(settings, list, acc))
+            };
+            return format!(
+                "{formatted} {}",
+                format_source_exprs(settings, remaining, acc)
+            )
+            .trim()
+            .to_owned();
+        }
+        return format!("{} {}", expr, format_source_exprs(settings, remaining, acc))
+            .trim()
+            .to_owned();
+    };
+    acc.to_owned()
+}
+
+fn format_begin(settings: &Settings, exprs: &[SymbolicExpression]) -> String {
+    let mut begin_acc = "(begin\n".to_string();
+    for arg in exprs.get(1..).unwrap_or_default() {
+        if let Some(list) = arg.match_list() {
+            begin_acc.push_str(&format!(
+                "\n  ({})",
+                format_source_exprs(settings, list, "")
+            ))
+        }
+    }
+    begin_acc.push_str("\n)\n");
+    begin_acc.to_owned()
+}
+
+fn format_let(settings: &Settings, exprs: &[SymbolicExpression]) -> String {
+    let mut begin_acc = "(let (\n".to_string();
+    for arg in exprs.get(1..).unwrap_or_default() {
+        if let Some(list) = arg.match_list() {
+            begin_acc.push_str(&format!(
+                "\n  ({})",
+                format_source_exprs(settings, list, "")
+            ))
+        }
+    }
+    begin_acc.push_str("\n)  \n");
+    begin_acc.to_owned()
+}
+
+fn format_tuple(settings: &Settings, exprs: &[SymbolicExpression]) -> String {
+    let mut tuple_acc = "{ ".to_string();
+    for (i, expr) in exprs[1..].iter().enumerate() {
+        let (key, value) = expr
+            .match_list()
+            .and_then(|list| list.split_first())
+            .unwrap();
+        if i < exprs.len() - 2 {
+            tuple_acc.push_str(&format!(
+                "{key}: {}, ",
+                format_source_exprs(settings, value, "")
+            ));
+        } else {
+            tuple_acc.push_str(&format!(
+                "{key}: {}",
+                format_source_exprs(settings, value, "")
+            ));
+        }
+    }
+    tuple_acc.push_str(" }");
+    tuple_acc.to_string()
+}
+
+fn format_function(settings: &Settings, exprs: &[SymbolicExpression]) -> String {
+    let func_type = exprs.first().unwrap();
+    let name_and_args = exprs.get(1).and_then(|f| f.match_list()).unwrap();
+    let mut func_acc = format!(
+        "({func_type} ({})",
+        format_source_exprs(settings, name_and_args, "")
+    );
+    for arg in exprs.get(2..).unwrap_or_default() {
+        if let Some(list) = arg.match_list() {
+            func_acc.push_str(&format!(
+                "\n  ({})",
+                format_source_exprs(settings, list, "")
+            ))
+        }
+    }
+    func_acc.push_str("\n)");
+    func_acc.to_owned()
+}
+#[cfg(test)]
+mod tests_formatter {
+    use super::{ClarityFormatter, Settings};
+    fn format_with_default(source: &str) -> String {
+        let mut formatter = ClarityFormatter::new(Settings::default());
+        formatter.format(source)
+    }
+    #[test]
+    fn test_simplest_formatter() {
+        let result = format_with_default(&String::from("(  ok    true )"));
+        assert_eq!(result, "(ok true)");
+    }
+    #[test]
+    fn test_two_expr_formatter() {
+        let result = format_with_default(&String::from("(ok true)(ok true)"));
+        assert_eq!(result, "(ok true)\n(ok true)");
+    }
+    #[test]
+    fn test_function_formatter() {
+        let result = format_with_default(&String::from("(define-private (my-func) (ok true))"));
+        assert_eq!(result, "(define-private (my-func)\n  (ok true)\n)");
+    }
+    #[test]
+    fn test_tuple_formatter() {
+        let result = format_with_default(&String::from("{n1:1,n2:2,n3:3}"));
+        assert_eq!(result, "{ n1: 1, n2: 2, n3: 3 }");
+    }
+    #[test]
+    fn test_function_and_tuple_formatter() {
+        let src = "(define-private (my-func) (ok { n1: 1, n2: 2, n3: 3 }))";
+        let result = format_with_default(&String::from(src));
+        assert_eq!(
+            result,
+            "(define-private (my-func)\n  (ok { n1: 1, n2: 2, n3: 3 })\n)"
+        );
+    }
+
+    #[test]
+    fn test_function_args_multiline() {
+        let src = "(define-public (my-func (amount uint) (sender principal)) (ok true))";
+        let result = format_with_default(&String::from(src));
+        assert_eq!(
+            result,
+            "(define-public (my-func\n    (amount uint)\n    (sender principal)\n  )\n  (ok true)\n)"
+        );
+    }
+    #[test]
+    fn test_begin_never_one_line() {
+        let src = "(begin (ok true))";
+        let result = format_with_default(&String::from(src));
+        assert_eq!(result, "(begin\n  (ok true)\n)");
+    }
+}