traceur-rb 0.0.1

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

@@ -0,0 +1,59 @@
+
+module.exports = Function;
+
+/**
+    A utility to reduce unnecessary allocations of <code>function () {}</code>
+    in its many colorful variations.  It does nothing and returns
+    <code>undefined</code> thus makes a suitable default in some circumstances.
+
+    @function external:Function.noop
+*/
+Function.noop = function () {
+};
+
+/**
+    A utility to reduce unnecessary allocations of <code>function (x) {return
+    x}</code> in its many colorful but ultimately wasteful parameter name
+    variations.
+
+    @function external:Function.identity
+    @param {Any} any value
+    @returns {Any} that value
+*/
+Function.identity = function (value) {
+    return value;
+};
+
+/**
+    A utility for creating a comparator function for a particular aspect of a
+    figurative class of objects.
+
+    @function external:Function.by
+    @param {Function} relation A function that accepts a value and returns a
+    corresponding value to use as a representative when sorting that object.
+    @param {Function} compare an alternate comparator for comparing the
+    represented values.  The default is <code>Object.compare</code>, which
+    does a deep, type-sensitive, polymorphic comparison.
+    @returns {Function} a comparator that has been annotated with
+    <code>by</code> and <code>compare</code> properties so
+    <code>sorted</code> can perform a transform that reduces the need to call
+    <code>by</code> on each sorted object to just once.
+ */
+Function.by = function (by , compare) {
+    compare = compare || Object.compare;
+    by = by || Function.identity;
+    var compareBy = function (a, b) {
+        return compare(by(a), by(b));
+    };
+    compareBy.compare = compare;
+    compareBy.by = by;
+    return compareBy;
+};
+
+// TODO document
+Function.get = function (key) {
+    return function (object) {
+        return Object.get(object, key);
+    };
+};
+

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

