new features

Author: Andcool-Systems

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "css-linter"
-version = "1.8.2"
+version = "1.9.0"
 edition = "2021"
 
 [dependencies]
@@ -11,3 +11,4 @@ swc_ecma_ast = "8.0.0"
 swc_ecma_parser = { version = "10.0.0", features = ["typescript"] }
 swc_ecma_visit = "8.0.0"
 anyhow = "1.0.97"
+regex = "1.11.1"

src/main.rs

@@ -1,70 +1,34 @@
-use std::{
-    collections::{HashMap, HashSet},
-    env, fs,
-    path::{Path, PathBuf},
-    process,
-};
+use std::{env, process};
 
 use anyhow::Result;
-use config::get_compiler_options;
-use css_parser::{extract_classes, ClassName};
-use tsx_parser::{extract_default_css_imports, extract_used_classes, UsedClassName};
-use utils::{process_relative_import, replace_aliases};
+use modules::{
+    css_class::get_class_body, defined_classes::get_defined_classes, linter,
+    styles_imports::get_styles_imports,
+};
 
 mod config;
-mod css_parser;
-mod tsx_parser;
+mod modules;
+mod parsers;
 mod utils;
 
-fn list_files_in_directory(path: PathBuf, exclude: Vec<String>) -> Vec<String> {
-    let mut files = Vec::new();
-
-    if let Ok(entries) = fs::read_dir(&path) {
-        for entry in entries.flatten() {
-            let path = entry.path();
-
-            if path.is_dir() {
-                if let Some(p) = path.file_name() {
-                    let p_str = p.to_string_lossy();
-                    if p_str.starts_with('.') || exclude.iter().any(|i| p_str == *i) {
-                        continue;
-                    }
-                }
-                files.extend(list_files_in_directory(path, exclude.clone()));
-            } else if path.is_file() {
-                if let Some(path_str) = path.to_str() {
-                    files.push(path_str.to_string());
-                }
-            }
-        }
-    } else {
-        eprintln!("Cannot open target dir: {:?}", path);
-    }
-
-    files
-}
-
 fn main() -> Result<()> {
-    const COLOR_BLUE: &str = "\x1b[34m";
-    const COLOR_YELLOW: &str = "\x1b[33m";
-    const COLOR_GREEN: &str = "\x1b[32m";
     const COLOR_RED: &str = "\x1b[31m";
     const COLOR_RESET: &str = "\u{001B}[0m";
 
     let args: Vec<String> = env::args().collect();
+    if let Ok(cwd) = std::env::var("cwd") {
+        env::set_current_dir(cwd)?;
+    }
 
-    let path = match args.get(1) {
+    match args.get(1) {
         Some(arg) if arg == "-v" => {
-            println!("v{}", env!("CARGO_PKG_VERSION"));
+            print!("v{}", env!("CARGO_PKG_VERSION"));
             process::exit(0);
         }
-        Some(arg) if arg == "--lint" => args.get(2).unwrap_or_else(|| {
-            eprintln!(
-                "\n{}Error{}: Linting path must be specified",
-                COLOR_RED, COLOR_RESET
-            );
-            process::exit(1);
-        }),
+        Some(arg) if arg == "--lint" => linter::lint()?,
+        Some(arg) if arg == "--imports" => get_styles_imports()?,
+        Some(arg) if arg == "--classes" => get_defined_classes()?,
+        Some(arg) if arg == "--class" => get_class_body()?,
         Some(arg) => {
             eprintln!(
                 "{}Error{}: Invalid argument: {}",
@@ -75,178 +39,5 @@ fn main() -> Result<()> {
         None => todo!(),
     };
 
-    let minify = args.get(3).map_or("", |v| v) == "--minify";
-
-    if let Err(e) = env::set_current_dir(Path::new(path)) {
-        eprintln!(
-            "\n{}Error{}: Failed to set current directory: {}",
-            COLOR_RED, COLOR_RESET, e
-        );
-        process::exit(1);
-    }
-    let tsconfig = get_compiler_options().unwrap_or_else(|e| {
-        eprintln!(
-            "\n{}Error{}: Could not load tsconfig.json. Is the provided directory a typescript project? ({})",
-            COLOR_RED, COLOR_RESET, e
-        );
-        process::exit(1);
-    });
-
-    let dir = list_files_in_directory(Path::new(".").to_path_buf(), tsconfig.exclude);
-
-    let mut used_classnames: HashMap<String, HashSet<UsedClassName>> = Default::default();
-    let mut defined_classnames: HashMap<String, HashSet<ClassName>> = Default::default();
-
-    for entry in &dir {
-        let path = entry.replace("\\", "/");
-
-        if path.ends_with(".tsx") {
-            let code = fs::read_to_string(entry)?;
-            let imported_css = extract_default_css_imports(&code).unwrap_or_else(|e| {
-                eprintln!("Could not parse file: {}\n{}", entry, e);
-                process::exit(1);
-            });
-
-            for (mut style_path, class_names) in imported_css {
-                process_relative_import(Path::new(entry), &mut style_path)?;
-                replace_aliases(&mut style_path, tsconfig.compiler_options.paths.clone());
-
-                let used_fields = extract_used_classes(&code, &class_names, path.clone())
-                    .unwrap_or_else(|e| {
-                        eprintln!("Could not parse file: {}\n{}", entry, e);
-                        process::exit(1);
-                    });
-
-                used_classnames
-                    .entry(style_path)
-                    .or_insert_with(HashSet::new)
-                    .extend(used_fields);
-            }
-        } else if path.ends_with(".module.css") {
-            let code = fs::read_to_string(entry)?;
-            let classes = extract_classes(&code);
-            defined_classnames
-                .entry(path)
-                .or_insert_with(HashSet::new)
-                .extend(classes);
-        }
-    }
-
-    let mut files_count = 0;
-    let mut errors_count = 0;
-
-    for (css_file, mut classes_tsx) in defined_classnames.clone() {
-        if let Some(used_css) = used_classnames.get(&css_file) {
-            let used_css_flatten: Vec<String> =
-                used_css.iter().map(|v| v.class_name.clone()).collect();
-            classes_tsx.retain(|v| !used_css_flatten.contains(&v.class_name));
-        }
-
-        if classes_tsx.is_empty() {
-            continue;
-        }
-
-        files_count += 1;
-        errors_count += classes_tsx.len();
-
-        if !minify {
-            println!("{}{}{}", COLOR_BLUE, css_file, COLOR_RESET);
-        }
-
-        for extra in classes_tsx {
-            if !minify {
-                println!(
-                    "{}{}:{}  {}Warn{}: Unused class `{}` found.",
-                    COLOR_YELLOW,
-                    extra.line_index + 1,
-                    extra.column_index + 1,
-                    COLOR_YELLOW,
-                    COLOR_RESET,
-                    extra.class_name
-                );
-            } else {
-                println!(
-                    "{}:{}:{}:{}:\"{}\": Unused class found.",
-                    css_file,
-                    extra.line_index + 1,
-                    extra.column_index + 1,
-                    extra.class_name.len(),
-                    extra.class_name
-                );
-            }
-        }
-
-        if !minify {
-            println!();
-        }
-    }
-
-    let mut undefined_classes: HashMap<String, HashSet<UsedClassName>> = HashMap::new();
-
-    for (tsx_file, mut classes) in used_classnames {
-        if let Some(defined_css) = defined_classnames.get(&tsx_file) {
-            let defined_css: HashSet<String> =
-                defined_css.iter().map(|v| v.class_name.clone()).collect();
-            classes.retain(|v| !defined_css.contains(v.class_name.as_str()));
-        }
-
-        if classes.is_empty() {
-            continue;
-        }
-
-        files_count += 1;
-        errors_count += classes.len();
-
-        for extra in classes {
-            undefined_classes
-                .entry(extra.file_name.clone())
-                .or_insert_with(HashSet::new)
-                .insert(extra);
-        }
-    }
-
-    for undefined in undefined_classes {
-        if !minify {
-            println!("{}{}{}", COLOR_BLUE, undefined.0, COLOR_RESET);
-        }
-        for extra in undefined.1 {
-            if !minify {
-                println!(
-                    "{}{}:{}  {}Warn{}: Undefined class `{}` was used.",
-                    COLOR_YELLOW,
-                    extra.line,
-                    extra.column + 1,
-                    COLOR_YELLOW,
-                    COLOR_RESET,
-                    extra.class_name
-                );
-            } else {
-                println!(
-                    "{}:{}:{}:{}:\"{}\": Undefined class was used.",
-                    undefined.0,
-                    extra.line,
-                    extra.column + 1,
-                    extra.class_name.len(),
-                    extra.class_name
-                );
-            }
-        }
-
-        if !minify {
-            println!();
-        }
-    }
-
-    if !minify {
-        if errors_count == 0 {
-            println!("{}✔{} No CSS lint warnings found", COLOR_GREEN, COLOR_RESET);
-        } else {
-            println!(
-                "Found {}{} warnings{} in {} files",
-                COLOR_YELLOW, errors_count, COLOR_RESET, files_count
-            );
-        }
-    }
-
     Ok(())
 }

src/modules/css_class.rs

@@ -0,0 +1,47 @@
+use std::{env, fs, process};
+
+use anyhow::Result;
+use regex::Regex;
+
+pub fn get_class_body() -> Result<()> {
+    const COLOR_RED: &str = "\x1b[31m";
+    const COLOR_RESET: &str = "\u{001B}[0m";
+
+    let args: Vec<String> = env::args().collect();
+    let path = match args.get(2) {
+        Some(path) if !path.ends_with(".module.css") => {
+            eprintln!("{}Error{}: Invalid file extension.", COLOR_RED, COLOR_RESET);
+            process::exit(1);
+        }
+        Some(path) => path,
+        None => {
+            eprintln!("Path to the file must be provided");
+            process::exit(1);
+        }
+    };
+
+    let class_name = args.get(3).unwrap_or_else(|| {
+        eprintln!("Class name must be provided");
+        process::exit(1);
+    });
+
+    let code = fs::read_to_string(path)?;
+    let pattern = format!(
+        r"\.{}[^A-Za-z0-9_-][^{{}}]*\{{[^}}]*\}}",
+        regex::escape(class_name)
+    );
+    let re = Regex::new(&pattern)?;
+
+    for m in re.find_iter(&code) {
+        if m.as_str().starts_with(&format!(".{}", class_name)) {
+            let trimmed = m.as_str().trim_start();
+
+            match trimmed {
+                s if s.starts_with('.') || s.ends_with('}') => print!("{}", trimmed),
+                _ => print!("    {}", trimmed),
+            }
+            break;
+        }
+    }
+    Ok(())
+}

src/modules/defined_classes.rs

@@ -0,0 +1,37 @@
+use std::{env, fs, process};
+
+use anyhow::Result;
+
+use crate::parsers::extract_classes;
+
+pub fn get_defined_classes() -> Result<()> {
+    const COLOR_RED: &str = "\x1b[31m";
+    const COLOR_RESET: &str = "\u{001B}[0m";
+
+    let args: Vec<String> = env::args().collect();
+    let path = match args.get(2) {
+        Some(path) if !path.ends_with(".module.css") => {
+            eprintln!("{}Error{}: Invalid file extension.", COLOR_RED, COLOR_RESET);
+            process::exit(1);
+        }
+        Some(path) => path,
+        None => {
+            eprintln!("Path to the file must be provided");
+            process::exit(1);
+        }
+    };
+
+    let code = fs::read_to_string(path)?;
+    let imported_css = extract_classes(&code);
+
+    imported_css
+        .iter()
+        .try_for_each(|class_name| -> Result<()> {
+            println!(
+                "{}:{}:{}",
+                class_name.class_name, class_name.line_index, class_name.column_index
+            );
+            Ok(())
+        })?;
+    Ok(())
+}