traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add {next,prev}_concrete_sibling Node methods

Browse source
This commit is contained in:
Max Brunsfeld 2015-09-08 21:43:37 -07:00
parent c3f3f19ea8
commit 245daffbc4
7 changed files with 208 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

6
spec/runtime/helpers/tree_helpers.cc
View file

@ -1,8 +1,10 @@
#include "runtime/helpers/tree_helpers.h"
const char *symbol_names[12] = {
const char *symbol_names[24] = {
"ERROR", "END", "two", "three", "four", "five", "six", "seven", "eight",
"nine", "ten", "eleven",
"nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen",
"sixteen", "seventeen", "eighteen", "nineteen", "twenty", "twenty-one",
"twenty-two", "twenty-three"
};
TSTree ** tree_array(std::vector<TSTree *> trees) {

2
spec/runtime/helpers/tree_helpers.h
View file

@ -5,7 +5,7 @@
#include <vector>
#include <string>
extern const char *symbol_names[12];
extern const char *symbol_names[24];
TSTree ** tree_array(std::vector<TSTree *> trees);

68
spec/runtime/node_spec.cc
View file

@ -130,7 +130,59 @@ describe("Node", []() {
});
});
describe("next_sibling() and prev_sibling()", [&]() {
describe("next_concrete_sibling(), prev_concrete_sibling()", [&]() {
it("returns the node's next and previous sibling, including anonymous nodes", [&]() {
TSNode bracket_node1 = ts_node_concrete_child(array_node, 0);
TSNode number_node = ts_node_concrete_child(array_node, 1);
TSNode array_comma_node1 = ts_node_concrete_child(array_node, 2);
TSNode false_node = ts_node_concrete_child(array_node, 3);
TSNode array_comma_node2 = ts_node_concrete_child(array_node, 4);
TSNode object_node = ts_node_concrete_child(array_node, 5);
TSNode brace_node1 = ts_node_concrete_child(object_node, 0);
TSNode string_node = ts_node_concrete_child(object_node, 1);
TSNode colon_node = ts_node_concrete_child(object_node, 2);
TSNode null_node = ts_node_concrete_child(object_node, 3);
TSNode brace_node2 = ts_node_concrete_child(object_node, 4);
TSNode bracket_node2 = ts_node_concrete_child(array_node, 6);
AssertThat(ts_node_next_concrete_sibling(bracket_node1), Equals(number_node));
AssertThat(ts_node_next_concrete_sibling(number_node), Equals(array_comma_node1));
AssertThat(ts_node_next_concrete_sibling(array_comma_node1), Equals(false_node));
AssertThat(ts_node_next_concrete_sibling(false_node), Equals(array_comma_node2));
AssertThat(ts_node_next_concrete_sibling(array_comma_node2), Equals(object_node));
AssertThat(ts_node_next_concrete_sibling(object_node), Equals(bracket_node2));
AssertThat(ts_node_next_concrete_sibling(bracket_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(bracket_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(number_node), Equals(bracket_node1));
AssertThat(ts_node_prev_concrete_sibling(array_comma_node1), Equals(number_node));
AssertThat(ts_node_prev_concrete_sibling(false_node), Equals(array_comma_node1));
AssertThat(ts_node_prev_concrete_sibling(array_comma_node2), Equals(false_node));
AssertThat(ts_node_prev_concrete_sibling(object_node), Equals(array_comma_node2));
AssertThat(ts_node_prev_concrete_sibling(bracket_node2), Equals(object_node));
AssertThat(ts_node_next_concrete_sibling(brace_node1), Equals(string_node));
AssertThat(ts_node_next_concrete_sibling(string_node), Equals(colon_node));
AssertThat(ts_node_next_concrete_sibling(colon_node), Equals(null_node));
AssertThat(ts_node_next_concrete_sibling(null_node), Equals(brace_node2));
AssertThat(ts_node_next_concrete_sibling(brace_node2).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(brace_node1).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_concrete_sibling(string_node), Equals(brace_node1));
AssertThat(ts_node_prev_concrete_sibling(colon_node), Equals(string_node));
AssertThat(ts_node_prev_concrete_sibling(null_node), Equals(colon_node));
AssertThat(ts_node_prev_concrete_sibling(brace_node2), Equals(null_node));
});
it("returns null when the node has no parent", [&]() {
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
});
});
describe("next_concrete_sibling(), prev_concrete_sibling()", [&]() {
it("returns the node's next and previous siblings", [&]() {
TSNode number_node = ts_node_child(array_node, 0);
TSNode false_node = ts_node_child(array_node, 1);
@ -200,6 +252,20 @@ describe("Node", []() {
});
});
describe("find_concrete_for_range(start, end)", [&]() {
it("returns the smallest concrete node that spans the given range", [&]() {
TSNode node1 = ts_node_find_concrete_for_range(array_node, 19, 19);
AssertThat(ts_node_name(node1, document), Equals(":"));
AssertThat(ts_node_pos(node1).bytes, Equals<size_t>(19));
AssertThat(ts_node_size(node1).bytes, Equals<size_t>(1));
TSNode node2 = ts_node_find_concrete_for_range(array_node, 18, 20);
AssertThat(ts_node_name(node2, document), Equals("object"));
AssertThat(ts_node_pos(node2).bytes, Equals<size_t>(15));
AssertThat(ts_node_size(node2).bytes, Equals<size_t>(11));
});
});
describe("find_for_pos(position)", [&]() {
it("finds the smallest node that spans the given position", [&]() {
TSNode node = ts_node_find_for_pos(array_node, 10);