From af5a1180004d3f2af43caa2123cf089386153074 Mon Sep 17 00:00:00 2001
From: Max Brunsfeld <maxbrunsfeld@gmail.com>
Date: Sun, 20 Jul 2014 17:57:20 -0700
Subject: [PATCH] Add ts_node_child_count function

---
 include/tree_sitter/runtime.h |  1 +
 spec/runtime/node_spec.cc     | 93 ++++++++++++++++++++---------------
 src/runtime/node.c            |  6 +++
 3 files changed, 59 insertions(+), 41 deletions(-)

diff --git a/include/tree_sitter/runtime.h b/include/tree_sitter/runtime.h
index 061ddd64..8647297c 100644
--- a/include/tree_sitter/runtime.h
+++ b/include/tree_sitter/runtime.h
@@ -30,6 +30,7 @@ size_t ts_node_pos(const TSNode *);
 size_t ts_node_size(const TSNode *);
 TSSymbol ts_node_sym(const TSNode *);
 TSNode * ts_node_child(TSNode *, size_t);
+size_t ts_node_child_count(const TSNode *);
 TSNode * ts_node_leaf_at_pos(TSNode *, size_t);
 TSNode * ts_node_parent(TSNode *node);
 TSNode * ts_node_next_sibling(TSNode *node);
diff --git a/spec/runtime/node_spec.cc b/spec/runtime/node_spec.cc
index 9dcd44cf..b2b1427b 100644
--- a/spec/runtime/node_spec.cc
+++ b/spec/runtime/node_spec.cc
@@ -22,54 +22,65 @@ describe("Node", []() {
         ts_node_release(root);
     });
 
-    it("knows its position and size", [&]() {
-        TSNode *number1 = ts_node_child(root, 0);
-        TSNode *number2 = ts_node_child(root, 1);
-        TSNode *number3 = ts_node_child(root, 2);
-
-        AssertThat(ts_node_name(root), Equals("array"));
-        AssertThat(ts_node_name(number1), Equals("number"));
-        AssertThat(ts_node_name(number2), Equals("number"));
-        AssertThat(ts_node_name(number3), Equals("number"));
-
-        AssertThat(ts_node_pos(root), Equals<size_t>(2));
-        AssertThat(ts_node_size(root), Equals<size_t>(12));
-
-        AssertThat(ts_node_pos(number1), Equals<size_t>(3));
-        AssertThat(ts_node_size(number1), Equals<size_t>(2));
-
-        AssertThat(ts_node_pos(number2), Equals<size_t>(7));
-        AssertThat(ts_node_size(number2), Equals<size_t>(1));
-
-        AssertThat(ts_node_pos(number3), Equals<size_t>(10));
-        AssertThat(ts_node_size(number3), Equals<size_t>(3));
-
-        ts_node_release(number1);
-        ts_node_release(number2);
-        ts_node_release(number3);
+    describe("child_count", [&]() {
+        it("returns the number of visible child nodes", [&]() {
+            AssertThat(ts_node_child_count(root), Equals<size_t>(3));
+        });
     });
 
-    it("can retrieve its parent node", [&]() {
-        TSNode *number2 = ts_node_child(root, 1);
-        AssertThat(ts_node_parent(number2), Equals(root));
+    describe("child(i)", [&]() {
+        it("returns the child node at the given index", [&]() {
+            TSNode *number1 = ts_node_child(root, 0);
+            TSNode *number2 = ts_node_child(root, 1);
+            TSNode *number3 = ts_node_child(root, 2);
 
-        ts_node_release(number2);
+            AssertThat(ts_node_name(root), Equals("array"));
+            AssertThat(ts_node_name(number1), Equals("number"));
+            AssertThat(ts_node_name(number2), Equals("number"));
+            AssertThat(ts_node_name(number3), Equals("number"));
+
+            AssertThat(ts_node_pos(root), Equals<size_t>(2));
+            AssertThat(ts_node_size(root), Equals<size_t>(12));
+
+            AssertThat(ts_node_pos(number1), Equals<size_t>(3));
+            AssertThat(ts_node_size(number1), Equals<size_t>(2));
+
+            AssertThat(ts_node_pos(number2), Equals<size_t>(7));
+            AssertThat(ts_node_size(number2), Equals<size_t>(1));
+
+            AssertThat(ts_node_pos(number3), Equals<size_t>(10));
+            AssertThat(ts_node_size(number3), Equals<size_t>(3));
+
+            ts_node_release(number1);
+            ts_node_release(number2);
+            ts_node_release(number3);
+        });
     });
 
-    it("can retrieve its sibling nodes", [&]() {
-        TSNode *number1 = ts_node_child(root, 0);
-        TSNode *number2 = ts_node_child(root, 1);
-        TSNode *number3 = ts_node_child(root, 2);
-
-        AssertThat(ts_node_eq(ts_node_next_sibling(number2), number3), IsTrue());
-        AssertThat(ts_node_eq(ts_node_prev_sibling(number2), number1), IsTrue());
-
-        ts_node_release(number1);
-        ts_node_release(number2);
-        ts_node_release(number3);
+    describe("parent", [&]() {
+        it("returns the node's parent node", [&]() {
+            TSNode *number = ts_node_child(root, 1);
+            AssertThat(ts_node_parent(number), Equals(root));
+            ts_node_release(number);
+        });
     });
 
-    describe("retrieving leaf nodes", [&]() {
+    describe("next_sibling and prev_sibling", [&]() {
+        it("returns the node's next and previous siblings", [&]() {
+            TSNode *number1 = ts_node_child(root, 0);
+            TSNode *number2 = ts_node_child(root, 1);
+            TSNode *number3 = ts_node_child(root, 2);
+
+            AssertThat(ts_node_eq(ts_node_next_sibling(number2), number3), IsTrue());
+            AssertThat(ts_node_eq(ts_node_prev_sibling(number2), number1), IsTrue());
+
+            ts_node_release(number1);
+            ts_node_release(number2);
+            ts_node_release(number3);
+        });
+    });
+
+    describe("leaf_at_pos", [&]() {
         it("can retrieve the leaf node at a given position", [&]() {
             TSNode *number1 = ts_node_leaf_at_pos(root, 3);
             TSNode *number2 = ts_node_leaf_at_pos(root, 7);
diff --git a/src/runtime/node.c b/src/runtime/node.c
index 7de3a786..d23c32e8 100644
--- a/src/runtime/node.c
+++ b/src/runtime/node.c
@@ -65,6 +65,12 @@ TSNode * ts_node_next_sibling(TSNode *child) {
     return ts_node_child(child->parent, child->index + 1);
 }
 
+size_t ts_node_child_count(const TSNode *parent) {
+    size_t result;
+    ts_tree_visible_children(parent->content, &result);
+    return result;
+}
+
 TSNode * ts_node_child(TSNode *parent, size_t index) {
     size_t child_count;
     TSChildWithPosition *children = ts_tree_visible_children(parent->content, &child_count);