rubydex 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73a4ef87ec062ac40a438143ac91edf1388543ff336a45bc875582886dc5259b
-  data.tar.gz: 5ba4364ae655fe44edd6897e6c53d95aaff4b970316076f9b538dbd52a6c936b
+  metadata.gz: cf823835a70dee735f2dc0e898eb1d47be47e4ab635a6be4de5677ceaf6bbe53
+  data.tar.gz: 663389c429d729bf8d9191f54b7eafe92b8ecb8e0c0a32e5b3f6adba3365f3fa
 SHA512:
-  metadata.gz: c4575cfb038c95e6e86460f5dd832a79224428e05d7f39b9431b50ec4c10029e719862be06acf4fc974a15e210a6a6272de1e5d1193aeb4a0e5a390e7c48d5af
-  data.tar.gz: d44dce9ff4da7f9332ce1c340087a87fc2655c3bc35ba33f76ad78fbe13774973b99c287aca0b92a65492b77b5b7425147144b1edbd0708f6047c19859ef71a7
+  metadata.gz: aa17ed0f03e392c4ad1a2bf256d3472057d7a78a2baca596bb72f80c06d1fe36d7fa80878ddfabe740ca0b8d23f961d01afe9ab0211219e2f41b36b4587b819d
+  data.tar.gz: 86d70527d4bcee2b8e90bbebb33912e1f5a6bf1f7fe9ce6e1435e7fff918829ae2a8de692072ab34fca42a199f5cfce5a12e18f77b6f08d5b8ca274c3e8f83f4

data/README.md

@@ -3,6 +3,8 @@
 This project is a high-performance static analysis toolkit for the Ruby language. The goal is to be a solid
 foundation to power a variety of tools, such as type checkers, linters, language servers and more.
 
+[Ruby API Documentation](https://shopify.github.io/rubydex/)
+
 ## Usage
 
 Both Ruby and Rust APIs are made available through a gem and a crate, respectively. Here's a simple example
@@ -77,6 +79,70 @@ diagnostic.message
 diagnostic.location
 ```
 
+## Ractor Safety
+
+A resolved `Rubydex::Graph` can be shared across Ractors without copying:
+
+```ruby
+graph = Rubydex::Graph.new
+graph.index_workspace
+graph.resolve
+Ractor.make_shareable(graph)
+
+# Worker Ractors can now read the graph in parallel
+ractor = Ractor.new(graph) { |g| g["Foo"]&.name }
+ractor.value
+```
+
+Thread safety comes from an `RwLock` on the Rust side, **not** from Ruby's
+`freeze`. This is a deliberate, but potentially surprising, choice:
+
+- A frozen (or `make_shareable`'d) graph **can still be mutated** — methods like
+  `index_source`, `resolve`, `exclude_patterns`, and `encoding=` work on a frozen
+  graph. This supports interactive use cases (LSP/MCP) that need incremental
+  edits while worker Ractors read concurrently.
+- Because the same underlying allocation is shared, callers are responsible for
+  ordering concurrent writes and reads, as with any shared mutable state across
+  Ractors.
+- Graphs cannot be `dup`'d or `clone`'d; both raise `RuntimeError` to avoid
+  aliasing the Rust allocation (which would double-free on GC) or ballooning
+  memory with a deep copy.
+
+## Querying with Cypher
+
+Rubydex exposes the indexed graph through a read-only subset of the
+[Cypher](https://opencypher.org/) query language. Only read clauses (`MATCH`,
+`WHERE`, `RETURN`, ...) are supported; there is no way to mutate the graph.
+
+From the command line:
+
+```bash
+# Run a query against the current workspace
+bundle exec rdx query "MATCH (c:Class)-[:DEFINES]->(m:Method) RETURN c.name, m.name"
+
+# Render results as JSON instead of a table
+bundle exec rdx query "MATCH (c:Class) RETURN c.name" --format json
+
+# Describe the queryable schema (node labels and relationship types) without indexing
+bundle exec rdx query --schema
+```
+
+From Ruby:
+
+```ruby
+graph = Rubydex::Graph.new
+graph.index_workspace
+graph.resolve
+
+# Parse once, render against a graph as a table or JSON string
+query = Rubydex::Query.parse("MATCH (c:Class) RETURN c.name")
+puts query.render(graph, "table")
+puts query.render(graph, "json")
+
+# Describe the schema
+puts Rubydex::Query.schema("table")
+```
+
 ## MCP Server (Experimental)
 
 Rubydex can run as an MCP (Model Context Protocol) server, enabling AI assistants
@@ -94,16 +160,16 @@ like Claude to semantically query your Ruby codebase.
    bundle install
    ```
 
-3. Configure your MCP client to run `bundle exec rdx --mcp`.
+3. Configure your MCP client to run `bundle exec rdx mcp`.
 
    Using Claude Code as an example:
    ```bash
-   claude mcp add --scope project rubydex -- bundle exec rdx --mcp
+   claude mcp add --scope project rubydex -- bundle exec rdx mcp
    ```
 
    Using Codex as an example:
    ```bash
-   codex mcp add rubydex -- bundle exec rdx --mcp
+   codex mcp add rubydex -- bundle exec rdx mcp
    ```
 
    Start your MCP client from that project directory. The MCP server indexes

data/THIRD_PARTY_LICENSES.html

@@ -52,7 +52,7 @@
         <ul class="licenses-overview">
             <li><a href="#Apache-2.0">Apache License 2.0</a> (116)</li>
             <li><a href="#Unicode-3.0">Unicode License v3</a> (19)</li>
-            <li><a href="#MIT">MIT License</a> (16)</li>
+            <li><a href="#MIT">MIT License</a> (17)</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>
@@ -2802,6 +2802,39 @@ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
+</pre>
+            </li>
+            <li class="license">
+                <h3 id="MIT">MIT License</h3>
+                <h4>Used by:</h4>
+                <ul class="license-used-by">
+                    <li><a
+                            href=" https://github.com/Shopify/cypher-parser ">cypher-parser
+                            0.2.0</a></li>
+                </ul>
+                <pre class="license-text">The MIT License (MIT)
+
+Copyright (c) 2025-present, Shopify Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the &quot;Software&quot;), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+See the generated THIRD_PARTY_LICENSES.html file for third party licenses.
 </pre>
             </li>
             <li class="license">

