rubydex 0.2.6 → 0.2.7

data/rust/rubydex/src/config.rs

@@ -0,0 +1,275 @@
+use crate::assert_mem_size;
+use crate::errors::Errors;
+use serde::Deserialize;
+use std::collections::HashSet;
+use std::fs;
+use std::io::ErrorKind;
+use std::path::{Path, PathBuf};
+
+pub const DEFAULT_EXCLUDED_DIRECTORIES: &[&str] = &[
+    ".bundle",
+    ".claude",
+    ".git",
+    ".github",
+    ".ruby-lsp",
+    ".vscode",
+    "log",
+    "node_modules",
+    "tmp",
+];
+
+/// Configuration coming from a config file
+#[derive(Debug, Default, Deserialize)]
+struct ConfigFile {
+    /// Paths to exclude from file discovery during indexing.
+    #[serde(default)]
+    exclude: Vec<PathBuf>,
+}
+
+/// Project configuration
+#[derive(Debug)]
+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>,
+}
+assert_mem_size!(Config, 64);
+
+impl Default for Config {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Config {
+    /// Creates a configuration whose workspace path defaults to the current working directory.
+    #[must_use]
+    pub fn new() -> Self {
+        Self {
+            workspace_path: std::env::current_dir()
+                .unwrap_or_else(|_| PathBuf::from("."))
+                .into_boxed_path(),
+            excluded_paths: DEFAULT_EXCLUDED_DIRECTORIES.iter().map(PathBuf::from).collect(),
+        }
+    }
+
+    /// Returns the root directory of the workspace being analyzed.
+    #[must_use]
+    pub fn workspace_path(&self) -> &Path {
+        &self.workspace_path
+    }
+
+    /// Sets the root directory of the workspace being analyzed.
+    pub fn set_workspace_path(&mut self, workspace_path: PathBuf) {
+        self.workspace_path = workspace_path.into_boxed_path();
+    }
+
+    /// 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: impl IntoIterator<Item = PathBuf>) {
+        self.excluded_paths.extend(paths);
+    }
+
+    /// Returns the set of paths excluded from file discovery
+    #[must_use]
+    pub fn excluded_paths(&self) -> HashSet<PathBuf> {
+        self.excluded_paths
+            .iter()
+            .map(|path| self.workspace_path.join(path))
+            .collect()
+    }
+
+    /// Merges the default `rubydex.toml` configuration file from the workspace root into this config, if present.
+    ///
+    /// The default config file is optional, so a missing `rubydex.toml` is silently ignored. Any other failure (an
+    /// unreadable or malformed file) is still reported.
+    ///
+    /// # Errors
+    ///
+    /// Will error if the config file exists but cannot be read or has invalid syntax.
+    pub fn load_default(&mut self) -> Result<(), Errors> {
+        let config_path = self.workspace_path.join("rubydex.toml");
+
+        match self.load_file(&config_path) {
+            Err(Errors::ConfigNotFound(_)) => Ok(()),
+            other => other,
+        }
+    }
+
+    /// Merges the configuration at `config_path` into this config
+    ///
+    /// # Errors
+    ///
+    /// Returns [`Errors::ConfigNotFound`] if the file does not exist or [`Errors::ConfigError`] if it cannot otherwise
+    /// be read or has invalid syntax.
+    pub fn load_file(&mut self, config_path: &Path) -> Result<(), Errors> {
+        let content = match fs::read_to_string(config_path) {
+            Ok(content) => content,
+            Err(error) if error.kind() == ErrorKind::NotFound => {
+                return Err(Errors::ConfigNotFound(format!(
+                    "Config file `{}` does not exist",
+                    config_path.display()
+                )));
+            }
+            Err(error) => {
+                return Err(Errors::ConfigError(format!(
+                    "Failed to read config file `{}`: {error}",
+                    config_path.display()
+                )));
+            }
+        };
+
+        let parsed = Self::parse(&content).map_err(|error| {
+            Errors::ConfigError(format!("Invalid config file `{}`: {error}", config_path.display()))
+        })?;
+
+        self.excluded_paths.extend(parsed.exclude);
+        Ok(())
+    }
+
+    /// Parses the content into a [`ConfigFile`]
+    fn parse(content: &str) -> Result<ConfigFile, toml::de::Error> {
+        toml::from_str(content)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::path::Path;
+
+    #[test]
+    fn excluded_paths_are_resolved_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")));
+    }
+
+    #[test]
+    fn new_seeds_the_default_excluded_directories() {
+        let config = Config::new();
+
+        for default in DEFAULT_EXCLUDED_DIRECTORIES {
+            assert!(
+                config.excluded_paths.contains(Path::new(default)),
+                "expected `{default}` to be excluded by default"
+            );
+        }
+    }
+
+    #[test]
+    fn load_file_merges_excluded_paths_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();
+
+        let mut config = Config::new();
+        config.set_workspace_path(PathBuf::from("/workspace"));
+
+        config
+            .load_file(&config_path)
+            .expect("expected the config file to load");
+
+        let excluded = config.excluded_paths();
+        // 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")));
+        // Defaults seeded at construction survive the merge.
+        assert!(excluded.contains(Path::new("/workspace/node_modules")));
+        // A config file cannot override the programmatically-set workspace path.
+        assert_eq!(config.workspace_path(), Path::new("/workspace"));
+    }
+
+    #[test]
+    fn load_file_accumulates_exclusions_across_multiple_loads() {
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        fs::write(dir.path().join("a.toml"), "exclude = [\"vendor\"]\n").unwrap();
+        fs::write(dir.path().join("b.toml"), "exclude = [\"generated\"]\n").unwrap();
+
+        let mut config = Config::new();
+        config.set_workspace_path(PathBuf::from("/workspace"));
+        config
+            .load_file(&dir.path().join("a.toml"))
+            .expect("expected the first file to load");
+        config
+            .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")));
+    }
+
+    #[test]
+    fn load_file_errors_when_the_file_is_missing() {
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        let mut config = Config::new();
+
+        let error = config
+            .load_file(&dir.path().join("does_not_exist.toml"))
+            .expect_err("an explicitly requested missing file must be an error");
+
+        assert!(
+            matches!(error, Errors::ConfigNotFound(_)),
+            "unexpected error: {error:?}"
+        );
+    }
+
+    #[test]
+    fn load_default_ignores_a_missing_config_file() {
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        let mut config = Config::new();
+        config.set_workspace_path(dir.path().to_path_buf());
+
+        config
+            .load_default()
+            .expect("a missing rubydex.toml must not be an error");
+    }
+
+    #[test]
+    fn load_default_loads_an_existing_config_file() {
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        fs::write(dir.path().join("rubydex.toml"), "exclude = [\"vendor\"]\n").unwrap();
+
+        let mut config = Config::new();
+        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")));
+    }
+
+    #[test]
+    fn load_default_propagates_malformed_config_errors() {
+        let dir = tempfile::tempdir().expect("failed to create temp dir");
+        fs::write(dir.path().join("rubydex.toml"), "exclude = [\n").unwrap();
+
+        let mut config = Config::new();
+        config.set_workspace_path(dir.path().to_path_buf());
+
+        let error = config
+            .load_default()
+            .expect_err("a malformed default config must still be an error");
+
+        assert!(matches!(error, Errors::ConfigError(_)), "unexpected error: {error:?}");
+    }
+
+    #[test]
+    fn parse_defaults_the_excluded_paths_to_empty_when_the_key_is_absent() {
+        let file = Config::parse("").expect("an empty config is valid");
+        assert!(file.exclude.is_empty());
+    }
+
+    #[test]
+    fn parse_rejects_an_exclude_value_of_the_wrong_type() {
+        Config::parse("exclude = \"vendor\"").expect_err("exclude must be an array of strings, not a string");
+    }
+}

