traceur-rb 0.0.1 → 0.0.2

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

@@ -1,186 +0,0 @@
-"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

@@ -1,55 +0,0 @@
-
-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

@@ -1,59 +0,0 @@
-
-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

@@ -1,236 +0,0 @@
-
-// 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);
-};
-