ruby_tree_sitter 1.6.0-x86_64-linux-gnu

data/ext/tree_sitter/query_predicate_step.c

@@ -0,0 +1,83 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cQueryPredicateStep;
+
+const char *done = "Done";
+const char *capture = "capture";
+const char *string = "String";
+
+DATA_WRAP(QueryPredicateStep, query_predicate_step)
+
+VALUE new_query_predicate_step_type(TSQueryPredicateStepType type) {
+  switch (type) {
+  case TSQueryPredicateStepTypeDone:
+    return ID2SYM(rb_intern(done));
+  case TSQueryPredicateStepTypeCapture:
+    return ID2SYM(rb_intern(capture));
+  case TSQueryPredicateStepTypeString:
+    return ID2SYM(rb_intern(string));
+  default:
+    return Qnil;
+  }
+}
+
+static const char *query_predicate_type_string(TSQueryPredicateStepType type) {
+  switch (type) {
+  case TSQueryPredicateStepTypeDone:
+    return done;
+  case TSQueryPredicateStepTypeCapture:
+    return capture;
+  case TSQueryPredicateStepTypeString:
+    return string;
+  default:
+    return "???";
+  }
+}
+
+TSQueryPredicateStepType value_to_query_predicate_step_type(VALUE step_type) {
+  VALUE type = SYM2ID(step_type);
+  VALUE c = rb_const_get_at(cQueryPredicateStep, rb_intern(capture));
+  VALUE s = rb_const_get_at(cQueryPredicateStep, rb_intern(string));
+
+  // NOTE: should we emit a warning instead of defaulting to done?
+  if (type == c) {
+    return TSQueryPredicateStepTypeCapture;
+  } else if (type == s) {
+    return TSQueryPredicateStepTypeString;
+  } else {
+    return TSQueryPredicateStepTypeDone;
+  }
+}
+
+static VALUE query_predicate_step_inspect(VALUE self) {
+  query_predicate_step_t *step = unwrap(self);
+  return rb_sprintf("{value_id=%i, type=%s}", step->data.value_id,
+                    query_predicate_type_string(step->data.type));
+}
+
+DATA_DEFINE_ACCESSOR(query_predicate_step, type, new_query_predicate_step_type,
+                     value_to_query_predicate_step_type)
+DATA_DEFINE_ACCESSOR(query_predicate_step, value_id, UINT2NUM, NUM2UINT)
+
+void init_query_predicate_step(void) {
+  cQueryPredicateStep =
+      rb_define_class_under(mTreeSitter, "QueryPredicateStep", rb_cObject);
+
+  rb_define_alloc_func(cQueryPredicateStep, query_predicate_step_allocate);
+
+  /* Constants */
+  rb_define_const(cQueryPredicateStep, "DONE", ID2SYM(rb_intern(done)));
+  rb_define_const(cQueryPredicateStep, "CAPTURE", ID2SYM(rb_intern(capture)));
+  rb_define_const(cQueryPredicateStep, "STRING", ID2SYM(rb_intern(string)));
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cQueryPredicateStep, query_predicate_step, type)
+  DECLARE_ACCESSOR(cQueryPredicateStep, query_predicate_step, value_id)
+
+  rb_define_method(cQueryPredicateStep, "inspect", query_predicate_step_inspect,
+                   0);
+  rb_define_method(cQueryPredicateStep, "to_s", query_predicate_step_inspect,
+                   0);
+}

data/ext/tree_sitter/range.c

@@ -0,0 +1,35 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cRange;
+
+DATA_WRAP(Range, range)
+DATA_DEFINE_ACCESSOR(range, start_point, new_point_by_val, value_to_point)
+DATA_DEFINE_ACCESSOR(range, end_point, new_point_by_val, value_to_point)
+DATA_DEFINE_ACCESSOR(range, start_byte, UINT2NUM, NUM2UINT)
+DATA_DEFINE_ACCESSOR(range, end_byte, UINT2NUM, NUM2UINT)
+
+static VALUE range_inspect(VALUE self) {
+  range_t *range = unwrap(self);
+  return rb_sprintf("{start_point= %+" PRIsVALUE ", end_point=%+" PRIsVALUE
+                    ", start_byte=%i, end_byte=%i}",
+                    new_point_by_val(range->data.start_point),
+                    new_point_by_val(range->data.end_point),
+                    range->data.start_byte, range->data.end_byte);
+}
+
+void init_range(void) {
+  cRange = rb_define_class_under(mTreeSitter, "Range", rb_cObject);
+
+  rb_define_alloc_func(cRange, range_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cRange, range, start_point)
+  DECLARE_ACCESSOR(cRange, range, end_point)
+  DECLARE_ACCESSOR(cRange, range, start_byte)
+  DECLARE_ACCESSOR(cRange, range, end_byte)
+
+  rb_define_method(cRange, "inspect", range_inspect, 0);
+  rb_define_method(cRange, "to_s", range_inspect, 0);
+}

