requirejs-rails 0.6.1 → 0.7.0

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# v0.7.0
+
+- Support for [almond](https://github.com/jrburke/almond) via
+  `config.requirejs.loader = :almond` in application.rb.
+- Builds with `config.assets.initialize_on_precompile = false` now work.
+  This supports building on Heroku, builds with Devise, etc. all of
+  which require that setting.
+- We should now play much better with existing Rails Engines that
+  leverage the asset pipeline for their needs.  Thanks to @hollow for the
+  patch.
+
 # v0.6.1
 
 - Fix regression in production env when `paths` specified in requirejs.yml.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    requirejs-rails (0.6.1)
+    requirejs-rails (0.7.0)
       railties (>= 3.1.1, < 3.3)
 
 GEM

data/README.md

@@ -118,6 +118,25 @@ the configuration should be referenced by one of:
 - Be a common library module like `appcommon`, listed in the `priority` config
   option.
 
+### Almond support
+
+This gem supports single-file builds with
+[almond](https://github.com/jrburke/almond). Use the following setting in
+`application.rb` to enable it:
+
+```ruby
+config.requirejs.loader = :almond
+```
+
+Almond builds have the restriction that there must be exactly one modules entry in
+`requirejs.yml`.  Typically the [wrap option](https://github.com/jrburke/r.js/blob/master/build/example.build.js#L275) will be used to create a self-contained build:
+
+```yaml
+modules:
+  - name: 'main'
+wrap: true
+```
+
 ## Advanced features
 
 ### Additional data attributes
@@ -167,10 +186,11 @@ support and actively tracks mainline.
 Underscore 1.3.x likewise doesn't have AMD support.  Again, see
 the [amdjs fork of Underscore](https://github.com/amdjs/underscore).
 
-## Changes
+## 0.x API Changes
 
-Usage changes that impact folks upgrading along the 0.x series are
-documented here. See [the Changelog](CHANGELOG.md) for other details.
+Usage changes that may break functionality for those upgrading along the 0.x
+series are documented here. See [the Changelog](CHANGELOG.md) for the full
+list of feature additions, bugfixes, etc.
 
 ### v0.5.1
 

data/app/helpers/requirejs_helper.rb

@@ -24,9 +24,15 @@ module RequirejsHelper
   end
 
   def requirejs_include_tag(name=nil, &block)
-    html = ""
     requirejs = Rails.application.config.requirejs
 
+    if requirejs.loader == :almond
+      name = requirejs.module_name_for(requirejs.build_config['modules'][0])
+      return _almond_include_tag(name, &block)
+    end
+
+    html = ""
+
     if controller.requirejs_included
       raise Requirejs::MultipleIncludeError, "Only one requirejs_include_tag allowed per page."
     end
@@ -34,7 +40,7 @@ module RequirejsHelper
     unless requirejs.run_config.empty?
       run_config = requirejs.run_config
       if Rails.application.config.assets.digest
-        modules = requirejs.build_config['modules'].map { |m| m['name'] }
+        modules = requirejs.build_config['modules'].map { |m| requirejs.module_name_for m }
 
         # Generate digestified paths from the modules spec
         paths = {}
@@ -56,4 +62,8 @@ module RequirejsHelper
     controller.requirejs_included = true
     html.html_safe
   end
+
+  def _almond_include_tag(name, &block)
+    "<script src='#{javascript_path name}'></script>\n".html_safe
+  end
 end

data/lib/requirejs/error.rb

@@ -1,4 +1,6 @@
 module Requirejs
   # Raised if requirejs_include_tag appears multiple times on a page.
   class MultipleIncludeError < RuntimeError; end
-end
+  # Raised if the configuration fails validation.
+  class ConfigError < ArgumentError; end
+end

data/lib/requirejs/rails/config.rb

@@ -1,4 +1,5 @@
 require 'requirejs/rails'
+require 'requirejs/error'
 
 require 'active_support/ordered_options'
 require 'erubis'
@@ -6,8 +7,9 @@ require 'pathname'
 
 module Requirejs::Rails
   class Config < ::ActiveSupport::OrderedOptions
+    LOADERS = [ :requirejs, :almond ]
 
-    def initialize(app=Rails.application)
+    def initialize
       super
       self.manifest = nil
 
@@ -18,18 +20,11 @@ module Requirejs::Rails
       self.target_dir = Rails.root + 'public/assets'
       self.rjs_path   = self.bin_dir+'r.js'
 
+      self.loader = :requirejs
+
       self.driver_template_path = Pathname.new(__FILE__+'/../rjs_driver.js.erb').cleanpath
       self.driver_path = self.tmp_dir + 'rjs_driver.js'
 
-      # The user-supplied config parameters, to be merged with the default params.
-      # This file must contain a single JavaScript object.
-      self.user_config_file = Pathname.new(app.paths["config"].first)+'requirejs.yml'
-      if self.user_config_file.exist?
-        self.user_config = YAML.load(self.user_config_file.read)
-      else
-        self.user_config = {}
-      end
-
       self.run_config_whitelist = %w{
         baseUrl
         callback
@@ -85,21 +80,51 @@ module Requirejs::Rails
       }
     end
 
+    def loader=(sym)
+      unless LOADERS.include?(sym)
+        raise Requirejs::ConfigError, "Attempt to set unknown loader: #{sym}"
+      end
+      self[:loader] = sym
+    end
+
     def build_config
-      build_config = self.run_config.merge "baseUrl" => source_dir.to_s
-      build_config.merge!(self.user_config).slice(*self.build_config_whitelist)
+      unless self.has_key?(:build_config)
+        self[:build_config] = self.run_config.merge "baseUrl" => source_dir.to_s,
+                                                    "modules" => [ { 'name' => 'application' } ]
+        self[:build_config].merge!(self.user_config).slice!(*self.build_config_whitelist)
+        case self.loader
+        when :requirejs 
+          # nothing to do
+        when :almond
+          mods = self[:build_config]['modules']
+          unless mods.length == 1
+            raise Requirejs::ConfigError, "Almond build requires exactly one module, config has #{mods.length}."
+          end
+          mod = mods[0]
+          name = mod['name']
+          mod['name'] = 'almond'
+          mod['include'] = name
+        end
+      end
+      self[:build_config]
     end
 
     def run_config
-      run_config = {
-        "baseUrl" => "/assets",
-        "modules" => [ { 'name' => 'application' } ]
-      }
+      run_config = { "baseUrl" => "/assets" }
       run_config.merge!(self.user_config).slice(*self.run_config_whitelist)
     end
 
-    def module_path_for(name)
-      self.target_dir+(name+'.js')
+    def module_name_for(mod)
+      case self.loader
+      when :almond
+        return mod['include']
+      when :requirejs
+        return mod['name']
+      end
+    end
+
+    def module_path_for(mod)
+      self.target_dir+(module_name_for(mod)+'.js')
     end
 
     def get_binding

data/lib/requirejs/rails/engine.rb

@@ -6,31 +6,42 @@ module Requirejs
   module Rails
     class Engine < ::Rails::Engine
 
-      initializer "requirejs.tag_included_state" do |app|
-        ActiveSupport.on_load(:action_controller) do
-          ::ActionController::Base.class_eval do
-            attr_accessor :requirejs_included
-          end
-        end
-      end
+      ### Configuration setup
+      config.before_configuration do |app|
+        config.requirejs = Requirejs::Rails::Config.new
+        config.requirejs.precompile = [/require\.js$/]
 
-      initializer "requirejs.config" do |app|
-        config = app.config
-        config.requirejs = Requirejs::Rails::Config.new(app)
-        if config.requirejs.manifest
-          path = File.join(config.assets.manifest, "rjs_manifest.yml")
+        # 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
-          path = File.join(::Rails.public_path, config.assets.prefix, "rjs_manifest.yml")
+          config.requirejs.user_config = {}
         end
-        config.requirejs.manifest_path = Pathname.new(path)
-        
-        config.requirejs.precompile = [/require\.js$/]
+      end
 
+      config.before_initialize do |app|
+        config = app.config
         if ::Rails.env == "production"
           config.assets.precompile += config.requirejs.precompile
         end
+
+        manifest_path = File.join(::Rails.public_path, config.assets.prefix, "rjs_manifest.yml")
+        config.requirejs.manifest_path = Pathname.new(manifest_path)
       end
-      
+
+      ### Initializers
+      initializer "requirejs.tag_included_state" do |app|
+        ActiveSupport.on_load(:action_controller) do
+          ::ActionController::Base.class_eval do
+            attr_accessor :requirejs_included
+          end
+        end
+      end
+
       initializer "requirejs.manifest", :after => "sprockets.environment" do |app|
         config = app.config
         if config.requirejs.manifest_path.exist? && config.assets.digests

data/lib/requirejs/rails/rjs_driver.js.erb

@@ -1,32 +1,22 @@
 //Load the requirejs optimizer
 var requirejs = require('<%= rjs_path %>'),
-    //Set up basic config, include config that is
-    //common to all the optimize() calls.
-    basConfig = <%= JSON.pretty_generate(build_config.reject {|k,v| k == 'modules'}) %>;
+  //Set up basic config, include config that is
+  //common to all the optimize() calls.
+  basConfig = <%= JSON.pretty_generate(build_config.reject {|k,v| k == 'modules'}) %>;
 
 // Function used to mix in baseConfig to a new config target
 function mix(target) {
-    for (var prop in basConfig) {
-        if (basConfig.hasOwnProperty(prop)) {
-            target[prop] = basConfig[prop];
-        }
+  for (var prop in basConfig) {
+    if (basConfig.hasOwnProperty(prop)) {
+      target[prop] = basConfig[prop];
     }
-    return target;
+  }
+  return target;
 }
 
 var module_specs = [
 <% build_config['modules'].each do |m| %>
-  {
-    name: "<%= m['name'] %>",
-    <% if m['include'] %>
-    include: [<%= m['include'].map {|i| "'#{i}'" }.join(", ") %>],
-    <% end %>
-    <% if m['exclude'] %>
-    exclude: [<%= m['exclude'].map {|i| "'#{i}'" }.join(", ") %>],
-    <% end %>
-
-    out: '<%= module_path_for m['name'] %>'
-  },
+<%= JSON.pretty_generate(m.merge 'out' => module_path_for(m).to_s ) %>,
 <% end %>
 ];
 

data/lib/requirejs/rails/version.rb

@@ -1,5 +1,6 @@
 module Requirejs
   module Rails
-    VERSION = "0.6.1"
+    Version = "0.7.0"
+    LibVersion = "1.0.7"
   end
 end

data/lib/tasks/requirejs-rails_tasks.rake

@@ -9,34 +9,8 @@ require 'tempfile'
 
 require 'active_support/ordered_options'
 
-# Prevent Sprockets::Bootstrap from making the environment immutable,
-# as we need to manipulate the environment paths before the asset build.
-#
-# Without this, task requirejs:assets:purge_js throws an exception from 
-# Sprockets::Index#expire_index!, which is in response to any mutating
-# method call.
-#
-if Rails.env == "production"
-  require 'sprockets/bootstrap'
-  module ::Sprockets
-    class Bootstrap
-      alias_method :orig_run, :run
-      def run(*args)
-        config = @app.config
-        saved_config_assets_digest = config.assets.digest
-        begin
-          config.assets.digest = false
-          orig_run(*args)
-        ensure
-          config.assets.digest = saved_config_assets_digest
-        end
-      end
-    end
-  end
-end
-
 namespace :requirejs do
-  
+
   # From Rails 3 assets.rake; we have the same problem:
   #
   # We are currently running with no explicit bundler group
@@ -49,38 +23,33 @@ namespace :requirejs do
       Rake::Task[task].invoke
     end
   end
-  
-  class String
-    def unindent
-      gsub /^#{self[/\A\s*/]}/, ''
-    end
-  end
-  
+
   requirejs = ActiveSupport::OrderedOptions.new
-  
+
   task :clean => ["requirejs:setup"] do
     FileUtils.remove_entry_secure(requirejs.config.source_dir, true)
     FileUtils.remove_entry_secure(requirejs.driver_path, true)
   end
 
-  task :setup => ["environment"] do
+  task :setup => ["assets:environment"] do
     unless Rails.application.config.assets.enabled
       warn "Cannot precompile assets if sprockets is disabled. Please set config.assets.enabled to true"
       exit
     end
-    
+
     # Ensure that action view is loaded and the appropriate
     # sprockets hooks get executed
     _ = ActionView::Base
 
     requirejs.env = Rails.application.assets
+
     # Preserve the original asset paths, as we'll be manipulating them later
     requirejs.env_paths = requirejs.env.paths.dup
     requirejs.config = Rails.application.config.requirejs
     requirejs.builder = Requirejs::Rails::Builder.new(requirejs.config)
     requirejs.manifest = {}
   end
-  
+
   task :test_node do
     begin
       `node -v`
@@ -93,38 +62,48 @@ EOM
       exit 1
     end
   end
-  
+
   namespace :precompile do
-    # stage1 must NOT be run in the production environment
+    task :all => ["requirejs:precompile:prepare_source",
+                  "requirejs:precompile:generate_rjs_driver",
+                  "requirejs:precompile:run_rjs",
+                  "requirejs:precompile:digestify_and_compress"]
+
+    task :disable_js_compressor do
+      # Ensure that Sprockets doesn't try to compress assets before they hit
+      # r.js.  Failure to do this can cause a build which works in dev, but
+      # emits require.js "notloaded" errors, etc. in production.
+      Rails.application.config.assets.js_compressor = false
+    end
+
+    # Invoke another ruby process if we're called from inside
+    # assets:precompile so we don't clobber the environment
     #
-    # Depend on test_node first here so we'll fail early and hard if 
-    # node isn't available.
-    task :stage1 => ["requirejs:test_node",
-                     "requirejs:precompile:prepare_source",
-                     "requirejs:precompile:generate_rjs_driver",
-                     "requirejs:precompile:run_rjs"]
-    task :stage2 => ["requirejs:precompile:digestify_and_compress"]
-    
-    # Copy all assets to tmp/assets
-    task :prepare_source => ["requirejs:setup", 
-                             "requirejs:clean", 
-                             "requirejs:assets:keep_js"] do
+    # We depend on test_node here so we'll fail early and hard if node
+    # isn't available.
+    task :external => ["requirejs:test_node"] do
+      ruby_rake_task "requirejs:precompile:all"
+    end
+
+    # copy all assets to tmp/assets
+    task :prepare_source => ["requirejs:setup",
+                             "requirejs:clean"] do
       requirejs.config.source_dir.mkpath
       requirejs.env.each_logical_path do |logical_path|
+        next unless logical_path =~ /\.js$/
         if asset = requirejs.env.find_asset(logical_path)
           filename = requirejs.config.source_dir + asset.logical_path
           filename.dirname.mkpath
-          
           asset.write_to(filename)
         end
       end
     end
-    
+
     task :generate_rjs_driver => ["requirejs:setup"] do
       requirejs.builder.generate_rjs_driver
     end
 
-    task :run_rjs => ["requirejs:setup", 
+    task :run_rjs => ["requirejs:setup",
                       "requirejs:test_node"] do
       requirejs.config.target_dir.mkpath
 
@@ -133,12 +112,12 @@ EOM
         raise RuntimeError, "Asset compilation with node failed."
       end
     end
-    
-    # Copy each built asset, identified by a named module in the 
+
+    # Copy each built asset, identified by a named module in the
     # build config, to its Sprockets digestified name.
     task :digestify_and_compress => ["requirejs:setup"] do
       requirejs.config.build_config['modules'].each do |m|
-        asset_name = "#{m['name']}.js"
+        asset_name = "#{requirejs.config.module_name_for(m)}.js"
         built_asset_path = requirejs.config.target_dir + asset_name
         digest_name = asset_name.sub(/\.(\w+)$/) { |ext| "-#{requirejs.builder.digest_for(built_asset_path)}#{ext}" }
         digest_asset_path = requirejs.config.target_dir + digest_name
@@ -156,7 +135,7 @@ EOM
         requirejs.config.manifest_path.open('wb') do |f|
           YAML.dump(requirejs.manifest,f)
         end
-      end    
+      end
     end
   end
 
@@ -164,31 +143,9 @@ EOM
   task :precompile do
     invoke_or_reboot_rake_task "requirejs:precompile:all"
   end
-
-  # We remove all .js assets from the Rails Asset Pipeline when 
-  # precompiling, as those are handled by r.js. Conversely, r.js 
-  # only sees .js assets. For now, this is by path convention; any
-  # asset path ending in "javascript". If you've got javascripts in 
-  # your stylesheets directory, then heaven help you. You've got bigger
-  # problems.
-  namespace :assets do
-    # Purge all ".../javascripts" directories from the asset paths
-    task :purge_js => ["requirejs:setup"] do
-      new_paths = requirejs.env_paths.dup.delete_if { |p| p =~ /javascripts$/ && p !~ /requirejs-rails/ }
-      requirejs.env.clear_paths
-      new_paths.each { |p| requirejs.env.append_path(p) }
-    end
-    
-    # Preserve only ".../javascripts" directories
-    task :keep_js => ["requirejs:setup"] do
-      new_paths = requirejs.env_paths.dup.keep_if { |p| p =~ /javascripts$/ }
-      requirejs.env.clear_paths
-      new_paths.each { |p| requirejs.env.append_path(p) }
-    end
-  end
 end
 
-task "assets:precompile:primary" => ["requirejs:precompile:stage2", 
-                                     "requirejs:assets:purge_js"]
-task "assets:precompile:nondigest" => ["requirejs:assets:purge_js"]
-task "assets:precompile" => ["requirejs:precompile:stage1"]
+task "assets:precompile" => ["requirejs:precompile:external"]
+if ARGV[0] == "requirejs:precompile:all"
+  task "assets:environment" => ["requirejs:precompile:disable_js_compressor"]
+end

data/requirejs-rails.gemspec

@@ -6,7 +6,7 @@ require "requirejs/rails/version"
 # Describe your gem and declare its dependencies:
 Gem::Specification.new do |s|
   s.name        = "requirejs-rails"
-  s.version     = Requirejs::Rails::VERSION
+  s.version     = Requirejs::Rails::Version
   s.authors     = ["John Whitley"]
   s.email       = ["whitley@bangpath.org"]
   s.homepage    = "http://github.com/jwhitley/requirejs-rails"

data/test/requirejs-rails_test.rb

@@ -13,7 +13,29 @@ class RequirejsRailsTest < ActiveSupport::TestCase
   test "require.js version" do
     require_js = Pathname.new(__FILE__+'/../../vendor/assets/javascripts/require.js').cleanpath.read
     context = ExecJS.compile(require_js)
-    assert_equal "1.0.7", context.eval("require.version")
+    assert_equal Requirejs::Rails::LibVersion, context.eval("require.version")
+  end
+
+  test "CHANGELOG up to date" do
+    changelog_match = (/^# v#{Requirejs::Rails::Version}/ =~ Pathname.new(__FILE__+'/../../CHANGELOG.md').cleanpath.read)
+    assert changelog_match, "CHANGELOG has no section for v#{Requirejs::Rails::Version}"
+  end
+end
+
+class RequirejsRailsConfigTest < ActiveSupport::TestCase
+  def setup
+    @cfg = Requirejs::Rails::Config.new
+  end
+
+  test "config accepts known loaders" do
+    @cfg.loader = :almond
+    assert_equal :almond, @cfg.loader
+  end
+
+  test "config rejects bad loaders" do
+    assert_raises Requirejs::ConfigError do
+      @cfg.loader = :wombat
+    end
   end
 end
 

data/vendor/assets/javascripts/almond.js

@@ -0,0 +1,277 @@
+/**
+ * almond 0.0.3 Copyright (c) 2011, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/almond for details
+ */
+/*jslint strict: false, plusplus: false */
+/*global setTimeout: false */
+
+var requirejs, require, define;
+(function (undef) {
+
+    var defined = {},
+        waiting = {},
+        aps = [].slice,
+        main, req;
+
+    if (typeof define === "function") {
+        //If a define is already in play via another AMD loader,
+        //do not overwrite.
+        return;
+    }
+
+    /**
+     * 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) {
+        //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.
+                baseName = baseName.split("/");
+                baseName = baseName.slice(0, baseName.length - 1);
+
+                name = baseName.concat(name.split("/"));
+
+                //start trimDots
+                var i, part;
+                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 ..
+                            break;
+                        } else if (i > 0) {
+                            name.splice(i - 1, 2);
+                            i -= 2;
+                        }
+                    }
+                }
+                //end trimDots
+
+                name = name.join("/");
+            }
+        }
+        return 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 (waiting.hasOwnProperty(name)) {
+            var args = waiting[name];
+            delete waiting[name];
+            main.apply(undef, args);
+        }
+        return defined[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.
+     */
+    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);
+        }
+
+        //Using ridiculous property names for space reasons
+        return {
+            f: prefix ? prefix + '!' + name : name, //fullName
+            n: name,
+            p: plugin
+        };
+    }
+
+    main = function (name, deps, callback, relName) {
+        var args = [],
+            usingExports,
+            cjsModule, depName, i, ret, map;
+
+        //Use name if no relName
+        if (!relName) {
+            relName = name;
+        }
+
+        //Call the callback to define the module, if necessary.
+        if (typeof callback === 'function') {
+
+            //Default to require, exports, module if no deps if
+            //the factory arg has any arguments specified.
+            if (!deps.length && callback.length) {
+                deps = ['require', 'exports', 'module'];
+            }
+
+            //Pull out the defined dependencies and pass the ordered
+            //values to the callback.
+            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]
+                    };
+                } 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 {
+                    throw 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) {
+                    defined[name] = cjsModule.exports;
+                } else if (!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 = 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.
+            //Drop the config stuff on the ground.
+            if (callback.splice) {
+                //callback is an array, which means it is a dependency list.
+                //Adjust args if there are dependencies
+                deps = callback;
+                callback = arguments[2];
+            } else {
+                deps = [];
+            }
+        }
+
+        //Simulate async callback;
+        if (forceSync) {
+            main(undef, deps, callback, relName);
+        } else {
+            setTimeout(function () {
+                main(undef, deps, callback, relName);
+            }, 15);
+        }
+
+        return req;
+    };
+
+    /**
+     * Just drops the config on the floor, but returns req in case
+     * the config return value is used.
+     */
+    req.config = function () {
+        return req;
+    };
+
+    /**
+     * Export require as a global, but only if it does not already exist.
+     */
+    if (!require) {
+        require = 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 (define.unordered) {
+            waiting[name] = [name, deps, callback];
+        } else {
+            main(name, deps, callback);
+        }
+    };
+
+    define.amd = {
+        jQuery: true
+    };
+}());

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: requirejs-rails
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-10 00:00:00.000000000 Z
+date: 2012-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
-  requirement: &70307822048760 !ruby/object:Gem::Requirement
+  requirement: &70126226567640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -24,10 +24,10 @@ dependencies:
         version: '3.3'
   type: :runtime
   prerelease: false
-  version_requirements: *70307822048760
+  version_requirements: *70126226567640
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70307822046940 !ruby/object:Gem::Requirement
+  requirement: &70126226564660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -38,10 +38,10 @@ dependencies:
         version: '3.3'
   type: :development
   prerelease: false
-  version_requirements: *70307822046940
+  version_requirements: *70126226564660
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70307822042460 !ruby/object:Gem::Requirement
+  requirement: &70126226563180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -49,7 +49,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70307822042460
+  version_requirements: *70126226563180
 description: This gem provides RequireJS support for your Rails 3 application.
 email:
 - whitley@bangpath.org
@@ -77,6 +77,7 @@ files:
 - lib/requirejs/rails/version.rb
 - lib/tasks/requirejs-rails_tasks.rake
 - requirejs-rails.gemspec
+- vendor/assets/javascripts/almond.js
 - vendor/assets/javascripts/order.js
 - vendor/assets/javascripts/require.js
 - test/dummy/.rvmrc
@@ -128,7 +129,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4356678976778407183
+      hash: 950199913290344440
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -137,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4356678976778407183
+      hash: 950199913290344440
 requirements:
 - node.js is required for 'rake assets:precompile', used to run the r.js build
 - If needed, jQuery should be v1.7 or greater (jquery-rails >= 1.0.17).