ruby_tree_sitter 0.20.6.3-x86_64-linux

data/lib/tree_sitter/node.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  class Node
+    def fields
+      return @fields if @fields
+
+      @fields = Set.new
+      child_count.times do |i|
+        name = field_name_for_child(i)
+        @fields << name.to_sym if name
+      end
+
+      @fields
+    end
+
+    def field?(field)
+      fields.include?(field)
+    end
+
+    # Access node's named children.
+    #
+    # It's similar to {#fetch}, but differes in input type, return values, and
+    # the internal implementation.
+    #
+    # Both of these methods exist for separate use cases, but also because
+    # sometime tree-sitter does some monkey business and having both separate
+    # implementations can help.
+    #
+    # Comparison with {#fetch}:
+    #
+    #              []                            | fetch
+    #              ------------------------------+----------------------
+    # input types  Integer, String, Symbol       | Array<String, Symbol>
+    #              Array<Integer, String, Symbol>|
+    #              ------------------------------+----------------------
+    # returns      1-to-1 correspondance with    | unique nodes
+    #              input                         |
+    #              ------------------------------+----------------------
+    # uses         named_child                   | field_name_for_child
+    #              child_by_field_name           |   via each_node
+    #              ------------------------------+----------------------
+    #
+    # @param keys [Integer | String | Symbol | Array<Integer, String, Symbol>, #read]
+    #
+    # @return [Node | Array<Node>]
+    def [](*keys)
+      case keys.length
+      when 0 then raise "#{self.class.name}##{__method__} requires a key."
+      when 1
+        case k = keys.first
+        when Numeric        then named_child(k)
+        when String, Symbol
+          if fields.include?(k.to_sym)
+            child_by_field_name(k.to_s)
+          else
+            raise "Cannot find field #{k}"
+          end
+        else raise <<~ERR
+          #{self.class.name}##{__method__} accepts Integer and returns named child at given index,
+              or a (String | Symbol) and returns the child by given field name.
+        ERR
+        end
+      else
+        keys.map { |key| self[key] }
+      end
+    end
+
+    # Allows access to child_by_field_name without using [].
+    def method_missing(method_name, *_args, &_block)
+      if fields.include?(method_name)
+        child_by_field_name(method_name.to_s)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(*args)
+      init_fields
+      args.length == 1 && fields.include?(args[0])
+    end
+
+    # Iterate over a node's children.
+    #
+    # @yieldparam child [Node] the child
+    def each
+      return enum_for __method__ if !block_given?
+
+      (0...(child_count)).each do |i|
+        yield child(i)
+      end
+    end
+
+    # Iterate over a node's children assigned to a field.
+    #
+    # @yieldparam name [NilClass | String] field name.
+    # @yieldparam child [Node] the child.
+    def each_field
+      return enum_for __method__ if !block_given?
+
+      each.with_index do |c, i|
+        f = field_name_for_child(i)
+        next if f.nil? || f.empty?
+
+        yield f, c
+      end
+    end
+
+    # Iterate over a node's named children
+    #
+    # @yieldparam child [Node] the child
+    def each_named
+      return enum_for __method__ if !block_given?
+
+      (0...(named_child_count)).each do |i|
+        yield named_child(i)
+      end
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    # Access node's named children.
+    #
+    # It's similar to {#fetch}, but differes in input type, return values, and
+    # the internal implementation.
+    #
+    # Both of these methods exist for separate use cases, but also because
+    # sometime tree-sitter does some monkey business and having both separate
+    # implementations can help.
+    #
+    # Comparison with {#fetch}:
+    #
+    #              []                            | fetch
+    #              ------------------------------+----------------------
+    # input types  Integer, String, Symbol       | String, Symbol
+    #              Array<Integer, String, Symbol>| Array<String, Symbol>
+    #              ------------------------------+----------------------
+    # returns      1-to-1 correspondance with    | unique nodes
+    #              input                         |
+    #              ------------------------------+----------------------
+    # uses         named_child                   | field_name_for_child
+    #              child_by_field_name           |   via each_node
+    #              ------------------------------+----------------------
+    def fetch(*keys)
+      dict = {}
+      keys.each.with_index do |k, i|
+        dict[k.to_s] = i
+      end
+
+      res = {}
+      each_field do |f, c|
+        if dict.key?(f)
+          res[dict[f]] = c
+          dict.delete(f)
+        end
+        break if dict.empty?
+      end
+
+      res.sort.map { |_, v| v }
+    end
+  end
+end

data/lib/tree_sitter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  VERSION = '0.20.6.3'
+end

