source: Dev/trunk/src/client/dojo/_base/kernel.js @ 483

define(["../has", "./config", "require", "module"], function(has, config, require, module){
        // module:
        //              dojo/_base/kernel

        // This module is the foundational module of the dojo boot sequence; it defines the dojo object.

        var
                // loop variables for this module
                i, p,

                // create dojo, dijit, and dojox
                // FIXME: in 2.0 remove dijit, dojox being created by dojo
                dijit = {},
                dojox = {},
                dojo = {
                        // summary:
                        //              This module is the foundational module of the dojo boot sequence; it defines the dojo object.

                        // notice dojo takes ownership of the value of the config module
                        config:config,
                        global:this,
                        dijit:dijit,
                        dojox:dojox
                };


        // Configure the scope map. For a 100% AMD application, the scope map is not needed other than to provide
        // a _scopeName property for the dojo, dijit, and dojox root object so those packages can create
        // unique names in the global space.
        //
        // Built, legacy modules use the scope map to allow those modules to be expressed as if dojo, dijit, and dojox,
        // where global when in fact they are either global under different names or not global at all. In v1.6-, the
        // config variable "scopeMap" was used to map names as used within a module to global names. This has been
        // subsumed by the AMD map configuration variable which can relocate packages to different names. For backcompat,
        // only the "*" mapping is supported. See http://livedocs.dojotoolkit.org/developer/design/loader#legacy-cross-domain-mode for details.
        //
        // The following computations contort the packageMap for this dojo instance into a scopeMap.
        var scopeMap =
                        // a map from a name used in a legacy module to the (global variable name, object addressed by that name)
                        // always map dojo, dijit, and dojox
                        {
                                dojo:["dojo", dojo],
                                dijit:["dijit", dijit],
                                dojox:["dojox", dojox]
                        },

                packageMap =
                        // the package map for this dojo instance; note, a foreign loader or no pacakgeMap results in the above default config
                        (require.map && require.map[module.id.match(/[^\/]+/)[0]]),

                item;


        // process all mapped top-level names for this instance of dojo
        for(p in packageMap){
                if(scopeMap[p]){
                        // mapped dojo, dijit, or dojox
                        scopeMap[p][0] = packageMap[p];
                }else{
                        // some other top-level name
                        scopeMap[p] = [packageMap[p], {}];
                }
        }

        // publish those names to _scopeName and, optionally, the global namespace
        for(p in scopeMap){
                item = scopeMap[p];
                item[1]._scopeName = item[0];
                if(!config.noGlobals){
                        this[item[0]] = item[1];
                }
        }
        dojo.scopeMap = scopeMap;

        /*===== dojo.__docParserConfigureScopeMap(scopeMap); =====*/

        // FIXME: dojo.baseUrl and dojo.config.baseUrl should be deprecated
        dojo.baseUrl = dojo.config.baseUrl = require.baseUrl;
        dojo.isAsync = !has("dojo-loader") || require.async;
        dojo.locale = config.locale;

        var rev = "$Rev: fd52c96 $".match(/[0-9a-f]{7,}/);
        dojo.version = {
                // summary:
                //              Version number of the Dojo Toolkit
                // description:
                //              Hash about the version, including
                //
                //              - major: Integer: Major version. If total version is "1.2.0beta1", will be 1
                //              - minor: Integer: Minor version. If total version is "1.2.0beta1", will be 2
                //              - patch: Integer: Patch version. If total version is "1.2.0beta1", will be 0
                //              - flag: String: Descriptor flag. If total version is "1.2.0beta1", will be "beta1"
                //              - revision: Number: The Git rev from which dojo was pulled

                major: 1, minor: 9, patch: 3, flag: "",
                revision: rev ? rev[0] : NaN,
                toString: function(){
                        var v = dojo.version;
                        return v.major + "." + v.minor + "." + v.patch + v.flag + " (" + v.revision + ")";      // String
                }
        };

        // If has("extend-dojo") is truthy, then as a dojo module is defined it should push it's definitions
        // into the dojo object, and conversely. In 2.0, it will likely be unusual to augment another object
        // as a result of defining a module. This has feature gives a way to force 2.0 behavior as the code
        // is migrated. Absent specific advice otherwise, set extend-dojo to truthy.
        has.add("extend-dojo", 1);


        (Function("d", "d.eval = function(){return d.global.eval ? d.global.eval(arguments[0]) : eval(arguments[0]);}"))(dojo);
        /*=====
        dojo.eval = function(scriptText){
                // summary:
                //              A legacy method created for use exclusively by internal Dojo methods. Do not use this method
                //              directly unless you understand its possibly-different implications on the platforms your are targeting.
                // description:
                //              Makes an attempt to evaluate scriptText in the global scope. The function works correctly for browsers
                //              that support indirect eval.
                //
                //              As usual, IE does not. On IE, the only way to implement global eval is to
                //              use execScript. Unfortunately, execScript does not return a value and breaks some current usages of dojo.eval.
                //              This implementation uses the technique of executing eval in the scope of a function that is a single scope
                //              frame below the global scope; thereby coming close to the global scope. Note carefully that
                //
                //              dojo.eval("var pi = 3.14;");
                //
                //              will define global pi in non-IE environments, but define pi only in a temporary local scope for IE. If you want
                //              to define a global variable using dojo.eval, write something like
                //
                //              dojo.eval("window.pi = 3.14;")
                // scriptText:
                //              The text to evaluation.
                // returns:
                //              The result of the evaluation. Often `undefined`
        };
        =====*/


        if(has("host-rhino")){
                dojo.exit = function(exitcode){
                        quit(exitcode);
                };
        }else{
                dojo.exit = function(){
                };
        }

        has.add("dojo-guarantee-console",
                // ensure that console.log, console.warn, etc. are defined
                1
        );
        if(has("dojo-guarantee-console")){
                typeof console != "undefined" || (console = {});
                //      Be careful to leave 'log' always at the end
                var cn = [
                        "assert", "count", "debug", "dir", "dirxml", "error", "group",
                        "groupEnd", "info", "profile", "profileEnd", "time", "timeEnd",
                        "trace", "warn", "log"
                ];
                var tn;
                i = 0;
                while((tn = cn[i++])){
                        if(!console[tn]){
                                (function(){
                                        var tcn = tn + "";
                                        console[tcn] = ('log' in console) ? function(){
                                                var a = Array.apply({}, arguments);
                                                a.unshift(tcn + ":");
                                                console["log"](a.join(" "));
                                        } : function(){};
                                        console[tcn]._fake = true;
                                })();
                        }
                }
        }

        has.add("dojo-debug-messages",
                // include dojo.deprecated/dojo.experimental implementations
                !!config.isDebug
        );
        dojo.deprecated = dojo.experimental =  function(){};
        if(has("dojo-debug-messages")){
                dojo.deprecated = function(/*String*/ behaviour, /*String?*/ extra, /*String?*/ removal){
                        // summary:
                        //              Log a debug message to indicate that a behavior has been
                        //              deprecated.
                        // behaviour: String
                        //              The API or behavior being deprecated. Usually in the form
                        //              of "myApp.someFunction()".
                        // extra: String?
                        //              Text to append to the message. Often provides advice on a
                        //              new function or facility to achieve the same goal during
                        //              the deprecation period.
                        // removal: String?
                        //              Text to indicate when in the future the behavior will be
                        //              removed. Usually a version number.
                        // example:
                        //      | dojo.deprecated("myApp.getTemp()", "use myApp.getLocaleTemp() instead", "1.0");

                        var message = "DEPRECATED: " + behaviour;
                        if(extra){ message += " " + extra; }
                        if(removal){ message += " -- will be removed in version: " + removal; }
                        console.warn(message);
                };

                dojo.experimental = function(/* String */ moduleName, /* String? */ extra){
                        // summary:
                        //              Marks code as experimental.
                        // description:
                        //              This can be used to mark a function, file, or module as
                        //              experimental.    Experimental code is not ready to be used, and the
                        //              APIs are subject to change without notice.      Experimental code may be
                        //              completed deleted without going through the normal deprecation
                        //              process.
                        // moduleName: String
                        //              The name of a module, or the name of a module file or a specific
                        //              function
                        // extra: String?
                        //              some additional message for the user
                        // example:
                        //      | dojo.experimental("dojo.data.Result");
                        // example:
                        //      | dojo.experimental("dojo.weather.toKelvin()", "PENDING approval from NOAA");

                        var message = "EXPERIMENTAL: " + moduleName + " -- APIs subject to change without notice.";
                        if(extra){ message += " " + extra; }
                        console.warn(message);
                };
        }

        has.add("dojo-modulePaths",
                // consume dojo.modulePaths processing
                1
        );
        if(has("dojo-modulePaths")){
                // notice that modulePaths won't be applied to any require's before the dojo/_base/kernel factory is run;
                // this is the v1.6- behavior.
                if(config.modulePaths){
                        dojo.deprecated("dojo.modulePaths", "use paths configuration");
                        var paths = {};
                        for(p in config.modulePaths){
                                paths[p.replace(/\./g, "/")] = config.modulePaths[p];
                        }
                        require({paths:paths});
                }
        }

        has.add("dojo-moduleUrl",
                // include dojo.moduleUrl
                1
        );
        if(has("dojo-moduleUrl")){
                dojo.moduleUrl = function(/*String*/module, /*String?*/url){
                        // summary:
                        //              Returns a URL relative to a module.
                        // example:
                        //      |       var pngPath = dojo.moduleUrl("acme","images/small.png");
                        //      |       console.dir(pngPath); // list the object properties
                        //      |       // create an image and set it's source to pngPath's value:
                        //      |       var img = document.createElement("img");
                        //      |       img.src = pngPath;
                        //      |       // add our image to the document
                        //      |       dojo.body().appendChild(img);
                        // example:
                        //              you may de-reference as far as you like down the package
                        //              hierarchy.  This is sometimes handy to avoid lenghty relative
                        //              urls or for building portable sub-packages. In this example,
                        //              the `acme.widget` and `acme.util` directories may be located
                        //              under different roots (see `dojo.registerModulePath`) but the
                        //              the modules which reference them can be unaware of their
                        //              relative locations on the filesystem:
                        //      |       // somewhere in a configuration block
                        //      |       dojo.registerModulePath("acme.widget", "../../acme/widget");
                        //      |       dojo.registerModulePath("acme.util", "../../util");
                        //      |
                        //      |       // ...
                        //      |
                        //      |       // code in a module using acme resources
                        //      |       var tmpltPath = dojo.moduleUrl("acme.widget","templates/template.html");
                        //      |       var dataPath = dojo.moduleUrl("acme.util","resources/data.json");

                        dojo.deprecated("dojo.moduleUrl()", "use require.toUrl", "2.0");

                        // require.toUrl requires a filetype; therefore, just append the suffix "/*.*" to guarantee a filetype, then
                        // remove the suffix from the result. This way clients can request a url w/out a filetype. This should be
                        // rare, but it maintains backcompat for the v1.x line (note: dojo.moduleUrl will be removed in v2.0).
                        // Notice * is an illegal filename so it won't conflict with any real path map that may exist the paths config.
                        var result = null;
                        if(module){
                                result = require.toUrl(module.replace(/\./g, "/") + (url ? ("/" + url) : "") + "/*.*").replace(/\/\*\.\*/, "") + (url ? "" : "/");
                        }
                        return result;
                };
        }

        dojo._hasResource = {}; // for backward compatibility with layers built with 1.6 tooling

        return dojo;
});