rubydex 0.2.6 → 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

@@ -7,10 +7,11 @@ use crate::document_api::DocumentsIter;
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::{name_api, utils};
 use libc::{c_char, c_void};
+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;
@@ -18,7 +19,7 @@ use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver}
 use rubydex::resolution::Resolver;
 use rubydex::{indexing, integrity, listing, query};
 use std::ffi::CString;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::{mem, ptr};
 
 pub type GraphPointer = *mut c_void;
@@ -57,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
@@ -197,7 +209,13 @@ pub unsafe extern "C" fn rdx_graph_excluded_paths(
         let c_strings: Vec<*const c_char> = excluded
             .iter()
             .filter_map(|path| {
-                CString::new(path.to_string_lossy().as_ref())
+                // Normalize all paths to use forward slashes. Otherwise, you get mixed backslashes and forward slashes
+                // on Windows if a configuration file is using forward slashes. For example:
+                //
+                // C:\project/vendor/bundle
+                let normalized = path.to_string_lossy().replace(std::path::MAIN_SEPARATOR, "/");
+
+                CString::new(normalized)
                     .ok()
                     .map(|c_string| c_string.into_raw().cast_const())
             })
@@ -210,6 +228,69 @@ pub unsafe extern "C" fn rdx_graph_excluded_paths(
     })
 }
 
+/// Sets the workspace path used as the root directory for indexing and relative path resolution. Silently ignores the
+/// call if the given path is not valid UTF-8, leaving the existing workspace path untouched (mirrors
+/// `rdx_graph_set_encoding`). This avoids unwinding across the FFI boundary on malformed input.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - `path` must be a valid, null-terminated string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_set_workspace_path(pointer: GraphPointer, path: *const c_char) {
+    let Ok(path) = (unsafe { utils::convert_char_ptr_to_string(path) }) else {
+        return;
+    };
+
+    with_mut_graph(pointer, |graph| graph.set_workspace_path(PathBuf::from(path)));
+}
+
+/// Returns the workspace path as a C string. Caller must free with `free_c_string`.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_workspace_path(pointer: GraphPointer) -> *const c_char {
+    with_graph(pointer, |graph| {
+        CString::new(graph.workspace_path().to_string_lossy().as_ref())
+            .map_or(ptr::null(), |c_string| c_string.into_raw().cast_const())
+    })
+}
+
+/// Loads configuration into the graph. A null `config_path` attempts to load the default configuration file.
+///
+/// Returns NULL on success. On failure returns an owned, null-terminated error message that the caller must free with
+/// `free_c_string`.
+///
+/// A `config_path` that is not valid UTF-8 is reported as an error message.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - `config_path` must either be NULL or a valid, null-terminated string.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_load_config(pointer: GraphPointer, config_path: *const c_char) -> *const c_char {
+    let result = with_mut_graph(pointer, |graph| {
+        if config_path.is_null() {
+            graph.load_config(None)
+        } else {
+            match unsafe { utils::convert_char_ptr_to_string(config_path) } {
+                Ok(config_path) => graph.load_config(Some(Path::new(&config_path))),
+                Err(_) => Err(Errors::ConfigError("config file path is not valid UTF-8".to_string())),
+            }
+        }
+    });
+
+    match result {
+        Ok(()) => ptr::null(),
+        Err(error) => CString::new(error.to_string())
+            .unwrap_or_default()
+            .into_raw()
+            .cast_const(),
+    }
+}
+
 /// Indexes all given file paths in parallel using the provided Graph pointer.
 /// Returns an array of error message strings and writes the count to `out_error_count`.
 /// Returns NULL if there are no errors. Caller must free with `free_c_string_array`.
@@ -232,7 +313,7 @@ pub unsafe extern "C" fn rdx_index_all(
     let file_paths: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(file_paths, count).unwrap() };
 
     with_mut_graph(pointer, |graph| {
-        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, graph.excluded_paths());
+        let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, &graph.excluded_paths());
         let indexing_errors = indexing::index_files(graph, file_paths, indexing::IndexerBackend::RubyIndexer);
 
         let all_errors: Vec<String> = listing_errors
@@ -428,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()
@@ -847,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(),
         )
@@ -881,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(),
         )
@@ -925,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.6
+  version: 0.2.8
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-25 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
@@ -88,7 +88,9 @@ files:
 - rust/rubydex-sys/src/signature_api.rs
 - rust/rubydex-sys/src/utils.rs
 - rust/rubydex/Cargo.toml
+- rust/rubydex/benches/graph_memory.rs
 - rust/rubydex/src/compile_assertions.rs
+- rust/rubydex/src/config.rs
 - rust/rubydex/src/diagnostic.rs
 - rust/rubydex/src/dot.rs
 - rust/rubydex/src/errors.rs