rubydex 0.2.4-aarch64-linux → 0.2.6-aarch64-linux

data/rust/rubydex/src/test_utils/graph_test.rs

@@ -1,20 +1,34 @@
 use super::normalize_indentation;
 #[cfg(test)]
 use crate::diagnostic::Rule;
-use crate::indexing::{self, LanguageId};
+use crate::indexing::{self, IndexerBackend, LanguageId};
 use crate::model::graph::{Graph, NameDependent};
 use crate::model::ids::{NameId, StringId};
 use crate::resolution::Resolver;
 
-#[derive(Default)]
 pub struct GraphTest {
     graph: Graph,
+    backend: IndexerBackend,
+}
+
+impl Default for GraphTest {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl GraphTest {
     #[must_use]
     pub fn new() -> Self {
-        Self { graph: Graph::new() }
+        Self::new_with_backend(IndexerBackend::RubyIndexer)
+    }
+
+    #[must_use]
+    pub fn new_with_backend(backend: IndexerBackend) -> Self {
+        Self {
+            graph: Graph::new(),
+            backend,
+        }
     }
 
     #[must_use]
@@ -30,7 +44,8 @@ impl GraphTest {
     /// Indexes a Ruby source
     pub fn index_uri(&mut self, uri: &str, source: &str) {
         let source = normalize_indentation(source);
-        indexing::index_source(&mut self.graph, uri, &source, &LanguageId::Ruby);
+        let local_graph = indexing::build_local_graph(uri.to_string(), &source, &LanguageId::Ruby, self.backend);
+        self.graph.consume_document_changes(local_graph);
     }
 
     /// Indexes an RBS source

data/rust/rubydex/src/test_utils/local_graph_test.rs

@@ -1,7 +1,7 @@
 use super::normalize_indentation;
 use crate::indexing::local_graph::LocalGraph;
 use crate::indexing::rbs_indexer::RBSIndexer;
-use crate::indexing::ruby_indexer::RubyIndexer;
+use crate::indexing::{IndexerBackend, LanguageId, build_local_graph};
 use crate::model::definitions::Definition;
 use crate::model::graph::NameDependent;
 use crate::model::ids::{NameId, StringId, UriId};
@@ -19,13 +19,14 @@ pub struct LocalGraphTest {
 impl LocalGraphTest {
     #[must_use]
     pub fn new(uri: &str, source: &str) -> Self {
+        Self::new_with_backend(uri, source, IndexerBackend::RubyIndexer)
+    }
+
+    #[must_use]
+    pub fn new_with_backend(uri: &str, source: &str, backend: IndexerBackend) -> Self {
         let uri = uri.to_string();
         let source = normalize_indentation(source);
-
-        let mut indexer = RubyIndexer::new(uri.clone(), &source);
-        indexer.index();
-        let graph = indexer.local_graph();
-
+        let graph = build_local_graph(uri.clone(), &source, &LanguageId::Ruby, backend);
         Self { uri, source, graph }
     }
 

data/rust/rubydex/tests/cli.rs

@@ -1,7 +1,6 @@
 use assert_cmd::{assert::Assert, prelude::*};
 use predicates::prelude::*;
-use regex::Regex;
-use rubydex::test_utils::{normalize_indentation, with_context};
+use rubydex::test_utils::with_context;
 use std::process::Command;
 
 fn rdx_cmd(args: &[&str]) -> Command {
@@ -21,7 +20,7 @@ fn prints_help() {
         .stdout(predicate::str::contains("A Static Analysis Toolkit for Ruby"))
         .stdout(predicate::str::contains("Usage:"))
         .stdout(predicate::str::contains("--stats"))
-        .stdout(predicate::str::contains("--visualize"))
+        .stdout(predicate::str::contains("--dot"))
         .stdout(predicate::str::contains("--stop-after"));
 }
 
@@ -68,68 +67,25 @@ fn prints_index_metrics() {
     });
 }
 
-fn normalize_visualization_output(output: &str) -> String {
-    let def_re = Regex::new(r"def_-?[a-f0-9]+").unwrap();
-    let uri_re = Regex::new(r#"file://[^"]+/([^/"]+\.rb)"#).unwrap();
-
-    let normalized = def_re.replace_all(output, "def_<ID>");
-    uri_re.replace_all(&normalized, "file://<PATH>/$1").to_string()
-}
-
 #[test]
-fn visualize_simple_class() {
+fn dot_flag() {
     with_context(|context| {
         context.write("simple.rb", "class SimpleClass\nend\n");
 
-        let output = rdx_cmd(&[context.absolute_path().to_str().unwrap(), "--visualize"])
-            .output()
-            .unwrap();
-
-        assert!(output.status.success());
-
-        let stdout = String::from_utf8_lossy(&output.stdout);
-        let normalized = normalize_visualization_output(&stdout);
-
-        let expected = normalize_indentation({
-            r#"
-            digraph {
-                rankdir=TB;
-
-                "Name:BasicObject" [label="BasicObject",shape=hexagon];
-                "Name:BasicObject" -> "def_<ID>" [dir=both];
-                "Name:Class" [label="Class",shape=hexagon];
-                "Name:Class" -> "def_<ID>" [dir=both];
-                "Name:Kernel" [label="Kernel",shape=hexagon];
-                "Name:Kernel" -> "def_<ID>" [dir=both];
-                "Name:Module" [label="Module",shape=hexagon];
-                "Name:Module" -> "def_<ID>" [dir=both];
-                "Name:Object" [label="Object",shape=hexagon];
-                "Name:Object" -> "def_<ID>" [dir=both];
-                "Name:SimpleClass" [label="SimpleClass",shape=hexagon];
-                "Name:SimpleClass" -> "def_<ID>" [dir=both];
-
-                "def_<ID>" [label="Class(BasicObject)",shape=ellipse];
-                "def_<ID>" [label="Class(Class)",shape=ellipse];
-                "def_<ID>" [label="Class(Module)",shape=ellipse];
-                "def_<ID>" [label="Class(Object)",shape=ellipse];
-                "def_<ID>" [label="Class(SimpleClass)",shape=ellipse];
-                "def_<ID>" [label="Module(Kernel)",shape=ellipse];
-
-                "file://<PATH>/simple.rb" [label="simple.rb",shape=box];
-                "def_<ID>" -> "file://<PATH>/simple.rb";
-                "rubydex:built-in" [label="rubydex:built-in",shape=box];
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-                "def_<ID>" -> "rubydex:built-in";
-
-            }
-
-            "#
-        });
-
-        assert_eq!(normalized, expected);
+        rdx(&[context.absolute_path().to_str().unwrap(), "--dot"])
+            .success()
+            .stdout(predicate::str::contains("digraph rubydex"))
+            // Document node
+            .stdout(predicate::str::contains("Document"))
+            .stdout(predicate::str::contains("simple.rb"))
+            // Definition node
+            .stdout(predicate::str::contains("ClassDef"))
+            .stdout(predicate::str::contains("SimpleClass"))
+            // Declaration node
+            .stdout(predicate::str::contains("ClassDecl"))
+            // Edges
+            .stdout(predicate::str::contains("defines"))
+            .stdout(predicate::str::contains("declares"));
     });
 }
 

data/rust/rubydex-mcp/Cargo.toml

@@ -1,16 +1,22 @@
 [package]
 name = "rubydex-mcp"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
 rust-version = "1.89.0"
 license = "MIT"
+description = "MCP server exposing Rubydex semantic Ruby code intelligence tools."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "mcp", "static-analysis"]
+categories = ["development-tools"]
 
 [[bin]]
 name = "rubydex_mcp"
 path = "src/main.rs"
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 clap = { version = "4.5.16", features = ["derive"] }
 rmcp = { version = "1.4", features = ["server", "macros", "transport-io", "schemars"] }
 tokio = { version = "1", features = ["macros", "rt", "io-std"] }
@@ -20,7 +26,7 @@ schemars = "1"
 url = "2"
 
 [dev-dependencies]
-rubydex = { path = "../rubydex", features = ["test_utils"] }
+rubydex = { version = "0.2.6", path = "../rubydex", features = ["test_utils"] }
 assert_cmd = "2.0"
 serde_json = "1"
 

data/rust/rubydex-mcp/src/server.rs

@@ -54,7 +54,11 @@ impl RubydexServer {
                 }
 
                 let mut graph = Graph::new();
-                let errors = rubydex::indexing::index_files(&mut graph, file_paths);
+                let errors = rubydex::indexing::index_files(
+                    &mut graph,
+                    file_paths,
+                    rubydex::indexing::IndexerBackend::RubyIndexer,
+                );
                 for error in &errors {
                     eprintln!("Indexing error: {error}");
                 }

data/rust/rubydex-sys/Cargo.toml

@@ -1,14 +1,21 @@
 [package]
 name = "rubydex-sys"
-version = "0.1.0"
+version = "0.2.6"
 edition = "2024"
+rust-version = "1.89.0"
 license = "MIT"
+description = "C FFI bindings for the Rubydex Ruby code indexing engine."
+homepage = "https://github.com/Shopify/rubydex"
+repository = "https://github.com/Shopify/rubydex"
+readme = "README.md"
+keywords = ["ruby", "ffi", "static-analysis"]
+categories = ["development-tools", "external-ffi-bindings"]
 
 [lib]
 crate-type = ["cdylib", "staticlib"]
 
 [dependencies]
-rubydex = { path = "../rubydex" }
+rubydex = { version = "0.2.6", path = "../rubydex" }
 libc = "0.2.174"
 url = "2.5.4"
 line-index = "0.1.2"

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

@@ -7,6 +7,7 @@ use crate::reference_api::CConstantReference;
 use libc::c_char;
 use rubydex::model::definitions::{Definition, Mixin};
 use rubydex::model::ids::DefinitionId;
+use rubydex::query::AliasResolutionError;
 use std::ffi::CString;
 use std::ptr;
 
@@ -276,6 +277,30 @@ pub unsafe extern "C" fn rdx_definition_declaration(pointer: GraphPointer, defin
     })
 }
 
+/// Returns the lexical nesting definition id for the given definition, or NULL if there is no lexical nesting.
+/// Caller must free the returned pointer with `free_u64`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id.
+///
+/// # Panics
+/// This function will panic if the definition cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_definition_lexical_nesting_id(pointer: GraphPointer, definition_id: u64) -> *const u64 {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+        let Some(defn) = graph.definitions().get(&def_id) else {
+            panic!("Definition not found: {definition_id:?}");
+        };
+
+        match defn.lexical_nesting_id() {
+            Some(lexical_nesting_id) => Box::into_raw(Box::new(**lexical_nesting_id)).cast_const(),
+            None => ptr::null(),
+        }
+    })
+}
+
 /// Creates a new iterator over definition IDs for a given declaration by snapshotting the current set of IDs.
 ///
 /// # Panics
