Unify code in emmylua_check and emmylua_doc_cli

Both CLI tools have similar, yet slightly different code and usage. This PR makes them more consistent.

In `emmylua_doc_cli`:

- added positional parameter `[WORKSPACE]...`;
- deprecated `-i, --input` in favor of `[WORKSPACE]...`;
- added `-c, --config` to specify location of `.emmyrc.json`/`.luarc.json`;
- added `--ignore` to specify ignored files. No short option for `--ignore` because that would clash with `-i, --input`;
- deprecated long option `--format` in favor of `--output-format`;
- supported `--output stdout` for JSON output;
- re-implemented debug output using `log` crate, added `--verbose` option;
- contents of `init.rs` are now identical to those from `emmylua_check`.

In `emmylua_check`:

- added short option `-f` for output format,
- supported specifying multiple workspaces.

Author: taminomara

Cargo.lock

@@ -14,7 +14,8 @@ pub struct CmdArgs {
     pub config: Option<Vec<PathBuf>>,
 
     /// Path to the workspace directory
-    pub workspace: PathBuf,
+    #[arg(num_args = 1..)]
+    pub workspace: Vec<PathBuf>,
 
     /// Comma separated list of ignore patterns.
     /// Patterns must follow glob syntax
@@ -24,11 +25,17 @@ pub struct CmdArgs {
     /// Specify output format
     #[cfg_attr(
         feature = "cli",
-        arg(long, default_value = "text", value_enum, ignore_case = true)
+        arg(
+            long,
+            short = 'f',
+            default_value = "text",
+            value_enum,
+            ignore_case = true
+        )
     )]
     pub output_format: OutputFormat,
 
-    /// Specify output destination (stdout or a file path, only used when output_format is json).
+    /// Specify output destination (stdout or a file path, only used when output_format is json)
     #[cfg_attr(feature = "cli", arg(long, default_value = "stdout"))]
     pub output: OutputDestination,
 

crates/emmylua_check/src/cmd_args.rs

@@ -1,9 +1,10 @@
-use std::{path::PathBuf, str::FromStr, sync::Arc};
-
 use emmylua_code_analysis::{
     load_configs, load_workspace_files, update_code_style, DbIndex, EmmyLuaAnalysis, Emmyrc,
     FileId, LuaFileInfo,
 };
+use fern::Dispatch;
+use log::LevelFilter;
+use std::{path::PathBuf, str::FromStr, sync::Arc};
 
 fn root_from_configs(config_paths: &Vec<PathBuf>, fallback: &PathBuf) -> PathBuf {
     if config_paths.len() != 1 {
@@ -26,13 +27,44 @@ fn root_from_configs(config_paths: &Vec<PathBuf>, fallback: &PathBuf) -> PathBuf
     }
 }
 
