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

data/ext/rubydex/graph.c

@@ -0,0 +1,405 @@
+#include "graph.h"
+#include "declaration.h"
+#include "diagnostic.h"
+#include "document.h"
+#include "location.h"
+#include "reference.h"
+#include "ruby/internal/globals.h"
+#include "rustbindings.h"
+#include "utils.h"
+
+static VALUE cGraph;
+static VALUE eIndexingError;
+
+// Free function for the custom Graph allocator. We always have to call into Rust to free data allocated by it
+static void graph_free(void *ptr) {
+    if (ptr) {
+        rdx_graph_free(ptr);
+    }
+}
+
+const rb_data_type_t graph_type = {"Graph", {0, graph_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+
+// Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
+// as a void pointer
+static VALUE rdxr_graph_alloc(VALUE klass) {
+    void *graph = rdx_graph_new();
+    return TypedData_Wrap_Struct(klass, &graph_type, graph);
+}
+
+// Graph#index_all: (Array[String] file_paths) -> nil
+// Raises IndexingError if anything failed during indexing
+static VALUE rdxr_graph_index_all(VALUE self, VALUE file_paths) {
+    rdxi_check_array_of_strings(file_paths);
+
+    // Convert the given file paths into a char** array, so that we can pass to Rust
+    size_t length = RARRAY_LEN(file_paths);
+    char **converted_file_paths = rdxi_str_array_to_char(file_paths, length);
+
+    // Get the underying graph pointer and then invoke the Rust index all implementation
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    const char *error_messages = rdx_index_all(graph, (const char **)converted_file_paths, length);
+
+    // Free the converted file paths and allow the GC to collect them
+    for (size_t i = 0; i < length; i++) {
+        free(converted_file_paths[i]);
+    }
+    free(converted_file_paths);
+
+    // If indexing errors were returned, turn them into a Ruby string, call Rust to free the CString it allocated and
+    // return the Ruby string
+    if (error_messages != NULL) {
+        VALUE error_string = rb_utf8_str_new_cstr(error_messages);
+        free_c_string(error_messages);
+        rb_raise(eIndexingError, "%s", StringValueCStr(error_string));
+    }
+
+    return Qnil;
+}
+
+// Body function for rb_ensure in Graph#declarations
+static VALUE graph_declarations_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    int64_t id = 0;
+    while (rdx_graph_declarations_iter_next(iter, &id)) {
+        VALUE argv[] = {self, LL2NUM(id)};
+        VALUE handle = rb_class_new_instance(2, argv, cDeclaration);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Graph#declarations to always free the iterator
+static VALUE graph_declarations_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_graph_declarations_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the declarations enumerator
+static VALUE graph_declarations_size(VALUE self, VALUE _args, VALUE _eobj) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    DeclarationsIter *iter = rdx_graph_declarations_iter_new(graph);
+    size_t len = rdx_graph_declarations_iter_len(iter);
+    rdx_graph_declarations_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Graph#declarations: () -> Enumerator[Declaration]
+// Returns an enumerator that yields all declarations lazily
+static VALUE rdxr_graph_declarations(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("declarations"), 0, NULL, graph_declarations_size);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_declarations_iter_new(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(graph_declarations_yield, args, graph_declarations_ensure, args);
+
+    return self;
+}
+
+// Graph#search: () -> Enumerator[Declaration]
+// Returns an enumerator that yields all declarations lazily
+static VALUE rdxr_graph_search(VALUE self, VALUE query) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("search"), 1, &query);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    const char *c_query = StringValueCStr(query);
+
+    void *iter = rdx_graph_declarations_search(graph, c_query);
+
+    if (iter == NULL) {
+        // The only case where the iterator will be NULL instead of a list is if the query cannot be converted to a Rust
+        // string
+        rb_raise(rb_eRuntimeError, "Converting query to Rust string failed");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(graph_declarations_yield, args, graph_declarations_ensure, args);
+
+    return self;
+}
+
+// Body function for rb_ensure in Graph#documents
+static VALUE graph_documents_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    int64_t id = 0;
+    while (rdx_graph_documents_iter_next(iter, &id)) {
+        VALUE argv[] = {self, LL2NUM(id)};
+        VALUE handle = rb_class_new_instance(2, argv, cDocument);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Graph#documents to always free the iterator
+static VALUE graph_documents_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_graph_documents_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the documents enumerator
+static VALUE graph_documents_size(VALUE self, VALUE _args, VALUE _eobj) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    DocumentsIter *iter = rdx_graph_documents_iter_new(graph);
+    size_t len = rdx_graph_documents_iter_len(iter);
+    rdx_graph_documents_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Graph#documents: () -> Enumerator[Document]
+// Returns an enumerator that yields all documents lazily
+static VALUE rdxr_graph_documents(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("documents"), 0, NULL, graph_documents_size);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_documents_iter_new(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(graph_documents_yield, args, graph_documents_ensure, args);
+
+    return self;
+}
+
+// Graph#[]: (String fully_qualified_name) -> Declaration
+// Returns a declaration handle for the given ID
+static VALUE rdxr_graph_aref(VALUE self, VALUE key) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    if (TYPE(key) != T_STRING) {
+        rb_raise(rb_eTypeError, "expected String");
+    }
+
+    const int64_t *id_ptr = rdx_graph_get_declaration(graph, StringValueCStr(key));
+    if (id_ptr == NULL) {
+        return Qnil;
+    }
+
+    int64_t id = *id_ptr;
+    free_i64(id_ptr);
+    VALUE argv[] = {self, LL2NUM(id)};
+
+    return rb_class_new_instance(2, argv, cDeclaration);
+}
+
+// Body function for rb_ensure for the reference enumerators
+static VALUE graph_references_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    int64_t id = 0;
+    ReferenceKind kind;
+    while (rdx_references_iter_next(iter, &id, &kind)) {
+        VALUE ref_class = rdxi_reference_class_for_kind(kind);
+        VALUE argv[] = {self, LL2NUM(id)};
+        VALUE obj = rb_class_new_instance(2, argv, ref_class);
+        rb_yield(obj);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure for the reference enumerators to always free the iterator
+static VALUE graph_references_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_references_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the constant_references enumerator
+static VALUE graph_constant_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    ReferencesIter *iter = rdx_graph_constant_references_iter_new(graph);
+    size_t len = rdx_references_iter_len(iter);
+    rdx_references_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Graph#constant_references: () -> Enumerator[ConstantReference]
+// Returns an enumerator that yields constant references lazily
+static VALUE rdxr_graph_constant_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("constant_references"), 0, NULL,
+                                          graph_constant_references_size);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_constant_references_iter_new(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(graph_references_yield, args, graph_references_ensure, args);
+
+    return self;
+}
+
+// Size function for the method_references enumerator
+static VALUE graph_method_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    ReferencesIter *iter = rdx_graph_method_references_iter_new(graph);
+    size_t len = rdx_references_iter_len(iter);
+    rdx_references_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Graph#method_references: () -> Enumerator[MethodReference]
+// Returns an enumerator that yields method references lazily
+static VALUE rdxr_graph_method_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("method_references"), 0, NULL,
+                                          graph_method_references_size);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_method_references_iter_new(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(graph_references_yield, args, graph_references_ensure, args);
+
+    return self;
+}
+
+// Graph#resolve: () -> self
+// Runs the resolver to compute declarations and ownership
+static VALUE rdxr_graph_resolve(VALUE self) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    rdx_graph_resolve(graph);
+    return self;
+}
+
+// Graph#set_encoding: (String) -> void
+// Sets the encoding used for transforming byte offsets into LSP code unit line/column positions
+static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
+    Check_Type(encoding, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    char *encoding_string = StringValueCStr(encoding);
+    if (!rdx_graph_set_encoding(graph, encoding_string)) {
+        rb_raise(rb_eArgError, "invalid encoding `%s` (should be utf8, utf16 or utf32)", encoding_string);
+    }
+
+    return Qnil;
+}
+
+// Graph#resolve_constant: (String, Array[String]) -> Declaration?
+// Runs the resolver on a single constant reference to determine what it points to
+static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nesting) {
+    Check_Type(const_name, T_STRING);
+    rdxi_check_array_of_strings(nesting);
+
+    // Convert the given file paths into a char** array, so that we can pass to Rust
+    size_t length = RARRAY_LEN(nesting);
+    char **converted_file_paths = rdxi_str_array_to_char(nesting, length);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    const int64_t *id_ptr =
+        rdx_graph_resolve_constant(graph, StringValueCStr(const_name), (const char **)converted_file_paths, length);
+
+    for (size_t i = 0; i < length; i++) {
+        free(converted_file_paths[i]);
+    }
+    free(converted_file_paths);
+
+    if (id_ptr == NULL) {
+        return Qnil;
+    }
+
+    int64_t id = *id_ptr;
+    free_i64(id_ptr);
+    VALUE argv[] = {self, LL2NUM(id)};
+
+    return rb_class_new_instance(2, argv, cDeclaration);
+}
+
+// Graph#diagnostics -> Array[Rubydex::Diagnostic]
+static VALUE rdxr_graph_diagnostics(VALUE self) {
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    DiagnosticArray *array = rdx_graph_diagnostics(graph);
+    if (array == NULL || array->len == 0) {
+        if (array != NULL) {
+            rdx_diagnostics_free(array);
+        }
+        return rb_ary_new();
+    }
+
+    VALUE diagnostics = rb_ary_new_capa((long)array->len);
+    for (size_t i = 0; i < array->len; i++) {
+        DiagnosticEntry entry = array->items[i];
+        VALUE message = entry.message == NULL ? Qnil : rb_utf8_str_new_cstr(entry.message);
+        VALUE rule = rb_str_new2(entry.rule);
+        VALUE location = rdxi_build_location_value(entry.location);
+
+        VALUE kwargs = rb_hash_new();
+        rb_hash_aset(kwargs, ID2SYM(rb_intern("rule")), rule);
+        rb_hash_aset(kwargs, ID2SYM(rb_intern("message")), message);
+        rb_hash_aset(kwargs, ID2SYM(rb_intern("location")), location);
+
+        VALUE diagnostic = rb_class_new_instance_kw(1, &kwargs, cDiagnostic, RB_PASS_KEYWORDS);
+        rb_ary_push(diagnostics, diagnostic);
+    }
+
+    rdx_diagnostics_free(array);
+    return diagnostics;
+}
+
+void rdxi_initialize_graph(VALUE mRubydex) {
+    VALUE eRubydexError = rb_const_get(mRubydex, rb_intern("Error"));
+    eIndexingError = rb_define_class_under(mRubydex, "IndexingError", eRubydexError);
+
+    cGraph = rb_define_class_under(mRubydex, "Graph", rb_cObject);
+    rb_define_alloc_func(cGraph, rdxr_graph_alloc);
+    rb_define_method(cGraph, "index_all", rdxr_graph_index_all, 1);
+    rb_define_method(cGraph, "resolve", rdxr_graph_resolve, 0);
+    rb_define_method(cGraph, "resolve_constant", rdxr_graph_resolve_constant, 2);
+    rb_define_method(cGraph, "declarations", rdxr_graph_declarations, 0);
+    rb_define_method(cGraph, "documents", rdxr_graph_documents, 0);
+    rb_define_method(cGraph, "constant_references", rdxr_graph_constant_references, 0);
+    rb_define_method(cGraph, "method_references", rdxr_graph_method_references, 0);
+    rb_define_method(cGraph, "diagnostics", rdxr_graph_diagnostics, 0);
+    rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
+    rb_define_method(cGraph, "search", rdxr_graph_search, 1);
+    rb_define_method(cGraph, "set_encoding", rdxr_graph_set_encoding, 1);
+}

