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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49147264143f618ef7d2b5bbfa983e511b86123dc01548c2a4176e686a44b57e
-  data.tar.gz: cbd51f1380330f85dde7861c7df96cbc1db4117458952c561164eef9c511901e
+  metadata.gz: f428a340913b09bd93ef62c2c150af6fee8513747d932c58605b0c262e533ad4
+  data.tar.gz: 78917993925bf6c11911a869f8ff6cc0ec27097b03244797a1e54422910ab471
 SHA512:
-  metadata.gz: 5daa009adaef78d504f2710aac72ec36875a3a7ae169048b36e7220d984ddaf7dd562431a460a44b95530bb030a341887ccf300d14646051f722ba0cc941e9bb
-  data.tar.gz: adf4c9a9faf405356b64e6de927a7aa4b8499164c9cf48918683b45ab0e7825668f5505d50e0b29305292bae3db511ae6ffb6ab2e96628c1b1ecdc2076fb8b3b
+  metadata.gz: 4b47ac60c6a4920bd85b99154545acf82cd57a2036dd748e181159a286474643def1151f13fbdae99d15244ab89576c769d0a713e42a6f1e667da5a26052cc66
+  data.tar.gz: e3a5203e261885c70a7240e0ee8a87ce8412525015c330a980c4d715e9cb6d333405cab81c4c83d0ef01112bd68d858c71e9f948fd29404b30972ae661bc8b0a

data/README.md

@@ -84,30 +84,31 @@ like Claude to semantically query your Ruby codebase.
 
 ### Setup
 
-1. Install the binary:
+1. Add Rubydex to the Ruby project you want to index:
+   ```ruby
+   gem "rubydex"
+   ```
+
+2. Install the bundle:
    ```bash
-   cargo install --path rust/rubydex-mcp
+   bundle install
    ```
 
-2. Add rubydex to the Ruby project you want to index:
+3. Configure your MCP client to run `bundle exec rubydex_mcp`.
+
+   Using Claude Code as an example:
    ```bash
-   claude mcp add --scope project rubydex "\${HOME}/.cargo/bin/rubydex_mcp"
+   claude mcp add --scope project rubydex -- bundle exec rubydex_mcp
    ```
 