data/lib/tree_sitter.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TreeSitter
+end
+
+require 'set'
+
+require 'tree_sitter/version'
+
+require 'tree_sitter/tree_sitter'
+require 'tree_sitter/node'
+
+ObjectSpace.define_finalizer(TreeSitter::Tree.class, proc { TreeSitter::Tree.finalizer })

data/test/README.md

@@ -0,0 +1,15 @@
+# Unit testing
+
+Since we don't have languages bundled in ruby gems, we have to load the dynamic
+libraries from disk.
+
+We're using the `bin/get` scripts to do so.
+
+Since not all languages have a Makefile in their root dir, and we don't want to
+mess with copying Makefiles, we're going to rely on languages that do have a
+Makefile in their root.
+
+So for the time being we're sticking with `ruby`.
+
+We might need to change this strategy in the future if we're to test some
+multilang parsing.

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+at_exit { GC.start }
+
+require 'minitest/autorun'
+require 'minitest/color'
+require 'tree_sitter'
+
+require_relative '../examples/helpers'

data/test/tree_sitter/language_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+ruby = TreeSitter.lang('ruby')
+parser = TreeSitter::Parser.new
+parser.language = ruby
+
+program = <<~RUBY
+  def mul(a, b)
+    res = a * b
+    puts res.inspect
+    return res
+  end
+RUBY
+
+tree = parser.parse_string(nil, program)
+root = tree.root_node
+
+# NOTE: one should be weary of testing with data structures that are owned by
+# parsers.   They are not reliable and we should expect them to break when these
+# parsers evolve.
+
+describe 'language' do
+  it 'must be able to load a library from `Pathname` (or any object that has `to_s`)' do
+    path =
+      if p = ENV.fetch('TREE_SITTER_PARSERS', nil)
+        Pathname(p) / "libtree-sitter-ruby.#{TreeSitter.ext}"
+      else
+        Pathname('tree-sitter-parsers') / 'ruby' / "libtree-sitter-ruby.#{TreeSitter.ext}"
+      end
+    ll = TreeSitter::Language.load('ruby', path)
+    assert ll.field_count.positive?
+  end
+
+  it 'must return symbol count' do
+    assert ruby.symbol_count.positive?
+  end
+
+  it 'must return symbol name' do
+    assert_equal 'end', ruby.symbol_name(0)
+  end
+
+  it 'must return symbol id for string name' do
+    assert ruby.symbol_for_name(root.type, root.named?).positive?
+  end
+
+  it 'must return field count' do
+    assert ruby.field_count.positive?
+  end
+
+  it 'must return field name for id' do
+    assert_equal 'alias', ruby.field_name_for_id(1)
+  end
+
+  it 'must return field name for id' do
+    assert_equal 1, ruby.field_id_for_name('alias')
+  end
+
+  it 'must return field symbol type' do
+    assert_equal TreeSitter::SymbolType::AUXILIARY, ruby.symbol_type(0)
+  end
+
+  it 'must be of correct version' do
+    assert ruby.version <= TreeSitter::LANGUAGE_VERSION \
+           && ruby.version >= TreeSitter::MIN_COMPATIBLE_LANGUAGE_VERSION
+  end
+end

