Merge pull request #513 from lewis6991/feat/emmyluaerrors

emmylua_check

Author: CppCXY

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,42 +4,44 @@ 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")]
-    pub config: Option<std::path::PathBuf>,
+    /// Configuration file paths.
+    /// If not provided, both ".emmyrc.json" and ".luarc.json" will be searched in the workspace
+    /// directory
+    #[structopt(short, long, use_delimiter = true, parse(from_os_str))]
+    pub config: Option<Vec<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)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum OutputFormat {
     Json,
     Text,

crates/emmylua_check/src/cmd_args.rs

@@ -4,9 +4,30 @@ use emmylua_code_analysis::{
     load_configs, load_workspace_files, update_code_style, EmmyLuaAnalysis, Emmyrc, LuaFileInfo,
 };
 
+fn root_from_configs(config_paths: &Vec<PathBuf>, fallback: &PathBuf) -> PathBuf {
+    if config_paths.len() > 1 {
+        fallback.clone()
+    } else {
+        let config_path = &config_paths[0];
+        // Need to convert to canonical path to ensure parent() is not an empty
+        // string in the case the path is a relative basename.
+        match config_path.canonicalize() {
+            Ok(path) => path.parent().unwrap().to_path_buf(),
+            Err(err) => {
+                log::error!(
+                    "Failed to canonicalize config path: \"{:?}\": {}",
+                    config_path,
+                    err
+                );
+                fallback.clone()
+            }
+        }
+    }
+}
+
 pub fn load_workspace(
     workspace_folder: PathBuf,
-    config_path: Option<PathBuf>,
+    config_paths: Option<Vec<PathBuf>>,
     ignore: Option<Vec<String>>,
 ) -> Option<EmmyLuaAnalysis> {
     let mut analysis = EmmyLuaAnalysis::new();
@@ -18,22 +39,27 @@ pub fn load_workspace(
     }
 
     let main_path = workspace_folders.first()?.clone();
-    let (config_files, config_root) = if let Some(config_path) = config_path {
-        (
-            vec![config_path.clone()],
-            config_path.parent().unwrap().to_path_buf(),
-        )
-    } else {
-        (
-            vec![
-                main_path.join(".luarc.json"),
-                main_path.join(".emmyrc.json"),
-            ],
-            main_path.clone(),
-        )
-    };
+    let (config_files, config_root): (Vec<PathBuf>, PathBuf) =
+        if let Some(config_paths) = config_paths {
+            (
+                config_paths.clone(),
+                root_from_configs(&config_paths, &main_path),
+            )
+        } else {
+            (
+                vec![
+                    main_path.join(".luarc.json"),
+                    main_path.join(".emmyrc.json"),
+                ],
+                main_path.clone(),
+            )
+        };
 
     let mut emmyrc = load_configs(config_files, None);
+    log::info!(
+        "Pre processing configurations using root: \"{}\"",
+        config_root.display()
+    );
     emmyrc.pre_process_emmyrc(&config_root);
 
     for root in &emmyrc.workspace.workspace_roots {
@@ -110,23 +136,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 => {

crates/emmylua_check/src/main.rs

@@ -25,18 +25,33 @@ pub async fn output_result(
 
     let mut has_error = false;
     let mut count = 0;
+    let mut error_count = 0;
+    let mut warning_count = 0;
+    let mut info_count = 0;
+    let mut hint_count = 0;
+
     while let Some((file_id, diagnostics)) = receiver.recv().await {
         count += 1;
         if let Some(diagnostics) = diagnostics {
             for diagnostic in &diagnostics {
-                if diagnostic.severity == Some(lsp_types::DiagnosticSeverity::ERROR) {
-                    has_error = true;
-                    break;
-                } else if warnings_as_errors
-                    && diagnostic.severity == Some(lsp_types::DiagnosticSeverity::WARNING)
-                {
-                    has_error = true;
-                    break;
+                match diagnostic.severity {
+                    Some(lsp_types::DiagnosticSeverity::ERROR) => {
+                        has_error = true;
+                        error_count += 1;
+                    }
+                    Some(lsp_types::DiagnosticSeverity::WARNING) => {
+                        if warnings_as_errors {
+                            has_error = true;
+                        }
+                        warning_count += 1;
+                    }
+                    Some(lsp_types::DiagnosticSeverity::INFORMATION) => {
+                        info_count += 1;
+                    }
+                    Some(lsp_types::DiagnosticSeverity::HINT) => {
+                        hint_count += 1;
+                    }
+                    _ => {}
                 }
             }
             writer.write(db, file_id, diagnostics);
@@ -49,6 +64,21 @@ pub async fn output_result(
 
     writer.finish();
 
+    if output_format == OutputFormat::Text {
+        if error_count > 0 {
+            println!("Errors: {}", error_count);
+        }
+        if warning_count > 0 {
+            println!("Warnings: {}", warning_count);
+        }
+        if info_count > 0 {
+            println!("Information: {}", info_count);
+        }
+        if hint_count > 0 {
+            println!("Hints: {}", hint_count);
+        }
+    }
+
     if has_error {
         1
     } else {