@@ -322,8 +347,8 @@ pub unsafe extern "C" fn rdx_definition_is_deprecated(pointer: GraphPointer, def
 }
 
 /// Returns a newly allocated `Location` for the name portion of a definition id.
-/// For class, module, and singleton class definitions, this returns the location of just
-/// the name (e.g., "Bar" in `class Foo::Bar`).
+/// For class, module, singleton class, and method definitions, this returns the location of just
+/// the name (e.g., "Bar" in `class Foo::Bar`, or "foo" in `def foo`).
 /// For other definition types, returns NULL.
 /// Caller must free the returned pointer with `rdx_location_free`.
 ///
@@ -467,3 +492,72 @@ pub unsafe extern "C" fn rdx_definition_mixins(pointer: GraphPointer, definition
         MixinsIter::new(entries.into_boxed_slice())
     })
 }
+
+/// Status of a `MethodAliasDefinition#target` resolution.
+#[repr(u8)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CMethodAliasResolution {
+    /// The alias chain resolved successfully; `declaration` is valid.
+    Resolved = 0,
+    /// The chain could not be resolved because the target name does not exist on the owner, or the owner itself was
+    /// never resolved. Treated as `nil` on the Ruby side.
+    NotFound = 1,
+    /// The alias chain forms a cycle. Surfaced as a `Rubydex::AliasCycleError` on the Ruby side.
+    Cycle = 2,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+pub struct CMethodAliasTargetResult {
+    pub status: CMethodAliasResolution,
+    pub declaration: *const CDeclaration,
+}
+
+/// Resolves a `MethodAliasDefinition` to its target method declaration via `query::follow_method_alias` and reports the
+/// outcome as a tagged status. The `declaration` pointer is non-null only when `status == Resolved`; the caller is
+/// responsible for freeing it with `free_c_declaration`.
+///
+/// # Safety
+/// - `pointer` must be a valid pointer previously returned by `rdx_graph_new`.
+/// - `definition_id` must be a valid definition id for a `MethodAliasDefinition`.
+///
+/// # Panics
+/// Panics on graph inconsistencies (the definition is not a method alias, or the alias resolved to a non-method
+/// declaration).
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_alias_definition_target(
+    pointer: GraphPointer,
+    definition_id: u64,
+) -> CMethodAliasTargetResult {
+    with_graph(pointer, |graph| {
+        let def_id = DefinitionId::new(definition_id);
+
+        match rubydex::query::follow_method_alias(graph, def_id) {
+            Ok(target_id) => {
+                let target_decl = graph
+                    .declarations()
+                    .get(&target_id)
+                    .expect("target declaration must exist");
+                let boxed = Box::new(CDeclaration::from_declaration(target_id, target_decl));
+
+                CMethodAliasTargetResult {
+                    status: CMethodAliasResolution::Resolved,
+                    declaration: Box::into_raw(boxed).cast_const(),
+                }
+            }
+            Err(AliasResolutionError::TargetNotFound | AliasResolutionError::UnresolvedOwner) => {
+                CMethodAliasTargetResult {
+                    status: CMethodAliasResolution::NotFound,
+                    declaration: ptr::null(),
+                }
+            }
+            Err(AliasResolutionError::Cycle) => CMethodAliasTargetResult {
+                status: CMethodAliasResolution::Cycle,
+                declaration: ptr::null(),
+            },
+            Err(err @ (AliasResolutionError::NotAnAlias | AliasResolutionError::TargetNotMethod)) => {
+                panic!("graph inconsistency in method alias resolution: {err:?}")
+            }
+        }
+    })
+}

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

