traceur-rb 0.0.1

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

@@ -0,0 +1,14 @@
+
+/**
+    accepts a string; returns the string with regex metacharacters escaped.
+    the returned string can safely be used within a regex to match a literal
+    string. escaped characters are [, ], {, }, (, ), -, *, +, ?, ., \, ^, $,
+    |, #, [comma], and whitespace.
+*/
+if (!RegExp.escape) {
+    var special = /[-[\]{}()*+?.\\^$|,#\s]/g;
+    RegExp.escape = function (string) {
+        return string.replace(special, "\\$&");
+    };
+}
+

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

@@ -0,0 +1,6 @@
+
+var Array = require("./shim-array");
+var Object = require("./shim-object");
+var Function = require("./shim-function");
+var RegExp = require("./shim-regexp");
+

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

@@ -0,0 +1,49 @@
+"use strict";
+
+var Shim = require("./shim");
+var SortedArraySet = require("./sorted-array-set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = SortedArrayMap;
+
+function SortedArrayMap(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedArrayMap)) {
+        return new SortedArrayMap(values, equals, compare, getDefault);
+    }
+    equals = equals || Object.equals;
+    compare = compare || Object.compare;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentCompare = compare;
+    this.getDefault = getDefault;
+    this.store = new SortedArraySet(
+        null,
+        function keysEqual(a, b) {
+            return equals(a.key, b.key);
+        },
+        function compareKeys(a, b) {
+            return compare(a.key, b.key);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-array-map").SortedArrayMap will work in MontageJS
+SortedArrayMap.SortedArrayMap = SortedArrayMap;
+
+Object.addEach(SortedArrayMap.prototype, GenericCollection.prototype);
+Object.addEach(SortedArrayMap.prototype, GenericMap.prototype);
+Object.addEach(SortedArrayMap.prototype, PropertyChanges.prototype);
+
+SortedArrayMap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+

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

@@ -0,0 +1,51 @@
+"use strict";
+
+module.exports = SortedArraySet;
+
+var Shim = require("./shim");
+var SortedArray = require("./sorted-array");
+var GenericSet = require("./generic-set");
+var PropertyChanges = require("./listen/property-changes");
+
+function SortedArraySet(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedArraySet)) {
+        return new SortedArraySet(values, equals, compare, getDefault);
+    }
+    SortedArray.call(this, values, equals, compare, getDefault);
+}
+
+// hack so require("sorted-array-set".SortedArraySet works in MontageJS
+SortedArraySet.SortedArraySet = SortedArraySet;
+
+SortedArraySet.prototype = Object.create(SortedArray.prototype);
+
+SortedArraySet.prototype.constructor = SortedArraySet;
+
+Object.addEach(SortedArraySet.prototype, GenericSet.prototype);
+Object.addEach(SortedArraySet.prototype, PropertyChanges.prototype);
+
+SortedArraySet.prototype.add = function (value) {
+    if (!this.has(value)) {
+        SortedArray.prototype.add.call(this, value);
+        return true;
+    } else {
+        return false;
+    }
+};
+
+SortedArraySet.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var self = this;
+    var thisp = arguments[2];
+    return this.array.reduce(function (basis, value, index) {
+        return callback.call(thisp, basis, value, index, self);
+    }, basis);
+};
+
+SortedArraySet.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var self = this;
+    var thisp = arguments[2];
+    return this.array.reduceRight(function (basis, value, index) {
+        return callback.call(thisp, basis, value, index, self);
+    }, basis);
+};
+

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

