rubydex 0.1.0.beta12-aarch64-linux

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
+    uint64_t id;     // Canonical ID 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 = NUM2ULL(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,123 @@
+#include "reference.h"
+#include "declaration.h"
+#include "graph.h"
+#include "handle.h"
+#include "location.h"
+#include "rustbindings.h"
+
+VALUE cReference;
+VALUE cConstantReference;
+VALUE cUnresolvedConstantReference;
+VALUE cResolvedConstantReference;
+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;
+}
+
+// ResolvedConstantReference#declaration -> Declaration
+static VALUE rdxr_resolved_constant_reference_declaration(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 struct CDeclaration *decl = rdx_resolved_constant_reference_declaration(graph, data->id);
+    if (decl == NULL) {
+        rb_raise(rb_eRuntimeError, "Invalid declaration for a resolved constant reference");
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
+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, "location", rdxr_constant_reference_location, 0);
+    rb_funcall(rb_singleton_class(cConstantReference), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
+
+    cUnresolvedConstantReference = rb_define_class_under(mRubydex, "UnresolvedConstantReference", cConstantReference);
+    rb_define_alloc_func(cUnresolvedConstantReference, rdxr_handle_alloc);
+    rb_define_method(cUnresolvedConstantReference, "name", rdxr_constant_reference_name, 0);
+
+    cResolvedConstantReference = rb_define_class_under(mRubydex, "ResolvedConstantReference", cConstantReference);
+    rb_define_alloc_func(cResolvedConstantReference, rdxr_handle_alloc);
+    rb_define_method(cResolvedConstantReference, "declaration", rdxr_resolved_constant_reference_declaration, 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,15 @@
+#ifndef RUBYDEX_REFERENCE_H
+#define RUBYDEX_REFERENCE_H
+
+#include "ruby.h"
+#include "rustbindings.h"
+
+extern VALUE cReference;
+extern VALUE cConstantReference;
+extern VALUE cUnresolvedConstantReference;
+extern VALUE cResolvedConstantReference;
+extern VALUE cMethodReference;
+
+void rdxi_initialize_reference(VALUE mRubydex);
+
+#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,108 @@
+#include "utils.h"
+#include "declaration.h"
+#include "reference.h"
+#include "rustbindings.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;
+}
+
+// Free a char** array allocated by rdxi_str_array_to_char
+void rdxi_free_str_array(char **array, size_t length) {
+    if (array != NULL) {
+        for (size_t i = 0; i < length; i++) {
+            free(array[i]);
+        }
+        free(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);
+    }
+}
+
+// Yield body for iterating over declarations
+VALUE rdxi_declarations_yield(VALUE args) {
+    VALUE self = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    CDeclaration decl;
+    while (rdx_graph_declarations_iter_next(iter, &decl)) {
+        VALUE decl_class = rdxi_declaration_class_for_kind(decl.kind);
+        VALUE argv[] = {self, ULL2NUM(decl.id)};
+        VALUE handle = rb_class_new_instance(2, argv, decl_class);
+        rb_yield(handle);
+    }
+
+    return Qnil;
+}
+
+// Ensure function for iterating over declarations to always free the iterator
+VALUE rdxi_declarations_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_graph_declarations_iter_free(iter);
+    return Qnil;
+}
+
+// Yield body for iterating over constant references
+VALUE rdxi_constant_references_yield(VALUE args) {
+    VALUE graph_obj = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    CConstantReference cref;
+    while (rdx_constant_references_iter_next(iter, &cref)) {
+        VALUE ref_class = (cref.declaration_id == 0)
+            ? cUnresolvedConstantReference
+            : cResolvedConstantReference;
+        VALUE argv[] = {graph_obj, ULL2NUM(cref.id)};
+        VALUE obj = rb_class_new_instance(2, argv, ref_class);
+        rb_yield(obj);
+    }
+    return Qnil;
+}
+
+// Ensure function for iterating over constant references to always free the iterator
+VALUE rdxi_constant_references_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_constant_references_iter_free(iter);
+    return Qnil;
+}
+
+// Yield body for iterating over method references
+VALUE rdxi_method_references_yield(VALUE args) {
+    VALUE graph_obj = rb_ary_entry(args, 0);
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+
+    CMethodReference cref;
+    while (rdx_method_references_iter_next(iter, &cref)) {
+        VALUE argv[] = {graph_obj, ULL2NUM(cref.id)};
+        VALUE obj = rb_class_new_instance(2, argv, cMethodReference);
+        rb_yield(obj);
+    }
+    return Qnil;
+}
+
+// Ensure function for iterating over method references to always free the iterator
+VALUE rdxi_method_references_ensure(VALUE args) {
+    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
+    rdx_method_references_iter_free(iter);
+    return Qnil;
+}