data/ext/rubydex/graph.h

@@ -0,0 +1,10 @@
+#ifndef RUBYDEX_GRAPH_H
+#define RUBYDEX_GRAPH_H
+
+#include "ruby.h"
+
+extern const rb_data_type_t graph_type;
+
+void rdxi_initialize_graph(VALUE mRubydex);
+
+#endif // RUBYDEX_GRAPH_H

data/ext/rubydex/handle.h

@@ -0,0 +1,44 @@
+#ifndef RUBYDEX_HANDLE_H
+#define RUBYDEX_HANDLE_H
+
+#include "ruby.h"
+
+typedef struct {
+    VALUE graph_obj; // Ruby Graph object to keep it alive
+    int64_t id;      // Canonical ID (i64) mapping to a DeclarationId, DefinitionId, UriId, etc. See `ids.rs`.
+} HandleData;
+
+static void handle_mark(void *ptr) {
+    if (ptr) {
+        HandleData *data = (HandleData *)ptr;
+        rb_gc_mark(data->graph_obj);
+    }
+}
+
+static void handle_free(void *ptr) {
+    if (ptr) {
+        xfree(ptr);
+    }
+}
+
+static const rb_data_type_t handle_type = {
+    "RubydexHandle", {handle_mark, handle_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+
+static VALUE rdxr_handle_alloc(VALUE klass) {
+    HandleData *data = ALLOC(HandleData);
+    data->graph_obj = Qnil;
+    data->id = 0;
+
+    return TypedData_Wrap_Struct(klass, &handle_type, data);
+}
+
+static VALUE rdxr_handle_initialize(VALUE self, VALUE graph_obj, VALUE id_val) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+    data->graph_obj = graph_obj;
+    data->id = NUM2LL(id_val);
+
+    return self;
+}
+
+#endif // RUBYDEX_HANDLE_H

data/ext/rubydex/location.c

@@ -0,0 +1,22 @@
+#include "location.h"
+
+VALUE cLocation;
+
+VALUE rdxi_build_location_value(Location *loc) {
+    if (loc == NULL) {
+        return Qnil;
+    }
+
+    VALUE uri = rb_utf8_str_new_cstr(loc->uri);
+
+    VALUE kwargs = rb_hash_new_capa(5);
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("uri")), uri);
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("start_line")), UINT2NUM(loc->start_line));
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("end_line")), UINT2NUM(loc->end_line));
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("start_column")), UINT2NUM(loc->start_column));
+    rb_hash_aset(kwargs, ID2SYM(rb_intern("end_column")), UINT2NUM(loc->end_column));
+
+    return rb_class_new_instance_kw(1, &kwargs, cLocation, RB_PASS_KEYWORDS);
+}
+
+void rdxi_initialize_location(VALUE mRubydex) { cLocation = rb_define_class_under(mRubydex, "Location", rb_cObject); }

