Iterate over the previous and next siblings

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -351,7 +351,7 @@ class SymbolTree {
         }
 
         /**
-         * Iterate over all children of the given object to an array.
+         * Iterate over all children of the given object
          *
          * `O(1)` for a single iteration
          *
@@ -390,6 +390,86 @@ class SymbolTree {
                 return iterator;
         }
 
+        /**
+         * Iterate over all the previous siblings of the given object. (in reverse tree order)
+         *
+         * `O(1)` for a single iteration
+         *
+         * @method prevSiblingsIterator
+         * @memberOf module:symbol-tree#
+         * @param {Object} object
+         * @return {Object} An iterable iterator (ES6)
+         */
+        prevSiblingsIterator(object) {
+                const _node = this._node.bind(this);
+
+                let nextObject = _node(object).prev;
+                const iterator = {};
+
+                iterator.next = function() {
+                        if (!nextObject) {
+                                return {
+                                        done  : true,
+                                        value : object
+                                };
+                        }
+
+                        const value = nextObject;
+                        nextObject = _node(nextObject).prev;
+
+                        return {
+                                done  : false,
+                                value : value
+                        };
+                };
+
+                iterator[Symbol.iterator] = function() {
+                        return iterator;
+                };
+
+                return iterator;
+        }
+
+        /**
+         * Iterate over all the next siblings of the given object. (in tree order)
+         *
+         * `O(1)` for a single iteration
+         *
+         * @method nextSiblingsIterator
+         * @memberOf module:symbol-tree#
+         * @param {Object} object
+         * @return {Object} An iterable iterator (ES6)
+         */
+        nextSiblingsIterator(object) {
+                const _node = this._node.bind(this);
+
+                let nextObject = _node(object).next;
+                const iterator = {};
+
+                iterator.next = function() {
+                        if (!nextObject) {
+                                return {
+                                        done  : true,
+                                        value : object
+                                };
+                        }
+
+                        const value = nextObject;
+                        nextObject = _node(nextObject).next;
+
+                        return {
+                                done  : false,
+                                value : value
+                        };
+                };
+
+                iterator[Symbol.iterator] = function() {
+                        return iterator;
+                };
+
+                return iterator;
+        }
+
         /**
          * Iterate over all inclusive ancestors of the given object
          *

test/SymbolTree.js

@@ -724,6 +724,64 @@ test('children iterator return value using a generator', function(t) {
         t.end();
 });
 
+test('prev sibling iterator', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const ac = {};
+        const ad = {};
+        const ae = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(ac, a);
+        tree.insertLast(ad, a);
+        tree.insertLast(ae, a);
+        tree.insertAfter(b, a);
+
+        const results = [];
+
+        for (const object of tree.prevSiblingsIterator(ad)) {
+                results.push(object);
+        }
+        t.deepEqual([ac, ab, aa], results);
+
+        t.end();
+});
+
+test('next sibling iterator', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const ab = {};
+        const aba = {};
+        const ac = {};
+        const ad = {};
+        const ae = {};
+        const b = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(ac, a);
+        tree.insertLast(ad, a);
+        tree.insertLast(ae, a);
+        tree.insertAfter(b, a);
+
+        const results = [];
+
+        for (const object of tree.nextSiblingsIterator(ab)) {
+                results.push(object);
+        }
+        t.deepEqual([ac, ad, ae], results);
+
+        t.end();
+});
+
 test('ancestorsToArray', function(t) {
         const tree = new SymbolTree();
         const a = {};