data/exe/rdx

@@ -5,75 +5,151 @@ $LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
 
 require "optparse"
 
-options = {}
+USAGE = <<~TEXT
+  Usage: rdx <command> [options]
 
-option_parser = OptionParser.new do |parser|
-  parser.on("--version", "Print the gem's version") do
+  Commands:
+    query <CYPHER>   Run a Cypher query against the workspace graph and print the result.
+                     Use `query --schema` to describe the queryable schema (labels,
+                     relationships, properties) without indexing the workspace.
+    console          Open an interactive session with a populated graph for the current workspace
+    mcp [PATH]       Run the MCP server for AI assistants (workspace defaults to the current dir)
+    help             Show this help message
+
+  Run `rdx <command> --help` for command-specific options.
+TEXT
+
+def abort_with_usage(message)
+  warn(message)
+  warn("")
+  warn(USAGE)
+  exit(1)
+end
+
+# Top-level --version / --help / bare invocation, handled before command dispatch. Each branch
+# performs its action and reports whether it handled the invocation, so we exit exactly once here
+# rather than from inside every branch.
+handled =
+  case ARGV.first
+  when "--version", "version"
     require "rubydex/version"
     puts "v#{Rubydex::VERSION}"
-    exit
+    true
+  when nil, "-h", "--help", "help"
+    puts USAGE
+    true
+  else
+    false
   end
 
-  parser.on("-h", "--help", "Prints this help") do
-    puts parser
-    exit
-  end
+exit if handled
 
-  parser.on("-i", "--interactive", "Open an interactive session with a populated graph for the current workspace") do
-    options[:interactive] = true
-  end
+command = ARGV.shift
 
-  parser.on("--mcp", "Run the MCP server for AI assistants") do
-    options[:mcp] = true
-  end
+def with_timer(io, message)
+  io.print(message)
+  start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond)
+  yield
+  duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_millisecond) - start
+  io.puts(" finished in #{duration.round(2)}ms")
 end
 
-begin
-  arguments = option_parser.parse(ARGV)
-rescue OptionParser::ParseError => e
-  warn("error: #{e.message}")
-  warn
-  warn(option_parser)
-  exit(2)
+# Builds the workspace graph, sending progress messages to `progress_io`.
+def build_graph(progress_io)
+  graph = Rubydex::Graph.new
+  graph.load_config
+  with_timer(progress_io, "Indexing workspace...") { graph.index_workspace }
+  with_timer(progress_io, "Resolving graph...") { graph.resolve }
+  graph
 end
 
 require "rubydex"
 
