rubydex 0.1.0.beta2 → 0.1.0.beta4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb8f807fc83bb4eda600ee3e1beb0946f3aadffe4eec4d73435dc4eaf611339d
-  data.tar.gz: 0ae8326b457b0ff4defad2fc5ff3c7fe7c368910763d85e2d0a807944d5709aa
+  metadata.gz: b478f1b6a25378ce0dfe556a64fcd7f1dac9aee981edec8a77e03a04dc2123ae
+  data.tar.gz: d3d9164cca1d9071a8e53b7f5d769eec893f4b251ec95918427ea3ecd6ea30b0
 SHA512:
-  metadata.gz: fcc8407ab2077cc18fe1bdfe418bf28edcdbf1c2d4035a1a9d19977084b20acbbc540759e0ef1723fa4fdf0f96daca7867a0d62e19ef1f077acd7d298771a109
-  data.tar.gz: fb911a5d36c74b7c5a8a70cd9b13faf77ea7289a73d04a69d37aa7ec01fb1e9dc35c4770a25207a5fbd5addefa5b8e0eace9f08425c221349b6c4eab7da59a7b
+  metadata.gz: 6fc387f42024ccedb00e8c6feea3c3d6542ad512fa4b20711a4fdf30cf604833ad72ef890cc379024cbab763f3ae27c867e82885993756ac01f6709eb4dac4d8
+  data.tar.gz: dc1616a4d88eb7de20099888ca7af449a58dba3cbd79ed63e6acb44066420b402007b6d41d98bb84ae9a83e233a914e345a38992dd34b8cd652c146724b57e6d

data/README.md

@@ -11,13 +11,70 @@ of using the Ruby API:
 ```ruby
 # Create a new graph representing the current workspace
 graph = Rubydex::Graph.new
+# Configuring graph LSP encoding
+graph.set_encoding("utf16")
 # Index the entire workspace with all dependencies
 graph.index_workspace
+# Or index specific file paths
+graph.index_all(["path/to/file.rb"])
 # Transform the initially collected information into its semantic understanding by running resolution
 graph.resolve
+# Get all diagnostics acquired during the analysis
+graph.diagnostics
 
-# Access the information as needed
-graph["Foo"]
+# Iterating over graph nodes
+graph.declarations
+graph.documents
+graph.constant_references
+graph.method_references
+
+# Analyzing require paths
+graph.resolve_require_path("rails/engine", load_paths) # => document pointed by `rails/engine`
+graph.require_paths(load_paths) # => array of all indexed require paths
+
+# Querying
+graph["Foo"] # Get declaration by fully qualified name
+graph.search("Foo#b") # Name search
+graph.resolve_constant("Bar", ["Foo", "Baz::Qux"]) # Resolve constant reference based on nesting
+
+# Declarations
+declaration = graph["Foo"]
+
+# All declarations include
+declaration.name
+declaration.unqualified_name
+declaration.definitions
+declaration.owner
+
+# Namespace declarations include
+declaration.member("bar()")
+declaration.member("@ivar")
+declaration.singleton_class
+declaration.ancestors
+declaration.descendants
+
+# Documents
+document = graph.documents.first
+document.uri
+document.definitions # => list of definitions discovered in this document
+
+# Definitions
+definition = declaration.definitions.first
+definition.location
+definition.comments
+definition.name
+definition.deprecated?
+definition.name_location
+
+# Locations
+location = definition.location
+location.path
+
+# Diagnostics
+diagnostic = graph.diagnostics.first
+diagnostic.rule
+diagnostic.message
+diagnostic.location
 ```
 
 ## Contributing

data/THIRD_PARTY_LICENSES.html

@@ -53,6 +53,7 @@
             <li><a href="#Apache-2.0">Apache License 2.0</a> (106)</li>
             <li><a href="#Unicode-3.0">Unicode License v3</a> (19)</li>
             <li><a href="#MIT">MIT License</a> (15)</li>
