rubydex 0.2.6 → 0.2.8

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

@@ -1,9 +1,11 @@
 use std::collections::HashSet;
 use std::collections::hash_map::Entry;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::assert_mem_size;
+use crate::config::Config;
 use crate::diagnostic::Diagnostic;
+use crate::errors::Errors;
 use crate::indexing::local_graph::LocalGraph;
 use crate::model::built_in::{OBJECT_ID, add_built_in_data};
 use crate::model::declaration::{Ancestor, Declaration, Namespace};
@@ -11,7 +13,10 @@ use crate::model::definitions::{Definition, MethodVisibilityDefinition, Receiver
 use crate::model::document::Document;
 use crate::model::encoding::Encoding;
 use crate::model::identity_maps::{IdentityHashMap, IdentityHashSet};
-use crate::model::ids::{ConstantReferenceId, DeclarationId, DefinitionId, MethodReferenceId, NameId, StringId, UriId};
+use crate::model::ids::{
+    ConstantReferenceId, DeclarationId, DefinitionId, MethodReferenceId, NameId, StringId, UriId,
+    declaration_id_from_lookup_name,
+};
 use crate::model::name::{Name, NameRef, ParentScope, ResolvedName};
 use crate::model::references::{ConstantReference, MethodRef};
 use crate::model::string_ref::StringRef;
@@ -85,10 +90,10 @@ pub struct Graph {
     /// Drained by `take_pending_work()` before resolution.
     pending_work: Vec<Unit>,
 
-    /// Paths to exclude from file discovery during indexing.
-    excluded_paths: HashSet<PathBuf>,
+    /// Project configuration
+    config: Config,
 }
-assert_mem_size!(Graph, 336);
+assert_mem_size!(Graph, 352);
 
 impl Graph {
     #[must_use]
@@ -104,7 +109,7 @@ impl Graph {
             position_encoding: Encoding::default(),
             name_dependents: IdentityHashMap::default(),
             pending_work: Vec::default(),
-            excluded_paths: HashSet::new(),
+            config: Config::new(),
         };
 
         add_built_in_data(&mut graph);
@@ -126,13 +131,40 @@ impl Graph {
     /// 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.excluded_paths.extend(paths);
+        self.config.exclude_paths(paths);
     }
 
     /// Returns the set of paths excluded from file discovery.
     #[must_use]
-    pub fn excluded_paths(&self) -> &HashSet<PathBuf> {
-        &self.excluded_paths
+    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
+        self.config.excluded_paths()
+    }
+
+    /// Returns the root directory of the workspace being indexed.
+    #[must_use]
+    pub fn workspace_path(&self) -> &Path {
+        self.config.workspace_path()
+    }
+
+    /// Sets the root directory of the workspace being indexed.
+    pub fn set_workspace_path(&mut self, workspace_path: PathBuf) {
+        self.config.set_workspace_path(workspace_path);
+    }
+
+    /// Loads a configuration file. Pass `None` to load the default `rubydex.toml` configuration file if it exists
+    ///
+    /// # Errors
+    ///
+    /// Returns an [`Errors::ConfigNotFound`] if an explicitly requested file does not exist or an
+    /// [`Errors::ConfigError`] if a file cannot otherwise be read or its contents are malformed.
+    pub fn load_config(&mut self, config_path: Option<&Path>) -> Result<(), Errors> {
+        match config_path {
+            Some(path) => {
+                let path = self.config.workspace_path().join(path);
+                self.config.load_file(&path)
+            }
+            None => self.config.load_default(),
+        }
     }
 
     /// # Panics
@@ -486,10 +518,7 @@ impl Graph {
 
     #[must_use]
     pub fn all_diagnostics(&self) -> Vec<&Diagnostic> {
-        let document_diagnostics = self.documents.values().flat_map(Document::diagnostics);
-        let declaration_diagnostics = self.declarations.values().flat_map(Declaration::diagnostics);
-
-        document_diagnostics.chain(declaration_diagnostics).collect()
+        self.documents.values().flat_map(Document::diagnostics).collect()
     }
 
     /// Interns a string in the graph unless already interned. This method is only used to back the
@@ -552,7 +581,7 @@ impl Graph {
 
     #[must_use]
     pub fn get(&self, name: &str) -> Option<Vec<&Definition>> {
-        let declaration_id = DeclarationId::from(name);
+        let declaration_id = declaration_id_from_lookup_name(name);
         let declaration = self.declarations.get(&declaration_id)?;
 
         Some(
@@ -1201,9 +1230,6 @@ impl Graph {
             for def_id in detach_def_ids {
                 decl.remove_definition(def_id);
             }
-            if !detach_def_ids.is_empty() {
-                decl.clear_diagnostics();
-            }
         }
 
         let Some(decl) = self.declarations.get(&decl_id) else {
@@ -1247,6 +1273,10 @@ impl Graph {
                 let unqualified_str_id = StringId::from(&decl.unqualified_name());
                 let owner_id = *decl.owner_id();
                 let is_singleton_class = matches!(decl, Declaration::Namespace(Namespace::SingletonClass(_)));
+                let ancestors_to_detach: Vec<Ancestor> = decl
+                    .as_namespace()
+                    .map(|ns| ns.ancestors().iter().copied().collect())
+                    .unwrap_or_default();
 
                 for def_id in def_ids {
                     self.push_work(Unit::Definition(def_id));
@@ -1261,6 +1291,16 @@ impl Graph {
                         ns.remove_member(&unqualified_str_id);
                     }
                 }
+
+                // Detach from each complete ancestor's descendant set so we don't leave a stale id in descendants
+                for ancestor in ancestors_to_detach {
+                    if let Ancestor::Complete(ancestor_id) = ancestor
+                        && let Some(anc_decl) = self.declarations.get_mut(&ancestor_id)
+                        && let Some(ns) = anc_decl.as_namespace_mut()
+                    {
+                        ns.remove_descendant(&decl_id);
+                    }
+                }
             }
 
             self.declarations.remove(&decl_id);
@@ -1547,6 +1587,10 @@ mod tests {
         assert_members_eq, assert_no_diagnostics, assert_no_members,
     };
 
+    fn definition_ids(definitions: Vec<&Definition>) -> Vec<DefinitionId> {
+        definitions.into_iter().map(Definition::id).collect()
+    }
+
     #[test]
     fn deleting_a_uri() {
         let mut context = GraphTest::new();
@@ -1969,6 +2013,34 @@ mod tests {
         assert_eq!(definitions[0].offset().start(), 6);
     }
 
+    #[test]
+    fn get_accepts_leading_double_colon() {
+        let mut context = GraphTest::new();
+
+        context.index_uri("file:///foo.rb", "module Foo; module Bar; end; end");
+        context.resolve();
+
+        // Built-in declarations (root-scoped):
+        let unqualified = context.graph().get("Object").expect("unqualified `Object` lookup");
+        let qualified = context.graph().get("::Object").expect("qualified `::Object` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        // Indexed declarations, top-level and nested:
+        let unqualified = context.graph().get("Foo").expect("unqualified `Foo` lookup");
+        let qualified = context.graph().get("::Foo").expect("qualified `::Foo` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        let unqualified = context.graph().get("Foo::Bar").expect("unqualified `Foo::Bar` lookup");
+        let qualified = context
+            .graph()
+            .get("::Foo::Bar")
+            .expect("qualified `::Foo::Bar` lookup");
+        assert_eq!(definition_ids(unqualified), definition_ids(qualified));
+
+        // Unknown names still return None when prefixed:
+        assert!(context.graph().get("::DoesNotExist").is_none());
+    }
+
     #[test]
     fn adding_another_definition_from_a_different_uri() {
         let mut context = GraphTest::new();
@@ -2476,6 +2548,7 @@ mod tests {
 
 #[cfg(test)]
 mod incremental_resolution_tests {
+    use crate::model::ids::DeclarationId;
     use crate::model::name::NameRef;
     use crate::test_utils::GraphTest;
     use crate::{
@@ -4103,4 +4176,37 @@ mod incremental_resolution_tests {
         assert_declaration_exists!(context, "Foo::<Foo>");
         assert_declaration_exists!(context, "Bar::<Bar>");
     }
+
+    #[test]
+    fn constant_references_through_object_inheritance_are_invalidated() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///a.rb", "class Foo; end");
+        context.index_uri(
+            "file:///b.rb",
+            r"
+            module Wrap
+              class Foo; end
+              ::Foo
+              Foo
+            end
+            ",
+        );
+        context.resolve();
+
+        context.delete_uri("file:///a.rb");
+        context.resolve();
+
+        let kernel = context
+            .graph()
+            .declarations()
+            .get(&DeclarationId::from("Kernel"))
+            .unwrap();
+
+        for id in kernel.as_namespace().unwrap().descendants() {
+            assert!(
+                context.graph().declarations().contains_key(id),
+                "Kernel has stale descendant id {id:?} with no backing declaration"
+            );
+        }
+    }
 } // mod incremental_resolution_tests

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

@@ -9,6 +9,15 @@ pub struct DeclarationMarker;
 /// `DeclarationId` represents the ID of a fully qualified name. For example, `Foo::Bar` or `Foo#my_method`
 pub type DeclarationId = Id<DeclarationMarker>;
 
+/// Creates a `DeclarationId` from a user-facing lookup name.
+///
+/// Declaration names are stored without the root-scope marker, so `"::Object"`
+/// and `"Object"` must resolve to the same declaration ID.
+#[must_use]
+pub fn declaration_id_from_lookup_name(name: &str) -> DeclarationId {
+    DeclarationId::from(name.strip_prefix("::").unwrap_or(name))
+}
+
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)]
 pub struct DefinitionMarker;
 
@@ -84,3 +93,24 @@ assert_mem_size!(ClassVariableReferenceId, 8);
 pub struct InstanceVariableMarker;
 pub type InstanceVariableReferenceId = Id<InstanceVariableMarker>;
 assert_mem_size!(InstanceVariableReferenceId, 8);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn declaration_id_from_lookup_name_accepts_root_scope_marker() {
+        assert_eq!(
+            DeclarationId::from("Object"),
+            declaration_id_from_lookup_name("::Object")
+        );
+        assert_eq!(
+            DeclarationId::from("Foo::Bar"),
+            declaration_id_from_lookup_name("::Foo::Bar")
+        );
+        assert_ne!(
+            DeclarationId::from("Object"),
+            declaration_id_from_lookup_name("::::Object")
+        );
+    }
+}

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

@@ -9,15 +9,23 @@ use std::ops::Deref;
 /// graph when its count reaches zero.
 #[derive(Debug)]
 pub struct StringRef {
-    value: String,
+    value: Box<str>,
     ref_count: u32,
 }
-assert_mem_size!(StringRef, 32);
+assert_mem_size!(StringRef, 24);
 
 impl StringRef {
     #[must_use]
     pub fn new(value: String) -> Self {
-        Self { value, ref_count: 1 }
+        Self {
+            value: value.into_boxed_str(),
+            ref_count: 1,
+        }
+    }
+
+    #[must_use]
+    pub fn as_str(&self) -> &str {
+        &self.value
     }
 
     #[must_use]
@@ -44,7 +52,7 @@ impl StringRef {
 }
 
 impl Deref for StringRef {
-    type Target = String;
+    type Target = str;
 
     fn deref(&self) -> &Self::Target {
         &self.value

data/rust/rubydex/src/query.rs

@@ -27,12 +27,25 @@ pub enum MatchMode {
     Exact,
 }
 
+/// Searches all declarations in parallel based on fully qualified names. Accepts multiple queries in case the caller
+/// wants to find multiple patterns without having to re-traverse the graph and also accepts match mode.
+///
+/// Note: an empty query returns all declarations, so if any are included the rest of the queries will be ignored.
+///
 /// # Panics
 ///
 /// Will panic if any of the threads panic
-pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) -> Vec<DeclarationId> {
+pub fn declaration_search(graph: &Graph, queries: &[&str], match_mode: &MatchMode) -> Vec<DeclarationId> {
     let num_threads = thread::available_parallelism().map_or(4, std::num::NonZero::get);
     let declarations = graph.declarations();
+
+    // An empty query matches all declarations as per the LSP specification and is equivalent to fetching all of them
+    // directly. Since an empty query matches all, there's no point in checking the other queries or pay the price of
+    // spawning threads.
+    if queries.iter().any(|q| q.is_empty()) {
+        return declarations.keys().copied().collect();
+    }
+
     let ids: Vec<DeclarationId> = declarations.keys().copied().collect();
     let chunk_size = ids.len().div_ceil(num_threads);
 
@@ -48,16 +61,8 @@ pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) ->
                     chunk
                         .iter()
                         .filter(|id| {
-                            let declaration = declarations.get(id).unwrap();
-                            let name = declaration.name();
-                            match match_mode {
-                                MatchMode::Fuzzy => {
-                                    // When the query is empty, we return everything as per the LSP specification.
-                                    // Otherwise, we compute the match score and return anything with a score greater than zero
-                                    query.is_empty() || match_score(query, name) > 0
-                                }
-                                MatchMode::Exact => name.contains(query),
-                            }
+                            let name = declarations.get(id).unwrap().name();
+                            queries.iter().any(|query| matches_query(query, name, match_mode))
                         })
                         .copied()
                         .collect::<Vec<_>>()
@@ -69,6 +74,15 @@ pub fn declaration_search(graph: &Graph, query: &str, match_mode: &MatchMode) ->
     })
 }
 
+/// Returns whether a single `query` matches `name` under the given [`MatchMode`].
+#[must_use]
+fn matches_query(query: &str, name: &str, match_mode: &MatchMode) -> bool {
+    match match_mode {
+        MatchMode::Fuzzy => match_score(query, name) > 0,
+        MatchMode::Exact => name.contains(query),
+    }
+}
+
 #[must_use]
 fn match_score(query: &str, target: &str) -> usize {
     let mut query_chars = query.chars().peekable();
@@ -836,7 +850,7 @@ mod tests {
             assert_results_eq!($context, $query, &MatchMode::default(), $expected);
         };
         ($context:expr, $query:expr, $match_mode:expr, $expected:expr) => {
-            let actual = declaration_search(&$context.graph(), $query, $match_mode);
+            let actual = declaration_search(&$context.graph(), &[$query], $match_mode);
             assert_eq!(
                 actual,
                 $expected
@@ -945,8 +959,8 @@ mod tests {
             "
         });
         context.resolve();
-        let exact_results = declaration_search(context.graph(), "", &MatchMode::Exact);
-        let fuzzy_results = declaration_search(context.graph(), "", &MatchMode::Fuzzy);
+        let exact_results = declaration_search(context.graph(), &[""], &MatchMode::Exact);
+        let fuzzy_results = declaration_search(context.graph(), &[""], &MatchMode::Fuzzy);
 
         assert_eq!(exact_results.len(), fuzzy_results.len());
         assert_eq!(context.graph().declarations().len(), exact_results.len());
@@ -972,6 +986,51 @@ mod tests {
         assert_results_eq!(context, "#Is_A?()", ["Foo#is_a_foo?()", "Bar#is_a?()"]);
     }
 
+    #[test]
+    fn multiple_queries_return_union_of_matches() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def foo_method; end
+              def bar_method; end
+              def other_method; end
+            end
+            "
+        });
+        context.resolve();
+
+        let results = declaration_search(context.graph(), &["#foo_method()", "#bar_method()"], &MatchMode::Exact);
+        let mut names: Vec<String> = results
+            .iter()
+            .map(|id| context.graph().declarations().get(id).unwrap().name().to_string())
+            .collect();
+        names.sort();
+
+        assert_eq!(names, ["Foo#bar_method()", "Foo#foo_method()"]);
+    }
+
+    #[test]
+    fn overlapping_queries_do_not_duplicate_results() {
+        let mut context = GraphTest::new();
+        context.index_uri("file:///foo.rb", {
+            r"
+            class Foo
+              def is_a_foo?; end
+            end
+            "
+        });
+        context.resolve();
+
+        let results = declaration_search(context.graph(), &["is_a", "foo?"], &MatchMode::Exact);
+        let matches = results
+            .iter()
+            .filter(|id| context.graph().declarations().get(id).unwrap().name() == "Foo#is_a_foo?()")
+            .count();
+
+        assert_eq!(matches, 1);
+    }
+
     fn test_root() -> PathBuf {
         let root = if cfg!(windows) { "C:\\" } else { "/" };
         PathBuf::from_str(root).unwrap()
@@ -2767,7 +2826,16 @@ mod tests {
                 self_decl_id: None,
                 nesting_name_id,
             },
-            ["Bar#@@bar_cvar"]
+            [
+                "Bar",
+                "Bar#@@bar_cvar",
+                "BasicObject",
+                "Class",
+                "Foo",
+                "Kernel",
+                "Module",
+                "Object"
+            ]
         );
     }