rubydex 0.3.0 → 0.4.1

data/ext/rubydex/definition.c

@@ -38,6 +38,17 @@ VALUE cClassVariableDefinition;
 VALUE cMethodAliasDefinition;
 VALUE cGlobalVariableAliasDefinition;
 
+uint64_t rdxi_definition_id_for_graph(VALUE definition, VALUE graph_obj) {
+    HandleData *data;
+    TypedData_Get_Struct(definition, HandleData, &handle_type, data);
+
+    if (data->graph_obj != graph_obj) {
+        rb_raise(rb_eArgError, "definition must belong to this graph");
+    }
+
+    return data->id;
+}
+
 // Keep this in sync with definition.rs
 VALUE rdxi_definition_class_for_kind(DefinitionKind kind) {
     switch (kind) {
@@ -153,6 +164,25 @@ static VALUE rdxr_definition_name(VALUE self) {
     return rdxi_owned_c_string_to_ruby(name);
 }
 
+/*
+ * call-seq:
+ *   raw_name -> String
+ *
+ * Returns the class, module, or constant name as written in source, preserving explicit parent scopes like "Foo::Bar"
+ * and rooted paths like "::Bar".
+ */
+static VALUE rdxr_definition_raw_name(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const char *name = rdx_definition_raw_name(graph, data->id);
+    if (name == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition not found");
+    }
+
+    return rdxi_owned_c_string_to_ruby(name);
+}
+
 /*
  * call-seq:
  *   deprecated? -> bool
@@ -442,6 +472,7 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "document", rdxr_definition_document, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
+    rb_define_method(cClassDefinition, "raw_name", rdxr_definition_raw_name, 0);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
     rb_define_method(cClassDefinition, "mixins", rdxr_definition_mixins, 0);
 
@@ -449,10 +480,13 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cSingletonClassDefinition, "mixins", rdxr_definition_mixins, 0);
 
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
+    rb_define_method(cModuleDefinition, "raw_name", rdxr_definition_raw_name, 0);
     rb_define_method(cModuleDefinition, "mixins", rdxr_definition_mixins, 0);
 
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
+    rb_define_method(cConstantDefinition, "raw_name", rdxr_definition_raw_name, 0);
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
+    rb_define_method(cConstantAliasDefinition, "raw_name", rdxr_definition_raw_name, 0);
     cConstantVisibilityDefinition = rb_define_class_under(mRubydex, "ConstantVisibilityDefinition", cDefinition);
     cMethodVisibilityDefinition = rb_define_class_under(mRubydex, "MethodVisibilityDefinition", cDefinition);
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);

data/ext/rubydex/definition.h

@@ -22,6 +22,9 @@ extern VALUE cGlobalVariableAliasDefinition;
 
 void rdxi_initialize_definition(VALUE mRubydex);
 
+// Returns the definition ID after verifying that the definition belongs to `graph_obj`.
+uint64_t rdxi_definition_id_for_graph(VALUE definition, VALUE graph_obj);
+
 // Returns the Ruby class for a given DefinitionKind without calling back into Rust
 VALUE rdxi_definition_class_for_kind(DefinitionKind kind);
 

data/ext/rubydex/diagnostic.c

@@ -6,6 +6,33 @@
  * mRubydex = rb_define_module("Rubydex")
  */
 
+static VALUE mRules;
 VALUE cDiagnostic;
 
-void rdxi_initialize_diagnostic(VALUE mRubydex) { cDiagnostic = rb_define_class_under(mRubydex, "Diagnostic", rb_cObject); }
+VALUE rdxi_build_diagnostic_severity_value(VALUE mRubydex, DiagnosticSeverity severity) {
+    VALUE mSeverity = rb_const_get(mRubydex, rb_intern("Severity"));
+
+    switch (severity) {
+    case DiagnosticSeverity_Error:
+        return rb_const_get(mSeverity, rb_intern("Error"));
+    case DiagnosticSeverity_Warning:
+        return rb_const_get(mSeverity, rb_intern("Warning"));
+    case DiagnosticSeverity_Information:
+        return rb_const_get(mSeverity, rb_intern("Information"));
+    case DiagnosticSeverity_Hint:
+        return rb_const_get(mSeverity, rb_intern("Hint"));
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown DiagnosticSeverity: %d", severity);
+    }
+
+    return Qnil;
+}
+
+VALUE rdxi_rule_class_from_name(const char *name, size_t length) {
+    return rb_const_get_at(mRules, rb_intern2(name, (long)length));
+}
+
+void rdxi_initialize_diagnostic(VALUE moduleRubydex) {
+    cDiagnostic = rb_define_class_under(moduleRubydex, "Diagnostic", rb_cObject);
+    mRules = rb_define_module_under(moduleRubydex, "Rules");
+}

data/ext/rubydex/diagnostic.h

@@ -7,5 +7,7 @@
 extern VALUE cDiagnostic;
 
 void rdxi_initialize_diagnostic(VALUE mRubydex);
+VALUE rdxi_build_diagnostic_severity_value(VALUE mRubydex, DiagnosticSeverity severity);
+VALUE rdxi_rule_class_from_name(const char *name, size_t length);
 
 #endif // RUBYDEX_DIAGNOSTIC_H

data/ext/rubydex/extconf.rb

@@ -23,12 +23,12 @@ release = ENV["RELEASE"] || !developing_rubydex
 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?
-target_dir = target_dir.join(release ? "release" : "debug")
+target_dir = target_dir.join("$(RUST_PROFILE)")
 
 bindings_path = root_dir.join("rubydex-sys").join("rustbindings.h")
 
 cargo_args = ["--manifest-path #{root_dir.join("Cargo.toml")}"]
-cargo_args << "--release" if release
+cargo_args << "$(CARGO_PROFILE_FLAG)"
 
 if Gem.win_platform?
   cargo_args << "--target x86_64-pc-windows-gnu"
@@ -102,6 +102,8 @@ makefile = File.read("Makefile")
 
 new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.chomp)
   .PHONY: compile_rust
+  RUST_PROFILE = $(if $(strip $(RELEASE)),release,#{developing_rubydex ? "debug" : "release"})
+  CARGO_PROFILE_FLAG = $(if $(filter release,$(RUST_PROFILE)),--release)
   RUST_SRCS = #{File.expand_path("Cargo.toml", root_dir)} #{File.expand_path("Cargo.lock", root_dir)} #{rust_srcs.join(" ")}
 
   .rust_built: $(RUST_SRCS)

data/ext/rubydex/graph.c

@@ -1,5 +1,7 @@
 #include "graph.h"
+#include "config.h"
 #include "declaration.h"
+#include "definition.h"
 #include "diagnostic.h"
 #include "document.h"
 #include "location.h"
@@ -255,6 +257,30 @@ static VALUE rdxr_graph_fuzzy_search(int argc, VALUE *argv, VALUE self) {
     return rdxr_graph_yield_search_results(self, iter);
 }
 
+/*
+ * call-seq:
+ *   dead_code_candidates -> Enumerator[Rubydex::Declaration]
+ *
+ * Returns an enumerator over declarations that may be unused because the analysis could not find any references to
+ * them. This misses metaprogramming or untyped code, which is why the term candidates is used.
+ *
+ * Currently, only supports constants.
+ */
+static VALUE rdxr_graph_dead_code_candidates(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("dead_code_candidates"), 0, NULL);
+    }
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    void *iter = rdx_graph_dead_code_candidates(graph);
+    VALUE args = rb_ary_new_from_args(2, self, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_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);
@@ -485,25 +511,48 @@ static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
 
 /*
  * call-seq:
- *   resolve_constant(name, nesting) -> Rubydex::Declaration?
+ *   resolve_constant(name, context) -> Rubydex::Declaration?
  *
- * Runs the resolver on a single constant reference to determine what it points to.
+ * Runs the resolver on a single constant reference using an array of nesting names or a namespace definition as its
+ * context.
  */
-static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nesting) {
+static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE context) {
     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);
