rubydex 0.1.0.beta14-aarch64-linux → 0.2.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cdc01aa399a75ed7879bb08aead637940bcf6311bd73e81e36225bff02911f9e
-  data.tar.gz: 85d5ffede4745c71b7361576149abc56670ed10a7c3488a218ac82daf10a5c00
+  metadata.gz: 44787b43319481966587e2e358c33a55e58800a092864ef132d9c10d2271f5c0
+  data.tar.gz: 520ab23713bc163e050622c52b986672e591c116954935e6957c7f8e52dfe343
 SHA512:
-  metadata.gz: 17a6b72d3bb15e77b74a19734cd31462c83899fbd96c8a9af81f797a40b6881eafdec3313fc7eb686e8c9cb16c98ef45a4d320aa2063990ba8c0a6f7332b2ba9
-  data.tar.gz: fbb9acee6525a8a7c94dbca60c26ad11dc507e6e2c540cf655e4e0adb600b81b175392e332a62c93372e2e1264d2bbd8cae8ede0fdd6573b99afa1a3bc5038a9
+  metadata.gz: 941b4124e0ec93076390a9a777d538189316512a964d4cc2210ad9775ff14408ccd2912c2e757314304ba4eb343bef241a82399b8a99d8f3b5a9b959608126ff
+  data.tar.gz: 74a4eaeeb123b057140cd64529dc4502232ca4b3821a992f6a91cb85994de0b3173f0042249aa8eeab4c53cb7486dde3bb9e7ee3c790dde6d29ad6bbb00b7750

data/exe/rdx

@@ -2,11 +2,12 @@
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
 require "optparse"
 
-OptionParser.new do |parser|
-  parser.banner = "Usage: [path1, path2]"
+options = {}
 
+OptionParser.new do |parser|
   parser.on("--version", "Print the gem's version") do
     require "rubydex/version"
     puts "v#{Rubydex::VERSION}"
@@ -17,31 +18,34 @@ OptionParser.new do |parser|
     puts parser
     exit
   end
+
+  parser.on("-i", "--interactive", "Open an interactive session with a populated graph for the current workspace") do
+    options[:interactive] = true
+  end
 end.parse!
 
 require "rubydex"
 
-workspace_path = ARGV.first
-
-# If a workspace path is passed, we need to ensure that Bundler is setup in that context so that we find the
-# dependencies for that project
-if workspace_path
-  gemfile_path = File.join(workspace_path, "Gemfile")
-
-  if File.exist?(gemfile_path)
-    ENV["BUNDLE_GEMFILE"] = gemfile_path
-
-    begin
-      Bundler.setup
-    rescue Bundler::BundlerError => e
-      $stderr.puts(<<~MESSAGE)
-        Bundle setup failed for #{gemfile_path}. Indexing of dependencies may be partial
-        Error:
-          #{e.message}
-      MESSAGE
-    end
-  end
+def __with_timer(message, &block)
+  print(message)
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+  block.call
+  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+  puts " finished in #{duration.round(2)}ms"
 end
 
-graph = Rubydex::Graph.new(workspace_path: workspace_path)
-graph.index_workspace
+graph = Rubydex::Graph.new
+__with_timer("Indexing workspace...") { graph.index_workspace }
+__with_timer("Resolving graph...") { graph.resolve }
+
+if options[:interactive]
+  begin
+    require "irb"
+    IRB.setup(nil)
+    IRB.conf[:IRB_NAME] = "rubydex"
+    workspace = IRB::WorkSpace.new(binding)
+    IRB::Irb.new(workspace).run(IRB.conf)
+  rescue LoadError
+    abort("Interactive mode requires `irb` to be in the bundle")
+  end
+end

data/ext/rubydex/extconf.rb

@@ -141,10 +141,12 @@ end
 
 File.write("Makefile", new_makefile)
 
-begin
-  require "extconf_compile_commands_json"
+if developing_rubydex
+  begin
+    require "extconf_compile_commands_json"
 
-  ExtconfCompileCommandsJson.generate!
-  ExtconfCompileCommandsJson.symlink!
-rescue LoadError # rubocop:disable Lint/SuppressedException
+    ExtconfCompileCommandsJson.generate!
+    ExtconfCompileCommandsJson.symlink!
+  rescue LoadError # rubocop:disable Lint/SuppressedException
+  end
 end

