initial commit

Author: Andcool-Systems

.gitignore

@@ -0,0 +1,3 @@
+.vscode
+target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "css-linter"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde_json = "1.0.140"
+serde = { version = "1.0.217", features = ["derive"] }
+swc_common = "8.0.0"
+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"

Readme.md

@@ -0,0 +1,4 @@
+# Next.Js CSS modules using linter
+
+## Description
+Coming soon

src/config.rs

@@ -0,0 +1,27 @@
+use std::{collections::HashMap, fs};
+
+use serde::Deserialize;
+
+#[derive(Deserialize, Debug)]
+pub struct CompilerOptions {
+    pub paths: HashMap<String, Vec<String>>,
+}
+
+#[derive(Deserialize, Debug)]
+pub struct Properties {
+    #[serde(rename(deserialize = "compilerOptions"))]
+    pub compiler_options: CompilerOptions,
+    pub exclude: Vec<String>,
+}
+
+pub fn get_compiler_options() -> Properties {
+    let tsconfig_contents = fs::read_to_string("tsconfig.json")
+        .expect("Could not load tsconfig. Is the provided directory is typescript project?");
+
+    let v: Properties = match serde_json::from_str(&tsconfig_contents) {
+        Ok(res) => res,
+        Err(err) => panic!("{}", err),
+    };
+
+    v
+}

src/css_parser.rs

@@ -0,0 +1,91 @@
+use std::collections::HashSet;
+
+fn is_char(c: char) -> bool {
+    c.is_alphabetic() || c.is_numeric() || c == '_' || c == '-'
+}
+
+fn is_first_char_numeric(buffer: &str) -> bool {
+    buffer.chars().next().map_or(false, |c| c.is_numeric())
+}
+
+#[derive(Eq, Hash, PartialEq, Clone)]
+pub struct ClassName {
+    pub class_name: String,
+    pub line_index: usize,
+    pub column_index: usize,
+}
+
+pub fn extract_classes(css_content: &str) -> HashSet<ClassName> {
+    let mut defined_classes: HashSet<ClassName> = HashSet::new();
+    const DISABLE_RULE_FLAG: &str = "css-lint-disable-rule ";
+    let mut skip_lines_remaining = 0;
+
+    for (index, line) in css_content.split('\n').enumerate() {
+        let stripped_line = line.trim_start();
+
+        if stripped_line.starts_with("/*") {
+            let comment_content = stripped_line
+                .trim_start_matches("/*")
+                .trim_end_matches("*/")
+                .trim();
+
+            if let Some(rest) = comment_content.strip_prefix(DISABLE_RULE_FLAG) {
+                if rest.trim_start().starts_with("unused-class") {
+                    skip_lines_remaining = 2;
+                }
+            }
+        }
+        if skip_lines_remaining != 0 {
+            skip_lines_remaining -= 1;
+            continue;
+        }
+
+        if !stripped_line.starts_with('.') {
+            continue;
+        }
+
+        let mut buffer: String = String::new();
+        let mut is_class = true;
+        let mut start_index = 0;
+        for (column_index, symbol) in stripped_line.chars().enumerate() {
+            match symbol {
+                '.' => {
+                    if !buffer.is_empty() && !is_first_char_numeric(&buffer) {
+                        defined_classes.insert(ClassName {
+                            class_name: buffer.clone(),
+                            line_index: index,
+                            column_index: start_index,
+                        });
+                    }
+                    buffer.clear();
+                    start_index = column_index;
+                    is_class = true;
+                }
+                char_i => {
+                    if is_class && is_char(char_i) {
+                        buffer.push(char_i);
+                    } else if !buffer.is_empty() {
+                        if !is_first_char_numeric(&buffer) {
+                            defined_classes.insert(ClassName {
+                                class_name: buffer.clone(),
+                                line_index: index,
+                                column_index: start_index,
+                            });
+                        }
+                        buffer.clear();
+                        is_class = false;
+                    }
+                }
+            }
+        }
+        if !buffer.is_empty() && !is_first_char_numeric(&buffer) {
+            defined_classes.insert(ClassName {
+                class_name: buffer,
+                line_index: index,
+                column_index: start_index,
+            });
+        }
+    }
+
+    defined_classes
+}

src/main.rs

