traceur-rb 0.0.1

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

@@ -0,0 +1,371 @@
+"use strict";
+
+module.exports = Iterator;
+
+var Object = require("./shim-object");
+var GenericCollection = require("./generic-collection");
+
+// upgrades an iterable to a Iterator
+function Iterator(iterable) {
+
+    if (!(this instanceof Iterator)) {
+        return new Iterator(iterable);
+    }
+
+    if (Array.isArray(iterable) || typeof iterable === "string")
+        return Iterator.iterate(iterable);
+
+    iterable = Object(iterable);
+
+    if (iterable instanceof Iterator) {
+        return iterable;
+    } else if (iterable.next) {
+        this.next = function () {
+            return iterable.next();
+        };
+    } else if (iterable.iterate) {
+        var iterator = iterable.iterate();
+        this.next = function () {
+            return iterator.next();
+        };
+    } else if (Object.prototype.toString.call(iterable) === "[object Function]") {
+        this.next = iterable;
+    } else {
+        throw new TypeError("Can't iterate " + iterable);
+    }
+
+}
+
+Iterator.prototype.forEach = GenericCollection.prototype.forEach;
+Iterator.prototype.map = GenericCollection.prototype.map;
+Iterator.prototype.filter = GenericCollection.prototype.filter;
+Iterator.prototype.every = GenericCollection.prototype.every;
+Iterator.prototype.some = GenericCollection.prototype.some;
+Iterator.prototype.any = GenericCollection.prototype.any;
+Iterator.prototype.all = GenericCollection.prototype.all;
+Iterator.prototype.min = GenericCollection.prototype.min;
+Iterator.prototype.max = GenericCollection.prototype.max;
+Iterator.prototype.sum = GenericCollection.prototype.sum;
+Iterator.prototype.average = GenericCollection.prototype.average;
+Iterator.prototype.flatten = GenericCollection.prototype.flatten;
+Iterator.prototype.zip = GenericCollection.prototype.zip;
+Iterator.prototype.enumerate = GenericCollection.prototype.enumerate;
+Iterator.prototype.sorted = GenericCollection.prototype.sorted;
+Iterator.prototype.group = GenericCollection.prototype.group;
+Iterator.prototype.reversed = GenericCollection.prototype.reversed;
+Iterator.prototype.toArray = GenericCollection.prototype.toArray;
+Iterator.prototype.toObject = GenericCollection.prototype.toObject;
+Iterator.prototype.iterator = GenericCollection.prototype.iterator;
+
+// this is a bit of a cheat so flatten and such work with the generic
+// reducible
+Iterator.prototype.constructClone = function (values) {
+    var clone = [];
+    clone.addEach(values);
+    return clone;
+};
+
+Iterator.prototype.mapIterator = function (callback /*, thisp*/) {
+    var self = Iterator(this),
+        thisp = arguments[1],
+        i = 0;
+
+    if (Object.prototype.toString.call(callback) != "[object Function]")
+        throw new TypeError();
+
+    return new self.constructor(function () {
+        return callback.call(thisp, self.next(), i++, self);
+    });
+};
+
+Iterator.prototype.filterIterator = function (callback /*, thisp*/) {
+    var self = Iterator(this),
+        thisp = arguments[1],
+        i = 0;
+
+    if (Object.prototype.toString.call(callback) != "[object Function]")
+        throw new TypeError();
+
+    return new self.constructor(function () {
+        var value;
+        while (true) {
+            value = self.next();
+            if (callback.call(thisp, value, i++, self))
+                return value;
+        }
+    });
+};
+
+Iterator.prototype.reduce = function (callback /*, initial, thisp*/) {
+    var self = Iterator(this),
+        result = arguments[1],
+        thisp = arguments[2],
+        i = 0,
+        value;
+
+    if (Object.prototype.toString.call(callback) != "[object Function]")
+        throw new TypeError();
+
+    // first iteration unrolled
+    try {
+        value = self.next();
+        if (arguments.length > 1) {
+            result = callback.call(thisp, result, value, i, self);
+        } else {
+            result = value;
+        }
+        i++;
+    } catch (exception) {
+        if (isStopIteration(exception)) {
+            if (arguments.length > 1) {
+                return arguments[1]; // initial
+            } else {
+                throw TypeError("cannot reduce a value from an empty iterator with no initial value");
+            }
+        } else {
+            throw exception;
+        }
+    }
+
+    // remaining entries
+    try {
+        while (true) {
+            value = self.next();
+            result = callback.call(thisp, result, value, i, self);
+            i++;
+        }
+    } catch (exception) {
+        if (isStopIteration(exception)) {
+            return result;
+        } else {
+            throw exception;
+        }
+    }
+
+};
+
+Iterator.prototype.concat = function () {
+    return Iterator.concat(
+        Array.prototype.concat.apply(this, arguments)
+    );
+};
+
+Iterator.prototype.dropWhile = function (callback /*, thisp */) {
+    var self = Iterator(this),
+        thisp = arguments[1],
+        stopped = false,
+        stopValue;
+
+    if (Object.prototype.toString.call(callback) != "[object Function]")
+        throw new TypeError();
+
+    self.forEach(function (value, i) {
+        if (!callback.call(thisp, value, i, self)) {
+            stopped = true;
+            stopValue = value;
+            throw StopIteration;
+        }
+    });
+
+    if (stopped) {
+        return self.constructor([stopValue]).concat(self);
+    } else {
+        return self.constructor([]);
+    }
+};
+
+Iterator.prototype.takeWhile = function (callback /*, thisp*/) {
+    var self = Iterator(this),
+        thisp = arguments[1];
+
+    if (Object.prototype.toString.call(callback) != "[object Function]")
+        throw new TypeError();
+
+    return self.mapIterator(function (value, i) {
+        if (!callback.call(thisp, value, i, self))
+            throw StopIteration;
+        return value;
+    });
+};
+
+Iterator.prototype.zipIterator = function () {
+    return Iterator.unzip(
+        Array.prototype.concat.apply(this, arguments)
+    );
+};
+
+Iterator.prototype.enumerateIterator = function (start) {
+    return Iterator.count(start).zipIterator(this);
+};
+
+// creates an iterator for Array and String
+Iterator.iterate = function (iterable) {
+    var start;
+    start = 0;
+    return new Iterator(function () {
+        // advance to next owned entry
+        if (typeof iterable === "object") {
+            while (!(start in iterable)) {
+                // deliberately late bound
+                if (start >= iterable.length)
+                    throw StopIteration;
+                start += 1;
+            }
+        } else if (start >= iterable.length) {
+            throw StopIteration;
+        }
+        var result = iterable[start];
+        start += 1;
+        return result;
+    });
+};
+
+Iterator.cycle = function (cycle, times) {
+    if (arguments.length < 2)
+        times = Infinity;
+    //cycle = Iterator(cycle).toArray();
+    var next = function () {
+        throw StopIteration;
+    };
+    return new Iterator(function () {
+        var iteration;
+        try {
+            return next();
+        } catch (exception) {
+            if (isStopIteration(exception)) {
+                if (times <= 0)
+                    throw exception;
+                times--;
+                iteration = Iterator.iterate(cycle);
+                next = iteration.next.bind(iteration);
+                return next();
+            } else {
+                throw exception;
+            }
+        }
+    });
+};
+
+Iterator.concat = function (iterators) {
+    iterators = Iterator(iterators);
+    var next = function () {
+        throw StopIteration;
+    };
+    return new Iterator(function (){
+        var iteration;
+        try {
+            return next();
+        } catch (exception) {
+            if (isStopIteration(exception)) {
+                iteration = Iterator(iterators.next());
+                next = iteration.next.bind(iteration);
+                return next();
+            } else {
+                throw exception;
+            }
+        }
+    });
+};
+
+Iterator.unzip = function (iterators) {
+    iterators = Iterator(iterators).map(Iterator);
+    if (iterators.length === 0)
+        return new Iterator([]);
+    return new Iterator(function () {
+        var stopped;
+        var result = iterators.map(function (iterator) {
+            try {
+                return iterator.next();
+            } catch (exception) {
+                if (isStopIteration(exception)) {
+                    stopped = true;
+                } else {
+                    throw exception;
+                }
+            }
+        });
+        if (stopped) {
+            throw StopIteration;
+        }
+        return result;
+    });
+};
+
+Iterator.zip = function () {
+    return Iterator.unzip(
+        Array.prototype.slice.call(arguments)
+    );
+};
+
+Iterator.chain = function () {
+    return Iterator.concat(
+        Array.prototype.slice.call(arguments)
+    );
+};
+
+Iterator.range = function (start, stop, step) {
+    if (arguments.length < 3) {
+        step = 1;
+    }
+    if (arguments.length < 2) {
+        stop = start;
+        start = 0;
+    }
+    start = start || 0;
+    step = step || 1;
+    return new Iterator(function () {
+        if (start >= stop)
+            throw StopIteration;
+        var result = start;
+        start += step;
+        return result;
+    });
+};
+
+Iterator.count = function (start, step) {
+    return Iterator.range(start, Infinity, step);
+};
+
+Iterator.repeat = function (value, times) {
+    return new Iterator.range(times).mapIterator(function () {
+        return value;
+    });
+};
+
+// shim isStopIteration
+if (typeof isStopIteration === "undefined") {
+    global.isStopIteration = function (exception) {
+        return Object.prototype.toString.call(exception) === "[object StopIteration]";
+    };
+}
+
+// shim StopIteration
+if (typeof StopIteration === "undefined") {
+    global.StopIteration = {};
+    Object.prototype.toString = (function (toString) {
+        return function () {
+            if (
+                this === global.StopIteration ||
+                this instanceof global.ReturnValue
+            )
+                return "[object StopIteration]";
+            else
+                return toString.call(this, arguments);
+        };
+    })(Object.prototype.toString);
+}
+
+// shim ReturnValue
+if (typeof ReturnValue === "undefined") {
+    global.ReturnValue = function ReturnValue(value) {
+        this.message = "Iteration stopped with " + value;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ReturnValue);
+        }
+        if (!(this instanceof global.ReturnValue))
+            return new global.ReturnValue(value);
+        this.value = value;
+    };
+    ReturnValue.prototype = Error.prototype;
+}
+

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

