traceur-rb 0.0.1

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

@@ -0,0 +1,22 @@
+
+// used exclusively to generate collections.min.js for browsers
+
+var Shim = require("./shim");
+
+global.List = require("./list");
+global.Set = require("./set");
+global.Map = require("./map");
+global.MultiMap = require("./multi-map");
+global.WeakMap = require("weak-map");
+global.SortedSet = require("./sorted-set");
+global.SortedMap = require("./sorted-map");
+global.LruSet = require("./lru-set");
+global.LruMap = require("./lru-map");
+global.SortedArray = require("./sorted-array");
+global.SortedArraySet = require("./sorted-array-set");
+global.SortedArrayMap = require("./sorted-array-map");
+global.FastSet = require("./fast-set");
+global.FastMap = require("./fast-map");
+global.Dict = require("./dict");
+global.Iterator = require("./iterator");
+

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

@@ -0,0 +1,142 @@
+"use strict";
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+// Burgled from https://github.com/domenic/dict
+
+module.exports = Dict;
+function Dict(values, getDefault) {
+    if (!(this instanceof Dict)) {
+        return new Dict(values, getDefault);
+    }
+    getDefault = getDefault || Function.noop;
+    this.getDefault = getDefault;
+    this.store = {};
+    this.length = 0;
+    this.addEach(values);
+}
+
+Dict.Dict = Dict; // hack so require("dict").Dict will work in MontageJS.
+
+function mangle(key) {
+    return "~" + key;
+}
+
+function unmangle(mangled) {
+    return mangled.slice(1);
+}
+
+Object.addEach(Dict.prototype, GenericCollection.prototype);
+Object.addEach(Dict.prototype, GenericMap.prototype);
+Object.addEach(Dict.prototype, PropertyChanges.prototype);
+
+Dict.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.mangle, this.getDefault);
+};
+
+Dict.prototype.assertString = function (key) {
+    if (typeof key !== "string") {
+        throw new TypeError("key must be a string but Got " + key);
+    }
+}
+
+Dict.prototype.get = function (key, defaultValue) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) {
+        return this.store[mangled];
+    } else if (arguments.length > 1) {
+        return defaultValue;
+    } else {
+        return this.getDefault(key);
+    }
+};
+
+Dict.prototype.set = function (key, value) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) { // update
+        if (this.dispatchesBeforeMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        this.store[mangled] = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return false;
+    } else { // create
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, undefined);
+        }
+        this.length++;
+        this.store[mangled] = value;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, value);
+        }
+        return true;
+    }
+};
+
+Dict.prototype.has = function (key) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    return mangled in this.store;
+};
+
+Dict.prototype["delete"] = function (key) {
+    this.assertString(key);
+    var mangled = mangle(key);
+    if (mangled in this.store) {
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        delete this.store[mangle(key)];
+        this.length--;
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+        return true;
+    }
+    return false;
+};
+
+Dict.prototype.clear = function () {
+    var key, mangled;
+    for (mangled in this.store) {
+        key = unmangle(mangled);
+        if (this.dispatchesMapChanges) {
+            this.dispatchBeforeMapChange(key, this.store[mangled]);
+        }
+        delete this.store[mangled];
+        if (this.dispatchesMapChanges) {
+            this.dispatchMapChange(key, undefined);
+        }
+    }
+    this.length = 0;
+};
+
+Dict.prototype.reduce = function (callback, basis, thisp) {
+    for (var mangled in this.store) {
+        basis = callback.call(thisp, basis, this.store[mangled], unmangle(mangled), this);
+    }
+    return basis;
+};
+
+Dict.prototype.reduceRight = function (callback, basis, thisp) {
+    var self = this;
+    var store = this.store;
+    return Object.keys(this.store).reduceRight(function (basis, mangled) {
+        return callback.call(thisp, basis, store[mangled], unmangle(mangled), self);
+    }, basis);
+};
+
+Dict.prototype.one = function () {
+    var key;
+    for (key in this.store) {
+        return this.store[key];
+    }
+};
+

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