@@ -0,0 +1,146 @@
+use std::{
+    collections::{HashMap, HashSet},
+    env, fs,
+    path::{Path, PathBuf},
+    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};
+use utils::{process_relative_import, replace_aliases};
+
+mod config;
+mod css_parser;
+mod tsx_parser;
+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();
+    let path = args.get(1).unwrap_or_else(|| {
+        eprintln!(
+            "\n{}Error{}: Linting path must be specified",
+            COLOR_RED, COLOR_RESET
+        );
+        process::exit(1);
+    });
+
+    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();
+
+    let dir = list_files_in_directory(Path::new(".").to_path_buf(), tsconfig.exclude);
+
+    let mut used_classnames: HashMap<String, HashSet<String>> = 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);
+
+            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);
+                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;
+    println!(); // Initial spacing
+
+    for (css_file, mut classes) in defined_classnames {
+        if let Some(used_css) = used_classnames.get(&css_file) {
+            classes.retain(|v| !used_css.contains(&v.class_name));
+        }
+
+        if classes.is_empty() {
+            continue;
+        }
+
+        files_count += 1;
+        errors_count += classes.len();
+
+        println!("{}{}{}", COLOR_BLUE, css_file, COLOR_RESET);
+        for extra in classes {
+            println!(
+                "{}{}:{}  {}Warn{}: Unused class `{}` found",
+                COLOR_YELLOW,
+                extra.line_index + 1,
+                extra.column_index + 1,
+                COLOR_YELLOW,
+                COLOR_RESET,
+                extra.class_name
+            );
+        }
+
+        println!();
+    }
+
+    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/tsx_parser.rs

@@ -0,0 +1,89 @@
+use std::collections::HashSet;
+use swc_common::{sync::Lrc, FileName, SourceMap};
+use swc_ecma_ast::{ImportSpecifier, Module, ModuleDecl};
+use swc_ecma_parser::{Parser, StringInput, Syntax, TsSyntax};
+use swc_ecma_visit::{Visit, VisitWith};
+
+pub fn module_parser(tsx_code: &str) -> Module {
+    let cm: Lrc<SourceMap> = Default::default();
+    let fm = cm.new_source_file(FileName::Custom("input.tsx".into()).into(), tsx_code.into());
+
+    let syntax = Syntax::Typescript(TsSyntax {
+        tsx: true,
+        decorators: false,
+        dts: false,
+        no_early_errors: false,
+        disallow_ambiguous_jsx_like: false,
+    });
+
+    let mut parser = Parser::new(syntax, StringInput::from(&*fm), None);
+
+    parser.parse_module().expect("Failed to parse")
+}
+
+struct PropertyFinder {
+    variable_name: String,
+    properties: HashSet<String>,
+}
+
+impl Visit for PropertyFinder {
+    fn visit_member_expr(&mut self, node: &swc_ecma_ast::MemberExpr) {
+        if let swc_ecma_ast::Expr::Ident(ref obj) = *node.obj {
+            if obj.sym == self.variable_name {
+                if let swc_ecma_ast::MemberProp::Ident(ref prop) = node.prop {
+                    self.properties.insert(prop.sym.to_string());
+                }
+            }
+        }
+
+        node.visit_children_with(self);
+    }
+}
+
+pub fn extract_used_classes(tsx_code: &str, variable_name: &str) -> HashSet<String> {
+    let module = module_parser(tsx_code);
+
+    let mut finder = PropertyFinder {
+        variable_name: variable_name.to_string(),
+        properties: HashSet::new(),
+    };
+
+    module.visit_with(&mut finder);
+
+    finder.properties
+}
+
+struct DefaultCssImportFinder {
+    imported_variables: HashSet<(String, String)>,
+}
+
+impl Visit for DefaultCssImportFinder {
+    fn visit_module(&mut self, node: &Module) {
+        for stmt in &node.body {
+            if let swc_ecma_ast::ModuleItem::ModuleDecl(ModuleDecl::Import(import)) = stmt {
+                if import.src.value.ends_with(".module.css") {
+                    for specifier in &import.specifiers {
+                        if let ImportSpecifier::Default(default) = specifier {
+                            self.imported_variables.insert((
+                                import.src.value.to_string(),
+                                default.local.sym.to_string(),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub fn extract_default_css_imports(tsx_code: &str) -> HashSet<(String, String)> {
+    let module = module_parser(tsx_code);
+
+    let mut finder = DefaultCssImportFinder {
+        imported_variables: HashSet::new(),
+    };
+
+    module.visit_with(&mut finder);
+
+    finder.imported_variables
+}