ruby_tree_sitter 0.20.8.2-x86_64-darwin-20 → 1.0.0-x86_64-darwin-20

data/ext/tree_sitter/parser.c

@@ -40,10 +40,63 @@ static VALUE parser_allocate(VALUE klass) {
   return res;
 }
 
+/**
+ * Get the parser's current cancellation flag pointer.
+ *
+ * @return [Integer]
+ */
+static VALUE parser_get_cancellation_flag(VALUE self) {
+  return SIZET2NUM(*ts_parser_cancellation_flag(SELF));
+}
+
+/**
+ * Set the parser's current cancellation flag pointer.
+ *
+ * If a non-null pointer is assigned, then the parser will periodically read
+ * from this pointer during parsing. If it reads a non-zero value, it will
+ * halt early, returning +nil+.
+ *
+ * @see parse
+ *
+ * @note This is not well-tested in the bindings.
+ *
+ * @return nil
+ */
+static VALUE parser_set_cancellation_flag(VALUE self, VALUE flag) {
+  unwrap(self)->cancellation_flag = NUM2SIZET(flag);
+  ts_parser_set_cancellation_flag(SELF, &unwrap(self)->cancellation_flag);
+  return Qnil;
+}
+
+/**
+ * Get the parser's current language.
+ */
 static VALUE parser_get_language(VALUE self) {
   return new_language(ts_parser_language(SELF));
 }
 
