Compare relative tree position between two objects

Author: Joris-van-der-Wel

lib/SymbolTree.js

@@ -6,11 +6,16 @@
  */
 
 const SymbolTreeNode = require('./SymbolTreeNode');
+const TreePosition = require('./TreePosition');
 
 function returnTrue() {
         return true;
 }
 
+function reverseArrayIndex(array, reverseIndex) {
+        return array[array.length - 1 - reverseIndex]; // no need to check `index >= 0`
+}
+
 class SymbolTree {
 
         /**
@@ -528,7 +533,7 @@ class SymbolTree {
          *
          * @method childrenCount
          * @memberOf module:symbol-tree#
-         * @param parent
+         * @param {Object} parent
          * @return {Number}
          */
         childrenCount(parent) {
@@ -541,6 +546,98 @@ class SymbolTree {
                 return this.index(parentNode.last) + 1;
         }
 
+        /**
+         * Compare the position of an object relative to another object. A bit set is returned:
+         *
+         * <ul>
+         *     <li>DISCONNECTED : 1</li>
+         *     <li>PRECEDING : 2</li>
+         *     <li>FOLLOWING : 4</li>
+         *     <li>CONTAINS : 8</li>
+         *     <li>CONTAINED_BY : 16</li>
+         * </ul>
+         *
+         * The semantics are the same as compareDocumentPosition in DOM, with the exception that
+         * DISCONNECTED never occurs with any other bit.
+         *
+         * `O(n)` (worst case)
+         *
+         * @method childrenCount
+         * @memberOf module:symbol-tree#
+         * @param {Object} left
+         * @param {Object} right
+         * @return {Number}
+         */
+        compareTreePosition(left, right) {
+                // In DOM terms:
+                // left = reference / context object
+                // right = other
+
+                if (left === right) {
+                        return 0;
+                }
+
+                /* jshint -W016 */
+
+                const leftAncestors = []; { // inclusive
+                        let leftAncestor = left;
+
+                        while (leftAncestor) {
+                                if (leftAncestor === right) {
+                                        return TreePosition.CONTAINS | TreePosition.PRECEDING;
+                                        // other is ancestor of reference
+                                }
+
+                                leftAncestors.push(leftAncestor);
+                                leftAncestor = this.parent(leftAncestor);
+                        }
+                }
+
+
+                const rightAncestors = []; {
+                        let rightAncestor = right;
+
+                        while (rightAncestor) {
+                                if (rightAncestor === left) {
+                                        return TreePosition.CONTAINED_BY | TreePosition.FOLLOWING;
+                                }
+
+                                rightAncestors.push(rightAncestor);
+                                rightAncestor = this.parent(rightAncestor);
+                        }
+                }
+
+
+                const root = reverseArrayIndex(leftAncestors, 0);
+
+                if (!root || root !== reverseArrayIndex(rightAncestors, 0)) {
+                        // note: unlike DOM, preceding / following is not set here
+                        return TreePosition.DISCONNECTED;
+                }
+
+                let commonAncestorIndex = 0;
+                const ancestorsMinLength = Math.min(leftAncestors.length, rightAncestors.length);
+
+                for (let i = 0; i < ancestorsMinLength; ++i) {
+                        const leftAncestor  = reverseArrayIndex(leftAncestors , i);
+                        const rightAncestor = reverseArrayIndex(rightAncestors, i);
+
+                        if (leftAncestor !== rightAncestor) {
+                                break;
+                        }
+
+                        commonAncestorIndex = i;
+                }
+
+                // indexes within the common ancestor
+                const leftIndex  = this.index(reverseArrayIndex(leftAncestors , commonAncestorIndex + 1));
+                const rightIndex = this.index(reverseArrayIndex(rightAncestors, commonAncestorIndex + 1));
+
+                return rightIndex < leftIndex
+                        ? TreePosition.PRECEDING
+                        : TreePosition.FOLLOWING;
+        }
+
         /**
          * Remove the object from this tree.
          * Has no effect if already removed.

lib/TreePosition.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = Object.freeze({
+        // same as DOM DOCUMENT_POSITION_
+        DISCONNECTED : 1,
+        PRECEDING    : 2,
+        FOLLOWING    : 4,
+        CONTAINS     : 8,
+        CONTAINED_BY : 16
+});

test/SymbolTree.js

@@ -1007,3 +1007,49 @@ test('children count', function(t) {
 
         t.end();
 });
+
+
+test('compare tree position', function(t) {
+        const tree = new SymbolTree();
+        const a = {};
+        const aa = {};
+        const aaa = {};
+        const ab = {};
+        const aba = {};
+        const abaa = {};
+        const ac = {};
+
+        const b = {};
+        const ba = {};
+
+        tree.insertLast(aa, a);
+        tree.insertLast(aaa, aa);
+        tree.insertLast(ab, a);
+        tree.insertLast(aba, ab);
+        tree.insertLast(abaa, aba);
+        tree.insertLast(ac, a);
+
+        tree.insertAfter(b, a);
+        tree.insertLast(ba, b);
+
+        t.equal(0, tree.compareTreePosition(a, a), 'object equal');
+
+        t.equal(1, tree.compareTreePosition(a, {}), 'object disconnected');
+        t.equal(1, tree.compareTreePosition(a, b), 'object disconnected');
+
+        t.equal(20, tree.compareTreePosition(a, aa), 'contained by & following');
+        t.equal(10, tree.compareTreePosition(aa, a), 'contains & preceding');
+        t.equal(20, tree.compareTreePosition(a, abaa), 'contained by & following');
+        t.equal(10, tree.compareTreePosition(abaa, a), 'contains & preceding');
+
+        t.equal(4, tree.compareTreePosition(aa, ab), 'following');
+        t.equal(2, tree.compareTreePosition(ab, aa), 'preceding');
+        t.equal(4, tree.compareTreePosition(aa, aba), 'following');
+        t.equal(2, tree.compareTreePosition(aba, aa), 'preceding');
+        t.equal(4, tree.compareTreePosition(aa, abaa), 'following');
+        t.equal(2, tree.compareTreePosition(abaa, aa), 'preceding');
+        t.equal(4, tree.compareTreePosition(aaa, abaa), 'following');
+        t.equal(2, tree.compareTreePosition(abaa, aaa), 'preceding');
+
+        t.end();
+});