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

Remove 'document' wrapper node

Browse source
This commit is contained in:
Max Brunsfeld 2015-08-22 10:48:34 -07:00
parent 6933d7b425
commit 21258e6a9e
23 changed files with 165 additions and 136 deletions
Download patch file Download diff file Expand all files Collapse all files

55
spec/runtime/node_spec.cc
View file

@ -6,18 +6,18 @@ START_TEST
describe("Node", []() {
TSDocument *document;
TSNode root;
TSNode array_node;
before_each([&]() {
document = ts_document_make();
ts_document_set_language(document, ts_language_json());
ts_document_set_input_string(document, " [123, false, {\"x\": null}]");
root = ts_document_root_node(document);
AssertThat(ts_node_string(root, document), Equals(
"(DOCUMENT (array "
array_node = ts_document_root_node(document);
AssertThat(ts_node_string(array_node, document), Equals(
"(array "
"(number) "
"(false) "
"(object (string) (null))))"));
"(object (string) (null)))"));
});
after_each([&]() {
@ -26,25 +26,23 @@ describe("Node", []() {
describe("child_count()", [&]() {
it("returns the number of visible child nodes", [&]() {
TSNode array = ts_node_child(root, 0);
AssertThat(ts_node_child_count(array), Equals<size_t>(3));
AssertThat(ts_node_child_count(array_node), Equals<size_t>(3));
});
});
describe("child(i)", [&]() {
it("returns the child node at the given index", [&]() {
TSNode parent = ts_node_child(root, 0);
TSNode child1 = ts_node_child(parent, 0);
TSNode child2 = ts_node_child(parent, 1);
TSNode child3 = ts_node_child(parent, 2);
TSNode child1 = ts_node_child(array_node, 0);
TSNode child2 = ts_node_child(array_node, 1);
TSNode child3 = ts_node_child(array_node, 2);
AssertThat(ts_node_name(parent, document), Equals("array"));
AssertThat(ts_node_name(array_node, document), Equals("array"));
AssertThat(ts_node_name(child1, document), Equals("number"));
AssertThat(ts_node_name(child2, document), Equals("false"));
AssertThat(ts_node_name(child3, document), Equals("object"));
AssertThat(ts_node_pos(parent).bytes, Equals<size_t>(2));
AssertThat(ts_node_size(parent).bytes, Equals<size_t>(25));
AssertThat(ts_node_pos(array_node).bytes, Equals<size_t>(2));
AssertThat(ts_node_size(array_node).bytes, Equals<size_t>(25));
AssertThat(ts_node_pos(child1).bytes, Equals<size_t>(3));
AssertThat(ts_node_size(child1).bytes, Equals<size_t>(3));
@ -55,17 +53,15 @@ describe("Node", []() {
AssertThat(ts_node_pos(child3).bytes, Equals<size_t>(15));
AssertThat(ts_node_size(child3).bytes, Equals<size_t>(11));
AssertThat(ts_node_parent(child1), Equals(parent));
AssertThat(ts_node_parent(child2), Equals(parent));
AssertThat(ts_node_parent(child3), Equals(parent));
AssertThat(ts_node_parent(parent), Equals(root));
AssertThat(ts_node_parent(root).data, Equals<void *>(nullptr));
AssertThat(ts_node_parent(child1), Equals(array_node));
AssertThat(ts_node_parent(child2), Equals(array_node));
AssertThat(ts_node_parent(child3), Equals(array_node));
AssertThat(ts_node_parent(array_node).data, Equals<void *>(nullptr));
});
});
describe("next_sibling() and prev_sibling()", [&]() {
it("returns the node's next and previous siblings", [&]() {
TSNode array_node = ts_node_child(root, 0);
TSNode number_node = ts_node_child(array_node, 0);
TSNode false_node = ts_node_child(array_node, 1);
TSNode object_node = ts_node_child(array_node, 2);
@ -81,9 +77,8 @@ describe("Node", []() {
});
it("returns null when the node has no parent", [&]() {
TSNode array_node = ts_node_child(root, 0);
AssertThat(ts_node_next_sibling(root).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(root).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));
AssertThat(ts_node_next_sibling(array_node).data, Equals<void *>(nullptr));
AssertThat(ts_node_prev_sibling(array_node).data, Equals<void *>(nullptr));
});
@ -92,12 +87,12 @@ describe("Node", []() {
describe("find_for_range(start, end)", [&]() {
describe("when there is a leaf node that spans the given range exactly", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_find_for_range(root, 16, 18);
TSNode leaf = ts_node_find_for_range(array_node, 16, 18);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
leaf = ts_node_find_for_range(root, 3, 5);
leaf = ts_node_find_for_range(array_node, 3, 5);
AssertThat(ts_node_name(leaf, document), Equals("number"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(3));
@ -106,12 +101,12 @@ describe("Node", []() {
describe("when there is a leaf node that extends beyond the given range", [&]() {
it("returns that leaf node", [&]() {
TSNode leaf = ts_node_find_for_range(root, 16, 17);
TSNode leaf = ts_node_find_for_range(array_node, 16, 17);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
leaf = ts_node_find_for_range(root, 17, 18);
leaf = ts_node_find_for_range(array_node, 17, 18);
AssertThat(ts_node_name(leaf, document), Equals("string"));
AssertThat(ts_node_size(leaf).bytes, Equals<size_t>(3));
AssertThat(ts_node_pos(leaf).bytes, Equals<size_t>(16));
@ -120,14 +115,14 @@ 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 node = ts_node_find_for_range(root, 16, 19);
TSNode node = ts_node_find_for_range(array_node, 16, 19);
AssertThat(ts_node_name(node, document), Equals("object"));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(11));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(15));
});
it("does not return invisible nodes (repeats)", [&]() {
TSNode node = ts_node_find_for_range(root, 6, 7);
TSNode node = ts_node_find_for_range(array_node, 6, 7);
AssertThat(ts_node_name(node, document), Equals("array"));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(25));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(2));
@ -137,7 +132,7 @@ describe("Node", []() {
describe("find_for_pos(position)", [&]() {
it("finds the smallest node that spans the given position", [&]() {
TSNode node = ts_node_find_for_pos(root, 10);
TSNode node = ts_node_find_for_pos(array_node, 10);
AssertThat(ts_node_name(node, document), Equals("false"));
AssertThat(ts_node_pos(node).bytes, Equals<size_t>(8));
AssertThat(ts_node_size(node).bytes, Equals<size_t>(5));