-   Or manually create a `.mcp.json` in the project root:
-   ```json
-   {
-     "mcpServers": {
-       "rubydex": {
-         "command": "${HOME}/.cargo/bin/rubydex_mcp"
-       }
-     }
-   }
+   Using Codex as an example:
+   ```bash
+   codex mcp add rubydex -- bundle exec rubydex_mcp
    ```
 
-3. Start Claude Code from that project directory. The MCP server indexes
-   the project at startup and provides semantic code intelligence tools.
-   Verify with `/mcp` in the session.
+   Start your MCP client from that project directory. The MCP server indexes
+   the project at startup and provides semantic code intelligence tools through
+   the tools below.
 
 ### Available MCP Tools
 

data/THIRD_PARTY_LICENSES.html

@@ -3823,14 +3823,14 @@ SOFTWARE.
                 <h4>Used by:</h4>
                 <ul class="license-used-by">
                     <li><a
-                            href=" https://crates.io/crates/rubydex ">rubydex
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex
+                            0.2.6</a></li>
                     <li><a
-                            href=" https://crates.io/crates/rubydex-mcp ">rubydex-mcp
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex-mcp
+                            0.2.6</a></li>
                     <li><a
-                            href=" https://crates.io/crates/rubydex-sys ">rubydex-sys
-                            0.1.0</a></li>
+                            href=" https://github.com/Shopify/rubydex ">rubydex-sys
+                            0.2.6</a></li>
                     <li><a
                             href=" https://github.com/DimaKudosh/difflib ">difflib
                             0.4.0</a></li>

data/exe/rubydex_mcp

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "rbconfig"
+
+host_os = RbConfig::CONFIG.fetch("host_os")
+executable = host_os.match?(/mswin|mingw|cygwin/) ? "rubydex_mcp.exe" : "rubydex_mcp"
+binary = File.expand_path("../lib/rubydex/bin/#{executable}", __dir__)
+
+unless File.executable?(binary)
+  abort(<<~MESSAGE.chomp)
+    rubydex_mcp is not available at #{binary}.
+    Install a precompiled rubydex gem, or reinstall rubydex with Cargo available so the MCP executable can be built locally.
+  MESSAGE
+end
+
+exec(binary, *ARGV)

data/ext/rubydex/definition.c

@@ -154,8 +154,8 @@ static VALUE rdxr_definition_deprecated(VALUE self) {
 }
 
 // Definition#name_location -> Rubydex::Location or nil
-// For class, module, and singleton class definitions, returns the location of just the name
-// (e.g., "Bar" in "class Foo::Bar"). For other definition types, returns nil.
+// For class, module, singleton class, and method definitions, returns the location of just the name
+// (e.g., "Bar" in "class Foo::Bar", or "foo" in "def foo"). For other definition types, returns nil.
 static VALUE rdxr_definition_name_location(VALUE self) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
@@ -195,6 +195,60 @@ static VALUE rdxr_definition_declaration(VALUE self) {
     return rb_class_new_instance(2, argv, decl_class);
 }
 
+static VALUE rdxi_build_definition(VALUE graph_obj, void *graph, uint64_t definition_id) {
+    DefinitionKind kind = rdx_definition_kind(graph, definition_id);
+    VALUE defn_class = rdxi_definition_class_for_kind(kind);
+    VALUE argv[] = {graph_obj, ULL2NUM(definition_id)};
+
+    return rb_class_new_instance(2, argv, defn_class);
+}
+
+// Definition#lexical_owner -> Rubydex::Definition?
+// Returns the lexically enclosing definition, if any.
+static VALUE rdxr_definition_lexical_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 uint64_t *owner_id = rdx_definition_lexical_nesting_id(graph, data->id);
+    if (owner_id == NULL) {
+        return Qnil;
+    }
+
+    VALUE owner = rdxi_build_definition(data->graph_obj, graph, *owner_id);
+    free_u64(owner_id);
+
+    return owner;
+}
+
+// Definition#lexical_nesting -> Array<Rubydex::Definition>
+// Returns the lexical nesting from the direct owner up to the root.
+static VALUE rdxr_definition_lexical_nesting(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    VALUE nesting = rb_ary_new();
+    uint64_t definition_id = data->id;
+
+    while (true) {
+        const uint64_t *owner_id = rdx_definition_lexical_nesting_id(graph, definition_id);
+        if (owner_id == NULL) {
+            break;
+        }
+
+        rb_ary_push(nesting, rdxi_build_definition(data->graph_obj, graph, *owner_id));
+        definition_id = *owner_id;
+        free_u64(owner_id);
+    }
+
+    return nesting;
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -287,6 +341,36 @@ static VALUE rdxr_method_alias_definition_signatures(VALUE self) {
     return rdxi_signatures_to_ruby(arr);
 }
 
+// MethodAliasDefinition#target -> Rubydex::Method?
+// Returns the resolved target method declaration by following the alias chain, or nil if the chain could not be
+// resolved (the target name doesn't exist on the owner, or the owner itself never resolved). Raises
+// Rubydex::AliasCycleError when the alias chain forms a cycle.
+static VALUE rdxr_method_alias_definition_target(VALUE self) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+
+    CMethodAliasTargetResult result = rdx_method_alias_definition_target(graph, data->id);
+
+    switch (result.status) {
+    case CMethodAliasResolution_Resolved: {
+        VALUE decl_class = rdxi_declaration_class_for_kind(result.declaration->kind);
+        VALUE argv[] = {data->graph_obj, ULL2NUM(result.declaration->id)};
+
+        free_c_declaration(result.declaration);
+        return rb_class_new_instance(2, argv, decl_class);
+    }
+    case CMethodAliasResolution_NotFound:
+        return Qnil;
+    case CMethodAliasResolution_Cycle:
+        rb_raise(rb_const_get(mRubydex, rb_intern("AliasCycleError")), "method alias chain forms a cycle");
+    default:
+        rb_raise(rb_eRuntimeError, "Unknown CMethodAliasResolution: %d", result.status);
+    }
+}
+
 void rdxi_initialize_definition(VALUE mod) {
     mRubydex = mod;
 
@@ -306,6 +390,8 @@ void rdxi_initialize_definition(VALUE mod) {
     rb_define_method(cDefinition, "deprecated?", rdxr_definition_deprecated, 0);
     rb_define_method(cDefinition, "name_location", rdxr_definition_name_location, 0);
     rb_define_method(cDefinition, "declaration", rdxr_definition_declaration, 0);
+    rb_define_method(cDefinition, "lexical_owner", rdxr_definition_lexical_owner, 0);
+    rb_define_method(cDefinition, "lexical_nesting", rdxr_definition_lexical_nesting, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);
@@ -331,5 +417,6 @@ void rdxi_initialize_definition(VALUE mod) {
     cClassVariableDefinition = rb_define_class_under(mRubydex, "ClassVariableDefinition", cDefinition);
     cMethodAliasDefinition = rb_define_class_under(mRubydex, "MethodAliasDefinition", cDefinition);
     rb_define_method(cMethodAliasDefinition, "signatures", rdxr_method_alias_definition_signatures, 0);
+    rb_define_method(cMethodAliasDefinition, "target", rdxr_method_alias_definition_target, 0);
     cGlobalVariableAliasDefinition = rb_define_class_under(mRubydex, "GlobalVariableAliasDefinition", cDefinition);
 }

data/ext/rubydex/document.c

@@ -3,6 +3,7 @@
 #include "graph.h"
 #include "handle.h"
 #include "rustbindings.h"
+#include "utils.h"
 
 VALUE cDocument;
 
@@ -85,6 +86,40 @@ static VALUE rdxr_document_definitions(VALUE self) {
     return self;
 }
 
+// Size function for the Document#method_references enumerator
+static VALUE document_method_references_size(VALUE self, VALUE _args, VALUE _eobj) {
+    HandleData *data;
+    TypedData_Get_Struct(self, HandleData, &handle_type, data);
+
+    void *graph;
+    TypedData_Get_Struct(data->graph_obj, void *, &graph_type, graph);
+    struct MethodReferencesIter *iter = rdx_document_method_references_iter_new(graph, data->id);
+    size_t len = rdx_method_references_iter_len(iter);
+    rdx_method_references_iter_free(iter);
+
+    return SIZET2NUM(len);
+}
+
+// Document#method_references: () -> Enumerator[MethodReference]
+// Returns an enumerator that yields all method references for this document lazily
+static VALUE rdxr_document_method_references(VALUE self) {
+    if (!rb_block_given_p()) {
+        return rb_enumeratorize_with_size(self, rb_str_new2("method_references"), 0, NULL,
+                                          document_method_references_size);
+    }
+
+    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_document_method_references_iter_new(graph, data->id);
+    VALUE args = rb_ary_new_from_args(2, data->graph_obj, ULL2NUM((uintptr_t)iter));
+    rb_ensure(rdxi_method_references_yield, args, rdxi_method_references_ensure, args);
+
+    return self;
+}
+
 void rdxi_initialize_document(VALUE mRubydex) {
     cDocument = rb_define_class_under(mRubydex, "Document", rb_cObject);
 
@@ -92,6 +127,7 @@ void rdxi_initialize_document(VALUE mRubydex) {
     rb_define_method(cDocument, "initialize", rdxr_handle_initialize, 2);
     rb_define_method(cDocument, "uri", rdxr_document_uri, 0);
     rb_define_method(cDocument, "definitions", rdxr_document_definitions, 0);
+    rb_define_method(cDocument, "method_references", rdxr_document_method_references, 0);
 
     rb_funcall(rb_singleton_class(cDocument), rb_intern("private"), 1, ID2SYM(rb_intern("new")));
 }

data/ext/rubydex/extconf.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "mkmf"
+require "fileutils"
 require "pathname"
 
 unless system("cargo", "--version", out: File::NULL, err: File::NULL)
@@ -81,6 +82,12 @@ else
 end
 
 lib_dir = gem_dir.join("lib").join("rubydex")
+mcp_bin_dir = lib_dir.join("bin")
+FileUtils.mkdir_p(mcp_bin_dir)
+
+mcp_executable = Gem.win_platform? ? "rubydex_mcp.exe" : "rubydex_mcp"
+mcp_src = target_dir.join(mcp_executable)
+mcp_dst = mcp_bin_dir.join(mcp_executable)
 
 copy_dylib_commands = if Gem.win_platform?
   ""
@@ -107,6 +114,7 @@ new_makefile = makefile.gsub("$(OBJS): $(HDRS) $(ruby_headers)", <<~MAKEFILE.cho
   .rust_built: $(RUST_SRCS)
   \t#{cargo_command} || (echo "Compiling Rust failed" && exit 1)
   \t$(COPY) #{bindings_path} #{__dir__}
+  \t$(COPY) #{mcp_src} #{mcp_dst}
   \ttouch $@
 
   compile_rust: .rust_built

data/ext/rubydex/graph.c

@@ -16,17 +16,20 @@ static VALUE cKeywordParameter;
 // Interned once in `rdxi_initialize_graph` to avoid repeated symbol-table lookups on hot completion paths.
 static ID id_self_receiver;
 
-// Extracts the optional `self_receiver:` kwarg from `opts`. Returns NULL when the kwarg is
-// absent or nil; raises ArgumentError when the value is the wrong type or empty.
+// Extracts the required `self_receiver:` kwarg from `opts`. Returns NULL when the value is `nil`,
+// which means "no self-type to walk" (e.g., empty class body where the singleton class hasn't
+// been created). Raises ArgumentError if the kwarg is absent, of the wrong type, or an empty
+// string. The kwarg is required so that callers commit to a self type — there is no implicit
+// default.
 static const char *extract_self_receiver(VALUE opts) {
     if (NIL_P(opts)) {
-        return NULL;
+        rb_raise(rb_eArgError, "missing keyword: self_receiver");
     }
 
     VALUE kwarg_val;
-    rb_get_kwargs(opts, &id_self_receiver, 0, 1, &kwarg_val);
+    rb_get_kwargs(opts, &id_self_receiver, 1, 0, &kwarg_val);
 
-    if (kwarg_val == Qundef || NIL_P(kwarg_val)) {
+    if (NIL_P(kwarg_val)) {
         return NULL;
     }
 
@@ -45,7 +48,18 @@ static void graph_free(void *ptr) {
     }
 }
 
-const rb_data_type_t graph_type = {"Graph", {0, graph_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+const rb_data_type_t graph_type = {
+    .wrap_struct_name = "Graph",
+    .function = {
+        .dmark = NULL,
+        .dfree = graph_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 // Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
 // as a void pointer
@@ -589,11 +603,10 @@ static VALUE completion_result_to_ruby_array(struct CompletionResult result, VAL
     return ruby_array;
 }
 
-// Graph#complete_expression: (Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword]
+// Graph#complete_expression: (Array[String] nesting, self_receiver:) -> Array[Declaration | Keyword]
 // Returns completion candidates for an expression context.
-// The nesting array represents the lexical scope stack. The optional self_receiver keyword argument
-// overrides the self-type (e.g., "Foo::<Foo>" for `def Foo.bar`); when nil, self is derived from
-// the innermost nesting element.
+// The nesting array represents the lexical scope stack. The required self_receiver keyword argument overrides the
+// self-type (e.g., "Foo::<Foo>" for `def Foo.bar`); when nil, self is derived from the innermost nesting element.
 static VALUE rdxr_graph_complete_expression(int argc, VALUE *argv, VALUE self) {
     VALUE nesting, opts;
     rb_scan_args(argc, argv, "1:", &nesting, &opts);
@@ -614,10 +627,11 @@ static VALUE rdxr_graph_complete_expression(int argc, VALUE *argv, VALUE self) {
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_namespace_access: (String name, self_receiver: nil) -> Array[Declaration]
+// Graph#complete_namespace_access: (String name, self_receiver:) -> Array[Declaration]
 // Returns completion candidates after a namespace access operator (e.g., `Foo::`).
-// The optional self_receiver kwarg is the caller's runtime self type, used to filter
-// visibility-restricted singleton methods (e.g., `private_class_method`).
+// The required self_receiver kwarg is the caller's runtime self type, used to filter
+// visibility-restricted singleton methods (e.g., `private_class_method`). Pass `nil` when there
+// is no caller context.
 static VALUE rdxr_graph_complete_namespace_access(int argc, VALUE *argv, VALUE self) {
     VALUE name, opts;
     rb_scan_args(argc, argv, "1:", &name, &opts);
@@ -633,10 +647,10 @@ static VALUE rdxr_graph_complete_namespace_access(int argc, VALUE *argv, VALUE s
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_call: (String name, self_receiver: nil) -> Array[Declaration]
+// Graph#complete_method_call: (String name, self_receiver:) -> Array[Declaration]
 // Returns completion candidates after a method call operator (e.g., `foo.`).
-// The optional self_receiver kwarg is the caller's runtime self type, used for MRI-style
-// visibility checks (private/protected).
+// The required self_receiver kwarg is the caller's runtime self type, used for visibility checks (private/protected).
+// Pass `nil` when there is no caller context.
 static VALUE rdxr_graph_complete_method_call(int argc, VALUE *argv, VALUE self) {
     VALUE name, opts;
     rb_scan_args(argc, argv, "1:", &name, &opts);
@@ -652,9 +666,9 @@ static VALUE rdxr_graph_complete_method_call(int argc, VALUE *argv, VALUE self)
     return completion_result_to_ruby_array(result, self);
 }
 
-// Graph#complete_method_argument: (String name, Array[String] nesting, self_receiver: nil) -> Array[Declaration | Keyword | KeywordParameter]
+// Graph#complete_method_argument: (String name, Array[String] nesting, self_receiver:) -> Array[Declaration | Keyword | KeywordParameter]
 // Returns completion candidates inside a method call's argument list (e.g., `foo.bar(|)`).
-// See complete_expression for semantics of self_receiver.
+// See complete_expression for semantics of self_receiver (required, may be nil).
 static VALUE rdxr_graph_complete_method_argument(int argc, VALUE *argv, VALUE self) {
     VALUE name, nesting, opts;
     rb_scan_args(argc, argv, "2:", &name, &nesting, &opts);

data/ext/rubydex/handle.h

@@ -22,12 +22,25 @@ static void handle_free(void *ptr) {
 }
 
 static const rb_data_type_t handle_type = {
-    "RubydexHandle", {handle_mark, handle_free, 0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY};
+    .wrap_struct_name = "RubydexHandle",
+    .function = {
+        .dmark = handle_mark,
+        .dfree = handle_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
 
 static VALUE rdxr_handle_alloc(VALUE klass) {
     HandleData *data = ALLOC(HandleData);
-    data->graph_obj = Qnil;
-    data->id = 0;
+
+    *data = (HandleData) {
+        .graph_obj = Qnil,
+        .id = 0,
+    };
 
     return TypedData_Wrap_Struct(klass, &handle_type, data);
 }
@@ -35,8 +48,11 @@ static VALUE rdxr_handle_alloc(VALUE klass) {
 static VALUE rdxr_handle_initialize(VALUE self, VALUE graph_obj, VALUE id_val) {
     HandleData *data;
     TypedData_Get_Struct(self, HandleData, &handle_type, data);
-    data->graph_obj = graph_obj;
-    data->id = NUM2ULL(id_val);
+
+    *data = (HandleData) {
+        .graph_obj = graph_obj,
+        .id = NUM2ULL(id_val),
+    };
 
     return self;
 }

data/lib/rubydex/declaration.rb

@@ -21,9 +21,9 @@ module Rubydex
   end
 
   class Namespace < Declaration
-    #: (String ancestor_name) -> bool
-    def has_ancestor?(ancestor_name)
-      ancestors.any? { |ancestor| ancestor.name == ancestor_name }
+    #: (*String ancestor_names) -> bool
+    def has_ancestor?(*ancestor_names)
+      ancestors.any? { |ancestor| ancestor_names.include?(ancestor.name) }
     end
   end
 

data/lib/rubydex/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rubydex
+  class Error < StandardError; end
+
+  # Raised when `MethodAliasDefinition#target` walks an alias chain that loops back on itself.
+  class AliasCycleError < Error; end
+end

