rubydex 0.3.0 → 0.4.0

data/rust/rubydex-sys/src/diagnostic_api.rs

@@ -3,12 +3,87 @@
 use crate::graph_api::{GraphPointer, with_graph};
 use crate::location_api::{Location, create_location_for_uri_and_offset};
 use libc::c_char;
+use rubydex::diagnostic::{Rule, Severity};
 use std::{ffi::CString, mem, ptr};
 
+/// C-compatible enum representing diagnostic severity levels.
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum DiagnosticSeverity {
+    Error = 1,
+    Warning = 2,
+    Information = 3,
+    Hint = 4,
+}
+
+impl From<Severity> for DiagnosticSeverity {
+    fn from(severity: Severity) -> Self {
+        match severity {
+            Severity::Error => DiagnosticSeverity::Error,
+            Severity::Warning => DiagnosticSeverity::Warning,
+            Severity::Information => DiagnosticSeverity::Information,
+            Severity::Hint => DiagnosticSeverity::Hint,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CRule {
+    pub name: *const c_char,
+    pub name_length: usize,
+    pub default_severity: DiagnosticSeverity,
+}
+
+impl From<Rule> for CRule {
+    fn from(rule: Rule) -> Self {
+        let name = rule.name();
+
+        Self {
+            name: name.as_ptr().cast::<c_char>(),
+            name_length: name.len(),
+            default_severity: DiagnosticSeverity::from(rule.default_severity()),
+        }
+    }
+}
+
+#[repr(C)]
+pub struct CRuleArray {
+    pub items: *mut CRule,
+    pub len: usize,
+}
+
+/// Returns every rule the graph can report. Caller must free it with `rdx_rules_free`.
+#[unsafe(no_mangle)]
+pub extern "C" fn rdx_rules() -> CRuleArray {
+    let items = Rule::all().iter().copied().map(CRule::from).collect::<Box<[CRule]>>();
+
+    CRuleArray {
+        len: items.len(),
+        items: Box::into_raw(items).cast::<CRule>(),
+    }
+}
+
+/// Frees an array previously returned by `rdx_rules`.
+///
+/// # Safety
+///
+/// - `rules` must have been returned by `rdx_rules` and must not be used afterwards.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_rules_free(rules: CRuleArray) {
+    if rules.items.is_null() {
+        return;
+    }
+
+    unsafe {
+        let _ = Box::from_raw(ptr::slice_from_raw_parts_mut(rules.items, rules.len));
+    }
+}
+
 /// C-compatible struct representing a diagnostic entry.
 #[repr(C)]
 pub struct DiagnosticEntry {
-    pub rule: *const c_char,
+    pub rule: CRule,
     pub message: *const c_char,
     pub location: *mut Location,
 }
@@ -50,10 +125,7 @@ pub unsafe extern "C" fn rdx_graph_diagnostics(pointer: GraphPointer) -> *mut Di
                 let location = create_location_for_uri_and_offset(graph, document, diagnostic.offset());
 
                 DiagnosticEntry {
-                    rule: CString::new(diagnostic.rule().to_string())
-                        .unwrap()
-                        .into_raw()
-                        .cast_const(),
+                    rule: CRule::from(*diagnostic.rule()),
                     message: CString::new(diagnostic.message()).unwrap().into_raw().cast_const(),
                     location,
                 }
@@ -82,9 +154,6 @@ pub unsafe extern "C" fn rdx_diagnostics_free(ptr: *mut DiagnosticArray) {
         let mut boxed_slice: Box<[DiagnosticEntry]> = unsafe { Box::from_raw(slice_ptr) };
 
         for entry in &mut *boxed_slice {
-            if !entry.rule.is_null() {
-                let _ = unsafe { CString::from_raw(entry.rule.cast_mut()) };
-            }
             if !entry.message.is_null() {
                 let _ = unsafe { CString::from_raw(entry.message.cast_mut()) };
             }

data/rust/rubydex-sys/src/graph_api.rs

@@ -1,5 +1,6 @@
 //! This file provides the C API for the Graph object
 
+use crate::config_api::ConfigPointer;
 use crate::declaration_api::CDeclaration;
 use crate::declaration_api::DeclarationsIter;
 use crate::declaration_api::decl_id_from_char_ptr;
@@ -7,7 +8,7 @@ use crate::document_api::DocumentsIter;
 use crate::reference_api::{CConstantReference, CMethodReference, ConstantReferencesIter, MethodReferencesIter};
 use crate::{name_api, utils};
 use libc::{c_char, c_void};
-use rubydex::errors::Errors;
+use rubydex::config::Config;
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
@@ -15,12 +16,11 @@ use rubydex::model::ids::{DeclarationId, NameId, UriId, declaration_id_from_look
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::model::visibility::Visibility;
-use rubydex::query::cypher::{self, OutputFormat};
 use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver};
 use rubydex::resolution::Resolver;
 use rubydex::{indexing, integrity, listing, query};
 use std::ffi::CString;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 use std::{mem, ptr, sync::RwLock};
 
 pub type GraphPointer = *mut c_void;
@@ -216,14 +216,8 @@ pub unsafe extern "C" fn rdx_graph_excluded_patterns(
 
         let c_strings: Vec<*const c_char> = excluded
             .iter()
-            .filter_map(|path| {
-                // Normalize all paths to use forward slashes. Otherwise, you get mixed backslashes and forward slashes
-                // on Windows if a configuration file is using forward slashes. For example:
-                //
-                // C:\project/vendor/bundle
-                let normalized = path.replace(std::path::MAIN_SEPARATOR, "/");
-
-                CString::new(normalized)
+            .filter_map(|pattern| {
+                CString::new(pattern.as_ref())
                     .ok()
                     .map(|c_string| c_string.into_raw().cast_const())
             })
@@ -236,23 +230,6 @@ pub unsafe extern "C" fn rdx_graph_excluded_patterns(
     })
 }
 
-/// Sets the workspace path used as the root directory for indexing and relative path resolution. Silently ignores the
-/// call if the given path is not valid UTF-8, leaving the existing workspace path untouched (mirrors
-/// `rdx_graph_set_encoding`). This avoids unwinding across the FFI boundary on malformed input.
-///
-/// # Safety
-///
-/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `path` must be a valid, null-terminated string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_graph_set_workspace_path(pointer: GraphPointer, path: *const c_char) {
-    let Ok(path) = (unsafe { utils::convert_char_ptr_to_string(path) }) else {
-        return;
-    };
-
-    with_mut_graph(pointer, |graph| graph.set_workspace_path(PathBuf::from(path)));
-}
-
 /// Returns the workspace path as a C string. Caller must free with `free_c_string`.
 ///
 /// # Safety
@@ -261,42 +238,23 @@ pub unsafe extern "C" fn rdx_graph_set_workspace_path(pointer: GraphPointer, pat
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_workspace_path(pointer: GraphPointer) -> *const c_char {
     with_graph(pointer, |graph| {
-        CString::new(graph.workspace_path().to_string_lossy().as_ref())
+        CString::new(utils::interop_path(graph.workspace_path()))
             .map_or(ptr::null(), |c_string| c_string.into_raw().cast_const())
     })
 }
 
-/// Loads configuration into the graph. A null `config_path` attempts to load the default configuration file.
-///
-/// Returns NULL on success. On failure returns an owned, null-terminated error message that the caller must free with
-/// `free_c_string`.
-///
-/// A `config_path` that is not valid UTF-8 is reported as an error message.
+/// Applies a parsed configuration file to the graph, which adopts the workspace it was loaded for along with the
+/// settings of its `[graph]` section. This is the only way to point the graph at a workspace other than the current
+/// directory, and it replaces any previously applied configuration. Tool-specific sections are ignored.
 ///
 /// # Safety
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `config_path` must either be NULL or a valid, null-terminated string.
+/// - `config` must be a valid `ConfigPointer` previously returned by `rdx_config_load`.
 #[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_graph_load_config(pointer: GraphPointer, config_path: *const c_char) -> *const c_char {
-    let result = with_mut_graph(pointer, |graph| {
-        if config_path.is_null() {
-            graph.load_config(None)
-        } else {
-            match unsafe { utils::convert_char_ptr_to_string(config_path) } {
-                Ok(config_path) => graph.load_config(Some(Path::new(&config_path))),
-                Err(_) => Err(Errors::ConfigError("config file path is not valid UTF-8".to_string())),
-            }
-        }
-    });
-
-    match result {
-        Ok(()) => ptr::null(),
-        Err(error) => CString::new(error.to_string())
-            .unwrap_or_default()
-            .into_raw()
-            .cast_const(),
-    }
+pub unsafe extern "C" fn rdx_graph_load_config(pointer: GraphPointer, config: ConfigPointer) {
+    let config = unsafe { &*config.cast::<Config>() };
+    with_mut_graph(pointer, |graph| graph.load_config(config));
 }
 
 /// Indexes all given file paths in parallel using the provided Graph pointer.
@@ -1066,145 +1024,6 @@ pub unsafe extern "C" fn rdx_keyword_get(name: *const c_char) -> *const CKeyword
     }
 }
 
-/// The result of running a Cypher query, carrying either the formatted output or an error message.
-#[repr(C)]
-pub struct CQueryResult {
-    /// Non-null on success; null on error. Caller must free with `free_c_string`.
-    pub output: *const c_char,
-    /// Non-null on error; null on success. Caller must free with `free_c_string`.
-    pub error: *const c_char,
-}
-
-impl CQueryResult {
-    fn success(output: &str) -> Self {
-        match CString::new(output) {
-            Ok(c_string) => Self {
-                output: c_string.into_raw().cast_const(),
-                error: ptr::null(),
-            },
-            Err(_) => Self::error("query output contained an interior NUL byte"),
-        }
-    }
-
-    fn error(message: &str) -> Self {
-        Self {
-            output: ptr::null(),
-            error: CString::new(message).map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        }
-    }
-}
-
-/// The result of parsing a Cypher query into an opaque, reusable parsed-query object.
-#[repr(C)]
-pub struct CParseResult {
-    /// Non-null on success: a heap-allocated parsed query. Free with `rdx_cypher_query_free`.
-    pub query: *mut c_void,
-    /// Non-null on error; null on success. Caller must free with `free_c_string`.
-    pub error: *const c_char,
-}
-
-/// Parses a Cypher query string into an opaque parsed-query object, without needing a graph.
-///
-/// On success, `query` is a heap-allocated parsed query that can be executed against a graph with
-/// `rdx_query_run` and must eventually be freed with `rdx_cypher_query_free`. On failure, `error`
-/// holds the message.
-///
-/// # Safety
-///
-/// - `query` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_parse(query: *const c_char) -> CParseResult {
-    let Ok(query_str) = (unsafe { utils::convert_char_ptr_to_string(query) }) else {
-        return CParseResult {
-            query: ptr::null_mut(),
-            error: CString::new("query is not valid UTF-8").map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        };
-    };
-
-    match cypher::parse(&query_str) {
-        Ok(parsed) => CParseResult {
-            query: Box::into_raw(Box::new(parsed)).cast::<c_void>(),
-            error: ptr::null(),
-        },
-        Err(error) => CParseResult {
-            query: ptr::null_mut(),
-            error: CString::new(error.to_string()).map_or(ptr::null(), |s| s.into_raw().cast_const()),
-        },
-    }
-}
-
-/// Frees a parsed query previously returned by `rdx_cypher_parse`.
-///
-/// # Safety
-///
-/// - `query` must be a pointer returned by `rdx_cypher_parse`, or null. It must not be used after.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_query_free(query: *mut c_void) {
-    if query.is_null() {
-        return;
-    }
-    let _ = unsafe { Box::from_raw(query.cast::<cypher::Query>()) };
-}
-
-/// Executes a previously parsed query (from `rdx_cypher_parse`) against the graph and returns the
-/// formatted output or an error message. `format` must be `"table"` or `"json"`.
-///
-/// # Safety
-///
-/// - `query` must be a valid pointer returned by `rdx_cypher_parse`.
-/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
-/// - `format` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_query_run(
-    query: *const c_void,
-    pointer: GraphPointer,
-    format: *const c_char,
-) -> CQueryResult {
-    if query.is_null() {
-        return CQueryResult::error("query is null");
-    }
-
-    let Ok(format_str) = (unsafe { utils::convert_char_ptr_to_string(format) }) else {
-        return CQueryResult::error("format is not valid UTF-8");
-    };
-
-    let output_format = match format_str.as_str() {
-        "table" => OutputFormat::Table,
-        "json" => OutputFormat::Json,
-        other => {
-            return CQueryResult::error(&format!("unknown query format `{other}` (expected `table` or `json`)"));
-        }
-    };
-
-    let parsed = unsafe { &*query.cast::<cypher::Query>() };
-
-    with_graph(pointer, |graph| {
-        match cypher::run_parsed(graph, parsed, output_format) {
-            Ok(output) => CQueryResult::success(&output),
-            Err(error) => CQueryResult::error(&error.to_string()),
-        }
-    })
-}
-
-/// Returns a description of the queryable Cypher schema (node labels, relationship types, and
-/// properties) in the given format (`"table"` or `"json"`). The schema is static and requires no
-/// graph. Caller must free the returned pointer with `free_c_string`.
-///
-/// # Safety
-///
-/// - `format` must be a valid, null-terminated UTF-8 string.
-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn rdx_cypher_schema(format: *const c_char) -> *const c_char {
-    let format_str = unsafe { utils::convert_char_ptr_to_string(format) }.unwrap_or_else(|_| "table".to_string());
-    let output_format = if format_str == "json" {
-        OutputFormat::Json
-    } else {
-        OutputFormat::Table
-    };
-
-    CString::new(cypher::schema(output_format)).map_or(ptr::null(), |s| s.into_raw().cast_const())
-}
-
 #[repr(u8)]
 #[derive(Debug, Clone, Copy)]
 pub enum CVisibility {

data/rust/rubydex-sys/src/lib.rs

@@ -68,6 +68,8 @@ macro_rules! iterator {
     };
 }
 
+pub mod config_api;
+pub mod cypher_api;
 pub mod declaration_api;
 pub mod definition_api;
 pub mod diagnostic_api;

data/rust/rubydex-sys/src/name_api.rs

@@ -1,8 +1,4 @@
-use rubydex::model::{
-    graph::Graph,
-    ids::NameId,
-    name::{Name, ParentScope},
-};
+use rubydex::model::{graph::Graph, ids::NameId, name::ParentScope};
 
 /// Takes a constant name and a nesting stack (e.g.: `["Foo", "Bar::Baz", "Qux"]`) and transforms it into a `NameId`,
 /// registering each required part in the graph. Returns the `NameId` and a list of name ids that need to be untracked
@@ -74,7 +70,7 @@ fn process_qualified_name(
         };
 
         let str_id = graph.intern_string(part.to_owned());
-        let name_id = graph.add_name(Name::new(str_id, parent_scope, nesting_for_part));
+        let name_id = graph.add_name(str_id, parent_scope, nesting_for_part);
         names_to_untrack.push(name_id);
         *current_name = ParentScope::Some(name_id);
     }

