childrenToArray: Filter function argument

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -238,19 +238,29 @@ class SymbolTree {
          *
          * @method childrenToArray
          * @memberOf module:symbol-tree#
-         * @param {Object} object
+         * @param {Object} parent
          * @param {Object[]} [array=[]]
+         * @param {Function} [filter] Function to test each object before it is added to the array.
+         *                            Invoked with arguments (object). Should return `true` if an object
+         *                            is to be included.
+         * @param {*} [thisArg] Value to use as `this` when executing `filter`.
          * @return {Object[]}
          */
-        childrenToArray(object, array) {
+        childrenToArray(parent, array, filter, thisArg) {
                 if (!array) {
                         array = [];
                 }
 
-                object = this._node(object).first;
+                if (!filter) {
+                        filter = returnTrue;
+                }
+
+                let object = this._node(parent).first;
 
                 while (object) {
-                        array.push(object);
+                        if (filter.call(thisArg, object)) {
+                                array.push(object);
+                        }
                         object = this._node(object).next;
                 }
 

test/SymbolTree.js

@@ -638,6 +638,41 @@ test('childrenToArray', function(t) {
         t.end();
 });
 
+test('childrenToArray with filter', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const ac = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(ac, a);
+        tree.insertAfter(b, a);
+
+        const filter = function(object) {
+                t.equal(this, undefined);
+
+                return object !== ab;
+        };
+
+        t.deepEqual([aa, ac], tree.childrenToArray(a, null, filter));
+
+        const thisArg = {a: 123};
+        const filterThis = function(object) {
+                t.equal(this, thisArg);
+
+                return object !== ab;
+        };
+
+        t.deepEqual([aa, ac], tree.childrenToArray(a, null, filterThis, thisArg));
+
+        t.end();
+});
+
 test('treeToArray', function(t) {
         const tree = new SymbolTree();
         const a = {};