rubydex 0.2.8 → 0.2.9

data/rust/Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
   "rubydex",
-  "rubydex-mcp",
   "rubydex-sys",
 ]
 

data/rust/rubydex/src/config.rs

@@ -21,9 +21,9 @@ pub const DEFAULT_EXCLUDED_DIRECTORIES: &[&str] = &[
 /// Configuration coming from a config file
 #[derive(Debug, Default, Deserialize)]
 struct ConfigFile {
-    /// Paths to exclude from file discovery during indexing.
+    /// Patterns to exclude from file discovery during indexing.
     #[serde(default)]
-    exclude: Vec<PathBuf>,
+    exclude: Vec<Box<str>>,
 }
 
 /// Project configuration
@@ -31,8 +31,8 @@ struct ConfigFile {
 pub struct Config {
     /// Path to the workspace being analyzed
     workspace_path: Box<Path>,
-    /// Paths to exclude from file discovery during indexing.
-    excluded_paths: HashSet<PathBuf>,
+    /// Patterns to exclude from file discovery during indexing.
+    excluded_patterns: HashSet<Box<str>>,
 }
 assert_mem_size!(Config, 64);
 
@@ -50,7 +50,7 @@ impl Config {
             workspace_path: std::env::current_dir()
                 .unwrap_or_else(|_| PathBuf::from("."))
                 .into_boxed_path(),
-            excluded_paths: DEFAULT_EXCLUDED_DIRECTORIES.iter().map(PathBuf::from).collect(),
+            excluded_patterns: DEFAULT_EXCLUDED_DIRECTORIES.iter().map(|&dir| Box::from(dir)).collect(),
         }
     }
 
@@ -65,18 +65,24 @@ impl Config {
         self.workspace_path = workspace_path.into_boxed_path();
     }
 
-    /// Adds paths to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
+    /// Adds patterns to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
     /// directory traversal.
-    pub fn exclude_paths(&mut self, paths: impl IntoIterator<Item = PathBuf>) {
-        self.excluded_paths.extend(paths);
+    pub fn exclude_patterns(&mut self, patterns: impl IntoIterator<Item = Box<str>>) {
+        self.excluded_patterns.extend(patterns);
     }
 
-    /// Returns the set of paths excluded from file discovery
+    /// Returns the set of exclusion patterns resolved against the workspace path.
     #[must_use]
-    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
-        self.excluded_paths
+    pub fn excluded_patterns(&self) -> HashSet<Box<str>> {
+        self.excluded_patterns
             .iter()
-            .map(|path| self.workspace_path.join(path))
+            .map(|entry| {
+                self.workspace_path
+                    .join(&**entry)
+                    .to_string_lossy()
+                    .into_owned()
+                    .into_boxed_str()
+            })
             .collect()
     }
 
@@ -124,7 +130,7 @@ impl Config {
             Errors::ConfigError(format!("Invalid config file `{}`: {error}", config_path.display()))
         })?;
 
-        self.excluded_paths.extend(parsed.exclude);
+        self.excluded_patterns.extend(parsed.exclude);
         Ok(())
     }
 