data/ext/rubydex/utils.h

@@ -0,0 +1,34 @@
+#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 with rdxi_free_str_array
+char **rdxi_str_array_to_char(VALUE array, size_t length);
+
+// Free a char** array allocated by rdxi_str_array_to_char
+void rdxi_free_str_array(char **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);
+
+// Yield body for iterating over declarations
+VALUE rdxi_declarations_yield(VALUE args);
+
+// Ensure function for iterating over declarations to always free the iterator
+VALUE rdxi_declarations_ensure(VALUE args);
+
+// Yield body for iterating over constant references
+VALUE rdxi_constant_references_yield(VALUE args);
+
+// Ensure function for iterating over constant references
+VALUE rdxi_constant_references_ensure(VALUE args);
+
+// Yield body for iterating over method references
+VALUE rdxi_method_references_yield(VALUE args);
+
+// Ensure function for iterating over method references
+VALUE rdxi_method_references_ensure(VALUE args);
+
+#endif // RUBYDEX_UTILS_H

data/lib/rubydex/comment.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Comment
+    #: String
+    attr_reader :string
+
+    #: Location
+    attr_reader :location
+
+    #: (?string: String, ?location: Location) -> void
+    def initialize(string:, location:)
+      @string = string
+      @location = location
+    end
+  end
+end

data/lib/rubydex/diagnostic.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Diagnostic
+    #: Symbol
+    attr_reader :rule
+
+    #: String
+    attr_reader :message
+
+    #: Location
+    attr_reader :location
+
+    #: (rule: Symbol, message: String, location: Location) -> void
+    def initialize(rule:, message:, location:)
+      @rule = rule
+      @message = message
+      @location = location
+    end
+  end
+end

data/lib/rubydex/failures.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Failure
+    #: String
+    attr_reader :message
+
+    #: (String) -> void
+    def initialize(message)
+      @message = message
+    end
+  end
+
+  class IntegrityFailure < Failure; end
+end

data/lib/rubydex/graph.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Rubydex
+  # The global graph representing all declarations and their relationships for the workspace
+  #
+  # Note: this class is partially defined in C to integrate with the Rust backend
+  class Graph
+    IGNORED_DIRECTORIES = [
+      ".bundle",
+      ".claude",
+      ".git",
+      ".github",
+      ".ruby-lsp",
+      ".vscode",
+      "log",
+      "node_modules",
+      "tmp",
+    ].freeze
+
+    #: String
+    attr_accessor :workspace_path
+
+    #: (?workspace_path: String) -> void
+    def initialize(workspace_path: Dir.pwd)
+      @workspace_path = workspace_path
+
+      exclude_paths(IGNORED_DIRECTORIES.map { |dir| File.join(@workspace_path, dir) })
+    end
+
+    # Index all files and dependencies of the workspace that exists in `@workspace_path`
+    #: -> Array[String]
+    def index_workspace
+      index_all(workspace_paths)
+    end
+
+    # Returns all workspace paths that should be indexed, excluding directories that we don't need to descend into such
+    # as `.git`, `node_modules`. Also includes any top level Ruby files
+    #
+    #: -> Array[String]
+    def workspace_paths
+      paths = []
+
+      Dir.each_child(@workspace_path) do |entry|
+        full_path = File.join(@workspace_path, entry)
+
+        if File.directory?(full_path)
+          paths << full_path unless IGNORED_DIRECTORIES.include?(entry)
+        elsif File.extname(entry) == ".rb"
+          paths << full_path
+        end
+      end
+
+      add_workspace_dependency_paths(paths)
+      add_core_rbs_definition_paths(paths)
+      paths.uniq!
+      paths
+    end
+
+    private
+
+    # Gathers the paths we have to index for all workspace dependencies
+    #: (Array[String]) -> void
+    def add_workspace_dependency_paths(paths)
+      specs = Bundler.locked_gems&.specs
+      return unless specs
+
+      specs.each do |lazy_spec|
+        spec = Gem::Specification.find_by_name(lazy_spec.name)
+        spec.require_paths.each do |path|
+          # For native extensions, RubyGems inserts an absolute require path pointing to
+          # `gems/some-gem-1.0.0/extensions`. Those paths don't actually include any Ruby files inside, so we can skip
+          # descending them
+          next if File.absolute_path?(path)
+
+          paths << File.join(spec.full_gem_path, path)
+        end
+      rescue Gem::MissingSpecError
+        nil
+      end
+    end
+
+    # Searches for the latest installation of the `rbs` gem and adds the paths for the core and stdlib RBS definitions
+    # to the list of paths. This method does not require `rbs` to be a part of the bundle. It searches for whatever
+    # latest installation of `rbs` exists in the system and fails silently if we can't find one
+    #
+    #: (Array[String]) -> void
+    def add_core_rbs_definition_paths(paths)
+      rbs_gem_path = Gem.path
+        .flat_map { |path| Dir.glob(File.join(path, "gems", "rbs-[0-9]*/")) }
+        .max_by { |path| Gem::Version.new(File.basename(path).delete_prefix("rbs-")) }
+
+      return unless rbs_gem_path
+
+      paths << File.join(rbs_gem_path, "core")
+      paths << File.join(rbs_gem_path, "stdlib")
+    end
+  end
+end