data/rust/rubydex-sys/src/utils.rs

@@ -1,5 +1,6 @@
 use libc::{c_char, size_t};
 use std::ffi::{CStr, CString};
+use std::path::Path;
 use std::slice;
 use std::str::Utf8Error;
 
@@ -68,3 +69,39 @@ pub unsafe extern "C" fn free_c_string_array(ptr: *const *const c_char, count: u
         .map(|arg| unsafe { CString::from_raw((*arg).cast_mut()) })
         .collect();
 }
+
+/// Converts a Rust `&str` to an owned C string (`*const c_char`), suitable for returning across the
+/// FFI boundary. The caller is responsible for freeing it with `free_c_string`.
+///
+/// # Panics
+///
+/// Panics if `value` contains an interior null byte, which should never occur in rubydex data.
+#[must_use]
+pub fn cstring_raw(value: &str) -> *const c_char {
+    CString::new(value).unwrap().into_raw().cast_const()
+}
+
+/// Rust uses backslashes as separators on Windows, but Ruby prefers forward slashes everywhere. We need to make sure
+/// we're maintaining the right separators at the boundary.
+#[must_use]
+pub fn interop_path(path: &Path) -> String {
+    path.to_string_lossy().replace(std::path::MAIN_SEPARATOR, "/")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(unix)]
+    #[test]
+    fn interop_path_leaves_a_unix_path_untouched() {
+        // A backslash is an ordinary character in a Unix file name, so rewriting it would name a different file.
+        assert_eq!(interop_path(Path::new(r"/tmp/we\ird")), r"/tmp/we\ird");
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn interop_path_separates_a_windows_path_with_forward_slashes() {
+        assert_eq!(interop_path(Path::new(r"D:\a\_temp\project")), "D:/a/_temp/project");
+    }
+}

