rubydex 0.1.0.beta11 → 0.1.0.beta13

data/ext/rubydex/utils.c

@@ -1,86 +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 references
-VALUE rdxi_references_yield(VALUE args) {
-    VALUE graph_obj = rb_ary_entry(args, 0);
-    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
-
-    CReference cref;
-    while (rdx_references_iter_next(iter, &cref)) {
-        VALUE ref_class = rdxi_reference_class_for_kind(cref.kind);
-        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 references to always free the iterator
-VALUE rdxi_references_ensure(VALUE args) {
-    void *iter = (void *)(uintptr_t)NUM2ULL(rb_ary_entry(args, 1));
-    rdx_references_iter_free(iter);
-    return Qnil;
-}
+#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

@@ -1,28 +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 references
-VALUE rdxi_references_yield(VALUE args);
-
-// Ensure function for iterating over references to always free the iterator
-VALUE rdxi_references_ensure(VALUE args);
-
-#endif // RUBYDEX_UTILS_H
+#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

@@ -1,17 +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
+# 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/declaration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Declaration
+    # @abstract
+    #: () -> Enumerable[Reference]
+    def references
+      raise NotImplementedError, "Subclasses must implement #references"
+    end
+  end
+end

data/lib/rubydex/diagnostic.rb

@@ -1,21 +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
+# 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

@@ -1,15 +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
+# 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

@@ -1,92 +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",
-      ".git",
-      ".github",
-      "node_modules",
-      "tmp",
-    ].freeze
-
-    #: String
-    attr_accessor :workspace_path
-
-    #: (?workspace_path: String) -> void
-    def initialize(workspace_path: Dir.pwd)
-      @workspace_path = workspace_path
-    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
+# 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