data/ext/rubydex/graph.c

@@ -303,6 +303,24 @@ static VALUE rdxr_graph_method_references(VALUE self) {
     return self;
 }
 
+// Graph#document: (String uri) -> Document?
+// Returns the Document for the given URI, or nil if it doesn't exist.
+static VALUE rdxr_graph_document(VALUE self, VALUE uri) {
+    Check_Type(uri, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+    const uint64_t *uri_id = rdx_graph_get_document(graph, StringValueCStr(uri));
+
+    if (uri_id == NULL) {
+        return Qnil;
+    }
+
+    VALUE argv[] = {self, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 // Graph#delete_document: (String uri) -> Document?
 // Deletes a document and all of its definitions from the graph.
 // Returns the removed Document or nil if it doesn't exist.
@@ -676,6 +694,7 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     rb_define_alloc_func(cGraph, rdxr_graph_alloc);
     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);
     rb_define_method(cGraph, "delete_document", rdxr_graph_delete_document, 1);
     rb_define_method(cGraph, "resolve", rdxr_graph_resolve, 0);
     rb_define_method(cGraph, "resolve_constant", rdxr_graph_resolve_constant, 2);

data/ext/rubydex/reference.c

@@ -75,6 +75,28 @@ static VALUE rdxr_method_reference_location(VALUE self) {
     return location;
 }
 
+// MethodReference#receiver -> Rubydex::Declaration?
+// Returns the resolved declaration for the receiver of the method call. Returns nil when the receiver is not a
+// tracked constant or cannot be resolved.
+static VALUE rdxr_method_reference_receiver(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    const struct CDeclaration *decl = rdx_method_reference_receiver_declaration(graph, data->id);
+    if (decl == NULL) {
+        return Qnil;
+    }
+
+    VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);
+    VALUE argv[] = {data->graph_obj, ULL2NUM(decl->id)};
+    free_c_declaration(decl);
+
+    return rb_class_new_instance(2, argv, decl_class);
+}
+
 // ResolvedConstantReference#declaration -> Declaration
 static VALUE rdxr_resolved_constant_reference_declaration(VALUE self) {
     HandleData *data;
@@ -120,4 +142,5 @@ void rdxi_initialize_reference(VALUE mRubydex) {
     rb_define_method(cMethodReference, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cMethodReference, "name", rdxr_method_reference_name, 0);
     rb_define_method(cMethodReference, "location", rdxr_method_reference_location, 0);
+    rb_define_method(cMethodReference, "receiver", rdxr_method_reference_receiver, 0);
 }

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.1.0.beta14"
+  VERSION = "0.2.0"
 end

data/rbi/rubydex.rbi

@@ -259,6 +259,9 @@ class Rubydex::Graph
   sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
   def delete_document(uri); end
 
+  sig { params(uri: String).returns(T.nilable(Rubydex::Document)) }
+  def document(uri); end
+
   sig { returns(T::Array[Rubydex::Diagnostic]) }
   def diagnostics; end
 
@@ -415,6 +418,9 @@ class Rubydex::MethodReference < Rubydex::Reference
 
   sig { returns(String) }
   def name; end
+
+  sig { returns(T.nilable(Rubydex::Declaration)) }
+  def receiver; end
 end
 
 class Rubydex::Reference

data/rust/rubydex/src/indexing/ruby_indexer.rs

@@ -234,6 +234,7 @@ impl<'a> RubyIndexer<'a> {
                     Offset::from_prism_location(&name_loc),
                     str_id,
                 )));
+                self.visit(&opt_param.value());
             }
 
             if let Some(rest) = parameters_list.rest() {
@@ -276,6 +277,7 @@ impl<'a> RubyIndexer<'a> {
                         let str_id = self.local_graph.intern_string(self.offset_to_string(&offset));
 
                         parameters.push(Parameter::OptionalKeyword(ParameterStruct::new(offset, str_id)));
+                        self.visit(&optional.value());
                     }
                     _ => {}
                 }

