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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e40d6283bd73a05b172cc8f4b63a28d73a8e848a410baca43d5f49d3e2d182e9
-  data.tar.gz: 8dead457de3b56dfca3c4f28f118b905b73b5bc36d56465e5d11dd8ea29c9407
+  metadata.gz: a4cd7117d9875054427596fc86ec03777c49f83def03b61e88854054ed3ba29e
+  data.tar.gz: 784d1100f887338f37156b1154abe838809620fee042a9ee1e6ddb7bce1343e6
 SHA512:
-  metadata.gz: 98cb7573b8a755aca9dec29076fc24cccc11fcaa5ec24d8b27e9f4373db361b8aa9ba0b32e5529e7d00d7445c921d5d48bb1d924a0d9f49d6fff8d893f815427
-  data.tar.gz: 9b9ce0292b9c494595325a1d50526f0df6769f94cf9be52aab566f9122296efa247d76187cacb015c934dc7c13c01744fe341eb9c48e894776646155b8ca0ae6
+  metadata.gz: '084c9c76384daa40ba132d79fd4e4ef8971e4e7f0d1dd33af187ae004507c8b5135b2d241e222acbd47adfc92c043b94924b45e1f7e6f2cda51d783f310c63a4'
+  data.tar.gz: dd14d62e46de868f0622c72d379816ef913f0696454507458bb7d7598a6d3f334502a0b4470b5d6775861e208e46b069fcc78efcc6ef1b06b553696dffc7f18b

data/ext/rubydex/declaration.c