@@ -0,0 +1,269 @@
+"use strict";
+
+module.exports = SortedArray;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+function SortedArray(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedArray)) {
+        return new SortedArray(values, equals, compare, getDefault);
+    }
+    if (Array.isArray(values)) {
+        this.array = values;
+        values = values.splice(0, values.length);
+    } else {
+        this.array = [];
+    }
+    this.contentEquals = equals || Object.equals;
+    this.contentCompare = compare || Object.compare;
+    this.getDefault = getDefault || Function.noop;
+
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-array").SortedArray will work in MontageJS
+SortedArray.SortedArray = SortedArray;
+
+Object.addEach(SortedArray.prototype, GenericCollection.prototype);
+Object.addEach(SortedArray.prototype, PropertyChanges.prototype);
+Object.addEach(SortedArray.prototype, RangeChanges.prototype);
+
+function search(array, value, compare) {
+    var first = 0;
+    var last = array.length - 1;
+    while (first <= last) {
+        var middle = (first + last) >> 1; // Math.floor( / 2)
+        var comparison = compare(value, array[middle]);
+        if (comparison > 0) {
+            first = middle + 1;
+        } else if (comparison < 0) {
+            last = middle - 1;
+        } else {
+            return middle;
+        }
+    }
+    return -(first + 1);
+}
+
+function searchFirst(array, value, compare, equals) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -1;
+    } else {
+        while (index > 0 && equals(value, array[index - 1])) {
+            index--;
+        }
+        if (!equals(value, array[index])) {
+            return -1;
+        } else {
+            return index;
+        }
+    }
+}
+
+function searchLast(array, value, compare, equals) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -1;
+    } else {
+        while (index < array.length - 1 && equals(value, array[index + 1])) {
+            index++;
+        }
+        if (!equals(value, array[index])) {
+            return -1;
+        } else {
+            return index;
+        }
+    }
+}
+
+function searchForInsertionIndex(array, value, compare) {
+    var index = search(array, value, compare);
+    if (index < 0) {
+        return -index - 1;
+    } else {
+        var last = array.length - 1;
+        while (index < last && compare(value, array[index + 1]) === 0) {
+            index++;
+        }
+        return index;
+    }
+}
+
+SortedArray.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+
+SortedArray.prototype.has = function (value) {
+    var index = search(this.array, value, this.contentCompare);
+    return index >= 0 && this.contentEquals(this.array[index], value);
+};
+
+SortedArray.prototype.get = function (value) {
+    var index = searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+    if (index !== -1) {
+        return this.array[index];
+    } else {
+        return this.getDefault(value);
+    }
+};
+
+SortedArray.prototype.add = function (value) {
+    var index = searchForInsertionIndex(this.array, value, this.contentCompare);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchBeforeRangeChange([value], [], index);
+    }
+    this.array.splice(index, 0, value);
+    this.length++;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([value], [], index);
+    }
+    return true;
+};
+
+SortedArray.prototype["delete"] = function (value) {
+    var index = searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+    if (index !== -1) {
+        if (this.dispatchesRangeChanges) {
+            this.dispatchBeforeRangeChange([], [value], index);
+        }
+        this.array.splice(index, 1);
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange([], [value], index);
+        }
+        return true;
+    } else {
+        return false;
+    }
+};
+
+SortedArray.prototype.indexOf = function (value) {
+    return searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.lastIndexOf = function (value) {
+    return searchLast(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.find = function (value) {
+    return searchFirst(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.findLast = function (value) {
+    return searchLast(this.array, value, this.contentCompare, this.contentEquals);
+};
+
+SortedArray.prototype.push = function () {
+    this.addEach(arguments);
+};
+
+SortedArray.prototype.unshift = function () {
+    this.addEach(arguments);
+};
+
+SortedArray.prototype.pop = function () {
+    return this.array.pop();
+};
+
+SortedArray.prototype.shift = function () {
+    return this.array.shift();
+};
+
+SortedArray.prototype.slice = function () {
+    return this.array.slice.apply(this.array, arguments);
+};
+
+SortedArray.prototype.splice = function (index, length /*...plus*/) {
+    return this.swap(index, length, Array.prototype.slice.call(arguments, 2));
+};
+
+SortedArray.prototype.swap = function (index, length, plus) {
+    if (index === undefined && length === undefined) {
+        return [];
+    }
+    index = index || 0;
+    if (index < 0) {
+        index += this.length;
+    }
+    if (length === undefined) {
+        length = Infinity;
+    }
+    var minus = this.slice(index, index + length);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchBeforeRangeChange(plus, minus, index);
+    }
+    this.array.splice(index, length);
+    this.addEach(plus);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, index);
+    }
+    return minus;
+};
+
+SortedArray.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    return this.array.reduce(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+SortedArray.prototype.reduceRight = function () {
+    var thisp = arguments[2];
+    return this.array.reduceRight(function (basis, value, key) {
+        return callback.call(thisp, basis, value, key, this);
+    }, basis, this);
+};
+
+SortedArray.prototype.min = function () {
+    if (this.length) {
+        return this.array[0];
+    }
+};
+
+SortedArray.prototype.max = function () {
+    if (this.length) {
+        return this.array[this.length - 1];
+    }
+};
+
+SortedArray.prototype.one = function () {
+    return this.array.one();
+};
+
+SortedArray.prototype.clear = function () {
+    var minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.array.slice();
+        this.dispatchBeforeRangeChange([], minus, 0);
+    }
+    this.length = 0;
+    this.array.clear();
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([], minus, 0);
+    }
+};
+
+SortedArray.prototype.equals = function (that, equals) {
+    return this.array.equals(that, equals);
+};
+
+SortedArray.prototype.compare = function (that, compare) {
+    return this.array.compare(that, compare);
+};
+
+SortedArray.prototype.iterate = function (start, end) {
+    return new this.Iterator(this.array, start, end);
+};
+
+SortedArray.prototype.Iterator = Array.prototype.Iterator;
+

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

@@ -0,0 +1,61 @@
+"use strict";
+
+var Shim = require("./shim");
+var SortedSet = require("./sorted-set");
+var GenericCollection = require("./generic-collection");
+var GenericMap = require("./generic-map");
+var PropertyChanges = require("./listen/property-changes");
+
+module.exports = SortedMap;
+
+function SortedMap(values, equals, compare, getDefault) {
+    if (!(this instanceof SortedMap)) {
+        return new SortedMap(values, equals, compare, getDefault);
+    }
+    equals = equals || Object.equals;
+    compare = compare || Object.compare;
+    getDefault = getDefault || Function.noop;
+    this.contentEquals = equals;
+    this.contentCompare = compare;
+    this.getDefault = getDefault;
+    this.store = new SortedSet(
+        null,
+        function keysEqual(a, b) {
+            return equals(a.key, b.key);
+        },
+        function compareKeys(a, b) {
+            return compare(a.key, b.key);
+        }
+    );
+    this.length = 0;
+    this.addEach(values);
+}
+
+// hack so require("sorted-map").SortedMap will work in MontageJS
+SortedMap.SortedMap = SortedMap;
+
+Object.addEach(SortedMap.prototype, GenericCollection.prototype);
+Object.addEach(SortedMap.prototype, GenericMap.prototype);
+Object.addEach(SortedMap.prototype, PropertyChanges.prototype);
+
+SortedMap.prototype.constructClone = function (values) {
+    return new this.constructor(
+        values,
+        this.contentEquals,
+        this.contentCompare,
+        this.getDefault
+    );
+};
+
+SortedMap.prototype.log = function (charmap, logNode, callback, thisp) {
+    logNode = logNode || this.logNode
+    this.store.log(charmap, function (node, log, logBefore) {
+        logNode(node.value, log, logBefore);
+    }, callback, thisp);
+};
+
+SortedMap.prototype.logNode = function (node, log) {
+    log(" key: " + node.key);
+    log(" value: " + node.value);
+};
+