@@ -0,0 +1,435 @@
+"use strict";
+
+module.exports = List;
+
+var Shim = require("./shim");
+var GenericCollection = require("./generic-collection");
+var GenericOrder = require("./generic-order");
+var PropertyChanges = require("./listen/property-changes");
+var RangeChanges = require("./listen/range-changes");
+
+function List(values, equals, getDefault) {
+    if (!(this instanceof List)) {
+        return new List(values, equals, getDefault);
+    }
+    var head = this.head = new this.Node();
+    head.next = head;
+    head.prev = head;
+    this.contentEquals = equals || Object.equals;
+    this.getDefault = getDefault || Function.noop;
+    this.length = 0;
+    this.addEach(values);
+}
+
+List.List = List; // hack so require("list").List will work in MontageJS
+
+Object.addEach(List.prototype, GenericCollection.prototype);
+Object.addEach(List.prototype, GenericOrder.prototype);
+Object.addEach(List.prototype, PropertyChanges.prototype);
+Object.addEach(List.prototype, RangeChanges.prototype);
+
+List.prototype.constructClone = function (values) {
+    return new this.constructor(values, this.contentEquals, this.getDefault);
+};
+
+List.prototype.find = function (value, equals) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = head.next;
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.next;
+    }
+};
+
+List.prototype.findLast = function (value, equals) {
+    equals = equals || this.contentEquals;
+    var head = this.head;
+    var at = head.prev;
+    while (at !== head) {
+        if (equals(at.value, value)) {
+            return at;
+        }
+        at = at.prev;
+    }
+};
+
+List.prototype.has = function (value, equals) {
+    return !!this.find(value, equals);
+};
+
+List.prototype.get = function (value, equals) {
+    var found = this.find(value, equals);
+    if (found) {
+        return found.value;
+    }
+    return this.getDefault(value);
+};
+
+// LIFO (delete removes the most recently added equivalent value)
+List.prototype['delete'] = function (value, equals) {
+    var found = this.findLast(value, equals);
+    if (found) {
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, found.index);
+        }
+        found['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(found.next, found.index);
+            this.dispatchRangeChange(plus, minus, found.index);
+        }
+        return true;
+    }
+    return false;
+};
+
+List.prototype.clear = function () {
+    var plus, minus;
+    if (this.dispatchesRangeChanges) {
+        minus = this.toArray();
+        plus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    this.head.next = this.head.prev = this.head;
+    this.length = 0;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.add = function (value) {
+    var node = new this.Node(value)
+    if (this.dispatchesRangeChanges) {
+        node.index = this.length;
+        this.dispatchBeforeRangeChange([value], [], node.index);
+    }
+    this.head.addBefore(node);
+    this.length++;
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange([value], [], node.index);
+    }
+    return true;
+};
+
+List.prototype.push = function () {
+    var head = this.head;
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = []
+        var index = this.length;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+        var start = this.head.prev;
+    }
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        head.addBefore(node);
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(start.next, start.index === undefined ? 0 : start.index + 1);
+        this.dispatchRangeChange(plus, minus, index);
+    }
+};
+
+List.prototype.unshift = function () {
+    if (this.dispatchesRangeChanges) {
+        var plus = Array.prototype.slice.call(arguments);
+        var minus = [];
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    for (var i = 0; i < arguments.length; i++) {
+        var value = arguments[i];
+        var node = new this.Node(value);
+        at.addAfter(node);
+        at = node;
+    }
+    this.length += arguments.length;
+    if (this.dispatchesRangeChanges) {
+        this.updateIndexes(this.head.next, 0);
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+};
+
+List.prototype.pop = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.prev.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            var index = this.length - 1;
+            this.dispatchBeforeRangeChange(plus, minus, index);
+        }
+        head.prev['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.dispatchRangeChange(plus, minus, index);
+        }
+    }
+    return value;
+};
+
+List.prototype.shift = function () {
+    var value;
+    var head = this.head;
+    if (head.prev !== head) {
+        value = head.next.value;
+        if (this.dispatchesRangeChanges) {
+            var plus = [];
+            var minus = [value];
+            this.dispatchBeforeRangeChange(plus, minus, 0);
+        }
+        head.next['delete']();
+        this.length--;
+        if (this.dispatchesRangeChanges) {
+            this.updateIndexes(this.head.next, 0);
+            this.dispatchRangeChange(plus, minus, 0);
+        }
+    }
+    return value;
+};
+
+List.prototype.peek = function () {
+    if (this.head !== this.head.next) {
+        return this.head.next.value;
+    }
+};
+
+List.prototype.poke = function (value) {
+    if (this.head !== this.head.next) {
+        this.head.next.value = value;
+    } else {
+        this.push(value);
+    }
+};
+
+List.prototype.one = function () {
+    return this.peek();
+};
+
+// an internal utility for coercing index offsets to nodes
+List.prototype.scan = function (at, fallback) {
+    var head = this.head;
+    if (typeof at === "number") {
+        var count = at;
+        if (count >= 0) {
+            at = head.next;
+            while (count) {
+                count--;
+                at = at.next;
+                if (at == head) {
+                    break;
+                }
+            }
+        } else {
+            at = head;
+            while (count < 0) {
+                count++;
+                at = at.prev;
+                if (at == head) {
+                    break;
+                }
+            }
+        }
+        return at;
+    } else {
+        return at || fallback;
+    }
+};
+
+// at and end may both be positive or negative numbers (in which cases they
+// correspond to numeric indicies, or nodes)
+List.prototype.slice = function (at, end) {
+    var sliced = [];
+    var head = this.head;
+    at = this.scan(at, head.next);
+    end = this.scan(end, head);
+
+    while (at !== end && at !== head) {
+        sliced.push(at.value);
+        at = at.next;
+    }
+
+    return sliced;
+};
+
+List.prototype.splice = function (at, length /*...plus*/) {
+    return this.swap(at, length, Array.prototype.slice.call(arguments, 2));
+};
+
+List.prototype.swap = function (start, length, plus) {
+    var initial = start;
+    // start will be head if start is null or -1 (meaning from the end), but
+    // will be head.next if start is 0 (meaning from the beginning)
+    start = this.scan(start, this.head);
+    if (length == null) {
+        length = Infinity;
+    }
+    plus = Array.from(plus);
+
+    // collect the minus array
+    var minus = [];
+    var at = start;
+    while (length-- && length >= 0 && at !== this.head) {
+        minus.push(at.value);
+        at = at.next;
+    }
+
+    // before range change
+    var index, startNode;
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            index = this.length;
+        } else if (start.prev === this.head) {
+            index = 0;
+        } else {
+            index = start.index;
+        }
+        startNode = start.prev;
+        this.dispatchBeforeRangeChange(plus, minus, index);
+    }
+
+    // delete minus
+    var at = start;
+    for (var i = 0, at = start; i < minus.length; i++, at = at.next) {
+        at["delete"]();
+    }
+    // add plus
+    if (initial == null && at === this.head) {
+        at = this.head.next;
+    }
+    for (var i = 0; i < plus.length; i++) {
+        var node = new this.Node(plus[i]);
+        at.addBefore(node);
+    }
+    // adjust length
+    this.length += plus.length - minus.length;
+
+    // after range change
+    if (this.dispatchesRangeChanges) {
+        if (start === this.head) {
+            this.updateIndexes(this.head.next, 0);
+        } else {
+            this.updateIndexes(startNode.next, startNode.index + 1);
+        }
+        this.dispatchRangeChange(plus, minus, index);
+    }
+
+    return minus;
+};
+
+List.prototype.reverse = function () {
+    if (this.dispatchesRangeChanges) {
+        var minus = this.toArray();
+        var plus = minus.reversed();
+        this.dispatchBeforeRangeChange(plus, minus, 0);
+    }
+    var at = this.head;
+    do {
+        var temp = at.next;
+        at.next = at.prev;
+        at.prev = temp;
+        at = at.next;
+    } while (at !== this.head);
+    if (this.dispatchesRangeChanges) {
+        this.dispatchRangeChange(plus, minus, 0);
+    }
+    return this;
+};
+
+List.prototype.sort = function () {
+    this.swap(0, this.length, this.sorted());
+};
+
+// TODO account for missing basis argument
+List.prototype.reduce = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.next;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.next;
+    }
+    return basis;
+};
+
+List.prototype.reduceRight = function (callback, basis /*, thisp*/) {
+    var thisp = arguments[2];
+    var head = this.head;
+    var at = head.prev;
+    while (at !== head) {
+        basis = callback.call(thisp, basis, at.value, at, this);
+        at = at.prev;
+    }
+    return basis;
+};
+
+List.prototype.updateIndexes = function (node, index) {
+    while (node !== this.head) {
+        node.index = index++;
+        node = node.next;
+    }
+};
+
+List.prototype.makeObservable = function () {
+    this.head.index = -1;
+    this.updateIndexes(this.head.next, 0);
+    this.dispatchesRangeChanges = true;
+};
+
+List.prototype.iterate = function () {
+    return new ListIterator(this.head);
+};
+
+function ListIterator(head) {
+    this.head = head;
+    this.at = head.next;
+};
+
+ListIterator.prototype.next = function () {
+    if (this.at === this.head) {
+        throw StopIteration;
+    } else {
+        var value = this.at.value;
+        this.at = this.at.next;
+        return value;
+    }
+};
+
+List.prototype.Node = Node;
+
+function Node(value) {
+    this.value = value;
+    this.prev = null;
+    this.next = null;
+};
+
+Node.prototype['delete'] = function () {
+    this.prev.next = this.next;
+    this.next.prev = this.prev;
+};
+
+Node.prototype.addBefore = function (node) {
+    var prev = this.prev;
+    this.prev = node;
+    node.prev = prev;
+    prev.next = node;
+    node.next = this;
+};
+
+Node.prototype.addAfter = function (node) {
+    var next = this.next;
+    this.next = node;
+    node.next = next;
+    next.prev = node;
+    node.prev = this;
+};
+