@@ -139,19 +145,32 @@ mod tests {
     use super::*;
     use std::path::Path;
 
+    fn workspace_exclusion(entry: &str) -> String {
+        PathBuf::from("/workspace").join(entry).to_string_lossy().into_owned()
+    }
+
     #[test]
-    fn excluded_paths_are_resolved_against_the_workspace_path() {
+    fn excluded_patterns_resolves_patterns_against_the_workspace_path() {
         let mut config = Config::new();
         config.set_workspace_path(PathBuf::from("/workspace"));
-        config.exclude_paths([PathBuf::from("vendor"), PathBuf::from("/absolute/path")]);
-
-        let excluded = config.excluded_paths();
-
-        // Relative entries (including the defaults) are joined with the workspace path.
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/.git")));
-        // Absolute entries pass through unchanged.
-        assert!(excluded.contains(Path::new("/absolute/path")));
+        config.exclude_patterns([
+            Box::from("vendor"),
+            Box::from("**/fixtures"),
+            Box::from("/absolute/path"),
+        ]);
+
+        let excluded = config.excluded_patterns();
+
+        let vendor = workspace_exclusion("vendor");
+        let fixtures = workspace_exclusion("**/fixtures");
+        let absolute = PathBuf::from("/absolute/path").to_string_lossy().into_owned();
+        let git = workspace_exclusion(".git");
+
+        assert!(excluded.contains(vendor.as_str()));
+        assert!(excluded.contains(fixtures.as_str()));
+        assert!(excluded.contains(absolute.as_str()));
+        // Defaults are included and resolved as well.
+        assert!(excluded.contains(git.as_str()));
     }
 
     #[test]
@@ -160,14 +179,14 @@ mod tests {
 
         for default in DEFAULT_EXCLUDED_DIRECTORIES {
             assert!(
-                config.excluded_paths.contains(Path::new(default)),
+                config.excluded_patterns.contains(*default),
                 "expected `{default}` to be excluded by default"
             );
         }
     }
 
     #[test]
-    fn load_file_merges_excluded_paths_and_leaves_the_workspace_path_untouched() {
+    fn load_file_merges_excluded_patterns_and_leaves_the_workspace_path_untouched() {
         let dir = tempfile::tempdir().expect("failed to create temp dir");
         let config_path = dir.path().join("rubydex.toml");
         fs::write(&config_path, "exclude = [\"vendor\", \"generated\"]\n").unwrap();
@@ -179,12 +198,12 @@ mod tests {
             .load_file(&config_path)
             .expect("expected the config file to load");
 
-        let excluded = config.excluded_paths();
+        let excluded = config.excluded_patterns();
         // Entries from the file are merged in and resolved against the workspace path.
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/generated")));
+        assert!(excluded.contains(workspace_exclusion("vendor").as_str()));
+        assert!(excluded.contains(workspace_exclusion("generated").as_str()));
         // Defaults seeded at construction survive the merge.
-        assert!(excluded.contains(Path::new("/workspace/node_modules")));
+        assert!(excluded.contains(workspace_exclusion("node_modules").as_str()));
         // A config file cannot override the programmatically-set workspace path.
         assert_eq!(config.workspace_path(), Path::new("/workspace"));
     }
@@ -204,9 +223,9 @@ mod tests {
             .load_file(&dir.path().join("b.toml"))
             .expect("expected the second file to load");
 
-        let excluded = config.excluded_paths();
-        assert!(excluded.contains(Path::new("/workspace/vendor")));
-        assert!(excluded.contains(Path::new("/workspace/generated")));
+        let excluded = config.excluded_patterns();
+        assert!(excluded.contains(workspace_exclusion("vendor").as_str()));
+        assert!(excluded.contains(workspace_exclusion("generated").as_str()));
     }
 
     #[test]
@@ -244,7 +263,8 @@ mod tests {
         config.set_workspace_path(dir.path().to_path_buf());
         config.load_default().expect("expected rubydex.toml to load");
 
-        assert!(config.excluded_paths().contains(&dir.path().join("vendor")));
+        let expected = dir.path().join("vendor").to_string_lossy().into_owned();
+        assert!(config.excluded_patterns().contains(expected.as_str()));
     }
 
     #[test]
@@ -263,7 +283,7 @@ mod tests {
     }
 
     #[test]
-    fn parse_defaults_the_excluded_paths_to_empty_when_the_key_is_absent() {
+    fn parse_defaults_the_excluded_patterns_to_empty_when_the_key_is_absent() {
         let file = Config::parse("").expect("an empty config is valid");
         assert!(file.exclude.is_empty());
     }

data/rust/rubydex/src/listing.rs

@@ -3,9 +3,9 @@ use crate::{
     job_queue::{Job, JobQueue},
 };
 use crossbeam_channel::{Sender, unbounded};
+use glob::Pattern;
 use std::{
     collections::HashSet,
-    fs,
     hash::BuildHasher,
     path::{Path, PathBuf},
     sync::Arc,
@@ -16,7 +16,7 @@ pub struct FileDiscoveryJob {
     queue: Arc<JobQueue>,
     paths_tx: Sender<PathBuf>,
     errors_tx: Sender<Errors>,
-    excluded_paths: Arc<HashSet<PathBuf>>,
+    excluded_patterns: Arc<Vec<Pattern>>,
 }
 
 impl FileDiscoveryJob {
@@ -26,24 +26,17 @@ impl FileDiscoveryJob {
         queue: Arc<JobQueue>,
         paths_tx: Sender<PathBuf>,
         errors_tx: Sender<Errors>,
-        excluded_paths: Arc<HashSet<PathBuf>>,
+        excluded_patterns: Arc<Vec<Pattern>>,
     ) -> Self {
         Self {
             path,
             queue,
             paths_tx,
             errors_tx,
-            excluded_paths,
+            excluded_patterns,
         }
     }
-}
-
-fn is_indexable_file(path: &Path) -> bool {
-    path.extension()
-        .is_some_and(|ext| ext == "rb" || ext == "rake" || ext == "rbs" || ext == "ru")
-}
 
-impl FileDiscoveryJob {
     fn handle_file(&self, path: &Path) {
         if is_indexable_file(path) {
             self.paths_tx
@@ -52,29 +45,6 @@ impl FileDiscoveryJob {
         }
     }
 
-    fn handle_symlink(&self, path: &PathBuf) {
-        let Ok(canonicalized) = fs::canonicalize(path) else {
-            self.send_error(Errors::FileError(format!(
-                "Failed to canonicalize symlink: `{}`",
-                path.display(),
-            )));
-
-            return;
-        };
-
-        if self.excluded_paths.contains(&canonicalized) {
-            return;
-        }
-
-        self.queue.push(Box::new(FileDiscoveryJob::new(
-            canonicalized,
-            Arc::clone(&self.queue),
-            self.paths_tx.clone(),
-            self.errors_tx.clone(),
-            Arc::clone(&self.excluded_paths),
-        )));
-    }
-
     fn send_error(&self, error: Errors) {
         self.errors_tx
             .send(error)
@@ -84,64 +54,59 @@ impl FileDiscoveryJob {
 
 impl Job for FileDiscoveryJob {
     fn run(&self) {
-        if self.path.is_dir() {
-            let Ok(read_dir) = self.path.read_dir() else {
+        let Ok(read_dir) = self.path.read_dir() else {
+            if self.path.is_file() {
+                self.handle_file(&self.path);
+            } else {
                 self.send_error(Errors::FileError(format!(
                     "Failed to read directory `{}`",
+                    self.path.display()
+                )));
+            }
+
+            return;
+        };
+
+        for result in read_dir {
+            let Ok(entry) = result else {
+                self.send_error(Errors::FileError(format!(
+                    "Failed to read directory `{}`: {result:?}",
                     self.path.display(),
                 )));
 
-                return;
+                continue;
             };
 
-            for result in read_dir {
-                let Ok(entry) = result else {
-                    self.send_error(Errors::FileError(format!(
-                        "Failed to read directory `{}`: {result:?}",
-                        self.path.display(),
-                    )));
-
-                    continue;
-                };
-
-                let kind = entry.file_type().unwrap();
-
-                if kind.is_dir() {
-                    if self.excluded_paths.contains(&entry.path()) {
-                        continue;
-                    }
-
-                    self.queue.push(Box::new(FileDiscoveryJob::new(
-                        entry.path(),
-                        Arc::clone(&self.queue),
-                        self.paths_tx.clone(),
-                        self.errors_tx.clone(),
-                        Arc::clone(&self.excluded_paths),
-                    )));
-                } else if kind.is_file() {
-                    self.handle_file(&entry.path());
-                } else if kind.is_symlink() {
-                    self.handle_symlink(&entry.path());
-                } else {
-                    self.send_error(Errors::FileError(format!(
-                        "Path `{}` is not a file or directory",
-                        entry.path().display()
-                    )));
-                }
+            let path = entry.path();
+
+            if is_excluded(&self.excluded_patterns, &path) {
+                continue;
+            }
+
+            if entry.file_type().unwrap().is_dir() {
+                self.queue.push(Box::new(FileDiscoveryJob::new(
+                    path,
+                    Arc::clone(&self.queue),
+                    self.paths_tx.clone(),
+                    self.errors_tx.clone(),
+                    Arc::clone(&self.excluded_patterns),
+                )));
+            } else {
+                self.handle_file(&path);
             }
-        } else if self.path.is_file() {
-            self.handle_file(&self.path);
-        } else if self.path.is_symlink() {
-            self.handle_symlink(&self.path);
-        } else {
-            self.send_error(Errors::FileError(format!(
-                "Path `{}` is not a file or directory",
-                self.path.display()
-            )));
         }
     }
 }
 
+fn is_indexable_file(path: &Path) -> bool {
+    path.extension()
+        .is_some_and(|ext| ext == "rb" || ext == "rake" || ext == "rbs" || ext == "ru")
+}
+
+fn is_excluded(excluded_patterns: &[Pattern], path: &Path) -> bool {
+    excluded_patterns.iter().any(|pattern| pattern.matches_path(path))
+}
+
 /// Recursively collects all Ruby files for the given workspace and dependencies, returning a vector of document instances
 ///
 /// # Errors
@@ -154,34 +119,42 @@ impl Job for FileDiscoveryJob {
 #[must_use]
 pub fn collect_file_paths<S: BuildHasher>(
     paths: Vec<String>,
-    excluded: &HashSet<PathBuf, S>,
+    excluded: &HashSet<Box<str>, S>,
 ) -> (Vec<PathBuf>, Vec<Errors>) {
     let queue = Arc::new(JobQueue::new());
     let (files_tx, files_rx) = unbounded();
     let (errors_tx, errors_rx) = unbounded();
 
-    // Canonicalize the excluded paths since they may be symlinks
-    let excluded: Arc<HashSet<PathBuf>> = Arc::new(excluded.iter().filter_map(|p| fs::canonicalize(p).ok()).collect());
+    let excluded_patterns: Arc<Vec<Pattern>> =
+        Arc::new(excluded.iter().filter_map(|entry| Pattern::new(entry).ok()).collect());
 
     for path in paths {
-        let Ok(canonicalized) = fs::canonicalize(&path) else {
+        let Ok(path) = std::path::absolute(&path) else {
             errors_tx
-                .send(Errors::FileError(format!("Path `{path}` does not exist")))
+                .send(Errors::FileError(format!("Failed to resolve path `{path}`")))
                 .expect("errors receiver dropped before run completion");
 
             continue;
         };
 
-        if excluded.contains(&canonicalized) {
+        if !path.exists() {
+            errors_tx
+                .send(Errors::FileError(format!("Path `{}` does not exist", path.display())))
+                .expect("errors receiver dropped before run completion");
+
+            continue;
+        }
+
+        if is_excluded(&excluded_patterns, &path) {
             continue;
         }
 
         queue.push(Box::new(FileDiscoveryJob::new(
-            canonicalized,
+            path,
             Arc::clone(&queue),
             files_tx.clone(),
             errors_tx.clone(),
-            Arc::clone(&excluded),
+            Arc::clone(&excluded_patterns),
         )));
     }
 
@@ -205,7 +178,7 @@ mod tests {
     fn collect_document_paths_with_exclusions(
         context: &Context,
         paths: &[&str],
-        excluded: &HashSet<PathBuf>,
+        excluded: &HashSet<Box<str>>,
     ) -> (Vec<String>, Vec<Errors>) {
         let (files, errors) = collect_file_paths(
             paths
@@ -324,6 +297,31 @@ mod tests {
         );
     }
 
+    #[cfg(unix)]
+    #[test]
+    fn collect_files_emits_absolute_paths_for_relative_roots() {
+        let context = Context::new();
+        context.touch(PathBuf::from("project").join("foo.rb"));
+
+        // Express the project directory as a path relative to the process working directory.
+        let working_directory = std::env::current_dir().unwrap();
+        let mut relative_root = PathBuf::new();
+        for _ in 0..working_directory.components().count() - 1 {
+            relative_root.push("..");
+        }
+        let project = context.absolute_path_to("project");
+        let relative_root = relative_root.join(project.strip_prefix("/").unwrap());
+
+        let (files, errors) = collect_file_paths(vec![relative_root.to_string_lossy().into_owned()], &HashSet::new());
+
+        assert!(errors.is_empty());
+        assert!(!files.is_empty());
+        assert!(
+            files.iter().all(|path| path.is_absolute()),
+            "expected only absolute paths, got {files:?}"
+        );
+    }
+
     #[test]
     fn collect_files_excludes_directories() {
         let context = Context::new();
@@ -333,7 +331,7 @@ mod tests {
         context.touch(&excluded_file);
 
         let mut excluded = HashSet::new();
-        excluded.insert(context.absolute_path_to("excluded"));
+        excluded.insert(context.absolute_path_to("excluded").to_string_lossy().into());
 
         let (files, errors) = collect_document_paths_with_exclusions(&context, &["included", "excluded"], &excluded);
 
@@ -350,7 +348,7 @@ mod tests {
         context.touch(&nested);
 
         let mut excluded = HashSet::new();
-        excluded.insert(context.absolute_path_to("root/skip"));
+        excluded.insert("**/skip".into());
 
         let (files, errors) = collect_document_paths_with_exclusions(&context, &["root"], &excluded);
 
@@ -360,23 +358,82 @@ mod tests {
 
     #[cfg(unix)]
     #[test]
-    fn collect_files_excludes_symlinked_directories() {
+    fn collect_files_indexes_symlinked_files_at_their_own_path() {
         let context = Context::new();
-        let included = PathBuf::from("included").join("foo.rb");
-        let excluded_file = PathBuf::from("real_dir").join("bar.rb");
-        context.touch(&included);
-        context.touch(&excluded_file);
+        let target = PathBuf::from("outside").join("real.rb");
+        context.touch(&target);
+        context.mkdir("project");
+
+        // Create a symlink to a file outside the traversed tree: project/alias.rb -> outside/real.rb
+        std::os::unix::fs::symlink(
+            context.absolute_path_to("outside/real.rb"),
+            context.absolute_path_to("project/alias.rb"),
+        )
+        .unwrap();
+
+        let (files, errors) = collect_document_paths(&context, &["project"]);
+
+        assert!(errors.is_empty());
+        // The symlink is indexed at its own path, not resolved to the target.
+        let alias = PathBuf::from("project").join("alias.rb");
+        assert_eq!(files, [alias.to_str().unwrap().to_string()]);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn collect_files_does_not_follow_symlinked_directories() {
+        let context = Context::new();
+        let kept = PathBuf::from("project").join("foo.rb");
+        let outside = PathBuf::from("outside").join("bar.rb");
+        context.touch(&kept);
+        context.touch(&outside);
 
-        // Create a symlink: link -> real_dir
-        std::os::unix::fs::symlink(context.absolute_path_to("real_dir"), context.absolute_path_to("link")).unwrap();
+        // Create a symlink inside the traversed tree: project/link -> outside
+        std::os::unix::fs::symlink(
+            context.absolute_path_to("outside"),
+            context.absolute_path_to("project/link"),
+        )
+        .unwrap();
+
+        let (files, errors) = collect_document_paths(&context, &["project"]);
+
+        assert!(errors.is_empty());
+        // The symlinked directory is not followed, so `outside/bar.rb` is never reached.
+        assert_eq!(files, [kept.to_str().unwrap().to_string()]);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn collect_files_indexes_symlinked_directory_roots() {
+        let context = Context::new();
+        let target = PathBuf::from("real").join("foo.rb");
+        context.touch(&target);
+
+        // A symlink to a directory passed as an explicit root, as `Graph#workspace_paths` does via `File.directory?`.
+        std::os::unix::fs::symlink(context.absolute_path_to("real"), context.absolute_path_to("link")).unwrap();
+
+        let (files, errors) = collect_document_paths(&context, &["link"]);
+
+        assert!(errors.is_empty());
+        // The requested root is traversed; files are indexed under the requested (symlink) path.
+        let foo = PathBuf::from("link").join("foo.rb");
+        assert_eq!(files, [foo.to_str().unwrap().to_string()]);
+    }
+
+    #[test]
+    fn collect_files_excludes_nested_files_matching_globs() {
+        let context = Context::new();
+        let kept = PathBuf::from("lib").join("foo.rb");
+        let excluded_file = PathBuf::from("lib").join("version.rb");
+        context.touch(&kept);
+        context.touch(&excluded_file);
 
-        // Excluding the real directory while requesting to index the symlink should properly exclude the link
         let mut excluded = HashSet::new();
-        excluded.insert(context.absolute_path_to("real_dir"));
+        excluded.insert("**/version.rb".into());
 
-        let (files, errors) = collect_document_paths_with_exclusions(&context, &["included", "link"], &excluded);
+        let (files, errors) = collect_document_paths_with_exclusions(&context, &["lib"], &excluded);
 
         assert!(errors.is_empty());
-        assert_eq!(files, [included.to_str().unwrap().to_string()]);
+        assert_eq!(files, [kept.to_str().unwrap().to_string()]);
     }
 }

data/rust/rubydex/src/main.rs

@@ -134,7 +134,7 @@ fn main() {
     // Listing
 
     let (file_paths, errors) = time_it!(listing, {
-        listing::collect_file_paths(args.paths, &graph.excluded_paths())
+        listing::collect_file_paths(args.paths, &graph.excluded_patterns())
     });
 
     for error in errors {

data/rust/rubydex/src/model/graph.rs

@@ -128,16 +128,16 @@ impl Graph {
         &mut self.declarations
     }
 
-    /// Adds paths to exclude from file discovery during indexing. Excluded directories will be skipped entirely during
-    /// directory traversal.
-    pub fn exclude_paths(&mut self, paths: Vec<PathBuf>) {
-        self.config.exclude_paths(paths);
+    /// Adds glob patterns to exclude from file discovery during indexing. Excluded directories will be skipped entirely
+    /// during directory traversal.
+    pub fn exclude_patterns(&mut self, patterns: Vec<Box<str>>) {
+        self.config.exclude_patterns(patterns);
     }
 
-    /// Returns the set of paths excluded from file discovery.
+    /// Returns the set of exclusion patterns.
     #[must_use]
-    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
-        self.config.excluded_paths()
+    pub fn excluded_patterns(&self) -> HashSet<Box<str>> {
+        self.config.excluded_patterns()
     }
 
     /// Returns the root directory of the workspace being indexed.

data/rust/rubydex/src/operation/applier.rs

@@ -116,9 +116,7 @@ impl OperationApplier {
             _ => {}
         }
     }
-}
 
-impl OperationApplier {
     fn apply_operation(&mut self, op: Operation) {
         match op {
             Operation::EnterClass(op) => self.apply_enter_class(op),