traceur-rb 0.0.1

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/generic-map.js

@@ -0,0 +1,186 @@
+"use strict";
+
+var Object = require("./shim-object");
+var MapChanges = require("./listen/map-changes");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = GenericMap;
+function GenericMap() {
+    throw new Error("Can't construct. GenericMap is a mixin.");
+}
+
+Object.addEach(GenericMap.prototype, MapChanges.prototype);
+Object.addEach(GenericMap.prototype, PropertyChanges.prototype);
+
+// all of these methods depend on the constructor providing a `store` set
+
+GenericMap.prototype.isMap = true;
+
+GenericMap.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            // copy map-alikes
+            if (values.isMap === true) {
+                values.forEach(function (value, key) {
+                    this.set(key, value);
+                }, this);
+            // iterate key value pairs of other iterables
+            } else {
+                values.forEach(function (pair) {
+                    this.set(pair[0], pair[1]);
+                }, this);
+            }
+        } else {
+            // copy other objects as map-alikes
+            Object.keys(values).forEach(function (key) {
+                this.set(key, values[key]);
+            }, this);
+        }
+    }
+    return this;
+}
+
+GenericMap.prototype.get = function (key, defaultValue) {
+    var item = this.store.get(new this.Item(key));
+    if (item) {
+        return item.value;
+    } else if (arguments.length > 1) {
+        return defaultValue;
+    } else {
+        return this.getDefault(key);
+    }
+};
+
+GenericMap.prototype.set = function (key, value) {
+    var item = new this.Item(key, value);
+    var found = this.store.get(item);
+    var grew = false;
+    if (found) { // update
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, found.value);
+        }
+        found.value = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        if (this.store.add(item)) {
+            this.length++;
+            grew = true;
+        }
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+    }
+    return grew;
+};
+
+GenericMap.prototype.add = function (value, key) {
+    return this.set(key, value);
+};
+
+GenericMap.prototype.has = function (key) {
+    return this.store.has(new this.Item(key));
+};
+
+GenericMap.prototype['delete'] = function (key) {
+    var item = new this.Item(key);
+    if (this.store.has(item)) {
+        var from = this.store.get(item).value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, from);
+        }
+        this.store["delete"](item);
+        this.length--;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+        return true;
+    }
+    return false;
+};
+
+GenericMap.prototype.clear = function () {
+    var keys;
+    if (this.dispatchesMapChanges) {
+        this.forEach(function (value, key) {
+            this.dispatchBeforeMapChange(key, value);
+        }, this);
+        keys = this.keys();
+    }
+    this.store.clear();
+    this.length = 0;
+    if (this.dispatchesMapChanges) {
+        keys.forEach(function (key) {
+            this.dispatchMapChange(key);
+        }, this);
+    }
+};
+
+GenericMap.prototype.reduce = function (callback, basis, thisp) {
+    return this.store.reduce(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.reduceRight = function (callback, basis, thisp) {
+    return this.store.reduceRight(function (basis, item) {
+        return callback.call(thisp, basis, item.value, item.key, this);
+    }, basis, this);
+};
+
+GenericMap.prototype.keys = function () {
+    return this.map(function (value, key) {
+        return key;
+    });
+};
+
+GenericMap.prototype.values = function () {
+    return this.map(Function.identity);
+};
+
+GenericMap.prototype.entries = function () {
+    return this.map(function (value, key) {
+        return [key, value];
+    });
+};
+
+// XXX deprecated
+GenericMap.prototype.items = function () {
+    return this.entries();
+};
+
+GenericMap.prototype.equals = function (that, equals) {
+    equals = equals || Object.equals;
+    if (this === that) {
+        return true;
+    } else if (Object.can(that, "every")) {
+        return that.length === this.length && that.every(function (value, key) {
+            return equals(this.get(key), value);
+        }, this);
+    } else {
+        var keys = Object.keys(that);
+        return keys.length === this.length && Object.keys(that).every(function (key) {
+            return equals(this.get(key), that[key]);
+        }, this);
+    }
+};
+
+GenericMap.prototype.Item = Item;
+
+function Item(key, value) {
+    this.key = key;
+    this.value = value;
+}
+
+Item.prototype.equals = function (that) {
+    return Object.equals(this.key, that.key) && Object.equals(this.value, that.value);
+};
+
+Item.prototype.compare = function (that) {
+    return Object.compare(this.key, that.key);
+};
+

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/generic-order.js

@@ -0,0 +1,55 @@
+
+var Object = require("./shim-object");
+
+module.exports = GenericOrder;
+function GenericOrder() {
+    throw new Error("Can't construct. GenericOrder is a mixin.");
+}
+
+GenericOrder.prototype.equals = function (that, equals) {
+    equals = equals || this.contentEquals || Object.equals;
+
+    if (this === that) {
+        return true;
+    }
+    if (!that) {
+        return false;
+    }
+
+    var self = this;
+    return (
+        this.length === that.length &&
+        this.zip(that).every(function (pair) {
+            return equals(pair[0], pair[1]);
+        })
+    );
+};
+
+GenericOrder.prototype.compare = function (that, compare) {
+    compare = compare || this.contentCompare || Object.compare;
+
+    if (this === that) {
+        return 0;
+    }
+    if (!that) {
+        return 1;
+    }
+
+    var length = Math.min(this.length, that.length);
+    var comparison = this.zip(that).reduce(function (comparison, pair, index) {
+        if (comparison === 0) {
+            if (index >= length) {
+                return comparison;
+            } else {
+                return compare(pair[0], pair[1]);
+            }
+        } else {
+            return comparison;
+        }
+    }, 0);
+    if (comparison === 0) {
+        return this.length - that.length;
+    }
+    return comparison;
+};
+

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

@@ -0,0 +1,59 @@
+
+module.exports = GenericSet;
+function GenericSet() {
+    throw new Error("Can't construct. GenericSet is a mixin.");
+}
+
+GenericSet.prototype.union = function (that) {
+    var union =  this.constructClone(this);
+    union.addEach(that);
+    return union;
+};
+
+GenericSet.prototype.intersection = function (that) {
+    return this.constructClone(this.filter(function (value) {
+        return that.has(value);
+    }));
+};
+
+GenericSet.prototype.difference = function (that) {
+    var union =  this.constructClone(this);
+    union.deleteEach(that);
+    return union;
+};
+
+GenericSet.prototype.symmetricDifference = function (that) {
+    var union = this.union(that);
+    var intersection = this.intersection(that);
+    return union.difference(intersection);
+};
+
+GenericSet.prototype.equals = function (that, equals) {
+    var self = this;
+    return (
+        Object.can(that, "reduce") &&
+        this.length === that.length &&
+        that.reduce(function (equal, value) {
+            return equal && self.has(value, equals);
+        }, true)
+    );
+};
+
+// W3C DOMTokenList API overlap (does not handle variadic arguments)
+
+GenericSet.prototype.contains = function (value) {
+    return this.has(value);
+};
+
+GenericSet.prototype.remove = function (value) {
+    return this["delete"](value);
+};
+
+GenericSet.prototype.toggle = function (value) {
+    if (this.has(value)) {
+        this["delete"](value);
+    } else {
+        this.add(value);
+    }
+};
+

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/heap.js

@@ -0,0 +1,236 @@
+
+// Adapted from Eloquent JavaScript by Marijn Haverbeke
+// http://eloquentjavascript.net/appendix2.html
+
+var ArrayChanges = require("./listen/array-changes");
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var MapChanges = require("./listen/map-changes");
+var RangeChanges = require("./listen/range-changes");
+var PropertyChanges = require("./listen/property-changes");
+
+// Max Heap by default.  Comparison can be reversed to produce a Min Heap.
+
+module.exports = Heap;
+
+function Heap(values, equals, compare) {
+    if (!(this instanceof Heap)) {
+        return new Heap(values, equals, compare);
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.content = [];
+    this.length = 0;
+    this.addEach(values);
+}
+
+Heap.Heap = Heap; // hack so require("heap").Heap will work in MontageJS
+
+Object.addEach(Heap.prototype, GenericCollection.prototype);
+Object.addEach(Heap.prototype, PropertyChanges.prototype);
+Object.addEach(Heap.prototype, RangeChanges.prototype);
+Object.addEach(Heap.prototype, MapChanges.prototype);
+
+Heap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare
+    );
+};
+
+Heap.prototype.push = function (value) {
+    this.content.push(value);
+    this.float(this.content.length - 1);
+    this.length++;
+};
+
+Heap.prototype.pop = function () {
+    // Store the first value so we can return it later.  This will leave a gap
+    // at index 0 that must be filled.
+    var result = this.content[0];
+    // Remove the value at the end of the array.  The value most be removed
+    // from the end to preserve the completness of the tree, despite that the
+    // last child is also among the most likely to need to sink back to the
+    // bottom.
+    var top = this.content.pop();
+    // If there are any values remaining, put the last value on the top and
+    // let it sink back down.
+    if (this.content.length > 0) {
+        this.content.set(0, top);
+        this.sink(0);
+    }
+    this.length--;
+    return result;
+};
+
+Heap.prototype.add = function (value) {
+    this.push(value);
+};
+
+// indexOf must do a linear search since a binary heap does not preserve a
+// strict sort order.  Thus, deletion takes linear time for all values except
+// for the max value.
+
+Heap.prototype.indexOf = function (value) {
+    for (var index = 0; index < this.length; index++) {
+        if (this.contentEquals(this.content[index], value)) {
+            return index;
+        }
+    }
+    return -1;
+};
+
+Heap.prototype.delete = function (value) {
+    var index = this.indexOf(value);
+    if (index === -1)
+        return false;
+    var top = this.content.pop();
+    if (index === this.content.length)
+        return true;
+    this.content.set(index, top);
+    var comparison = this.contentCompare(top, value);
+    if (comparison > 0) {
+        this.float(index);
+    } else if (comparison < 0) {
+        this.sink(index);
+    }
+    this.length--;
+    return true;
+};
+
+Heap.prototype.peek = function () {
+    if (this.length) {
+        return this.content[0];
+    }
+};
+
+Heap.prototype.max = function () {
+    return this.peek();
+};
+
+Heap.prototype.one = function () {
+    return this.peek();
+};
+
+// Brings a value up until its parent is greater than it
+Heap.prototype.float = function (index) {
+    // Grab the value that is being adjusted
+    var value = this.content[index];
+    // A value can go no higher that the top: index 0
+    while (index > 0) {
+        // Compute the parent value's index and fetch it
+        var parentIndex = Math.floor((index + 1) / 2) - 1;
+        var parent = this.content[parentIndex];
+        // If the parent is less than it
+        if (this.contentCompare(parent, value) < 0) {
+            this.content.set(parentIndex, value);
+            this.content.set(index, parent);
+        } else {
+            // Stop propagating if the parent is greater than the value.
+            break;
+        }
+        // Proceed upward
+        index = parentIndex;
+    }
+};
+
+// Brings a value down until its children are both less than it
+Heap.prototype.sink = function (index) {
+    // Moves a value downward until it is greater than its children.
+    var length = this.content.length;
+    var value = this.content[index];
+    var left, right, leftIndex, rightIndex, swapIndex, needsSwap;
+
+    while (true) {
+        // Invariant: the value is at index.
+        // Variant: the index proceedes down the tree.
+
+        // Compute the indicies of the children.
+        rightIndex = (index + 1) * 2;
+        leftIndex = rightIndex - 1;
+
+        // If the left child exists, determine whether it is greater than the
+        // parent (value) and thus whether it can be floated upward.
+        needsSwap = false;
+        if (leftIndex < length) {
+            // Look it up and compare it.
+            var left = this.content[leftIndex];
+            var comparison = this.contentCompare(left, value);
+            // If the child is greater than the parent, it can be floated.
+            if (comparison > 0) {
+                swapIndex = leftIndex;
+                needsSwap = true;
+            }
+        }
+
+        // If the right child exists, determine whether it is greater than the
+        // parent (value), or even greater than the left child.
+        if (rightIndex < length) {
+            var right = this.content[rightIndex];
+            var comparison = this.contentCompare(right, needsSwap ? left : value);
+            if (comparison > 0) {
+                swapIndex = rightIndex;
+                needsSwap = true;
+            }
+        }
+
+        // if there is a child that is less than the value, float the child and
+        // sink the value.
+        if (needsSwap) {
+            this.content.set(index, this.content[swapIndex]);
+            this.content.set(swapIndex, value);
+            index = swapIndex;
+            // and continue sinking
+        } else {
+            // if the children are both less than the value
+            break;
+        }
+
+    }
+
+};
+
+Heap.prototype.clear = function () {
+    this.content.clear();
+    this.length = 0;
+};
+
+Heap.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.content.reduce(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+Heap.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.content.reduceRight(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+Heap.prototype.makeObservable = function () {
+    // TODO refactor dispatchers to allow direct forwarding
+    this.content.addRangeChangeListener(this, "content");
+    this.content.addBeforeRangeChangeListener(this, "content");
+    this.content.addMapChangeListener(this, "content");
+    this.content.addBeforeMapChangeListener(this, "content");
+};
+
+Heap.prototype.handleContentRangeChange = function (plus, minus, index) {
+    this.dispatchRangeChange(plus, minus, index);
+};
+
+Heap.prototype.handleContentRangeWillChange = function (plus, minus, index) {
+    this.dispatchBeforeRangeChange(plus, minus, index);
+};
+
+Heap.prototype.handleContentMapChange = function (value, key) {
+    this.dispatchMapChange(key, value);
+};
+
+Heap.prototype.handleContentMapWillChange = function (value, key) {
+    this.dispatchBeforeMapChange(key, value);
+};
+