+/**
+ * Set the language that the parser should use for parsing.
+ *
+ * Returns a boolean indicating whether or not the language was successfully
+ * assigned. True means assignment succeeded. False means there was a version
+ * mismatch: the language was generated with an incompatible version of the
+ * Tree-sitter CLI. Check the language's version using {Language#version}
+ * and compare it to this library's {TreeSitter::LANGUAGE_VERSION} and
+ * {TreeSitter::MIN_COMPATIBLE_LANGUAGE_VERSION} constants.
+ *
+ * @return [Boolean]
+ */
+static VALUE parser_set_language(VALUE self, VALUE language) {
+  return ts_parser_set_language(SELF, value_to_language(language)) ? Qtrue
+                                                                   : Qfalse;
+}
+
+/**
+ * Get the ranges of text that the parser will include when parsing.
+ *
+ * @return [Array<Range>]
+ */
 static VALUE parser_get_included_ranges(VALUE self) {
   uint32_t length;
   const TSRange *ranges = ts_parser_included_ranges(SELF, &length);
@@ -54,23 +107,33 @@ static VALUE parser_get_included_ranges(VALUE self) {
   return res;
 }
 
-static VALUE parser_get_timeout_micros(VALUE self) {
-  return ULL2NUM(ts_parser_timeout_micros(SELF));
-}
-
-static VALUE parser_get_logger(VALUE self) {
-  return new_logger_by_val(ts_parser_logger(SELF));
-}
-
-static VALUE parser_get_cancellation_flag(VALUE self) {
-  return SIZET2NUM(*ts_parser_cancellation_flag(SELF));
-}
-
-static VALUE parser_set_language(VALUE self, VALUE language) {
-  return ts_parser_set_language(SELF, value_to_language(language)) ? Qtrue
-                                                                   : Qfalse;
-}
-
+/**
+ * Set the ranges of text that the parser should include when parsing.
+ *
+ * By default, the parser will always include entire documents. This function
+ * allows you to parse only a *portion* of a document but still return a syntax
+ * tree whose ranges match up with the document as a whole. You can also pass
+ * multiple disjoint ranges.
+ *
+ * The second and third parameters specify the location and length of an array
+ * of ranges. The parser does *not* take ownership of these ranges; it copies
+ * the data, so it doesn't matter how these ranges are allocated.
+ *
+ * If +array+'s +length+ is zero, then the entire document will be parsed.
+ * Otherwise, the given ranges must be ordered from earliest to latest in the
+ * document, and they must not overlap. That is, the following must hold for
+ * all:
+ *
+ *   i < length - 1: ranges[i].end_byte <= ranges[i + 1].start_byte
+ *
+ * If this requirement is not satisfied, the operation will fail, the ranges
+ * will not be assigned, and this function will return +false+. On success,
+ * this function returns +true+
+ *
+ * @param array [Array<Range>]
+ *
+ * @return [Boolean]
+ */
 static VALUE parser_set_included_ranges(VALUE self, VALUE array) {
   Check_Type(array, T_ARRAY);
 
@@ -86,22 +149,76 @@ static VALUE parser_set_included_ranges(VALUE self, VALUE array) {
   return res ? Qtrue : Qfalse;
 }
 
-static VALUE parser_set_timeout_micros(VALUE self, VALUE timeout) {
-  ts_parser_set_timeout_micros(SELF, NUM2ULL(timeout));
-  return Qnil;
-}
-
-static VALUE parser_set_cancellation_flag(VALUE self, VALUE flag) {
-  unwrap(self)->cancellation_flag = NUM2SIZET(flag);
-  ts_parser_set_cancellation_flag(SELF, &unwrap(self)->cancellation_flag);
-  return Qnil;
+/**
+ * Get the parser's current logger.
+ *
+ * @return [Logger]
+ */
+static VALUE parser_get_logger(VALUE self) {
+  return new_logger_by_val(ts_parser_logger(SELF));
 }
 
+/**
+ * Set the logger that a parser should use during parsing.
+ *
+ * The parser does not take ownership over the logger payload. If a logger was
+ * previously assigned, the caller is responsible for releasing any memory
+ * owned by the previous logger.
+ *
+ * @param logger [Logger] or any object that has a +printf+, +puts+, or +write+.
+ *
+ * @return nil
+ */
 static VALUE parser_set_logger(VALUE self, VALUE logger) {
   ts_parser_set_logger(SELF, value_to_logger(logger));
   return Qnil;
 }
 
+/**
+ * Use the parser to parse some source code and create a syntax tree.
+ *
+ * If you are parsing this document for the first time, pass +nil+ for the
+ * +old_tree+ parameter. Otherwise, if you have already parsed an earlier
+ * version of this document and the document has since been edited, pass the
+ * previous syntax tree so that the unchanged parts of it can be reused.
+ * This will save time and memory. For this to work correctly, you must have
+ * already edited the old syntax tree using the {Tree#edit} function in a
+ * way that exactly matches the source code changes.
+ *
+ * The input parameter lets you specify how to read the text. It has the
+ * following three fields:
+ * 1. +read+: A function to retrieve a chunk of text at a given byte offset
+ *    and (row, column) position. The function should return a pointer to the
+ *    text and write its length to the +bytes_read+ pointer. The parser does
+ *    not take ownership of this buffer; it just borrows it until it has
+ *    finished reading it. The function should write a zero value to the
+ *    +bytes_read+ pointer to indicate the end of the document.
+ * 2. +payload+: An arbitrary pointer that will be passed to each invocation
+ *    of the +read+ function.
+ * 3. +encoding+: An indication of how the text is encoded. Either
+ *    {Encoding::UTF8} or {Encoding::UTF16}.
+ *
+ * This function returns a syntax tree on success, and +nil+ on failure. There
+ * are three possible reasons for failure:
+ * 1. The parser does not have a language assigned. Check for this using the
+ *    {Parser#language} function.
+ * 2. Parsing was cancelled due to a timeout that was set by an earlier call to
+ *    the {Parser#timeout_micros=} function. You can resume parsing from
+ *    where the parser left out by calling {Parser#parse} again with the
+ *    same arguments. Or you can start parsing from scratch by first calling
+ *    {Parser#reset}.
+ * 3. Parsing was cancelled using a cancellation flag that was set by an
+ *    earlier call to {Parsert#cancellation_flag=}. You can resume parsing
+ *    from where the parser left out by calling {Parser#parse} again with
+ *    the same arguments.
+ *
+ * @note this is curently incomplete, as the {Input} class is incomplete.
+ *
+ * @param old_tree [Tree]
+ * @param input    [Input]
+ *
+ * @return [Tree, nil] A parse tree if parsing was successful.
+ */
 static VALUE parser_parse(VALUE self, VALUE old_tree, VALUE input) {
   if (NIL_P(input)) {
     return Qnil;
@@ -120,6 +237,17 @@ static VALUE parser_parse(VALUE self, VALUE old_tree, VALUE input) {
   }
 }
 
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer.
+ * The first two parameters are the same as in the {Parser#parse} function
+ * above. The second two parameters indicate the location of the buffer and its
+ * length in bytes.
+ *
+ * @param old_tree [Tree]
+ * @param string   [String]
+ *
+ * @return [Tree, nil] A parse tree if parsing was successful.
+ */
 static VALUE parser_parse_string(VALUE self, VALUE old_tree, VALUE string) {
   if (NIL_P(string)) {
     return Qnil;
@@ -140,6 +268,18 @@ static VALUE parser_parse_string(VALUE self, VALUE old_tree, VALUE string) {
   }
 }
 
+/**
+ * Use the parser to parse some source code stored in one contiguous buffer with
+ * a given encoding. The first four parameters work the same as in the
+ * {Parser#parse_string} method above. The final parameter indicates whether
+ * the text is encoded as {Encoding::UTF8} or {Encoding::UTF16}.
+ *
+ * @param old_tree [Tree]
+ * @param string   [String]
+ * @param encoding [Encoding]
+ *
+ * @return [Tree, nil] A parse tree if parsing was successful.
+ */
 static VALUE parser_parse_string_encoding(VALUE self, VALUE old_tree,
                                           VALUE string, VALUE encoding) {
   if (NIL_P(string)) {
@@ -163,11 +303,17 @@ static VALUE parser_parse_string_encoding(VALUE self, VALUE old_tree,
   }
 }
 
-static VALUE parser_reset(VALUE self) {
-  ts_parser_reset(SELF);
-  return Qnil;
-}
-
+/**
+ * Set the file descriptor to which the parser should write debugging graphs
+ * during parsing. The graphs are formatted in the DOT language. You may want
+ * to pipe these graphs directly to a +dot(1)+ process in order to generate
+ * SVG output. You can turn off this logging by passing a negative number.
+ *
+ * @param file [Integer, String, nil] a file name to print, or turn off by
+ * passing +nil+ or +-1+
+ *
+ * @return nil
+ */
 static VALUE parser_print_dot_graphs(VALUE self, VALUE file) {
   if (NIL_P(file)) {
     ts_parser_print_dot_graphs(SELF, -1);
@@ -183,21 +329,70 @@ static VALUE parser_print_dot_graphs(VALUE self, VALUE file) {
   return Qnil;
 }
 
+/**
+ * Instruct the parser to start the next parse from the beginning.
+ *
+ * If the parser previously failed because of a timeout or a cancellation, then
+ * by default, it will resume where it left off on the next call to
+ * {Parser#parse} or other parsing functions. If you don't want to resume,
+ * and instead intend to use this parser to parse some other document, you must
+ * call {Parser#reset} first.
+ *
+ * @return nil
+ */
+static VALUE parser_reset(VALUE self) {
+  ts_parser_reset(SELF);
+  return Qnil;
+}
+
+/**
+ * Get the duration in microseconds that parsing is allowed to take.
+ *
+ * @return [Integer]
+ */
+static VALUE parser_get_timeout_micros(VALUE self) {
+  return ULL2NUM(ts_parser_timeout_micros(SELF));
+}
+
+/**
+ * Set the maximum duration in microseconds that parsing should be allowed to
+ * take before halting.
+ *
+ * If parsing takes longer than this, it will halt early, returning +nil+.
+ *
+ * @see parse
+ *
+ * @param timeout [Integer]
+ *
+ * @return [nil]
+ */
+static VALUE parser_set_timeout_micros(VALUE self, VALUE timeout) {
+  ts_parser_set_timeout_micros(SELF, NUM2ULL(timeout));
+  return Qnil;
+}
+
 void init_parser(void) {
   cParser = rb_define_class_under(mTreeSitter, "Parser", rb_cObject);
 
   rb_define_alloc_func(cParser, parser_allocate);
 
   /* Class methods */
-  DECLARE_ACCESSOR(cParser, parser, language)
-  DECLARE_ACCESSOR(cParser, parser, included_ranges)
-  DECLARE_ACCESSOR(cParser, parser, timeout_micros)
-  DECLARE_ACCESSOR(cParser, parser, logger)
-  DECLARE_ACCESSOR(cParser, parser, cancellation_flag)
+  rb_define_method(cParser, "cancellation_flag", parser_get_cancellation_flag,
+                   0);
+  rb_define_method(cParser, "cancellation_flag=", parser_set_cancellation_flag,
+                   1);
+  rb_define_method(cParser, "included_ranges", parser_get_included_ranges, 0);
+  rb_define_method(cParser, "included_ranges=", parser_set_included_ranges, 1);
+  rb_define_method(cParser, "language", parser_get_language, 0);
+  rb_define_method(cParser, "language=", parser_set_language, 1);
+  rb_define_method(cParser, "logger", parser_get_logger, 0);
+  rb_define_method(cParser, "logger=", parser_set_logger, 1);
   rb_define_method(cParser, "parse", parser_parse, 2);
   rb_define_method(cParser, "parse_string", parser_parse_string, 2);
   rb_define_method(cParser, "parse_string_encoding",
                    parser_parse_string_encoding, 3);
-  rb_define_method(cParser, "reset", parser_reset, 0);
   rb_define_method(cParser, "print_dot_graphs", parser_print_dot_graphs, 1);
+  rb_define_method(cParser, "reset", parser_reset, 0);
+  rb_define_method(cParser, "timeout_micros", parser_get_timeout_micros, 0);
+  rb_define_method(cParser, "timeout_micros=", parser_set_timeout_micros, 1);
 }

data/ext/tree_sitter/query.c

@@ -6,7 +6,125 @@ 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);
@@ -25,30 +143,48 @@ static VALUE query_initialize(VALUE self, VALUE language, VALUE 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));
 }
 
-static VALUE query_capture_count(VALUE self) {
-  return UINT2NUM(ts_query_capture_count(SELF));
-}
-
-static VALUE query_string_count(VALUE self) {
-  return UINT2NUM(ts_query_string_count(SELF));
-}
-
-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));
-  }
+/**
+ * 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);
@@ -64,40 +200,46 @@ static VALUE query_predicates_for_pattern(VALUE self, VALUE pattern_index) {
   return res;
 }
 
-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)));
-}
-
-static VALUE query_capture_name_for_id(VALUE self, VALUE id) {
+/**
+ * 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(id);
-  uint32_t range = ts_query_capture_count(query);
+  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 {
-    uint32_t length;
-    const char *name = ts_query_capture_name_for_id(query, index, &length);
-    return safe_str2(name, length);
+    return UINT2NUM(ts_query_start_byte_for_pattern(SELF, index));
   }
 }
 
-static VALUE query_capture_quantifier_for_id(VALUE self, VALUE id,
-                                             VALUE capture_id) {
-  const TSQuery *query = SELF;
-  uint32_t pattern = NUM2UINT(id);
-  uint32_t index = NUM2UINT(capture_id);
-  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));
-  }
+/**
+ * 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);
@@ -112,46 +254,29 @@ static VALUE query_string_value_for_id(VALUE self, VALUE id) {
   }
 }
 
-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;
-}
-
-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;
-  }
-}
-
+// 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, "initialize", query_initialize, 2);
-  rb_define_method(cQuery, "pattern_count", query_pattern_count, 0);
   rb_define_method(cQuery, "capture_count", query_capture_count, 0);
-  rb_define_method(cQuery, "string_count", query_string_count, 0);
-  rb_define_method(cQuery, "start_byte_for_pattern",
-                   query_start_byte_for_pattern, 1);
-  rb_define_method(cQuery, "predicates_for_pattern",
-                   query_predicates_for_pattern, 1);
-  rb_define_method(cQuery, "pattern_guaranteed_at_step?",
-                   query_pattern_guaranteed_at_step, 1);
   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, "string_value_for_id", query_string_value_for_id, 1);
   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);
 }