First commit of Ninja to ninja-internal

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

1 files changed, 871 insertions, 0 deletions

diff --git a/node_modules/montage/require/require.js b/node_modules/montage/require/require.js
new file mode 100755
index 00000000..988dd811
--- /dev/null
+++ b/node_modules/montage/require/require.js
@@ -0,0 +1,871 @@
+/* <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> */
+bootstrap("require/require", function (require, CJS) {
+
+    var Promise = require("core/promise").Promise;
+    var URL = require("core/url");
+
+    var global = (function () {return this})();
+    var globalEval = eval; // reassigning causes eval to not use lexical scope.
+
+    // Non-CommonJS speced extensions should be marked with an "// EXTENSION" comment.
+
+    // Sandbox is an instance of the loader system. Different sandboxes will have different instances of modules.
+    // Returns the root "require" function. If this root "require()" function is called the loader will be in synchronous mode.
+    // To get asynchronous loading you MUST call the root "require.async()". In async mode all subsequent calls to "require()" will
+    // be asynchronously loaded, and synchronously executed.
+    CJS.Sandbox = function(config) {
+        // Configuration defaults:
+        config = config || {};
+        config.location = URL.resolve(config.location || CJS.pwd(), ".");
+        config.lib = URL.resolve(config.location, config.lib || ".");
+        config.paths = config.paths || [config.lib];
+        config.mappings = config.mappings || {}; // EXTENSION
+        config.definitions = config.definitions || {};
+        config.modules = config.modules || {};
+        config.exposedConfigs = config.exposedConfigs || [
+            "paths",
+            "mappings",
+            "loader",
+            "definitions",
+            "base",
+            "location",
+            "packageDescription",
+            "loadPackage"
+        ];
+        config.makeLoader = config.makeLoader || CJS.DefaultLoaderConstructor;
+        config.loader = config.loader || config.makeLoader(config);
+        config.makeCompiler = config.makeCompiler || CJS.DefaultCompilerConstructor;
+        config.compiler = config.compiler || config.makeCompiler(config);
+
+        // Sandbox state:
+        // Module instances: { exports, id, path, uri }
+        var modules = config.modules;
+        // Module definition objects: { factory, dependencies, path }
+        var definitions = config.definitions;
+        // Arrays of callbacks to be executed once a module definition has been loaded
+        var definitionListeners = {};
+        // Mapping from canonical IDs to the initial top ID used to load module
+        var urisToIds = {};
+
+        // Ensures a module definition is loaded before returning or executing the callback.
+        // Supports multiple calls for the same topId by registering callback as a listener if it has already been initiated.
+        function loadDefinition(topId, callback) {
+            if (callback) {
+                // already loaded
+                if (has(definitions, topId) && definitions[topId].factory) {
+                    callback(topId);
+                }
+                // in progress
+                else if (has(definitionListeners, topId)) {
+                    definitionListeners[topId].push(callback);
+                }
+                // pre-arranged
+                else if (has(definitions, topId) && definitions[topId].path !== undefined) {
+                    var def = definitions[topId];
+                    CJS.read(def.path).then(function (text) {
+                        def.text = text;
+                        config.compiler(def);
+                        callback(topId);
+                    }, function (reason) {
+                        console.warn("Can't read " + JSON.stringify(def.path) + ": " + reason);
+                        callback(null);
+                    });
+                }
+                // hasn't started
+                else {
+                    definitionListeners[topId] = [callback];
+
+                    config.loader(topId, function(definition) {
+                        if (!definition) {
+                            CJS.warn("Can't find module " + JSON.stringify(topId));
+                        }
+                        definitions[topId] = definition || null;
+
+                        CJS.progress.loadedModules.push([
+                            config.location,
+                            topId
+                        ].join("#"));
+
+                        definitionListeners[topId].forEach(function(fn) { 
+                            fn(topId);
+                        });
+
+                    });
+                }
+            } else {
+                // already loaded
+                if (has(definitions, topId)) {
+                    return;
+                }
+                // hasn't started
+                else {
+                    var definition = config.loader(topId);
+                    if (!definition) {
+                        CJS.warn("Can't find module " + JSON.stringify(topId));
+                    }
+                    definitions[topId] = definition || null;
+                }
+            }
+        }
+
+        function loadDeepDefinitions(topId, callback) {
+            if (has(modules, topId)) {
+                CJS.warn("module already init (1): " + topId);
+                return callback && callback();
+            }
+            if (callback) {
+                // in async mode we need to load the transitive dependencies first
+                var transitiveDependencies = {}; // undefined = not yet seen; false = not yet loaded; true = already loaded;
+                var loaded = false;
+                function loadDependencies(id) {
+                    transitiveDependencies[id] = true;
+                    if (definitions[id]) {
+                        (definitions[id].dependencies || []).map(function(dependency) {
+                            var depId = resolve(dependency, id);
+                            if (!has(transitiveDependencies, depId)) {
+                                transitiveDependencies[depId] = false;
+                                return depId;
+                            }
+                        }).forEach(function(depId) {
+                            depId && loadDefinition(depId, loadDependencies);
+                        });
+                    }
+                    // if any dependency is still unloaded, bail early
+                    // TODO: could eliminate this loop by counting
+                    for (var dependency in transitiveDependencies) {
+                        if (transitiveDependencies[dependency] === false) {
+                            return;
+                        }
+                    }
+                    // otherwise we're done loading transitive dependencies
+                    if (!loaded) {
+                        loaded = true;
+                        callback();
+                    }
+                }
+                // kick it off with the root module:
+                loadDefinition(topId, loadDependencies);
+            } else {
+                loadDefinition(topId);
+            }
+        }
+
+        // Loads module definition (and it's transitive dependencies if in async loading mode) then initializes the module.
+        function loadModule(topId) {
+            var result = Promise.defer();
+
+            // Update the list of modules that need to load
+            CJS.progress.requiredModules.push(
+                [config.location, topId].join("#")
+            );
+
+            loadDeepDefinitions(topId, function () {
+                try {
+                    initModule(topId);
+                    result.resolve();
+                } catch (exception) {
+                    result.reject(exception.message, exception);
+                }
+            });
+
+            return result.promise;
+        }
+
+        // Initializes a module by executing the factory function with a new module "exports" object.
+        function initModule(topId) {
+            if (has(definitions, topId)) {
+                if (definitions[topId] && typeof definitions[topId].factory === "function") {
+                    // HACK: look up canonical URI in previously initialized modules (different topId, same URI)
+                    // TODO: Handle this at higher level?
+                    var uri = URL.resolve(definitions[topId].path, "");
+                    if (has(urisToIds, uri)) {
+                        var canonicalId = urisToIds[uri];
+                        modules[topId] = modules[canonicalId];
+                    } else {
+                        urisToIds[uri] = topId;
+
+                        var module = modules[topId] = {
+                            exports: {},
+                            id: topId,
+                            path: definitions[topId].path,
+                            directory: URL.resolve(definitions[topId].path, "."),
+                            uri: uri // EXTENSION
+                        };
+
+                        var requireArg = makeRequire(topId);
+                        var exportsArg = module.exports;
+                        var moduleArg = module;
+
+                        // Execute the factory function:
+                        var returnValue = definitions[topId].factory.call(global, requireArg, exportsArg, moduleArg);
+
+                        // Modules should never have a return value.
+                        if (returnValue !== undefined) {
+                            CJS.warn('require: module "'+topId+'" returned a value.');
+                        }
+
+                        // Update the list of modules that are ready to use
+                        CJS.progress.initializedModules.push([
+                            config.location,
+                            topId
+                        ].join("#"));
+
+                    }