rubydex 0.2.7 → 0.2.8

data/rust/rubydex/tests/cli.rs

@@ -19,6 +19,9 @@ fn prints_help() {
         .success()
         .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
         .stdout(predicate::str::contains("Usage:"))
+        .stdout(predicate::str::contains(
+            "If the first path is a directory, it is used as the workspace root for rubydex.toml",
+        ))
         .stdout(predicate::str::contains("--stats"))
         .stdout(predicate::str::contains("--dot"))
         .stdout(predicate::str::contains("--stop-after"));
@@ -52,6 +55,69 @@ fn paths_argument_variants() {
     });
 }
 
+#[test]
+fn single_directory_argument_is_workspace_root_for_config() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[context.absolute_path().to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn first_directory_argument_is_workspace_root_for_config() {
+    with_context(|context| {
+        context.write("included/kept.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[
+            context.absolute_path().to_str().unwrap(),
+            context.absolute_path_to("included").to_str().unwrap(),
+            context.absolute_path_to("excluded").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn single_file_argument_is_not_used_as_workspace_root() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[context.absolute_path_to("excluded/skipped.rb").to_str().unwrap()])
+            .success()
+            .stderr(predicate::str::is_empty())
+            .stdout(predicate::str::contains("Indexed 2 files"));
+    });
+}
+
+#[test]
+fn first_file_argument_is_not_used_as_workspace_root() {
+    with_context(|context| {
+        context.write("included.rb", "class Included\nend\n");
+        context.write("excluded/skipped.rb", "class Skipped\nend\n");
+        context.write("rubydex.toml", "exclude = [\"excluded\"]\n");
+
+        rdx(&[
+            context.absolute_path_to("included.rb").to_str().unwrap(),
+            context.absolute_path_to("excluded").to_str().unwrap(),
+        ])
+        .success()
+        .stderr(predicate::str::is_empty())
+        .stdout(predicate::str::contains("Indexed 3 files"));
+    });
+}
+
 #[test]
 fn prints_index_metrics() {
     with_context(|context| {

data/rust/rubydex-mcp/src/server.rs

@@ -241,7 +241,7 @@ impl RubydexServer {
                 .to_string();
             }
         };
-        let ids = rubydex::query::declaration_search(graph, &params.query, &match_mode);
+        let ids = rubydex::query::declaration_search(graph, &[params.query.as_str()], &match_mode);
 
         let limit = params.limit.filter(|&l| l > 0).unwrap_or(50).min(100); // default 50, max 100
         let offset = params.offset.unwrap_or(0);

data/rust/rubydex-sys/src/declaration_api.rs

@@ -9,7 +9,7 @@ use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::utils;
-use rubydex::model::ids::{DeclarationId, StringId};
+use rubydex::model::ids::{DeclarationId, StringId, declaration_id_from_lookup_name};
 
 #[repr(C)]
 #[derive(Debug, Clone, Copy)]
@@ -80,7 +80,7 @@ pub(crate) unsafe fn decl_id_from_char_ptr(ptr: *const c_char) -> Option<Declara
     if s.is_empty() {
         return None;
     }
-    Some(DeclarationId::from(s.as_str()))
+    Some(declaration_id_from_lookup_name(&s))
 }
 
 /// An iterator over declaration IDs

data/rust/rubydex-sys/src/graph_api.rs

@@ -11,7 +11,7 @@ use rubydex::errors::Errors;
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId, UriId};
+use rubydex::model::ids::{DeclarationId, NameId, UriId, declaration_id_from_lookup_name};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::model::visibility::Visibility;
@@ -58,64 +58,75 @@ where
     result
 }
 
-/// Searches the graph using exact substring matching
+/// Searches the graph using exact substring matching, returning every declaration whose name matches any of the
+/// queries.
 ///
 /// # Safety
 ///
-/// Expects both the graph and the query pointers to be valid
+/// Expects `pointer` to be a valid graph and `c_queries` to point to an array of `count` valid, NUL-terminated C
+/// strings. Returns a null pointer when `count` is zero, `c_queries` is null, or any query is not valid UTF-8.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_declarations_search(
     pointer: GraphPointer,