@@ -6,6 +6,7 @@ use std::ptr;
 
 use crate::definition_api::{DefinitionsIter, rdx_definitions_iter_new_from_ids};
 use crate::graph_api::{GraphPointer, with_graph};
+use crate::reference_api::{CMethodReference, MethodReferencesIter};
 use rubydex::model::ids::UriId;
 
 #[derive(Debug)]
@@ -83,3 +84,30 @@ pub unsafe extern "C" fn rdx_document_definitions_iter_new(pointer: GraphPointer
         }
     })
 }
+
+/// Creates a new iterator over method reference IDs for a given document by snapshotting the current set of IDs.
+///
+/// # Safety
+///
+/// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
+/// - The returned pointer must be freed with `rdx_method_references_iter_free`.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_document_method_references_iter_new(
+    pointer: GraphPointer,
+    uri_id: u64,
+) -> *mut MethodReferencesIter {
+    with_graph(pointer, |graph| {
+        let uri_id = UriId::new(uri_id);
+        if let Some(doc) = graph.documents().get(&uri_id) {
+            let entries: Vec<_> = doc
+                .method_references()
+                .iter()
+                .map(|ref_id| CMethodReference { id: **ref_id })
+                .collect();
+
+            MethodReferencesIter::new(entries.into_boxed_slice())
+        } else {
+            MethodReferencesIter::new(Vec::<_>::new().into_boxed_slice())
+        }
+    })
+}

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