@@ -0,0 +1,538 @@
+"use strict";
+
+var WeakMap = require("weak-map");
+
+module.exports = Object;
+
+/*
+    Based in part on extras from Motorola Mobility’s Montage
+    Copyright (c) 2012, Motorola Mobility LLC. All Rights Reserved.
+    3-Clause BSD License
+    https://github.com/motorola-mobility/montage/blob/master/LICENSE.md
+*/
+
+/**
+    Defines extensions to intrinsic <code>Object</code>.
+    @see [Object class]{@link external:Object}
+*/
+
+/**
+    A utility object to avoid unnecessary allocations of an empty object
+    <code>{}</code>.  This object is frozen so it is safe to share.
+
+    @object external:Object.empty
+*/
+Object.empty = Object.freeze(Object.create(null));
+
+/**
+    Returns whether the given value is an object, as opposed to a value.
+    Unboxed numbers, strings, true, false, undefined, and null are not
+    objects.  Arrays are objects.
+
+    @function external:Object.isObject
+    @param {Any} value
+    @returns {Boolean} whether the given value is an object
+*/
+Object.isObject = function (object) {
+    return Object(object) === object;
+};
+
+/**
+    Returns the value of an any value, particularly objects that
+    implement <code>valueOf</code>.
+
+    <p>Note that, unlike the precedent of methods like
+    <code>Object.equals</code> and <code>Object.compare</code> would suggest,
+    this method is named <code>Object.getValueOf</code> instead of
+    <code>valueOf</code>.  This is a delicate issue, but the basis of this
+    decision is that the JavaScript runtime would be far more likely to
+    accidentally call this method with no arguments, assuming that it would
+    return the value of <code>Object</code> itself in various situations,
+    whereas <code>Object.equals(Object, null)</code> protects against this case
+    by noting that <code>Object</code> owns the <code>equals</code> property
+    and therefore does not delegate to it.
+
+    @function external:Object.getValueOf
+    @param {Any} value a value or object wrapping a value
+    @returns {Any} the primitive value of that object, if one exists, or passes
+    the value through
+*/
+Object.getValueOf = function (value) {
+    if (Object.can(value, "valueOf")) {
+        value = value.valueOf();
+    }
+    return value;
+};
+
+var hashMap = new WeakMap();
+Object.hash = function (object) {
+    if (Object.can(object, "hash")) {
+        return "" + object.hash();
+    } else if (Object(object) === object) {
+        if (!hashMap.has(object)) {
+            hashMap.set(object, Math.random().toString(36).slice(2));
+        }
+        return hashMap.get(object);
+    } else {
+        return "" + object;
+    }
+};
+
+/**
+    A shorthand for <code>Object.prototype.hasOwnProperty.call(object,
+    key)</code>.  Returns whether the object owns a property for the given key.
+    It does not consult the prototype chain and works for any string (including
+    "hasOwnProperty") except "__proto__".
+
+    @function external:Object.owns
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object owns a property wfor the given key.
+*/
+var owns = Object.prototype.hasOwnProperty;
+Object.owns = function (object, key) {
+    return owns.call(object, key);
+};
+
+/**
+    Returns whether a value implements a particular duck-type method.
+
+    <p>To qualify as a duck-type method, the value in question must have a
+    method by the given name on the prototype chain.  To distinguish it from
+    a property of an object literal, the property must not be owned by the
+    object directly.
+
+    <p>A value that implements a method is not necessarily an object, for
+    example, numbers implement <code>valueOf</code>, so this is function
+    does not imply <code>Object.isObject</code> of the same value.
+
+    @function external:Object.can
+    @param {Any} value a value
+    @param {String} name a method name
+    @returns {Boolean} whether the given value implements the given method
+
+*/
+Object.can = function (object, name) {
+    return (
+        object != null && // false only for null *and* undefined
+        typeof object[name] === "function" &&
+        !owns.call(object, name)
+    );
+};
+
+/**
+    A utility that is like Object.owns but is also useful for finding
+    properties on the prototype chain, provided that they do not refer to
+    methods on the Object prototype.  Works for all strings except "__proto__".
+
+    <p>Alternately, you could use the "in" operator as long as the object
+    descends from "null" instead of the Object.prototype, as with
+    <code>Object.create(null)</code>.  However,
+    <code>Object.create(null)</code> only works in fully compliant EcmaScript 5
+    JavaScript engines and cannot be faithfully shimmed.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "has", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the instance.
+
+    @param {Object} object
+    @param {String} key
+    @returns {Boolean} whether the object, or any of its prototypes except
+    <code>Object.prototype</code>
+    @function external:Object.has
+*/
+Object.has = function (object, key) {
+    if (typeof object !== "object") {
+        throw new Error("Object.has can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "has"
+    if (Object.can(object, "has")) {
+        return object.has(key);
+    // otherwise report whether the key is on the prototype chain,
+    // as long as it is not one of the methods on object.prototype
+    } else if (typeof key === "string") {
+        return key in object && object[key] !== Object.prototype[key];
+    } else {
+        throw new Error("Key must be a string for Object.has on plain objects");
+    }
+};
+
+/**
+    Gets the value for a corresponding key from an object.
+
+    <p>Uses Object.has to determine whether there is a corresponding value for
+    the given key.  As such, <code>Object.get</code> is capable of retriving
+    values from the prototype chain as long as they are not from the
+    <code>Object.prototype</code>.
+
+    <p>If there is no corresponding value, returns the given default, which may
+    be <code>undefined</code>.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "get", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  In that
+    case, the domain of the key depends on the implementation.  For a `Map`,
+    for example, the key might be any object.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value a default to return, <code>undefined</code> if omitted
+    @returns {Any} value for key, or default value
+    @function external:Object.get
+*/
+Object.get = function (object, key, value) {
+    if (typeof object !== "object") {
+        throw new Error("Object.get can't accept non-object: " + typeof object);
+    }
+    // forward to mapped collections that implement "get"
+    if (Object.can(object, "get")) {
+        return object.get(key, value);
+    } else if (Object.has(object, key)) {
+        return object[key];
+    } else {
+        return value;
+    }
+};
+
+/**
+    Sets the value for a given key on an object.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "set", this function defers to the collection, so this method can be
+    used to generically handle objects, arrays, or other collections.  As such,
+    the key domain varies by the object type.
+
+    @param {Object} object
+    @param {String} key
+    @param {Any} value
+    @returns <code>undefined</code>
+    @function external:Object.set
+*/
+Object.set = function (object, key, value) {
+    if (Object.can(object, "set")) {
+        object.set(key, value);
+    } else {
+        object[key] = value;
+    }
+};
+
+Object.addEach = function (target, source) {
+    if (!source) {
+    } else if (Object.can(source, "forEach")) {
+        // copy map-alikes
+        if (typeof source.keys === "function") {
+            source.forEach(function (value, key) {
+                target[key] = value;
+            });
+        // iterate key value pairs of other iterables
+        } else {
+            source.forEach(function (pair) {
+                target[pair[0]] = pair[1];
+            });
+        }
+    } else {
+        // copy other objects as map-alikes
+        Object.keys(source).forEach(function (key) {
+            target[key] = source[key];
+        });
+    }
+    return target;
+};
+
+/**
+    Iterates over the owned properties of an object.
+
+    @function external:Object.forEach
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+*/
+Object.forEach = function (object, callback, thisp) {
+    Object.keys(object).forEach(function (key) {
+        callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Iterates over the owned properties of a map, constructing a new array of
+    mapped values.
+
+    @function external:Object.map
+    @param {Object} object an object to iterate.
+    @param {Function} callback a function to call for every key and value
+    pair in the object.  Receives <code>value</code>, <code>key</code>,
+    and <code>object</code> as arguments.
+    @param {Object} thisp the <code>this</code> to pass through to the
+    callback
+    @returns {Array} the respective values returned by the callback for each
+    item in the object.
+*/
+Object.map = function (object, callback, thisp) {
+    return Object.keys(object).map(function (key) {
+        return callback.call(thisp, object[key], key, object);
+    });
+};
+
+/**
+    Returns the values for owned properties of an object.
+
+    @function external:Object.map
+    @param {Object} object
+    @returns {Array} the respective value for each owned property of the
+    object.
+*/
+Object.values = function (object) {
+    return Object.map(object, Function.identity);
+};
+
+// TODO inline document concat
+Object.concat = function () {
+    var object = {};
+    for (var i = 0; i < arguments.length; i++) {
+        Object.addEach(object, arguments[i]);
+    }
+    return object;
+};
+
+Object.from = Object.concat;
+
+/**
+    Returns whether two values are identical.  Any value is identical to itself
+    and only itself.  This is much more restictive than equivalence and subtly
+    different than strict equality, <code>===</code> because of edge cases
+    including negative zero and <code>NaN</code>.  Identity is useful for
+    resolving collisions among keys in a mapping where the domain is any value.
+    This method does not delgate to any method on an object and cannot be
+    overridden.
+    @see http://wiki.ecmascript.org/doku.php?id=harmony:egal
+    @param {Any} this
+    @param {Any} that
+    @returns {Boolean} whether this and that are identical
+    @function external:Object.is
+*/
+Object.is = function (x, y) {
+    if (x === y) {
+        // 0 === -0, but they are not identical
+        return x !== 0 || 1 / x === 1 / y;
+    }
+    // NaN !== NaN, but they are identical.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    return x !== x && y !== y;
+};
+
+/**
+    Performs a polymorphic, type-sensitive deep equivalence comparison of any
+    two values.
+
+    <p>As a basic principle, any value is equivalent to itself (as in
+    identity), any boxed version of itself (as a <code>new Number(10)</code> is
+    to 10), and any deep clone of itself.
+
+    <p>Equivalence has the following properties:
+
+    <ul>
+        <li><strong>polymorphic:</strong>
+            If the given object is an instance of a type that implements a
+            methods named "equals", this function defers to the method.  So,
+            this function can safely compare any values regardless of type,
+            including undefined, null, numbers, strings, any pair of objects
+            where either implements "equals", or object literals that may even
+            contain an "equals" key.
+        <li><strong>type-sensitive:</strong>
+            Incomparable types are not equal.  No object is equivalent to any
+            array.  No string is equal to any other number.
+        <li><strong>deep:</strong>
+            Collections with equivalent content are equivalent, recursively.
+        <li><strong>equivalence:</strong>
+            Identical values and objects are equivalent, but so are collections
+            that contain equivalent content.  Whether order is important varies
+            by type.  For Arrays and lists, order is important.  For Objects,
+            maps, and sets, order is not important.  Boxed objects are mutally
+            equivalent with their unboxed values, by virtue of the standard
+            <code>valueOf</code> method.
+    </ul>
+    @param this
+    @param that
+    @returns {Boolean} whether the values are deeply equivalent
+    @function external:Object.equals
+*/
+Object.equals = function (a, b, equals) {
+    equals = equals || Object.equals;
+    // unbox objects, but do not confuse object literals
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    if (a === b)
+        // 0 === -0, but they are not equal
+        return a !== 0 || 1 / a === 1 / b;
+    if (a === null || b === null)
+        return a === b;
+    if (Object.can(a, "equals"))
+        return a.equals(b, equals);
+    // commutative
+    if (Object.can(b, "equals"))
+        return b.equals(a, equals);
+    if (typeof a === "object" && typeof b === "object") {
+        var aPrototype = Object.getPrototypeOf(a);
+        var bPrototype = Object.getPrototypeOf(b);
+        if (
+            aPrototype === bPrototype && (
+                aPrototype === Object.prototype ||
+                aPrototype === null
+            )
+        ) {
+            for (var key in a) {
+                if (!equals(a[key], b[key])) {
+                    return false;
+                }
+            }
+            for (var key in b) {
+                if (!equals(a[key], b[key])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+    // NaN !== NaN, but they are equal.
+    // NaNs are the only non-reflexive value, i.e., if x !== x,
+    // then x is a NaN.
+    // isNaN is broken: it converts its argument to number, so
+    // isNaN("foo") => true
+    return a !== a && b !== b;
+};
+
+// Because a return value of 0 from a `compare` function  may mean either
+// "equals" or "is incomparable", `equals` cannot be defined in terms of
+// `compare`.  However, `compare` *can* be defined in terms of `equals` and
+// `lessThan`.  Again however, more often it would be desirable to implement
+// all of the comparison functions in terms of compare rather than the other
+// way around.
+
+/**
+    Determines the order in which any two objects should be sorted by returning
+    a number that has an analogous relationship to zero as the left value to
+    the right.  That is, if the left is "less than" the right, the returned
+    value will be "less than" zero, where "less than" may be any other
+    transitive relationship.
+
+    <p>Arrays are compared by the first diverging values, or by length.
+
+    <p>Any two values that are incomparable return zero.  As such,
+    <code>equals</code> should not be implemented with <code>compare</code>
+    since incomparability is indistinguishable from equality.
+
+    <p>Sorts strings lexicographically.  This is not suitable for any
+    particular international setting.  Different locales sort their phone books
+    in very different ways, particularly regarding diacritics and ligatures.
+
+    <p>If the given object is an instance of a type that implements a method
+    named "compare", this function defers to the instance.  The method does not
+    need to be an owned property to distinguish it from an object literal since
+    object literals are incomparable.  Unlike <code>Object</code> however,
+    <code>Array</code> implements <code>compare</code>.
+
+    @param {Any} left
+    @param {Any} right
+    @returns {Number} a value having the same transitive relationship to zero
+    as the left and right values.
+    @function external:Object.compare
+*/
+Object.compare = function (a, b) {
+    // unbox objects, but do not confuse object literals
+    // mercifully handles the Date case
+    a = Object.getValueOf(a);
+    b = Object.getValueOf(b);
+    var aType = typeof a;
+    var bType = typeof b;
+    if (a === b)
+        return 0;
+    if (aType !== bType)
+        return 0;
+    if (aType === "number")
+        return a - b;
+    if (aType === "string")
+        return a < b ? -1 : 1;
+        // the possibility of equality elimiated above
+    if (Object.can(a, "compare"))
+        return a.compare(b);
+    // not commutative, the relationship is reversed
+    if (Object.can(b, "compare"))
+        return -b.compare(a);
+    return 0;
+};
+
+/**
+    Creates a deep copy of any value.  Values, being immutable, are
+    returned without alternation.  Forwards to <code>clone</code> on
+    objects and arrays.
+
+    @function external:Object.clone
+    @param {Any} value a value to clone
+    @param {Number} depth an optional traversal depth, defaults to infinity.
+    A value of <code>0</code> means to make no clone and return the value
+    directly.
+    @param {Map} memo an optional memo of already visited objects to preserve
+    reference cycles.  The cloned object will have the exact same shape as the
+    original, but no identical objects.  Te map may be later used to associate
+    all objects in the original object graph with their corresponding member of
+    the cloned graph.
+    @returns a copy of the value
+*/
+Object.clone = function (value, depth, memo) {
+    value = Object.getValueOf(value);
+    memo = memo || new WeakMap();
+    if (depth === undefined) {
+        depth = Infinity;
+    } else if (depth === 0) {
+        return value;
+    }
+    if (Object.isObject(value)) {
+        if (!memo.has(value)) {
+            if (Object.can(value, "clone")) {
+                memo.set(value, value.clone(depth, memo));
+            } else {
+                var prototype = Object.getPrototypeOf(value);
+                if (prototype === null || prototype === Object.prototype) {
+                    var clone = Object.create(prototype);
+                    memo.set(value, clone);
+                    for (var key in value) {
+                        clone[key] = Object.clone(value[key], depth - 1, memo);
+                    }
+                } else {
+                    throw new Error("Can't clone " + value);
+                }
+            }
+        }
+        return memo.get(value);
+    }
+    return value;
+};
+
+/**
+    Removes all properties owned by this object making the object suitable for
+    reuse.
+
+    @function external:Object.clear
+    @returns this
+*/
+Object.clear = function (object) {
+    if (Object.can(object, "clear")) {
+        object.clear();
+    } else {
+        var keys = Object.keys(object),
+            i = keys.length;
+        while (i) {
+            i--;
+            delete object[keys[i]];
+        }
+    }
+    return object;
+};
+