rubydex 0.3.0 → 0.4.1

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

@@ -6,7 +6,9 @@ use crate::location_api::{Location, create_location_for_uri_and_offset};
 use crate::reference_api::CConstantReference;
 use libc::c_char;
 use rubydex::model::definitions::{Definition, Mixin};
-use rubydex::model::ids::DefinitionId;
+use rubydex::model::graph::Graph;
+use rubydex::model::ids::{DefinitionId, NameId};
+use rubydex::model::name::ParentScope;
 use rubydex::query::AliasResolutionError;
 use std::ffi::CString;
 use std::ptr;
@@ -110,6 +112,71 @@ pub unsafe extern "C" fn rdx_definition_name(pointer: GraphPointer, definition_i
     })
 }
 
+fn raw_name_for_name(graph: &Graph, name_id: NameId) -> String {
+    let mut raw_name = String::new();
+    append_raw_name(graph, name_id, &mut raw_name);
+    raw_name
+}
+
+fn append_raw_name(graph: &Graph, name_id: NameId, raw_name: &mut String) {
+    let name = graph
+        .names()
+        .get(&name_id)
+        .expect("name should exist while building raw_name");
+    let simple_name = graph
+        .strings()
+        .get(name.str())
+        .expect("string should exist while building raw_name")
+        .as_str();
+
+    match name.parent_scope() {
+        ParentScope::None => {}
+        ParentScope::TopLevel => raw_name.push_str("::"),
+        ParentScope::Some(parent_id) | ParentScope::Attached(parent_id) => {
+            append_raw_name(graph, *parent_id, raw_name);
+            raw_name.push_str("::");
+        }
+    }
+
+    raw_name.push_str(simple_name);
+}
+
+fn raw_name_id(definition: &Definition) -> Option<&NameId> {
+    match definition {
+        Definition::Class(_) | Definition::Module(_) | Definition::Constant(_) | Definition::ConstantAlias(_) => {
+            definition.name_id()
+        }
+        _ => None,
+    }
+}
+
+/// Returns the UTF-8 raw name string for a class, module, constant, or constant-alias definition id.
+///
+/// The raw name is reconstructed from the definition's `Name`, preserving explicit parent scopes like `Foo::Bar` and
+/// rooted paths like `::Bar`. Returns null if the definition cannot be found or does not support raw names. Caller must
+/// free a non-null result with `free_c_string`.
+///
+/// # Panics
+///
+/// Panics if the graph contains an invalid name or string reference, or if the name contains an embedded null byte.
+///
+/// # Safety
+///
+/// Assumes pointer is valid.
+///
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_raw_name(pointer: GraphPointer, definition_id: u64) -> *const c_char {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let Some(name_id) = graph.definitions().get(&def_id).and_then(raw_name_id) else {
+            return ptr::null();
+        };
+
+        let name = raw_name_for_name(graph, *name_id);
+        CString::new(name).unwrap().into_raw().cast_const()
+    })
+}
+
 /// Shared iterator over definition (id, kind) pairs
 #[derive(Debug)]
 pub struct DefinitionsIter {

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

@@ -3,12 +3,52 @@
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
 use libc::c_char;
+use rubydex::diagnostic::{Rule, Severity};
 use std::{ffi::CString, mem, ptr};
 
+/// C-compatible enum representing diagnostic severity levels.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum DiagnosticSeverity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4,
+}
+
+impl From<Severity> for DiagnosticSeverity {
+    fn from(severity: Severity) -> Self {
+        match severity {
+            Severity::Error => DiagnosticSeverity::Error,
+            Severity::Warning => DiagnosticSeverity::Warning,
+            Severity::Information => DiagnosticSeverity::Information,
+            Severity::Hint => DiagnosticSeverity::Hint,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CRule {
+    pub name: *const c_char,
+    pub name_length: usize,
+}
+
+impl From<Rule> for CRule {
+    fn from(rule: Rule) -> Self {
+        let name = rule.name();
+
+        Self {
+            name: name.as_ptr().cast::<c_char>(),
+            name_length: name.len(),
+        }
+    }
+}
+
 /// C-compatible struct representing a diagnostic entry.
 #[repr(C)]
 pub struct DiagnosticEntry {
-    pub rule: *const c_char,
+    pub rule: CRule,
     pub message: *const c_char,
     pub location: *mut Location,
 }
@@ -50,10 +90,7 @@ pub unsafe extern "C" fn rdx_graph_diagnostics(pointer: GraphPointer) -> *mut Di
                 let location = create_location_for_uri_and_offset(graph, document, diagnostic.offset());
 
                 DiagnosticEntry {
-                    rule: CString::new(diagnostic.rule().to_string())
-                        .unwrap()
-                        .into_raw()
-                        .cast_const(),
+                    rule: CRule::from(*diagnostic.rule()),
                     message: CString::new(diagnostic.message()).unwrap().into_raw().cast_const(),
                     location,
                 }
@@ -82,9 +119,6 @@ pub unsafe extern "C" fn rdx_diagnostics_free(ptr: *mut DiagnosticArray) {
         let mut boxed_slice: Box<[DiagnosticEntry]> = unsafe { Box::from_raw(slice_ptr) };
 
         for entry in &mut *boxed_slice {
-            if !entry.rule.is_null() {
-                let _ = unsafe { CString::from_raw(entry.rule.cast_mut()) };
-            }
             if !entry.message.is_null() {
                 let _ = unsafe { CString::from_raw(entry.message.cast_mut()) };
             }

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

@@ -1,5 +1,6 @@
 //! This file provides the C API for the Graph object
 
+use crate::config_api::ConfigPointer;
 use crate::declaration_api::CDeclaration;
 use crate::declaration_api::DeclarationsIter;
 use crate::declaration_api::decl_id_from_char_ptr;
@@ -7,20 +8,20 @@ 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::config::Config;
 use rubydex::indexing::LanguageId;
+use rubydex::model::definitions::Definition;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId, UriId, declaration_id_from_lookup_name};
+use rubydex::model::ids::{DeclarationId, DefinitionId, NameId, UriId, declaration_id_from_lookup_name};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::model::visibility::Visibility;
-use rubydex::query::cypher::{self, OutputFormat};
 use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver};
 use rubydex::resolution::Resolver;
 use rubydex::{indexing, integrity, listing, query};
 use std::ffi::CString;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::{mem, ptr, sync::RwLock};
 
 pub type GraphPointer = *mut c_void;
@@ -133,6 +134,27 @@ pub unsafe extern "C" fn rdx_graph_declarations_fuzzy_search(
     DeclarationsIter::new(entries)
 }
 
+/// Returns an iterator over all dead code candidates in the graph.
+///
+/// # Safety
+///
+/// Expects `pointer` to be a valid graph. The returned iterator must be freed with `rdx_graph_declarations_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_dead_code_candidates(pointer: GraphPointer) -> *mut DeclarationsIter {
+    let entries = with_graph(pointer, |graph| {
+        query::dead_code_candidates(graph)
+            .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
 ///
 /// Will panic if the nesting cannot be transformed into a vector of strings
@@ -155,24 +177,103 @@ pub unsafe extern "C" fn rdx_graph_resolve_constant(
             return ptr::null();
         };
 
-        let mut resolver = Resolver::new(graph);
+        resolve_constant_name(graph, name_id, names_to_untrack)
+    })
+}
 
-        let declaration = match resolver.resolve_constant(name_id) {
-            Some(id) => {
-                let decl = graph.declarations().get(&id).unwrap();
-                Box::into_raw(Box::new(CDeclaration::from_declaration(id, decl))).cast_const()
+/// Result of resolving a constant using a namespace definition as its lexical context.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CDefinitionConstantResolution {
+    Resolved = 0,
+    NotFound = 1,
+    DefinitionNotFound = 2,
+    InvalidDefinitionKind = 3,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CDefinitionConstantResolutionResult {
+    pub status: CDefinitionConstantResolution,
+    pub declaration: *const CDeclaration,
+}
+
+/// Resolves a constant using a namespace definition as its lexical context.
+///
+/// # Panics
+///
+/// Panics if `const_name` cannot be converted to a string.
+///
+/// # Safety
+///
+/// Assumes that `pointer` and `const_name` are valid.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_resolve_constant_from_definition(
+    pointer: GraphPointer,
+    const_name: *const c_char,
+    definition_id: u64,
+) -> CDefinitionConstantResolutionResult {
+    with_mut_graph(pointer, |graph| {
+        let const_name: String = unsafe { utils::convert_char_ptr_to_string(const_name).unwrap() };
+        let nesting = match class_or_module_definition_name_id(graph, DefinitionId::new(definition_id)) {
+            Ok(nesting) => nesting,
+            Err(status) => {
+                return CDefinitionConstantResolutionResult {
+                    status,
+                    declaration: ptr::null(),
+                };
             }
-            None => ptr::null(),
         };
 
-        for name_id in names_to_untrack {
-            graph.untrack_name(name_id);
-        }
+        let Some((name_id, names_to_untrack)) = name_api::name_in_nesting_to_name_id(graph, &const_name, Some(nesting))
+        else {
+            return CDefinitionConstantResolutionResult {
+                status: CDefinitionConstantResolution::NotFound,
+                declaration: ptr::null(),
+            };
+        };
+
+        let declaration = resolve_constant_name(graph, name_id, names_to_untrack);
+        let status = if declaration.is_null() {
+            CDefinitionConstantResolution::NotFound
+        } else {
+            CDefinitionConstantResolution::Resolved
+        };
 
-        declaration
+        CDefinitionConstantResolutionResult { status, declaration }
     })
 }
 
+fn class_or_module_definition_name_id(
+    graph: &Graph,
+    definition_id: DefinitionId,
+) -> Result<NameId, CDefinitionConstantResolution> {
+    let Some(definition) = graph.definitions().get(&definition_id) else {
+        return Err(CDefinitionConstantResolution::DefinitionNotFound);
+    };
+
+    match definition {
+        Definition::Class(definition) => Ok(*definition.name_id()),
+        Definition::SingletonClass(definition) => Ok(*definition.name_id()),
+        Definition::Module(definition) => Ok(*definition.name_id()),
+        _ => Err(CDefinitionConstantResolution::InvalidDefinitionKind),
+    }
+}
+
+fn resolve_constant_name(graph: &mut Graph, name_id: NameId, names_to_untrack: Vec<NameId>) -> *const CDeclaration {
+    let declaration_id = Resolver::new(graph).resolve_constant(name_id);
+    let declaration = declaration_id.map_or(ptr::null(), |id| {
+        let declaration = graph.declarations().get(&id).unwrap();
+        Box::into_raw(Box::new(CDeclaration::from_declaration(id, declaration))).cast_const()
+    });
+
+    for name_id in names_to_untrack {
+        graph.untrack_name(name_id);
+    }
+
+    declaration
+}
+
 /// Adds glob patterns to exclude from file discovery during indexing.
 ///
 /// # Panics
@@ -216,14 +317,8 @@ pub unsafe extern "C" fn rdx_graph_excluded_patterns(
 
         let c_strings: Vec<*const c_char> = excluded
             .iter()
-            .filter_map(|path| {
-                // 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.replace(std::path::MAIN_SEPARATOR, "/");
-
-                CString::new(normalized)
+            .filter_map(|pattern| {
+                CString::new(pattern.as_ref())
                     .ok()
                     .map(|c_string| c_string.into_raw().cast_const())
             })
@@ -236,23 +331,6 @@ pub unsafe extern "C" fn rdx_graph_excluded_patterns(
     })
 }
 
-/// 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
@@ -261,42 +339,23 @@ pub unsafe extern "C" fn rdx_graph_set_workspace_path(pointer: GraphPointer, pat
 #[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())
+        CString::new(utils::interop_path(graph.workspace_path()))
             .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.
+/// Applies a parsed configuration file to the graph, which adopts the workspace it was loaded for along with the
+/// settings of its `[graph]` section. This is the only way to point the graph at a workspace other than the current
+/// directory, and it replaces any previously applied configuration. Tool-specific sections are ignored.
 ///
 /// # Safety
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `config_path` must either be NULL or a valid, null-terminated string.
+/// - `config` must be a valid `ConfigPointer` previously returned by `rdx_config_load`.
 #[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(),
-    }
+pub unsafe extern "C" fn rdx_graph_load_config(pointer: GraphPointer, config: ConfigPointer) {
+    let config = unsafe { &*config.cast::<Config>() };
+    with_mut_graph(pointer, |graph| graph.load_config(config));
 }
 
 /// Indexes all given file paths in parallel using the provided Graph pointer.
@@ -1066,145 +1125,6 @@ pub unsafe extern "C" fn rdx_keyword_get(name: *const c_char) -> *const CKeyword
     }
 }
 
-/// The result of running a Cypher query, carrying either the formatted output or an error message.
-#[repr(C)]
-pub struct CQueryResult {
-    /// Non-null on success; null on error. Caller must free with `free_c_string`.
-    pub output: *const c_char,
-    /// Non-null on error; null on success. Caller must free with `free_c_string`.
-    pub error: *const c_char,
-}
-
-impl CQueryResult {
-    fn success(output: &str) -> Self {
-        match CString::new(output) {
-            Ok(c_string) => Self {
-                output: c_string.into_raw().cast_const(),
-                error: ptr::null(),
-            },
-            Err(_) => Self::error("query output contained an interior NUL byte"),
-        }
-    }
-
-    fn error(message: &str) -> Self {
-        Self {
-            output: ptr::null(),
-            error: CString::new(message).map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        }
-    }
-}
-
-/// The result of parsing a Cypher query into an opaque, reusable parsed-query object.
-#[repr(C)]
-pub struct CParseResult {
-    /// Non-null on success: a heap-allocated parsed query. Free with `rdx_cypher_query_free`.
-    pub query: *mut c_void,
-    /// Non-null on error; null on success. Caller must free with `free_c_string`.
-    pub error: *const c_char,
-}
-
-/// Parses a Cypher query string into an opaque parsed-query object, without needing a graph.
-///
-/// On success, `query` is a heap-allocated parsed query that can be executed against a graph with
-/// `rdx_query_run` and must eventually be freed with `rdx_cypher_query_free`. On failure, `error`
-/// holds the message.
-///
-/// # Safety
-///
-/// - `query` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_parse(query: *const c_char) -> CParseResult {
-    let Ok(query_str) = (unsafe { utils::convert_char_ptr_to_string(query) }) else {
-        return CParseResult {
-            query: ptr::null_mut(),
-            error: CString::new("query is not valid UTF-8").map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        };
-    };
-
-    match cypher::parse(&query_str) {
-        Ok(parsed) => CParseResult {
-            query: Box::into_raw(Box::new(parsed)).cast::<c_void>(),
-            error: ptr::null(),
-        },
-        Err(error) => CParseResult {
-            query: ptr::null_mut(),
-            error: CString::new(error.to_string()).map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        },
-    }
-}
-
-/// Frees a parsed query previously returned by `rdx_cypher_parse`.
-///
-/// # Safety
-///
-/// - `query` must be a pointer returned by `rdx_cypher_parse`, or null. It must not be used after.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_query_free(query: *mut c_void) {
-    if query.is_null() {
-        return;
-    }
-    let _ = unsafe { Box::from_raw(query.cast::<cypher::Query>()) };
-}
-
-/// Executes a previously parsed query (from `rdx_cypher_parse`) against the graph and returns the
-/// formatted output or an error message. `format` must be `"table"` or `"json"`.
-///
-/// # Safety
-///
-/// - `query` must be a valid pointer returned by `rdx_cypher_parse`.
-/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `format` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_query_run(
-    query: *const c_void,
-    pointer: GraphPointer,
-    format: *const c_char,
-) -> CQueryResult {
-    if query.is_null() {
-        return CQueryResult::error("query is null");
-    }
-
-    let Ok(format_str) = (unsafe { utils::convert_char_ptr_to_string(format) }) else {
-        return CQueryResult::error("format is not valid UTF-8");
-    };
-
-    let output_format = match format_str.as_str() {
-        "table" => OutputFormat::Table,
-        "json" => OutputFormat::Json,
-        other => {
-            return CQueryResult::error(&format!("unknown query format `{other}` (expected `table` or `json`)"));
-        }
-    };
-
-    let parsed = unsafe { &*query.cast::<cypher::Query>() };
-
-    with_graph(pointer, |graph| {
-        match cypher::run_parsed(graph, parsed, output_format) {
-            Ok(output) => CQueryResult::success(&output),
-            Err(error) => CQueryResult::error(&error.to_string()),
-        }
-    })
-}
-
-/// Returns a description of the queryable Cypher schema (node labels, relationship types, and
-/// properties) in the given format (`"table"` or `"json"`). The schema is static and requires no
-/// graph. Caller must free the returned pointer with `free_c_string`.
-///
-/// # Safety
-///
-/// - `format` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_schema(format: *const c_char) -> *const c_char {
-    let format_str = unsafe { utils::convert_char_ptr_to_string(format) }.unwrap_or_else(|_| "table".to_string());
-    let output_format = if format_str == "json" {
-        OutputFormat::Json
-    } else {
-        OutputFormat::Table
-    };
-
-    CString::new(cypher::schema(output_format)).map_or(ptr::null(), |s| s.into_raw().cast_const())
-}
-
 #[repr(u8)]
 #[derive(Debug, Clone, Copy)]
 pub enum CVisibility {

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

@@ -68,6 +68,8 @@ macro_rules! iterator {
     };
 }
 
+pub mod config_api;
+pub mod cypher_api;
 pub mod declaration_api;
 pub mod definition_api;
 pub mod diagnostic_api;