Rename prev and next to previousSibling and nextSibling

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -107,27 +107,27 @@ class SymbolTree {
          *
          * `O(1)`
          *
-         * @method prev
+         * @method previousSibling
          * @memberOf module:symbol-tree#
          * @param {Object} object
          * @return {Object}
          */
-        prev(object) {
-                return this._node(object).prev;
+        previousSibling(object) {
+                return this._node(object).previousSibling;
         }
 
         /**
-         * Return the next sibling of the given object.
+         * Return the nextSibling sibling of the given object.
          *
          * `O(1)`
          *
-         * @method next
+         * @method nextSibling
          * @memberOf module:symbol-tree#
          * @param {Object} object
          * @return {Object}
          */
-        next(object) {
-                return this._node(object).next;
+        nextSibling(object) {
+                return this._node(object).nextSibling;
         }
 
         /**
@@ -187,10 +187,10 @@ class SymbolTree {
                         return null;
                 }
 
-                const prev = this._node(object).prev;
+                const previousSibling = this._node(object).previousSibling;
 
-                if (prev) {
-                        return this.lastInclusiveDescendant(prev);
+                if (previousSibling) {
+                        return this.lastInclusiveDescendant(previousSibling);
                 }
 
                 // if there is no previous sibling return the parent (might be null)
@@ -229,10 +229,10 @@ class SymbolTree {
                                 return null;
                         }
 
-                        const next = this._node(object).next;
+                        const nextSibling = this._node(object).nextSibling;
 
-                        if (next) {
-                                return next;
+                        if (nextSibling) {
+                                return nextSibling;
                         }
 
                         object = this._node(object).parent;
@@ -276,7 +276,7 @@ class SymbolTree {
                                 array.push(object);
                         }
 
-                        object = node.next;
+                        object = node.nextSibling;
                         ++index;
                 }
 
@@ -387,7 +387,7 @@ class SymbolTree {
                 return new TreeIterator(
                         this,
                         object,
-                        this._node(object).prev,
+                        this._node(object).previousSibling,
                         TreeIterator.PREV
                 );
         }
@@ -406,7 +406,7 @@ class SymbolTree {
                 return new TreeIterator(
                         this,
                         object,
-                        this._node(object).next,
+                        this._node(object).nextSibling,
                         TreeIterator.NEXT
                 );
         }
@@ -487,7 +487,7 @@ class SymbolTree {
 
                 if (parentNode.childIndexCachedUpTo) {
                         const cachedUpToNode = this._node(parentNode.childIndexCachedUpTo);
-                        object = cachedUpToNode.next;
+                        object = cachedUpToNode.nextSibling;
                         index = cachedUpToNode.getCachedIndex(parentNode) + 1;
                 }
 
@@ -500,7 +500,7 @@ class SymbolTree {
                         }
 
                         ++index;
-                        object = node.next;
+                        object = node.nextSibling;
                 }
 
                 parentNode.childIndexCachedUpTo = child;
@@ -635,30 +635,30 @@ class SymbolTree {
         remove(removeObject) {
                 const removeNode = this._node(removeObject);
                 const parentNode = this._node(removeNode.parent);
-                const prevNode = this._node(removeNode.prev);
-                const nextNode = this._node(removeNode.next);
+                const prevNode = this._node(removeNode.previousSibling);
+                const nextNode = this._node(removeNode.nextSibling);
 
                 if (parentNode) {
                         if (parentNode.firstChild === removeObject) {
-                                parentNode.firstChild = removeNode.next;
+                                parentNode.firstChild = removeNode.nextSibling;
                         }
 
                         if (parentNode.lastChild === removeObject) {
-                                parentNode.lastChild = removeNode.prev;
+                                parentNode.lastChild = removeNode.previousSibling;
                         }
                 }
 
                 if (prevNode) {
-                        prevNode.next = removeNode.next;
+                        prevNode.nextSibling = removeNode.nextSibling;
                 }
 
                 if (nextNode) {
-                        nextNode.prev = removeNode.prev;
+                        nextNode.previousSibling = removeNode.previousSibling;
                 }
 
                 removeNode.parent = null;
-                removeNode.prev = null;
-                removeNode.next = null;
+                removeNode.previousSibling = null;
+                removeNode.nextSibling = null;
 
                 if (parentNode) {
                         parentNode.childrenChanged();
@@ -682,7 +682,7 @@ class SymbolTree {
          */
         insertBefore(newObject, referenceObject) {
                 const referenceNode = this._node(referenceObject);
-                const prevNode = this._node(referenceNode.prev);
+                const prevNode = this._node(referenceNode.previousSibling);
                 const newNode = this._node(newObject);
                 const parentNode = this._node(referenceNode.parent);
 
@@ -691,12 +691,12 @@ class SymbolTree {
                 }
 
                 newNode.parent = referenceNode.parent;
-                newNode.prev = referenceNode.prev;
-                newNode.next = referenceObject;
-                referenceNode.prev = newObject;
+                newNode.previousSibling = referenceNode.previousSibling;
+                newNode.nextSibling = referenceObject;
+                referenceNode.previousSibling = newObject;
 
                 if (prevNode) {
-                        prevNode.next = newObject;
+                        prevNode.nextSibling = newObject;
                 }
 
                 if (parentNode && parentNode.firstChild === referenceObject) {
@@ -725,7 +725,7 @@ class SymbolTree {
          */
         insertAfter(newObject, referenceObject) {
                 const referenceNode = this._node(referenceObject);
-                const nextNode = this._node(referenceNode.next);
+                const nextNode = this._node(referenceNode.nextSibling);
                 const newNode = this._node(newObject);
                 const parentNode = this._node(referenceNode.parent);
 
@@ -734,12 +734,12 @@ class SymbolTree {
                 }
 
                 newNode.parent = referenceNode.parent;
-                newNode.prev = referenceObject;
-                newNode.next = referenceNode.next;
-                referenceNode.next = newObject;
+                newNode.previousSibling = referenceObject;
+                newNode.nextSibling = referenceNode.nextSibling;
+                referenceNode.nextSibling = newObject;
 
                 if (nextNode) {
-                        nextNode.prev = newObject;
+                        nextNode.previousSibling = newObject;
                 }
 
                 if (parentNode && parentNode.lastChild === referenceObject) {

lib/SymbolTreeNode.js

@@ -3,8 +3,8 @@
 module.exports = class SymbolTreeNode {
         constructor() {
                 this.parent = null;
-                this.prev = null;
-                this.next = null;
+                this.previousSibling = null;
+                this.nextSibling = null;
 
                 this.firstChild = null;
                 this.lastChild = null;
@@ -21,7 +21,7 @@ module.exports = class SymbolTreeNode {
         }
 
         get isAttached() {
-                return !!(this.parent || this.prev || this.next);
+                return !!(this.parent || this.previousSibling || this.nextSibling);
         }
 
         get hasChildren() {

lib/TreeIterator.js

@@ -28,10 +28,10 @@ class TreeIterator {
                 const value = this[NEXT];
 
                 if (iterateFunc === 1) {
-                        this[NEXT] = tree._node(value).prev;
+                        this[NEXT] = tree._node(value).previousSibling;
                 }
                 else if (iterateFunc === 2) {
-                        this[NEXT] = tree._node(value).next;
+                        this[NEXT] = tree._node(value).nextSibling;
                 }
                 else if (iterateFunc === 3) {
                         this[NEXT] = tree._node(value).parent;