requirejs-rails 0.9.0 → 0.9.1

data/lib/requirejs/rails/config.rb

@@ -32,10 +32,12 @@ module Requirejs::Rails
         baseUrl
         callback
         catchError
+        config
         context
         deps
         jQuery
         locale
+        map
         packages
         paths
         priority
@@ -61,6 +63,7 @@ module Requirejs::Rails
         inlineText
         locale
         mainConfigFile
+        map
         modules
         name
         namespace

data/lib/requirejs/rails/engine.rb

@@ -7,24 +7,18 @@ module Requirejs
     class Engine < ::Rails::Engine
 
       ### Configuration setup
-      config.before_configuration do |app|
+      config.before_configuration do
         config.requirejs = Requirejs::Rails::Config.new
         config.requirejs.precompile = [/require\.js$/]
-
-        # Location of the user-supplied config parameters, which will be
-        # merged with the default params.  It should be a YAML file with
-        # a single top-level hash, keys/values corresponding to require.js
-        # config parameters.
-        config.requirejs.user_config_file = Pathname.new(app.paths["config"].first)+'requirejs.yml'
-        if config.requirejs.user_config_file.exist?
-          config.requirejs.user_config = YAML.load(config.requirejs.user_config_file.read)
-        else
-          config.requirejs.user_config = {}
-        end
       end
 
       config.before_initialize do |app|
         config = app.config
+
+        # Process the user config file in #before_initalization (instead of #before_configuration) so that
+        # environment-specific configuration can be injected into the user configuration file
+        process_user_config_file(app, config)
+
         config.assets.precompile += config.requirejs.precompile
 
         manifest_path = File.join(::Rails.public_path, config.assets.prefix, "rjs_manifest.yml")
@@ -43,11 +37,40 @@ module Requirejs
       initializer "requirejs.manifest", :after => "sprockets.environment" do |app|
         config = app.config
         if config.requirejs.manifest_path.exist? && config.assets.digests
-          rjs_digests = YAML.load_file(config.requirejs.manifest_path)
+          rjs_digests = YAML.load(ERB.new(File.new(config.requirejs.manifest_path).read).result)
           config.assets.digests.merge!(rjs_digests)
         end
       end
 
+      private
+
+      # Process the user-supplied config parameters, which will be
+      # merged with the default params.  It should be a YAML file with
+      # a single top-level hash, keys/values corresponding to require.js
+      # config parameters.
+      def process_user_config_file(app, config)
+        config_path = Pathname.new(app.paths["config"].first)
+        config.requirejs.user_config_file = config_path+'requirejs.yml'
+
+        yaml_file_contents = nil
+        if config.requirejs.user_config_file.exist?
+          yaml_file_contents = config.requirejs.user_config_file.read
+        else
+          # if requirejs.yml doesn't exist, look for requirejs.yml.erb and process it as an erb
+          config.requirejs.user_config_file = config_path+'requirejs.yml.erb'
+
+          if config.requirejs.user_config_file.exist?
+            yaml_file_contents = ERB.new(config.requirejs.user_config_file.read).result
+          end
+        end
+
+        if yaml_file_contents.nil?
+          # If we couldn't find any matching file contents to process, empty user config
+          config.requirejs.user_config = {}
+        else
+          config.requirejs.user_config = YAML.load(yaml_file_contents)
+        end
+      end
     end # class Engine
   end
 end

data/lib/requirejs/rails/version.rb

@@ -1,6 +1,6 @@
 module Requirejs
   module Rails
-    Version = "0.9.0"
-    LibVersion = "2.0.2"
+    Version = "0.9.1"
+    LibVersion = "2.1.2"
   end
 end

data/lib/tasks/requirejs-rails_tasks.rake

@@ -107,7 +107,7 @@ EOM
                       "requirejs:test_node"] do
       requirejs.config.target_dir.mkpath
 
-      `node #{requirejs.config.driver_path}`
+      `node "#{requirejs.config.driver_path}"`
       unless $?.success?
         raise RuntimeError, "Asset compilation with node failed."
       end

data/vendor/assets/javascripts/almond.js

@@ -1,5 +1,5 @@
 /**
- * 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
  */
