Merge remote branch 'rails/master'

12 files changed, 181 insertions, 106 deletions

diff --git a/railties/lib/rails/application.rb b/railties/lib/rails/application.rb
index aabe86715c..4a7ed2d028 100644
--- a/railties/lib/rails/application.rb
+++ b/railties/lib/rails/application.rb
@@ -28,7 +28,7 @@ module Rails
   # Besides providing the same configuration as Rails::Engine and Rails::Railtie,
   # the application object has several specific configurations, for example
   # "allow_concurrency", "cache_classes", "consider_all_requests_local", "filter_parameters",
-  # "logger", "reload_engines", "reload_plugins" and so forth.
+  # "logger", "reload_plugins" and so forth.
   #
   # Check Rails::Application::Configuration to see them all.
   #
@@ -217,10 +217,5 @@ module Rails
     def initialize_generators
       require "rails/generators"
     end
-
-    # Application is always reloadable when config.cache_classes is false.
-    def reloadable?(app)
-      true
-    end
   end
 end
diff --git a/railties/lib/rails/application/configuration.rb b/railties/lib/rails/application/configuration.rb
index e3165b2d4c..465851c0e6 100644
--- a/railties/lib/rails/application/configuration.rb
+++ b/railties/lib/rails/application/configuration.rb
@@ -10,7 +10,7 @@ module Rails
       attr_accessor :allow_concurrency, :cache_classes, :cache_store,
                     :encoding, :consider_all_requests_local, :dependency_loading,
                     :filter_parameters,  :log_level, :logger, :middleware,
-                    :plugins, :preload_frameworks, :reload_engines, :reload_plugins,
+                    :plugins, :preload_frameworks, :reload_plugins,
                     :secret_token, :serve_static_assets, :session_options,
                     :time_zone, :whiny_nils
 
@@ -59,7 +59,7 @@ module Rails
           if File.exists?("#{root}/test/mocks/#{Rails.env}")
             ActiveSupport::Deprecation.warn "\"Rails.root/test/mocks/#{Rails.env}\" won't be added " <<
               "automatically to load paths anymore in future releases"
-            paths.mocks_path  "test/mocks", :load_path => true, :glob => Rails.env
+            paths.mocks_path  "test/mocks", :autoload => true, :glob => Rails.env
           end
 
           paths
diff --git a/railties/lib/rails/engine.rb b/railties/lib/rails/engine.rb
index 0a3f21fb1b..ee3e3ba040 100644
--- a/railties/lib/rails/engine.rb
+++ b/railties/lib/rails/engine.rb
@@ -142,7 +142,7 @@ module Rails
 
     # Add configured load paths to ruby load paths and remove duplicates.
     initializer :set_load_path, :before => :bootstrap_hook do
-      config.autoload_paths.reverse_each do |path|
+      _all_load_paths.reverse_each do |path|
         $LOAD_PATH.unshift(path) if File.directory?(path)
       end
       $LOAD_PATH.uniq!
@@ -154,16 +154,12 @@ module Rails
     # This needs to be an initializer, since it needs to run once
     # per engine and get the engine as a block parameter
     initializer :set_autoload_paths, :before => :bootstrap_hook do |app|
-      ActiveSupport::Dependencies.autoload_paths.unshift(*config.autoload_paths)
-
-      if reloadable?(app)
-        ActiveSupport::Dependencies.autoload_once_paths.unshift(*config.autoload_once_paths)
-      else
-        ActiveSupport::Dependencies.autoload_once_paths.unshift(*config.autoload_paths)
-      end
+      ActiveSupport::Dependencies.autoload_paths.unshift(*_all_autoload_paths)
+      ActiveSupport::Dependencies.autoload_once_paths.unshift(*config.autoload_once_paths)
 
       # Freeze so future modifications will fail rather than do nothing mysteriously
       config.autoload_paths.freeze
+      config.eager_load_paths.freeze
       config.autoload_once_paths.freeze
     end
 
@@ -195,7 +191,6 @@ module Rails
       ActiveSupport.on_load(:action_controller) do
         prepend_view_path(views)
       end
-
       ActiveSupport.on_load(:action_mailer) do
         prepend_view_path(views)
       end
@@ -214,8 +209,12 @@ module Rails
 
   protected
 
-    def reloadable?(app)
-      app.config.reload_engines
+    def _all_autoload_paths
+      @_all_autoload_paths ||= (config.autoload_paths + config.eager_load_paths + config.autoload_once_paths).uniq
+    end
+
+    def _all_load_paths
+      @_all_load_paths ||= (config.paths.load_paths + _all_autoload_paths).uniq
     end
   end
 end
diff --git a/railties/lib/rails/engine/configuration.rb b/railties/lib/rails/engine/configuration.rb
index 4e27180f1e..2f465670cf 100644
--- a/railties/lib/rails/engine/configuration.rb
+++ b/railties/lib/rails/engine/configuration.rb
@@ -42,11 +42,11 @@ module Rails
       end
 
       def autoload_once_paths
