ruby_tree_sitter 0.20.6.3-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66f3c718ba1bb03d6db4b418d6ca9e6fa11a071f2d07379497d57298b57415c2
+  data.tar.gz: e25e0f44fc08cfacdc5f6aced98a26b127294726a835a41a605996189f5d317e
+SHA512:
+  metadata.gz: 628079b69ee0279679074bf76b8be2d179aa0fb0f419e306dce7472450389a6106ff049767a4d7a8b3ac756b458b0bc5cb0afb7658b740160cb2be29b1473dc9
+  data.tar.gz: aba7b46de4bc19d453cac906ca7784b4be2ba6a9482d6061e7a1ff15b86ca6a80173931c0f9ebc655785fd8e7ffd4f149a9e5d10cf5db499ff7a045dd70f90f8

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018-2021 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), 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 "AS IS", 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.

data/README.md

@@ -0,0 +1,152 @@
+# Ruby tree-sitter bindings
+
+[![ci](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/ci.yml/badge.svg)](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/ci.yml) [![valgrind](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/valgrind.yml/badge.svg)](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/valgrind.yml) [![asan/ubsan](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/asan.yml/badge.svg)](https://github.com/Faveod/ruby-tree-sitter/actions/workflows/asan.yml)
+
+Ruby bindings for [tree-sitter](https://github.com/tree-sitter/tree-sitter).
+
+The [official bindings](https://github.com/tree-sitter/ruby-tree-sitter) are
+very old, unmaintained, and don't work with modern `tree-sitter` APIs.
+
+
+## Usage
+
+``` ruby
+require 'tree_sitter'
+
+parser = TreeSitter::Parser.new
+language = TreeSitter::Language.load('javascript', 'path/to/libtree-sitter-javascript.{so,dylib}')
+
+src = "[1, null]"
+
+parser.language = language
+
+tree = parser.parse_string(nil, src)
+root = tree.root_node
+
+root.each do |child|
+  # ...
+end
+```
+
+## About
+
+The main philosophy behind these bindings is to do a 1:1 mapping between
+tree-sitter's `C` API and `Ruby`.
+
+It doesn't mean that we're going to yield the best perormance, but this design
+allows us to better experiment, and easily port ideas from other projects.
+
+### Versioning
+
+This gem follows the `tree-sitter` versioning scheme, and appends its own
+version at the end.
+
+For instance, `tree-sitter` is now at version `0.20.6`, so this gem's version
+will be `0.20.6.x` where x is incremented with every notable batch of
+bugfixes or some ruby-only additions.
+
+## Dependencies
+
+This gem is a binding for `tree-sitter`.  It doesn't have a version of
+`tree-sitter` baked in it.
+
+You must install `tree-sitter` and make sure that their dynamic library is
+accessible from `$PATH`, or build the gem with `--disable-sys-libs`, which will
+download the latest tagged `tree-sitter` and build against it (see [Build from
+source](docs/Development.md#build-from-source) .)
+
+You can either install `tree-sitter` from source or through your go-to package manager.
+
+### Linux
+
+`ubuntu >= 22.04`
+
+```console
+sudo apt install libtree-sitter-dev
+```
+
+`arch`
+
+```console
+sudo pacman -S tree-sitter
+```
+
+### MacOS
+
+```console
+sudo port install tree-sitter
+```
+
+or
+
+```console
+brew install tree-sitter
+```
+
+## Install
+
+We haven't released the gem on `Rubygems` as of yet, but we'e planning on doing so.
+
+Meanwhile, please install from `git` source, which will compile on installation.
+
+If you don't want to install from `git`, or if you don't want to compile on
+install, download a native gem from this repository's
+[releases](https://github.com/Faveod/ruby-tree-sitter/releases), or you can
+compile it yourself (see [Build from
+source](docs/Development.md#build-from-source) .)
+
+### Gemfile
+
+```ruby
+gem 'tree_sitter', git: 'https://github.com/Faveod/ruby-tree-sitter'
+```
+
+If you chose to install a native gem, then you'd have to download it somewhere
+and then specify `path` as such:
+
+``` ruby
+gem 'tree_sitter', path: 'path/to/native/tree_sitter.gem'
+```
+
+### Parsers
+
+You will have to install parsers yourself, either by:
+
+1. Downloading and building from source.
+1. Downloading from your package manager, if available.
+1. Downloading a pre-built binary from
+   [Faveod/tree-sitter-parsers](https://github.com/Faveod/tree-sitter-parsers)
+   which supports numerous architectures.
+
+## Examples
+
+See `examples` directory.
+
+## Development
+
+See [`docs/README.md`](docs/Development.md).
+
+## 🚧 👷‍♀️ Notes 👷 🚧
+
+Since we're doing a 1:1 mapping between the `tree-sitter` API and the bindings,
+you need to be extra-careful when playing with the provided objects.  Some of
+them have their underlying `C` data-structure automatically freed, so you might
+get yourself in undesirable situations if you don't pay attention to what you're
+doing.
+
+We're only talking about `Tree`, `TreeCursor`, `Query`, and `QueryCursor`.  Just
+don't copy them left and right, and then expect them to work without
+`SEGFAULT`ing and creating a black-hole in your living-room.  Assume that you
+have to work locally with them. If you get a `SEGFAULT`, you can debug the
+native `C` code using `gdb`.  You can read more on `SEGFAULT`s
+[here](docs/SIGSEGV.md), and debugging [here](docs/Development.md#Debugging).
+
+That said, we do aim at providing an idiomatic `Ruby` interface.  It should also
+provide a _safer_ interface, where you don't have to worry about when and how
+resources are freed.
+
+To See a full list of the ruby-specific APIs, see [here](lib/README.md).
+
+## Sponsors
+
+<img src="img/faveod.jpg" width="75%">

data/ext/tree_sitter/encoding.c

@@ -0,0 +1,29 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE mEncoding;
+
+const char *utf8 = "utf8";
+const char *utf16 = "utf16";
+
+TSInputEncoding value_to_encoding(VALUE encoding) {
+  VALUE enc = SYM2ID(encoding);
+  /* VALUE u8 = rb_const_get_at(mEncoding, rb_intern(utf8)); */
+  VALUE u16 = SYM2ID(rb_const_get_at(mEncoding, rb_intern("UTF16")));
+
+  // NOTE: should we emit a warning instead of defaulting to UTF8?
+  if (enc == u16) {
+    return TSInputEncodingUTF16;
+  } else {
+    return TSInputEncodingUTF8;
+  }
+}
+
+void init_encoding(void) {
+  mEncoding = rb_define_module_under(mTreeSitter, "Encoding");
+
+  /* Constants */
+  rb_define_const(mEncoding, "UTF8", ID2SYM(rb_intern(utf8)));
+  rb_define_const(mEncoding, "UTF16", ID2SYM(rb_intern(utf16)));
+}

data/ext/tree_sitter/extconf.rb

@@ -0,0 +1,172 @@
+require 'mkmf'
+require 'pathname'
+
+# ################################## #
+#             Some helpers           #
+# ################################## #
+
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+cflags = []
+ldflags = []
+
+def system_tree_sitter?
+  enable_config('sys-libs', true)
+end
+
+def sh cmd
+  if !system(cmd)
+    abort <<~MSG
+
+      Failed to run: #{cmd}
+
+      exiting…
+
+    MSG
+  end
+end
+
+def env_var_on?(var)
+  %w[1 on true t yes y].include?(ENV.fetch(var, '').downcase)
+end
+
+# ################################## #
+#            System lib              #
+#                                    #
+#                OR                  #
+#                                    #
+#          Downloaded libs           #
+# ################################## #
+
+dir_include, dir_lib =
+  if system_tree_sitter?
+    [['/opt/include', '/opt/local/include', '/usr/include', '/usr/local/include'],
+     ['/opt/lib', '/opt/local/lib', '/usr/lib', '/usr/local/lib']]
+  else
+    src = Pathname.pwd / "tree-sitter-#{TreeSitter::VERSION}"
+    if !Dir.exist? src
+      if find_executable('git')
+        sh "git clone https://github.com/tree-sitter/tree-sitter #{src}"
+        sh "cd #{src} && git checkout tags/v#{TreeSitter::VERSION}"
+      elsif find_executable('curl')
+        if find_executable('tar')
+          sh "curl -L https://github.com/tree-sitter/tree-sitter/archive/refs/tags/v#{TreeSitter::VERSION}.tar.gz -o tree-sitter-v#{TreeSitter::VERSION}.tar.gz"
+          sh "tar -xf tree-sitter-v#{TreeSitter::VERSION}.tar.gz"
+        elsif find_executable('zip')
+          sh "curl -L https://github.com/tree-sitter/tree-sitter/archive/refs/tags/v#{TreeSitter::VERSION}.zip -o tree-sitter-v#{TreeSitter::VERSION}.zip"
+          sh "unzip -q tree-sitter-v#{TreeSitter::VERSION}.zip"
+        else
+          abort('Could not find `tar` or `zip` (and `git` was not found!)')
+        end
+      else
+        abort('Could not find `git` or `curl` to download tree-sitter and build from sources.')
+      end
+    end
+
+    # We need to make sure we're selecting the proper toolchain.
+    # Especially needed for corss-compilation.
+    ENV.store('CC', RbConfig::CONFIG['CC'])
+    # We need to clean because the same folder is used over and over
+    # by rake-compiler-dock
+    sh "cd #{src} && make clean && make"
+
+    [[src / 'lib' / 'include'], [src.to_s]]
+  end
+
+# ################################## #
+#          Generate Makefile         #
+# ################################## #
+
+header = find_header('tree_sitter/api.h', *dir_include)
+
+library = find_library('tree-sitter',   # libtree-sitter
+                       'ts_parser_new', # a symbol
+                       *dir_lib)
+
+if !header || !library
+  abort <<~MSG
+
+    * Missing header         : #{header ? 'no' : 'yes'}
+    * Missing lib            : #{library ? 'no' : 'yes'}
+    * Use system tree-sitter : #{system_tree_sitter?}
+
+    Try to install tree-sitter from source, or through your package manager,
+    or even try one of the following options to extconf.rb/rake compile:
+
+      --with-tree-sitter-dir=/path/to/tree-sitter
+      --with-tree-sitter-lib=/path/to/tree-sitter/lib
+      --with-tree-sitter-include=/path/to/tree-sitter/include
+
+  MSG
+end
+
+if env_var_on?('TREE_SITTER_PEDANTIC')
+  cflags << '-Werror'
+end
+
+if env_var_on?('DEBUG')
+  cflags << '-fbounds-check'
+  CONFIG['optflags'].gsub!(/-O\d/, '-O0')
+else
+  cflags << '-DNDEBUG'
+  CONFIG['optflags'].gsub!(/-O\d/, '-O3')
+end
+
+sanitizers = ENV.fetch('SANITIZE', nil)
+
+if sanitizers =~ /memory/
+  puts <<~MSG
+
+    We do not support memory sanitizers as of yet.
+    It requires building ruby with the same sanitizer, and maybe its dependencies.
+
+    exiting…
+
+  MSG
+  exit 1
+end
+
+if sanitizers
+  # NOTE: when sanitizing, the default generated warning flags emit a lot of …
+  # warnings.
+  #
+  # I couldn't make mkmf understand it's running with clang and not gcc, so
+  # I'm omitting the warning generating warnings.
+  #
+  # It should be harmless, since sanitization is meant for CI and dev builds.
+  %w[
+    -Wduplicated-cond
+    -Wimplicit-fallthrough=\d+
+    -Wno-cast-function-type
+    -Wno-packed-bitfield-compat
+    -Wsuggest-attribute=\w+
+  ].each do |r|
+    $warnflags.gsub!(/#{r}/, '')
+  end
+
+  cflags.concat %W[
+    -fms-extensions
+    -fdeclspec
+    -fsanitize=#{sanitizers}
+    -fsanitize-blacklist=../../../../.asanignore
+    -fsanitize-recover=#{sanitizers}
+    -fno-sanitize-recover=all
+    -fno-sanitize=null
+    -fno-sanitize=alignment
+    -fno-omit-frame-pointer
+  ]
+
+  ldflags.concat %W[
+    -fsanitize=#{sanitizers}
+    -dynamic-libasan
+  ]
+end
+
+cflags.concat %w[-std=c99 -fPIC -Wall]
+
+append_cflags(cflags)
+append_ldflags(ldflags)
+
+dir_config('tree-sitter')
+create_header
+create_makefile('tree_sitter/tree_sitter')

data/ext/tree_sitter/input.c

@@ -0,0 +1,126 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cInput;
+
+typedef struct {
+  TSInput data;
+  VALUE payload;
+  VALUE last_result;
+} input_t;
+
+const char *input_read(void *payload, uint32_t byte_index, TSPoint position,
+                       uint32_t *bytes_read) {
+  input_t *input = (input_t *)payload;
+  VALUE read = rb_funcall(input->payload, rb_intern("read"), 2,
+                          UINT2NUM(byte_index), new_point(&position));
+  if (NIL_P(read)) {
+    *bytes_read = 0;
+    input->last_result = Qnil;
+    return NULL;
+  }
+
+  VALUE size = rb_funcall(read, rb_intern("bytesize"), 0);
+  *bytes_read = NUM2UINT(size);
+  input->last_result = rb_funcall(read, rb_intern("to_str"), 0);
+
+  return StringValueCStr(input->last_result);
+}
+
+static void input_payload_set(input_t *input, VALUE value) {
+  input->payload = value;
+  input->last_result = Qnil;
+  input->data.payload = (void *)input;
+  input->data.read = input_read;
+}
+
+static void input_free(void *ptr) { xfree(ptr); }
+
+static size_t input_memsize(const void *ptr) {
+  input_t *type = (input_t *)ptr;
+  return sizeof(type);
+}
+
+static void input_mark(void *ptr) {
+  input_t *input = (input_t *)ptr;
+  rb_gc_mark_movable(input->payload);
+  // we don't want last_result to move because its const char* content will be
+  // consumed by the parser.
+  //
+  // No funny things please.
+  rb_gc_mark(input->last_result);
+}
+
+static void input_compact(void *ptr) {
+  input_t *input = (input_t *)ptr;
+  input->payload = rb_gc_location(input->payload);
+}
+
+const rb_data_type_t input_data_type = {
+    .wrap_struct_name = "input",
+    .function =
+        {
+            .dmark = input_mark,
+            .dfree = input_free,
+            .dsize = input_memsize,
+            .dcompact = input_compact,
+        },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+DATA_UNWRAP(input)
+
+static VALUE input_allocate(VALUE klass) {
+  input_t *input;
+  return TypedData_Make_Struct(klass, input_t, &input_data_type, input);
+}
+
+TSInput value_to_input(VALUE self) { return SELF; }
+
+VALUE new_input(const TSInput *ptr) {
+  if (ptr != NULL) {
+    VALUE res = input_allocate(cInput);
+    input_t *input = unwrap(res);
+    VALUE payload = Qnil;
+    if (ptr->payload != NULL) {
+      input_t *old_input = (input_t *)ptr->payload;
+      payload = old_input->payload;
+    }
+    input_payload_set(input, payload);
+    return res;
+  } else {
+    return Qnil;
+  }
+}
+
+static VALUE input_initialize(int argc, VALUE *argv, VALUE self) {
+  input_t *input = unwrap(self);
+  VALUE payload;
+  rb_scan_args(argc, argv, "01", &payload);
+  input_payload_set(input, payload);
+  return self;
+}
+
+static VALUE input_inspect(VALUE self) {
+  return rb_sprintf("{payload=%+" PRIsVALUE "}", unwrap(self)->payload);
+}
+
+DEFINE_GETTER(input, payload)
+
+static VALUE input_set_payload(VALUE self, VALUE payload) {
+  input_payload_set(unwrap(self), payload);
+  return Qnil;
+}
+
+void init_input(void) {
+  cInput = rb_define_class_under(mTreeSitter, "Input", rb_cObject);
+
+  rb_define_alloc_func(cInput, input_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cInput, input, payload)
+  rb_define_method(cInput, "initialize", input_initialize, -1);
+  rb_define_method(cInput, "inspect", input_inspect, 0);
+  rb_define_method(cInput, "to_s", input_inspect, 0);
+}

data/ext/tree_sitter/input_edit.c

@@ -0,0 +1,42 @@
+#include "tree_sitter.h"
+
+extern VALUE mTreeSitter;
+
+VALUE cInputEdit;
+
+DATA_WRAP(InputEdit, input_edit)
+DATA_DEFINE_ACCESSOR(input_edit, start_byte, UINT2NUM, NUM2UINT)
+DATA_DEFINE_ACCESSOR(input_edit, old_end_byte, UINT2NUM, NUM2UINT)
+DATA_DEFINE_ACCESSOR(input_edit, new_end_byte, UINT2NUM, NUM2UINT)
+DATA_DEFINE_ACCESSOR(input_edit, start_point, new_point_by_val, value_to_point)
+DATA_DEFINE_ACCESSOR(input_edit, old_end_point, new_point_by_val, value_to_point)
+DATA_DEFINE_ACCESSOR(input_edit, new_end_point, new_point_by_val, value_to_point)
+
+static VALUE input_edit_inspect(VALUE self) {
+  input_edit_t *input_edit = unwrap(self);
+  return rb_sprintf("{start_byte=%i, old_end_byte=%i , new_end_byte=%i, "
+                    "start_point=%+" PRIsVALUE ", old_end_point=%+" PRIsVALUE
+                    ", new_end_point=%+" PRIsVALUE "}",
+                    input_edit->data.start_byte, input_edit->data.old_end_byte,
+                    input_edit->data.new_end_byte,
+                    new_point_by_val(input_edit->data.start_point),
+                    new_point_by_val(input_edit->data.old_end_point),
+                    new_point_by_val(input_edit->data.new_end_point));
+}
+
+void init_input_edit(void) {
+  cInputEdit = rb_define_class_under(mTreeSitter, "InputEdit", rb_cObject);
+
+  rb_define_alloc_func(cInputEdit, input_edit_allocate);
+
+  /* Class methods */
+  DECLARE_ACCESSOR(cInputEdit, input_edit, start_byte)
+  DECLARE_ACCESSOR(cInputEdit, input_edit, old_end_byte)
+  DECLARE_ACCESSOR(cInputEdit, input_edit, new_end_byte)
+  DECLARE_ACCESSOR(cInputEdit, input_edit, start_point)
+  DECLARE_ACCESSOR(cInputEdit, input_edit, old_end_point)
+  DECLARE_ACCESSOR(cInputEdit, input_edit, new_end_point)
+
+  rb_define_method(cInputEdit, "inspect", input_edit_inspect, 0);
+  rb_define_method(cInputEdit, "to_s", input_edit_inspect, 0);
+}

data/ext/tree_sitter/language.c

@@ -0,0 +1,134 @@
+#include "tree_sitter.h"
+#include <dlfcn.h>
+#include <stdint.h>
+#include <stdio.h>
+
+typedef TSLanguage *(tree_sitter_lang)(void);
+const char *tree_sitter_prefix = "tree_sitter_";
+
+extern VALUE mTreeSitter;
+
+VALUE cLanguage;
+
+DATA_TYPE(TSLanguage *, language)
+DATA_FREE(language)
+DATA_MEMSIZE(language)
+DATA_DECLARE_DATA_TYPE(language)
+DATA_ALLOCATE(language)
+DATA_UNWRAP(language)
+
+TSLanguage *value_to_language(VALUE self) { return SELF; }
+
+VALUE new_language(const TSLanguage *language) {
+  VALUE res = language_allocate(cLanguage);
+  unwrap(res)->data = (TSLanguage *)language;
+  return res;
+}
+
+static VALUE language_symbol_count(VALUE self) {
+  return UINT2NUM(ts_language_symbol_count(SELF));
+}
+
+static VALUE language_symbol_name(VALUE self, VALUE symbol) {
+  return safe_str(ts_language_symbol_name(SELF, NUM2UINT(symbol)));
+}
+
+static VALUE language_symbol_for_name(VALUE self, VALUE string,
+                                      VALUE is_named) {
+  const char *str = rb_id2name(SYM2ID(string));
+  uint32_t length = (uint32_t)strlen(str);
+  bool named = RTEST(is_named);
+  return UINT2NUM(ts_language_symbol_for_name(SELF, str, length, named));
+}
+
+static VALUE language_field_count(VALUE self) {
+  return UINT2NUM(ts_language_field_count(SELF));
+}
+
+static VALUE language_field_name_for_id(VALUE self, VALUE field_id) {
+  return safe_str(ts_language_field_name_for_id(SELF, NUM2UINT(field_id)));
+}
+
+static VALUE language_field_id_for_name(VALUE self, VALUE name) {
+  TSLanguage *language = SELF;
+  const char *str = StringValuePtr(name);
+  uint32_t length = (uint32_t)RSTRING_LEN(name);
+  return UINT2NUM(ts_language_field_id_for_name(language, str, length));
+}
+
+static VALUE language_symbol_type(VALUE self, VALUE symbol) {
+  return new_symbol_type(ts_language_symbol_type(SELF, NUM2UINT(symbol)));
+}
+
+static VALUE language_version(VALUE self) {
+  return UINT2NUM(ts_language_version(SELF));
+}
+
+static VALUE language_load(VALUE self, VALUE name, VALUE path) {
+  VALUE path_s = rb_funcall(path, rb_intern("to_s"), 0);
+  char *path_cstr = StringValueCStr(path_s);
+  void *lib = dlopen(path_cstr, RTLD_NOW);
+  const char *err = dlerror();
+  if (err != NULL) {
+    rb_raise(rb_eRuntimeError,
+             "Could not load shared library `%s'.\nReason: %s", path_cstr, err);
+  }
+
+  char buf[256];
+  snprintf(buf, sizeof(buf), "tree_sitter_%s", StringValueCStr(name));
+  tree_sitter_lang *make_ts_language = dlsym(lib, buf);
+  err = dlerror();
+  if (err != NULL) {
+    dlclose(lib);
+    rb_raise(rb_eRuntimeError,
+             "Could not load symbol `%s' from library `%s'.\nReason:%s",
+             StringValueCStr(name), StringValueCStr(path), err);
+  }
+
+  TSLanguage *lang = make_ts_language();
+  if (lang == NULL) {
+    dlclose(lib);
+    rb_raise(rb_eRuntimeError,
+             "TSLanguage = NULL for language `%s' in library `%s'.\nCall your "
+             "local TSLanguage supplier.",
+             StringValueCStr(name), StringValueCStr(path));
+  }
+
+  uint32_t version = ts_language_version(lang);
+  if (version < TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION) {
+    rb_raise(rb_eRuntimeError,
+             "Language %s (v%d) from `%s' is old.\nMinimum supported ABI: "
+             "v%d.\nCurrent ABI: v%d.",
+             StringValueCStr(name), version, StringValueCStr(path),
+             TREE_SITTER_MIN_COMPATIBLE_LANGUAGE_VERSION,
+             TREE_SITTER_LANGUAGE_VERSION);
+  }
+
+  return new_language(lang);
+}
+
+static VALUE language_equal(VALUE self, VALUE other) {
+  TSLanguage *this = SELF;
+  TSLanguage *that = unwrap(other)->data;
+  return this == that ? Qtrue : Qfalse;
+}
+
+void init_language(void) {
+  cLanguage = rb_define_class_under(mTreeSitter, "Language", rb_cObject);
+
+  rb_define_alloc_func(cLanguage, language_allocate);
+
+  /* Class methods */
+  rb_define_method(cLanguage, "symbol_count", language_symbol_count, 0);
+  rb_define_method(cLanguage, "symbol_name", language_symbol_name, 1);
+  rb_define_method(cLanguage, "symbol_for_name", language_symbol_for_name, 2);
+  rb_define_method(cLanguage, "field_count", language_field_count, 0);
+  rb_define_method(cLanguage, "field_name_for_id", language_field_name_for_id,
+                   1);
+  rb_define_method(cLanguage, "field_id_for_name", language_field_id_for_name,
+                   1);
+  rb_define_method(cLanguage, "symbol_type", language_symbol_type, 1);
+  rb_define_method(cLanguage, "version", language_version, 0);
+  rb_define_module_function(cLanguage, "load", language_load, 2);
+  rb_define_method(cLanguage, "==", language_equal, 1);
+}