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

Rename ts_node_name -> ts_node_type

Browse source
This commit is contained in:
Max Brunsfeld 2016-09-06 21:43:59 -07:00
parent 38241d466b
commit a6a08dde31
4 changed files with 47 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

70
spec/runtime/node_spec.cc
View file

@ -63,7 +63,7 @@ describe("Node", []() {
describe("named_child_count(), named_child(i)", [&]() {
it("returns the named child node at the given index", [&]() {
AssertThat(ts_node_name(array_node, document), Equals("array"));
AssertThat(ts_node_type(array_node, document), Equals("array"));
AssertThat(ts_node_named_child_count(array_node), Equals<size_t>(3));
AssertThat(ts_node_start_byte(array_node), Equals(array_index));
@ -77,9 +77,9 @@ describe("Node", []() {
TSNode false_node = ts_node_named_child(array_node, 1);
TSNode object_node = ts_node_named_child(array_node, 2);
AssertThat(ts_node_name(number_node, document), Equals("number"));
AssertThat(ts_node_name(false_node, document), Equals("false"));
AssertThat(ts_node_name(object_node, document), Equals("object"));
AssertThat(ts_node_type(number_node, document), Equals("number"));
AssertThat(ts_node_type(false_node, document), Equals("false"));
AssertThat(ts_node_type(object_node, document), Equals("object"));
AssertThat(ts_node_start_byte(number_node), Equals(number_index));
AssertThat(ts_node_end_byte(number_node), Equals(number_end_index));
@ -101,7 +101,7 @@ describe("Node", []() {
TSNode pair_node = ts_node_named_child(object_node, 0);
AssertThat(ts_node_name(pair_node, document), Equals("pair"));
AssertThat(ts_node_type(pair_node, document), Equals("pair"));
AssertThat(ts_node_start_byte(pair_node), Equals(string_index));
AssertThat(ts_node_end_byte(pair_node), Equals(null_end_index));
AssertThat(ts_node_start_point(pair_node), Equals<TSPoint>({ 6, 4 }));
@ -111,8 +111,8 @@ describe("Node", []() {
TSNode string_node = ts_node_named_child(pair_node, 0);
TSNode null_node = ts_node_named_child(pair_node, 1);
AssertThat(ts_node_name(string_node, document), Equals("string"));
AssertThat(ts_node_name(null_node, document), Equals("null"));
AssertThat(ts_node_type(string_node, document), Equals("string"));
AssertThat(ts_node_type(null_node, document), Equals("null"));
AssertThat(ts_node_start_byte(string_node), Equals(string_index));
AssertThat(ts_node_end_byte(string_node), Equals(string_end_index));
@ -182,14 +182,14 @@ describe("Node", []() {
TSNode child6 = ts_node_child(array_node, 5);
TSNode child7 = ts_node_child(array_node, 6);
AssertThat(ts_node_name(array_node, document), Equals("array"));
AssertThat(ts_node_name(child1, document), Equals("["));
AssertThat(ts_node_name(child2, document), Equals("number"));
AssertThat(ts_node_name(child3, document), Equals(","));
AssertThat(ts_node_name(child4, document), Equals("false"));
AssertThat(ts_node_name(child5, document), Equals(","));
AssertThat(ts_node_name(child6, document), Equals("object"));
AssertThat(ts_node_name(child7, document), Equals("]"));
AssertThat(ts_node_type(array_node, document), Equals("array"));
AssertThat(ts_node_type(child1, document), Equals("["));
AssertThat(ts_node_type(child2, document), Equals("number"));
AssertThat(ts_node_type(child3, document), Equals(","));
AssertThat(ts_node_type(child4, document), Equals("false"));
AssertThat(ts_node_type(child5, document), Equals(","));
AssertThat(ts_node_type(child6, document), Equals("object"));
AssertThat(ts_node_type(child7, document), Equals("]"));
AssertThat(ts_node_is_named(array_node), IsTrue());
AssertThat(ts_node_is_named(child1), IsFalse());
@ -230,13 +230,13 @@ describe("Node", []() {
TSNode grandchild3 = ts_node_child(pair, 1);
TSNode grandchild4 = ts_node_child(pair, 2);
AssertThat(ts_node_name(left_brace, document), Equals("{"));
AssertThat(ts_node_name(pair, document), Equals("pair"));
AssertThat(ts_node_name(right_brace, document), Equals("}"));
AssertThat(ts_node_type(left_brace, document), Equals("{"));
AssertThat(ts_node_type(pair, document), Equals("pair"));
AssertThat(ts_node_type(right_brace, document), Equals("}"));
AssertThat(ts_node_name(grandchild2, document), Equals("string"));
AssertThat(ts_node_name(grandchild3, document), Equals(":"));
AssertThat(ts_node_name(grandchild4, document), Equals("null"));
AssertThat(ts_node_type(grandchild2, document), Equals("string"));
AssertThat(ts_node_type(grandchild3, document), Equals(":"));
AssertThat(ts_node_type(grandchild4, document), Equals("null"));
AssertThat(ts_node_parent(grandchild2), Equals(pair));
AssertThat(ts_node_parent(grandchild3), Equals(pair));
@ -337,14 +337,14 @@ describe("Node", []() {
describe("when there is a leaf node that spans the given range exactly", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_named_descendant_for_char_range(array_node, string_index, string_end_index - 1);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_type(leaf, document), Equals("string"));
AssertThat(ts_node_start_byte(leaf), Equals(string_index));
AssertThat(ts_node_end_byte(leaf), Equals(string_end_index));
AssertThat(ts_node_start_point(leaf), Equals<TSPoint>({ 6, 4 }));
AssertThat(ts_node_end_point(leaf), Equals<TSPoint>({ 6, 7 }));
leaf = ts_node_named_descendant_for_char_range(array_node, number_index, number_end_index - 1);
AssertThat(ts_node_name(leaf, document), Equals("number"));
AssertThat(ts_node_type(leaf, document), Equals("number"));
AssertThat(ts_node_start_byte(leaf), Equals(number_index));
AssertThat(ts_node_end_byte(leaf), Equals(number_end_index));
AssertThat(ts_node_start_point(leaf), Equals<TSPoint>({ 3, 2 }));
@ -355,14 +355,14 @@ describe("Node", []() {
describe("when there is a leaf node that extends beyond the given range", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_named_descendant_for_char_range(array_node, string_index, string_index + 1);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_type(leaf, document), Equals("string"));
AssertThat(ts_node_start_byte(leaf), Equals(string_index));
AssertThat(ts_node_end_byte(leaf), Equals(string_end_index));
AssertThat(ts_node_start_point(leaf), Equals<TSPoint>({ 6, 4 }));
AssertThat(ts_node_end_point(leaf), Equals<TSPoint>({ 6, 7 }));
leaf = ts_node_named_descendant_for_char_range(array_node, string_index + 1, string_index + 2);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_type(leaf, document), Equals("string"));
AssertThat(ts_node_start_byte(leaf), Equals(string_index));
AssertThat(ts_node_end_byte(leaf), Equals(string_end_index));
AssertThat(ts_node_start_point(leaf), Equals<TSPoint>({ 6, 4 }));
@ -373,7 +373,7 @@ describe("Node", []() {
describe("when there is no leaf node that spans the given range", [&]() {
it("returns the smallest node that does span the range", [&]() {
TSNode pair_node = ts_node_named_descendant_for_char_range(array_node, string_index, string_index + 3);
AssertThat(ts_node_name(pair_node, document), Equals("pair"));
AssertThat(ts_node_type(pair_node, document), Equals("pair"));
AssertThat(ts_node_start_byte(pair_node), Equals(string_index));
AssertThat(ts_node_end_byte(pair_node), Equals(null_end_index));
AssertThat(ts_node_start_point(pair_node), Equals<TSPoint>({ 6, 4 }));
@ -382,7 +382,7 @@ describe("Node", []() {
it("does not return invisible nodes (repeats)", [&]() {
TSNode node = ts_node_named_descendant_for_char_range(array_node, number_end_index, number_end_index + 1);
AssertThat(ts_node_name(node, document), Equals("array"));
AssertThat(ts_node_type(node, document), Equals("array"));
AssertThat(ts_node_start_byte(node), Equals(array_index));
AssertThat(ts_node_end_byte(node), Equals(array_end_index));
AssertThat(ts_node_start_point(node), Equals<TSPoint>({ 2, 0 }));
@ -394,14 +394,14 @@ describe("Node", []() {
describe("descendant_for_char_range(start, end)", [&]() {
it("returns the smallest node that spans the given range", [&]() {
TSNode node1 = ts_node_descendant_for_char_range(array_node, colon_index, colon_index);
AssertThat(ts_node_name(node1, document), Equals(":"));
AssertThat(ts_node_type(node1, document), Equals(":"));
AssertThat(ts_node_start_byte(node1), Equals(colon_index));
AssertThat(ts_node_end_byte(node1), Equals(colon_index + 1));
AssertThat(ts_node_start_point(node1), Equals<TSPoint>({ 6, 7 }));
AssertThat(ts_node_end_point(node1), Equals<TSPoint>({ 6, 8 }));
TSNode node2 = ts_node_descendant_for_char_range(array_node, string_index + 2, string_index + 4);
AssertThat(ts_node_name(node2, document), Equals("pair"));
AssertThat(ts_node_type(node2, document), Equals("pair"));
AssertThat(ts_node_start_byte(node2), Equals(string_index));
AssertThat(ts_node_end_byte(node2), Equals(null_end_index));
AssertThat(ts_node_start_point(node2), Equals<TSPoint>({ 6, 4 }));
@ -416,26 +416,26 @@ describe("Node", []() {
TSNode array_node = ts_document_root_node(document);
TSNode node1 = ts_node_descendant_for_char_range(array_node, 7, 7);
AssertThat(ts_node_name(node1, document), Equals(","));
AssertThat(ts_node_type(node1, document), Equals(","));
TSNode node2 = ts_node_descendant_for_byte_range(array_node, 6, 10);
AssertThat(ts_node_name(node2, document), Equals("string"));
AssertThat(ts_node_start_byte(node2), Equals(1));
AssertThat(ts_node_end_byte(node2), Equals(11));
AssertThat(ts_node_type(node2, document), Equals("string"));
AssertThat(ts_node_start_byte(node2), Equals<size_t>(1));
AssertThat(ts_node_end_byte(node2), Equals<size_t>(11));
});
});
describe("descendant_for_point_range(start, end)", [&]() {
it("returns the smallest concrete node that spans the given range", [&]() {
TSNode node1 = ts_node_descendant_for_point_range(array_node, {6, 7}, {6, 7});
AssertThat(ts_node_name(node1, document), Equals(":"));
AssertThat(ts_node_type(node1, document), Equals(":"));
AssertThat(ts_node_start_byte(node1), Equals(colon_index));
AssertThat(ts_node_end_byte(node1), Equals(colon_index + 1));
AssertThat(ts_node_start_point(node1), Equals<TSPoint>({ 6, 7 }));
AssertThat(ts_node_end_point(node1), Equals<TSPoint>({ 6, 8 }));
TSNode node2 = ts_node_descendant_for_point_range(array_node, {6, 6}, {6, 8});
AssertThat(ts_node_name(node2, document), Equals("pair"));
AssertThat(ts_node_type(node2, document), Equals("pair"));
AssertThat(ts_node_start_byte(node2), Equals(string_index));
AssertThat(ts_node_end_byte(node2), Equals(null_end_index));
AssertThat(ts_node_start_point(node2), Equals<TSPoint>({ 6, 4 }));