add i18n plugin

Author: clmath

Gruntfile.js

@@ -7,15 +7,15 @@ module.exports = function (grunt) {
         jshint: {
             all: [
                 "Gruntfile.js",
-                "plugins/*.js"
+                "plugins/**/*.js"
             ],
             options: {
                 jshintrc: ".jshintrc",
             },
         },
 
         jsbeautifier: {
-            files: ["Gruntfile.js", "plugins/*.js"],
+            files: ["Gruntfile.js", "plugins/**/*.js"],
             options: {
                 config: ".jshintrc",
                 js: {

README.md

@@ -7,6 +7,11 @@
 This plugin purpose is to load a file if it exists, while not blocking the loader if it does not. If the module was not found, it will be falsy.
 This plugin should work with RequireJS and Dojo.
 
+## i18n.js
+
+This plugin is based on requirejs i18n.
+ * see: http://github.com/requirejs/i18n for details
+
 ## Licensing
 
 This project is distributed by the Dojo Foundation and licensed under the ["New" BSD License](https://github.com/dojo/dojo/blob/master/LICENSE#L13-L41).

plugins/i18n.js

@@ -0,0 +1,90 @@
+/**
+ * Plugin based on requirejs i18n
+ * see: http://github.com/requirejs/i18n for details
+ */
+(function () {
+    'use strict';
+
+    //regexp for reconstructing the master bundle name from parts of the regexp match
+    //nlsRegExp.exec("foo/bar/baz/nls/en-ca/foo") gives:
+    //["foo/bar/baz/nls/en-ca/foo", "foo/bar/baz/nls/", "/", "/", "en-ca", "foo"]
+    //nlsRegExp.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.
+    var nlsRegExp = /(^.*(^|\/)nls(\/|$))([^\/]*)\/?([^\/]*)/;
+
+    /**
+     * Simple function to mix in properties from source into target,
+     * but only if target does not already have a property of the same name.
+     * This is not robust in IE for transferring methods that match
+     * Object.prototype names, but the uses of mixin here seem unlikely to
+     * trigger a problem related to that.
+     */
+    function mixin(target, source, force) {
+        var prop;
+        for (prop in source) {
+            if (source.hasOwnProperty(prop) && (!target.hasOwnProperty(prop) || force)) {
+                target[prop] = source[prop];
+            } else if (typeof source[prop] === 'object') {
+                if (!target[prop] && source[prop]) {
+                    target[prop] = {};
+                }
+                mixin(target[prop], source[prop], force);
+            }
+        }
+    }
+
+    define(['./i18n/common' /*, './i18n/preload!myapp/nls/src*["fr","ROOT"]'*/ ], function (common) {
+
+        return {
+            load: function (name, req, onLoad, config) {
+                config = config || {};
+
+                var masterName,
+                    match = nlsRegExp.exec(name),
+                    prefix = match[1],
+                    locale = match[4],
+                    suffix = match[5];
+
+                //If match[5] is blank, it means this is the top bundle definition,
+                //so it does not have to be handled. Locale-specific requests
+                //will have a match[4] value but no match[5]
+                if (match[5]) {
+                    //locale-specific bundle
+                    prefix = match[1];
+                    masterName = prefix + suffix;
+                } else {
+                    //Top-level bundle.
+                    masterName = name;
+                    suffix = match[4];
+                    locale = common.getLocale(config);
+                }
+
+                //First, fetch the master bundle, it knows what locales are available.
+                req([masterName], function (master) {
+                    var getBundleAndMixin = function (prefix, suffix, locale, value) {
+                        var mixBundle = function (bundle) {
+                            mixin(value, bundle);
+                            locale = common.getParentLocale(locale);
+                            if (!bundle._flattened && locale) {
+                                getBundleAndMixin(prefix, suffix, locale, value);
+                            } else {
+                                value._flattened = true;
+                                onLoad(value);
+                                return;
+                            }
+                        };
+                        if (master[locale] === true || master[locale] === 1) {
+                            req([prefix + locale + '/' + suffix], mixBundle);
+                        } else {
+                            // root is on the master bundle or locale is unexisting
+                            mixBundle(master[locale] || {});
+                        }
+                    };
+
+                    getBundleAndMixin(prefix, suffix, locale, {});
+                });
+            }
+        };
+    });
+}());

plugins/i18n/common.js

@@ -0,0 +1,29 @@
+define(["../maybe!./parentLocales"], function (parentLocales) {
+    parentLocales = parentLocales || {};
+
+    return {
+        getLocale: function (config) {
+            var locale = config.locale;
+            if (!locale) {
+                locale = typeof navigator === "undefined" ? "root" :
+                    (navigator.language ||
+                    navigator.userLanguage || "root");
+            }
+            // just to be extra-sure
+            return locale.toLowerCase();
+        },
+
+        getParentLocale: function (loc) {
+            if (!loc || loc === "root") {
+                return undefined;
+            }
+            if (parentLocales[loc]) {
+                return parentLocales[loc];
+            }
+
+            var parts = loc.split("-");
+            parts.pop();
+            return (parts.length > 0) ? parts.join("-") : "root";
+        }
+    };
+});

plugins/i18n/parentLocales.js

@@ -0,0 +1,3 @@
+define({
+    "en": "es"
+});

plugins/i18n/preload.js

@@ -0,0 +1,22 @@
+define(["./common"], function (common) {
+    return {
+        load: function (name, req, onLoad, config) {
+            config = config || {};
+
+            var locale = common.getLocale(config),
+                parts = name.split("*"),
+                flattenedLocales = JSON.parse(parts[1]);
+
+            name = parts[0];
+            while (locale) {
+                if (flattenedLocales.indexOf(locale) >= 0) {
+                    require([name + "_" + locale], function (bundle) {
+                        onLoad(bundle);
+                        return;
+                    });
+                }
+                locale = common.getParentLocale(locale);
+            }
+        }
+    };
+});