@@ -0,0 +1,146 @@
+#include "declaration.h"
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "rustbindings.h"
+
+VALUE cDeclaration;
+
+// Declaration#name -> String
+static VALUE rdxr_declaration_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_declaration_name(graph, data->id);
+
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+
+    return str;
+}
+
+// Declaration#unqualified_name -> String
+static VALUE rdxr_declaration_unqualified_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_declaration_unqualified_name(graph, data->id);
+
+    if (name == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+
+    return str;
+}
+
+// Body function for rb_ensure in Declaration#definitions
+static VALUE declaration_definitions_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    int64_t id = 0;
+    DefinitionKind kind;
+    while (rdx_definitions_iter_next(iter, &id, &kind)) {
+        VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(kind);
+        VALUE handle = rb_class_new_instance(2, argv, defn_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Declaration#definitions to always free the
+// iterator
+static VALUE declaration_definitions_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_definitions_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the Declaration#definitions enumerator
+static VALUE declaration_definitions_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    struct DefinitionsIter *iter = rdx_declaration_definitions_iter_new(graph, data->id);
+    size_t len = rdx_definitions_iter_len(iter);
+    rdx_definitions_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Declaration#definitions: () -> Enumerator[Definition]
+// Returns an enumerator that yields all definitions for this declaration lazily
+static VALUE rdxr_declaration_definitions(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("definitions"), 0, NULL, declaration_definitions_size);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    void *iter = rdx_declaration_definitions_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(declaration_definitions_yield, args, declaration_definitions_ensure, args);
+
+    return self;
+}
+
+// Declaration#member: (String member) -> Declaration
+// Returns a declaration handle for the given member
+static VALUE rdxr_declaration_member(VALUE self, VALUE name) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    if (TYPE(name) != T_STRING) {
+        rb_raise(rb_eTypeError, "expected String");
+    }
+
+    const int64_t *id_ptr = rdx_declaration_member(graph, data->id, StringValueCStr(name));
+    if (id_ptr == NULL) {
+        return Qnil;
+    }
+
+    int64_t id = *id_ptr;
+    free_i64(id_ptr);
+    VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+
+    return rb_class_new_instance(2, argv, cDeclaration);
+}
+
+void rdxi_initialize_declaration(VALUE mRubydex) {
+    cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
+
+    rb_define_alloc_func(cDeclaration, rdxr_handle_alloc);
+    rb_define_method(cDeclaration, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cDeclaration, "name", rdxr_declaration_name, 0);
+    rb_define_method(cDeclaration, "unqualified_name", rdxr_declaration_unqualified_name, 0);
+    rb_define_method(cDeclaration, "definitions", rdxr_declaration_definitions, 0);
+    rb_define_method(cDeclaration, "member", rdxr_declaration_member, 1);
+
+    rb_funcall(rb_singleton_class(cDeclaration), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+}

data/ext/rubydex/declaration.h

@@ -0,0 +1,10 @@
+#ifndef RUBYDEX_DECLARATION_H
+#define RUBYDEX_DECLARATION_H
+
+#include "ruby.h"
+
+extern VALUE cDeclaration;
+
+void rdxi_initialize_declaration(VALUE mRubydex);
+
+#endif // RUBYDEX_DECLARATION_H

data/ext/rubydex/definition.c

@@ -0,0 +1,234 @@
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "location.h"
+#include "ruby/internal/scan_args.h"
+#include "rustbindings.h"
+
+static VALUE mRubydex;
+VALUE cComment;
+VALUE cDefinition;
+VALUE cClassDefinition;
+VALUE cSingletonClassDefinition;
+VALUE cModuleDefinition;
+VALUE cConstantDefinition;
+VALUE cConstantAliasDefinition;
+VALUE cMethodDefinition;
+VALUE cAttrAccessorDefinition;
+VALUE cAttrReaderDefinition;
+VALUE cAttrWriterDefinition;
+VALUE cGlobalVariableDefinition;
+VALUE cInstanceVariableDefinition;
+VALUE cClassVariableDefinition;
+VALUE cMethodAliasDefinition;
+VALUE cGlobalVariableAliasDefinition;
+
+// Keep this in sync with definition.rs
+VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
+    switch (kind) {
+    case DefinitionKind_Class:
+        return cClassDefinition;
+    case DefinitionKind_SingletonClass:
+        return cSingletonClassDefinition;
+    case DefinitionKind_Module:
+        return cModuleDefinition;
+    case DefinitionKind_Constant:
+        return cConstantDefinition;
+    case DefinitionKind_ConstantAlias:
+        return cConstantAliasDefinition;
+    case DefinitionKind_Method:
+        return cMethodDefinition;
+    case DefinitionKind_AttrAccessor:
+        return cAttrAccessorDefinition;
+    case DefinitionKind_AttrReader:
+        return cAttrReaderDefinition;
+    case DefinitionKind_AttrWriter:
+        return cAttrWriterDefinition;
+    case DefinitionKind_GlobalVariable:
+        return cGlobalVariableDefinition;
+    case DefinitionKind_InstanceVariable:
+        return cInstanceVariableDefinition;
+    case DefinitionKind_ClassVariable:
+        return cClassVariableDefinition;
+    case DefinitionKind_MethodAlias:
+        return cMethodAliasDefinition;
+    case DefinitionKind_GlobalVariableAlias:
+        return cGlobalVariableAliasDefinition;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown DefinitionKind: %d", kind);
+    }
+}
+
+// Definition#location -> Rubydex::Location
+static VALUE rdxr_definition_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_definition_location(graph, data->id);
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+
+    return location;
+}
+
+// Definition#comments -> [Rubydex::Comment]
+static VALUE rdxr_definition_comments(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    CommentArray *arr = rdx_definition_comments(graph, data->id);
+    if (arr == NULL || arr->len == 0) {
+        if (arr != NULL) {
+            rdx_definition_comments_free(arr);
+        }
+        return rb_ary_new();
+    }
+
+    VALUE ary = rb_ary_new_capa((long)arr->len);
+    for (size_t i = 0; i < arr->len; i++) {
+        CommentEntry entry = arr->items[i];
+
+        VALUE string = rb_utf8_str_new_cstr(entry.string);
+
+        Location *loc = entry.location;
+        VALUE location = rdxi_build_location_value(loc);
+
+        VALUE comment_kwargs = rb_hash_new();
+        rb_hash_aset(comment_kwargs, ID2SYM(rb_intern("string")), string);
+        rb_hash_aset(comment_kwargs, ID2SYM(rb_intern("location")), location);
+        VALUE comment = rb_class_new_instance_kw(1, &comment_kwargs, cComment, RB_PASS_KEYWORDS);
+
+        rb_ary_push(ary, comment);
+    }
+
+    // Free the array and all inner allocations on the Rust side
+    rdx_definition_comments_free(arr);
+    return ary;
+}
+
+// Definition#name -> String
+static VALUE rdxr_definition_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_definition_name(graph, data->id);
+    if (name == NULL) {
+        return Qnil;
+    }
+    VALUE str = rb_utf8_str_new_cstr(name);
+    free_c_string(name);
+    return str;
+}
+
+// Definition#deprecated? -> bool
+static VALUE rdxr_definition_deprecated(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    bool deprecated = rdx_definition_is_deprecated(graph, data->id);
+    return deprecated ? Qtrue : Qfalse;
+}
+
+// Definition#name_location -> Rubydex::Location or nil
+// For class, module, and singleton class definitions, returns the location of just the name
+// (e.g., "Bar" in "class Foo::Bar"). For other definition types, returns nil.
+static VALUE rdxr_definition_name_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_definition_name_location(graph, data->id);
+    if (loc == NULL) {
+        return Qnil;
+    }
+    VALUE location = rdxi_build_location_value(loc);
+    rdx_location_free(loc);
+
+    return location;
+}
+
+void rdxi_initialize_definition(VALUE mod) {
+    mRubydex = mod;
+
+    cComment = rb_define_class_under(mRubydex, "Comment", rb_cObject);
+
+    cDefinition = rb_define_class_under(mRubydex, "Definition", rb_cObject);
+    rb_define_alloc_func(cDefinition, rdxr_handle_alloc);
+    rb_define_method(cDefinition, "initialize", rdxr_handle_initialize, 2);
+    rb_funcall(rb_singleton_class(cDefinition), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+    rb_define_method(cDefinition, "location", rdxr_definition_location, 0);
+    rb_define_method(cDefinition, "comments", rdxr_definition_comments, 0);
+    rb_define_method(cDefinition, "name", rdxr_definition_name, 0);
+    rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
+    rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
+
+    cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
+    rb_define_alloc_func(cClassDefinition, rdxr_handle_alloc);
+    rb_define_method(cClassDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
+    rb_define_alloc_func(cSingletonClassDefinition, rdxr_handle_alloc);
+    rb_define_method(cSingletonClassDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    rb_define_alloc_func(cModuleDefinition, rdxr_handle_alloc);
+    rb_define_method(cModuleDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
+    rb_define_alloc_func(cConstantDefinition, rdxr_handle_alloc);
+    rb_define_method(cConstantDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
+    rb_define_alloc_func(cConstantAliasDefinition, rdxr_handle_alloc);
+    rb_define_method(cConstantAliasDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
+    rb_define_alloc_func(cMethodDefinition, rdxr_handle_alloc);
+    rb_define_method(cMethodDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
+    rb_define_alloc_func(cAttrAccessorDefinition, rdxr_handle_alloc);
+    rb_define_method(cAttrAccessorDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);
+    rb_define_alloc_func(cAttrReaderDefinition, rdxr_handle_alloc);
+    rb_define_method(cAttrReaderDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cAttrWriterDefinition = rb_define_class_under(mRubydex, "AttrWriterDefinition", cDefinition);
+    rb_define_alloc_func(cAttrWriterDefinition, rdxr_handle_alloc);
+    rb_define_method(cAttrWriterDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cGlobalVariableDefinition = rb_define_class_under(mRubydex, "GlobalVariableDefinition", cDefinition);
+    rb_define_alloc_func(cGlobalVariableDefinition, rdxr_handle_alloc);
+    rb_define_method(cGlobalVariableDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cInstanceVariableDefinition = rb_define_class_under(mRubydex, "InstanceVariableDefinition", cDefinition);
+    rb_define_alloc_func(cInstanceVariableDefinition, rdxr_handle_alloc);
+    rb_define_method(cInstanceVariableDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
+    rb_define_alloc_func(cClassVariableDefinition, rdxr_handle_alloc);
+    rb_define_method(cClassVariableDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
+    rb_define_alloc_func(cMethodAliasDefinition, rdxr_handle_alloc);
+    rb_define_method(cMethodAliasDefinition, "initialize", rdxr_handle_initialize, 2);
+
+    cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
+    rb_define_alloc_func(cGlobalVariableAliasDefinition, rdxr_handle_alloc);
+    rb_define_method(cGlobalVariableAliasDefinition, "initialize", rdxr_handle_initialize, 2);
+}

data/ext/rubydex/definition.h

@@ -0,0 +1,28 @@
+#ifndef RUBYDEX_DEFINITION_H
+#define RUBYDEX_DEFINITION_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cDefinition;
+extern VALUE cClassDefinition;
+extern VALUE cSingletonClassDefinition;
+extern VALUE cModuleDefinition;
+extern VALUE cConstantDefinition;
+extern VALUE cConstantAliasDefinition;
+extern VALUE cMethodDefinition;
+extern VALUE cAttrAccessorDefinition;
+extern VALUE cAttrReaderDefinition;
+extern VALUE cAttrWriterDefinition;
+extern VALUE cGlobalVariableDefinition;
+extern VALUE cInstanceVariableDefinition;
+extern VALUE cClassVariableDefinition;
+extern VALUE cMethodAliasDefinition;
+extern VALUE cGlobalVariableAliasDefinition;
+
+void rdxi_initialize_definition(VALUE mRubydex);
+
+// Returns the Ruby class for a given DefinitionKind without calling back into Rust
+VALUE rdxi_definition_class_for_kind(DefinitionKind kind);
+
+#endif // RUBYDEX_DEFINITION_H

data/ext/rubydex/diagnostic.c

@@ -0,0 +1,6 @@
+#include "diagnostic.h"
+#include "rustbindings.h"
+
+VALUE cDiagnostic;
+
+void rdxi_initialize_diagnostic(VALUE mRubydex) { cDiagnostic = rb_define_class_under(mRubydex, "Diagnostic", rb_cObject); }

data/ext/rubydex/diagnostic.h

@@ -0,0 +1,11 @@
+#ifndef RUBYDEX_DIAGNOSTIC_H
+#define RUBYDEX_DIAGNOSTIC_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cDiagnostic;
+
+void rdxi_initialize_diagnostic(VALUE mRubydex);
+
+#endif // RUBYDEX_DIAGNOSTIC_H

data/ext/rubydex/document.c

@@ -0,0 +1,98 @@
+#include "document.h"
+#include "definition.h"
+#include "graph.h"
+#include "handle.h"
+#include "rustbindings.h"
+
+VALUE cDocument;
+
+// Document#uri -> String
+static VALUE rdxr_document_uri(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 *uri = rdx_document_uri(graph, data->id);
+
+    if (uri == NULL) {
+        return Qnil;
+    }
+
+    VALUE str = rb_utf8_str_new_cstr(uri);
+    free_c_string(uri);
+
+    return str;
+}
+
+// Body function for rb_ensure in Document#definitions
+static VALUE document_definitions_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    int64_t id = 0;
+    DefinitionKind kind;
+    while (rdx_definitions_iter_next(iter, &id, &kind)) {
+        VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+        VALUE defn_class = rdxi_definition_class_for_kind(kind);
+        VALUE handle = rb_class_new_instance(2, argv, defn_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for rb_ensure in Document#definitions to always free the iterator
+static VALUE document_definitions_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_definitions_iter_free(iter);
+
+    return Qnil;
+}
+
+// Size function for the Document#definitions enumerator
+static VALUE document_definitions_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    struct DefinitionsIter *iter = rdx_document_definitions_iter_new(graph, data->id);
+    size_t len = rdx_definitions_iter_len(iter);
+    rdx_definitions_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Document#definitions: () -> Enumerator[Definition]
+// Returns an enumerator that yields all definitions for this document lazily
+static VALUE rdxr_document_definitions(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("definitions"), 0, NULL, document_definitions_size);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    void *iter = rdx_document_definitions_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(document_definitions_yield, args, document_definitions_ensure, args);
+
+    return self;
+}
+
+void rdxi_initialize_document(VALUE mRubydex) {
+    cDocument = rb_define_class_under(mRubydex, "Document", rb_cObject);
+
+    rb_define_alloc_func(cDocument, rdxr_handle_alloc);
+    rb_define_method(cDocument, "initialize", rdxr_handle_initialize, 2);
+    rb_define_method(cDocument, "uri", rdxr_document_uri, 0);
+    rb_define_method(cDocument, "definitions", rdxr_document_definitions, 0);
+
+    rb_funcall(rb_singleton_class(cDocument), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+}

data/ext/rubydex/document.h

@@ -0,0 +1,10 @@
+#ifndef RUBYDEX_DOCUMENT_H
+#define RUBYDEX_DOCUMENT_H
+
+#include "ruby.h"
+
+extern VALUE cDocument;
+
+void rdxi_initialize_document(VALUE mRubydex);
+
+#endif // RUBYDEX_DOCUMENT_H

data/ext/rubydex/extconf.rb

@@ -3,8 +3,12 @@
 require "mkmf"
 require "pathname"
 
-release = ENV["RELEASE"]
+unless system("cargo", "--version", out: File::NULL, err: File::NULL)
+  abort "Installing Rubydex requires Cargo, the Rust package manager for platforms that we do not precompile binaries."
+end
+
 gem_dir = Pathname.new("../..").expand_path(__dir__)
+release = ENV["RELEASE"] || !gem_dir.join(".git").exist?
 root_dir = gem_dir.join("rust")
 target_dir = root_dir.join("target")
 target_dir = target_dir.join("x86_64-pc-windows-gnu") if Gem.win_platform?
@@ -34,7 +38,16 @@ if Gem.win_platform?
     $LDFLAGS << " -l#{lib}"
   end
 else
-  append_ldflags("-Wl,-rpath,#{target_dir}")
+  if RUBY_PLATFORM.include?("darwin")
+    # On the precompiled version of the gem, the `dylib` is one folder above the `.bundle/.so` file. For on machine
+    # compilation, they are at the same level
+    append_ldflags("-Wl,-rpath,@loader_path")
+    append_ldflags("-Wl,-rpath,@loader_path/..")
+  else
+    $LDFLAGS << " -Wl,-rpath,\\$$ORIGIN"
+    $LDFLAGS << " -Wl,-rpath,\\$$ORIGIN/.."
+  end
+
   # We cannot use append_ldflags here because the Rust code is only compiled later. If it's not compiled yet, this will
   # fail and the flag will not be added
   $LDFLAGS << " -L#{target_dir} -lrubydex_sys"
@@ -49,9 +62,22 @@ else
   "cargo build #{cargo_args.join(" ")}".strip
 end
 
-rust_srcs = Dir.glob("#{root_dir}/**/*.rs")
+lib_dir = gem_dir.join("lib").join("rubydex")
+
+copy_dylib_commands = if Gem.win_platform?
+  ""
+elsif RUBY_PLATFORM.include?("darwin")
+  src_dylib = target_dir.join("librubydex_sys.dylib")
+  "\t$(COPY) #{src_dylib} #{lib_dir}"
+else
+  # Linux
+  src_dylib = target_dir.join("librubydex_sys.so")
+  "\t$(COPY) #{src_dylib} #{lib_dir}"
+end
 
+rust_srcs = Dir.glob("#{root_dir}/**/*.rs").reject { |path| path.include?("rust/target") }
 makefile = File.read("Makefile")
+
 new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.chomp)
   .PHONY: compile_rust
   RUST_SRCS = #{File.expand_path("Cargo.toml", root_dir)} #{File.expand_path("Cargo.lock", root_dir)} #{rust_srcs.join(" ")}
@@ -66,21 +92,16 @@ new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.cho
   $(OBJS): $(HDRS) $(ruby_headers) .rust_built
 MAKEFILE
 
-new_makefile.gsub!("$(Q) $(POSTLINK)", <<~MAKEFILE.chomp)
-  $(Q) $(POSTLINK)
+new_makefile.gsub!(/(\$\(Q\) \$\(LDSHARED\) .*)/, <<~MAKEFILE.chomp)
+  \\1
+  #{copy_dylib_commands}
   \t$(Q)$(RM) .rust_built
 MAKEFILE
 
-# Bundle all dependency licenses when building a release version of the gem
-if release
-  unless system("cargo about --version > /dev/null 2>&1")
-    abort <<~MESSAGE
-      ERROR: cargo-about is not installed and required to build the release version of the gem.
-      Please install it by running:
-        cargo install cargo-about
-    MESSAGE
-  end
-
+# Bundle all dependency licenses when building a release version of the gem. This only has to happen on CI where we
+# precompile binaries. Oherwise, we're not redistributing the Rust dependencies as they are getting downloaded, compiled
+# and linked on the user's machine
+if release && system("cargo", "about", "--version", out: File::NULL, err: File::NULL)
   licenses_file = root_dir.join("THIRD_PARTY_LICENSES.html")
   about_config = root_dir.join("about.toml")
   about_template = root_dir.join("about.hbs")