data/lib/rubydex/keyword.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Keyword
+    #: String
+    attr_reader :name
+
+    #: String
+    attr_reader :documentation
+
+    #: (String name, String documentation) -> void
+    def initialize(name, documentation)
+      @name = name
+      @documentation = documentation
+    end
+  end
+end

data/lib/rubydex/keyword_parameter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class KeywordParameter
+    #: String
+    attr_reader :name
+
+    #: (String name) -> void
+    def initialize(name)
+      @name = name
+    end
+  end
+end

data/lib/rubydex/location.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Rubydex
+  # A zero based internal location. Intended to be used for tool-to-tool communication, such as a language server
+  # communicating with an editor.
+  class Location
+    class NotFileUriError < StandardError; end
+
+    include Comparable
+
+    #: String
+    attr_reader :uri
+
+    #: Integer
+    attr_reader :start_line, :end_line, :start_column, :end_column
+
+    #: (?uri: String, ?start_line: Integer, ?end_line: Integer, ?start_column: Integer, ?end_column: Integer) -> void
+    def initialize(uri:, start_line:, end_line:, start_column:, end_column:)
+      @uri = uri
+      @start_line = start_line
+      @end_line = end_line
+      @start_column = start_column
+      @end_column = end_column
+    end
+
+    #: () -> String
+    def to_file_path
+      uri = URI(@uri)
+      raise NotFileUriError, "URI is not a file:// URI: #{@uri}" unless uri.scheme == "file"
+
+      path = uri.path
+      # TODO: This has to go away once we have a proper URI abstraction
+      path.delete_prefix!("/") if Gem.win_platform?
+      path
+    end
+
+    #: (other: BasicObject) -> Integer
+    def <=>(other)
+      return -1 unless other.is_a?(Location)
+
+      comparable_values <=> other.comparable_values
+    end
+
+    #: () -> [String, Integer, Integer, Integer, Integer]
+    def comparable_values
+      [@uri, @start_line, @start_column, @end_line, @end_column]
+    end
+
+    # Turns this zero based location into a one based location for display purposes.
+    #
+    #: () -> DisplayLocation
+    def to_display
+      DisplayLocation.new(
+        uri: @uri,
+        start_line: @start_line + 1,
+        end_line: @end_line + 1,
+        start_column: @start_column + 1,
+        end_column: @end_column + 1,
+      )
+    end
+
+    #: -> String
+    def to_s
+      "#{to_file_path}:#{@start_line + 1}:#{@start_column + 1}-#{@end_line + 1}:#{@end_column + 1}"
+    end
+  end
+
+  # A one based location intended for display purposes. This is what should be used when displaying a location to users,
+  # like in CLIs
+  class DisplayLocation < Location
+    # Returns itself
+    #
+    #: () -> DisplayLocation
+    def to_display
+      self
+    end
+
+    # Normalize to zero-based for comparison with Location
+    #
+    #: () -> [String, Integer, Integer, Integer, Integer]
+    def comparable_values
+      [@uri, @start_line - 1, @start_column - 1, @end_line - 1, @end_column - 1]
+    end
+
+    #: -> String
+    def to_s
+      "#{to_file_path}:#{@start_line}:#{@start_column}-#{@end_line}:#{@end_column}"
+    end
+  end
+end