data/ext/tree_sitter/repo.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../../lib/tree_sitter/version'
+
+module TreeSitter
+  # Fetches tree-sitter sources.
+  class Repo
+    attr_reader :exe, :src, :url, :version
+
+    def initialize
+      @version = TREESITTER_VERSION
+
+      # `tree-sitter-@version` is the name produced by tagged releases of sources
+      # by git, so we use it everywhere, including when cloning from git.
+      @src = Pathname.pwd / "tree-sitter-#{@version}"
+
+      @url = {
+        git: 'https://github.com/tree-sitter/tree-sitter',
+        tar: "https://github.com/tree-sitter/tree-sitter/archive/refs/tags/v#{@version}.tar.gz",
+        zip: "https://github.com/tree-sitter/tree-sitter/archive/refs/tags/v#{@version}.zip",
+      }
+
+      @exe = {}
+      %i[curl git tar wget zip].each do |cmd|
+        @exe[cmd] = find_executable(cmd.to_s)
+      end
+    end
+
+    def compile
+      # We need to clean because the same folder is used over and over
+      # by rake-compiler-dock
+      ar = RbConfig::MAKEFILE_CONFIG['AR']
+      ar = " AR=#{ar}" if ar
+      sh "cd #{src} && make clean &&#{ar} make libtree-sitter.a"
+    end
+
+    def exe?(name)
+      @exe[name]
+    end
+
+    def extract?
+      !exe.filter { |k, v| %i[tar zip].include?(k) && v }.empty?
+    end
+
+    def download
+      # TODO: should we force re-download? Maybe with a flag?
+      return true if Dir.exist? src
+
+      res = false
+      %w[git curl wget].each do |cmd|
+        res =
+          if find_executable(cmd)
+            send("sources_from_#{cmd}")
+          else
+            false
+          end
+        break if res
+      end
+
+      res
+    end
+
+    def include_and_lib_dirs
+      [[(src / 'lib' / 'include').to_s], [src.to_s]]
+    end
+
+    def patch
+      root = Pathname.new(File.expand_path(__dir__)).realpath.parent.parent
+      patch = root / 'patches' / 'cross-compile.patch'
+
+      sh "patch --forward #{src / 'Makefile'} #{patch}"
+    end
+
+    def sh(cmd)
+      return if system(cmd)
+
+      abort <<~MSG
+
+        Failed to run: #{cmd}
+
+        exiting …
+
+      MSG
+    end
+
+    def sources_from_curl
+      return false if !exe?(:curl) || !extract?
+
+      if exe?(:tar)
+        sh "curl -L #{url[:tar]} -o tree-sitter-v#{version}.tar.gz"
+        sh "tar -xf tree-sitter-v#{version}.tar.gz"
+      elsif exe?(:zip)
+        sh "curl -L #{url[:zip]} -o tree-sitter-v#{version}.zip"
+        sh "unzip -q tree-sitter-v#{version}.zip"
+      end
+
+      true
+    end
+
+    def sources_from_git
+      return false if !exe?(:git)
+
+      sh <<~SHELL.chomp
+        mkdir #{src} \\
+        && cd #{src} \\
+        && git init \\
+        && git remote add origin "#{url[:git]}" \\
+        && git fetch origin --depth 1 tags/v#{version} \\
+        && git reset --hard FETCH_HEAD
+      SHELL
+      true
+    end
+
+    def sources_from_wget
+      return false if !exe?(:wget) || !extract?
+
+      if exe?(:tar)
+        sh "wget #{url[:tar]} -O tree-sitter-v#{version}.tar.gz"
+        sh "tar -xf tree-sitter-v#{version}.tar.gz"
+      elsif exe?(:zip)
+        sh "wget #{url[:zip]} -O tree-sitter-v#{version}.zip"
+        sh "unzip -q tree-sitter-v#{version}.zip"
+      end
+
+      true
+    end
+  end
+end

data/ext/tree_sitter/symbol_type.c

