traceur-rb 0.0.1

data/vendor/node_modules/traceur/node_modules/q-io/node_modules/collections/listen/range-changes.js

@@ -0,0 +1,139 @@
+"use strict";
+
+var WeakMap = require("weak-map");
+var Dict = require("../dict");
+
+var rangeChangeDescriptors = new WeakMap(); // {isActive, willChangeListeners, changeListeners}
+
+module.exports = RangeChanges;
+function RangeChanges() {
+    throw new Error("Can't construct. RangeChanges is a mixin.");
+}
+
+RangeChanges.prototype.getAllRangeChangeDescriptors = function () {
+    if (!rangeChangeDescriptors.has(this)) {
+        rangeChangeDescriptors.set(this, Dict());
+    }
+    return rangeChangeDescriptors.get(this);
+};
+
+RangeChanges.prototype.getRangeChangeDescriptor = function (token) {
+    var tokenChangeDescriptors = this.getAllRangeChangeDescriptors();
+    token = token || "";
+    if (!tokenChangeDescriptors.has(token)) {
+        tokenChangeDescriptors.set(token, {
+            isActive: false,
+            changeListeners: [],
+            willChangeListeners: []
+        });
+    }
+    return tokenChangeDescriptors.get(token);
+};
+
+RangeChanges.prototype.addRangeChangeListener = function (listener, token, beforeChange) {
+    // a concession for objects like Array that are not inherently observable
+    if (!this.isObservable && this.makeObservable) {
+        this.makeObservable();
+    }
+
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    // even if already registered
+    listeners.push(listener);
+    Object.defineProperty(this, "dispatchesRangeChanges", {
+        value: true,
+        writable: true,
+        configurable: true,
+        enumerable: false
+    });
+
+    var self = this;
+    return function cancelRangeChangeListener() {
+        if (!self) {
+            // TODO throw new Error("Range change listener " + JSON.stringify(token) + " has already been canceled");
+            return;
+        }
+        self.removeRangeChangeListener(listener, token, beforeChange);
+        self = null;
+    };
+};
+
+RangeChanges.prototype.removeRangeChangeListener = function (listener, token, beforeChange) {
+    var descriptor = this.getRangeChangeDescriptor(token);
+
+    var listeners;
+    if (beforeChange) {
+        listeners = descriptor.willChangeListeners;
+    } else {
+        listeners = descriptor.changeListeners;
+    }
+
+    var index = listeners.lastIndexOf(listener);
+    if (index === -1) {
+        throw new Error("Can't remove listener: does not exist.");
+    }
+    listeners.splice(index, 1);
+};
+
+RangeChanges.prototype.dispatchRangeChange = function (plus, minus, index, beforeChange) {
+    var descriptors = this.getAllRangeChangeDescriptors();
+    var changeName = "Range" + (beforeChange ? "WillChange" : "Change");
+    descriptors.forEach(function (descriptor, token) {
+
+        if (descriptor.isActive) {
+            return;
+        } else {
+            descriptor.isActive = true;
+        }
+
+        // before or after
+        var listeners;
+        if (beforeChange) {
+            listeners = descriptor.willChangeListeners;
+        } else {
+            listeners = descriptor.changeListeners;
+        }
+
+        var tokenName = "handle" + (
+            token.slice(0, 1).toUpperCase() +
+            token.slice(1)
+        ) + changeName;
+        // notably, defaults to "handleRangeChange" or "handleRangeWillChange"
+        // if token is "" (the default)
+
+        // dispatch each listener
+        try {
+            listeners.forEach(function (listener) {
+                if (listener[tokenName]) {
+                    listener[tokenName](plus, minus, index, this, beforeChange);
+                } else if (listener.call) {
+                    listener.call(this, plus, minus, index, this, beforeChange);
+                } else {
+                    throw new Error("Handler " + listener + " has no method " + tokenName + " and is not callable");
+                }
+            }, this);
+        } finally {
+            descriptor.isActive = false;
+        }
+    }, this);
+};
+
+RangeChanges.prototype.addBeforeRangeChangeListener = function (listener, token) {
+    return this.addRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.removeBeforeRangeChangeListener = function (listener, token) {
+    return this.removeRangeChangeListener(listener, token, true);
+};
+
+RangeChanges.prototype.dispatchBeforeRangeChange = function (plus, minus, index) {
+    return this.dispatchRangeChange(plus, minus, index, true);
+};
+

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

@@ -0,0 +1,79 @@
+"use strict";
+
+var Shim = require("./shim");
+var LruSet = require("./lru-set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = LruMap;
+
+function LruMap(values, maxLength, equals, hash, getDefault) {
+    if (!(this instanceof LruMap)) {
+        return new LruMap(values, maxLength, 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 LruSet(
+        undefined,
+        maxLength,
+        function keysEqual(a, b) {
+            return equals(a.key, b.key);
+        },
+        function keyHash(item) {
+            return hash(item.key);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+LruMap.LruMap = LruMap; // hack so require("lru-map").LruMap will work in MontageJS
+
+Object.addEach(LruMap.prototype, GenericCollection.prototype);
+Object.addEach(LruMap.prototype, GenericMap.prototype);
+Object.addEach(LruMap.prototype, PropertyChanges.prototype);
+
+LruMap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.maxLength,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+LruMap.prototype.log = function (charmap, stringify) {
+    stringify = stringify || this.stringify;
+    this.store.log(charmap, stringify);
+};
+
+LruMap.prototype.stringify = function (item, leader) {
+    return leader + JSON.stringify(item.key) + ": " + JSON.stringify(item.value);
+};
+
+LruMap.prototype.addMapChangeListener = function () {
+    if (!this.dispatchesMapChanges) {
+        // Detect LRU deletions in the LruSet and emit as MapChanges.
+        // Array and Heap have no store.
+        // Dict and FastMap define no listeners on their store.
+        var self = this;
+        this.store.addBeforeRangeChangeListener(function(plus, minus) {
+            if (plus.length && minus.length) {  // LRU item pruned
+                self.dispatchBeforeMapChange(minus[0].key, undefined);
+            }
+        });
+        this.store.addRangeChangeListener(function(plus, minus) {
+            if (plus.length && minus.length) {
+                self.dispatchMapChange(minus[0].key, undefined);
+            }
+        });
+    }
+    GenericMap.prototype.addMapChangeListener.apply(this, arguments);
+};
+

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

@@ -0,0 +1,142 @@
+"use strict";
+
+var Shim = require("./shim");
+var Set = require("./set");
+var GenericCollection = require("./generic-collection");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+module.exports = LruSet;
+
+function LruSet(values, maxLength, equals, hash, getDefault) {
+    if (!(this instanceof LruSet)) {
+        return new LruSet(values, maxLength, equals, hash, getDefault);
+    }
+    maxLength = maxLength || Infinity;
+    equals = equals || Object.equals;
+    hash = hash || Object.hash;
+    getDefault = getDefault || Function.noop;
+    this.store = new Set(undefined, equals, hash);
+    this.contentEquals = equals;
+    this.contentHash = hash;
+    this.getDefault = getDefault;
+    this.maxLength = maxLength;
+    this.length = 0;
+    this.addEach(values);
+}
+
+LruSet.LruSet = LruSet; // hack so require("lru-set").LruSet will work in MontageJS
+
+Object.addEach(LruSet.prototype, GenericCollection.prototype);
+Object.addEach(LruSet.prototype, GenericSet.prototype);
+Object.addEach(LruSet.prototype, PropertyChanges.prototype);
+Object.addEach(LruSet.prototype, RangeChanges.prototype);
+
+LruSet.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.maxLength,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+LruSet.prototype.has = function (value) {
+    return this.store.has(value);
+};
+
+LruSet.prototype.get = function (value) {
+    value = this.store.get(value);
+    if (value !== undefined) {
+        this.store["delete"](value);
+        this.store.add(value);
+    } else {
+        value = this.getDefault(value);
+    }
+    return value;
+};
+
+LruSet.prototype.add = function (value) {
+    var found = this.store.has(value);
+    var plus = [], minus = [], eldest;
+    // if the value already exists, we delete it and add it back again so it
+    // appears at the end of the list of values to truncate
+    if (found) {    // update
+        this.store["delete"](value);
+        this.store.add(value);
+    } else if (this.maxLength > 0) {    // add
+        // because minus is constructed before adding value, we must ensure the
+        // set has positive length. hence the maxLength check.
+        plus.push(value);
+        if (this.length >= this.maxLength) {
+            eldest = this.store.order.head.next;
+            minus.push(eldest.value);
+        }
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange(plus, minus, 0);
+        }
+        this.store.add(value);
+        if (minus.length > 0) {
+            this.store['delete'](eldest.value);
+        }
+        // only assign to length once to avoid jitter on length observers
+        this.length = this.length + plus.length - minus.length;
+        // after change
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange(plus, minus, 0);
+        }
+    }
+    // whether it grew
+    return plus.length !== minus.length;
+};
+
+LruSet.prototype["delete"] = function (value) {
+    var found = this.store.has(value);
+    if (found) {
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([], [value], 0);
+        }
+        this.store["delete"](value);
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([], [value], 0);
+        }
+    }
+    return found;
+};
+
+LruSet.prototype.one = function () {
+    if (this.length > 0) {
+        return this.store.one();
+    }
+};
+
+LruSet.prototype.clear = function () {
+    this.store.clear();
+    this.length = 0;
+};
+
+LruSet.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var set = this.store;
+    var index = 0;
+    return set.reduce(function (basis, value) {
+        return callback.call(thisp, basis, value, index++, this);
+    }, basis, this);
+};
+
+LruSet.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var set = this.store;
+    var index = this.length - 1;
+    return set.reduceRight(function (basis, value) {
+        return callback.call(thisp, basis, value, index--, this);
+    }, basis, this);
+};
+
+LruSet.prototype.iterate = function () {
+    return this.store.iterate();
+};
+

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

@@ -0,0 +1,60 @@
+"use strict";
+
+var Shim = require("./shim");
+var Set = require("./set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = Map;
+
+function Map(values, equals, hash, getDefault) {
+    if (!(this instanceof Map)) {
+        return new Map(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);
+}
+
+Map.Map = Map; // hack so require("map").Map will work in MontageJS
+
+Object.addEach(Map.prototype, GenericCollection.prototype);
+Object.addEach(Map.prototype, GenericMap.prototype); // overrides GenericCollection
+Object.addEach(Map.prototype, PropertyChanges.prototype);
+
+Map.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentHash,
+        this.getDefault
+    );
+};
+
+Map.prototype.log = function (charmap, logNode, callback, thisp) {
+    logNode = logNode || this.logNode;
+    this.store.log(charmap, function (node, log, logBefore) {
+        logNode(node.value.value, log, logBefore);
+    }, callback, thisp);
+};
+
+Map.prototype.logNode = function (node, log) {
+    log(' key: ' + node.key);
+    log(' value: ' + node.value);
+};
+

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

@@ -0,0 +1,41 @@
+"use strict";
+
+var Map = require("./map");
+
+module.exports = MultiMap;
+function MultiMap(values, bucket, equals, hash) {
+    if (!(this instanceof MultiMap)) {
+        return new MultiMap(values, bucket, equals, hash);
+    }
+    this.bucket = bucket || this.bucket;
+    Map.call(this, values, equals, hash, function getDefault(key) {
+        var bucket = this.bucket();
+        Map.prototype.set.call(this, key, bucket);
+        return bucket;
+    });
+}
+
+MultiMap.MultiMap = MultiMap; // hack so require("multi-map").MultiMap will work in MontageJS
+
+MultiMap.prototype = Object.create(Map.prototype);
+
+MultiMap.prototype.constructor = MultiMap;
+
+MultiMap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.bucket,
+        this.contentEquals,
+        this.contentHash
+    );
+};
+
+MultiMap.prototype.set = function (key, newValues) {
+    var values = this.get(key);
+    values.swap(0, values.length, newValues);
+};
+
+MultiMap.prototype.bucket = function (key) {
+    return [];
+};
+