First commit of Ninja to ninja-internal

Signed-off-by: Valerio Virgillito <rmwh84@motorola.com>

1 files changed, 694 insertions, 0 deletions

diff --git a/node_modules/montage/core/promise.js b/node_modules/montage/core/promise.js
new file mode 100755
index 00000000..80c63943
--- /dev/null
+++ b/node_modules/montage/core/promise.js
@@ -0,0 +1,694 @@
+/* <copyright>
+ This file contains proprietary software owned by Motorola Mobility, Inc.<br/>
+ No rights, expressed or implied, whatsoever to this software are provided by Motorola Mobility, Inc. hereunder.<br/>
+ (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
+ </copyright> */
+
+// Scope:
+//  * ES5, W3C setImmediate (shimmed if necessary)
+//  * speed and economy of memory before safety and securability
+//  * run-time compatibility via thenability
+
+// TODO note the comps/promiseSend/sendPromise and argument order
+//      changes from Q
+
+// This module is used during the boot-strapping, so it can be required as
+// a normal CommonJS module, but alternately bootstraps Montage if there
+// is a bootstrap global variable.
+(function (definition) {
+    if (typeof bootstrap !== "undefined") {
+        bootstrap("core/promise", definition);
+    } else if (typeof require !== "undefined") {
+        // module
+        definition(require, exports, module);
+    } else {
+        // global script
+        Q = {};
+        definition(function () {}, Q);
+    }
+})(function (require, exports, module) {
+
+"use strict";
+
+try {
+    // bootstrapping can't handle relative identifiers
+    require("core/shim/timers"); // setImmediate
+} catch (exception) {
+    // in this case, node can't handle absolute identifiers
+    require("./shim/timers"); // setImmediate
+}
+
+// merely ensures that the returned value can respond to
+// messages; does not guarantee a full promise API
+function toPromise(value) {
+    if (value && typeof value.sendPromise !== "undefined") {
+        return value;
+    } else if (value && typeof value.then !== "undefined") {
+        var deferred = Promise.defer();
+        value.then(function (value) {
+            deferred.resolve(value);
+        }, function (reason, error, rejection) {
+            if (rejection) {
+                deferred.resolve(rejection);
+            } else {
+                deferred.reject(reason, error);
+            }
+        });
+        return deferred.promise;
+    } else {
+        return Promise.fulfill(value);
+    }
+}
+
+var Creatable = Object.create(Object.prototype, {
+    create: {
+        value: function (descriptor) {
+            return Object.create(this, descriptor);
+        }
+    },
+});
+
+// Common implementation details of FulfilledPromise, RejectedPromise, and
+// DeferredPromise
+var AbstractPromise = Creatable.create({
+
+    // Common implementation of sendPromise for FulfiledPromise and
+    // RejectedPromise, but overridden by DeferredPromise to buffer
+    // messages instead of handling them.
+    sendPromise: {
+        value: function (resolve, op /*, ...args*/) {
+            var result;
+            try {
+                result = (this._handlers[op] || this._fallback)
+                    .apply(this, arguments);
+            } catch (error) {
+                result = this.Promise.reject(error && error.message, error);
+            }
+            resolve(result);
+        }
+    },
+
+    // Defers polymorphically to toString
+    toSource: {
+        value: function () {
+            return this.toString();
+        }
+    }
+
+});
+
+// Basic implementation of the Promise object and prototypes for its
+// Fulfilled, Rejected, and Deferred subtypes.  The mixin descriptors that
+// give the promise types useful methods like "then" are not applied until
+// .create() is used the first time to make the actual Promise export.
+var PrimordialPromise = Creatable.create({
+
+    create: {
+        value: function (descriptor, promiseDescriptor) {
+
+            // automatically subcreate each of the contained promise types
+            var creation = Object.create(this, {
+                DeferredPromise: {
+                    value: this.DeferredPromise.create(promiseDescriptor)
+                },
+                FulfilledPromise: {
+                    value: this.FulfilledPromise.create(promiseDescriptor)
+                },
+                RejectedPromise: {
+                    value: this.RejectedPromise.create(promiseDescriptor)
+                }
+            });
+
+            if (descriptor) {
+                Object.defineProperties(creation, descriptor);
+            }
+
+            // create static reflections of all new promise methods
+            if (promiseDescriptor) {
+                var statics = {};
+                Object.keys(promiseDescriptor).forEach(function (name) {
+                    statics[name] = {
+                        value: function (value) {
+                            var args = Array.prototype.slice.call(arguments, 1);
+                            var promise = this.ref(value);
+                            return promise[name].apply(promise, args);
+                        }
+                    };
+                });
+                Object.defineProperties(creation, statics);
+            }
+
+            return creation;
+        }
+    },
+
+    isPromise: {
+        value: function (value) {
+            return value && typeof value.sendPromise !== "undefined";
+        }
+    },
+
+    ref: {
+        value: function (object) {
+            // if it is already a promise, wrap it to guarantee
+            // the full public API of this promise variety.
+            if (object && typeof object.sendPromise === "function") {
+                var deferred = this.defer();
+                deferred.resolve(object);
+                return deferred.promise;
+            // if it is at least a thenable duck-type, wrap it
+            } else if (object && typeof object.then === "function") {
+                var deferred = this.defer();
+                object.then(function (value) {
+                    deferred.resolve(value);
+                }, function (reason, error, rejection) {
+                    // if the thenable recognizes rejection
+                    // forwarding, accept the given rejection
+                    if (rejection) {
+                        deferred.resolve(rejection);
+                    // otherwise, handle reason and optional error forwarding
+                    } else {
+                        deferred.reject(reason, error);
+                    }
+                })
+                return deferred.promise;
+            // if it is a fulfillment value, wrap it with a fulfillment
+            // promise
+            } else {
+                return this.fulfill(object);
+            }
+        }
+    },
+
+    fulfill: {
+        value: function (value) {
+            return this.FulfilledPromise.create({
+                _value: {
+                    value: value,
+                    writable: true
+                },
+                Promise: {
+                    value: this
+                }
+            });
+        }
+    },
+
+    FulfilledPromise: {
+        value: AbstractPromise.create({
+
+            _handlers: {
+                value: {
+                    then: function (r, o) {
+                        return this._value;
+                    },
+                    get: function (r, o, key) {
+                        return this._value[key];
+                    },
+                    put: function (r, o, key, value) {
+                        return this._value[key] = value;
+                    },
+                    "delete": function (r, o, key) {
+                        return delete this._value[key];
+                    },
+                    post: function (r, o, key, value) {
+                        return this._value[key].apply(this._value, value);
+                    },
+                    apply: function (r, o, self, args) {
+                        return this._value.apply(self, args);
+                    },
+                    keys: function (r, o) {
+                        return Object.keys(this._value);
+                    }
+                }
+            },
+
+            _fallback: {
+                value: function (callback, operator) {
+                    return this.Promise.reject("Promise does not support operation: " + operator);
+                }