+            <li><a href="#BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</a> (2)</li>
             <li><a href="#BSD-3-Clause">BSD 3-Clause &quot;New&quot; or &quot;Revised&quot; License</a> (1)</li>
             <li><a href="#BSL-1.0">Boost Software License 1.0</a> (1)</li>
             <li><a href="#ISC">ISC License</a> (1)</li>
@@ -2332,6 +2333,28 @@ distributed under the License is distributed on an &quot;AS IS&quot; BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
+</pre>
+            </li>
+            <li class="license">
+                <h3 id="BSD-2-Clause">BSD 2-Clause &quot;Simplified&quot; License</h3>
+                <h4>Used by:</h4>
+                <ul class="license-used-by">
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs-sys
+                            0.1.1</a></li>
+                    <li><a
+                            href=" https://github.com/ruby/rbs.git ">ruby-rbs
+                            0.1.1</a></li>
+                </ul>
+                <pre class="license-text">Copyright (c) &lt;year&gt; &lt;owner&gt; 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 </pre>
             </li>
             <li class="license">
@@ -2539,10 +2562,10 @@ THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRES
                 <ul class="license-used-by">
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism-sys
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                     <li><a
                             href=" https://github.com/ruby/prism ">ruby-prism
-                            1.6.0</a></li>
+                            1.9.0</a></li>
                 </ul>
                 <pre class="license-text">Copyright 2022-present, Shopify Inc.
 

data/ext/rubydex/declaration.c

@@ -3,8 +3,45 @@
 #include "graph.h"
 #include "handle.h"
 #include "rustbindings.h"
+#include "utils.h"
 
 VALUE cDeclaration;
+VALUE cNamespace;
+VALUE cClass;
+VALUE cModule;
+VALUE cSingletonClass;
+VALUE cConstant;
+VALUE cConstantAlias;
+VALUE cMethod;
+VALUE cGlobalVariable;
+VALUE cInstanceVariable;
+VALUE cClassVariable;
+
+// Keep this in sync with declaration_api.rs
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind) {
+    switch (kind) {
+    case CDeclarationKind_Class:
+        return cClass;
+    case CDeclarationKind_Module:
+        return cModule;
+    case CDeclarationKind_SingletonClass:
+        return cSingletonClass;
+    case CDeclarationKind_Constant:
+        return cConstant;
+    case CDeclarationKind_ConstantAlias:
+        return cConstantAlias;
+    case CDeclarationKind_Method:
+        return cMethod;
+    case CDeclarationKind_GlobalVariable:
+        return cGlobalVariable;
+    case CDeclarationKind_InstanceVariable:
+        return cInstanceVariable;
+    case CDeclarationKind_ClassVariable:
+        return cClassVariable;
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CDeclarationKind: %d", kind);
+    }
+}
 
 // Declaration#name -> String
 static VALUE rdxr_declaration_name(VALUE self) {
@@ -52,10 +89,10 @@ static VALUE declaration_definitions_yield(VALUE args) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
-    int64_t id = 0;
+    uint64_t id = 0;
     DefinitionKind kind;
     while (rdx_definitions_iter_next(iter, &id, &kind)) {
-        VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
         VALUE defn_class = rdxi_definition_class_for_kind(kind);
         VALUE handle = rb_class_new_instance(2, argv, defn_class);
         rb_yield(handle);
@@ -120,27 +157,129 @@ static VALUE rdxr_declaration_member(VALUE self, VALUE name) {
         rb_raise(rb_eTypeError, "expected String");
     }
 
-    const int64_t *id_ptr = rdx_declaration_member(graph, data->id, StringValueCStr(name));
-    if (id_ptr == NULL) {
+    const CDeclaration *decl = rdx_declaration_member(graph, data->id, StringValueCStr(name));
+    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);
+}
+
+// Declaration#singleton_class -> SingletonClass
+static VALUE rdxr_declaration_singleton_class(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 CDeclaration *decl = rdx_declaration_singleton_class(graph, data->id);
+
+    if (decl == NULL) {
         return Qnil;
     }
 
-    int64_t id = *id_ptr;
-    free_i64(id_ptr);
-    VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+    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);
+}
+
+// Declaration#owner -> Declaration
+static VALUE rdxr_declaration_owner(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 CDeclaration *decl = rdx_declaration_owner(graph, data->id);
+
+    if (decl == NULL) {
+        rb_raise(rb_eRuntimeError, "owner can never be nil for any declarations");
+    }
+
+    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);
+}
+
+// Declaration#ancestors: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_ancestors(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("ancestors"), 0, NULL);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    void *iter = rdx_declaration_ancestors(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
+
+    return self;
+}
+
+// Declaration#descendants: () -> Enumerator[Declaration]
+static VALUE rdxr_declaration_descendants(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize(self, rb_str_new2("descendants"), 0, NULL);
+    }
+
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    void *iter = rdx_declaration_descendants(graph, data->id);
+    if (iter == NULL) {
+        rb_raise(rb_eRuntimeError, "failed to create iterator");
+    }
+
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_declarations_yield, args, rdxi_declarations_ensure, args);
 