+    const char *const_name_string = StringValueCStr(const_name);
 
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    const CDeclaration *decl =
-        rdx_graph_resolve_constant(graph, StringValueCStr(const_name), (const char **)converted_file_paths, length);
+    const CDeclaration *decl;
+    if (RB_TYPE_P(context, T_ARRAY)) {
+        rdxi_check_array_of_strings(context);
+
+        size_t length = RARRAY_LEN(context);
+        char **converted_names = rdxi_str_array_to_char(context, length);
+        decl = rdx_graph_resolve_constant(graph, const_name_string, (const char **)converted_names, length);
+        rdxi_free_str_array(converted_names, length);
+    } else if (rb_obj_is_kind_of(context, cClassDefinition) ||
+               rb_obj_is_kind_of(context, cSingletonClassDefinition) ||
+               rb_obj_is_kind_of(context, cModuleDefinition)) {
+        uint64_t definition_id = rdxi_definition_id_for_graph(context, self);
+        CDefinitionConstantResolutionResult result =
+            rdx_graph_resolve_constant_from_definition(graph, const_name_string, definition_id);
+
+        if (result.status == CDefinitionConstantResolution_DefinitionNotFound) {
+            rb_raise(rb_eRuntimeError, "Definition not found");
+        }
+        if (result.status == CDefinitionConstantResolution_InvalidDefinitionKind) {
+            // This is unreachable because the rb_obj_is_kind_of checks above only accept supported definition kinds.
+            rb_raise(rb_eRuntimeError, "Unexpected definition kind");
+        }
 
-    rdxi_free_str_array(converted_file_paths, length);
+        decl = result.declaration;
+    } else {
+        rb_raise(
+            rb_eTypeError,
+            "context must be an Array of Strings, ClassDefinition, SingletonClassDefinition, or ModuleDefinition"
+        );
+    }
 
     if (decl == NULL) {
         return Qnil;
@@ -631,7 +680,7 @@ static VALUE rdxr_graph_diagnostics(VALUE self) {
     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_intern(rb_str_new2(entry.rule));
+        VALUE rule = rdxi_rule_class_from_name(entry.rule.name, entry.rule.name_length);
         VALUE location = rdxi_build_location_value(entry.location);
 
         VALUE kwargs = rb_hash_new();
@@ -787,6 +836,7 @@ static VALUE rdxr_graph_complete_method_argument(int argc, VALUE *argv, VALUE se
 
     Check_Type(name, T_STRING);
     rdxi_check_array_of_strings(nesting);
+    const char *name_string = StringValueCStr(name);
 
     const char *self_receiver = extract_self_receiver(opts);
 
@@ -797,7 +847,7 @@ static VALUE rdxr_graph_complete_method_argument(int argc, VALUE *argv, VALUE se
     char **converted_nesting = rdxi_str_array_to_char(nesting, nesting_count);
 
     struct CompletionResult result = rdx_graph_complete_method_argument(
-        graph, StringValueCStr(name), (const char *const *)converted_nesting, nesting_count, self_receiver);
+        graph, name_string, (const char *const *)converted_nesting, nesting_count, self_receiver);
 
     rdxi_free_str_array(converted_nesting, nesting_count);
     return completion_result_to_ruby_array(result, self);
@@ -872,52 +922,18 @@ static VALUE rdxr_graph_workspace_path(VALUE self) {
 
 /*
  * call-seq:
- *   workspace_path=(path) -> void
+ *   load_config(config) -> void
  *
- * Sets the root directory of the workspace being indexed.
+ * Applies a parsed Rubydex::Config to the graph.
  */
-static VALUE rdxr_graph_set_workspace_path(VALUE self, VALUE path) {
-    Check_Type(path, T_STRING);
-
-    void *graph;
-    TypedData_Get_Struct(self, void*, &graph_type, graph);
-
-    rdx_graph_set_workspace_path(graph, StringValueCStr(path));
-    return path;
-}
-
-/*
- * call-seq:
- *   load_config(config_path = nil) -> void
- *
- * Loads a configuration file for the graph. If `config_path` is nil, loads the default configuration file at
- * `workspace_path/rubydex.toml` if it exists. Will raise on malformed files or if an explicit path is given but the
- * file does not exist.
- */
-static VALUE rdxr_graph_load_config(int argc, VALUE *argv, VALUE self) {
-    VALUE config_path;
-    rb_scan_args(argc, argv, "01", &config_path);
-
+static VALUE rdxr_graph_load_config(VALUE self, VALUE config_obj) {
     void *graph;
     TypedData_Get_Struct(self, void *, &graph_type, graph);
 
-    const char *config_path_cstr = NULL;
-
-    if (!NIL_P(config_path)) {
-        Check_Type(config_path, T_STRING);
-        config_path_cstr = StringValueCStr(config_path);
-    }
-
-    const char *error = rdx_graph_load_config(graph, config_path_cstr);
-    if (error == NULL) {
-        return Qnil;
-    }
+    void *config = rdxi_config_from_object(config_obj);
+    rdx_graph_load_config(graph, config);
 
-    VALUE message = rb_utf8_str_new_cstr(error);
-    free_c_string(error);
-
-    VALUE config_error = rb_const_get(mRubydex, rb_intern("ConfigError"));
-    rb_exc_raise(rb_exc_new_str(config_error, message));
+    return Qnil;
 }
 
 /*
@@ -969,6 +985,7 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
     rb_define_method(cGraph, "search", rdxr_graph_search, -1);
     rb_define_method(cGraph, "fuzzy_search", rdxr_graph_fuzzy_search, -1);
+    rb_define_method(cGraph, "dead_code_candidates", rdxr_graph_dead_code_candidates, 0);
     rb_define_method(cGraph, "encoding=", rdxr_graph_set_encoding, 1);
     rb_define_method(cGraph, "resolve_require_path", rdxr_graph_resolve_require_path, 2);
     rb_define_method(cGraph, "require_paths", rdxr_graph_require_paths, 1);
@@ -979,7 +996,6 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_method(cGraph, "exclude_patterns", rdxr_graph_exclude_patterns, 1);
     rb_define_method(cGraph, "excluded_patterns", rdxr_graph_excluded_patterns, 0);
     rb_define_method(cGraph, "workspace_path", rdxr_graph_workspace_path, 0);
-    rb_define_method(cGraph, "workspace_path=", rdxr_graph_set_workspace_path, 1);
-    rb_define_method(cGraph, "load_config", rdxr_graph_load_config, -1);
+    rb_define_method(cGraph, "load_config", rdxr_graph_load_config, 1);
     rb_define_method(cGraph, "keyword", rdxr_graph_keyword, 1);
 }

data/ext/rubydex/graph.h

@@ -5,6 +5,12 @@
 
 extern const rb_data_type_t graph_type;
 
+static inline void *rdxi_graph_from_object(VALUE graph_obj) {
+    void *graph;
+    TypedData_Get_Struct(graph_obj, void *, &graph_type, graph);
+    return graph;
+}
+
 void rdxi_initialize_graph(VALUE mRubydex);
 
 #endif // RUBYDEX_GRAPH_H