-        @autoload_once_paths ||= paths.load_once
+        @autoload_once_paths ||= paths.autoload_once
       end
 
       def autoload_paths
-        @autoload_paths ||= paths.load_paths
+        @autoload_paths ||= paths.autoload_paths
       end
     end
   end
diff --git a/railties/lib/rails/generators/actions.rb b/railties/lib/rails/generators/actions.rb
index 7af329bbf0..199afbdc30 100644
--- a/railties/lib/rails/generators/actions.rb
+++ b/railties/lib/rails/generators/actions.rb
@@ -275,7 +275,7 @@ module Rails
       #
       def route(routing_code)
         log :route, routing_code
-        sentinel = "routes.draw do |map|"
+        sentinel = /\.routes\.draw do(\s*\|map\|)?\s*$/
 
         in_root do
           inject_into_file 'config/routes.rb', "\n  #{routing_code}\n", { :after => sentinel, :verbose => false }
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
index f0e917dd96..99758dfcf7 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/development.rb.tt
@@ -16,4 +16,7 @@
 
   # Don't care if the mailer can't send
   config.action_mailer.raise_delivery_errors = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
index b9fb13b640..500fc4d860 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/production.rb.tt
@@ -43,4 +43,7 @@
   # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
   # the I18n.default_locale when a translation can not be found)
   config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners
+  config.active_support.deprecation = :notify
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt b/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
index beb28e2229..26cdef071a 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
+++ b/railties/lib/rails/generators/rails/app/templates/config/environments/test.rb.tt
@@ -29,4 +29,7 @@
   # This is necessary if your schema can't be completely dumped by the schema dumper,
   # like if you have constraints or database-specific column types
   # config.active_record.schema_format = :sql
+
+  # Print deprecation notices to the stderr
+  config.active_support.deprecation = :stderr
 end
diff --git a/railties/lib/rails/generators/rails/app/templates/config/routes.rb b/railties/lib/rails/generators/rails/app/templates/config/routes.rb
index d6c0365c04..d42cf3bfdf 100644
--- a/railties/lib/rails/generators/rails/app/templates/config/routes.rb
+++ b/railties/lib/rails/generators/rails/app/templates/config/routes.rb
@@ -1,4 +1,4 @@
-<%= app_const %>.routes.draw do |map|
+<%= app_const %>.routes.draw do
   # The priority is based upon order of creation:
   # first created -> highest priority.
 