@@ -0,0 +1,57 @@
+"use strict";
+
+var Shim = require("./shim");
+var Set = require("./fast-set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = FastMap;
+
+function FastMap(values, equals, hash, getDefault) {
+    if (!(this instanceof FastMap)) {
+        return new FastMap(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    this.store = new Set(
+        undefined,
+        function keysEqual(a, b) {
+            return equals(a.key, b.key);
+        },
+        function keyHash(item) {
+            return hash(item.key);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+FastMap.FastMap = FastMap; // hack so require("fast-map").FastMap will work in MontageJS
+
+Object.addEach(FastMap.prototype, GenericCollection.prototype);
+Object.addEach(FastMap.prototype, GenericMap.prototype);
+Object.addEach(FastMap.prototype, PropertyChanges.prototype);
+
+FastMap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+FastMap.prototype.log = function (charmap, stringify) {
+    stringify = stringify || this.stringify;
+    this.store.log(charmap, stringify);
+};
+
+FastMap.prototype.stringify = function (item, leader) {
+    return leader + JSON.stringify(item.key) + ": " + JSON.stringify(item.value);
+}
+

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

@@ -0,0 +1,183 @@
+"use strict";
+
+var Shim = require("./shim");
+var Dict = require("./dict");
+var List = require("./list");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var TreeLog = require("./tree-log");
+var PropertyChanges = require("./listen/property-changes");
+
+var object_has = Object.prototype.hasOwnProperty;
+
+module.exports = FastSet;
+
+function FastSet(values, equals, hash, getDefault) {
+    if (!(this instanceof FastSet)) {
+        return new FastSet(values, equals, hash, getDefault);
+    }
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    this.buckets = new this.Buckets(null, this.Bucket);
+    this.length = 0;
+    this.addEach(values);
+}
+
+FastSet.FastSet = FastSet; // hack so require("fast-set").FastSet will work in MontageJS
+
+Object.addEach(FastSet.prototype, GenericCollection.prototype);
+Object.addEach(FastSet.prototype, GenericSet.prototype);
+Object.addEach(FastSet.prototype, PropertyChanges.prototype);
+
+FastSet.prototype.Buckets = Dict;
+FastSet.prototype.Bucket = List;
+
+FastSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+FastSet.prototype.has = function (value) {
+    var hash = this.contentHash(value);
+    return this.buckets.get(hash).has(value);
+};
+
+FastSet.prototype.get = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        return buckets.get(hash).get(value);
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+FastSet.prototype['delete'] = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (buckets.has(hash)) {
+        var bucket = buckets.get(hash);
+        if (bucket["delete"](value)) {
+            this.length--;
+            if (bucket.length === 0) {
+                buckets["delete"](hash);
+            }
+            return true;
+        }
+    }
+    return false;
+};
+
+FastSet.prototype.clear = function () {
+    this.buckets.clear();
+    this.length = 0;
+};
+
+FastSet.prototype.add = function (value) {
+    var hash = this.contentHash(value);
+    var buckets = this.buckets;
+    if (!buckets.has(hash)) {
+        buckets.set(hash, new this.Bucket(null, this.contentEquals));
+    }
+    if (!buckets.get(hash).has(value)) {
+        buckets.get(hash).add(value);
+        this.length++;
+        return true;
+    }
+    return false;
+};
+
+FastSet.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var buckets = this.buckets;
+    var index = 0;
+    return buckets.reduce(function (basis, bucket) {
+        return bucket.reduce(function (basis, value) {
+            return callback.call(thisp, basis, value, index++, this);
+        }, basis, this);
+    }, basis, this);
+};
+
+FastSet.prototype.one = function () {
+    if (this.length > 0) {
+        return this.buckets.one().one();
+    }
+};
+
+FastSet.prototype.iterate = function () {
+    return this.buckets.values().flatten().iterate();
+};
+
+FastSet.prototype.log = function (charmap, logNode, callback, thisp) {
+    charmap = charmap || TreeLog.unicodeSharp;
+    logNode = logNode || this.logNode;
+    if (!callback) {
+        callback = console.log;
+        thisp = console;
+    }
+    callback = callback.bind(thisp);
+
+    var buckets = this.buckets;
+    var hashes = buckets.keys();
+    hashes.forEach(function (hash, index) {
+        var branch;
+        var leader;
+        if (index === hashes.length - 1) {
+            branch = charmap.fromAbove;
+            leader = ' ';
+        } else if (index === 0) {
+            branch = charmap.branchDown;
+            leader = charmap.strafe;
+        } else {
+            branch = charmap.fromBoth;
+            leader = charmap.strafe;
+        }
+        var bucket = buckets.get(hash);
+        callback.call(thisp, branch + charmap.through + charmap.branchDown + ' ' + hash);
+        bucket.forEach(function (value, node) {
+            var branch, below;
+            if (node === bucket.head.prev) {
+                branch = charmap.fromAbove;
+                below = ' ';
+            } else {
+                branch = charmap.fromBoth;
+                below = charmap.strafe;
+            }
+            var written;
+            logNode(
+                node,
+                function (line) {
+                    if (!written) {
+                        callback.call(thisp, leader + ' ' + branch + charmap.through + charmap.through + line);
+                        written = true;
+                    } else {
+                        callback.call(thisp, leader + ' ' + below + '  ' + line);
+                    }
+                },
+                function (line) {
+                    callback.call(thisp, leader + ' ' + charmap.strafe + '  ' + line);
+                }
+            );
+        });
+    });
+};
+
+FastSet.prototype.logNode = function (node, write) {
+    var value = node.value;
+    if (Object(value) === value) {
+        JSON.stringify(value, null, 4).split("\n").forEach(function (line) {
+            write(" " + line);
+        });
+    } else {
+        write(" " + value);
+    }
+};
+

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

@@ -0,0 +1,261 @@
+"use strict";
+
+module.exports = GenericCollection;
+function GenericCollection() {
+    throw new Error("Can't construct. GenericCollection is a mixin.");
+}
+
+GenericCollection.prototype.addEach = function (values) {
+    if (values && Object(values) === values) {
+        if (typeof values.forEach === "function") {
+            values.forEach(this.add, this);
+        } else if (typeof values.length === "number") {
+            // Array-like objects that do not implement forEach, ergo,
+            // Arguments
+            for (var i = 0; i < values.length; i++) {
+                this.add(values[i], i);
+            }
+        } else {
+            Object.keys(values).forEach(function (key) {
+                this.add(values[key], key);
+            }, this);
+        }
+    }
+    return this;
+};
+
+// This is sufficiently generic for Map (since the value may be a key)
+// and ordered collections (since it forwards the equals argument)
+GenericCollection.prototype.deleteEach = function (values, equals) {
+    values.forEach(function (value) {
+        this["delete"](value, equals);
+    }, this);
+    return this;
+};
+
+// all of the following functions are implemented in terms of "reduce".
+// some need "constructClone".
+
+GenericCollection.prototype.forEach = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (undefined, value, key, object, depth) {
+        callback.call(thisp, value, key, object, depth);
+    }, undefined);
+};
+
+GenericCollection.prototype.map = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = [];
+    this.reduce(function (undefined, value, key, object, depth) {
+        result.push(callback.call(thisp, value, key, object, depth));
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.enumerate = function (start) {
+    if (start == null) {
+        start = 0;
+    }
+    var result = [];
+    this.reduce(function (undefined, value) {
+        result.push([start++, value]);
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.group = function (callback, thisp, equals) {
+    equals = equals || Object.equals;
+    var groups = [];
+    var keys = [];
+    this.forEach(function (value, key, object) {
+        var key = callback.call(thisp, value, key, object);
+        var index = keys.indexOf(key, equals);
+        var group;
+        if (index === -1) {
+            group = [];
+            groups.push([key, group]);
+            keys.push(key);
+        } else {
+            group = groups[index][1];
+        }
+        group.push(value);
+    });
+    return groups;
+};
+
+GenericCollection.prototype.toArray = function () {
+    return this.map(Function.identity);
+};
+
+// this depends on stringable keys, which apply to Array and Iterator
+// because they have numeric keys and all Maps since they may use
+// strings as keys.  List, Set, and SortedSet have nodes for keys, so
+// toObject would not be meaningful.
+GenericCollection.prototype.toObject = function () {
+    var object = {};
+    this.reduce(function (undefined, value, key) {
+        object[key] = value;
+    }, undefined);
+    return object;
+};
+
+GenericCollection.prototype.filter = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    var result = this.constructClone();
+    this.reduce(function (undefined, value, key, object, depth) {
+        if (callback.call(thisp, value, key, object, depth)) {
+            result.add(value);
+        }
+    }, undefined);
+    return result;
+};
+
+GenericCollection.prototype.every = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result && callback.call(thisp, value, key, object, depth);
+    }, true);
+};
+
+GenericCollection.prototype.some = function (callback /*, thisp*/) {
+    var thisp = arguments[1];
+    return this.reduce(function (result, value, key, object, depth) {
+        return result || callback.call(thisp, value, key, object, depth);
+    }, false);
+};
+
+GenericCollection.prototype.all = function () {
+    return this.every(Boolean);
+};
+
+GenericCollection.prototype.any = function () {
+    return this.some(Boolean);
+};
+
+GenericCollection.prototype.min = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) < 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.max = function (compare) {
+    compare = compare || this.contentCompare || Object.compare;
+    var first = true;
+    return this.reduce(function (result, value) {
+        if (first) {
+            first = false;
+            return value;
+        } else {
+            return compare(value, result) > 0 ? value : result;
+        }
+    }, undefined);
+};
+
+GenericCollection.prototype.sum = function (zero) {
+    zero = zero === undefined ? 0 : zero;
+    return this.reduce(function (a, b) {
+        return a + b;
+    }, zero);
+};
+
+GenericCollection.prototype.average = function (zero) {
+    var sum = zero === undefined ? 0 : zero;
+    var count = zero === undefined ? 0 : zero;
+    this.reduce(function (undefined, value) {
+        sum += value;
+        count += 1;
+    }, undefined);
+    return sum / count;
+};
+
+GenericCollection.prototype.concat = function () {
+    var result = this.constructClone(this);
+    for (var i = 0; i < arguments.length; i++) {
+        result.addEach(arguments[i]);
+    }
+    return result;
+};
+
+GenericCollection.prototype.flatten = function () {
+    var self = this;
+    return this.reduce(function (result, array) {
+        array.forEach(function (value) {
+            this.push(value);
+        }, result, self);
+        return result;
+    }, []);
+};
+
+GenericCollection.prototype.zip = function () {
+    var table = Array.prototype.slice.call(arguments);
+    table.unshift(this);
+    return Array.unzip(table);
+}
+
+GenericCollection.prototype.join = function (delimiter) {
+    return this.reduce(function (result, string) {
+        return result + delimiter + string;
+    });
+};
+
+GenericCollection.prototype.sorted = function (compare, by, order) {
+    compare = compare || this.contentCompare || Object.compare;
+    // account for comparators generated by Function.by
+    if (compare.by) {
+        by = compare.by;
+        compare = compare.compare || this.contentCompare || Object.compare;
+    } else {
+        by = by || Function.identity;
+    }
+    if (order === undefined)
+        order = 1;
+    return this.map(function (item) {
+        return {
+            by: by(item),
+            value: item
+        };
+    })
+    .sort(function (a, b) {
+        return compare(a.by, b.by) * order;
+    })
+    .map(function (pair) {
+        return pair.value;
+    });
+};
+
+GenericCollection.prototype.reversed = function () {
+    return this.constructClone(this).reverse();
+};
+
+GenericCollection.prototype.clone = function (depth, memo) {
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return this;
+    }
+    var clone = this.constructClone();
+    this.forEach(function (value, key) {
+        clone.add(Object.clone(value, depth - 1, memo), key);
+    }, this);
+    return clone;
+};
+
+GenericCollection.prototype.only = function () {
+    if (this.length === 1) {
+        return this.one();
+    }
+};
+
+GenericCollection.prototype.iterator = function () {
+    return this.iterate.apply(this, arguments);
+};
+
+require("./shim-array");
+