data/lib/rubydex/graph.rb

@@ -17,6 +17,8 @@ module Rubydex
       "tmp",
     ].freeze
 
+    INDEXABLE_EXTENSIONS = [".rb", ".rake", ".rbs", ".ru"].freeze
+
     #: String
     attr_accessor :workspace_path
 
@@ -45,7 +47,7 @@ module Rubydex
 
         if File.directory?(full_path)
           paths << full_path unless IGNORED_DIRECTORIES.include?(entry)
-        elsif File.extname(entry) == ".rb"
+        elsif INDEXABLE_EXTENSIONS.include?(File.extname(entry))
           paths << full_path
         end
       end

data/lib/rubydex/location.rb

@@ -14,6 +14,19 @@ module Rubydex
     #: Integer
     attr_reader :start_line, :end_line, :start_column, :end_column
 
+    class << self
+      #: (Prism::Location prism_location, uri: String) -> Location
+      def from_prism(prism_location, uri:)
+        Location.new(
+          uri: uri,
+          start_line: prism_location.start_line - 1,
+          start_column: prism_location.start_column,
+          end_line: prism_location.end_line - 1,
+          end_column: prism_location.end_column,
+        )
+      end
+    end
+
     #: (?uri: String, ?start_line: Integer, ?end_line: Integer, ?start_column: Integer, ?end_column: Integer) -> void
     def initialize(uri:, start_line:, end_line:, start_column:, end_column:)
       @uri = uri
@@ -68,6 +81,17 @@ module Rubydex
   # A one based location intended for display purposes. This is what should be used when displaying a location to users,
   # like in CLIs
   class DisplayLocation < Location
+    class << self
+      #: (Prism::Location prism_location, uri: String) -> Location
+      def from_prism(prism_location, uri:)
+        raise NotImplementedError, <<~MESSAGE
+          Cannot convert Prism::Location directly to a Rubydex::DisplayLocation.
+          Start with `Rubydex::Location.from_prism(...)` and then convert the resulting
+          location with `to_display`
+        MESSAGE
+      end
+    end
+
     # Returns itself
     #
     #: () -> DisplayLocation

data/lib/rubydex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rubydex
-  VERSION = "0.2.4"
+  VERSION = "0.2.6"
 end

data/lib/rubydex.rb

@@ -14,6 +14,7 @@ rescue LoadError
   require "rubydex/rubydex"
 end
 
+require "rubydex/errors"
 require "rubydex/failures"
 require "rubydex/location"
 require "rubydex/comment"