traceur-rb 0.0.1 → 0.0.2

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

@@ -1,59 +0,0 @@
-
-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

@@ -1,538 +0,0 @@
-"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;
-};
-