rubydex 0.2.8 → 0.3.0

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

@@ -1,13 +1,9 @@
 use clap::{Parser, ValueEnum};
-use std::{
-    fs, mem,
-    path::{Path, PathBuf},
-    time::{Duration, Instant},
-};
+use std::{fs, mem, path::PathBuf};
 
 use rubydex::{
     dot,
-    indexing::{self, IndexerBackend, LanguageId, build_local_graph},
+    indexing::{self, IndexerBackend},
     integrity, listing,
     model::graph::Graph,
     resolution::Resolver,
@@ -16,7 +12,6 @@ use rubydex::{
         timer::{Timer, time_it},
     },
 };
-use url::Url;
 
 #[derive(Parser, Debug)]
 #[command(name = "rubydex_cli", about = "A Static Analysis Toolkit for Ruby", version)]
@@ -61,21 +56,6 @@ struct Args {
         help = "Write orphan definitions report to specified file"
     )]
     report_orphans: Option<String>,
-
-    #[arg(
-        long = "incremental_cycle",
-        value_name = "N",
-        help = "After the initial build, run N incremental resolution cycles and report their timings"
-    )]
-    incremental_cycle: Option<usize>,
-
-    #[arg(
-        long = "incremental_files",
-        value_name = "N",
-        default_value_t = 1,
-        help = "Number of files to re-index per incremental cycle"
-    )]
-    incremental_files: usize,
 }
 
 #[derive(Debug, Clone, ValueEnum)]
@@ -134,7 +114,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 {
@@ -149,14 +129,6 @@ fn main() {
 
     let backend = IndexerBackend::from(&args.indexer);
 
-    // The incremental benchmark re-indexes files after the initial build, so keep a copy of the
-    // paths before `index_files` consumes them.
-    let incremental_paths = if args.incremental_cycle.is_some() {
-        file_paths.clone()
-    } else {
-        Vec::new()
-    };
-
     let errors = time_it!(indexing, { indexing::index_files(&mut graph, file_paths, backend) });
 
     for error in errors {
@@ -174,12 +146,6 @@ fn main() {
         resolver.resolve();
     });
 
-    // Incremental resolution benchmark. Runs before the stop-after check so it can be combined with
-    // `--stop-after=resolution`.
-    if let Some(cycles) = args.incremental_cycle {
-        run_incremental_resolution(&mut graph, &incremental_paths, cycles, args.incremental_files, backend);
-    }
-
     if let Some(StopAfter::Resolution) = args.stop_after {
         return exit(args.stats);
     }
@@ -241,91 +207,3 @@ fn main() {
     // Forget the graph so we don't have to wait for deallocation and let the system reclaim the memory at exit
     mem::forget(graph);
 }
-
-/// Simulates incremental editing to measure incremental resolution cost. For each cycle it
-/// re-indexes a rotating window of `files_per_cycle` files (parsing plus the same invalidation the
-/// LSP performs on save) and then re-runs resolution over the resulting pending work, reporting
-/// per-cycle and aggregate `resolve()` timings.
-///
-/// With `--stats`, the `compute_descendants` breakdown printed in the timing summary reflects the
-/// last incremental cycle, since it is recorded on every `resolve()`.
-fn run_incremental_resolution(
-    graph: &mut Graph,
-    paths: &[PathBuf],
-    cycles: usize,
-    files_per_cycle: usize,
-    backend: IndexerBackend,
-) {
-    if paths.is_empty() || cycles == 0 || files_per_cycle == 0 {
-        eprintln!("Skipping incremental resolution: nothing to re-index");
-        return;
-    }
-
-    let files_per_cycle = files_per_cycle.min(paths.len());
-
-    let mut reindex_total = Duration::ZERO;
-    let mut resolve_total = Duration::ZERO;
-    let mut resolve_min = Duration::MAX;
-    let mut resolve_max = Duration::ZERO;
-
-    println!();
-    println!("Incremental resolution ({cycles} cycle(s), {files_per_cycle} file(s)/cycle)");
-    println!("  Scenario: no-op reindex; files are indexed again without changing their contents.");
-    println!("  This should be the fastest incremental resolution path.");
-    println!("  Add scenario-based benchmarks before optimizing incremental resolution.");
-
-    for cycle in 0..cycles {
-        // Re-index the window of files for this cycle. Rotating the window across cycles samples
-        // different parts of the codebase rather than measuring the same delta repeatedly.
-        let reindex_start = Instant::now();
-        for i in 0..files_per_cycle {
-            let path = &paths[(cycle * files_per_cycle + i) % paths.len()];
-            reindex_file(graph, path, backend);
-        }
-        reindex_total += reindex_start.elapsed();
-
-        let resolve_start = Instant::now();
-        Resolver::new(graph).resolve();
-        let elapsed = resolve_start.elapsed();
-
-        resolve_total += elapsed;
-        resolve_min = resolve_min.min(elapsed);
-        resolve_max = resolve_max.max(elapsed);
-
-        println!(
-            "  cycle {:>3}: resolve {:9.3}ms",
-            cycle + 1,
-            elapsed.as_secs_f64() * 1000.0
-        );
-    }
-
-    let avg = resolve_total / u32::try_from(cycles).expect("cycle count fits in u32");
-
-    println!(
-        "  resolve total {:.3}ms  avg {:.3}ms  min {:.3}ms  max {:.3}ms",
-        resolve_total.as_secs_f64() * 1000.0,
-        avg.as_secs_f64() * 1000.0,
-        resolve_min.as_secs_f64() * 1000.0,
-        resolve_max.as_secs_f64() * 1000.0,
-    );
-    println!(
-        "  reindex+invalidate total {:.3}ms (parse + document merge, excluded from resolve above)",
-        reindex_total.as_secs_f64() * 1000.0,
-    );
-}
-
-/// Re-indexes a single file into the graph, running the same invalidation the LSP performs on save.
-fn reindex_file(graph: &mut Graph, path: &Path, backend: IndexerBackend) {
-    let Ok(source) = fs::read_to_string(path) else {
-        eprintln!("Failed to read file `{}`", path.display());
-        return;
-    };
-    let Ok(url) = Url::from_file_path(path) else {
-        eprintln!("Couldn't build URI from path `{}`", path.display());
-        return;
-    };
-
-    let language = path.extension().map_or(LanguageId::Ruby, LanguageId::from);
-    let local_graph = build_local_graph(url.to_string(), &source, &language, backend);
-    graph.consume_document_changes(local_graph);
-}

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

@@ -192,10 +192,6 @@ macro_rules! namespace_declaration {
                 &self.ancestors
             }
 
-            pub fn ancestors_mut(&mut self) -> &mut Ancestors {
-                &mut self.ancestors
-            }
-
             #[must_use]
             pub fn clone_ancestors(&self) -> Ancestors {
                 self.ancestors.clone()
@@ -552,13 +548,6 @@ impl Namespace {
         all_namespaces!(self, it => it.remove_descendant(descendant_id));
     }
 
-    pub fn for_each_ancestor<F>(&self, mut f: F)
-    where
-        F: FnMut(&Ancestor),
-    {
-        all_namespaces!(self, it => it.ancestors().iter().for_each(&mut f));
-    }
-
     pub fn for_each_descendant<F>(&self, mut f: F)
     where
         F: FnMut(&DeclarationId),