rubydex 0.2.9 → 0.4.0

data/ext/rubydex/config.c

@@ -0,0 +1,140 @@
+#include "config.h"
+#include "diagnostic.h"
+#include "rustbindings.h"
+#include "utils.h"
+
+/*
+ * RDoc parser workaround for https://github.com/ruby/rdoc/issues/1744:
+ * mRubydex = rb_define_module("Rubydex")
+ */
+
+static VALUE mRubydex;
+// Defined here so that the configuration can build them, but implemented in Ruby (`lib/rubydex/config.rb`), like the
+// other value objects handed back to Ruby.
+static VALUE cLinterConfig;
+static VALUE cRuleConfig;
+static ID id_linter;
+
+// Free function for Rubydex::Config: releases the parsed configuration allocated by Rust.
+static void config_free(void *ptr) {
+    if (ptr) {
+        rdx_config_free(ptr);
+    }
+}
+
+// Body function for rb_ensure while building a Rubydex::LinterConfig.
+static VALUE config_linter_build(VALUE opaque_rule_array) {
+    CLinterRuleArray *rule_array = (CLinterRuleArray *)(uintptr_t)opaque_rule_array;
+    VALUE rules = rb_hash_new_capa((long)rule_array->len);
+
+    for (size_t i = 0; i < rule_array->len; i++) {
+        CLinterRule rule = rule_array->items[i];
+        VALUE rule_name = rb_str_freeze(rb_utf8_str_new(rule.name, (long)rule.name_length));
+        VALUE exclude_patterns = rb_ary_new_capa((long)rule.exclude_patterns_length);
+        for (size_t j = 0; j < rule.exclude_patterns_length; j++) {
+            CConfigString pattern = rule.exclude_patterns[j];
+            rb_ary_push(exclude_patterns, rb_str_freeze(rb_utf8_str_new(pattern.data, (long)pattern.length)));
+        }
+        rb_obj_freeze(exclude_patterns);
+
+        VALUE severity = rule.severity == NULL
+            ? Qnil
+            : rdxi_build_diagnostic_severity_value(mRubydex, *rule.severity);
+        VALUE argv[] = {rule_name, rule.enabled ? Qtrue : Qfalse, exclude_patterns, severity};
+
+        rb_hash_aset(rules, rule_name, rb_class_new_instance(4, argv, cRuleConfig));
+    }
+
+    return rb_class_new_instance(1, &rules, cLinterConfig);
+}
+
+// Ensure function for rb_ensure while building a Rubydex::LinterConfig.
+static VALUE config_linter_ensure(VALUE opaque_rule_array) {
+    CLinterRuleArray *rule_array = (CLinterRuleArray *)(uintptr_t)opaque_rule_array;
+    rdx_config_linter_rules_free(*rule_array);
+
+    return Qnil;
+}
+
+static VALUE config_linter(VALUE config_obj) {
+    CLinterRuleArray rule_array = rdx_config_linter_rules(rdxi_config_from_object(config_obj));
+    VALUE opaque_rule_array = (VALUE)(uintptr_t)&rule_array;
+
+    return rb_ensure(config_linter_build, opaque_rule_array, config_linter_ensure, opaque_rule_array);
+}
+
+const rb_data_type_t config_type = {
+    .wrap_struct_name = "Rubydex::Config",
+    .function = {
+        .dmark = NULL,
+        .dfree = config_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
+};
+
+/*
+ * call-seq:
+ *   Rubydex::Config.load(workspace_path) -> Rubydex::Config
+ *
+ * Loads the configuration of the workspace rooted at +workspace_path+, which is where its `rubydex.toml` is expected to
+ * be. A workspace without a configuration file gets an empty configuration. Raises Rubydex::ConfigError if the file
+ * exists, but cannot be read or is malformed.
+ */
+static VALUE rdxr_config_load(VALUE klass, VALUE workspace_path) {
+    Check_Type(workspace_path, T_STRING);
+
+    struct CConfigResult result = rdx_config_load(StringValueCStr(workspace_path));
+    if (result.error != NULL) {
+        VALUE message = rb_utf8_str_new_cstr(result.error);
+        free_c_string(result.error);
+
+        VALUE config_error = rb_const_get(mRubydex, rb_intern("ConfigError"));
+        rb_exc_raise(rb_exc_new_str(config_error, message));
+    }
+
+    VALUE config = TypedData_Wrap_Struct(klass, &config_type, result.config);
+    rb_ivar_set(config, id_linter, config_linter(config));
+
+    return config;
+}
+
+/*
+ * call-seq:
+ *   workspace_path -> String
+ *
+ * Returns the root directory of the workspace this configuration was loaded for.
+ */
+static VALUE rdxr_config_workspace_path(VALUE self) {
+    const char *result = rdx_config_workspace_path(rdxi_config_from_object(self));
+    // A configuration always has a workspace, so there is no absent case to hand back to Ruby. NULL only means the
+    // conversion itself failed, which is why this raises instead of returning nil.
+    if (result == NULL) {
+        rb_raise(rb_eRuntimeError, "Converting workspace path to Ruby string failed");
+    }
+
+    return rdxi_owned_c_string_to_ruby(result);
+}
+
+void rdxi_initialize_config(VALUE moduleRubydex) {
+    mRubydex = moduleRubydex;
+
+    cLinterConfig = rb_define_class_under(mRubydex, "LinterConfig", rb_cObject);
+    cRuleConfig = rb_define_class_under(mRubydex, "RuleConfig", rb_cObject);
+    id_linter = rb_intern("@linter");
+
+    VALUE cConfig = rb_define_class_under(mRubydex, "Config", rb_cObject);
+    rb_undef_alloc_func(cConfig);
+
+    // A configuration can only be obtained through `load`; `new` would create an object with no Rust data behind it.
+    rb_undef_method(rb_singleton_class(cConfig), "new");
+
+    rb_define_singleton_method(cConfig, "load", rdxr_config_load, 1);
+    rb_define_method(cConfig, "workspace_path", rdxr_config_workspace_path, 0);
+
+    /* Returns the linter settings read from the `[linter]` section. Its rules are empty when the section is absent. */
+    rb_define_attr(cConfig, "linter", true, false);
+}

data/ext/rubydex/config.h

@@ -0,0 +1,16 @@
+#ifndef RUBYDEX_CONFIG_H
+#define RUBYDEX_CONFIG_H
+
+#include "ruby.h"
+
+extern const rb_data_type_t config_type;
+
+static inline void *rdxi_config_from_object(VALUE config_obj) {
+    void *config;
+    TypedData_Get_Struct(config_obj, void *, &config_type, config);
+    return config;
+}
+
+void rdxi_initialize_config(VALUE mRubydex);
+
+#endif // RUBYDEX_CONFIG_H

data/ext/rubydex/declaration.c

@@ -236,7 +236,7 @@ static VALUE rdxr_declaration_owner(VALUE self) {
     const CDeclaration *decl = rdx_declaration_owner(graph, data->id);
 
     if (decl == NULL) {
-        rb_raise(rb_eRuntimeError, "owner can never be nil for any declarations");
+        rb_raise(rb_eRuntimeError, "Declaration must exist for a valid id");
     }
 
     VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);

data/ext/rubydex/definition.c

@@ -18,6 +18,7 @@ static VALUE mRubydex;
 static VALUE cInclude;
 static VALUE cPrepend;
 static VALUE cExtend;
+static VALUE cDocument;
 VALUE cComment;
 VALUE cDefinition;
 VALUE cClassDefinition;
@@ -88,6 +89,9 @@ static VALUE rdxr_definition_location(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     Location *loc = rdx_definition_location(graph, data->id);
+    if (loc == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition must exist for a valid id");
+    }
     VALUE location = rdxi_build_location_value(loc);
     rdx_location_free(loc);
 
@@ -105,10 +109,11 @@ static VALUE rdxr_definition_comments(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     CommentArray *arr = rdx_definition_comments(graph, data->id);
-    if (arr == NULL || arr->len == 0) {
-        if (arr != NULL) {
-            rdx_definition_comments_free(arr);
-        }
+    if (arr == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition must exist for a valid id");
+    }
+    if (arr->len == 0) {
+        rdx_definition_comments_free(arr);
         return rb_ary_new();
     }
 
@@ -261,6 +266,27 @@ static VALUE rdxr_definition_lexical_nesting(VALUE self) {
     return nesting;
 }
 
+/*
+ * call-seq:
+ *   document -> Rubydex::Document
+ *
+ * Returns the document this definition belongs to.
+ */
+static VALUE rdxr_definition_document(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const uint64_t *uri_id = rdx_definition_document(graph, data->id);
+    if (uri_id == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition not found");
+    }
+
+    VALUE argv[] = {data->graph_obj, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -397,6 +423,7 @@ void rdxi_initialize_definition(VALUE mod) {
     cInclude = rb_const_get(mRubydex, rb_intern("Include"));
     cPrepend = rb_const_get(mRubydex, rb_intern("Prepend"));
     cExtend = rb_const_get(mRubydex, rb_intern("Extend"));
+    cDocument = rb_const_get(mRubydex, rb_intern("Document"));
 
     cComment = rb_define_class_under(mRubydex, "Comment", rb_cObject);
 
@@ -412,6 +439,7 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "declaration", rdxr_definition_declaration, 0);
     rb_define_method(cDefinition, "lexical_owner", rdxr_definition_lexical_owner, 0);
     rb_define_method(cDefinition, "lexical_nesting", rdxr_definition_lexical_nesting, 0);
+    rb_define_method(cDefinition, "document", rdxr_definition_document, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);

data/ext/rubydex/diagnostic.c

@@ -6,6 +6,80 @@
  * mRubydex = rb_define_module("Rubydex")
  */
 
+static VALUE mRubydex;
+static VALUE mRules;
 VALUE cDiagnostic;
+static VALUE cRule;
+static ID id_default_severity;
 
-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;
+}
+
+/*
+ * call-seq:
+ *   default_severity -> Rubydex::Severity::Base
+ *
+ * Returns the Rubydex::Severity subclass the diagnostics of this rule get unless the configuration overrides it.
+ */
+static VALUE rdxr_generated_rule_default_severity(VALUE self) {
+    VALUE severity = rb_attr_get(self, id_default_severity);
+
+    // Class-level instance variables are not inherited, so a class inheriting from a generated rule reaches this without
+    // a severity of its own.
+    if (NIL_P(severity)) {
+        rb_raise(rb_eRuntimeError, "Rule %s has no default severity", rb_class2name(self));
+    }
+
+    return severity;
+}
+
+// Generates a rule class for every rule the graph can report. Severities are resolved here rather than when they are
+// read, which is why Rubydex::Severity is loaded before this extension (see `lib/rubydex.rb`).
+static void define_generated_rules(void) {
+    CRuleArray rule_array = rdx_rules();
+    VALUE rules = rb_ary_new_capa((long)rule_array.len);
+
+    for (size_t i = 0; i < rule_array.len; i++) {
+        CRule built_in_rule = rule_array.items[i];
+        VALUE name = rb_utf8_str_new(built_in_rule.name, (long)built_in_rule.name_length);
+        VALUE rule = rb_define_class_under(mRules, StringValueCStr(name), cRule);
+        VALUE severity = rdxi_build_diagnostic_severity_value(mRubydex, built_in_rule.default_severity);
+
+        rb_ivar_set(rule, id_default_severity, severity);
+        rb_define_singleton_method(rule, "default_severity", rdxr_generated_rule_default_severity, 0);
+        rb_ary_push(rules, rule);
+    }
+
+    rdx_rules_free(rule_array);
+    rb_define_const(mRules, "ALL", rb_obj_freeze(rules));
+}
+
+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) {
+    mRubydex = moduleRubydex;
+    id_default_severity = rb_intern("@default_severity");
+
+    cDiagnostic = rb_define_class_under(mRubydex, "Diagnostic", rb_cObject);
+    cRule = rb_define_class_under(mRubydex, "Rule", rb_cObject);
+    mRules = rb_define_module_under(mRubydex, "Rules");
+    define_generated_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/graph.c

@@ -1,4 +1,5 @@
 #include "graph.h"
+#include "config.h"
 #include "declaration.h"
 #include "diagnostic.h"
 #include "document.h"
@@ -63,16 +64,25 @@ const rb_data_type_t graph_type = {
     },
     .parent = NULL,
     .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
-// Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
-// as a void pointer
+// Custom allocator for the Graph class. Calls into Rust to create a new Box<RwLock<Graph>> that gets stored
+// internally as an opaque void pointer. The RwLock provides thread-safe concurrent access across Ractors.
 static VALUE rdxr_graph_alloc(VALUE klass) {
     void *graph = rdx_graph_new();
     return TypedData_Wrap_Struct(klass, &graph_type, graph);
 }
 
+// Graph is intentionally non-copyable. A dup/clone of the TypedData wrapper would alias the
+// same underlying Rust allocation (double-free on GC) or, if deep-copied, balloon memory use.
+// Block both paths: `dup` dispatches to `initialize_copy`, `clone` to `initialize_clone`.
+static VALUE rdxr_graph_initialize_copy(VALUE self, VALUE other) {
+    (void)self;
+    (void)other;
+    rb_raise(rb_eRuntimeError, "Rubydex::Graph cannot be duplicated or cloned");
+}
+
 /*
  * call-seq:
  *   index_all(file_paths) -> Array[String]
@@ -483,6 +493,7 @@ static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
 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);
+    const char *const_name_string = StringValueCStr(const_name);
 
     // Convert the given file paths into a char** array, so that we can pass to Rust
     size_t length = RARRAY_LEN(nesting);
@@ -492,7 +503,7 @@ static VALUE rdxr_graph_resolve_constant(VALUE self, VALUE const_name, VALUE nes
     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);
+        rdx_graph_resolve_constant(graph, const_name_string, (const char **)converted_file_paths, length);
 
     rdxi_free_str_array(converted_file_paths, length);
 
@@ -622,7 +633,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();
@@ -778,6 +789,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);
 
@@ -788,7 +800,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);
@@ -863,52 +875,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;
 }
 
 /*
@@ -943,6 +921,8 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     id_self_receiver = rb_intern("self_receiver");
 
     rb_define_alloc_func(cGraph, rdxr_graph_alloc);
+    rb_define_method(cGraph, "initialize_copy", rdxr_graph_initialize_copy, 1);
+    rb_define_method(cGraph, "initialize_clone", rdxr_graph_initialize_copy, 1);
     rb_define_method(cGraph, "index_all", rdxr_graph_index_all, 1);
     rb_define_method(cGraph, "index_source", rdxr_graph_index_source, 3);
     rb_define_method(cGraph, "document", rdxr_graph_document, 1);
@@ -968,7 +948,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