data/rust/rubydex/src/errors.rs

@@ -25,4 +25,6 @@ macro_rules! errors {
 
 errors!(
     FileError;
+    ConfigError;
+    ConfigNotFound;
 );

data/rust/rubydex/src/lib.rs

@@ -1,4 +1,11 @@
+// Setting the global allocator needs to happen during linking and consumers may not always want to change the global
+// allocator. We gate the usage of jemalloc with a cargo feature, so that consumers can decide if they want to use it
+#[cfg(all(feature = "jemalloc", not(target_os = "windows")))]
+#[global_allocator]
+static GLOBAL: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
 pub mod compile_assertions;
+pub mod config;
 pub mod diagnostic;
 pub mod dot;
 pub mod errors;

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

@@ -1,5 +1,4 @@
 use crate::assert_mem_size;
-use crate::diagnostic::Diagnostic;
 use crate::model::ids::{
     ClassVariableReferenceId, GlobalVariableReferenceId, InstanceVariableReferenceId, MethodReferenceId,
 };
@@ -111,8 +110,6 @@ macro_rules! namespace_declaration {
             descendants: IdentityHashSet<DeclarationId>,
             /// The singleton class associated with this declaration
             singleton_class_id: Option<DeclarationId>,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
         }
 
         impl $name {
@@ -127,13 +124,11 @@ macro_rules! namespace_declaration {
                     ancestors: Ancestors::Partial(Vec::new()),
                     descendants: IdentityHashSet::default(),
                     singleton_class_id: None,
-                    diagnostics: Vec::new(),
                 }
             }
 
-            pub fn extend(&mut self, mut other: Declaration) {
+            pub fn extend(&mut self, other: Declaration) {
                 self.definition_ids.extend(other.definitions());
-                self.diagnostics.extend(other.take_diagnostics());
 
                 match other {
                     Declaration::Namespace(namespace) => {
@@ -243,8 +238,6 @@ macro_rules! simple_declaration {
             references: IdentityHashSet<$reference_type>,
             /// The ID of the owner of this declaration
             owner_id: DeclarationId,
-            /// Diagnostics associated with this declaration
-            diagnostics: Vec<Diagnostic>,
         }
 
         impl $name {
@@ -255,13 +248,11 @@ macro_rules! simple_declaration {
                     definition_ids: Vec::new(),
                     references: IdentityHashSet::default(),
                     owner_id,
-                    diagnostics: Vec::new(),
                 }
             }
 
-            pub fn extend(&mut self, mut other: $name) {
+            pub fn extend(&mut self, other: $name) {
                 self.definition_ids.extend(other.definitions());
-                self.diagnostics.extend(other.take_diagnostics());
                 self.references.extend(other.references());
             }
 
@@ -278,10 +269,6 @@ macro_rules! simple_declaration {
                 self.references.remove(reference_id);
             }
 
-            pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-                std::mem::take(&mut self.diagnostics)
-            }
-
             #[must_use]
             pub fn definitions(&self) -> &[DefinitionId] {
                 &self.definition_ids
@@ -436,23 +423,6 @@ impl Declaration {
         })
     }
 
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_declarations!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_declarations!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
-    pub fn add_diagnostic(&mut self, diagnostic: Diagnostic) {
-        all_declarations!(self, it => it.diagnostics.push(diagnostic));
-    }
-
-    pub fn clear_diagnostics(&mut self) {
-        all_declarations!(self, it => it.diagnostics.clear());
-    }
-
     #[must_use]
     pub fn reference_count(&self) -> usize {
         all_declarations!(self, it => it.references.len())
@@ -546,15 +516,6 @@ impl Namespace {
         all_namespaces!(self, it => &it.members)
     }
 
-    #[must_use]
-    pub fn diagnostics(&self) -> &[Diagnostic] {
-        all_namespaces!(self, it => &it.diagnostics)
-    }
-
-    pub fn take_diagnostics(&mut self) -> Vec<Diagnostic> {
-        all_namespaces!(self, it => std::mem::take(&mut it.diagnostics))
-    }
-
     pub fn extend(&mut self, other: Declaration) {
         all_namespaces!(self, it => it.extend(other));
     }
@@ -647,25 +608,25 @@ impl Namespace {
 }
 
 namespace_declaration!(Class, ClassDeclaration);
-assert_mem_size!(ClassDeclaration, 216);
+assert_mem_size!(ClassDeclaration, 192);
 namespace_declaration!(Module, ModuleDeclaration);
-assert_mem_size!(ModuleDeclaration, 216);
+assert_mem_size!(ModuleDeclaration, 192);
 namespace_declaration!(SingletonClass, SingletonClassDeclaration);
-assert_mem_size!(SingletonClassDeclaration, 216);
+assert_mem_size!(SingletonClassDeclaration, 192);
 namespace_declaration!(Todo, TodoDeclaration);
-assert_mem_size!(TodoDeclaration, 216);
+assert_mem_size!(TodoDeclaration, 192);
 simple_declaration!(ConstantDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantDeclaration, 112);
+assert_mem_size!(ConstantDeclaration, 88);
 simple_declaration!(MethodDeclaration, MethodReferenceId);
-assert_mem_size!(MethodDeclaration, 112);
+assert_mem_size!(MethodDeclaration, 88);
 simple_declaration!(GlobalVariableDeclaration, GlobalVariableReferenceId);
-assert_mem_size!(GlobalVariableDeclaration, 112);
+assert_mem_size!(GlobalVariableDeclaration, 88);
 simple_declaration!(InstanceVariableDeclaration, InstanceVariableReferenceId);
-assert_mem_size!(InstanceVariableDeclaration, 112);
+assert_mem_size!(InstanceVariableDeclaration, 88);
 simple_declaration!(ClassVariableDeclaration, ClassVariableReferenceId);
-assert_mem_size!(ClassVariableDeclaration, 112);
+assert_mem_size!(ClassVariableDeclaration, 88);
 simple_declaration!(ConstantAliasDeclaration, ConstantReferenceId);
-assert_mem_size!(ConstantAliasDeclaration, 112);
+assert_mem_size!(ConstantAliasDeclaration, 88);
 
 #[cfg(test)]
 mod tests {

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};
@@ -85,10 +87,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 +106,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 +128,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 +515,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
@@ -1201,9 +1227,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 {

data/rust/rubydex/src/resolution.rs

@@ -710,18 +710,8 @@ impl<'a> Resolver<'a> {
                     offset,
                     format!("undefined method `{owner_name}#{method_name}` for visibility change"),
                 );
-                if is_singleton {
-                    // Document-scoped: the singleton class may be synthetic (created by this
-                    // visibility resolution) and won't be cleaned up on file delete, so attaching
-                    // the diagnostic to the declaration would leave it orphaned.
-                    self.graph.add_document_diagnostic(uri_id, diagnostic);
-                } else {
-                    self.graph
-                        .declarations_mut()
-                        .get_mut(&owner_id)
-                        .unwrap()
-                        .add_diagnostic(diagnostic);
-                }
+
+                self.graph.add_document_diagnostic(uri_id, diagnostic);
             }
         }
 

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

@@ -7,6 +7,7 @@ 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;
@@ -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;
@@ -197,7 +198,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 +217,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 +302,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