traceur-rb 0.0.1 → 0.0.2

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/sorted-set.js

@@ -1,736 +0,0 @@
-"use strict";
-
-module.exports = SortedSet;
-
-var Shim = require("./shim");
-var GenericCollection = require("./generic-collection");
-var GenericSet = require("./generic-set");
-var PropertyChanges = require("./listen/property-changes");
-var RangeChanges = require("./listen/range-changes");
-var TreeLog = require("./tree-log");
-
-function SortedSet(values, equals, compare, getDefault) {
-    if (!(this instanceof SortedSet)) {
-        return new SortedSet(values, equals, compare, getDefault);
-    }
-    this.contentEquals = equals || Object.equals;
-    this.contentCompare = compare || Object.compare;
-    this.getDefault = getDefault || Function.noop;
-    this.root = null;
-    this.length = 0;
-    this.addEach(values);
-}
-
-// hack so require("sorted-set").SortedSet will work in MontageJS
-SortedSet.SortedSet = SortedSet;
-
-Object.addEach(SortedSet.prototype, GenericCollection.prototype);
-Object.addEach(SortedSet.prototype, GenericSet.prototype);
-Object.addEach(SortedSet.prototype, PropertyChanges.prototype);
-Object.addEach(SortedSet.prototype, RangeChanges.prototype);
-
-SortedSet.prototype.constructClone = function (values) {
-    return new this.constructor(
-        values,
-        this.contentEquals,
-        this.contentCompare,
-        this.getDefault
-    );
-};
-
-SortedSet.prototype.has = function (value) {
-    if (this.root) {
-        this.splay(value);
-        return this.contentEquals(value, this.root.value);
-    } else {
-        return false;
-    }
-};
-
-SortedSet.prototype.get = function (value) {
-    if (this.root) {
-        this.splay(value);
-        if (this.contentEquals(value, this.root.value)) {
-            return this.root.value;
-        }
-    }
-    return this.getDefault(value);
-};
-
-SortedSet.prototype.add = function (value) {
-    var node = new this.Node(value);
-    if (this.root) {
-        this.splay(value);
-        if (!this.contentEquals(value, this.root.value)) {
-            var comparison = this.contentCompare(value, this.root.value);
-            if (comparison === 0) {
-                throw new Error("SortedSet cannot contain incomparable but inequal values: " + value + " and " + this.root.value);
-            }
-            if (this.dispatchesRangeChanges) {
-                this.dispatchBeforeRangeChange([value], [], this.root.index);
-            }
-            if (comparison < 0) {
-                // rotate right
-                //   R        N
-                //  / \  ->  / \
-                // l   r    l   R
-                // :   :    :    \
-                //                r
-                //                :
-                node.right = this.root;
-                node.left = this.root.left;
-                this.root.left = null;
-                this.root.touch();
-            } else {
-                // rotate left
-                //   R        N
-                //  / \  ->  / \
-                // l   r    R   r
-                // :   :   /    :
-                //        l
-                //        :
-                node.left = this.root;
-                node.right = this.root.right;
-                this.root.right = null;
-                this.root.touch();
-            }
-            node.touch();
-            this.root = node;
-            this.length++;
-            if (this.dispatchesRangeChanges) {
-                this.dispatchRangeChange([value], [], this.root.index);
-            }
-            return true;
-        }
-    } else {
-        if (this.dispatchesRangeChanges) {
-            this.dispatchBeforeRangeChange([value], [], 0);
-        }
-        this.root = node;
-        this.length++;
-        if (this.dispatchesRangeChanges) {
-            this.dispatchRangeChange([value], [], 0);
-        }
-        return true;
-    }
-    return false;
-};
-
-SortedSet.prototype['delete'] = function (value) {
-    if (this.root) {
-        this.splay(value);
-        if (this.contentEquals(value, this.root.value)) {
-            var index = this.root.index;
-            if (this.dispatchesRangeChanges) {
-                this.dispatchBeforeRangeChange([], [value], index);
-            }
-            if (!this.root.left) {
-                this.root = this.root.right;
-            } else {
-                // remove the right side of the tree,
-                var right = this.root.right;
-                this.root = this.root.left;
-                // the tree now only contains the left side of the tree, so all
-                // values are less than the value deleted.
-                // splay so that the root has an empty right child
-                this.splay(value);
-                // put the right side of the tree back
-                this.root.right = right;
-            }
-            this.length--;
-            if (this.root) {
-                this.root.touch();
-            }
-            if (this.dispatchesRangeChanges) {
-                this.dispatchRangeChange([], [value], index);
-            }
-            return true;
-        }
-    }
-    return false;
-};
-
-SortedSet.prototype.indexOf = function (value) {
-    if (this.root) {
-        this.splay(value);
-        if (this.contentEquals(value, this.root.value)) {
-            return this.root.index;
-        }
-    }
-    return -1;
-};
-
-SortedSet.prototype.find = function (value) {
-    if (this.root) {
-        this.splay(value);
-        if (this.contentEquals(value, this.root.value)) {
-            return this.root;
-        }
-    }
-};
-
-SortedSet.prototype.findGreatest = function (at) {
-    if (this.root) {
-        at = at || this.root;
-        while (at.right) {
-            at = at.right;
-        }
-        return at;
-    }
-};
-
-SortedSet.prototype.findLeast = function (at) {
-    if (this.root) {
-        at = at || this.root;
-        while (at.left) {
-            at = at.left;
-        }
-        return at;
-    }
-};
-
-SortedSet.prototype.findGreatestLessThanOrEqual = function (value) {
-    if (this.root) {
-        this.splay(value);
-        // assert root.value <= value
-        return this.root;
-    }
-};
-
-SortedSet.prototype.findGreatestLessThan = function (value) {
-    if (this.root) {
-        this.splay(value);
-        // assert root.value <= value
-        return this.root.getPrevious();
-    }
-};
-
-SortedSet.prototype.findLeastGreaterThanOrEqual = function (value) {
-    if (this.root) {
-        this.splay(value);
-        // assert root.value <= value
-        var comparison = this.contentCompare(value, this.root.value);
-        if (comparison === 0) {
-            return this.root;
-        } else {
-            return this.root.getNext();
-        }
-    }
-};
-
-SortedSet.prototype.findLeastGreaterThan = function (value) {
-    if (this.root) {
-        this.splay(value);
-        // assert root.value <= value
-        var comparison = this.contentCompare(value, this.root.value);
-        return this.root.getNext();
-    }
-};
-
-SortedSet.prototype.pop = function () {
-    if (this.root) {
-        var found = this.findGreatest();
-        this["delete"](found.value);
-        return found.value;
-    }
-};
-
-SortedSet.prototype.shift = function () {
-    if (this.root) {
-        var found = this.findLeast();
-        this["delete"](found.value);
-        return found.value;
-    }
-};
-
-SortedSet.prototype.push = function () {
-    this.addEach(arguments);
-};
-
-SortedSet.prototype.unshift = function () {
-    this.addEach(arguments);
-};
-
-SortedSet.prototype.slice = function (start, end) {
-    var temp;
-    start = start || 0;
-    end = end || this.length;
-    if (start < 0) {
-        start += this.length;
-    }
-    if (end < 0) {
-        end += this.length;
-    }
-    var sliced = [];
-    if (this.root) {
-        this.splayIndex(start);
-        while (this.root.index < end) {
-            sliced.push(this.root.value);
-            if (!this.root.right) {
-                break;
-            }
-            this.splay(this.root.getNext().value);
-        }
-    }
-    return sliced;
-};
-
-SortedSet.prototype.splice = function (at, length /*...plus*/) {
-    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
-};
-
-SortedSet.prototype.swap = function (start, length, plus) {
-    if (start === undefined && length === undefined) {
-        return [];
-    }
-    start = start || 0;
-    if (start < 0) {
-        start += this.length;
-    }
-    if (length === undefined) {
-        length = Infinity;
-    }
-    var swapped = [];
-
-    if (this.root) {
-
-        // start
-        this.splayIndex(start);
-
-        // minus length
-        for (var i = 0; i < length; i++) {
-            swapped.push(this.root.value);
-            var next = this.root.getNext();
-            this["delete"](this.root.value);
-            if (!next) {
-                break;
-            }
-            this.splay(next.value);
-        }
-    }
-
-    // plus
-    this.addEach(plus);
-
-    return swapped;
-};
-
-// This is the simplified top-down splaying algorithm from: "Self-adjusting
-// Binary Search Trees" by Sleator and Tarjan guarantees that the root.value <=
-// value if root exists
-// - as described in https://github.com/hij1nx/forest
-SortedSet.prototype.splay = function (value) {
-    var stub, left, right, temp, root, history;
-
-    if (!this.root) {
-        return;
-    }
-
-    // Create a stub node.  The use of the stub node is a bit
-    // counter-intuitive: The right child of the stub node will hold the L tree
-    // of the algorithm.  The left child of the stub node will hold the R tree
-    // of the algorithm.  Using a stub node, left and right will always be
-    // nodes and we avoid special cases.
-    // - http://code.google.com/p/v8/source/browse/branches/bleeding_edge/src/splay-tree-inl.h
-    stub = left = right = new this.Node();
-    // The history is an upside down tree used to propagate new tree sizes back
-    // up the left and right arms of a traversal.  The right children of the
-    // transitive left side of the tree will be former roots while linking
-    // left.  The left children of the transitive walk to the right side of the
-    // history tree will all be previous roots from linking right.  The last
-    // node of the left and right traversal will each become a child of the new
-    // root.
-    history = new this.Node();
-    root = this.root;
-
-    while (true) {
-        var comparison = this.contentCompare(value, root.value);
-        if (comparison < 0) {
-            if (root.left) {
-                if (this.contentCompare(value, root.left.value) < 0) {
-                    // rotate right
-                    //        Root         L(temp)
-                    //      /     \       / \
-                    //     L(temp) R    LL    Root
-                    //    / \                /    \
-                    //  LL   LR            LR      R
-                    temp = root.left;
-                    root.left = temp.right;
-                    root.touch();
-                    temp.right = root;
-                    temp.touch();
-                    root = temp;
-                    if (!root.left) {
-                        break;
-                    }
-                }
-                // remember former root for repropagating length
-                temp = new Node();
-                temp.right = root;
-                temp.left = history.left;
-                history.left = temp;
-                // link left
-                right.left = root;
-                right.touch();
-                right = root;
-                root = root.left;
-            } else {
-                break;
-            }
-        } else if (comparison > 0) {
-            if (root.right) {
-                if (this.contentCompare(value, root.right.value) > 0) {
-                    // rotate left
-                    //        Root         L(temp)
-                    //      /     \       / \
-                    //     L(temp) R    LL    Root
-                    //    / \                /    \
-                    //  LL   LR            LR      R
-                    temp = root.right;
-                    root.right = temp.left;
-                    root.touch();
-                    temp.left = root;
-                    temp.touch();
-                    root = temp;
-                    if (!root.right) {
-                        break;
-                    }
-                }
-                // remember former root for repropagating length
-                temp = new Node();
-                temp.left = root;
-                temp.right = history.right;
-                history.right = temp;
-                // link right
-                left.right = root;
-                left.touch();
-                left = root;
-                root = root.right;
-            } else {
-                break;
-            }
-        } else { // equal or incomparable
-            break;
-        }
-    }
-
-    // reassemble
-    left.right = root.left;
-    left.touch();
-    right.left = root.right;
-    right.touch();
-    root.left = stub.right;
-    root.right = stub.left;
-
-    // propagate new lengths
-    while (history.left) {
-        history.left.right.touch();
-        history.left = history.left.left;
-    }
-    while (history.right) {
-        history.right.left.touch();
-        history.right = history.right.right;
-    }
-    root.touch();
-
-    this.root = root;
-};
-
-// an internal utility for splaying a node based on its index
-SortedSet.prototype.splayIndex = function (index) {
-    if (this.root) {
-        var at = this.root;
-        var atIndex = this.root.index;
-
-        while (atIndex !== index) {
-            if (atIndex > index && at.left) {
-                at = at.left;
-                atIndex -= 1 + (at.right ? at.right.length : 0);
-            } else if (atIndex < index && at.right) {
-                at = at.right;
-                atIndex += 1 + (at.left ? at.left.length : 0);
-            } else {
-                break;
-            }
-        }
-
-        this.splay(at.value);
-
-        return this.root.index === index;
-    }
-    return false;
-};
-
-SortedSet.prototype.reduce = function (callback, basis, thisp) {
-    if (this.root) {
-        basis = this.root.reduce(callback, basis, 0, thisp, this);
-    }
-    return basis;
-};
-
-SortedSet.prototype.reduceRight = function (callback, basis, thisp) {
-    if (this.root) {
-        basis = this.root.reduceRight(callback, basis, this.length - 1, thisp, this);
-    }
-    return basis;
-};
-
-SortedSet.prototype.min = function (at) {
-    var least = this.findLeast(at);
-    if (least) {
-        return least.value;
-    }
-};
-
-SortedSet.prototype.max = function (at) {
-    var greatest = this.findGreatest(at);
-    if (greatest) {
-        return greatest.value;
-    }
-};
-
-SortedSet.prototype.one = function () {
-    return this.min();
-};
-
-SortedSet.prototype.clear = function () {
-    var minus;
-    if (this.dispatchesRangeChanges) {
-        minus = this.toArray();
-        this.dispatchBeforeRangeChange([], minus, 0);
-    }
-    this.root = null;
-    this.length = 0;
-    if (this.dispatchesRangeChanges) {
-        this.dispatchRangeChange([], minus, 0);
-    }
-};
-
-SortedSet.prototype.iterate = function (start, end) {
-    return new this.Iterator(this, start, end);
-};
-
-SortedSet.prototype.Iterator = Iterator;
-
-SortedSet.prototype.summary = function () {
-    if (this.root) {
-        return this.root.summary();
-    } else {
-        return "()";
-    }
-};
-
-SortedSet.prototype.log = function (charmap, logNode, callback, thisp) {
-    charmap = charmap || TreeLog.unicodeRound;
-    logNode = logNode || this.logNode;
-    if (!callback) {
-        callback = console.log;
-        thisp = console;
-    }
-    callback = callback.bind(thisp);
-    if (this.root) {
-        this.root.log(charmap, logNode, callback, callback);
-    }
-};
-
-SortedSet.prototype.logNode = function (node, log, logBefore) {
-    log(" " + node.value);
-};
-
-SortedSet.logCharsets = TreeLog;
-
-SortedSet.prototype.Node = Node;
-
-function Node(value) {
-    this.value = value;
-    this.left = null;
-    this.right = null;
-    this.length = 1;
-}
-
-// TODO case where no basis is provided for reduction
-
-Node.prototype.reduce = function (callback, basis, index, thisp, tree, depth) {
-    depth = depth || 0;
-    if (this.left) {
-        // prerecord length to be resistant to mutation
-        var length = this.left.length;
-        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
-        index += length;
-    }
-    basis = callback.call(thisp, basis, this.value, index, tree, this, depth);
-    index += 1;
-    if (this.right) {
-        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
-    }
-    return basis;
-};
-
-Node.prototype.reduceRight = function (callback, basis, index, thisp, tree, depth) {
-    depth = depth || 0;
-    if (this.right) {
-        basis = this.right.reduce(callback, basis, index, thisp, tree, depth + 1);
-        index -= this.right.length;
-    }
-    basis = callback.call(thisp, basis, this.value, this.value, tree, this, depth);
-    index -= 1;
-    if (this.left) {
-        basis = this.left.reduce(callback, basis, index, thisp, tree, depth + 1);
-    }
-    return basis;
-};
-
-Node.prototype.touch = function () {
-    this.length = 1 +
-        (this.left ? this.left.length : 0) +
-        (this.right ? this.right.length : 0);
-    this.index = this.left ? this.left.length : 0;
-};
-
-Node.prototype.checkIntegrity = function () {
-    var length = 1;
-    length += this.left ? this.left.checkIntegrity() : 0;
-    length += this.right ? this.right.checkIntegrity() : 0;
-    if (this.length !== length)
-        throw new Error("Integrity check failed: " + this.summary());
-    return length;
-}
-
-// get the next node in this subtree
-Node.prototype.getNext = function () {
-    var node = this;
-    if (node.right) {
-        node = node.right;
-        while (node.left) {
-            node = node.left;
-        }
-        return node;
-    }
-};
-
-// get the previous node in this subtree
-Node.prototype.getPrevious = function () {
-    var node = this;
-    if (node.left) {
-        node = node.left;
-        while (node.right) {
-            node = node.right;
-        }
-        return node;
-    }
-};
-
-Node.prototype.summary = function () {
-    var value = this.value || "-";
-    value += " <" + this.length;
-    if (!this.left && !this.right) {
-        return "(" + value + ")";
-    }
-    return "(" + value + " " + (
-        this.left ? this.left.summary() : "()"
-    ) + ", " + (
-        this.right ? this.right.summary() : "()"
-    ) + ")";
-};
-
-Node.prototype.log = function (charmap, logNode, log, logAbove) {
-    var self = this;
-
-    var branch;
-    if (this.left && this.right) {
-        branch = charmap.intersection;
-    } else if (this.left) {
-        branch = charmap.branchUp;
-    } else if (this.right) {
-        branch = charmap.branchDown;
-    } else {
-        branch = charmap.through;
-    }
-
-    var loggedAbove;
-    this.left && this.left.log(
-        charmap,
-        logNode,
-        function innerWrite(line) {
-            if (!loggedAbove) {
-                loggedAbove = true;
-                // leader
-                logAbove(charmap.fromBelow + charmap.through + line);
-            } else {
-                // below
-                logAbove(charmap.strafe + " " + line);
-            }
-        },
-        function innerWriteAbove(line) {
-            // above
-            logAbove("  " + line);
-        }
-    );
-
-    var loggedOn;
-    logNode(
-        this,
-        function innerWrite(line) {
-            if (!loggedOn) {
-                loggedOn = true;
-                log(branch + line);
-            } else {
-                log((self.right ? charmap.strafe : " ") + line);
-            }
-        },
-        function innerWriteAbove(line) {
-            logAbove((self.left ? charmap.strafe : " ") + line);
-        }
-    );
-
-    var loggedBelow;
-    this.right && this.right.log(
-        charmap,
-        logNode,
-        function innerWrite(line) {
-            if (!loggedBelow) {
-                loggedBelow = true;
-                log(charmap.fromAbove + charmap.through + line);
-            } else {
-                log("  " + line);
-            }
-        },
-        function innerWriteAbove(line) {
-            log(charmap.strafe + " " + line);
-        }
-    );
-};
-
-function Iterator(set, start, end) {
-    this.set = set;
-    this.prev = null;
-    this.end = end;
-    if (start) {
-        var next = this.set.findLeastGreaterThanOrEqual(start);
-        if (next) {
-            this.set.splay(next.value);
-            this.prev = next.getPrevious();
-        }
-    }
-}
-
-Iterator.prototype.next = function () {
-    var next;
-    if (this.prev) {
-        next = this.set.findLeastGreaterThan(this.prev.value);
-    } else {
-        next = this.set.findLeast();
-    }
-    if (!next) {
-        throw StopIteration;
-    }
-    if (
-        this.end !== undefined &&
-        this.set.contentCompare(next.value, this.end) >= 0
-    ) {
-        throw StopIteration;
-    }
-    this.prev = next;
-    return next.value;
-};
-