@@ -0,0 +1,46 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE mSymbolType;
+
+const char *regular = "regular";
+const char *anonymous = "anonymous";
+const char *auxiliary = "auxiliary";
+
+TSSymbolType value_to_symbol_type(VALUE symbol_type) {
+  VALUE sym = SYM2ID(symbol_type);
+  VALUE anon = rb_const_get_at(mSymbolType, rb_intern(anonymous));
+  VALUE aux = rb_const_get_at(mSymbolType, rb_intern(auxiliary));
+
+  // NOTE: should we emit a warning instead of defaulting to regular?
+  if (sym == anon) {
+    return TSSymbolTypeAnonymous;
+  } else if (sym == aux) {
+    return TSSymbolTypeAuxiliary;
+  } else {
+    return TSSymbolTypeRegular;
+  }
+}
+
+VALUE new_symbol_type(TSSymbolType symbol_type) {
+  switch (symbol_type) {
+  case TSSymbolTypeRegular:
+    return ID2SYM(rb_intern(regular));
+  case TSSymbolTypeAnonymous:
+    return ID2SYM(rb_intern(anonymous));
+  case TSSymbolTypeAuxiliary:
+    return ID2SYM(rb_intern(auxiliary));
+  default:
+    return ID2SYM(rb_intern("this_should_never_get_reached"));
+  }
+}
+
+void init_symbol_type(void) {
+  mSymbolType = rb_define_module_under(mTreeSitter, "SymbolType");
+
+  /* Constants */
+  rb_define_const(mSymbolType, "REGULAR", ID2SYM(rb_intern(regular)));
+  rb_define_const(mSymbolType, "ANONYMOUS", ID2SYM(rb_intern(anonymous)));
+  rb_define_const(mSymbolType, "AUXILIARY", ID2SYM(rb_intern(auxiliary)));
+}

data/ext/tree_sitter/tree.c