data/skills/send-private-method/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: send-private-method
+description: Remediate a `send`/`__send__` call that reaches a private method, restoring a real public seam instead of bypassing visibility. Use when send is being used to invoke private functionality in a class.
+---
+
+# Send Private Method
+
+A test calls `obj.send(:some_private_method)` (or `__send__`) to invoke a method Ruby's visibility system would otherwise forbid. `send` deliberately bypasses encapsulation. `__send__` behaves identically and is the conventional spelling when a class defines its own `send`; Ruby warns when you redefine `__send__`, but it is not un-overridable. Remediation is the same for both. The smell is not "you used `send`" — it is "the test reaches past the public API into an implementation detail," which breaks the moment the private method is renamed, reorganized, or removed even though the public contract is unchanged.
+
+## Confirm the receiver and the method
+
+You have a call site: a file path and a line number. Before changing anything, answer two questions:
+
+1. **What is the receiver's real type?** Trace the receiver expression at the flagged line back to its class. If it is a local/ivar, find where it is assigned (a `let`, `setup`, factory, or constructor).
+2. **Where is the private method defined?** Search the workspace for `def <method_name>` (and `define_method :<method_name>`). Confirm the definition is under `private` (or `private :<method_name>`). Note its enclosing class/module and read the method body — you cannot decide the fix without knowing what the method does.
+
+A name-based search matches by method *name* across the whole workspace, so a public method and a private method sharing the same unqualified name on different classes can produce a false positive. If the receiver's type has a *public* method of that name, this is not the smell — stop here.
+
+## Decide which situation you are in
+
+Read the method body and the test. Exactly one of these applies:
+
+- **The caller needs behavior that should be public.** The private method does something the application legitimately depends on, and there is no public entry point that exposes it. The encapsulation boundary was drawn too tightly.
+- **The caller is a test reaching past an existing public API.** A public method already wraps or drives this private one; the test bypassed it to assert on an intermediate result instead of the observable outcome. If the public outcome is already tested elsewhere, the private-method test is redundant — delete it rather than rewriting it.
+- **The private method is the wrong home for the logic.** The behavior is genuinely useful to more than one caller, but it lives tucked away inside one class's private section. Both production and tests want it.
+
+## Fix per situation
+
+### 1. Promote to public (or `protected`)
+
+If the behavior is part of the object's real contract, make it public and document it as API. Use `protected` only when every legitimate caller is an instance inside the same class hierarchy as the class that defines the method — never to paper over a single test's reach-in.
+
+Before:
+```ruby
+class Foo
+  def bar = qux.sum
+
+  private
+
+  def qux
+    @items.reject(&:voided?).map { |i| i.baz - i.discount }
+  end
+end
+# test
+foo.send(:qux)
+```
+
+After:
+```ruby
+class Foo
+  def bar = qux.sum
+
+  # Public: items with discounts applied, voided items excluded.
+  # Used by reporting and by #bar's total.
+  def qux
+    @items.reject(&:voided?).map { |i| i.baz - i.discount }
+  end
+end
+# test
+foo.qux
+```
+
+### 2. Drive the public entry point, assert on the observable outcome
+
+If a public method already exercises the private one, call the public method and assert on what it produces — not on the private intermediate.
+
+Before:
+```ruby
+class Foo
+  def bar(baz) = Receipt.new(tax: baz.amount * qux(baz.quux))
+
+  private
+
+  def qux(quux) = RATES.fetch(quux)
+end
+# test
+foo.send(:qux, "CA") # => 0.05
+```
+
+After:
+```ruby
+# test — assert on the observable result of the public API
+result = foo.bar(baz_with(quux: "CA", amount: 100))
+assert_equal 5.0, result.tax
+```
+
+### 3. Extract to its own object/module
+
+When the logic serves multiple callers but is trapped in one class's private section, move it to a dedicated object or module with a public interface both callers can use.
+
+Before:
+```ruby
+class Foo
+  private
+
+  def bar(raw) = raw.transform_keys(&:to_s).compact
+end
+# test
+foo.send(:bar, { baz: "Q" })
+```
+
+After:
+```ruby
+class Bar
+  def call(raw) = raw.transform_keys(&:to_s).compact
+end
+
+class Foo
+  def initialize(bar: Bar.new) = @bar = bar
+  def baz(raw) = @bar.call(raw)
+end
+# test
+assert_equal({ "baz" => "Q" }, Bar.new.call({ baz: "Q" }))
+```
+
+## Private class methods and `module_function`
+
+The three situations above cover instance methods. Two related visibility forms need special handling:
+
+- **Private class methods** (`private_class_method :bar`, or a `def bar` under `private` inside `class << self`). A bare `private` does **not** apply to `def self.bar`: that singleton method stays public wherever it sits relative to the `private` line, so a public `def self.bar` under `private` is not this smell. A `send` like `Foo.send(:bar)` reaches a genuinely private singleton method. The remediation mirrors instance methods — promote with `public_class_method :bar` (or drop the `private_class_method :bar` call), drive an existing public class method, or extract. Do not use the instance-method patterns verbatim; the fix targets the singleton class.
+- **`module_function`**. `module_function :foo` creates a public singleton method and a private instance method. If the test calls `instance.send(:foo)` on the private instance side, the public entry point already exists: call `MyModule.foo` directly. This is situation 2 — drive the public singleton method, do not promote the instance method.
+
+## Legitimate exceptions — and what to do about them
+
+Not every `send` to a private name is a smell to remove. Handle these deliberately:
+
+- **Dynamic dispatch over a validated allowlist.** The method name is genuinely computed (`send(action)`), and the action set is bounded and checked. Constrain it: define an `ALLOWED_ACTIONS = %i[...].freeze` constant, guard with `raise unless ALLOWED_ACTIONS.include?(action)`, and call `public_send(action)` so the visibility system still applies. If every allowed action is public, the smell is gone.
+- **Framework or DSL callbacks.** Some libraries require `send` to reach hooks they themselves marked private. If the method name is dictated by the framework contract, leave the call but add a one-line comment naming the framework and the callback it satisfies.
+- **Third-party code you cannot change.** The private method belongs to a gem or an owned-elsewhere class you must not edit. Wrap the reach-in behind a single named adapter method in your own code with a comment stating why (e.g. `# Sends :bar to avoid the gem's private API; remove when upstream exposes a public hook.`). The adapter localizes the violation so it is auditable and removable in one place.
+
+## What does NOT fix it
+
+Switching `send` to `public_send` on a method that is *still private* does not fix anything — it just moves the failure from "silently bypassed encapsulation" to a `NoMethodError` at runtime. Answer the encapsulation question first; only then choose `public_send` (for dynamic dispatch over public methods) or a direct call (once promoted).

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -24,6 +24,8 @@ files:
 - README.md
 - THIRD_PARTY_LICENSES.html
 - exe/rdx
