rubydex 0.1.0.beta4 → 0.1.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b478f1b6a25378ce0dfe556a64fcd7f1dac9aee981edec8a77e03a04dc2123ae
-  data.tar.gz: d3d9164cca1d9071a8e53b7f5d769eec893f4b251ec95918427ea3ecd6ea30b0
+  metadata.gz: c2c48ae779052983ff0d4f7a345b2a6ac612271cc6c015ba99486220d5617949
+  data.tar.gz: 4c81285808882e4a545ecb34bc418821d996fd4e6fe34200f89963430f8014f6
 SHA512:
-  metadata.gz: 6fc387f42024ccedb00e8c6feea3c3d6542ad512fa4b20711a4fdf30cf604833ad72ef890cc379024cbab763f3ae27c867e82885993756ac01f6709eb4dac4d8
-  data.tar.gz: dc1616a4d88eb7de20099888ca7af449a58dba3cbd79ed63e6acb44066420b402007b6d41d98bb84ae9a83e233a914e345a38992dd34b8cd652c146724b57e6d
+  metadata.gz: 0e61f0fbf4d4cf6613042b40a4e72a41d36428b72c1f21c711b9c99ea3e6bc686b87edd9d182307e29af796df7256921da6e88ffb9cf54219630b34c324d151c
+  data.tar.gz: 1bb42b0c43a1483d1610ea743320852c1bcc4d3d5ebfab043949fb18671eb5a0c2d8f7275f3795c66faa884ac40bca62279739a23e38bbef624256c3cdf1a09e

data/README.md

@@ -12,7 +12,7 @@ of using the Ruby API:
 # Create a new graph representing the current workspace
 graph = Rubydex::Graph.new
 # Configuring graph LSP encoding
-graph.set_encoding("utf16")
+graph.encoding = "utf16"
 # Index the entire workspace with all dependencies
 graph.index_workspace
 # Or index specific file paths

data/ext/rubydex/graph.c

@@ -61,6 +61,28 @@ static VALUE rdxr_graph_index_all(VALUE self, VALUE file_paths) {
     return array;
 }
 