data/ext/rubydex/location.h

@@ -0,0 +1,15 @@
+#ifndef RUBYDEX_LOCATION_H
+#define RUBYDEX_LOCATION_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cLocation;
+
+void rdxi_initialize_location(VALUE mRubydex);
+
+// Helper to build a Ruby Rubydex::Location from a C Location pointer.
+// Does not take ownership; caller remains responsible for freeing the C Location on the Rust side.
+VALUE rdxi_build_location_value(Location *loc);
+
+#endif // RUBYDEX_LOCATION_H

data/ext/rubydex/reference.c

@@ -0,0 +1,104 @@
+#include "reference.h"
+#include "graph.h"
+#include "handle.h"
+#include "location.h"
+#include "rustbindings.h"
+
+VALUE cReference;
+VALUE cConstantReference;
+VALUE cMethodReference;
+
+// ConstantReference#name -> String
+static VALUE rdxr_constant_reference_name(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const char *name = rdx_constant_reference_name(graph, data->id);
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+    return str;
+}
+
+// ConstantReference#location -> Rubydex::Location
+static VALUE rdxr_constant_reference_location(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    Location *loc = rdx_constant_reference_location(graph, data->id);
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+    return location;
+}
+
+// MethodReference#name -> String
+static VALUE rdxr_method_reference_name(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const char *name = rdx_method_reference_name(graph, data->id);
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+    return str;
+}
+
+// MethodReference#location -> Rubydex::Location
+static VALUE rdxr_method_reference_location(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    Location *loc = rdx_method_reference_location(graph, data->id);
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+    return location;
+}
+
+// Keep this in sync with unresolved_reference_api.rs
+VALUE rdxi_reference_class_for_kind(ReferenceKind kind) {
+    switch (kind) {
+    case ReferenceKind_Constant:
+        return cConstantReference;
+    case ReferenceKind_Method:
+        return cMethodReference;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown UnresolvedReferenceKind: %d", kind);
+    }
+}
+
+void rdxi_initialize_reference(VALUE mRubydex) {
+    cReference = rb_define_class_under(mRubydex, "Reference", rb_cObject);
+    rb_define_alloc_func(cReference, rdxr_handle_alloc);
+    rb_define_method(cReference, "initialize", rdxr_handle_initialize, 2);
+    rb_funcall(rb_singleton_class(cReference), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+
+    cConstantReference = rb_define_class_under(mRubydex, "ConstantReference", cReference);
+    rb_define_alloc_func(cConstantReference, rdxr_handle_alloc);
+    rb_define_method(cConstantReference, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cConstantReference, "name", rdxr_constant_reference_name, 0);
+    rb_define_method(cConstantReference, "location", rdxr_constant_reference_location, 0);
+
+    cMethodReference = rb_define_class_under(mRubydex, "MethodReference", cReference);
+    rb_define_alloc_func(cMethodReference, rdxr_handle_alloc);
+    rb_define_method(cMethodReference, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cMethodReference, "name", rdxr_method_reference_name, 0);
+    rb_define_method(cMethodReference, "location", rdxr_method_reference_location, 0);
+}

data/ext/rubydex/reference.h

@@ -0,0 +1,16 @@
+#ifndef RUBYDEX_REFERENCE_H
+#define RUBYDEX_REFERENCE_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cReference;
+extern VALUE cConstantReference;
+extern VALUE cMethodReference;
+
+void rdxi_initialize_reference(VALUE mRubydex);
+
+// Returns the Ruby class for a given UnresolvedReferenceKind without calling back into Rust
+VALUE rdxi_reference_class_for_kind(ReferenceKind kind);
+
+#endif // RUBYDEX_REFERENCE_H

data/ext/rubydex/rubydex.c

@@ -0,0 +1,22 @@
+#include "declaration.h"
+#include "definition.h"
+#include "diagnostic.h"
+#include "document.h"
+#include "graph.h"
+#include "location.h"
+#include "reference.h"
+
+VALUE mRubydex;
+
+void Init_rubydex(void) {
+    rb_ext_ractor_safe(true);
+
+    mRubydex = rb_define_module("Rubydex");
+    rdxi_initialize_graph(mRubydex);
+    rdxi_initialize_declaration(mRubydex);
+    rdxi_initialize_document(mRubydex);
+    rdxi_initialize_definition(mRubydex);
+    rdxi_initialize_location(mRubydex);
+    rdxi_initialize_diagnostic(mRubydex);
+    rdxi_initialize_reference(mRubydex);
+}

data/ext/rubydex/utils.c

@@ -0,0 +1,27 @@
+#include "utils.h"
+
+// Convert a Ruby array of strings into a double char pointer so that we can pass that to Rust.
+// This copies the data so it must be freed
+char **rdxi_str_array_to_char(VALUE array, size_t length) {
+    char **converted_array = malloc(length * sizeof(char *));
+
+    for (size_t i = 0; i < length; i++) {
+        VALUE item = rb_ary_entry(array, i);
+        const char *string = StringValueCStr(item);
+
+        converted_array[i] = malloc(strlen(string) + 1);
+        strcpy(converted_array[i], string);
+    }
+
+    return converted_array;
+}
+
+// Verify that the Ruby object is an array of strings or raise `TypeError`
+void rdxi_check_array_of_strings(VALUE array) {
+    Check_Type(array, T_ARRAY);
+
+    for (long i = 0; i < RARRAY_LEN(array); i++) {
+        VALUE item = rb_ary_entry(array, i);
+        Check_Type(item, T_STRING);
+    }
+}

data/ext/rubydex/utils.h

@@ -0,0 +1,13 @@
+#ifndef RUBYDEX_UTILS_H
+#define RUBYDEX_UTILS_H
+
+#include "ruby.h"
+
+// Convert a Ruby array of strings into a double char pointer so that we can pass that to Rust.
+// This copies the data so it must be freed
+char **rdxi_str_array_to_char(VALUE array, size_t length);
+
+// Verify that the Ruby object is an array of strings or raise `TypeError`
+void rdxi_check_array_of_strings(VALUE array);
+
+#endif // RUBYDEX_UTILS_H