ruby_tree_sitter 0.20.8.2-x86_64-linux → 1.0.0-x86_64-linux

data/test/tree_sitter/node_test.rb

@@ -1,355 +0,0 @@
-# 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

data/test/tree_sitter/parser_test.rb

@@ -1,140 +0,0 @@
-# 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
-
-# NOTE: I was trying to parse invalid programs and see what happens.
-#
-# What happens = undefined behavior with the ruby parsers.
-#
-# Sometimes it would parse normally and return an instance of Tree, and
-# sometimes it would return nil.  That goes for both `parse_string` and
-# `parse_string_encoded`.
-#
-# I suspect the same thing would happen with `parse`
-
-# margorp = <<~YBUR
-#   fibfast n = fib' 0 1 n
-#     where fib' a b n | n <= 1 = b
-#                      | otherwise = fib' b (a+b) (n-1)
-# YBUR
-
-program16 = program.encode('utf-16')
-# margorp_16 = margorp.encode('utf-16')
-
-describe 'loading a language' do
-  before do
-    parser.reset
-  end
-
-  it 'must set/get the same language' do
-    parser.language = ruby
-    assert_equal ruby, parser.language
-  end
-end
-
-describe 'parse_string' do
-  before do
-    parser.reset
-  end
-
-  it 'must parse nil' do
-    res = parser.parse_string(nil, nil)
-    assert_nil res
-  end
-
-  [
-    ['empty', '', 0],
-    ['valid', program, 1],
-    # ['invalid', margorp, 3]
-  ].each do |q, p, c|
-    it "must parse #{q} programs" do
-      res = parser.parse_string(nil, p)
-      assert_instance_of TreeSitter::Tree, res
-
-      root = res.root_node
-      assert_instance_of TreeSitter::Node, root
-      assert_equal c, root.child_count
-    end
-  end
-end
-
-describe 'parse_string_encoding' do
-  before do
-    parser.reset
-  end
-
-  it 'must parse nil' do
-    res = parser.parse_string_encoding(nil, nil, :utf8)
-    assert_nil res
-    res = parser.parse_string_encoding(nil, nil, :utf16)
-    assert_nil res
-  end
-
-  [
-    ['empty', '', 0, :utf8],
-    ['valid', program, 1, :utf8],
-    # ['invalid', margorp, 3, :utf8],
-    ['empty', ''.encode('utf-16'), 0, :utf16],
-    ['valid', program16, 1, :utf16],
-    # ['invalid', margorp_16, 1, :utf16]
-  ].each do |q, p, c, e|
-    it "must parse #{q} programs in #{e}" do
-      res = parser.parse_string_encoding(nil, p, e)
-      assert_instance_of TreeSitter::Tree, res
-
-      root = res.root_node
-      assert_instance_of TreeSitter::Node, root
-      assert_equal c, root.child_count
-    end
-  end
-end
-
-describe 'print_dot_graphs' do
-  before do
-    parser.reset
-  end
-
-  it 'must save its debug info to a file' do
-    dot = File.expand_path('tmp/debug-dot.gv', FileUtils.getwd)
-    parser.print_dot_graphs(dot)
-    parser.parse_string(nil, program)
-
-    assert File.exist?(dot), 'dot file must be exist'
-    assert File.file?(dot), 'dot file must be a file'
-    refute_equal 0, File.size(dot)
-  end
-end
-
-describe 'canecalation_flags' do
-  it 'must get/set cancellation_flah' do
-    parser.cancellation_flag = 1
-    assert_equal 1, parser.cancellation_flag
-  end
-end
-
-describe 'timeout_micros' do
-  it 'must get/set timeout_micros' do
-    parser.timeout_micros = 1
-    assert_equal 1, parser.timeout_micros
-  end
-end
-
-# TODO: included_ranges for parsing partial documents.
-
-# TODO: parsing with non-nil tree.
-
-# TODO: parsing Input streams.  We're currently just hading the callback from
-#       C-space to Ruby-space At some point we might need to implement a
-#       buffered input reader and we should test it here.

data/test/tree_sitter/query_test.rb

