enhance ignore

Author: CppCXY

Cargo.lock

@@ -34,3 +34,4 @@ serde_yml.workspace = true
 itertools.workspace = true
 dirs.workspace = true
 clap.workspace = true
+wax.workspace = true

crates/emmylua_ls/Cargo.toml

@@ -17,6 +17,7 @@ use std::{collections::HashMap, future::Future, sync::Arc};
 use tokio::sync::{Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
 pub use workspace_manager::load_emmy_config;
+pub use workspace_manager::WorkspaceFileMatcher;
 pub use workspace_manager::WorkspaceManager;
 
 pub struct ServerContext {

crates/emmylua_ls/src/context/mod.rs

@@ -1,15 +1,17 @@
 use std::collections::HashSet;
+use std::path::Path;
 use std::{path::PathBuf, sync::Arc, time::Duration};
 
 use super::{ClientProxy, FileDiagnostic, StatusBar};
 use crate::handlers::{init_analysis, ClientConfig};
 use dirs;
-use emmylua_code_analysis::update_code_style;
 use emmylua_code_analysis::{load_configs, EmmyLuaAnalysis, Emmyrc};
+use emmylua_code_analysis::{update_code_style, uri_to_file_path};
 use log::{debug, info};
 use lsp_types::Uri;
 use tokio::sync::{Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
+use wax::Pattern;
 
 pub struct WorkspaceManager {
     analysis: Arc<RwLock<EmmyLuaAnalysis>>,
@@ -21,6 +23,7 @@ pub struct WorkspaceManager {
     pub workspace_folders: Vec<PathBuf>,
     pub watcher: Option<notify::RecommendedWatcher>,
     pub current_open_files: HashSet<Uri>,
+    pub match_file_pattern: WorkspaceFileMatcher,
 }
 
 impl WorkspaceManager {
@@ -40,6 +43,7 @@ impl WorkspaceManager {
             file_diagnostic,
             watcher: None,
             current_open_files: HashSet::new(),
+            match_file_pattern: WorkspaceFileMatcher::default(),
         }
     }
 
@@ -163,6 +167,30 @@ impl WorkspaceManager {
 
         Some(())
     }
+
+    pub fn is_workspace_file(&self, uri: &Uri) -> bool {
+        if self.workspace_folders.is_empty() {
+            return true;
+        }
+
+        let Some(file_path) = uri_to_file_path(&uri) else {
+            return true;
+        };
+
+        let mut file_matched = true;
+        for workspace in &self.workspace_folders {
+            if let Ok(relative) = file_path.strip_prefix(workspace) {
+                file_matched = self.match_file_pattern.is_match(&file_path, relative);
+
+                if file_matched {
+                    // If the file matches the include pattern, we can stop checking further.
+                    break;
+                }
+            }
+        }
+
+        file_matched
+    }
 }
 
 pub fn load_emmy_config(config_root: Option<PathBuf>, client_config: ClientConfig) -> Arc<Emmyrc> {
@@ -304,3 +332,51 @@ impl ReindexToken {
         *need_re_sleep = true;
     }
 }
+
+#[derive(Debug, Clone)]
+pub struct WorkspaceFileMatcher {
+    include: Vec<String>,
+    exclude: Vec<String>,
+    exclude_dir: Vec<PathBuf>,
+}
+
+impl WorkspaceFileMatcher {
+    pub fn new(include: Vec<String>, exclude: Vec<String>, exclude_dir: Vec<PathBuf>) -> Self {
+        Self {
+            include,
+            exclude,
+            exclude_dir,
+        }
+    }
+    pub fn is_match(&self, path: &Path, relative_path: &Path) -> bool {
+        if self.exclude_dir.iter().any(|dir| path.starts_with(dir)) {
+            return false;
+        }
+
+        // let path_str = path.to_string_lossy().to_string().replace("\\", "/");
+        let exclude_matcher = wax::any(self.exclude.iter().map(|s| s.as_str()));
+        if let Ok(exclude_set) = exclude_matcher {
+            if exclude_set.is_match(relative_path) {
+                return false;
+            }
+        } else {
+            log::error!("Invalid exclude pattern");
+        }
+
+        let include_matcher = wax::any(self.include.iter().map(|s| s.as_str()));
+        if let Ok(include_set) = include_matcher {
+            return include_set.is_match(relative_path);
+        } else {
+            log::error!("Invalid include pattern");
+        }
+
+        return true;
+    }
+}
+
+impl Default for WorkspaceFileMatcher {
+    fn default() -> Self {
+        let include_pattern = vec!["**/*.lua".to_string()];
+        Self::new(include_pattern, vec![], vec![])
+    }
+}

crates/emmylua_ls/src/context/workspace_manager.rs

@@ -9,9 +9,12 @@ use crate::{
     cmd_args::CmdArgs,
     context::{
         get_client_id, load_emmy_config, ClientId, ClientProxy, FileDiagnostic, ProgressTask,
-        ServerContextSnapshot, StatusBar,
+        ServerContextSnapshot, StatusBar, WorkspaceFileMatcher,
+    },
+    handlers::{
+        initialized::collect_files::calculate_include_and_exclude,
+        text_document::register_files_watch,
     },
-    handlers::text_document::register_files_watch,
     logger::init_logger,
 };
 pub use client_config::{get_client_config, ClientConfig};
@@ -59,6 +62,8 @@ pub async fn initialized_handler(
     let mut workspace_manager = context.workspace_manager.write().await;
     workspace_manager.workspace_folders = workspace_folders.clone();
     workspace_manager.client_config = client_config.clone();
+    let (include, exclude, exclude_dir) = calculate_include_and_exclude(&emmyrc);
+    workspace_manager.match_file_pattern = WorkspaceFileMatcher::new(include, exclude, exclude_dir);
     drop(workspace_manager);
     // let file_diagnostic = context.file_diagnostic.clone();
 

crates/emmylua_ls/src/handlers/initialized/mod.rs

@@ -14,6 +14,14 @@ pub async fn on_did_open_text_document(
     let mut analysis = context.analysis.write().await;
     let uri = params.text_document.uri;
     let text = params.text_document.text;
+    let old_file_id = analysis.get_file_id(&uri);
+    // check is filter file
+    if old_file_id.is_none() {
+        let workspace_manager = context.workspace_manager.read().await;
+        if !workspace_manager.is_workspace_file(&uri) {
+            return None;
+        }
+    }
 
     let file_id = analysis.update_file_by_uri(&uri, Some(text));
     let emmyrc = analysis.get_emmyrc();
@@ -60,6 +68,15 @@ pub async fn on_did_change_text_document(
     let mut analysis = context.analysis.write().await;
     let uri = params.text_document.uri;
     let text = params.content_changes.first()?.text.clone();
+    let old_file_id = analysis.get_file_id(&uri);
+    // check is filter file
+    if old_file_id.is_none() {
+        let workspace_manager = context.workspace_manager.read().await;
+        if !workspace_manager.is_workspace_file(&uri) {
+            return None;
+        }
+    }
+
     let file_id = analysis.update_file_by_uri(&uri, Some(text));
     let emmyrc = analysis.get_emmyrc();
     let interval = emmyrc.diagnostics.diagnostic_interval.unwrap_or(500);

crates/emmylua_ls/src/handlers/text_document/text_document_handler.rs

@@ -24,6 +24,10 @@ pub async fn on_did_change_watched_files(
                 }
 
                 if !workspace.current_open_files.contains(&file_event.uri) {
+                    if !workspace.is_workspace_file(&file_event.uri) {
+                        continue;
+                    }
+
                     collect_lua_files(
                         &mut watched_lua_files,
                         file_event.uri,