rubydex 0.1.0.beta1-x86_64-linux → 0.1.0.beta2-x86_64-linux

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

@@ -0,0 +1,493 @@
+//! This file provides the C API for the Graph object
+
+use crate::reference_api::{ReferenceKind, ReferencesIter};
+use crate::{name_api, utils};
+use libc::{c_char, c_void};
+use rubydex::model::encoding::Encoding;
+use rubydex::model::graph::Graph;
+use rubydex::model::ids::DeclarationId;
+use rubydex::resolution::Resolver;
+use rubydex::{indexing, listing, query};
+use std::ffi::CString;
+use std::{mem, ptr};
+
+pub type GraphPointer = *mut c_void;
+
+/// Creates a new graph within a mutex. This is meant to be used when creating new Graph objects in Ruby
+#[unsafe(no_mangle)]
+pub extern "C" fn rdx_graph_new() -> GraphPointer {
+    Box::into_raw(Box::new(Graph::new())) as GraphPointer
+}
+
+/// Frees a Graph through its pointer
+#[unsafe(no_mangle)]
+pub extern "C" fn rdx_graph_free(pointer: GraphPointer) {
+    unsafe {
+        let _ = Box::from_raw(pointer.cast::<Graph>());
+    }
+}
+
+pub fn with_graph<F, T>(pointer: GraphPointer, action: F) -> T
+where
+    F: FnOnce(&mut Graph) -> T,
+{
+    let mut graph = unsafe { Box::from_raw(pointer.cast::<Graph>()) };
+    let result = action(&mut graph);
+    mem::forget(graph);
+    result
+}
+
+/// Searches the graph based on query and returns all declarations that match
+///
+/// # Safety
+///
+/// Expects both the graph and the query pointers to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_declarations_search(
+    pointer: GraphPointer,
+    c_query: *const c_char,
+) -> *mut DeclarationsIter {
+    let Ok(query) = (unsafe { utils::convert_char_ptr_to_string(c_query) }) else {
+        return ptr::null_mut();
+    };
+
+    let ids = with_graph(pointer, |graph| {
+        query::declaration_search(graph, &query)
+            .into_iter()
+            .map(|id| *id)
+            .collect::<Vec<i64>>()
+            .into_boxed_slice()
+    });
+
+    Box::into_raw(Box::new(DeclarationsIter { ids, index: 0 }))
+}
+
+/// # Panics
+///
+/// Will panic if the nesting cannot be transformed into a vector of strings
+///
+/// # Safety
+///
+/// Assumes that the `const_name` and `nesting` pointer are valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_resolve_constant(
+    pointer: GraphPointer,
+    const_name: *const c_char,
+    nesting: *const *const c_char,
+    count: usize,
+) -> *const i64 {
+    with_graph(pointer, |graph| {
+        let nesting: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(nesting, count).unwrap() };
+        let const_name: String = unsafe { utils::convert_char_ptr_to_string(const_name).unwrap() };
+        let (name_id, names_to_untrack) = name_api::nesting_stack_to_name_id(graph, &const_name, nesting);
+
+        let mut resolver = Resolver::new(graph);
+
+        let resolved_id = match resolver.resolve_constant(name_id) {
+            Some(id) => Box::into_raw(Box::new(*id)).cast_const(),
+            None => ptr::null(),
+        };
+
+        for name_id in names_to_untrack {
+            graph.untrack_name(name_id);
+        }
+        resolved_id
+    })
+}
+
+/// Indexes all given file paths in parallel using the provided Graph pointer
+///
+/// # Panics
+///
+/// Will panic if the given array of C string file paths cannot be converted to a Vec<String>
+///
+/// # Safety
+///
+/// This function is unsafe because it dereferences raw pointers coming from C. The caller has to ensure that the Ruby
+/// VM will not free the pointers related to the string array while they are in use by Rust
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_index_all(
+    pointer: GraphPointer,
+    file_paths: *const *const c_char,
+    count: usize,
+) -> *const c_char {
+    let file_paths: Vec<String> = unsafe { utils::convert_double_pointer_to_vec(file_paths, count).unwrap() };
+    let (file_paths, errors) = listing::collect_file_paths(file_paths);
+
+    if !errors.is_empty() {
+        let error_messages = errors
+            .iter()
+            .map(std::string::ToString::to_string)
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        return CString::new(error_messages).unwrap().into_raw().cast_const();
+    }
+
+    with_graph(pointer, |graph| {
+        let errors = indexing::index_files(graph, file_paths);
+
+        if !errors.is_empty() {
+            let error_messages = errors
+                .iter()
+                .map(std::string::ToString::to_string)
+                .collect::<Vec<_>>()
+                .join("\n");
+
+            return CString::new(error_messages).unwrap().into_raw().cast_const();
+        }
+
+        ptr::null()
+    })
+}
+
+/// Runs the resolver to compute declarations, ownership and related structures
+#[unsafe(no_mangle)]
+pub extern "C" fn rdx_graph_resolve(pointer: GraphPointer) {
+    with_graph(pointer, |graph| {
+        let mut resolver = Resolver::new(graph);
+        resolver.resolve_all();
+    });
+}
+
+/// # Safety
+///
+/// Expects both the graph pointer and encoding string pointer to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_set_encoding(pointer: GraphPointer, encoding_str: *const c_char) -> bool {
+    let Ok(encoding) = (unsafe { utils::convert_char_ptr_to_string(encoding_str) }) else {
+        return false;
+    };
+
+    let encoding_variant = match encoding.as_str() {
+        "utf8" => Encoding::Utf8,
+        "utf16" => Encoding::Utf16,
+        "utf32" => Encoding::Utf32,
+        _ => {
+            return false;
+        }
+    };
+
+    with_graph(pointer, |graph| {
+        graph.set_encoding(encoding_variant);
+    });
+
+    true
+}
+
+/// An iterator over declaration IDs
+///
+/// We snapshot the IDs at iterator creation so if the graph is modified, the iterator will not see the changes
+#[derive(Debug)]
+pub struct DeclarationsIter {
+    /// The snapshot of declaration IDs
+    ids: Box<[i64]>,
+    /// The current index of the iterator
+    index: usize,
+}
+
+/// Creates a new iterator over declaration IDs by snapshotting the current set of IDs.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - The returned pointer must be freed with `rdx_graph_declarations_iter_free`.
+///
+/// # Panics
+///
+/// Will panic if acquiring a read lock on the graph's declarations fails
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_declarations_iter_new(pointer: GraphPointer) -> *mut DeclarationsIter {
+    // Snapshot the IDs at iterator creation to avoid borrowing across FFI calls
+    let ids = with_graph(pointer, |graph| {
+        graph
+            .declarations()
+            .keys()
+            .map(|name_id| **name_id)
+            .collect::<Vec<i64>>()
+            .into_boxed_slice()
+    });
+
+    Box::into_raw(Box::new(DeclarationsIter { ids, index: 0 }))
+}
+
+/// Returns the total number of IDs in the iterator snapshot.
+///
+/// # Safety
+///
+/// - `iter` must be a valid pointer previously returned by `rdx_graph_declarations_iter_new`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_declarations_iter_len(iter: *const DeclarationsIter) -> usize {
+    if iter.is_null() {
+        return 0;
+    }
+
+    unsafe { (&*iter).ids.len() }
+}
+
+/// Advances the iterator and writes the next ID into `out_id`.
+/// Returns `true` if an ID was written, or `false` if the iterator is exhausted or inputs are invalid.
+///
+/// # Safety
+///
+/// - `iter` must be a valid pointer previously returned by `rdx_graph_declarations_iter_new`.
+/// - `out_id` must be a valid, writable pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_declarations_iter_next(iter: *mut DeclarationsIter, out_id: *mut i64) -> bool {
+    if iter.is_null() || out_id.is_null() {
+        return false;
+    }
+
+    let it = unsafe { &mut *iter };
+    if it.index >= it.ids.len() {
+        return false;
+    }
+
+    let id = it.ids[it.index];
+    it.index += 1;
+    unsafe { *out_id = id };
+
+    true
+}
+
+/// Frees an iterator created by `rdx_graph_declarations_iter_new`.
+///
+/// # Safety
+///
+/// - `iter` must be a pointer previously returned by `rdx_graph_declarations_iter_new`.
+/// - `iter` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_declarations_iter_free(iter: *mut DeclarationsIter) {
+    if iter.is_null() {
+        return;
+    }
+
+    unsafe {
+        let _ = Box::from_raw(iter);
+    }
+}
+
+/// An iterator over document (URI) IDs
+///
+/// We snapshot the IDs at iterator creation so if the graph is modified, the iterator will not see the changes
+#[derive(Debug)]
+pub struct DocumentsIter {
+    /// The snapshot of document (URI) IDs
+    ids: Box<[i64]>,
+    /// The current index of the iterator
+    index: usize,
+}
+
+/// Creates a new iterator over document (URI) IDs by snapshotting the current set of IDs.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - The returned pointer must be freed with `rdx_graph_documents_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_documents_iter_new(pointer: GraphPointer) -> *mut DocumentsIter {
+    // Snapshot the IDs at iterator creation to avoid borrowing across FFI calls
+    let ids = with_graph(pointer, |graph| {
+        graph
+            .documents()
+            .keys()
+            .map(|uri_id| **uri_id)
+            .collect::<Vec<i64>>()
+            .into_boxed_slice()
+    });
+
+    Box::into_raw(Box::new(DocumentsIter { ids, index: 0 }))
+}
+
+/// Returns the total number of IDs in the iterator snapshot.
+///
+/// # Safety
+///
+/// - `iter` must be a valid pointer previously returned by `rdx_graph_documents_iter_new`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_documents_iter_len(iter: *const DocumentsIter) -> usize {
+    if iter.is_null() {
+        return 0;
+    }
+
+    unsafe { (&*iter).ids.len() }
+}
+
+/// Advances the iterator and writes the next ID into `out_id`.
+/// Returns `true` if an ID was written, or `false` if the iterator is exhausted or inputs are invalid.
+///
+/// # Safety
+///
+/// - `iter` must be a valid pointer previously returned by `rdx_graph_documents_iter_new`.
+/// - `out_id` must be a valid, writable pointer.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_documents_iter_next(iter: *mut DocumentsIter, out_id: *mut i64) -> bool {
+    if iter.is_null() || out_id.is_null() {
+        return false;
+    }
+
+    let it = unsafe { &mut *iter };
+    if it.index >= it.ids.len() {
+        return false;
+    }
+
+    let id = it.ids[it.index];
+    it.index += 1;
+    unsafe { *out_id = id };
+
+    true
+}
+
+/// Frees an iterator created by `rdx_graph_documents_iter_new`.
+///
+/// # Safety
+///
+/// - `iter` must be a pointer previously returned by `rdx_graph_documents_iter_new`.
+/// - `iter` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_documents_iter_free(iter: *mut DocumentsIter) {
+    if iter.is_null() {
+        return;
+    }
+
+    unsafe {
+        let _ = Box::from_raw(iter);
+    }
+}
+
+/// Attempts to resolve a declaration from a fully-qualified name string.
+/// Returns a pointer to the internal ID if it exists, or NULL if it does not.
+///
+/// # Safety
+/// - `pointer` must be a valid `GraphPointer`
+/// - `name` must be a valid, null-terminated UTF-8 string
+/// - `out_id` must be a valid, writable pointer
+///
+/// # Panics
+///
+/// Will panic if acquiring a read lock on the graph's declarations fails
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_get_declaration(pointer: GraphPointer, name: *const c_char) -> *const i64 {
+    let Ok(name_str) = (unsafe { utils::convert_char_ptr_to_string(name) }) else {
+        return ptr::null();
+    };
+
+    with_graph(pointer, |graph| {
+        // TODO: We should perform name resolution instead of accessing the graph with the canonical ID
+        let decl_id = DeclarationId::from(name_str.as_str());
+        if graph.declarations().contains_key(&decl_id) {
+            Box::into_raw(Box::new(*decl_id)).cast_const()
+        } else {
+            ptr::null()
+        }
+    })
+}
+
+/// Creates a new iterator over constant references by snapshotting the current set of (id, kind) pairs.
+///
+/// # Safety
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_constant_references_iter_new(pointer: GraphPointer) -> *mut ReferencesIter {
+    with_graph(pointer, |graph| {
+        let refs: Vec<(i64, ReferenceKind)> = graph
+            .constant_references()
+            .keys()
+            .map(|id| (**id, ReferenceKind::Constant))
+            .collect();
+
+        ReferencesIter::new(refs.into_boxed_slice())
+    })
+}
+
+/// Creates a new iterator over method references by snapshotting the current set of (id, kind) pairs.
+///
+/// # Safety
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_method_references_iter_new(pointer: GraphPointer) -> *mut ReferencesIter {
+    with_graph(pointer, |graph| {
+        let refs: Vec<(i64, ReferenceKind)> = graph
+            .method_references()
+            .keys()
+            .map(|id| (**id, ReferenceKind::Method))
+            .collect();
+
+        ReferencesIter::new(refs.into_boxed_slice())
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use rubydex::indexing::ruby_indexer::RubyIndexer;
+
+    use super::*;
+
+    #[test]
+    fn names_are_untracked_after_resolving_constant() {
+        let mut indexer = RubyIndexer::new(
+            "file:///foo.rb".into(),
+            "
+            class Foo
+              BAR = 1
+            end
+            ",
+        );
+        indexer.index();
+
+        let mut graph = Graph::new();
+        graph.update(indexer.local_graph());
+        let mut resolver = Resolver::new(&mut graph);
+        resolver.resolve_all();
+
+        assert_eq!(
+            1,
+            graph
+                .names()
+                .iter()
+                .find_map(|(_, name)| {
+                    if graph.strings().get(name.str()).unwrap().as_str() == "BAR" {
+                        Some(name)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap()
+                .ref_count()
+        );
+
+        let graph_ptr = Box::into_raw(Box::new(graph)) as GraphPointer;
+
+        // Build the nesting array: ["Foo"] since BAR is inside class Foo
+        let nesting_strings: Vec<CString> = vec![CString::new("Foo").unwrap()];
+        let nesting_ptrs: Vec<*const c_char> = nesting_strings.iter().map(|s| s.as_ptr()).collect();
+
+        unsafe {
+            let id = rdx_graph_resolve_constant(
+                graph_ptr,
+                CString::new("BAR").unwrap().as_ptr(),
+                nesting_ptrs.as_ptr(),
+                nesting_ptrs.len(),
+            );
+            assert_eq!(*id, *DeclarationId::from("Foo::BAR"));
+        };
+
+        let graph = unsafe { Box::from_raw(graph_ptr.cast::<Graph>()) };
+
+        assert_eq!(
+            1,
+            graph
+                .names()
+                .iter()
+                .find_map(|(_, name)| {
+                    if graph.strings().get(name.str()).unwrap().as_str() == "BAR" {
+                        Some(name)
+                    } else {
+                        None
+                    }
+                })
+                .unwrap()
+                .ref_count()
+        );
+    }
+}

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

@@ -0,0 +1,9 @@
+pub mod declaration_api;
+pub mod definition_api;
+pub mod diagnostic_api;
+pub mod document_api;
+pub mod graph_api;
+pub mod location_api;
+pub mod name_api;
+pub mod reference_api;
+pub mod utils;

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

@@ -0,0 +1,79 @@
+//! Location-related C API and structs
+
+use libc::c_char;
+use rubydex::model::document::Document;
+use rubydex::model::graph::Graph;
+use rubydex::offset::Offset;
+use std::ffi::CString;
+
+/// C-compatible struct representing a definition location with offsets and line/column positions.
+#[repr(C)]
+#[derive(Debug, Clone)]
+pub struct Location {
+    pub uri: *const c_char,
+    pub start_line: u32,
+    pub end_line: u32,
+    pub start_column: u32,
+    pub end_column: u32,
+}
+
+/// Helper to create a location for a given URI and byte-offset range.
+/// Allocates and returns a pointer to `Location`. Caller must free with `rdx_location_free`.
+///
+/// # Panics
+///
+/// - If the URI cannot be converted to a file path.
+/// - If the file cannot be read.
+/// - If the offset cannot be converted to a position.
+#[must_use]
+pub(crate) fn create_location_for_uri_and_offset(graph: &Graph, document: &Document, offset: &Offset) -> *mut Location {
+    let line_index = document.line_index();
+    let start_pos = line_index.line_col(offset.start().into());
+    let end_pos = line_index.line_col(offset.end().into());
+
+    let loc = if let Some(wide_encoding) = graph.encoding().to_wide() {
+        let wide_start_pos = line_index.to_wide(wide_encoding, start_pos).unwrap();
+        let wide_end_pos = line_index.to_wide(wide_encoding, end_pos).unwrap();
+
+        Location {
+            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
+            start_line: wide_start_pos.line + 1,
+            end_line: wide_end_pos.line + 1,
+            start_column: wide_start_pos.col + 1,
+            end_column: wide_end_pos.col + 1,
+        }
+    } else {
+        Location {
+            uri: CString::new(document.uri()).unwrap().into_raw().cast_const(),
+            start_line: start_pos.line + 1,
+            end_line: end_pos.line + 1,
+            start_column: start_pos.col + 1,
+            end_column: end_pos.col + 1,
+        }
+    };
+
+    Box::into_raw(Box::new(loc))
+}
+
+/// Frees a `Location` struct and its owned inner strings.
+///
+/// # Safety
+///
+/// - `ptr` must be a valid pointer previously returned by `create_location_for_uri_and_offset`.
+/// - `ptr` must not be used after being freed.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_location_free(ptr: *mut Location) {
+    if ptr.is_null() {
+        return;
+    }
+    unsafe {
+        // Take ownership of the box so we can free inner allocations first
+        let boxed = Box::from_raw(ptr);
+
+        if !boxed.uri.is_null() {
+            let _ = CString::from_raw(boxed.uri.cast_mut());
+        }
+
+        // Box drops here, freeing the struct memory
+    }
+}

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

@@ -0,0 +1,81 @@
+use rubydex::model::{graph::Graph, ids::NameId, name::Name};
+
+/// Takes a constant name and a nesting stack (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms it into a `NameId`,
+/// registering each required part in the graph. Returns the `NameId` and a list of name ids that need to be untracked
+/// afterwards
+///
+/// # Panics
+///
+/// Should not panic because `const_name` will always be turned into a name
+pub fn nesting_stack_to_name_id(graph: &mut Graph, const_name: &str, nesting: Vec<String>) -> (NameId, Vec<NameId>) {
+    let mut current_nesting = None;
+    let mut current_name = None;
+    let mut names_to_untrack = Vec::new();
+
+    for entry in nesting {
+        for part in entry.split("::").map(String::from) {
+            let str_id = graph.intern_string(part);
+            let name_id = graph.add_name(Name::new(str_id, current_name, current_nesting));
+            names_to_untrack.push(name_id);
+            let new_name = Some(name_id);
+            current_name = new_name;
+        }
+
+        current_nesting = current_name;
+        current_name = None;
+    }
+
+    for part in const_name.split("::").map(String::from) {
+        let str_id = graph.intern_string(part);
+        let name_id = graph.add_name(Name::new(str_id, current_name, current_nesting));
+        names_to_untrack.push(name_id);
+        let new_name = Some(name_id);
+        current_name = new_name;
+    }
+
+    (
+        current_name.expect("The NameId cannot be None since it contains at least `const_name`"),
+        names_to_untrack,
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use rubydex::model::ids::StringId;
+
+    use super::*;
+
+    #[test]
+    fn nesting_is_converted_to_name_id() {
+        let mut graph = Graph::new();
+
+        let (name_id, _) = nesting_stack_to_name_id(
+            &mut graph,
+            "Some::CONST",
+            vec!["Foo".into(), "Bar::Zip".into(), "Qux".into()],
+        );
+
+        let const_name = graph.names().get(&name_id).unwrap();
+        assert_eq!(StringId::from("CONST"), *const_name.str());
+
+        let some_name = graph.names().get(&const_name.parent_scope().unwrap()).unwrap();
+        assert_eq!(StringId::from("Some"), *some_name.str());
+        assert_eq!(const_name.nesting(), some_name.nesting());
+
+        let qux_name = graph.names().get(&some_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Qux"), *qux_name.str());
+        assert!(qux_name.parent_scope().is_none());
+
+        let zip_name = graph.names().get(&qux_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Zip"), *zip_name.str());
+
+        let bar_name = graph.names().get(&zip_name.parent_scope().unwrap()).unwrap();
+        assert_eq!(StringId::from("Bar"), *bar_name.str());
+        assert_eq!(zip_name.nesting(), bar_name.nesting());
+
+        let foo_name = graph.names().get(&bar_name.nesting().unwrap()).unwrap();
+        assert_eq!(StringId::from("Foo"), *foo_name.str());
+        assert!(foo_name.parent_scope().is_none());
+        assert!(foo_name.nesting().is_none());
+    }
+}