add emmylua_format

Author: CppCXY

Cargo.lock

@@ -1,9 +1,27 @@
 [package]
 name = "emmylua_code_style"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [dependencies]
 serde.workspace = true
 emmylua_parser.workspace = true
 rowan.workspace = true
+serde_json.workspace = true
+serde_yml.workspace = true
+
+[dependencies.clap]
+workspace = true
+optional = true
+
+[dependencies.mimalloc]
+workspace = true
+optional = true
+
+[[bin]]
+name = "emmylua_format"
+required-features = ["cli"]
+
+[features]
+default = ["cli"]
+cli = ["dep:clap", "dep:mimalloc"]

crates/emmylua_code_style/Cargo.toml

@@ -0,0 +1,171 @@
+use std::{
+    fs,
+    io::{self, Read, Write},
+    path::PathBuf,
+    process::exit,
+};
+
+use clap::Parser;
+use emmylua_code_style::{LuaCodeStyle, cmd_args, reformat_lua_code};
+
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
+fn read_stdin_to_string() -> io::Result<String> {
+    let mut s = String::new();
+    io::stdin().read_to_string(&mut s)?;
+    Ok(s)
+}
+
+fn format_content(content: &str, style: &LuaCodeStyle) -> String {
+    reformat_lua_code(content, style)
+}
+
+#[allow(unused)]
+fn process_file(
+    path: &PathBuf,
+    style: &LuaCodeStyle,
+    write: bool,
+    list_diff: bool,
+) -> io::Result<(bool, Option<String>)> {
+    let original = fs::read_to_string(path)?;
+    let formatted = format_content(&original, style);
+    let changed = formatted != original;
+
+    if write && changed {
+        fs::write(path, formatted)?;
+        return Ok((true, None));
+    }
+
+    if list_diff && changed {
+        return Ok((true, Some(path.to_string_lossy().to_string())));
+    }
+
+    Ok((changed, None))
+}
+
+fn main() {
+    let args = cmd_args::CliArgs::parse();
+
+    let mut exit_code = 0;
+
+    let style = match cmd_args::resolve_style(&args) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("Error: {e}");
+            exit(2);
+        }
+    };
+
+    let is_stdin = args.stdin || args.paths.is_empty();
+
+    if is_stdin {
+        let content = match read_stdin_to_string() {
+            Ok(s) => s,
+            Err(e) => {
+                eprintln!("Failed to read stdin: {e}");
+                exit(2);
+            }
+        };
+
+        let formatted = format_content(&content, &style);
+        let changed = formatted != content;
+
+        if args.check || args.list_different {
+            if changed {
+                exit_code = 1;
+            }
+        } else if let Some(out) = &args.output {
+            if let Err(e) = fs::write(out, formatted) {
+                eprintln!("Failed to write output to {out:?}: {e}");
+                exit(2);
+            }
+        } else if args.write {
+            eprintln!("--write with stdin requires --output <FILE>");
+            exit(2);
+        } else {
+            let mut stdout = io::stdout();
+            if let Err(e) = stdout.write_all(formatted.as_bytes()) {
+                eprintln!("Failed to write to stdout: {e}");
+                exit(2);
+            }
+        }
+
+        exit(exit_code);
+    }
+
+    if args.paths.len() > 1 && args.output.is_some() {
+        eprintln!("--output can only be used with a single input or stdin");
+        exit(2);
+    }
+
+    if args.paths.len() > 1 && !(args.write || args.check || args.list_different) {
+        eprintln!("Multiple inputs require --write or --check");
+        exit(2);
+    }
+
+    let mut different_paths: Vec<String> = Vec::new();
+
+    for path in &args.paths {
+        match fs::metadata(path) {
+            Ok(meta) => {
+                if !meta.is_file() {
+                    eprintln!("Skipping non-file path: {}", path.to_string_lossy());
+                    continue;
+                }
+            }
+            Err(e) => {
+                eprintln!("Cannot access {}: {e}", path.to_string_lossy());
+                exit_code = 2;
+                continue;
+            }
+        }
+
+        match fs::read_to_string(path) {
+            Ok(original) => {
+                let formatted = format_content(&original, &style);
+                let changed = formatted != original;
+
+                if args.check || args.list_different {
+                    if changed {
+                        exit_code = 1;
+                        if args.list_different {
+                            different_paths.push(path.to_string_lossy().to_string());
+                        }
+                    }
+                } else if args.write {
+                    if changed {
+                        if let Err(e) = fs::write(path, formatted) {
+                            eprintln!("Failed to write {}: {e}", path.to_string_lossy());
+                            exit_code = 2;
+                        }
+                    }
+                } else if let Some(out) = &args.output {
+                    if let Err(e) = fs::write(out, formatted) {
+                        eprintln!("Failed to write output to {out:?}: {e}");
+                        exit(2);
+                    }
+                } else {
+                    // Single file without write/check: print to stdout
+                    let mut stdout = io::stdout();
+                    if let Err(e) = stdout.write_all(formatted.as_bytes()) {
+                        eprintln!("Failed to write to stdout: {e}");
+                        exit(2);
+                    }
+                }
+            }
+            Err(e) => {
+                eprintln!("Failed to read {}: {e}", path.to_string_lossy());
+                exit_code = 2;
+            }
+        }
+    }
+
+    if args.list_different && !different_paths.is_empty() {
+        for p in different_paths {
+            println!("{p}");
+        }
+    }
+
+    exit(exit_code);
+}