data/test/tree_sitter/logger_test.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'stringio'
+
+ruby = TreeSitter.lang('ruby')
+parser = TreeSitter::Parser.new
+parser.language = ruby
+
+program = <<~RUBY
+  def mul(a, b)
+    res = a * b
+    puts res.inspect
+    return res
+  end
+RUBY
+
+# Use with fork.
+#
+# Minitest on ruby 2.7 was failing sometimes for no particular reason,
+# complaining about some random number not having a `write` method.
+#
+# My assumption is that the global var $stderr is not playing nice when
+# we try to replace it and other minitest stuff are going alongside.
+#
+# If this theory holds, then forking should solve any race conditions that
+# minitest could introduce. Let's wait and see.
+def capture_stderr
+  # The output stream must be an IO-like object. In this case we capture it in
+  # an in-memory IO object so we can return the string value. You can assign any
+  # IO object here.
+  previous_stderr = $stderr
+  $stderr = StringIO.new
+  yield
+  $stderr.string
+ensure
+  # Restore the previous value of stderr (typically equal to STDERR).
+  $stderr = previous_stderr
+end
+
+describe 'logging' do
+  it 'should log to stderr by default' do
+    fork do
+      captured_output = capture_stderr do
+        # Does not output anything directly.
+        parser.logger = TreeSitter::Logger.new
+        parser.parse_string(nil, program)
+      end
+      refute_equal 0, captured_output.length
+    end
+  end
+
+  it 'should log to IO objects' do
+    backend = StringIO.new
+    parser.logger = TreeSitter::Logger.new(backend)
+    parser.parse_string(nil, program)
+    refute_equal 0, backend.length
+  end
+
+  it 'should format output when a format string is passed' do
+    delim = '~~~~~'
+    backend = StringIO.new
+    parser.logger = TreeSitter::Logger.new(backend, "%s#{delim}%s")
+    parser.parse_string(nil, program)
+    backend.each_line do |l|
+      assert (/#{delim}/ =~ l), 'delimiter must be in every single line'
+    end
+  end
+end

data/test/tree_sitter/node_test.rb

@@ -0,0 +1,355 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+
+ruby = TreeSitter.lang('ruby')
+parser = TreeSitter::Parser.new
+parser.language = ruby
+
+program = <<~RUBY
+  def mul(a, b)
+    res = a * b
+    puts res.inspect
+    return res
+  end
+RUBY
+
+tree = parser.parse_string(nil, program)
+root = tree.root_node
+
+describe 'type' do
+  it 'must be a Symbol' do
+    assert_instance_of Symbol, root.type
+  end
+
+  it 'must be "program" on root' do
+    assert_equal :program, root.type
+  end
+end
+
+describe 'symbol' do
+  it 'must be an Integer' do
+    assert_instance_of Integer, root.symbol
+  end
+end
+
+describe 'start_byte' do
+  it 'must be an Integer' do
+    assert_instance_of Integer, root.start_byte
+  end
+
+  it 'must be an 0' do
+    assert_equal 0, root.start_byte
+  end
+end
+
+describe 'end_byte' do
+  it 'must be an Integer' do
+    assert_instance_of Integer, root.end_byte
+  end
+
+  it 'must not be 0' do
+    refute_equal 0, root.end_byte
+  end
+end
+
+describe 'start_point' do
+  it 'must be an instance of point' do
+    assert_instance_of TreeSitter::Point, root.start_point
+  end
+
+  it 'must be at row 0' do
+    assert_equal 0, root.start_point.row
+  end
+
+  it 'must be at column 0' do
+    assert_equal 0, root.start_point.row
+  end
+end
+
+describe 'end_point' do
+  it 'must be an instance of point' do
+    assert_instance_of TreeSitter::Point, root.end_point
+  end
+
+  it 'must not be at row 0' do
+    refute_equal 0, root.end_point.row
+  end
+
+  it 'must not be at column 0' do
+    refute_equal 0, root.end_point.row
+  end
+end
+
+describe 'string' do
+  it 'must be an instance of string' do
+    assert_instance_of String, root.to_s
+  end
+
+  it 'must be non-empty' do
+    refute root.to_s.empty?
+  end
+end
+
+describe 'predicates' do
+  it 'must not be null' do
+    refute_nil root.null?
+  end
+
+  it 'must be named' do
+    assert root.named?
+  end
+
+  it 'must not be missing' do
+    refute root.missing?
+  end
+
+  it 'must not be extra' do
+    refute root.extra?
+  end
+
+  it 'must not have any changes' do
+    # TODO: needs a more elaborate test to check for true changes?
+    refute root.changed?
+  end
+
+  it 'must not have no errors' do
+    refute root.error?
+  end
+end
+
+describe 'parent' do
+  # NOTE: never call parent on root. It will segfault.
+  #
+  # tree-sitter does not provide a way to check if a node has a parent.
+
+  it 'must never be nil' do
+    refute_nil root.child(0).parent
+  end
+
+  it 'must be root for its children' do
+    assert_equal root, root.child(0).parent
+  end
+end
+
+describe 'child' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'must return proper children count' do
+    assert_equal 1, root.child_count
+  end
+
+  it 'must return proper name child count' do
+    assert_equal 5, @child.named_child_count
+  end
+
+  it 'must return proper name child' do
+    assert_equal @child.child(1), @child.named_child(0)
+  end
+
+  it 'must return proper child by field name' do
+    assert_equal @child.child(1), @child.child_by_field_name('name')
+  end
+
+  it 'must return proper child by field id' do
+    assert_equal @child.child(1), @child.child_by_field_id(ruby.field_id_for_name('name'))
+  end
+
+  it 'must return proper child for byte' do
+    child = @child.child(0)
+    assert_equal child, @child.first_child_for_byte(child.start_byte)
+  end
+
+  it 'must return proper named child for byte' do
+    child = @child.child(1)
+    assert_equal child, @child.first_named_child_for_byte(child.start_byte)
+  end
+
+  it 'must return proper descendant for byte range' do
+    child = @child.child(1)
+    assert_equal child, @child.descendant_for_byte_range(child.start_byte, child.end_byte)
+  end
+
+  it 'must return proper descendant for point range' do
+    child = @child.child(1)
+    assert_equal child, @child.descendant_for_point_range(child.start_point, child.end_point)
+  end
+
+  it 'must return proper named descendant for byte range' do
+    child = @child.child(1)
+    assert_equal child, @child.named_descendant_for_byte_range(child.start_byte, child.end_byte)
+  end
+
+  it 'must return proper named descendant for point range' do
+    child = @child.child(1)
+    assert_equal child, @child.named_descendant_for_point_range(child.start_point, child.end_point)
+  end
+
+  it 'must raise an exception for wrong ranges' do
+    child = @child.child(0)
+    assert_raises IndexError do
+      @child.descendant_for_byte_range(child.end_byte, child.start_byte)
+    end
+    assert_raises IndexError do
+      @child.named_descendant_for_byte_range(child.end_byte, child.start_byte)
+    end
+    assert_raises IndexError do
+      p1 = TreeSitter::Point.new
+      p1.row = @child.end_point.row
+      p1.column = @child.end_point.column + 1
+      @child.named_descendant_for_point_range(@child.start_point, p1)
+    end
+    assert_raises IndexError do
+      p1 = TreeSitter::Point.new
+      p1.row = @child.end_point.row
+      p1.column = @child.end_point.column + 1
+      @child.named_descendant_for_point_range(@child.start_point, p1)
+    end
+  end
+end
+
+describe 'field_name' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'must return proper field name' do
+    assert_equal 'name', @child.field_name_for_child(1)
+  end
+end
+
+describe 'siblings' do
+  before do
+    @child = root.child(0).child(0)
+  end
+
+  it 'must return proper next/previous siblings' do
+    assert_equal @child, @child.next_sibling.prev_sibling
+  end
+
+  it 'must return proper next/previous named siblings' do
+    assert_equal @child.parent.child(1), @child.next_named_sibling
+  end
+end
+
+# TODO: edit
+
+# Tese are High-Level Ruby APIs that we designed.
+# They rely on the bindings.
+
+describe '[]' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'must return a named child by index when index is an Integer' do
+    assert_equal @child.named_child(0), @child[0]
+  end
+
+  it 'must return a child by field name when index is a (String | Symbol)' do
+    assert_equal @child.named_child(0), @child[:name]
+    assert_equal @child.named_child(0), @child['name']
+  end
+
+  it 'must return an array of nodes when index is an Array' do
+    arr = [@child.named_child(0)] * 3
+    assert_equal arr, @child[0, :name, 'name']
+  end
+
+  it 'must throw an exception when out of index' do
+    assert_raises { @child[255] }
+  end
+
+  it 'must throw an exception when field is not found (NO SIGSEGV ANYMORE!)' do
+    assert_raises { @child[:randomzes] }
+  end
+end
+
+describe 'each' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'must iterate over all children' do
+    i = 0
+    @child.each do |_|
+      i += 1
+    end
+    assert @child.child_count, i
+  end
+
+  it 'must iterate ove named children attached to fields only' do
+    @child.each_field do |f, c|
+      refute f.nil?
+      refute f.empty?
+      assert_equal @child[f], c
+    end
+  end
+
+  it 'must iterate over named children when `each_named_child`' do
+    i = 0
+    @child.each_named do |c|
+      assert c.named?
+      i += 1
+    end
+    assert @child.named_child_count, i
+  end
+end
+
+describe 'method_missing' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'should act like the [] method when we pass (String | Symbol)' do
+    assert_equal @child[:name], @child.name
+  end
+end
+
+describe 'to_a' do
+  before do
+    @child = root.child(0)
+  end
+
+  it 'should return the list from each' do
+    ll = @child.to_a
+
+    refute ll.empty?
+
+    @child.each.with_index do |c, i|
+      assert_equal @child.child(i), c
+    end
+  end
+end
+
+describe 'fetch' do
+  before do
+    @child = root.child(0).child(4)
+  end
+
+  it 'should return all requested keys by order' do
+    method = @child.child(0)
+    arguments = @child.child(1)
+
+    m, a = @child.fetch(:method, :arguments)
+
+    assert_equal method, m
+    assert_equal arguments, a
+
+    a, m = @child.fetch(:arguments, :method)
+
+    assert_equal method, m
+    assert_equal arguments, a
+  end
+
+  it 'should return unique keys' do
+    method = @child.child(0)
+
+    m = @child.fetch(:method, :method)
+
+    assert_equal 1, m.length
+    assert_equal method, m.first
+  end
+end