+- ext/rubydex/config.c
+- ext/rubydex/config.h
 - ext/rubydex/declaration.c
 - ext/rubydex/declaration.h
 - ext/rubydex/definition.c
@@ -47,8 +49,18 @@ files:
 - ext/rubydex/signature.h
 - ext/rubydex/utils.c
 - ext/rubydex/utils.h
+- lib/ruby_lsp/rubydex/addon.rb
 - lib/rubydex.rb
+- lib/rubydex/cli.rb
+- lib/rubydex/cli/command.rb
+- lib/rubydex/cli/command/console.rb
+- lib/rubydex/cli/command/lint.rb
+- lib/rubydex/cli/command/lint/explain.rb
+- lib/rubydex/cli/command/mcp.rb
+- lib/rubydex/cli/command/query.rb
+- lib/rubydex/cli/command/skill.rb
 - lib/rubydex/comment.rb
+- lib/rubydex/config.rb
 - lib/rubydex/declaration.rb
 - lib/rubydex/diagnostic.rb
 - lib/rubydex/errors.rb
@@ -56,6 +68,13 @@ files:
 - lib/rubydex/graph.rb
 - lib/rubydex/keyword.rb
 - lib/rubydex/keyword_parameter.rb
+- lib/rubydex/linter.rb
+- lib/rubydex/linter/custom_rule.rb
+- lib/rubydex/linter/helpers/path_helpers.rb
+- lib/rubydex/linter/helpers/source_access_helpers.rb
+- lib/rubydex/linter/rule_loader.rb
+- lib/rubydex/linter/rule_test_case.rb
+- lib/rubydex/linter/runner.rb
 - lib/rubydex/location.rb
 - lib/rubydex/mcp_server.rb
 - lib/rubydex/mcp_server/protocol.rb