-if options[:mcp]
-  if arguments.length > 1
-    warn("error: unexpected argument '#{arguments[1]}' found")
-    warn
-    warn(option_parser)
-    exit(2)
-  end
+# Resolve the command into an operation on a populated graph. Each command parses its own options
+# and does any graph-independent work here; a command that needs no graph (like `query --schema`)
+# handles itself and exits. Whatever falls through returns a lambda that runs against the graph.
+operation =
+  case command
+  when "query"
+    schema = false
+    format = "table"
+    OptionParser.new do |parser|
+      parser.banner = "Usage: rdx query <CYPHER> [options]"
+      parser.on("--schema", "Describe the queryable schema instead of running a query") { schema = true }
+      parser.on("--format FORMAT", ["table", "json"], "Output format (table or json)") { |value| format = value }
+      parser.on("-h", "--help", "Show this help") do
+        puts parser
+        exit
+      end
+    end.parse!
 
-  require "rubydex/mcp_server"
-  Rubydex::MCPServer.run(arguments.fetch(0, Dir.pwd))
-  exit
-end
+    query = ARGV.shift
 
-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
+    if schema
+      warn("warning: ignoring query argument because `--schema` was given") if query
+      # The schema is static, so describe it without building a graph, then exit.
+      print(Rubydex::Query.schema(format))
+      exit
+    end
+
+    abort_with_usage("`query` requires a Cypher query argument (or pass `--schema`)") if query.nil? || query.empty?
+
+    # Parse the query up front so a malformed query fails fast, before the expensive indexing below.
+    parsed = begin
+      Rubydex::Query.parse(query)
+    rescue ArgumentError => e
+      abort(e.message)
+    end
 
-graph = Rubydex::Graph.new
-graph.load_config
-
-__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")
+    lambda do |graph|
+      print(parsed.render(graph, format))
+    rescue ArgumentError => e
+      abort(e.message)
+    end
+  when "console"
+    OptionParser.new do |parser|
+      parser.banner = "Usage: rdx console"
+      parser.on("-h", "--help", "Show this help") do
+        puts parser
+        exit
+      end
+    end.parse!
+
+    lambda do |graph|
+      require "irb"
+      IRB.setup(nil)
+      IRB.conf[:IRB_NAME] = "rubydex"
+      IRB::Irb.new(IRB::WorkSpace.new(binding)).run(IRB.conf)
+    rescue LoadError
+      abort("Interactive mode requires `irb` to be in the bundle")
+    end
+  when "mcp"
+    parser = OptionParser.new do |p|
+      p.banner = "Usage: rdx mcp [PATH]"
+      p.on("-h", "--help", "Show this help") do
+        puts p
+        exit
+      end
+    end
+    begin
+      parser.parse!
+    rescue OptionParser::ParseError => e
+      abort_with_usage(e.message)
+    end
+
+    path = ARGV.shift || Dir.pwd
+    abort_with_usage("unexpected argument: #{ARGV.first}") unless ARGV.empty?
+
+    # The MCP server manages its own graph lifecycle for the given workspace, so it runs here
+    # instead of falling through to the shared graph build below.
+    require "rubydex/mcp_server"
+    Rubydex::MCPServer.run(path)
+    exit
+  else
+    abort_with_usage("unknown command: #{command}")
   end
-end
+
+# Everything that reaches here operates on a populated graph. Progress goes to stderr so stdout
+# carries only the command's output (e.g. for piping a query's JSON).
+graph = build_graph($stderr)
+operation.call(graph)

data/ext/rubydex/declaration.c