@@ -0,0 +1,234 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cTree;
+
+int tree_rc_free(const TSTree *tree) {
+  VALUE ptr = ULONG2NUM((uintptr_t)tree);
+  VALUE rc = rb_cv_get(cTree, "@@rc");
+  VALUE val = rb_hash_lookup(rc, ptr);
+
+  if (!NIL_P(val)) {
+    unsigned int count = NUM2UINT(val);
+    --count;
+    if (count < 1) {
+      rb_hash_delete(rc, ptr);
+      ts_tree_delete((TSTree *)tree);
+      return 1;
+    } else {
+      rb_hash_aset(rc, ptr, ULONG2NUM(count));
+      return 0;
+    }
+  } else {
+    return 1;
+  }
+}
+
+void tree_rc_new(const TSTree *tree) {
+  VALUE ptr = ULONG2NUM((uintptr_t)tree);
+  VALUE rc = rb_cv_get(cTree, "@@rc");
+  VALUE val = rb_hash_lookup(rc, ptr);
+
+  if (NIL_P(val)) {
+    rb_hash_aset(rc, ptr, UINT2NUM(1));
+  } else {
+    rb_hash_aset(rc, ptr, UINT2NUM(NUM2UINT(val) + 1));
+  }
+}
+
+DATA_TYPE(TSTree *, tree)
+static void tree_free(void *ptr) {
+  tree_t *type = (tree_t *)ptr;
+  if (tree_rc_free(type->data)) {
+    xfree(ptr);
+  }
+}
+
+DATA_MEMSIZE(tree)
+DATA_DECLARE_DATA_TYPE(tree)
+DATA_ALLOCATE(tree)
+DATA_UNWRAP(tree)
+
+VALUE new_tree(TSTree *ptr) {
+  if (ptr == NULL) {
+    return Qnil;
+  }
+  VALUE res = tree_allocate(cTree);
+  tree_t *type = unwrap(res);
+  type->data = ptr;
+  tree_rc_new(ptr);
+  return res;
+}
+
+DATA_FROM_VALUE(TSTree *, tree)
+
+/**
+ * Compare an old edited syntax tree to a new syntax tree representing the same
+ * document, returning an array of ranges whose syntactic structure has changed.
+ *
+ * For this to work correctly, the old syntax tree must have been edited such
+ * that its ranges match up to the new tree. Generally, you'll want to call
+ * this function right after calling one of the {Parser#parse} functions.
+ * You need to pass the old tree that was passed to parse, as well as the new
+ * tree that was returned from that function.
+ *
+ * @param old_tree [Tree]
+ * @param new_tree [Tree]
+ *
+ * @return [Array<Range>]
+ */
+static VALUE tree_changed_ranges(VALUE _self, VALUE old_tree, VALUE new_tree) {
+  TSTree *old = unwrap(old_tree)->data;
+  TSTree *new = unwrap(new_tree)->data;
+  uint32_t length;
+  TSRange *ranges = ts_tree_get_changed_ranges(old, new, &length);
+  VALUE res = rb_ary_new_capa(length);
+
+  for (uint32_t i = 0; i < length; i++) {
+    rb_ary_push(res, new_range(&ranges[i]));
+  }
+
+  if (ranges) {
+    free(ranges);
+  }
+
+  return res;
+}
+
+static VALUE tree_finalizer(VALUE _self) {
+  VALUE rc = rb_cv_get(cTree, "@@rc");
+  VALUE keys = rb_funcall(rc, rb_intern("keys"), 0);
+  long len = RARRAY_LEN(keys);
+
+  for (long i = 0; i < len; ++i) {
+    VALUE curr = RARRAY_AREF(keys, i);
+    unsigned int val = NUM2UINT(rb_hash_lookup(rc, curr));
+    if (val > 0) {
+      ts_tree_delete((TSTree *)NUM2ULONG(curr));
+    }
+
+    rb_hash_delete(rc, curr);
+  }
+
+  return Qnil;
+}
+
+/**
+ * Create a shallow copy of the syntax tree. This is very fast.
+ *
+ * You need to copy a syntax tree in order to use it on more than one thread at
+ * a time, as syntax trees are not thread safe.
+ *
+ * @return [Tree]
+ */
+static VALUE tree_copy(VALUE self) { return new_tree(ts_tree_copy(SELF)); }
+
+/**
+ * Edit the syntax tree to keep it in sync with source code that has been
+ * edited.
+ *
+ * You must describe the edit both in terms of byte offsets and in terms of
+ * (row, column) coordinates.
+ *
+ * @param edit [InputEdit]
+ *
+ * @return [nil]
+ */
+static VALUE tree_edit(VALUE self, VALUE edit) {
+  TSInputEdit in = value_to_input_edit(edit);
+  ts_tree_edit(SELF, &in);
+  return Qnil;
+}
+
+/**
+ * Get the array of included ranges that was used to parse the syntax tree.
+ *
+ * @return [Array<Range>]
+ */
+static VALUE included_ranges(VALUE self) {
+  uint32_t length;
+  const TSRange *ranges = ts_tree_included_ranges(SELF, &length);
+  VALUE res = rb_ary_new_capa(length);
+  for (uint32_t i = 0; i < length; i++) {
+    rb_ary_push(res, new_range(&ranges[i]));
+  }
+  return res;
+}
+
+/**
+ * Get the language that was used to parse the syntax tree.
+ *
+ * @return [Language]
+ */
+static VALUE tree_language(VALUE self) {
+  return new_language(ts_tree_language(SELF));
+}
+
+/**
+ * Write a DOT graph describing the syntax tree to the given file.
+ *
+ * @param file [String]
+ *
+ * @return [nil]
+ */
+static VALUE tree_print_dot_graph(VALUE self, VALUE file) {
+  Check_Type(file, T_STRING);
+  char *path = StringValueCStr(file);
+  int fd = open(path, O_CREAT | O_WRONLY | O_TRUNC,
+                S_IWUSR | S_IRUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+  if (fd < 0) {
+    rb_raise(rb_eRuntimeError, "Could not open file `%s'.\nReason:\n%s", path,
+             strerror(fd));
+    return Qnil;
+  }
+  ts_tree_print_dot_graph(SELF, fd);
+  close(fd);
+  return Qnil;
+}
+
+/**
+ * Get the root node of the syntax tree.
+ *
+ * @return [Node]
+ */
+static VALUE tree_root_node(VALUE self) {
+  return new_node_by_val(ts_tree_root_node(SELF));
+}
+
+/**
+ * Get the root node of the syntax tree, but with its position
+ * shifted forward by the given offset.
+ *
+ * @return [Node]
+ */
+static VALUE tree_root_node_with_offset(VALUE self, VALUE offset_bytes,
+                                        VALUE offset_extent) {
+  uint32_t bytes = NUM2UINT(offset_bytes);
+  TSPoint extent = value_to_point(offset_extent);
+  return new_node_by_val(ts_tree_root_node_with_offset(SELF, bytes, extent));
+}
+
+void init_tree(void) {
+  cTree = rb_define_class_under(mTreeSitter, "Tree", rb_cObject);
+
+  rb_undef_alloc_func(cTree);
+
+  /* Module methods */
+  rb_define_module_function(cTree, "changed_ranges", tree_changed_ranges, 2);
+  rb_define_module_function(cTree, "finalizer", tree_finalizer, 0);
+
+  /* Class methods */
+  rb_define_method(cTree, "copy", tree_copy, 0);
+  rb_define_method(cTree, "edit", tree_edit, 1);
+  rb_define_method(cTree, "included_ranges", included_ranges, 0);
+  rb_define_method(cTree, "language", tree_language, 0);
+  rb_define_method(cTree, "print_dot_graph", tree_print_dot_graph, 1);
+  rb_define_method(cTree, "root_node", tree_root_node, 0);
+  rb_define_method(cTree, "root_node_with_offset", tree_root_node_with_offset,
+                   2);
+
+  // Reference-count created trees
+  VALUE rc = rb_hash_new();
+  rb_cv_set(cTree, "@@rc", rc);
+}