-    return rb_class_new_instance(2, argv, cDeclaration);
+    return self;
 }
 
 void rdxi_initialize_declaration(VALUE mRubydex) {
     cDeclaration = rb_define_class_under(mRubydex, "Declaration", rb_cObject);
+    cNamespace = rb_define_class_under(mRubydex, "Namespace", cDeclaration);
+    cClass = rb_define_class_under(mRubydex, "Class", cNamespace);
+    cModule = rb_define_class_under(mRubydex, "Module", cNamespace);
+    cSingletonClass = rb_define_class_under(mRubydex, "SingletonClass", cNamespace);
+    cConstant = rb_define_class_under(mRubydex, "Constant", cDeclaration);
+    cConstantAlias = rb_define_class_under(mRubydex, "ConstantAlias", cDeclaration);
+    cMethod = rb_define_class_under(mRubydex, "Method", cDeclaration);
+    cGlobalVariable = rb_define_class_under(mRubydex, "GlobalVariable", cDeclaration);
+    cInstanceVariable = rb_define_class_under(mRubydex, "InstanceVariable", cDeclaration);
+    cClassVariable = rb_define_class_under(mRubydex, "ClassVariable", cDeclaration);
 
     rb_define_alloc_func(cDeclaration, rdxr_handle_alloc);
     rb_define_method(cDeclaration, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cDeclaration, "name", rdxr_declaration_name, 0);
     rb_define_method(cDeclaration, "unqualified_name", rdxr_declaration_unqualified_name, 0);
     rb_define_method(cDeclaration, "definitions", rdxr_declaration_definitions, 0);
-    rb_define_method(cDeclaration, "member", rdxr_declaration_member, 1);
+    rb_define_method(cDeclaration, "owner", rdxr_declaration_owner, 0);
+
+    // Namespace only methods
+    rb_define_method(cNamespace, "member", rdxr_declaration_member, 1);
+    rb_define_method(cNamespace, "singleton_class", rdxr_declaration_singleton_class, 0);
+    rb_define_method(cNamespace, "ancestors", rdxr_declaration_ancestors, 0);
+    rb_define_method(cNamespace, "descendants", rdxr_declaration_descendants, 0);
 
     rb_funcall(rb_singleton_class(cDeclaration), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 }

data/ext/rubydex/declaration.h

@@ -2,9 +2,21 @@
 #define RUBYDEX_DECLARATION_H
 
 #include "ruby.h"
+#include "rustbindings.h"
 
 extern VALUE cDeclaration;
+extern VALUE cNamespace;
+extern VALUE cClass;
+extern VALUE cModule;
+extern VALUE cSingletonClass;
+extern VALUE cConstant;
+extern VALUE cConstantAlias;
+extern VALUE cMethod;
+extern VALUE cGlobalVariable;
+extern VALUE cInstanceVariable;
+extern VALUE cClassVariable;
 
+VALUE rdxi_declaration_class_for_kind(CDeclarationKind kind);
 void rdxi_initialize_declaration(VALUE mRubydex);
 
 #endif // RUBYDEX_DECLARATION_H

data/ext/rubydex/definition.c

@@ -177,58 +177,17 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
-    rb_define_alloc_func(cClassDefinition, rdxr_handle_alloc);
-    rb_define_method(cClassDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cSingletonClassDefinition = rb_define_class_under(mRubydex, "SingletonClassDefinition", cDefinition);
-    rb_define_alloc_func(cSingletonClassDefinition, rdxr_handle_alloc);
-    rb_define_method(cSingletonClassDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cModuleDefinition = rb_define_class_under(mRubydex, "ModuleDefinition", cDefinition);
-    rb_define_alloc_func(cModuleDefinition, rdxr_handle_alloc);
-    rb_define_method(cModuleDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cConstantDefinition = rb_define_class_under(mRubydex, "ConstantDefinition", cDefinition);
-    rb_define_alloc_func(cConstantDefinition, rdxr_handle_alloc);
-    rb_define_method(cConstantDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cConstantAliasDefinition = rb_define_class_under(mRubydex, "ConstantAliasDefinition", cDefinition);
-    rb_define_alloc_func(cConstantAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cConstantAliasDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cMethodDefinition = rb_define_class_under(mRubydex, "MethodDefinition", cDefinition);
-    rb_define_alloc_func(cMethodDefinition, rdxr_handle_alloc);
-    rb_define_method(cMethodDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrAccessorDefinition = rb_define_class_under(mRubydex, "AttrAccessorDefinition", cDefinition);
-    rb_define_alloc_func(cAttrAccessorDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrAccessorDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrReaderDefinition = rb_define_class_under(mRubydex, "AttrReaderDefinition", cDefinition);
-    rb_define_alloc_func(cAttrReaderDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrReaderDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cAttrWriterDefinition = rb_define_class_under(mRubydex, "AttrWriterDefinition", cDefinition);
-    rb_define_alloc_func(cAttrWriterDefinition, rdxr_handle_alloc);
-    rb_define_method(cAttrWriterDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cGlobalVariableDefinition = rb_define_class_under(mRubydex, "GlobalVariableDefinition", cDefinition);
-    rb_define_alloc_func(cGlobalVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cGlobalVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cInstanceVariableDefinition = rb_define_class_under(mRubydex, "InstanceVariableDefinition", cDefinition);
-    rb_define_alloc_func(cInstanceVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cInstanceVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
-    rb_define_alloc_func(cClassVariableDefinition, rdxr_handle_alloc);
-    rb_define_method(cClassVariableDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
-    rb_define_alloc_func(cMethodAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cMethodAliasDefinition, "initialize", rdxr_handle_initialize, 2);
-
     cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
-    rb_define_alloc_func(cGlobalVariableAliasDefinition, rdxr_handle_alloc);
-    rb_define_method(cGlobalVariableAliasDefinition, "initialize", rdxr_handle_initialize, 2);
 }

data/ext/rubydex/document.c

@@ -33,10 +33,10 @@ static VALUE document_definitions_yield(VALUE args) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
 
-    int64_t id = 0;
+    uint64_t id = 0;
     DefinitionKind kind;
     while (rdx_definitions_iter_next(iter, &id, &kind)) {
-        VALUE argv[] = {data->graph_obj, LL2NUM(id)};
+        VALUE argv[] = {data->graph_obj, ULL2NUM(id)};
         VALUE defn_class = rdxi_definition_class_for_kind(kind);
         VALUE handle = rb_class_new_instance(2, argv, defn_class);
         rb_yield(handle);

data/ext/rubydex/extconf.rb

@@ -56,7 +56,7 @@ end
 create_makefile("rubydex/rubydex")
 
 cargo_command = if ENV["SANITIZER"]
-  ENV["RUSTFLAGS"] = "-Zsanitizer=#{ENV["SANITIZER"]}"
+  ENV["RUSTFLAGS"] = "-Zsanitizer=#{ENV["SANITIZER"]} -C target-cpu=x86-64-v3"
   "cargo +nightly build -Zbuild-std #{cargo_args.join(" ")}".strip
 else
   "cargo build #{cargo_args.join(" ")}".strip