source: Dev/branches/rest-dojo-ui/client/dojo/i18n.js @ 256

define(["./_base/kernel", "require", "./has", "./_base/array", "./_base/lang", "./_base/xhr"], function(dojo, require, has, array, lang) {
        // module:
        //              dojo/i18n
        // summary:
        //              This module implements the !dojo/i18n plugin and the v1.6- i18n API
        // description:
        //              We choose to include our own plugin to leverage functionality already contained in dojo
        //              and thereby reduce the size of the plugin compared to various loader implementations. Also, this
        //              allows foreign AMD loaders to be used without their plugins.
        var
                thisModule= dojo.i18n=
                        // the dojo.i18n module
                        {},

                nlsRe=
                        // regexp for reconstructing the master bundle name from parts of the regexp match
                        // nlsRe.exec("foo/bar/baz/nls/en-ca/foo") gives:
                        // ["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
                        // nlsRe.exec("foo/bar/baz/nls/foo") gives:
                        // ["foo/bar/baz/nls/foo", "foo/bar/baz/nls/", "/", "/", "foo", ""]
                        // so, if match[5] is blank, it means this is the top bundle definition.
                        // courtesy of http://requirejs.org
                        /(^.*(^|\/)nls)(\/|$)([^\/]*)\/?([^\/]*)/,

                getAvailableLocales= function(
                        root,
                        locale,
                        bundlePath,
                        bundleName
                ){
                        // return a vector of module ids containing all available locales with respect to the target locale
                        // For example, assuming:
                        //       * the root bundle indicates specific bundles for "fr" and "fr-ca",
                        //       * bundlePath is "myPackage/nls"
                        //       * bundleName is "myBundle"
                        // Then a locale argument of "fr-ca" would return
                        //       ["myPackage/nls/myBundle", "myPackage/nls/fr/myBundle", "myPackage/nls/fr-ca/myBundle"]
                        // Notice that bundles are returned least-specific to most-specific, starting with the root.
                        //
                        // If root===false indicates we're working with a pre-AMD i18n bundle that doesn't tell about the available locales;
                        // therefore, assume everything is available and get 404 errors that indicate a particular localization is not available
                        //

                        for(var result= [bundlePath + bundleName], localeParts= locale.split("-"), current= "", i= 0; i<localeParts.length; i++){
                                current+= (current ? "-" : "") + localeParts[i];
                                if(!root || root[current]){
                                        result.push(bundlePath + current + "/" + bundleName);
                                }
                        }
                        return result;
                },

                cache= {},

                getL10nName= dojo.getL10nName = function(moduleName, bundleName, locale){
                        locale = locale ? locale.toLowerCase() : dojo.locale;
                        moduleName = "dojo/i18n!" + moduleName.replace(/\./g, "/");
                        bundleName = bundleName.replace(/\./g, "/");
                        return (/root/i.test(locale)) ?
                                (moduleName + "/nls/" + bundleName) :
                                (moduleName + "/nls/" + locale + "/" + bundleName);
                },

                doLoad = function(require, bundlePathAndName, bundlePath, bundleName, locale, load){
                        // get the root bundle which instructs which other bundles are required to contruct the localized bundle
                        require([bundlePathAndName], function(root){
                                var
                                        current= cache[bundlePathAndName + "/"]= lang.clone(root.root),
                                        availableLocales= getAvailableLocales(!root._v1x && root, locale, bundlePath, bundleName);
                                require(availableLocales, function(){
                                        for (var i= 1; i<availableLocales.length; i++){
                                                cache[availableLocales[i]]= current= lang.mixin(lang.clone(current), arguments[i]);
                                        }
                                        // target may not have been resolve (e.g., maybe only "fr" exists when "fr-ca" was requested)
                                        var target= bundlePathAndName + "/" + locale;
                                        cache[target]= current;
                                        load && load(lang.delegate(current));
                                });
                        });
                },

                normalize = function(id, toAbsMid){
                        // note: id may be relative
                        var match= nlsRe.exec(id),
                                bundlePath= match[1];
                        return /^\./.test(bundlePath) ? toAbsMid(bundlePath) + "/" +  id.substring(bundlePath.length) : id;
                };

                load = function(id, require, load){
                        // note: id is always absolute
                        var
                                match= nlsRe.exec(id),
                                bundlePath= match[1] + "/",
                                bundleName= match[5] || match[4],
                                bundlePathAndName= bundlePath + bundleName,
                                localeSpecified = (match[5] && match[4]),
                                targetLocale=  localeSpecified || dojo.locale,
                                target= bundlePathAndName + "/" + targetLocale;

                        if(localeSpecified){
                                if(cache[target]){
                                        // a request for a specific local that has already been loaded; just return it
                                        load(cache[target]);
                                }else{
                                        // a request for a specific local that has not been loaded; load and return just that locale
                                        doLoad(require, bundlePathAndName, bundlePath, bundleName, targetLocale, load);
                                }
                                return;
                        }// else a non-locale-specific request; therefore always load dojo.locale + dojo.config.extraLocale

                        // notice the subtle algorithm that loads targeLocal last, which is the only doLoad application that passes a value for the load callback
                        // this makes the sync loader follow a clean code path that loads extras first and then proceeds with tracing the current deps graph
                        var extra = dojo.config.extraLocale || [];
                        extra = lang.isArray(extra) ? extra : [extra];
                        extra.push(targetLocale);
                        array.forEach(extra, function(locale){
                                doLoad(require, bundlePathAndName, bundlePath, bundleName, locale, locale==targetLocale && load);
                        });
                };


        has.add("dojo-v1x-i18n-Api",
                // if true, define the v1.x i18n functions
                1
        );

        if(has("dojo-v1x-i18n-Api")){
                var
                        evalBundle=
                                // keep the minifiers off our define!
                                // if bundle is an AMD bundle, then __amdResult will be defined; otherwise it's a pre-amd bundle and the bundle value is returned by eval
                                new Function("bundle", "var __preAmdResult, __amdResult; function define(bundle){__amdResult= bundle;} __preAmdResult= eval(bundle); return [__preAmdResult, __amdResult];"),

                        fixup= function(url, preAmdResult, amdResult){
                                // nls/<locale>/<bundle-name> indicates not the root.
                                return preAmdResult ? (/nls\/[^\/]+\/[^\/]+$/.test(url) ? preAmdResult : {root:preAmdResult, _v1x:1}) : amdResult;
                        },

                        syncRequire= function(deps, callback){
                                var results= [];
                                dojo.forEach(deps, function(mid){
                                        var url= require.toUrl(mid + ".js");
                                        if(cache[url]){
                                                results.push(cache[url]);
                                        }else{

                                                try {
                                                        var bundle= require(mid);
                                                        if(bundle){
                                                                results.push(bundle);
                                                                return;
                                                        }
                                                }catch(e){}

                                                dojo.xhrGet({
                                                        url:url,
                                                        sync:true,
                                                        load:function(text){
                                                                var result = evalBundle(text);
                                                                results.push(cache[url]= fixup(url, result[0], result[1]));
                                                        },
                                                        error:function(){
                                                                results.push(cache[url]= {});
                                                        }
                                                });
                                        }
                                });
                                callback.apply(null, results);
                        };

                thisModule.getLocalization= function(moduleName, bundleName, locale){
                        var result,
                                l10nName= getL10nName(moduleName, bundleName, locale).substring(10);
                        load(l10nName, (has("dojo-sync-loader") && !require.isXdUrl(require.toUrl(l10nName + ".js")) ? syncRequire : require), function(result_){ result= result_; });
                        return result;
                };

                thisModule.normalizeLocale= function(locale){
                        var result = locale ? locale.toLowerCase() : dojo.locale;
                        if(result == "root"){
                                result = "ROOT";
                        }
                        return result;
                };
        }

        return lang.mixin(thisModule, {
                dynamic:true,
                normalize:normalize,
                load:load,
                cache:function(mid, value){
                        cache[mid] = value;
                }
        });
});