@@ -1,153 +0,0 @@
-# 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
-
-pattern = '(method_parameters)'
-capture = '(method_parameters (_)+ @args)'
-predicate = '(method_parameters (_)+ @args (#match? @args "\w"))'
-combined = "#{pattern} #{capture}"
-# string = '(method_parameters (_)+ @args)'
-
-# NOTE: It' still unclear to me what a captured string is.
-
-describe 'pattern/capture/string' do
-  it 'must return an Integer for pattern count' do
-    query = TreeSitter::Query.new(ruby, pattern)
-    assert_equal 1, query.pattern_count
-    assert_equal 0, query.capture_count
-    assert_equal 0, query.string_count
-  end
-
-  it 'must return an Integer for pattern count' do
-    query = TreeSitter::Query.new(ruby, capture)
-    assert_equal 1, query.pattern_count
-    assert_equal 1, query.capture_count
-    assert_equal 0, query.string_count
-  end
-
-  it 'must return an Integer for combined patterns' do
-    query = TreeSitter::Query.new(ruby, combined)
-    assert_equal 2, query.pattern_count
-    assert_equal 1, query.capture_count
-    assert_equal 0, query.string_count
-  end
-
-  it 'must return an Integer for pattern start byte' do
-    query = TreeSitter::Query.new(ruby, combined)
-    assert_equal 0, query.start_byte_for_pattern(0)
-    assert_equal pattern.bytesize + 1, query.start_byte_for_pattern(1)
-  end
-
-  it 'must return an array of predicates for a pattern' do
-    query = TreeSitter::Query.new(ruby, combined)
-
-    preds0 = query.predicates_for_pattern(0)
-    assert_instance_of Array, preds0
-    assert_equal 0, preds0.size
-
-    preds1 = query.predicates_for_pattern(1)
-    assert_instance_of Array, preds1
-    assert_equal 0, preds1.size
-
-    query = TreeSitter::Query.new(ruby, predicate)
-    preds2 = query.predicates_for_pattern(0)
-    assert_instance_of Array, preds2
-    assert_equal 4, preds2.size
-  end
-
-  it 'must return string names, quanitfier, and string value for capture id' do
-    query = TreeSitter::Query.new(ruby, predicate)
-    query.predicates_for_pattern(0).each do |step|
-      next if step.type != TreeSitter::QueryPredicateStep::CAPTURE
-
-      assert_equal 'args', query.capture_name_for_id(step.value_id)
-      assert_equal TreeSitter::Quantifier::ONE_OR_MORE, query.capture_quantifier_for_id(0, step.value_id)
-      assert_equal 'match?', query.string_value_for_id(step.value_id)
-    end
-  end
-
-  it 'must disable captures but keep it in count' do
-    query = TreeSitter::Query.new(ruby, capture)
-    query.disable_capture('@args')
-    assert_equal 1, query.capture_count
-  end
-
-  it 'must disable captures but keep it in count' do
-    query = TreeSitter::Query.new(ruby, capture)
-    query.disable_pattern(0)
-    assert_equal 1, query.pattern_count
-  end
-  # TODO: pattern guaranteed at step
-end
-
-describe 'query_cursor' do
-  before do
-    @query = TreeSitter::Query.new(ruby, capture)
-    @cursor = TreeSitter::QueryCursor.exec(@query, root)
-  end
-
-  it 'must work with limits' do
-    @cursor.match_limit = 1
-    assert_equal 1, @cursor.match_limit
-    refute @cursor.exceed_match_limit?
-    refute_nil @cursor.next_capture
-    assert @cursor.exceed_match_limit?
-  end
-
-  it 'must work with byte range' do
-    child = root.child(0).child(0)
-    @cursor.set_byte_range(child.start_byte, child.end_byte)
-    assert_nil @cursor.next_capture
-  end
-
-  it 'must work with point range' do
-    child = root.child(0).child(0)
-    @cursor.set_point_range(child.start_point, child.end_point)
-    assert_nil @cursor.next_capture
-  end
-
-  it 'must work with next/remove' do
-    assert_equal 0, @cursor.next_match.id
-    @cursor.remove_match(1)
-    assert_nil @cursor.next_match
-  end
-end
-
-describe 'querying anonymous nodes' do
-  it 'must match & capture the correct nodes' do
-    binary = '(binary left: (identifier) operator: "*" right: (identifier)) @binary'
-    prog = <<~RUBY
-      c + d
-      a * b
-      e / f
-    RUBY
-    prog_tree = parser.parse_string(nil, prog)
-    prog_root = prog_tree.root_node
-    query = TreeSitter::Query.new(ruby, binary)
-    cursor = TreeSitter::QueryCursor.exec(query, prog_root)
-
-    while match = cursor.next_match
-      refute_nil(match)
-      assert_equal(1, match.captures.size)
-
-      node = match.captures.first.node
-      assert_equal 'a * b', prog[node.start_byte...node.end_byte]
-    end
-    assert_nil(match)
-  end
-end