crates/emmylua_code_style/src/bin/emmylua_format.rs

@@ -0,0 +1,101 @@
+use std::{fs, path::PathBuf};
+
+use clap::{ArgGroup, Parser};
+
+use crate::styles::{LuaCodeStyle, LuaIndent};
+
+#[derive(Debug, Clone, Parser)]
+#[command(
+    name = "emmylua_format",
+    version,
+    about = "Format Lua source code using EmmyLua code style rules",
+    disable_help_subcommand = true
+)]
+#[command(group(
+	ArgGroup::new("indent_choice")
+		.args(["tab", "spaces"])
+		.multiple(false)
+))]
+pub struct CliArgs {
+    /// Input paths to format (files only). If omitted, reads from stdin.
+    #[arg(value_name = "PATH", value_hint = clap::ValueHint::FilePath)]
+    pub paths: Vec<PathBuf>,
+
+    /// Read source from stdin instead of files
+    #[arg(long)]
+    pub stdin: bool,
+
+    /// Write formatted result back to the file(s)
+    #[arg(long)]
+    pub write: bool,
+
+    /// Check if files would be reformatted. Exit with code 1 if any would change.
+    #[arg(long)]
+    pub check: bool,
+
+    /// Print paths of files that would be reformatted
+    #[arg(long, alias = "list-different")]
+    pub list_different: bool,
+
+    /// Write output to a specific file (only with a single input or stdin)
+    #[arg(short, long, value_name = "FILE", value_hint = clap::ValueHint::FilePath)]
+    pub output: Option<PathBuf>,
+
+    /// Load style config from a file (json/yml/yaml)
+    #[arg(long, value_name = "FILE", value_hint = clap::ValueHint::FilePath)]
+    pub config: Option<PathBuf>,
+
+    /// Use tabs for indentation
+    #[arg(long)]
+    pub tab: bool,
+
+    /// Use N spaces for indentation (mutually exclusive with --tab)
+    #[arg(long, value_name = "N")]
+    pub spaces: Option<usize>,
+
+    /// Set maximum line width
+    #[arg(long, value_name = "N")]
+    pub max_line_width: Option<usize>,
+}
+
+pub fn resolve_style(args: &CliArgs) -> Result<LuaCodeStyle, String> {
+    let mut style = if let Some(cfg) = &args.config {
+        let content = fs::read_to_string(cfg)
+            .map_err(|e| format!("读取配置失败: {}: {e}", cfg.to_string_lossy()))?;
+        let ext = cfg
+            .extension()
+            .and_then(|s| s.to_str())
+            .map(|s| s.to_ascii_lowercase())
+            .unwrap_or_default();
+        match ext.as_str() {
+            "json" => serde_json::from_str::<LuaCodeStyle>(&content)
+                .map_err(|e| format!("解析 JSON 配置失败: {e}"))?,
+            "yml" | "yaml" => serde_yml::from_str::<LuaCodeStyle>(&content)
+                .map_err(|e| format!("解析 YAML 配置失败: {e}"))?,
+            _ => {
+                // Unknown extension, try JSON first then YAML
+                match serde_json::from_str::<LuaCodeStyle>(&content) {
+                    Ok(v) => v,
+                    Err(_) => serde_yml::from_str::<LuaCodeStyle>(&content)
+                        .map_err(|e| format!("未知扩展名，按 JSON/YAML 解析均失败: {e}"))?,
+                }
+            }
+        }
+    } else {
+        LuaCodeStyle::default()
+    };
+
+    // Indent overrides
+    match (args.tab, args.spaces) {
+        (true, Some(_)) => return Err("--tab 与 --spaces 不能同时使用".into()),
+        (true, None) => style.indent = LuaIndent::Tab,
+        (false, Some(n)) => style.indent = LuaIndent::Space(n),
+        _ => {}
+    }
+
+    if let Some(w) = args.max_line_width {
+        style.max_line_width = w;
+    }
+
+    Ok(style)
+}