+// Indexes a single source string in memory, dispatching to the appropriate indexer based on language_id
+//
+// Graph#index_source: (String uri, String source, String language_id) -> void
+static VALUE rdxr_graph_index_source(VALUE self, VALUE uri, VALUE source, VALUE language_id) {
+    Check_Type(uri, T_STRING);
+    Check_Type(source, T_STRING);
+    Check_Type(language_id, T_STRING);
+
+    void *graph;
+    TypedData_Get_Struct(self, void *, &graph_type, graph);
+
+    const char *uri_str = StringValueCStr(uri);
+    const char *source_str = StringValueCStr(source);
+    const char *language_id_str = StringValueCStr(language_id);
+
+    if (!rdx_index_source(graph, uri_str, source_str, language_id_str)) {
+        rb_raise(rb_eArgError, "unsupported language_id `%s`", language_id_str);
+    }
+
+    return Qnil;
+}
+
 // Size function for the declarations enumerator
 static VALUE graph_declarations_size(VALUE self, VALUE _args, VALUE _eobj) {
     void *graph;
@@ -303,7 +325,7 @@ static VALUE rdxr_graph_resolve(VALUE self) {
     return self;
 }
 
-// Graph#set_encoding: (String) -> void
+// Graph#encoding=: (String) -> void
 // Sets the encoding used for transforming byte offsets into LSP code unit line/column positions
 static VALUE rdxr_graph_set_encoding(VALUE self, VALUE encoding) {
     Check_Type(encoding, T_STRING);
@@ -449,6 +471,7 @@ void rdxi_initialize_graph(VALUE mRubydex) {
     cGraph = rb_define_class_under(mRubydex, "Graph", rb_cObject);
     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, "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);
@@ -459,7 +482,7 @@ void rdxi_initialize_graph(VALUE mRubydex) {
     rb_define_method(cGraph, "diagnostics", rdxr_graph_diagnostics, 0);
     rb_define_method(cGraph, "[]", rdxr_graph_aref, 1);
     rb_define_method(cGraph, "search", rdxr_graph_search, 1);
-    rb_define_method(cGraph, "set_encoding", rdxr_graph_set_encoding, 1);
+    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);
 }

data/lib/rubydex/version.rb

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

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

@@ -1,23 +1,35 @@
 //! Visit the RBS AST and create type definitions.
 
-use crate::{
-    indexing::local_graph::LocalGraph,
-    model::{document::Document, ids::UriId},
-};
+use ruby_rbs::node::{self, ModuleNode, Node, TypeNameNode, Visit};
 
-pub struct RBSIndexer {
-    #[allow(dead_code)]
+use crate::diagnostic::Rule;
+use crate::indexing::local_graph::LocalGraph;
+use crate::model::comment::Comment;
+use crate::model::definitions::{Definition, DefinitionFlags, ModuleDefinition};
+use crate::model::document::Document;
+use crate::model::ids::{DefinitionId, NameId, UriId};
+use crate::model::name::{Name, ParentScope};
+use crate::offset::Offset;
+
+pub struct RBSIndexer<'a> {
     uri_id: UriId,
     local_graph: LocalGraph,
+    source: &'a str,
+    nesting_stack: Vec<DefinitionId>,
 }
 
-impl RBSIndexer {
+impl<'a> RBSIndexer<'a> {
     #[must_use]
-    pub fn new(uri: String, source: &str) -> Self {
+    pub fn new(uri: String, source: &'a str) -> Self {
         let uri_id = UriId::from(&uri);
         let local_graph = LocalGraph::new(uri_id, Document::new(uri, source));
 
-        Self { uri_id, local_graph }
+        Self {
+            uri_id,
+            local_graph,
+            source,
+            nesting_stack: Vec::new(),
+        }
     }
 
     #[must_use]
@@ -25,5 +37,203 @@ impl RBSIndexer {
         self.local_graph
     }
 
-    pub fn index(&mut self) {}
+    pub fn index(&mut self) {
+        let Ok(signature) = node::parse(self.source.as_bytes()) else {
+            self.local_graph.add_diagnostic(
+                Rule::ParseError,
+                Offset::new(0, 0),
+                "Failed to parse RBS document".to_string(),
+            );
+            return;
+        };
+
+        self.visit(&signature.as_node());
+    }
+
+    fn bytes_to_string(name: &[u8]) -> String {
+        String::from_utf8_lossy(name).into_owned()
+    }
+
+    /// Converts an RBS `TypeNameNode` into a rubydex `NameId`.
+    ///
+    /// Walks the namespace path (e.g. `Foo::Bar` in `Foo::Bar::Baz`) to build
+    /// a `ParentScope` chain, then creates the final `Name` for the leaf segment.
+    fn index_type_name(&mut self, type_name: &TypeNameNode, nesting_name_id: Option<NameId>) -> NameId {
+        let namespace = type_name.namespace();
+
+        let mut parent_scope = if namespace.absolute() {
+            ParentScope::TopLevel
+        } else {
+            ParentScope::None
+        };
+
+        for path_node in namespace.path().iter() {
+            let Node::Symbol(symbol) = path_node else {
+                continue;
+            };
+            parent_scope = ParentScope::Some(self.intern_name(symbol.name(), parent_scope, nesting_name_id));
+        }
+
+        self.intern_name(type_name.name().name(), parent_scope, nesting_name_id)
+    }
+
+    fn intern_name(&mut self, name_bytes: &[u8], parent_scope: ParentScope, nesting_name_id: Option<NameId>) -> NameId {
+        let string_id = self.local_graph.intern_string(Self::bytes_to_string(name_bytes));
+        self.local_graph
+            .add_name(Name::new(string_id, parent_scope, nesting_name_id))
+    }
+
+    fn parent_lexical_scope_id(&self) -> Option<DefinitionId> {
+        self.nesting_stack.last().copied()
+    }
+
+    fn add_member_to_current_lexical_scope(&mut self, owner_id: DefinitionId, member_id: DefinitionId) {
+        let owner = self
+            .local_graph
+            .get_definition_mut(owner_id)
+            .expect("owner definition should exist");
+
+        match owner {
+            Definition::Module(module) => module.add_member(member_id),
+            Definition::Class(class) => class.add_member(member_id),
+            _ => unreachable!("RBS nesting stack only contains modules/classes"),
+        }
+    }
+}
+
+impl Visit for RBSIndexer<'_> {
+    fn visit_module_node(&mut self, module_node: &ModuleNode) {
+        let lexical_nesting_id = self.parent_lexical_scope_id();
+        let nesting_name_id = lexical_nesting_id.map(|id| {
+            let owner = self
+                .local_graph
+                .definitions()
+                .get(&id)
+                .expect("owner definition should exist");
+            *owner.name_id().expect("nesting definition should have a name")
+        });
+
+        let type_name = module_node.name();
+        let name_id = self.index_type_name(&type_name, nesting_name_id);
+        let offset = Offset::from_rbs_location(&module_node.location());
+        let name_offset = Offset::from_rbs_location(&type_name.name().location());
+
+        let comments: Vec<_> = module_node
+            .comment()
+            .into_iter()
+            .map(|comment| {
+                let text = Self::bytes_to_string(comment.string().as_bytes());
+                Comment::new(Offset::from_rbs_location(&comment.location()), text)
+            })
+            .collect();
+
+        let definition = Definition::Module(Box::new(ModuleDefinition::new(
+            name_id,
+            self.uri_id,
+            offset,
+            name_offset,
+            comments,
+            DefinitionFlags::empty(),
+            lexical_nesting_id,
+        )));
+
+        let definition_id = self.local_graph.add_definition(definition);
+        if let Some(id) = lexical_nesting_id {
+            self.add_member_to_current_lexical_scope(id, definition_id);
+        }
+
+        self.nesting_stack.push(definition_id);
+
+        for member in module_node.members().iter() {
+            self.visit(&member);
+        }
+
+        self.nesting_stack.pop();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::test_utils::LocalGraphTest;
+    use crate::{
+        assert_def_name_eq, assert_def_name_offset_eq, assert_definition_at, assert_local_diagnostics_eq,
+        assert_no_local_diagnostics,
+    };
+
+    fn index_source(source: &str) -> LocalGraphTest {
+        LocalGraphTest::new_rbs("file:///foo.rbs", source)
+    }
+
+    #[test]
+    fn index_source_with_errors() {
+        let context = index_source("module");
+
+        assert_local_diagnostics_eq!(&context, ["parse-error: Failed to parse RBS document (1:1-1:1)"]);
+
+        assert!(context.graph().definitions().is_empty());
+    }
+
+    #[test]
+    fn index_module_node() {
+        let context = index_source({
+            "
+            module Foo
+              module Bar
+              end
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 2);
+
+        assert_definition_at!(&context, "1:1-4:4", Module, |def| {
+            assert_def_name_eq!(&context, def, "Foo");
+            assert_def_name_offset_eq!(&context, def, "1:8-1:11");
+            assert_eq!(1, def.members().len());
+            assert!(def.lexical_nesting_id().is_none());
+        });
+
+        assert_definition_at!(&context, "2:3-3:6", Module, |def| {
+            assert_def_name_eq!(&context, def, "Bar");
+            assert_def_name_offset_eq!(&context, def, "2:10-2:13");
+
+            assert_definition_at!(&context, "1:1-4:4", Module, |parent_nesting| {
+                assert_eq!(parent_nesting.id(), def.lexical_nesting_id().unwrap());
+                assert_eq!(parent_nesting.members()[0], def.id());
+            });
+        });
+    }
+
+    #[test]
+    fn index_module_node_with_qualified_name() {
+        let context = index_source({
+            "
+            module Foo
+              module Bar::Baz
+              end
+            end
+            "
+        });
+
+        assert_no_local_diagnostics!(&context);
+        assert_eq!(context.graph().definitions().len(), 2);
+
+        assert_definition_at!(&context, "1:1-4:4", Module, |def| {
+            assert_def_name_eq!(&context, def, "Foo");
+            assert_def_name_offset_eq!(&context, def, "1:8-1:11");
+            assert_eq!(1, def.members().len());
+            assert!(def.lexical_nesting_id().is_none());
+        });
+
+        assert_definition_at!(&context, "2:3-3:6", Module, |def| {
+            assert_def_name_eq!(&context, def, "Bar::Baz");
+            assert_def_name_offset_eq!(&context, def, "2:15-2:18");
+
+            assert_definition_at!(&context, "1:1-4:4", Module, |parent_nesting| {
+                assert_eq!(parent_nesting.id(), def.lexical_nesting_id().unwrap());
+                assert_eq!(parent_nesting.members()[0], def.id());
+            });
+        });
+    }
 }