almond.js in requirejs-rails-0.9.1

- old
+ new
@@ -1,314 +1,396 @@
 /**
- * almond 0.1.1 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
+ * almond 0.2.3 Copyright (c) 2011-2012, The Dojo Foundation All Rights Reserved.
  * Available via the MIT or new BSD license.
  * see: http://github.com/jrburke/almond for details
  */
 //Going sloppy to avoid 'use strict' string cost, but strict practices should
 //be followed.
 /*jslint sloppy: true */
 /*global setTimeout: false */
 
 var requirejs, require, define;
 (function (undef) {
-    var defined = {},
-        waiting = {},
-        config = {},
-        defining = {},
-        aps = [].slice,
-        main, req;
+  var main, req, makeMap, handlers,
+      defined = {},
+      waiting = {},
+      config = {},
+      defining = {},
+      hasOwn = Object.prototype.hasOwnProperty,
+      aps = [].slice;
 
-    /**
-     * Given a relative module name, like ./something, normalize it to
-     * a real name that can be mapped to a path.
-     * @param {String} name the relative name
-     * @param {String} baseName a real name that the name arg is relative
-     * to.
-     * @returns {String} normalized name
-     */
-    function normalize(name, baseName) {
-        var baseParts = baseName && baseName.split("/"),
-            map = config.map,
-            starMap = (map && map['*']) || {},
-            nameParts, nameSegment, mapValue, foundMap, i, j, part;
+  function hasProp(obj, prop) {
+    return hasOwn.call(obj, prop);
+  }
 
-        //Adjust any relative paths.
-        if (name && name.charAt(0) === ".") {
-            //If have a base name, try to normalize against it,
-            //otherwise, assume it is a top-level require that will
-            //be relative to baseUrl in the end.
-            if (baseName) {
-                //Convert baseName to array, and lop off the last part,
-                //so that . matches that "directory" and not name of the baseName's
-                //module. For instance, baseName of "one/two/three", maps to
-                //"one/two/three.js", but we want the directory, "one/two" for
-                //this normalization.
-                baseParts = baseParts.slice(0, baseParts.length - 1);
+  /**
+   * Given a relative module name, like ./something, normalize it to
+   * a real name that can be mapped to a path.
+   * @param {String} name the relative name
+   * @param {String} baseName a real name that the name arg is relative
+   * to.
+   * @returns {String} normalized name
+   */
+  function normalize(name, baseName) {
+    var nameParts, nameSegment, mapValue, foundMap,
+        foundI, foundStarMap, starI, i, j, part,
+        baseParts = baseName && baseName.split("/"),
+        map = config.map,
+        starMap = (map && map['*']) || {};
 
-                name = baseParts.concat(name.split("/"));
+    //Adjust any relative paths.
+    if (name && name.charAt(0) === ".") {
+      //If have a base name, try to normalize against it,
+      //otherwise, assume it is a top-level require that will
+      //be relative to baseUrl in the end.
+      if (baseName) {
+        //Convert baseName to array, and lop off the last part,
+        //so that . matches that "directory" and not name of the baseName's
+        //module. For instance, baseName of "one/two/three", maps to
+        //"one/two/three.js", but we want the directory, "one/two" for
+        //this normalization.
+        baseParts = baseParts.slice(0, baseParts.length - 1);
 
-                //start trimDots
-                for (i = 0; (part = name[i]); i++) {
-                    if (part === ".") {
-                        name.splice(i, 1);
-                        i -= 1;
-                    } else if (part === "..") {
-                        if (i === 1 && (name[2] === '..' || name[0] === '..')) {
-                            //End of the line. Keep at least one non-dot
-                            //path segment at the front so it can be mapped
-                            //correctly to disk. Otherwise, there is likely
-                            //no path mapping for a path starting with '..'.
-                            //This can still fail, but catches the most reasonable
-                            //uses of ..
-                            return true;
-                        } else if (i > 0) {
-                            name.splice(i - 1, 2);
-                            i -= 2;
-                        }
-                    }
-                }
-                //end trimDots
+        name = baseParts.concat(name.split("/"));
 
-                name = name.join("/");
+        //start trimDots
+        for (i = 0; i < name.length; i += 1) {
+          part = name[i];
+          if (part === ".") {
+            name.splice(i, 1);
+            i -= 1;
+          } else if (part === "..") {
+            if (i === 1 && (name[2] === '..' || name[0] === '..')) {
+              //End of the line. Keep at least one non-dot
+              //path segment at the front so it can be mapped
+              //correctly to disk. Otherwise, there is likely
+              //no path mapping for a path starting with '..'.
+              //This can still fail, but catches the most reasonable
+              //uses of ..
+              break;
+            } else if (i > 0) {
+              name.splice(i - 1, 2);
+              i -= 2;
             }
+          }
         }
+        //end trimDots
 
-        //Apply map config if available.
-        if ((baseParts || starMap) && map) {
-            nameParts = name.split('/');
+        name = name.join("/");
+      } else if (name.indexOf('./') === 0) {
+        // No baseName, so this is ID is resolved relative
+        // to baseUrl, pull off the leading dot.
+        name = name.substring(2);
+      }
+    }
 
-            for (i = nameParts.length; i > 0; i -= 1) {
-                nameSegment = nameParts.slice(0, i).join("/");
+    //Apply map config if available.
+    if ((baseParts || starMap) && map) {
+      nameParts = name.split('/');
 
-                if (baseParts) {
-                    //Find the longest baseName segment match in the config.
-                    //So, do joins on the biggest to smallest lengths of baseParts.
-                    for (j = baseParts.length; j > 0; j -= 1) {
-                        mapValue = map[baseParts.slice(0, j).join('/')];
+      for (i = nameParts.length; i > 0; i -= 1) {
+        nameSegment = nameParts.slice(0, i).join("/");
 
-                        //baseName segment has  config, find if it has one for
-                        //this name.
-                        if (mapValue) {
-                            mapValue = mapValue[nameSegment];
-                            if (mapValue) {
-                                //Match, update name to the new value.
-                                foundMap = mapValue;
-                                break;
-                            }
-                        }
-                    }
-                }
+        if (baseParts) {
+          //Find the longest baseName segment match in the config.
+          //So, do joins on the biggest to smallest lengths of baseParts.
+          for (j = baseParts.length; j > 0; j -= 1) {
+            mapValue = map[baseParts.slice(0, j).join('/')];
 
-                foundMap = foundMap || starMap[nameSegment];
-
-                if (foundMap) {
-                    nameParts.splice(0, i, foundMap);
-                    name = nameParts.join('/');
-                    break;
-                }
+            //baseName segment has  config, find if it has one for
+            //this name.
+            if (mapValue) {
+              mapValue = mapValue[nameSegment];
+              if (mapValue) {
+                //Match, update name to the new value.
+                foundMap = mapValue;
+                foundI = i;
+                break;
+              }
             }
+          }
         }
 
-        return name;
-    }
+        if (foundMap) {
+          break;
+        }
 
-    function makeRequire(relName, forceSync) {
-        return function () {
-            //A version of a require function that passes a moduleName
-            //value for items that may need to
-            //look up paths relative to the moduleName
-            return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
-        };
-    }
+        //Check for a star map match, but just hold on to it,
+        //if there is a shorter segment match later in a matching
+        //config, then favor over this star map.
+        if (!foundStarMap && starMap && starMap[nameSegment]) {
+          foundStarMap = starMap[nameSegment];
+          starI = i;
+        }
+      }
 
-    function makeNormalize(relName) {
-        return function (name) {
-            return normalize(name, relName);
-        };
-    }
+      if (!foundMap && foundStarMap) {
+        foundMap = foundStarMap;
+        foundI = starI;
+      }
 
-    function makeLoad(depName) {
-        return function (value) {
-            defined[depName] = value;
-        };
+      if (foundMap) {
+        nameParts.splice(0, foundI, foundMap);
+        name = nameParts.join('/');
+      }
     }
 
-    function callDep(name) {
-        if (waiting.hasOwnProperty(name)) {
-            var args = waiting[name];
-            delete waiting[name];
-            defining[name] = true;
-            main.apply(undef, args);
-        }
+    return name;
+  }
 
-        if (!defined.hasOwnProperty(name)) {
-            throw new Error('No ' + name);
-        }
-        return defined[name];
+  function makeRequire(relName, forceSync) {
+    return function () {
+      //A version of a require function that passes a moduleName
+      //value for items that may need to
+      //look up paths relative to the moduleName
+      return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
+    };
+  }
+
+  function makeNormalize(relName) {
+    return function (name) {
+      return normalize(name, relName);
+    };
+  }
+
+  function makeLoad(depName) {
+    return function (value) {
+      defined[depName] = value;
+    };
+  }
+
+  function callDep(name) {
+    if (hasProp(waiting, name)) {
+      var args = waiting[name];
+      delete waiting[name];
+      defining[name] = true;
+      main.apply(undef, args);
     }
 
-    /**
-     * Makes a name map, normalizing the name, and using a plugin
-     * for normalization if necessary. Grabs a ref to plugin
-     * too, as an optimization.
-     */
-    function makeMap(name, relName) {
-        var prefix, plugin,
-            index = name.indexOf('!');
+    if (!hasProp(defined, name) && !hasProp(defining, name)) {
+      throw new Error('No ' + name);
+    }
+    return defined[name];
+  }
 
-        if (index !== -1) {
-            prefix = normalize(name.slice(0, index), relName);
-            name = name.slice(index + 1);
-            plugin = callDep(prefix);
+  //Turns a plugin!resource to [plugin, resource]
+  //with the plugin being undefined if the name
+  //did not have a plugin prefix.
+  function splitPrefix(name) {
+    var prefix,
+        index = name ? name.indexOf('!') : -1;
+    if (index > -1) {
+      prefix = name.substring(0, index);
+      name = name.substring(index + 1, name.length);
+    }
+    return [prefix, name];
+  }
 
-            //Normalize according
-            if (plugin && plugin.normalize) {
-                name = plugin.normalize(name, makeNormalize(relName));
-            } else {
-                name = normalize(name, relName);
-            }
-        } else {
-            name = normalize(name, relName);
-        }
+  /**
+   * Makes a name map, normalizing the name, and using a plugin
+   * for normalization if necessary. Grabs a ref to plugin
+   * too, as an optimization.
+   */
+  makeMap = function (name, relName) {
+    var plugin,
+        parts = splitPrefix(name),
+        prefix = parts[0];
 
-        //Using ridiculous property names for space reasons
-        return {
-            f: prefix ? prefix + '!' + name : name, //fullName
-            n: name,
-            p: plugin
-        };
+    name = parts[1];
+
+    if (prefix) {
+      prefix = normalize(prefix, relName);
+      plugin = callDep(prefix);
     }
 
-    function makeConfig(name) {
-        return function () {
-            return (config && config.config && config.config[name]) || {};
-        };
+    //Normalize according
+    if (prefix) {
+      if (plugin && plugin.normalize) {
+        name = plugin.normalize(name, makeNormalize(relName));
+      } else {
+        name = normalize(name, relName);
+      }
+    } else {
+      name = normalize(name, relName);
+      parts = splitPrefix(name);
+      prefix = parts[0];
+      name = parts[1];
+      if (prefix) {
+        plugin = callDep(prefix);
+      }
     }
 
-    main = function (name, deps, callback, relName) {
-        var args = [],
-            usingExports,
-            cjsModule, depName, ret, map, i;
+    //Using ridiculous property names for space reasons
+    return {
+      f: prefix ? prefix + '!' + name : name, //fullName
+      n: name,
+      pr: prefix,
+      p: plugin
+    };
+  };
 
-        //Use name if no relName
-        relName = relName || name;
+  function makeConfig(name) {
+    return function () {
+      return (config && config.config && config.config[name]) || {};
+    };
+  }
 
-        //Call the callback to define the module, if necessary.
-        if (typeof callback === 'function') {
+  handlers = {
+    require: function (name) {
+      return makeRequire(name);
+    },
+    exports: function (name) {
+      var e = defined[name];
+      if (typeof e !== 'undefined') {
+        return e;
+      } else {
+        return (defined[name] = {});
+      }
+    },
+    module: function (name) {
+      return {
+        id: name,
+        uri: '',
+        exports: defined[name],
+        config: makeConfig(name)
+      };
+    }
+  };
 
-            //Pull out the defined dependencies and pass the ordered
-            //values to the callback.
-            //Default to [require, exports, module] if no deps
-            deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
-            for (i = 0; i < deps.length; i++) {
-                map = makeMap(deps[i], relName);
-                depName = map.f;
+  main = function (name, deps, callback, relName) {
+    var cjsModule, depName, ret, map, i,
+        args = [],
+        usingExports;
 
-                //Fast path CommonJS standard dependencies.
-                if (depName === "require") {
-                    args[i] = makeRequire(name);
-                } else if (depName === "exports") {
-                    //CommonJS module spec 1.1
-                    args[i] = defined[name] = {};
-                    usingExports = true;
-                } else if (depName === "module") {
-                    //CommonJS module spec 1.1
-                    cjsModule = args[i] = {
-                        id: name,
-                        uri: '',
-                        exports: defined[name],
-                        config: makeConfig(name)
-                    };
-                } else if (defined.hasOwnProperty(depName) || waiting.hasOwnProperty(depName)) {
-                    args[i] = callDep(depName);
-                } else if (map.p) {
-                    map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
-                    args[i] = defined[depName];
-                } else if (!defining[depName]) {
-                    throw new Error(name + ' missing ' + depName);
-                }
-            }
+    //Use name if no relName
+    relName = relName || name;
 
-            ret = callback.apply(defined[name], args);
+    //Call the callback to define the module, if necessary.
+    if (typeof callback === 'function') {
 
-            if (name) {
-                //If setting exports via "module" is in play,
-                //favor that over return value and exports. After that,
-                //favor a non-undefined return value over exports use.
-                if (cjsModule && cjsModule.exports !== undef &&
-                    cjsModule.exports !== defined[name]) {
-                    defined[name] = cjsModule.exports;
-                } else if (ret !== undef || !usingExports) {
-                    //Use the return value from the function.
-                    defined[name] = ret;
-                }
-            }
-        } else if (name) {
-            //May just be an object definition for the module. Only
-            //worry about defining if have a module name.
-            defined[name] = callback;
-        }
-    };
+      //Pull out the defined dependencies and pass the ordered
+      //values to the callback.
+      //Default to [require, exports, module] if no deps
+      deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
+      for (i = 0; i < deps.length; i += 1) {
+        map = makeMap(deps[i], relName);
+        depName = map.f;
 
-    requirejs = require = req = function (deps, callback, relName, forceSync) {
-        if (typeof deps === "string") {
-            //Just return the module wanted. In this scenario, the
-            //deps arg is the module name, and second arg (if passed)
-            //is just the relName.
-            //Normalize module name, if it contains . or ..
-            return callDep(makeMap(deps, callback).f);
-        } else if (!deps.splice) {
-            //deps is a config object, not an array.
-            config = deps;
-            if (callback.splice) {
-                //callback is an array, which means it is a dependency list.
-                //Adjust args if there are dependencies
-                deps = callback;
-                callback = relName;
-                relName = null;
-            } else {
-                deps = undef;
-            }
+        //Fast path CommonJS standard dependencies.
+        if (depName === "require") {
+          args[i] = handlers.require(name);
+        } else if (depName === "exports") {
+          //CommonJS module spec 1.1
+          args[i] = handlers.exports(name);
+          usingExports = true;
+        } else if (depName === "module") {
+          //CommonJS module spec 1.1
+          cjsModule = args[i] = handlers.module(name);
+        } else if (hasProp(defined, depName) ||
+            hasProp(waiting, depName) ||
+            hasProp(defining, depName)) {
+          args[i] = callDep(depName);
+        } else if (map.p) {
+          map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
+          args[i] = defined[depName];
+        } else {
+          throw new Error(name + ' missing ' + depName);
         }
+      }
 
-        //Support require(['a'])
-        callback = callback || function () {};
+      ret = callback.apply(defined[name], args);
 
-        //Simulate async callback;
-        if (forceSync) {
-            main(undef, deps, callback, relName);
-        } else {
-            setTimeout(function () {
-                main(undef, deps, callback, relName);
-            }, 15);
+      if (name) {
+        //If setting exports via "module" is in play,
+        //favor that over return value and exports. After that,
+        //favor a non-undefined return value over exports use.
+        if (cjsModule && cjsModule.exports !== undef &&
+            cjsModule.exports !== defined[name]) {
+          defined[name] = cjsModule.exports;
+        } else if (ret !== undef || !usingExports) {
+          //Use the return value from the function.
+          defined[name] = ret;
         }
+      }
+    } else if (name) {
+      //May just be an object definition for the module. Only
+      //worry about defining if have a module name.
+      defined[name] = callback;
+    }
+  };
 
-        return req;
-    };
+  requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
+    if (typeof deps === "string") {
+      if (handlers[deps]) {
+        //callback in this case is really relName
+        return handlers[deps](callback);
+      }
+      //Just return the module wanted. In this scenario, the
+      //deps arg is the module name, and second arg (if passed)
+      //is just the relName.
+      //Normalize module name, if it contains . or ..
+      return callDep(makeMap(deps, callback).f);
+    } else if (!deps.splice) {
+      //deps is a config object, not an array.
+      config = deps;
+      if (callback.splice) {
+        //callback is an array, which means it is a dependency list.
+        //Adjust args if there are dependencies
+        deps = callback;
+        callback = relName;
+        relName = null;
+      } else {
+        deps = undef;
+      }
+    }
 
-    /**
-     * Just drops the config on the floor, but returns req in case
-     * the config return value is used.
-     */
-    req.config = function (cfg) {
-        config = cfg;
-        return req;
-    };
+    //Support require(['a'])
+    callback = callback || function () {};
 
-    define = function (name, deps, callback) {
+    //If relName is a function, it is an errback handler,
+    //so remove it.
+    if (typeof relName === 'function') {
+      relName = forceSync;
+      forceSync = alt;
+    }
 
-        //This module may not have dependencies
-        if (!deps.splice) {
-            //deps is not an array, so probably means
-            //an object literal or factory function for
-            //the value. Adjust args.
-            callback = deps;
-            deps = [];
-        }
+    //Simulate async callback;
+    if (forceSync) {
+      main(undef, deps, callback, relName);
+    } else {
+      setTimeout(function () {
+        main(undef, deps, callback, relName);
+      }, 15);
+    }
 
-        waiting[name] = [name, deps, callback];
-    };
+    return req;
+  };
 
-    define.amd = {
-        jQuery: true
-    };
+  /**
+   * Just drops the config on the floor, but returns req in case
+   * the config return value is used.
+   */
+  req.config = function (cfg) {
+    config = cfg;
+    return req;
+  };
+
+  define = function (name, deps, callback) {
+
+    //This module may not have dependencies
+    if (!deps.splice) {
+      //deps is not an array, so probably means
+      //an object literal or factory function for
+      //the value. Adjust args.
+      callback = deps;
+      deps = [];
+    }
+
+    if (!hasProp(defined, name) && !hasProp(waiting, name)) {
+      waiting[name] = [name, deps, callback];
+    }
+  };
+
+  define.amd = {
+    jQuery: true
+  };
 }());