+pub fn setup_logger(verbose: bool) {
+    let logger = Dispatch::new()
+        .format(move |out, message, record| {
+            let (color, reset) = match record.level() {
+                log::Level::Error => ("\x1b[31m", "\x1b[0m"), // Red
+                log::Level::Warn => ("\x1b[33m", "\x1b[0m"),  // Yellow
+                log::Level::Info | log::Level::Debug | log::Level::Trace => ("", ""),
+            };
+            out.finish(format_args!(
+                "{}{}: {}{}",
+                color,
+                record.level(),
+                if verbose {
+                    format!("({}) {}", record.target(), message)
+                } else {
+                    message.to_string()
+                },
+                reset
+            ))
+        })
+        .level(if verbose {
+            LevelFilter::Info
+        } else {
+            LevelFilter::Warn
+        })
+        .chain(std::io::stderr());
+
+    if let Err(e) = logger.apply() {
+        eprintln!("Failed to apply logger: {:?}", e);
+    }
+}
+
 pub fn load_workspace(
-    workspace_folder: PathBuf,
+    main_path: PathBuf,
+    mut workspace_folders: Vec<PathBuf>,
     config_paths: Option<Vec<PathBuf>>,
     ignore: Option<Vec<String>>,
 ) -> Option<EmmyLuaAnalysis> {
-    let mut workspace_folders = vec![workspace_folder];
-    let main_path = workspace_folders.first()?.clone();
     let (config_files, config_root): (Vec<PathBuf>, PathBuf) =
         if let Some(config_paths) = config_paths {
             (
@@ -176,11 +208,11 @@ pub fn calculate_include_and_exclude(
     (include, exclude, exclude_dirs)
 }
 
-pub fn get_need_check_ids(db: &DbIndex, files: Vec<FileId>, workspace: &PathBuf) -> Vec<FileId> {
+pub fn get_need_check_ids(db: &DbIndex, files: Vec<FileId>, workspace: &[PathBuf]) -> Vec<FileId> {
     let mut need_check_files = Vec::new();
     for file_id in files {
         let file_path = db.get_vfs().get_file_path(&file_id).unwrap();
-        if file_path.starts_with(workspace) {
+        if workspace.iter().any(|ws| file_path.starts_with(ws)) {
             need_check_files.push(file_id);
         }
     }

crates/emmylua_check/src/init.rs

@@ -4,52 +4,38 @@ mod output;
 mod terminal_display;
 
 pub use cmd_args::*;
-use fern::Dispatch;
-use log::LevelFilter;
 use output::output_result;
 use std::{error::Error, sync::Arc};
 use tokio_util::sync::CancellationToken;
 
-use crate::init::get_need_check_ids;
+use crate::init::{get_need_check_ids, setup_logger};
 
 pub async fn run_check(cmd_args: CmdArgs) -> Result<(), Box<dyn Error + Sync + Send>> {
-    let mut workspace = cmd_args.workspace;
-    if !workspace.is_absolute() {
-        workspace = std::env::current_dir()?.join(workspace);
-    }
+    setup_logger(cmd_args.verbose);
 
-    let verbose = cmd_args.verbose;
-    let logger = Dispatch::new()
-        .format(move |out, message, record| {
-            let (color, reset) = match record.level() {
-                log::Level::Error => ("\x1b[31m", "\x1b[0m"), // Red
-                log::Level::Warn => ("\x1b[33m", "\x1b[0m"),  // Yellow
-                log::Level::Info | log::Level::Debug | log::Level::Trace => ("", ""),
-            };
-            out.finish(format_args!(
-                "{}{}: {}{}",
-                color,
-                record.level(),
-                if verbose {
-                    format!("({}) {}", record.target(), message)
-                } else {
-                    message.to_string()
-                },
-                reset
-            ))
-        })
-        .level(if verbose {
-            LevelFilter::Info
-        } else {
-            LevelFilter::Warn
+    let cwd = std::env::current_dir()?;
+    let workspaces: Vec<_> = cmd_args
+        .workspace
+        .into_iter()
+        .map(|workspace| {
+            if workspace.is_absolute() {
+                workspace
+            } else {
+                cwd.join(workspace)
+            }
         })
-        .chain(std::io::stderr());
-
-    if let Err(e) = logger.apply() {
-        eprintln!("Failed to apply logger: {:?}", e);
-    }
+        .collect();
+    let main_path = workspaces
+        .first()
+        .ok_or("Failed to load workspace")?
+        .clone();
 
-    let analysis = match init::load_workspace(workspace.clone(), cmd_args.config, cmd_args.ignore) {
+    let analysis = match init::load_workspace(
+        main_path.clone(),
+        workspaces.clone(),
+        cmd_args.config,
+        cmd_args.ignore,
+    ) {
         Some(analysis) => analysis,
         None => {
             return Err("Failed to load workspace".into());
@@ -58,7 +44,7 @@ pub async fn run_check(cmd_args: CmdArgs) -> Result<(), Box<dyn Error + Sync + S
 
     let files = analysis.compilation.get_db().get_vfs().get_all_file_ids();
     let db = analysis.compilation.get_db();
-    let need_check_files = get_need_check_ids(db, files, &workspace);
+    let need_check_files = get_need_check_ids(db, files, &workspaces);
 
     let (sender, receiver) = tokio::sync::mpsc::channel(100);
     let analysis = Arc::new(analysis);
@@ -76,7 +62,7 @@ pub async fn run_check(cmd_args: CmdArgs) -> Result<(), Box<dyn Error + Sync + S
     let exit_code = output_result(
         need_check_files.len(),
         db,
-        workspace,
+        main_path,
         receiver,
         cmd_args.output_format,
         cmd_args.output,

crates/emmylua_check/src/lib.rs

@@ -29,3 +29,8 @@ walkdir.workspace = true
 tera.workspace = true
 include_dir.workspace = true
 clap.workspace = true
+log.workspace = true
+fern.workspace = true
+
+[[bin]]
+name = "emmylua_doc_cli"

crates/emmylua_doc_cli/Cargo.toml

@@ -0,0 +1,6 @@
+use emmylua_doc_cli::{run_doc_cli, CmdArgs, Parser};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let cmd_args = CmdArgs::parse();
+    run_doc_cli(cmd_args)
+}

crates/emmylua_doc_cli/src/bin/emmylua_doc_cli.rs

@@ -3,17 +3,42 @@ use std::path::PathBuf;
 
 #[derive(Debug, Parser)]
 pub struct CmdArgs {
-    /// The path of the lua project
-    #[arg(long, short, num_args = 1..)]
+    /// Configuration file paths.
+    /// If not provided, both ".emmyrc.json" and ".luarc.json" will be searched in the workspace
+    /// directory
+    #[arg(short, long, value_delimiter = ',')]
+    pub config: Option<Vec<PathBuf>>,
+
+    /// Deprecated, use [WORKSPACE] instead
+    #[arg(short, long, num_args = 1..)]
     pub input: Vec<PathBuf>,
 
-    /// Format of the output, default is Markdown
-    #[arg(long, short, default_value = "markdown")]
-    pub format: Format,
+    /// Path to the workspace directory
+    #[arg(num_args = 1..)]
+    pub workspace: Vec<PathBuf>,
+
+    /// Comma separated list of ignore patterns.
+    /// Patterns must follow glob syntax
+    #[arg(long, value_delimiter = ',')]
+    pub ignore: Option<Vec<String>>,
+
+    /// Specify output format
+    #[arg(
+        long,
+        short = 'f',
+        default_value = "markdown",
+        value_enum,
+        ignore_case = true
+    )]
+    pub output_format: Format,
 
-    /// The output path of the docs file
+    /// Deprecated, use --output-format instead
+    #[arg(long, value_enum, ignore_case = true)]
+    pub format: Option<Format>,
+
+    /// Specify output destination (can be stdout when output_format is json)
     #[arg(long, short, default_value = "./output")]
-    pub output: PathBuf,
+    pub output: OutputDestination,
 
     /// The path of the override template
     #[arg(long)]
@@ -25,22 +50,31 @@ pub struct CmdArgs {
     /// The path of the mixin md file
     #[arg(long)]
     pub mixin: Option<PathBuf>,
+
+    /// Verbose output
+    #[arg(long)]
+    pub verbose: bool,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq, ValueEnum)]
 pub enum Format {
-    Markdown,
     Json,
+    Markdown,
 }
 
-impl std::str::FromStr for Format {
-    type Err = &'static str;
+#[allow(unused)]
+#[derive(Debug, Clone)]
+pub enum OutputDestination {
+    Stdout,
+    File(PathBuf),
+}
 
+impl std::str::FromStr for OutputDestination {
+    type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_ref() {
-            "markdown" => Ok(Self::Markdown),
-            "json" => Ok(Self::Json),
-            _ => Err("Invalid format, must be one of markdown, json"),
+        match s.to_lowercase().as_str() {
+            "stdout" => Ok(OutputDestination::Stdout),
+            _ => Ok(OutputDestination::File(PathBuf::from(s))),
         }
     }
 }