added references search

Author: Andcool-Systems

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "css-linter"
-version = "1.9.1"
+version = "1.9.2"
 edition = "2021"
 
 [dependencies]

src/main.rs

@@ -3,7 +3,7 @@ use std::env;
 use anyhow::Result;
 use modules::{
     css_class::get_class_body, defined_classes::get_defined_classes, help::print_help, linter,
-    styles_imports::get_styles_imports, version::get_version,
+    styles_imports::get_styles_imports, used_css::get_class_usages, version::get_version,
 };
 
 mod config;
@@ -23,6 +23,7 @@ fn main() -> Result<()> {
         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) if arg == "--usages" => get_class_usages()?,
         Some(_) => print_help(),
         None => print_help(),
     };

src/modules/linter.rs

@@ -23,7 +23,7 @@ pub fn lint() -> Result<()> {
     let args: Vec<String> = env::args().collect();
 
     let path = args.get(2).unwrap_or_else(|| {
-        eprintln!("Path to the file must be provided");
+        eprintln!("Path to the workplace must be provided");
         process::exit(1);
     });
 

src/modules/mod.rs

@@ -3,4 +3,5 @@ pub mod defined_classes;
 pub mod linter;
 pub mod styles_imports;
 pub mod version;
-pub mod help;
+pub mod help;
+pub mod used_css;

src/modules/used_css.rs

@@ -0,0 +1,85 @@
+use std::{env, fs, path::Path, process};
+
+use anyhow::Result;
+
+use crate::{
+    config::get_compiler_options,
+    parsers::{extract_default_css_imports, extract_used_classes},
+    utils::{list_files_in_directory, process_relative_import, replace_aliases},
+};
+
+pub fn get_class_usages() -> Result<()> {
+    const COLOR_RED: &str = "\x1b[31m";
+    const COLOR_RESET: &str = "\u{001B}[0m";
+
+    let args: Vec<String> = env::args().collect();
+
+    let file = args.get(2).unwrap_or_else(|| {
+        eprintln!("Path to the file must be provided");
+        process::exit(1);
+    });
+
+    let workplace_path = env::current_dir()?;
+    let target_file = match Path::new(file).strip_prefix(workplace_path) {
+        Ok(f) => f,
+        Err(_) => {
+            eprintln!("Path to the file must be relative to the current directory");
+            process::exit(1);
+        }
+    };
+
+    let class_name = args.get(3).unwrap_or_else(|| {
+        eprintln!("Class name must be provided");
+        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);
+    for entry in &dir {
+        let path = entry.replace("\\", "/");
+
+        if path.ends_with(".tsx") || path.ends_with(".jsx") {
+            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());
+
+                if target_file.to_string_lossy().replace("\\", "/") != style_path.replace("./", "")
+                {
+                    continue;
+                }
+
+                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);
+                    });
+
+                for field in used_fields {
+                    if field.class_name == *class_name {
+                        println!(
+                            "{}:{}:{}:{}",
+                            path,
+                            field.line,
+                            field.column,
+                            field.class_name.len()
+                        );
+                    }
+                }
+            }
+        }
+    }
+    Ok(())
+}

vscode-ext/package.json

@@ -2,7 +2,7 @@
   "name": "next-css-lint",
   "displayName": "Next.Js CSS linter",
   "description": "A Rust-based VSCode extension that adds tools for working with CSS modules in React and Next.Js",
-  "version": "1.8.2",
+  "version": "1.8.3",
   "license": "MIT",
   "repository": "https://github.com/Andcool-Systems/css-linter",
   "author": {

vscode-ext/src/extension.ts

@@ -6,6 +6,7 @@ import { run_diag } from './diagnostics';
 import { CssCompletionProvider } from './autocomplete';
 import { CSSHoverProvider } from './hover';
 import { convert_css } from './convert';
+import { CSSReferenceProvider } from './usages';
 
 const fileFilter = [
     { scheme: 'file', language: 'javascriptreact' },
@@ -24,6 +25,7 @@ export function activate(context: vscode.ExtensionContext) {
     const css_definition = new CssModuleDefinitionProvider();
     const css_completion = new CssCompletionProvider();
     const css_hover = new CSSHoverProvider();
+    const css_references = new CSSReferenceProvider();
 
     let save_evt = vscode.workspace.onDidSaveTextDocument(() => run_diag(diagnosticCollection));
     let code_action = vscode.languages.registerCodeActionsProvider(
@@ -42,12 +44,14 @@ export function activate(context: vscode.ExtensionContext) {
     );
     let hover_provider = vscode.languages.registerHoverProvider(fileFilter, css_hover);
     let extractor = vscode.commands.registerCommand('next-css-lint.convert-inline', convert_css);
+    let css_reference_provider = vscode.languages.registerReferenceProvider('css', css_references);
 
     const enable_command = vscode.commands.registerCommand('next-css-lint.enable', async () => {
         await config.update('enabled', true, vscode.ConfigurationTarget.Workspace);
         save_evt = vscode.workspace.onDidSaveTextDocument(() => run_diag(diagnosticCollection));
         hover_provider = vscode.languages.registerHoverProvider(fileFilter, css_hover);
         extractor = vscode.commands.registerCommand('next-css-lint.convert-inline', convert_css);
+        css_reference_provider = vscode.languages.registerReferenceProvider('css', css_references);
         code_action = vscode.languages.registerCodeActionsProvider(
             'css',
             fix_provider,
@@ -71,7 +75,8 @@ export function activate(context: vscode.ExtensionContext) {
                     definition_provider,
                     completion_provider,
                     hover_provider,
-                    extractor
+                    extractor,
+                    css_reference_provider
                 );
                 run_diag(diagnosticCollection);
             })
@@ -101,7 +106,8 @@ export function activate(context: vscode.ExtensionContext) {
                     definition_provider,
                     completion_provider,
                     hover_provider,
-                    extractor
+                    extractor,
+                    css_reference_provider
                 );
                 run_diag(diagnosticCollection);
             })

vscode-ext/src/usages/index.ts

@@ -0,0 +1,45 @@
+import * as vscode from 'vscode';
+import { execAsync, getExecPath } from '../utils';
+import { join } from 'path';
+
+export class CSSReferenceProvider implements vscode.ReferenceProvider {
+    async provideReferences(
+        document: vscode.TextDocument,
+        position: vscode.Position,
+        context: vscode.ReferenceContext,
+        token: vscode.CancellationToken
+    ): Promise<vscode.Location[] | null | undefined> {
+        const wordRange = document.getWordRangeAtPosition(position, /[a-zA-Z0-9_-]+/);
+        if (!wordRange) return null;
+
+        const exec_path = getExecPath();
+        const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+        if (!workspacePath) {
+            return null;
+        }
+
+        const className = document.getText(wordRange);
+        const used_classes = await execAsync(
+            `${exec_path} --usages ${document.uri.fsPath} ${className}`,
+            {
+                cwd: workspacePath
+            }
+        );
+        console.log(used_classes);
+        return used_classes
+            .split('\n')
+            .filter(Boolean)
+            .map(line => line.split(':'))
+            .map(usage => {
+                let path = usage[0];
+                if (usage[0].startsWith('.')) {
+                    path = join(workspacePath, usage[0]);
+                }
+                const file = vscode.Uri.file(path);
+                const line = parseInt(usage[1]) - 1;
+                const col = parseInt(usage[2]) + 1;
+                const len = parseInt(usage[3]);
+                return new vscode.Location(file, new vscode.Range(line, col, line, col + len));
+            });
+    }
+}