@@ -236,7 +236,7 @@ static VALUE rdxr_declaration_owner(VALUE self) {
     const CDeclaration *decl = rdx_declaration_owner(graph, data->id);
 
     if (decl == NULL) {
-        rb_raise(rb_eRuntimeError, "owner can never be nil for any declarations");
+        rb_raise(rb_eRuntimeError, "Declaration must exist for a valid id");
     }
 
     VALUE decl_class = rdxi_declaration_class_for_kind(decl->kind);

data/ext/rubydex/definition.c

@@ -18,6 +18,7 @@ static VALUE mRubydex;
 static VALUE cInclude;
 static VALUE cPrepend;
 static VALUE cExtend;
+static VALUE cDocument;
 VALUE cComment;
 VALUE cDefinition;
 VALUE cClassDefinition;
@@ -88,6 +89,9 @@ static VALUE rdxr_definition_location(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     Location *loc = rdx_definition_location(graph, data->id);
+    if (loc == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition must exist for a valid id");
+    }
     VALUE location = rdxi_build_location_value(loc);
     rdx_location_free(loc);
 
@@ -105,10 +109,11 @@ static VALUE rdxr_definition_comments(VALUE self) {
     void *graph = rdxi_graph_from_handle(self, &data);
 
     CommentArray *arr = rdx_definition_comments(graph, data->id);
-    if (arr == NULL || arr->len == 0) {
-        if (arr != NULL) {
-            rdx_definition_comments_free(arr);
-        }
+    if (arr == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition must exist for a valid id");
+    }
+    if (arr->len == 0) {
+        rdx_definition_comments_free(arr);
         return rb_ary_new();
     }
 
@@ -261,6 +266,27 @@ static VALUE rdxr_definition_lexical_nesting(VALUE self) {
     return nesting;
 }
 
+/*
+ * call-seq:
+ *   document -> Rubydex::Document
+ *
+ * Returns the document this definition belongs to.
+ */
+static VALUE rdxr_definition_document(VALUE self) {
+    HandleData *data;
+    void *graph = rdxi_graph_from_handle(self, &data);
+
+    const uint64_t *uri_id = rdx_definition_document(graph, data->id);
+    if (uri_id == NULL) {
+        rb_raise(rb_eRuntimeError, "Definition not found");
+    }
+
+    VALUE argv[] = {data->graph_obj, ULL2NUM(*uri_id)};
+    free_u64(uri_id);
+
+    return rb_class_new_instance(2, argv, cDocument);
+}
+
 static VALUE rdxi_build_constant_reference(VALUE graph_obj, const CConstantReference *cref) {
     VALUE ref_class = (cref->declaration_id == 0)
         ? cUnresolvedConstantReference
@@ -397,6 +423,7 @@ void rdxi_initialize_definition(VALUE mod) {
     cInclude = rb_const_get(mRubydex, rb_intern("Include"));
     cPrepend = rb_const_get(mRubydex, rb_intern("Prepend"));
     cExtend = rb_const_get(mRubydex, rb_intern("Extend"));
+    cDocument = rb_const_get(mRubydex, rb_intern("Document"));
 
     cComment = rb_define_class_under(mRubydex, "Comment", rb_cObject);
 
@@ -412,6 +439,7 @@ void rdxi_initialize_definition(VALUE mod) {
     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);
+    rb_define_method(cDefinition, "document", rdxr_definition_document, 0);
 
     cClassDefinition = rb_define_class_under(mRubydex, "ClassDefinition", cDefinition);
     rb_define_method(cClassDefinition, "superclass", rdxr_class_definition_superclass, 0);

data/ext/rubydex/graph.c

@@ -63,16 +63,25 @@ const rb_data_type_t graph_type = {
     },
     .parent = NULL,
     .data = NULL,
-    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_FROZEN_SHAREABLE,
 };
 
-// Custom allocator for the Graph class. Calls into Rust to create a new `Arc<Mutex<Graph>>` that gets stored internally
-// as a void pointer
+// Custom allocator for the Graph class. Calls into Rust to create a new Box<RwLock<Graph>> that gets stored
+// internally as an opaque void pointer. The RwLock provides thread-safe concurrent access across Ractors.
 static VALUE rdxr_graph_alloc(VALUE klass) {
     void *graph = rdx_graph_new();
     return TypedData_Wrap_Struct(klass, &graph_type, graph);
 }
 
+// Graph is intentionally non-copyable. A dup/clone of the TypedData wrapper would alias the
+// same underlying Rust allocation (double-free on GC) or, if deep-copied, balloon memory use.
+// Block both paths: `dup` dispatches to `initialize_copy`, `clone` to `initialize_clone`.
+static VALUE rdxr_graph_initialize_copy(VALUE self, VALUE other) {
+    (void)self;
+    (void)other;
+    rb_raise(rb_eRuntimeError, "Rubydex::Graph cannot be duplicated or cloned");
+}
+
 /*
  * call-seq:
  *   index_all(file_paths) -> Array[String]
@@ -943,6 +952,8 @@ void rdxi_initialize_graph(VALUE moduleRubydex) {
     id_self_receiver = rb_intern("self_receiver");
 
     rb_define_alloc_func(cGraph, rdxr_graph_alloc);
+    rb_define_method(cGraph, "initialize_copy", rdxr_graph_initialize_copy, 1);
+    rb_define_method(cGraph, "initialize_clone", rdxr_graph_initialize_copy, 1);
     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);

data/ext/rubydex/query.c

@@ -0,0 +1,105 @@
+#include "query.h"
+#include "graph.h"
+#include "rustbindings.h"
+#include "utils.h"
+
+/*
+ * call-seq:
+ *   Rubydex::Query.schema(format = :table) -> String
+ *
+ * Returns a description of the queryable Cypher schema. +format+ may be +:table+ (default) or
+ * +:json+. The schema is static, so it does not require a graph.
+ */
+static VALUE rdxr_cypher_schema(int argc, VALUE *argv, VALUE self) {
+    VALUE format;
+    rb_scan_args(argc, argv, "01", &format);
+
+    const char *output = rdx_cypher_schema(rdxi_symbol_or_string_cstr(format, "table"));
+    VALUE result = output == NULL ? rb_utf8_str_new_cstr("") : rb_utf8_str_new_cstr(output);
+    if (output != NULL) {
+        free_c_string(output);
+    }
+
+    return result;
+}
+
+// Free function for Rubydex::Query: releases the parsed query allocated by Rust.
+static void query_free(void *ptr) {
+    if (ptr) {
+        rdx_cypher_query_free(ptr);
+    }
+}
+
+static const rb_data_type_t query_type = {
+    .wrap_struct_name = "Rubydex::Query",
+    .function = {
+        .dmark = NULL,
+        .dfree = query_free,
+        .dsize = NULL,
+        .dcompact = NULL,
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+/*
+ * call-seq:
+ *   Rubydex::Query.parse(query) -> Rubydex::Query
+ *
+ * Parses a Cypher query into an opaque, reusable object without needing a graph. Raises
+ * ArgumentError on a syntax error, so a query can be validated before building a graph.
+ */
+static VALUE rdxr_query_parse(VALUE klass, VALUE query) {
+    Check_Type(query, T_STRING);
+
+    struct CParseResult result = rdx_cypher_parse(StringValueCStr(query));
+    if (result.error != NULL) {
+        VALUE message = rb_utf8_str_new_cstr(result.error);
+        free_c_string(result.error);
+        rb_raise(rb_eArgError, "%s", StringValueCStr(message));
+    }
+
+    return TypedData_Wrap_Struct(klass, &query_type, result.query);
+}
+
+/*
+ * call-seq:
+ *   render(graph, format = :table) -> String
+ *
+ * Runs this parsed query against +graph+ and returns the formatted output. +format+ may be
+ * +:table+ (default) or +:json+. Raises ArgumentError on an execution or format error.
+ */
+static VALUE rdxr_query_render(int argc, VALUE *argv, VALUE self) {
+    VALUE graph_obj, format;
+    rb_scan_args(argc, argv, "11", &graph_obj, &format);
+
+    void *query;
+    TypedData_Get_Struct(self, void *, &query_type, query);
+
+    void *graph;
+    TypedData_Get_Struct(graph_obj, void *, &graph_type, graph);
+
+    struct CQueryResult result = rdx_query_run(query, graph, rdxi_symbol_or_string_cstr(format, "table"));
+
+    if (result.error != NULL) {
+        VALUE message = rb_utf8_str_new_cstr(result.error);
+        free_c_string(result.error);
+        rb_raise(rb_eArgError, "%s", StringValueCStr(message));
+    }
+
+    VALUE output = result.output == NULL ? rb_utf8_str_new_cstr("") : rb_utf8_str_new_cstr(result.output);
+    if (result.output != NULL) {
+        free_c_string(result.output);
+    }
+
+    return output;
+}
+
+void rdxi_initialize_query(VALUE mRubydex) {
+    VALUE cQuery = rb_define_class_under(mRubydex, "Query", rb_cObject);
+    rb_undef_alloc_func(cQuery);
+    rb_define_singleton_method(cQuery, "parse", rdxr_query_parse, 1);
+    rb_define_singleton_method(cQuery, "schema", rdxr_cypher_schema, -1);
+    rb_define_method(cQuery, "render", rdxr_query_render, -1);
+}

data/ext/rubydex/query.h

@@ -0,0 +1,8 @@
+#ifndef RUBYDEX_QUERY_H
+#define RUBYDEX_QUERY_H
+
+#include "ruby.h"
+
+void rdxi_initialize_query(VALUE mRubydex);
+
+#endif // RUBYDEX_QUERY_H