-    c_query: *const c_char,
+    c_queries: *const *const c_char,
+    count: usize,
 ) -> *mut DeclarationsIter {
-    {
-        let Ok(query) = (unsafe { utils::convert_char_ptr_to_string(c_query) }) else {
-            return ptr::null_mut();
-        };
+    if count == 0 || c_queries.is_null() {
+        return ptr::null_mut();
+    }
 
-        let entries = with_graph(pointer, |graph| {
-            query::declaration_search(graph, &query, &query::MatchMode::Exact)
-                .into_iter()
-                .filter_map(|id| {
-                    let decl = graph.declarations().get(&id)?;
-                    Some(CDeclaration::from_declaration(id, decl))
-                })
-                .collect::<Vec<CDeclaration>>()
-                .into_boxed_slice()
-        });
+    let Ok(queries) = (unsafe { utils::convert_double_pointer_to_vec(c_queries, count) }) else {
+        return ptr::null_mut();
+    };
+    let query_refs: Vec<&str> = queries.iter().map(String::as_str).collect();
 
-        DeclarationsIter::new(entries)
-    }
+    let entries = with_graph(pointer, |graph| {
+        query::declaration_search(graph, &query_refs, &query::MatchMode::Exact)
+            .into_iter()
+            .filter_map(|id| {
+                let decl = graph.declarations().get(&id)?;
+                Some(CDeclaration::from_declaration(id, decl))
+            })
+            .collect::<Vec<CDeclaration>>()
+            .into_boxed_slice()
+    });
+
+    DeclarationsIter::new(entries)
 }
 
-/// Searches the graph using fuzzy matching
+/// Searches the graph using fuzzy matching, returning every declaration whose name matches any of the queries.
 ///
 /// # Safety
 ///
-/// Expects both the graph and the query pointers to be valid
+/// Expects `pointer` to be a valid graph and `c_queries` to point to an array of `count` valid, NUL-terminated C
+/// strings. Returns a null pointer when `count` is zero, `c_queries` is null, or any query is not valid UTF-8.
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_declarations_fuzzy_search(
     pointer: GraphPointer,
-    c_query: *const c_char,
+    c_queries: *const *const c_char,
+    count: usize,
 ) -> *mut DeclarationsIter {
-    {
-        let Ok(query) = (unsafe { utils::convert_char_ptr_to_string(c_query) }) else {
-            return ptr::null_mut();
-        };
+    if count == 0 || c_queries.is_null() {
+        return ptr::null_mut();
+    }
 
-        let entries = with_graph(pointer, |graph| {
-            query::declaration_search(graph, &query, &query::MatchMode::Fuzzy)
-                .into_iter()
-                .filter_map(|id| {
-                    let decl = graph.declarations().get(&id)?;
-                    Some(CDeclaration::from_declaration(id, decl))
-                })
-                .collect::<Vec<CDeclaration>>()
-                .into_boxed_slice()
-        });
+    let Ok(queries) = (unsafe { utils::convert_double_pointer_to_vec(c_queries, count) }) else {
+        return ptr::null_mut();
+    };
+    let query_refs: Vec<&str> = queries.iter().map(String::as_str).collect();
 
-        DeclarationsIter::new(entries)
-    }
+    let entries = with_graph(pointer, |graph| {
+        query::declaration_search(graph, &query_refs, &query::MatchMode::Fuzzy)
+            .into_iter()
+            .filter_map(|id| {
+                let decl = graph.declarations().get(&id)?;
+                Some(CDeclaration::from_declaration(id, decl))
+            })
+            .collect::<Vec<CDeclaration>>()
+            .into_boxed_slice()
+    });
+
+    DeclarationsIter::new(entries)
 }
 
 /// # Panics
@@ -498,7 +509,7 @@ pub unsafe extern "C" fn rdx_graph_get_declaration(pointer: GraphPointer, name:
     };
 
     with_graph(pointer, |graph| {
-        let decl_id = DeclarationId::from(name_str.as_str());
+        let decl_id = declaration_id_from_lookup_name(&name_str);
 
         if let Some(decl) = graph.declarations().get(&decl_id) {
             Box::into_raw(Box::new(CDeclaration::from_declaration(decl_id, decl))).cast_const()
@@ -917,7 +928,7 @@ pub unsafe extern "C" fn rdx_graph_complete_namespace_access(
             graph,
             CompletionReceiver::NamespaceAccess {
                 self_decl_id,
-                namespace_decl_id: DeclarationId::from(name_str.as_str()),
+                namespace_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             Vec::new(),
         )
@@ -951,7 +962,7 @@ pub unsafe extern "C" fn rdx_graph_complete_method_call(
             graph,
             CompletionReceiver::MethodCall {
                 self_decl_id,
-                receiver_decl_id: DeclarationId::from(name_str.as_str()),
+                receiver_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             Vec::new(),
         )
@@ -995,7 +1006,7 @@ pub unsafe extern "C" fn rdx_graph_complete_method_argument(
             CompletionReceiver::MethodArgument {
                 self_decl_id,
                 nesting_name_id,
-                method_decl_id: DeclarationId::from(name_str.as_str()),
+                method_decl_id: declaration_id_from_lookup_name(&name_str),
             },
             names_to_untrack,
         )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-30 00:00:00.000000000 Z
+date: 2026-07-08 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs