emmylua_check: print log warnings and errors to stderr

- Add `--verbose` flags.
- Improve docs for `--ignore` and `--config`.
- Add logging for include/excludes.

Resolves #512

Author: lewis6991

Cargo.lock

@@ -19,6 +19,8 @@ emmylua_parser.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 lsp-types.workspace = true
+log.workspace = true
+fern.workspace = true
 rowan.workspace = true
 walkdir.workspace = true
 structopt.workspace = true

crates/emmylua_check/Cargo.toml

@@ -4,39 +4,41 @@ use structopt::StructOpt;
 #[derive(Debug, StructOpt, Clone)]
 #[structopt(name = "emmylua-check", about = "EmmyLua Check")]
 pub struct CmdArgs {
-    #[structopt(short, long, parse(from_os_str), help = "Specify configuration file")]
+    /// Specify configuration file path.
+    /// If not provided, both ".emmyrc.json" and ".luarc.json" will be searched in the workspace
+    /// directory
+    #[structopt(short, long, parse(from_os_str))]
     pub config: Option<std::path::PathBuf>,
 
-    #[structopt(parse(from_os_str), help = "Path to the workspace directory")]
+    /// Path to the workspace directory
+    #[structopt(parse(from_os_str))]
     pub workspace: std::path::PathBuf,
 
-    #[structopt(
-        short,
-        long,
-        help = "Comma separated list of ignore patterns",
-        use_delimiter = true
-    )]
+    /// Comma separated list of ignore patterns.
+    /// Patterns must follow glob syntax
+    #[structopt(short, long, use_delimiter = true)]
     pub ignore: Option<Vec<String>>,
 
+    /// Specify output format
     #[structopt(
         long,
-        help = "Specify output format (json or text)",
         default_value = "text",
         possible_values = &OutputFormat::variants(),
         case_insensitive = true
     )]
     pub output_format: OutputFormat,
 
-    #[structopt(
-        long,
-        help = "Specify output destination (stdout or a file path, only used when output_format is json)",
-        default_value = "stdout",
-        parse(try_from_str)
-    )]
+    /// Specify output destination (stdout or a file path, only used when output_format is json).
+    #[structopt(long, default_value = "stdout", parse(try_from_str))]
     pub output: OutputDestination,
 
-    #[structopt(long, help = "Treat warnings as errors")]
+    /// Treat warnings as errors
+    #[structopt(long)]
     pub warnings_as_errors: bool,
+
+    /// Verbose output
+    #[structopt(long)]
+    pub verbose: bool,
 }
 
 #[derive(Debug, Clone)]

crates/emmylua_check/src/cmd_args.rs

@@ -110,23 +110,29 @@ pub fn calculate_include_and_exclude(
 
     for extension in &emmyrc.runtime.extensions {
         if extension.starts_with(".") {
+            log::info!("Adding extension: **/*{}", extension);
             include.push(format!("**/*{}", extension));
         } else if extension.starts_with("*.") {
+            log::info!("Adding extension: **/{}", extension);
             include.push(format!("**/{}", extension));
         } else {
+            log::info!("Adding extension: {}", extension);
             include.push(extension.clone());
         }
     }
 
     for ignore_glob in &emmyrc.workspace.ignore_globs {
+        log::info!("Adding ignore glob: {}", ignore_glob);
         exclude.push(ignore_glob.clone());
     }
 
     if let Some(ignore) = ignore {
+        log::info!("Adding ignores from \"--ignore\": {:?}", ignore);
         exclude.extend(ignore);
     }
 
     for dir in &emmyrc.workspace.ignore_dir {
+        log::info!("Adding ignore dir: {}", dir);
         exclude_dirs.push(PathBuf::from(dir));
     }
 

crates/emmylua_check/src/init.rs

@@ -4,6 +4,8 @@ mod output;
 
 use cmd_args::CmdArgs;
 use emmylua_code_analysis::{DbIndex, FileId};
+use fern::Dispatch;
+use log::LevelFilter;
 use output::output_result;
 use std::{error::Error, path::PathBuf, sync::Arc};
 use structopt::StructOpt;
@@ -17,6 +19,37 @@ async fn main() -> Result<(), Box<dyn Error + Sync + Send>> {
         workspace = std::env::current_dir()?.join(workspace);
     }
 
+    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
+        })
+        .chain(std::io::stderr());
+
+    if let Err(e) = logger.apply() {
+        eprintln!("Failed to apply logger: {:?}", e);
+    }
+
     let analysis = match init::load_workspace(workspace.clone(), cmd_args.config, cmd_args.ignore) {
         Some(analysis) => analysis,
         None => {