ruby_tree_sitter 1.6.0-arm-linux-gnu

data/ext/tree_sitter/query.c

@@ -0,0 +1,289 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQuery;
+
+DATA_PTR_WRAP(Query, query);
+
+/**
+ * Get the number of captures literals in the query.
+ *
+ * @return [Integer]
+ */
+static VALUE query_capture_count(VALUE self) {
+  return UINT2NUM(ts_query_capture_count(SELF));
+}
+
+/**
+ * Get the name and length of one of the query's captures, or one of the
+ * query's string literals. Each capture and string is associated with a
+ * numeric id based on the order that it appeared in the query's source.
+ *
+ * @raise [IndexError] if out of range.
+ *
+ * @param index [Integer]
+ *
+ * @return [String]
+ */
+static VALUE query_capture_name_for_id(VALUE self, VALUE index) {
+  const TSQuery *query = SELF;
+  uint32_t idx = NUM2UINT(index);
+  uint32_t range = ts_query_capture_count(query);
+
+  if (idx >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", idx, range);
+  } else {
+    uint32_t length;
+    const char *name = ts_query_capture_name_for_id(query, idx, &length);
+    return safe_str2(name, length);
+  }
+}
+
+/**
+ * Get the quantifier of the query's captures. Each capture is associated
+ * with a numeric id based on the order that it appeared in the query's source.
+ *
+ * @raise [IndexError] if out of range.
+ *
+ * @param query_idx   [Integer]
+ * @param capture_idx [Integer]
+ *
+ * @return [Integer]
+ */
+static VALUE query_capture_quantifier_for_id(VALUE self, VALUE query_idx,
+                                             VALUE capture_idx) {
+  const TSQuery *query = SELF;
+  uint32_t pattern = NUM2UINT(query_idx);
+  uint32_t index = NUM2UINT(capture_idx);
+  uint32_t range = ts_query_capture_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Capture ID %d out of range (len = %d)", index,
+             range);
+  } else {
+    return UINT2NUM(ts_query_capture_quantifier_for_id(query, pattern, index));
+  }
+}
+
+/**
+ * Disable a certain capture within a query.
+ *
+ * This prevents the capture from being returned in matches, and also avoids
+ * any resource usage associated with recording the capture. Currently, there
+ * is no way to undo this.
+ *
+ * @param capture [String]
+ *
+ * @return [nil]
+ */
+static VALUE query_disable_capture(VALUE self, VALUE capture) {
+  const char *cap = StringValuePtr(capture);
+  uint32_t length = (uint32_t)RSTRING_LEN(capture);
+  ts_query_disable_capture(SELF, cap, length);
+  return Qnil;
+}
+
+/**
+ * Disable a certain pattern within a query.
+ *
+ * This prevents the pattern from matching and removes most of the overhead
+ * associated with the pattern. Currently, there is no way to undo this.
+ *
+ * @raise [IndexError] if out of range.
+ *
+ * @param pattern [Integer]
+ *
+ * @return [nil]
+ */
+static VALUE query_disable_pattern(VALUE self, VALUE pattern) {
+  TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern);
+  uint32_t range = ts_query_pattern_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    ts_query_disable_pattern(query, index);
+    return Qnil;
+  }
+}
+
+/**
+ * Create a new query from a string containing one or more S-expression
+ * patterns. The query is associated with a particular language, and can
+ * only be run on syntax nodes parsed with that language.
+ *
+ * If all of the given patterns are valid, this returns a {Query}.
+ *
+ * @raise [RuntimeError]
+ *
+ * @param language [Language]
+ * @param source   [String]
+ *
+ * @return [Query]
+ */
+static VALUE query_initialize(VALUE self, VALUE language, VALUE source) {
+  // FIXME: should we raise an exception here?
+  TSLanguage *lang = value_to_language(language);
+  const char *src = StringValuePtr(source);
+  uint32_t len = (uint32_t)RSTRING_LEN(source);
+  uint32_t error_offset = 0;
+  TSQueryError error_type;
+
+  TSQuery *res = ts_query_new(lang, src, len, &error_offset, &error_type);
+
+  if (res == NULL || error_offset > 0) {
+    rb_raise(rb_eRuntimeError, "Could not create query: TSQueryError%s",
+             query_error_str(error_type));
+  } else {
+    SELF = res;
+  }
+
+  rb_iv_set(self, "@text_predicates", rb_ary_new());
+  rb_iv_set(self, "@property_predicates", rb_ary_new());
+  rb_iv_set(self, "@property_settings", rb_ary_new());
+  rb_iv_set(self, "@general_predicates", rb_ary_new());
+
+  rb_funcall(self, rb_intern("process"), 1, source);
+
+  return self;
+}
+
+/**
+ * Get the number of patterns in the query.
+ *
+ * @return [Integer]
+ */
+static VALUE query_pattern_count(VALUE self) {
+  return UINT2NUM(ts_query_pattern_count(SELF));
+}
+
+/**
+ * Check if a given pattern is guaranteed to match once a given step is reached.
+ * The step is specified by its byte offset in the query's source code.
+ *
+ * @param byte_offset [Integer]
+ *
+ * @return [Integer]
+ */
+static VALUE query_pattern_guaranteed_at_step(VALUE self, VALUE byte_offset) {
+  return UINT2NUM(
+      ts_query_is_pattern_guaranteed_at_step(SELF, NUM2UINT(byte_offset)));
+}
+
+/**
+ * Get all of the predicates for the given pattern in the query.
+ *
+ * The predicates are represented as a single array of steps. There are three
+ * types of steps in this array, which correspond to the three legal values for
+ * the +type+ field:
+ * - {QueryPredicateStep::CAPTURE}: Steps with this type represent names
+ *   of captures. Their +value_id+ can be used with the
+ *   {Query#capture_name_for_id} function to obtain the name of the capture.
+ * - {QueryPredicateStep::STRING}: Steps with this type represent literal
+ *   strings. Their +value_id+ can be used with the
+ *   {Query#string_value_for_id} function to obtain their string value.
+ * - {QueryPredicateStep::DONE}: Steps with this type are *sentinels*
+ *   that represent the end of an individual predicate. If a pattern has two
+ *   predicates, then there will be two steps with this +type+ in the array.
+ *
+ * @param pattern_index [Integer]
+ *
+ * @return [Array<QueryPredicateStep>]
+ */
+static VALUE query_predicates_for_pattern(VALUE self, VALUE pattern_index) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern_index);
+  uint32_t length;
+  const TSQueryPredicateStep *steps =
+      ts_query_predicates_for_pattern(query, index, &length);
+  VALUE res = rb_ary_new_capa(length);
+
+  for (uint32_t i = 0; i < length; i++) {
+    rb_ary_push(res, new_query_predicate_step(&steps[i]));
+  }
+
+  return res;
+}
+
+/**
+ * Get the byte offset where the given pattern starts in the query's source.
+ *
+ * This can be useful when combining queries by concatenating their source
+ * code strings.
+ *
+ * @raise [IndexError] if out of range.
+ *
+ * @param pattern_index [Integer]
+ *
+ * @return [Integer]
+ */
+static VALUE query_start_byte_for_pattern(VALUE self, VALUE pattern_index) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(pattern_index);
+  uint32_t range = ts_query_pattern_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    return UINT2NUM(ts_query_start_byte_for_pattern(SELF, index));
+  }
+}
+
+/**
+ * Get the number of string literals in the query.
+ *
+ * @return [Integer]
+ */
+static VALUE query_string_count(VALUE self) {
+  return UINT2NUM(ts_query_string_count(SELF));
+}
+
+/**
+ * @raise [IndexError] if out of range.
+ *
+ * @param id [Integer]
+ *
+ * @return [String]
+ */
+static VALUE query_string_value_for_id(VALUE self, VALUE id) {
+  const TSQuery *query = SELF;
+  uint32_t index = NUM2UINT(id);
+  uint32_t range = ts_query_string_count(query);
+
+  if (index >= range) {
+    rb_raise(rb_eIndexError, "Index %d out of range (len = %d)", index, range);
+  } else {
+    uint32_t length;
+    const char *string = ts_query_string_value_for_id(query, index, &length);
+    return safe_str2(string, length);
+  }
+}
+
+// FIXME: missing:
+// 1. ts_query_is_pattern_rooted
+// 1. ts_query_is_pattern_non_local
+void init_query(void) {
+  cQuery = rb_define_class_under(mTreeSitter, "Query", rb_cObject);
+
+  rb_define_alloc_func(cQuery, query_allocate);
+
+  /* Class methods */
+  rb_define_method(cQuery, "capture_count", query_capture_count, 0);
+  rb_define_method(cQuery, "capture_name_for_id", query_capture_name_for_id, 1);
+  rb_define_method(cQuery, "capture_quantifier_for_id",
+                   query_capture_quantifier_for_id, 2);
+  rb_define_method(cQuery, "disable_capture", query_disable_capture, 1);
+  rb_define_method(cQuery, "disable_pattern", query_disable_pattern, 1);
+  rb_define_method(cQuery, "initialize", query_initialize, 2);
+  rb_define_method(cQuery, "pattern_count", query_pattern_count, 0);
+  rb_define_method(cQuery, "pattern_guaranteed_at_step?",
+                   query_pattern_guaranteed_at_step, 1);
+  rb_define_method(cQuery, "predicates_for_pattern",
+                   query_predicates_for_pattern, 1);
+  rb_define_method(cQuery, "start_byte_for_pattern",
+                   query_start_byte_for_pattern, 1);
+  rb_define_method(cQuery, "string_count", query_string_count, 0);
+  rb_define_method(cQuery, "string_value_for_id", query_string_value_for_id, 1);
+}