@@ -10,305 +10,387 @@
 
 var requirejs, require, define;
 (function (undef) {
-    var defined = {},
-        waiting = {},
-        config = {},
-        defining = {},
-        aps = [].slice,
-        main, req;
-
-    /**
-     * 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;
-
-        //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);
-
-                name = baseParts.concat(name.split("/"));
-
-                //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 = name.join("/");
+  var main, req, makeMap, handlers,
+      defined = {},
+      waiting = {},
+      config = {},
+      defining = {},
+      hasOwn = Object.prototype.hasOwnProperty,
+      aps = [].slice;
+
+  function hasProp(obj, prop) {
+    return hasOwn.call(obj, prop);
+  }
+
+  /**
+   * 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['*']) || {};
+
+    //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);
+
+        name = baseParts.concat(name.split("/"));
+
+        //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
+
+        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);
+      }
+    }
 
-        //Apply map config if available.
-        if ((baseParts || starMap) && map) {
-            nameParts = name.split('/');
-
-            for (i = nameParts.length; i > 0; i -= 1) {
-                nameSegment = nameParts.slice(0, i).join("/");
-
-                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('/')];
-
-                        //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;
-                            }
-                        }
-                    }
-                }
-
-                foundMap = foundMap || starMap[nameSegment];
-
-                if (foundMap) {
-                    nameParts.splice(0, i, foundMap);
-                    name = nameParts.join('/');
-                    break;
-                }
+    //Apply map config if available.
+    if ((baseParts || starMap) && map) {
+      nameParts = name.split('/');
+
+      for (i = nameParts.length; i > 0; i -= 1) {
+        nameSegment = nameParts.slice(0, i).join("/");
+
+        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('/')];
+
+            //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]));
+    };
+  }
 
-    /**
-     * 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 (index !== -1) {
-            prefix = normalize(name.slice(0, index), relName);
-            name = name.slice(index + 1);
-            plugin = callDep(prefix);
-
-            //Normalize according
-            if (plugin && plugin.normalize) {
-                name = plugin.normalize(name, makeNormalize(relName));
-            } else {
-                name = normalize(name, relName);
-            }
-        } else {
-            name = normalize(name, relName);
-        }
+  function makeNormalize(relName) {
+    return function (name) {
+      return normalize(name, relName);
+    };
+  }
 
-        //Using ridiculous property names for space reasons
-        return {
-            f: prefix ? prefix + '!' + name : name, //fullName
-            n: name,
-            p: plugin
-        };
+  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);
     }
 
-    function makeConfig(name) {
-        return function () {
-            return (config && config.config && config.config[name]) || {};
-        };
+    if (!hasProp(defined, name) && !hasProp(defining, name)) {
+      throw new Error('No ' + name);
+    }
+    return defined[name];
+  }
+
+  //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];
+  }
+
+  /**
+   * 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];
+
+    name = parts[1];
+
+    if (prefix) {
+      prefix = normalize(prefix, relName);
+      plugin = callDep(prefix);
     }
 
-    main = function (name, deps, callback, relName) {
-        var args = [],
-            usingExports,
-            cjsModule, depName, ret, map, i;
-
-        //Use name if no relName
-        relName = relName || name;
-
-        //Call the callback to define the module, if necessary.
-        if (typeof callback === 'function') {
-
-            //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;
-
-                //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);
-                }
-            }
+    //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);
+      }
+    }
 
-            ret = callback.apply(defined[name], args);
-
-            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;
-        }
+    //Using ridiculous property names for space reasons
+    return {
+      f: prefix ? prefix + '!' + name : name, //fullName
+      n: name,
+      pr: prefix,
+      p: plugin
     };
+  };
 
-    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;
-            }
-        }
-
-        //Support require(['a'])
-        callback = callback || function () {};
-
-        //Simulate async callback;
-        if (forceSync) {
-            main(undef, deps, callback, relName);
+  function makeConfig(name) {
+    return function () {
+      return (config && config.config && config.config[name]) || {};
+    };
+  }
+
+  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)
+      };
+    }
+  };
+
+  main = function (name, deps, callback, relName) {
+    var cjsModule, depName, ret, map, i,
+        args = [],
+        usingExports;
+
+    //Use name if no relName
+    relName = relName || name;
+
+    //Call the callback to define the module, if necessary.
+    if (typeof callback === 'function') {
+
+      //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;
+
+        //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 {
-            setTimeout(function () {
-                main(undef, deps, callback, relName);
-            }, 15);
+          throw new Error(name + ' missing ' + depName);
+        }
+      }
+
+      ret = callback.apply(defined[name], args);
+
+      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;
+    }
+  };
+
+  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;
+      }
+    }
 
-        return req;
-    };
+    //Support require(['a'])
+    callback = callback || function () {};
 
-    /**
-     * 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;
-    };
+    //If relName is a function, it is an errback handler,
+    //so remove it.
+    if (typeof relName === 'function') {
+      relName = forceSync;
+      forceSync = alt;
+    }
 
-    define = function (name, deps, callback) {
+    //Simulate async callback;
+    if (forceSync) {
+      main(undef, deps, callback, relName);
+    } else {
+      setTimeout(function () {
+        main(undef, deps, callback, relName);
+      }, 15);
+    }
 
-        //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 = [];
-        }
+    return req;
+  };
+
+  /**
+   * 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 = [];
+    }
 
-        waiting[name] = [name, deps, callback];
-    };
+    if (!hasProp(defined, name) && !hasProp(waiting, name)) {
+      waiting[name] = [name, deps, callback];
+    }
+  };
 
-    define.amd = {
-        jQuery: true
-    };
+  define.amd = {
+    jQuery: true
+  };
 }());