diff --git a/railties/lib/rails/generators/rails/app/templates/public/javascripts/rails.js b/railties/lib/rails/generators/rails/app/templates/public/javascripts/rails.js
index c5fa02ae35..4283ed8982 100644
--- a/railties/lib/rails/generators/rails/app/templates/public/javascripts/rails.js
+++ b/railties/lib/rails/generators/rails/app/templates/public/javascripts/rails.js
@@ -1,87 +1,148 @@
-document.observe("dom:loaded", function() {
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
   function handleRemote(element) {
     var method, url, params;
 
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
     if (element.tagName.toLowerCase() === 'form') {
       method = element.readAttribute('method') || 'post';
       url    = element.readAttribute('action');
-      params = element.serialize(true);
+      params = element.serialize();
     } else {
       method = element.readAttribute('data-method') || 'get';
       url    = element.readAttribute('href');
       params = {};
     }
 
-    var event = element.fire("ajax:before");
-    if (event.stopped) return false;
-
     new Ajax.Request(url, {
       method: method,
       parameters: params,
-      asynchronous: true,
       evalScripts: true,
 
-      onLoading:     function(request) { element.fire("ajax:loading", {request: request}); },
-      onLoaded:      function(request) { element.fire("ajax:loaded", {request: request}); },
-      onInteractive: function(request) { element.fire("ajax:interactive", {request: request}); },
-      onComplete:    function(request) { element.fire("ajax:complete", {request: request}); },
-      onSuccess:     function(request) { element.fire("ajax:success", {request: request}); },
-      onFailure:     function(request) { element.fire("ajax:failure", {request: request}); }
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
     });
 
     element.fire("ajax:after");
   }
 
   function handleMethod(element) {
-    var method, url, token_name, token;
-
-    method     = element.readAttribute('data-method');
-    url        = element.readAttribute('href');
-    csrf_param = $$('meta[name=csrf-param]').first();
-    csrf_token = $$('meta[name=csrf-token]').first();
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
 
     var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
-    element.parentNode.appendChild(form);
+    element.parentNode.insert(form);
 
-    if (method != 'post') {
+    if (method !== 'post') {
       var field = new Element('input', { type: 'hidden', name: '_method', value: method });
-      form.appendChild(field);
+      form.insert(field);
     }
 
     if (csrf_param) {
-      var param = csrf_param.readAttribute('content');
-      var token = csrf_token.readAttribute('content');
-      var field = new Element('input', { type: 'hidden', name: param, value: token });
-      form.appendChild(field);
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
     }
 
     form.submit();
   }
 
-  $(document.body).observe("click", function(event) {
-    var message = event.findElement().readAttribute('data-confirm');
-    if (message && !confirm(message)) {
-      event.stop();
-      return false;
-    }
 
-    var element = event.findElement("a[data-remote]");
-    if (element) {
-      handleRemote(element);
-      event.stop();
-      return true;
-    }
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
 
-    var element = event.findElement("a[data-method]");
-    if (element) {
-      handleMethod(element);
-      event.stop();
-      return true;
-    }
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
   });
 
-  // TODO: I don't think submit bubbles in IE
-  $(document.body).observe("submit", function(event) {
+  document.on("submit", function(event) {
     var element = event.findElement(),
         message = element.readAttribute('data-confirm');
     if (message && !confirm(message)) {
@@ -103,16 +164,12 @@ document.observe("dom:loaded", function() {
     }
   });
 
-  $(document.body).observe("ajax:after", function(event) {
-    var element = event.findElement();
-
-    if (element.tagName.toLowerCase() === 'form') {
-      var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
-      inputs.each(function(input) {
-        input.value = input.readAttribute('data-original-value');
-        input.writeAttribute('data-original-value', null);
-        input.disabled = false;
-      });
-    }
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
   });
-});
\ No newline at end of file
+})();
diff --git a/railties/lib/rails/paths.rb b/railties/lib/rails/paths.rb
index 1c9e308631..7a65188a9a 100644
--- a/railties/lib/rails/paths.rb
+++ b/railties/lib/rails/paths.rb
@@ -25,9 +25,7 @@ module Rails
 
       def initialize(path)
         raise if path.is_a?(Array)
-
         @children = {}
-
         @path = path
         @root = self
         @all_paths = []
@@ -38,14 +36,18 @@ module Rails
         @all_paths
       end
 
-      def load_once
-        filter_by(:load_once?)
+      def autoload_once
+        filter_by(:autoload_once?)
       end
 
       def eager_load
         filter_by(:eager_load?)
       end
 
+      def autoload_paths
+        filter_by(:autoload?)
+      end
+
       def load_paths
         filter_by(:load_path?)
       end
@@ -61,15 +63,17 @@ module Rails
     protected
 
       def filter_by(constraint)
-        all_paths.map do |path|
+        all = []
+        all_paths.each do |path|
           if path.send(constraint)
             paths  = path.paths
             paths -= path.children.values.map { |p| p.send(constraint) ? [] : p.paths }.flatten
-            paths
-          else
-            []
+            all.concat(paths)
           end
-        end.flatten.uniq.select { |p| File.exists?(p) }
+        end
+        all.uniq!
+        all.reject! { |p| !File.exists?(p) }
+        all
       end
     end
 
@@ -80,15 +84,16 @@ module Rails
       attr_accessor :glob
 
       def initialize(root, *paths)
-        @options  = paths.last.is_a?(::Hash) ? paths.pop : {}
+        options   = paths.last.is_a?(::Hash) ? paths.pop : {}
         @children = {}
         @root     = root
         @paths    = paths.flatten
-        @glob     = @options.delete(:glob)
+        @glob     = options[:glob]
 
-        @load_once  = @options[:load_once]
-        @eager_load = @options[:eager_load]
-        @load_path  = @options[:load_path] || @eager_load || @load_once
+        autoload_once! if options[:autoload_once]
+        eager_load!    if options[:eager_load]
+        autoload!      if options[:autoload]
+        load_path!     if options[:load_path]
 
         @root.all_paths << self
       end
@@ -111,24 +116,30 @@ module Rails
         @paths.concat paths
       end
 
-      def load_once!
-        @load_once = true
-        @load_path = true
+      def autoload_once!
+        @autoload_once = true
       end
 
-      def load_once?
-        @load_once
+      def autoload_once?
+        @autoload_once
       end
 
       def eager_load!
         @eager_load = true
-        @load_path  = true
       end
 
       def eager_load?
         @eager_load
       end
 
+      def autoload!
+        @autoload = true
+      end
+
+      def autoload?
+        @autoload
+      end
+
       def load_path!
         @load_path = true
       end
diff --git a/railties/lib/rails/plugin.rb b/railties/lib/rails/plugin.rb
index fcdd099135..be229cc9a2 100644
--- a/railties/lib/rails/plugin.rb
+++ b/railties/lib/rails/plugin.rb
@@ -61,6 +61,16 @@ module Rails
       @config ||= Engine::Configuration.new
     end
 
+    initializer :handle_lib_autoload, :before => :set_load_path do |app|
+      paths = if app.config.reload_plugins
+        config.autoload_paths
+      else
+        config.autoload_once_paths
+      end
+
+      paths.concat config.paths.lib.to_a
+    end
+
     initializer :load_init_rb, :before => :load_config_initializers do |app|
       files = %w(rails/init.rb init.rb).map { |path| File.expand_path path, root }
       if initrb = files.find { |path| File.file? path }
@@ -77,11 +87,5 @@ module Rails
         raise "\"#{name}\" is a Railtie/Engine and cannot be installed as plugin"
       end
     end
-
-  protected
-
-    def reloadable?(app)
-      app.config.reload_plugins
-    end
   end
 end