data/ext/tree_sitter/query_capture.c

@@ -0,0 +1,28 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryCapture;
+
+DATA_WRAP(QueryCapture, query_capture)
+DATA_DEFINE_GETTER(query_capture, index, UINT2NUM)
+DATA_DEFINE_GETTER(query_capture, node, new_node_by_val)
+
+static VALUE query_capture_inspect(VALUE self) {
+  TSQueryCapture query_capture = SELF;
+  return rb_sprintf("{index=%d, node=%+" PRIsVALUE "}", query_capture.index,
+                    new_node(&query_capture.node));
+}
+
+void init_query_capture(void) {
+  cQueryCapture =
+      rb_define_class_under(mTreeSitter, "QueryCapture", rb_cObject);
+
+  rb_define_alloc_func(cQueryCapture, query_capture_allocate);
+
+  /* Class methods */
+  DECLARE_GETTER(cQueryCapture, query_capture, index)
+  DECLARE_GETTER(cQueryCapture, query_capture, node)
+  rb_define_method(cQueryCapture, "inspect", query_capture_inspect, 0);
+  rb_define_method(cQueryCapture, "to_s", query_capture_inspect, 0);
+}

data/ext/tree_sitter/query_cursor.c

@@ -0,0 +1,231 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryCursor;
+
+DATA_TYPE(TSQueryCursor *, query_cursor)
+DATA_FREE_PTR(query_cursor)
+DATA_MEMSIZE(query_cursor)
+DATA_DECLARE_DATA_TYPE(query_cursor)
+static VALUE query_cursor_allocate(VALUE klass) {
+  query_cursor_t *query_cursor;
+  VALUE res = TypedData_Make_Struct(klass, query_cursor_t,
+                                    &query_cursor_data_type, query_cursor);
+  query_cursor->data = ts_query_cursor_new();
+  return res;
+}
+DATA_UNWRAP(query_cursor)
+/**
+ * Create a new cursor for executing a given query.
+ *
+ * The cursor stores the state that is needed to iteratively search
+ * for matches. To use the query cursor, first call {QueryCursor#exec}
+ * to start running a given query on a given syntax node. Then, there are
+ * two options for consuming the results of the query:
+ * 1. Repeatedly call {QueryCursor#next_match} to iterate over all of the
+ *    *matches* in the order that they were found. Each match contains the
+ *    index of the pattern that matched, and an array of captures. Because
+ *    multiple patterns can match the same set of nodes, one match may contain
+ *    captures that appear *before* some of the captures from a previous match.
+ * 2. Repeatedly call {QueryCursor#next_capture} to iterate over all of the
+ *    individual *captures* in the order that they appear. This is useful if
+ *    don't care about which pattern matched, and just want a single ordered
+ *    sequence of captures.
+ *
+ * If you don't care about consuming all of the results, you can stop calling
+ * {QueryCursor#next_match} or {QueryCursor#next_capture} at any point.
+ * You can then start executing another query on another node by calling
+ * {QueryCursor#exec} again.
+ */
+DATA_PTR_NEW(cQueryCursor, TSQueryCursor, query_cursor)
+DATA_FROM_VALUE(TSQueryCursor *, query_cursor)
+
+/**
+ * Start running a given query on a given node.
+ *
+ * @param query [Query]
+ * @param node  [Node]
+ *
+ * @return [QueryCursor]
+ */
+static VALUE query_cursor_exec_static(VALUE self, VALUE query, VALUE node) {
+  VALUE res = query_cursor_allocate(cQueryCursor);
+  query_cursor_t *query_cursor = unwrap(res);
+  ts_query_cursor_exec(query_cursor->data, value_to_query(query),
+                       value_to_node(node));
+  return res;
+}
+
+/**
+ * Start running a given query on a given node.
+ *
+ * @param query [Query]
+ * @param node  [Node]
+ *
+ * @return [QueryCursor]
+ */
+static VALUE query_cursor_exec(VALUE self, VALUE query, VALUE node) {
+  query_cursor_t *query_cursor = unwrap(self);
+  ts_query_cursor_exec(query_cursor->data, value_to_query(query),
+                       value_to_node(node));
+  return self;
+}
+
+/**
+ * Manage the maximum number of in-progress matches allowed by this query
+ * cursor.
+ *
+ * Query cursors have an optional maximum capacity for storing lists of
+ * in-progress captures. If this capacity is exceeded, then the
+ * earliest-starting match will silently be dropped to make room for further
+ * matches. This maximum capacity is optional — by default, query cursors allow
+ * any number of pending matches, dynamically allocating new space for them as
+ * needed as the query is executed.
+ */
+static VALUE query_cursor_did_exceed_match_limit(VALUE self) {
+  return ts_query_cursor_did_exceed_match_limit(SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * @param limit [Integer]
+ *
+ * @return [nil]
+ */
+static VALUE query_cursor_set_match_limit(VALUE self, VALUE limit) {
+  ts_query_cursor_set_match_limit(SELF, NUM2UINT(limit));
+  return Qnil;
+}
+
+/**
+ * @return [Integer]
+ */
+static VALUE query_cursor_get_match_limit(VALUE self) {
+  return UINT2NUM(ts_query_cursor_match_limit(SELF));
+}
+
+/**
+ * Set the maximum start depth for a query cursor.
+ *
+ * This prevents cursors from exploring children nodes at a certain depth.
+ * Note if a pattern includes many children, then they will still be checked.
+ *
+ * The zero max start depth value can be used as a special behavior and
+ * it helps to destructure a subtree by staying on a node and using captures
+ * for interested parts. Note that the zero max start depth only limit a search
+ * depth for a pattern's root node but other nodes that are parts of the pattern
+ * may be searched at any depth what defined by the pattern structure.
+ *
+ * @param max_start_depth [Integer|nil] set to nil to remove the maximum start
+ * depth.
+ *
+ * @return [nil]
+ */
+static VALUE query_cursor_set_max_start_depth(VALUE self,
+                                              VALUE max_start_depth) {
+  uint32_t max = UINT32_MAX;
+  if (!NIL_P(max_start_depth)) {
+    max = NUM2UINT(max_start_depth);
+  }
+  ts_query_cursor_set_max_start_depth(SELF, max);
+  return Qnil;
+}
+
+// FIXME: maybe this is the limit of how "transparent" the bindings need to be.
+// Pending benchmarks, this can be very inefficient because obviously
+// ts_query_cursor_next_capture is intended to be used in a loop.  Creating an
+// array of two values and returning them, intuitively speaking, seem very
+// inefficient.
+// FIXME: maybe this needs to return an empty array to make for a nicer ruby
+// API?
+/**
+ * Advance to the next capture of the currently running query.
+ *
+ * @return [Array<Integer|Boolean>|nil] If there is a capture, return a tuple
+ * [Integer, Boolean], otherwise return +nil+.
+ */
+static VALUE query_cursor_next_capture(VALUE self) {
+  TSQueryMatch match;
+  uint32_t index;
+  if (ts_query_cursor_next_capture(SELF, &match, &index)) {
+    VALUE res = rb_ary_new_capa(2);
+    rb_ary_push(res, UINT2NUM(index));
+    rb_ary_push(res, new_query_match(&match));
+    return res;
+  } else {
+    return Qnil;
+  }
+}
+
+/**
+ * Advance to the next match of the currently running query.
+ *
+ * @return [Boolean] Whether there's a match.
+ */
+static VALUE query_cursor_next_match(VALUE self) {
+  TSQueryMatch match;
+  if (ts_query_cursor_next_match(SELF, &match)) {
+    return new_query_match(&match);
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE query_cursor_remove_match(VALUE self, VALUE id) {
+  ts_query_cursor_remove_match(SELF, NUM2UINT(id));
+  return Qnil;
+}
+
+/**
+ * @param from [Integer]
+ * @param to   [Integer]
+ *
+ * @return [nil]
+ */
+static VALUE query_cursor_set_byte_range(VALUE self, VALUE from, VALUE to) {
+  ts_query_cursor_set_byte_range(SELF, NUM2UINT(from), NUM2UINT(to));
+  return Qnil;
+}
+
+/**
+ * @param from [Point]
+ * @param to   [Point]
+ *
+ * @return [nil]
+ */
+static VALUE query_cursor_set_point_range(VALUE self, VALUE from, VALUE to) {
+  ts_query_cursor_set_point_range(SELF, value_to_point(from),
+                                  value_to_point(to));
+  return Qnil;
+}
+
+void init_query_cursor(void) {
+  cQueryCursor = rb_define_class_under(mTreeSitter, "QueryCursor", rb_cObject);
+
+  rb_define_alloc_func(cQueryCursor, query_cursor_allocate);
+
+  /* Module methods */
+  rb_define_module_function(cQueryCursor, "exec", query_cursor_exec_static, 2);
+
+  /* Class methods */
+  // Accessors
+  DECLARE_ACCESSOR(cQueryCursor, query_cursor, match_limit)
+
+  // Other
+  rb_define_method(cQueryCursor, "exec", query_cursor_exec, 2);
+  rb_define_method(cQueryCursor, "exceed_match_limit?",
+                   query_cursor_did_exceed_match_limit, 0);
+  rb_define_method(cQueryCursor, "match_limit", query_cursor_get_match_limit,
+                   0);
+  rb_define_method(cQueryCursor, "match_limit=", query_cursor_set_match_limit,
+                   1);
+  rb_define_method(cQueryCursor,
+                   "max_start_depth=", query_cursor_set_max_start_depth, 1);
+  rb_define_method(cQueryCursor, "next_capture", query_cursor_next_capture, 0);
+  rb_define_method(cQueryCursor, "next_match", query_cursor_next_match, 0);
+  rb_define_method(cQueryCursor, "remove_match", query_cursor_remove_match, 1);
+  rb_define_method(cQueryCursor, "set_byte_range", query_cursor_set_byte_range,
+                   2);
+  rb_define_method(cQueryCursor, "set_point_range",
+                   query_cursor_set_point_range, 2);
+}

data/ext/tree_sitter/query_error.c

@@ -0,0 +1,41 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE mQueryError;
+
+TSQueryError value_to_query_error(VALUE query_error) {
+  return NUM2UINT(query_error);
+}
+
+const char *query_error_str(TSQueryError error) {
+  switch (error) {
+  case TSQueryErrorNone:
+    return "None";
+  case TSQueryErrorSyntax:
+    return "Syntax";
+  case TSQueryErrorNodeType:
+    return "Node Type";
+  case TSQueryErrorField:
+    return "Field";
+  case TSQueryErrorCapture:
+    return "Capture";
+  case TSQueryErrorStructure:
+    return "Structure";
+  case TSQueryErrorLanguage:
+    return "Language";
+  default:
+    return "??";
+  }
+}
+
+void init_query_error(void) {
+  mQueryError = rb_define_module_under(mTreeSitter, "QueryError");
+  rb_define_const(mQueryError, "NONE", UINT2NUM(0));
+  rb_define_const(mQueryError, "Syntax", UINT2NUM(1));
+  rb_define_const(mQueryError, "NodeType", UINT2NUM(2));
+  rb_define_const(mQueryError, "Field", UINT2NUM(3));
+  rb_define_const(mQueryError, "Capture", UINT2NUM(4));
+  rb_define_const(mQueryError, "Structure", UINT2NUM(5));
+  rb_define_const(mQueryError, "Language", UINT2NUM(6));
+}

data/ext/tree_sitter/query_match.c

@@ -0,0 +1,44 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryMatch;
+
+DATA_WRAP(QueryMatch, query_match)
+DATA_DEFINE_GETTER(query_match, id, UINT2NUM)
+DATA_DEFINE_GETTER(query_match, pattern_index, INT2FIX)
+DATA_DEFINE_GETTER(query_match, capture_count, INT2FIX)
+
+static VALUE query_match_get_captures(VALUE self) {
+  query_match_t *query_match = unwrap(self);
+
+  uint16_t length = query_match->data.capture_count;
+  VALUE res = rb_ary_new_capa(length);
+  const TSQueryCapture *captures = query_match->data.captures;
+  for (int i = 0; i < length; i++) {
+    rb_ary_push(res, new_query_capture(&captures[i]));
+  }
+
+  return res;
+}
+
+static VALUE query_match_inspect(VALUE self) {
+  TSQueryMatch query_match = SELF;
+  return rb_sprintf("{id=%d, pattern_inex=%d, capture_count=%d}",
+                    query_match.id, query_match.pattern_index,
+                    query_match.capture_count);
+}
+
+void init_query_match(void) {
+  cQueryMatch = rb_define_class_under(mTreeSitter, "QueryMatch", rb_cObject);
+
+  rb_define_alloc_func(cQueryMatch, query_match_allocate);
+
+  /* Class methods */
+  DECLARE_GETTER(cQueryMatch, query_match, id)
+  DECLARE_GETTER(cQueryMatch, query_match, pattern_index)
+  DECLARE_GETTER(cQueryMatch, query_match, capture_count)
+  DECLARE_GETTER(cQueryMatch, query_match, captures)
+  rb_define_method(cQueryMatch, "inspect", query_match_inspect, 0);
+  rb_define_method(cQueryMatch, "to_s", query_match_inspect, 0);
+}