crates/emmylua_code_style/src/cmd_args.rs

@@ -21,4 +21,23 @@ impl FormatterContext {
             self.text.pop();
         }
     }
+
+    pub fn get_last_whitespace_count(&self) -> usize {
+        let mut count = 0;
+        for ch in self.text.chars().rev() {
+            if ch == ' ' {
+                count += 1;
+            } else {
+                break;
+            }
+        }
+        count
+    }
+
+    pub fn reset_whitespace_to(&mut self, n: usize) {
+        self.reset_whitespace();
+        if n > 0 {
+            self.text.push_str(&" ".repeat(n));
+        }
+    }
 }

crates/emmylua_code_style/src/format/formatter_context.rs

@@ -61,6 +61,15 @@ impl LuaFormatter {
                             continue;
                         }
                     }
+                    (Some(TokenExpected::MaxSpace(n)), LuaTokenKind::TkWhitespace) => {
+                        if !context.is_line_first_token {
+                            let white_space_len = token.text().chars().count();
+                            if white_space_len > n {
+                                context.reset_whitespace_to(n);
+                                continue;
+                            }
+                        }
+                    }
                     (_, LuaTokenKind::TkEndOfLine) => {
                         // No space expected
                         context.reset_whitespace();
@@ -85,6 +94,14 @@ impl LuaFormatter {
                                 context.text.push_str(&" ".repeat(*n));
                             }
                         }
+                        TokenExpected::MaxSpace(n) => {
+                            if !context.is_line_first_token {
+                                let current_spaces = context.get_last_whitespace_count();
+                                if current_spaces > *n {
+                                    context.reset_whitespace_to(*n);
+                                }
+                            }
+                        }
                     }
                 }
 

crates/emmylua_code_style/src/format/mod.rs

@@ -11,4 +11,5 @@ pub enum TokenNodeChange {
 #[derive(Debug, Clone, Copy)]
 pub enum TokenExpected {
     Space(usize),
+    MaxSpace(usize),
 }

crates/emmylua_code_style/src/format/syntax_node_change.rs

@@ -1,10 +1,10 @@
+pub mod cmd_args;
 mod format;
 mod style_ruler;
 mod styles;
 mod test;
 
 use emmylua_parser::{LuaAst, LuaParser, ParserConfig};
-use styles::LuaCodeStyle;
 
 pub fn reformat_lua_code(code: &str, styles: &LuaCodeStyle) -> String {
     let tree = LuaParser::parse(code, ParserConfig::default());
@@ -21,3 +21,6 @@ pub fn reformat_node(node: &LuaAst, styles: &LuaCodeStyle) -> String {
     let formatted_text = formatter.get_formatted_text();
     formatted_text
 }
+
+// Re-export commonly used types for consumers/binaries
+pub use styles::LuaCodeStyle;