data/rust/rubydex/src/indexing/ruby_indexer_tests.rs

@@ -4060,6 +4060,19 @@ mod constant_reference_tests {
         );
     }
 
+    #[test]
+    fn index_unresolved_constant_references_in_default_values() {
+        let context = index_source({
+            "
+            def foo(a = C1, b = C2::C3); end
+            def bar(a: C4, b: C5::C6); end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_constant_references_eq!(&context, ["C1", "C2", "C3", "C4", "C5", "C6"]);
+    }
+
     #[test]
     fn index_constant_path_and_write_visits_value() {
         let context = index_source({

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

@@ -9,7 +9,7 @@ use libc::{c_char, c_void};
 use rubydex::indexing::LanguageId;
 use rubydex::model::encoding::Encoding;
 use rubydex::model::graph::Graph;
-use rubydex::model::ids::{DeclarationId, NameId};
+use rubydex::model::ids::{DeclarationId, NameId, UriId};
 use rubydex::model::keywords;
 use rubydex::model::name::NameRef;
 use rubydex::query::{CompletionCandidate, CompletionContext, CompletionReceiver};
@@ -260,6 +260,29 @@ pub unsafe extern "C" fn rdx_index_all(
     })
 }
 
+/// Returns a pointer to the URI ID of the document identified by `uri`, or NULL if it doesn't exist.
+/// Caller must free the returned pointer with `free_u64`.
+///
+/// # Safety
+///
+/// Expects both the graph pointer and uri string pointer to be valid
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_graph_get_document(pointer: GraphPointer, uri: *const c_char) -> *const u64 {
+    let Ok(uri_str) = (unsafe { utils::convert_char_ptr_to_string(uri) }) else {
+        return ptr::null();
+    };
+
+    with_graph(pointer, |graph| {
+        let uri_id = UriId::from(uri_str.as_str());
+
+        if graph.documents().contains_key(&uri_id) {
+            Box::into_raw(Box::new(*uri_id)).cast_const()
+        } else {
+            ptr::null()
+        }
+    })
+}
+
 /// Deletes a document and all of its definitions from the graph.
 /// Returns a pointer to the URI ID if the document was found and removed, or NULL if it didn't exist.
 /// Caller must free the returned pointer with `free_u64`.

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

@@ -226,6 +226,43 @@ pub unsafe extern "C" fn rdx_resolved_constant_reference_declaration(
     })
 }
 
+/// Returns the declaration of the resolved receiver for the given method reference. Returns NULL when the method
+/// reference has no tracked receiver or when the receiver could not be resolved. Caller must free with
+/// `free_c_declaration`.
+///
+/// # Safety
+///
+/// Assumes pointer is valid.
+///
+/// # Panics
+///
+/// This function will panic if the reference cannot be found.
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn rdx_method_reference_receiver_declaration(
+    pointer: GraphPointer,
+    reference_id: u64,
+) -> *const CDeclaration {
+    with_graph(pointer, |graph| {
+        let ref_id = MethodReferenceId::new(reference_id);
+        let reference = graph.method_references().get(&ref_id).expect("Reference not found");
+
+        let Some(name_id) = reference.receiver() else {
+            return ptr::null();
+        };
+
+        let name_ref = graph.names().get(&name_id).expect("Name ID should exist");
+
+        match name_ref {
+            NameRef::Resolved(resolved) => {
+                let decl_id = *resolved.declaration_id();
+                let decl = graph.declarations().get(&decl_id).expect("Declaration not found");
+                Box::into_raw(Box::new(CDeclaration::from_declaration(decl_id, decl))).cast_const()
+            }
+            NameRef::Unresolved(_) => ptr::null(),
+        }
+    })
+}
+
 /// Returns a newly allocated `Location` for the given method reference id.
 /// Caller must free the returned pointer with `rdx_location_free`.
 ///

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubydex
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta14
+  version: 0.2.0
 platform: aarch64-linux
 authors:
 - Shopify
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-04-28 00:00:00.000000000 Z
+date: 2026-05-01 00:00:00.000000000 Z
 dependencies: []
 description: A high-performance static analysis suite for Ruby, built in Rust with
   Ruby APIs