@@ -233,7 +233,7 @@ pub unsafe extern "C" fn rdx_index_all(
 
     with_mut_graph(pointer, |graph| {
         let (file_paths, listing_errors) = listing::collect_file_paths(file_paths, graph.excluded_paths());
-        let indexing_errors = indexing::index_files(graph, file_paths);
+        let indexing_errors = indexing::index_files(graph, file_paths, indexing::IndexerBackend::RubyIndexer);
 
         let all_errors: Vec<String> = listing_errors
             .into_iter()
@@ -793,9 +793,7 @@ fn run_and_finalize_completion(
 ///
 /// - `pointer` must be a valid `GraphPointer` previously returned by this crate.
 /// - `nesting` must point to `nesting_count` valid, null-terminated UTF-8 strings.
-/// - `self_receiver` must be null or a valid, null-terminated UTF-8 string. When non-null, it
-///   overrides the self-type (e.g., `"Foo::<Foo>"` for completion inside `def Foo.bar`), while
-///   the lexical nesting still comes from `nesting`.
+/// - `self_receiver` is the fully qualified name of the **type of `self`**
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn rdx_graph_complete_expression(
     pointer: GraphPointer,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.6
 platform: aarch64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-05-26 00:00:00.000000000 Z
+date: 2026-06-25 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs
@@ -16,6 +16,7 @@ email:
 - ruby@shopify.com
 executables:
 - rdx
+- rubydex_mcp
 extensions: []
 extra_rdoc_files: []
 files:
@@ -23,6 +24,7 @@ files:
 - README.md
 - THIRD_PARTY_LICENSES.html
 - exe/rdx
+- exe/rubydex_mcp
 - ext/rubydex/declaration.c
 - ext/rubydex/declaration.h
 - ext/rubydex/definition.c
@@ -49,9 +51,11 @@ files:
 - lib/rubydex/3.3/rubydex.so
 - lib/rubydex/3.4/rubydex.so
 - lib/rubydex/4.0/rubydex.so
+- lib/rubydex/bin/rubydex_mcp
 - lib/rubydex/comment.rb
 - lib/rubydex/declaration.rb
 - lib/rubydex/diagnostic.rb
+- lib/rubydex/errors.rb
 - lib/rubydex/failures.rb
 - lib/rubydex/graph.rb
 - lib/rubydex/keyword.rb
@@ -90,6 +94,7 @@ files:
 - rust/rubydex/Cargo.toml
 - rust/rubydex/src/compile_assertions.rs
 - rust/rubydex/src/diagnostic.rs
+- rust/rubydex/src/dot.rs
 - rust/rubydex/src/errors.rs
 - rust/rubydex/src/indexing.rs
 - rust/rubydex/src/indexing/local_graph.rs
@@ -118,6 +123,10 @@ files:
 - rust/rubydex/src/model/string_ref.rs
 - rust/rubydex/src/model/visibility.rs
 - rust/rubydex/src/offset.rs
+- rust/rubydex/src/operation/applier.rs
+- rust/rubydex/src/operation/mod.rs
+- rust/rubydex/src/operation/printer.rs
+- rust/rubydex/src/operation/ruby_builder.rs
 - rust/rubydex/src/position.rs
 - rust/rubydex/src/query.rs
 - rust/rubydex/src/resolution.rs
@@ -130,8 +139,6 @@ files:
 - rust/rubydex/src/test_utils/context.rs
 - rust/rubydex/src/test_utils/graph_test.rs
 - rust/rubydex/src/test_utils/local_graph_test.rs
-- rust/rubydex/src/visualization.rs
-- rust/rubydex/src/visualization/dot.rs
 - rust/rubydex/tests/cli.rs
 - rust/rustfmt.toml
 homepage: https://github.com/Shopify/rubydex