@@ -68,8 +87,14 @@ files:
 - lib/rubydex/mcp_server/tools/search_declarations_tool.rb
 - lib/rubydex/mixin.rb
 - lib/rubydex/reference.rb
+- lib/rubydex/related_information.rb
+- lib/rubydex/rule.rb
+- lib/rubydex/severity.rb
 - lib/rubydex/signature.rb
+- lib/rubydex/skill.rb
+- lib/rubydex/skill_registry.rb
 - lib/rubydex/version.rb
+- lib/rubydex_linter/rules/rule_structure.rb
 - rbi/rubydex.rbi
 - rust/Cargo.lock
 - rust/Cargo.toml
@@ -79,6 +104,8 @@ files:
 - rust/rubydex-sys/Cargo.toml
 - rust/rubydex-sys/build.rs
 - rust/rubydex-sys/cbindgen.toml
+- rust/rubydex-sys/src/config_api.rs
+- rust/rubydex-sys/src/cypher_api.rs
 - rust/rubydex-sys/src/declaration_api.rs
 - rust/rubydex-sys/src/definition_api.rs
 - rust/rubydex-sys/src/diagnostic_api.rs
@@ -128,6 +155,7 @@ files:
 - rust/rubydex/src/operation/mod.rs
 - rust/rubydex/src/operation/printer.rs
 - rust/rubydex/src/operation/ruby_builder.rs
+- rust/rubydex/src/path_helpers.rs
 - rust/rubydex/src/position.rs
 - rust/rubydex/src/query.rs
 - rust/rubydex/src/query/cypher.rs
@@ -146,6 +174,7 @@ files:
 - rust/rubydex/src/test_utils/local_graph_test.rs
 - rust/rubydex/tests/cli.rs
 - rust/rustfmt.toml
+- skills/send-private-method/SKILL.md
 homepage: https://github.com/Shopify/rubydex
 licenses:
 - MIT