ruby_tree_sitter 1.6.0-x86_64-linux-musl

data/ext/tree_sitter/tree_cursor.c

@@ -0,0 +1,269 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cTreeCursor;
+
+DATA_TYPE(TSTreeCursor, tree_cursor)
+static void tree_cursor_free(void *ptr) {
+  tree_cursor_t *type = (tree_cursor_t *)ptr;
+  ts_tree_cursor_delete(&type->data);
+  xfree(ptr);
+}
+DATA_MEMSIZE(tree_cursor)
+DATA_DECLARE_DATA_TYPE(tree_cursor)
+DATA_ALLOCATE(tree_cursor)
+DATA_UNWRAP(tree_cursor)
+DATA_NEW(cTreeCursor, TSTreeCursor, tree_cursor)
+DATA_FROM_VALUE(TSTreeCursor, tree_cursor)
+
+/**
+ * Safely copy a tree cursor.
+ *
+ * @return [TreeCursor]
+ */
+static VALUE tree_cursor_copy(VALUE self) {
+  VALUE res = tree_cursor_allocate(cTreeCursor);
+  tree_cursor_t *ptr = unwrap(res);
+  ptr->data = ts_tree_cursor_copy(&SELF);
+  return res;
+}
+
+/**
+ * Get the depth of the cursor's current node relative to the original
+ * node that the cursor was constructed with.
+ *
+ * @return [Integer]
+ */
+static VALUE tree_cursor_current_depth(VALUE self) {
+  return UINT2NUM(ts_tree_cursor_current_depth(&SELF));
+}
+
+/**
+ * Get the index of the cursor's current node out of all of the
+ * descendants of the original node that the cursor was constructed with.
+ *
+ * @return [Integer]
+ */
+static VALUE tree_cursor_current_descendant_index(VALUE self) {
+  return UINT2NUM(ts_tree_cursor_current_descendant_index(&SELF));
+}
+
+/**
+ * Get the field id of the tree cursor's current node.
+ *
+ * This returns zero if the current node doesn't have a field.
+ *
+ * @see Node#child_by_field_id
+ * @see Node#field_id_for_name
+ *
+ * @return [Integer]
+ */
+static VALUE tree_cursor_current_field_id(VALUE self) {
+  return UINT2NUM(ts_tree_cursor_current_field_id(&SELF));
+}
+
+/**
+ * Get the field name of the tree cursor's current node.
+ *
+ * This returns +nil+ if the current node doesn't have a field.
+ *
+ * @see Node#child_by_field_name
+ *
+ * @return [String]
+ */
+static VALUE tree_cursor_current_field_name(VALUE self) {
+  return safe_str(ts_tree_cursor_current_field_name(&SELF));
+}
+
+/**
+ * Get the tree cursor's current node.
+ *
+ * @return [Node]
+ */
+static VALUE tree_cursor_current_node(VALUE self) {
+  TSNode node = ts_tree_cursor_current_node(&SELF);
+  return new_node(&node);
+}
+
+/**
+ * Move the cursor to the node that is the nth descendant of
+ * the original node that the cursor was constructed with, where
+ * zero represents the original node itself.
+ *
+ * @return [nil]
+ */
+static VALUE tree_cursor_goto_descendant(VALUE self, VALUE descendant_idx) {
+  uint32_t idx = NUM2UINT(descendant_idx);
+  ts_tree_cursor_goto_descendant(&SELF, idx);
+  return Qnil;
+}
+
+/**
+ * Move the cursor to the first child of its current node.
+ *
+ * This returns +true+ if the cursor successfully moved, and returns +false+
+ * if there were no children.
+ *
+ * @return [Boolean]
+ */
+static VALUE tree_cursor_goto_first_child(VALUE self) {
+  return ts_tree_cursor_goto_first_child(&SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * Move the cursor to the first child of its current node that extends beyond
+ * the given byte offset.
+ *
+ * This returns the index of the child node if one was found, and returns -1
+ * if no such child was found.
+ *
+ * @return [Integer]
+ */
+static VALUE tree_cursor_goto_first_child_for_byte(VALUE self, VALUE byte) {
+  return LL2NUM(
+      ts_tree_cursor_goto_first_child_for_byte(&SELF, NUM2UINT(byte)));
+}
+
+/**
+ * Move the cursor to the first child of its current node that extends beyond
+ * the given or point.
+ *
+ * This returns the index of the child node if one was found, and returns -1
+ * if no such child was found.
+ *
+ * @return [Integer]
+ */
+static VALUE tree_cursor_goto_first_child_for_point(VALUE self, VALUE point) {
+  return LL2NUM(
+      ts_tree_cursor_goto_first_child_for_point(&SELF, value_to_point(point)));
+}
+
+/**
+ * Move the cursor to the last child of its current node.
+ *
+ * This returns +true+ if the cursor successfully moved, and returns +false+ if
+ * there were no children.
+ *
+ * Note that this function may be slower than {#goto_first_child}
+ * because it needs to iterate through all the children to compute the child's
+ * position.
+ */
+static VALUE tree_cursor_goto_last_child(VALUE self) {
+  return ts_tree_cursor_goto_last_child(&SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * Move the cursor to the next sibling of its current node.
+ *
+ * This returns +true+ if the cursor successfully moved, and returns +false+
+ * if there was no next sibling node.
+ *
+ * @return Boolean
+ */
+static VALUE tree_cursor_goto_next_sibling(VALUE self) {
+  return ts_tree_cursor_goto_next_sibling(&SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * Move the cursor to the parent of its current node.
+ *
+ * This returns +true+ if the cursor successfully moved, and returns +false+
+ * if there was no parent node (the cursor was already on the root node).
+ *
+ * @return [Boolean]
+ */
+static VALUE tree_cursor_goto_parent(VALUE self) {
+  return ts_tree_cursor_goto_parent(&SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * Move the cursor to the previous sibling of its current node.
+ *
+ * This returns +true+ if the cursor successfully moved, and returns +false+ if
+ * there was no previous sibling node.
+ *
+ * Note, that this function may be slower than
+ * {#goto_next_sibling} due to how node positions are stored. In
+ * the worst case, this will need to iterate through all the children upto the
+ * previous sibling node to recalculate its position.
+ *
+ * @return [Boolean]
+ */
+static VALUE tree_cursor_goto_previous_sibling(VALUE self) {
+  return ts_tree_cursor_goto_previous_sibling(&SELF) ? Qtrue : Qfalse;
+}
+
+/**
+ * Create a new tree cursor starting from the given node.
+ *
+ * A tree cursor allows you to walk a syntax tree more efficiently than is
+ * possible using the {Node} functions. It is a mutable object that is always
+ * on a certain syntax node, and can be moved imperatively to different nodes.
+ *
+ * @return [TreeCursor]
+ */
+static VALUE tree_cursor_initialize(VALUE self, VALUE node) {
+  TSNode n = value_to_node(node);
+  tree_cursor_t *ptr = unwrap(self);
+  ptr->data = ts_tree_cursor_new(n);
+  return self;
+}
+
+/**
+ * Re-initialize a tree cursor to start at a different node.
+ *
+ * @return [nil]
+ */
+static VALUE tree_cursor_reset(VALUE self, VALUE node) {
+  ts_tree_cursor_reset(&SELF, value_to_node(node));
+  return Qnil;
+}
+
+/**
+ * Re-initialize a tree cursor to the same position as another cursor.
+ *
+ * Unlike {#reset}, this will not lose parent information and allows reusing
+ * already created cursors.
+ *
+ * @return [nil]
+ */
+VALUE tree_cursor_reset_to(VALUE self, VALUE src) {
+  ts_tree_cursor_reset_to(&SELF, &unwrap(src)->data);
+  return Qnil;
+}
+
+void init_tree_cursor(void) {
+  cTreeCursor = rb_define_class_under(mTreeSitter, "TreeCursor", rb_cObject);
+
+  rb_define_alloc_func(cTreeCursor, tree_cursor_allocate);
+
+  /* Class methods */
+  rb_define_method(cTreeCursor, "copy", tree_cursor_copy, 0);
+  rb_define_method(cTreeCursor, "current_depth", tree_cursor_current_depth, 0);
+  rb_define_method(cTreeCursor, "current_descendant_index",
+                   tree_cursor_current_descendant_index, 0);
+  rb_define_method(cTreeCursor, "current_field_id",
+                   tree_cursor_current_field_id, 0);
+  rb_define_method(cTreeCursor, "current_field_name",
+                   tree_cursor_current_field_name, 0);
+  rb_define_method(cTreeCursor, "current_node", tree_cursor_current_node, 0);
+  rb_define_method(cTreeCursor, "goto_descendant", tree_cursor_goto_descendant,
+                   1);
+  rb_define_method(cTreeCursor, "goto_first_child",
+                   tree_cursor_goto_first_child, 0);
+  rb_define_method(cTreeCursor, "goto_first_child_for_byte",
+                   tree_cursor_goto_first_child_for_byte, 1);
+  rb_define_method(cTreeCursor, "goto_first_child_for_point",
+                   tree_cursor_goto_first_child_for_point, 1);
+  rb_define_method(cTreeCursor, "goto_last_child", tree_cursor_goto_last_child,
+                   0);
+  rb_define_method(cTreeCursor, "goto_next_sibling",
+                   tree_cursor_goto_next_sibling, 0);
+  rb_define_method(cTreeCursor, "goto_parent", tree_cursor_goto_parent, 0);
+  rb_define_method(cTreeCursor, "goto_previous_sibling",
+                   tree_cursor_goto_previous_sibling, 0);
+  rb_define_method(cTreeCursor, "initialize", tree_cursor_initialize, 1);
+  rb_define_method(cTreeCursor, "reset", tree_cursor_reset, 1);
+  rb_define_method(cTreeCursor, "reset_to", tree_cursor_reset_to, 1);
+}

data/ext/tree_sitter/tree_sitter.c

@@ -0,0 +1,44 @@
+#include "tree_sitter.h"
+
+VALUE mTreeSitter;
+
+void Init_tree_sitter() {
+  mTreeSitter = rb_define_module("TreeSitter");
+
+  /**
+   * The latest ABI version that is supported by the current version of the
+   * library. When Languages are generated by the Tree-sitter CLI, they are
+   * assigned an ABI version number that corresponds to the current CLI version.
+   * The Tree-sitter library is generally backwards-compatible with languages
+   * generated using older CLI versions, but is not forwards-compatible.
+   */
+  rb_define_const(mTreeSitter, "LANGUAGE_VERSION",
+                  INT2NUM(TREE_SITTER_LANGUAGE_VERSION));
+
+  /**
+   * The earliest ABI version that is supported by the current version of the
+   * library.
+   */
+  rb_define_const(mTreeSitter, "MIN_COMPATIBLE_LANGUAGE_VERSION",
+                  TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION);
+
+  init_encoding();
+  init_input();
+  init_input_edit();
+  init_language();
+  init_logger();
+  init_node();
+  init_parser();
+  init_point();
+  init_quantifier();
+  init_query();
+  init_query_capture();
+  init_query_cursor();
+  init_query_error();
+  init_query_match();
+  init_query_predicate_step();
+  init_range();
+  init_symbol_type();
+  init_tree();
+  init_tree_cursor();
+}

data/ext/tree_sitter/tree_sitter.h

@@ -0,0 +1,107 @@
+#ifndef _RB_TREE_SITTER_H
+#define _RB_TREE_SITTER_H
+
+#include "macros.h"
+#include <dlfcn.h>
+#include <fcntl.h>
+#include <ruby.h>
+#include <stdio.h>
+#include <string.h>
+#include <tree_sitter/api.h>
+
+static inline VALUE safe_str(const char *str) {
+  if (str == NULL) {
+    return Qnil;
+  } else {
+    return rb_utf8_str_new_cstr(str);
+  }
+}
+
+static inline VALUE safe_str2(const char *str, uint32_t len) {
+  if (str == NULL) {
+    return Qnil;
+  } else if (len == 0) {
+    return rb_utf8_str_new_cstr("");
+  } else {
+    return rb_utf8_str_new(str, len);
+  }
+}
+
+static inline VALUE safe_symbol(const char *str) {
+  if (str == NULL) {
+    return Qnil;
+  } else {
+    return ID2SYM(rb_intern(str));
+  }
+}
+
+// VALUE to TS* converters
+
+TSInput value_to_input(VALUE);
+TSInputEdit value_to_input_edit(VALUE);
+TSInputEncoding value_to_encoding(VALUE);
+TSLanguage *value_to_language(VALUE);
+TSLogger value_to_logger(VALUE);
+TSNode value_to_node(VALUE);
+TSPoint value_to_point(VALUE);
+TSQuantifier value_to_quantifier(VALUE);
+TSQuery *value_to_query(VALUE);
+TSQueryCursor *value_to_query_cursor(VALUE);
+TSQueryError value_to_query_error(VALUE);
+TSQueryMatch value_to_query_match(VALUE);
+TSQueryPredicateStep value_to_query_predicate_step(VALUE);
+TSQueryPredicateStepType value_to_query_predicate_step_type(VALUE);
+TSRange value_to_range(VALUE);
+TSSymbolType value_to_symbol_type(VALUE);
+TSTree *value_to_tree(VALUE);
+TSTreeCursor value_to_tree_cursor(VALUE);
+
+// TS* to VALUE converters
+VALUE new_input(const TSInput *);
+VALUE new_language(const TSLanguage *);
+VALUE new_logger(const TSLogger *);
+VALUE new_logger_by_val(TSLogger);
+VALUE new_node(const TSNode *);
+VALUE new_node_by_val(TSNode);
+VALUE new_point(const TSPoint *);
+VALUE new_point_by_val(TSPoint);
+VALUE new_query_capture(const TSQueryCapture *);
+VALUE new_query_match(const TSQueryMatch *);
+VALUE new_query_predicate_step(const TSQueryPredicateStep *);
+VALUE new_range(const TSRange *);
+VALUE new_symbol_type(TSSymbolType);
+VALUE new_tree(TSTree *);
+
+// All init_* functions are called from Init_tree_sitter
+void init_encoding(void);
+void init_input(void);
+void init_input_edit(void);
+void init_language(void);
+void init_logger(void);
+void init_node(void);
+void init_parser(void);
+void init_point(void);
+void init_quantifier(void);
+void init_query(void);
+void init_query_capture(void);
+void init_query_cursor(void);
+void init_query_error(void);
+void init_query_match(void);
+void init_query_predicate_step(void);
+void init_range(void);
+void init_symbol_type(void);
+void init_tree(void);
+void init_tree_cursor(void);
+
+// Other helpers
+const char *quantifier_str(TSQuantifier);
+const char *query_error_str(TSQueryError);
+
+// TSTree reference counting
+int tree_rc_free(const TSTree *);
+void tree_rc_new(const TSTree *);
+
+// This is a special entry-point for the extension
+void Init_tree_sitter(void);
+
+#endif

data/lib/tree_sitter/helpers.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# splits an array like [rust](https://doc.rust-lang.org/std/primitive.slice.html#method.split)
+def array_split_like_rust(array, &block)
+  return enum_for(__method__, array) if !block_given?
+
+  return [] if array.empty?
+
+  result = []
+  current_slice = []
+
+  array.each do |element|
+    if yield(element)
+      result << current_slice
+      current_slice = []
+    else
+      current_slice << element
+    end
+  end
+
+  result << current_slice
+  result
+end

data/lib/tree_sitter/mixins/language.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # A colon-separated list of paths pointing to directories that can contain parsers.
+  # Order matters.
+  # Takes precedence over default lookup paths.
+  ENV_PARSERS =
+    ENV['TREE_SITTER_PARSERS']
+      &.split(':')
+      &.map { |v| Pathname(v) }
+      .freeze
+
+  # The default paths we use to lookup parsers.
+  # Order matters.
+  LIBDIRS = [
+    '.vendor/parsers',
+    '.vendor/tree-sitter-parsers',
+    'vendor/parsers',
+    'vendor/tree-sitter-parsers',
+    'parsers',
+    'tree-sitter-parsers',
+    '.',
+    '/opt/local/lib',
+    '/opt/lib',
+    '/usr/local/lib',
+    '/usr/lib',
+  ].map { |p| Pathname(p) }.freeze
+
+  # Mixins.
+  module Mixins
+    # Language Mixin.
+    module Language
+      # Load a language from configuration or default lookup paths.
+      #
+      # @example Load java from default paths
+      #    # This will look for:
+      #    #
+      #    #   .vendor/tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   .vendor/parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   vendor/tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   vendor/parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   tree-sitter-parsers/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /opt/local/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /opt/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /usr/local/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /usr/lib/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    java = TreeSitter.language('java')
+      #
+      # @example (TreeStand) Load java from a configured path
+      #    # This will look for:
+      #    #
+      #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    TreeStand.config.parser_path = '/my/path'
+      #    java = TreeStand::Parser.language('java')
+      #
+      # @example (TreeStand) Load java from environment variables
+      #    # This will look for:
+      #    #
+      #    #   /my/forced/env/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #   /my/path/(java/)?(libtree-sitter-)?java.{ext}
+      #    #
+      #    # … and the same works for the default paths if `TreeStand.config.parser_path`
+      #    # was `nil`
+      #    ENV['TREE_SITTER_PARSERS'] = '/my/forced/env/path'
+      #    TreeStand.config.parser_path = '/my/path'
+      #    java = TreeStand::Parser.language('java')
+      #
+      # @note the name is case sensitive, but library lookup is not: if your parser is defined as `COBOL`,
+      #   then you have to call `language('COBOL')`, but the parser can be `cobol.so/COBOL.so/…`.
+      #
+      # @param name [String] the name of the parser.
+      #   This name is used to load the symbol from the compiled parser, replacing `-` with `_`.
+      #
+      # @return [TreeSitter:language] a language object to use in your parsers.
+      #
+      # @raise [RuntimeError] if the parser was not found.
+      #
+      # @see search_for_lib
+      def language(name)
+        lib = search_for_lib(name)
+
+        if lib.nil?
+          raise <<~MSG.chomp
+            Failed to load a parser for #{name}.
+
+            #{search_lib_message}
+          MSG
+        end
+
+        # We know that the bindings will accept `lib`, but I don't know how to tell sorbet
+        # the types in ext/tree_sitter where `load` is defined.
+        TreeSitter::Language.load(name.tr('-', '_'), lib)
+      end
+
+      # The platform-specific extension of the parser.
+      # @return [String] `dylib` or `so` for mac or linux.
+      def ext
+        case Gem::Platform.local.os
+        in   /darwin/ then 'dylib'
+        else               'so'
+        end
+      end
+
+      private
+
+      # The library directories we need to look into.
+      #
+      # @return [Array<Pathname>] the list of candidate places to use when searching for parsers.
+      #
+      # @see ENV_PARSERS
+      # @see LIBDIRS
+      def lib_dirs = [*TreeSitter::ENV_PARSERS, *TreeSitter::LIBDIRS]
+
+      # Lookup a parser by name.
+      #
+      # Precedence:
+      # 1. `Env['TREE_SITTER_PARSERS]`.
+      # 2. {TreeStand::Config#parser_path} if using {TreeStand}.
+      # 3. {LIBDIRS}.
+      #
+      # If a {TreeStand::Config#parser_path} is `nil`, {LIBDIRS} is used.
+      # If a {TreeStand::Config#parser_path} is a {::Pathname}, {LIBDIRS} is ignored.
+      def search_for_lib(name)
+        files =
+          [name, name.upcase, name.downcase]
+            .uniq
+            .flat_map do |n|
+              base = "#{n}.#{ext}"
+              [base, "tree-sitter-#{base}", "libtree-sitter-#{base}"]
+            end
+
+        lib_dirs
+          .product(files)
+          .find do |dir, so|
+            path = dir / so
+            path = dir / name / so if !path.exist?
+            break path.expand_path if path.exist?
+          end
+      end
+
+      # Generates a string message on where parser lookup happens.
+      #
+      # @return [String] A pretty message.
+      def search_lib_message
+        indent = 2
+        pretty = ->(arr) {
+          if arr
+            arr
+              .compact
+              .map { |v| "#{' ' * indent}#{v.expand_path}" }
+              .join("\n")
+          end
+        }
+        <<~MSG.chomp
+          From ENV['TREE_SITTER_PARSERS']:
+          #{pretty.call(ENV_PARSERS)}
+
+          From Defaults:
+          #{pretty.call(lib_dirs)}
+        MSG
+      end
+    end
+  end
+end