Merge commit 'mainstream/master'

33 files changed, 450 insertions, 230 deletions

diff --git a/actionmailer/lib/action_mailer/base.rb b/actionmailer/lib/action_mailer/base.rb
index f421945763..db4589ee8f 100644
--- a/actionmailer/lib/action_mailer/base.rb
+++ b/actionmailer/lib/action_mailer/base.rb
@@ -254,6 +254,8 @@ module ActionMailer #:nodoc:
     private_class_method :new #:nodoc:
 
     class_inheritable_accessor :view_paths
+    self.view_paths = []
+
     cattr_accessor :logger
 
     @@smtp_settings = {
@@ -594,7 +596,7 @@ module ActionMailer #:nodoc:
       end
 
       def initialize_template_class(assigns)
-        template = ActionView::Base.new(view_paths, assigns, self)
+        template = ActionView::Base.new(self.class.view_paths, assigns, self)
         template.template_format = default_template_format
         template
       end
diff --git a/actionmailer/test/mail_service_test.rb b/actionmailer/test/mail_service_test.rb
index 0934d3537f..1e04531753 100644
--- a/actionmailer/test/mail_service_test.rb
+++ b/actionmailer/test/mail_service_test.rb
@@ -975,7 +975,7 @@ end
 
 class InheritableTemplateRootTest < Test::Unit::TestCase
   def test_attr
-    expected = ("#{File.dirname(__FILE__)}/fixtures/path.with.dots").sub(/\.\//, '')
+    expected = "#{File.dirname(__FILE__)}/fixtures/path.with.dots"
     assert_equal expected, FunkyPathMailer.template_root.to_s
 
     sub = Class.new(FunkyPathMailer)
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index 1a3e05cc86..ca826e7bfc 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -59,6 +59,7 @@ module ActionController
   autoload :ParamsParser, 'action_controller/params_parser'
   autoload :PolymorphicRoutes, 'action_controller/polymorphic_routes'
   autoload :RecordIdentifier, 'action_controller/record_identifier'
+  autoload :Reloader, 'action_controller/reloader'
   autoload :Request, 'action_controller/request'
   autoload :RequestForgeryProtection, 'action_controller/request_forgery_protection'
   autoload :Rescue, 'action_controller/rescue'
diff --git a/actionpack/lib/action_controller/dispatcher.rb b/actionpack/lib/action_controller/dispatcher.rb
index e91babde10..ec40b5c4e6 100644
--- a/actionpack/lib/action_controller/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatcher.rb
@@ -5,8 +5,9 @@ module ActionController
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          # Development mode callbacks
-          before_dispatch :reload_application
+          unless self.middleware.include?(Reloader)
+            self.middleware.insert_after(Failsafe, Reloader)
+          end
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
@@ -41,6 +42,30 @@ module ActionController
         callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
         @prepare_dispatch_callbacks.replace_or_append!(callback)
       end
+
+      def run_prepare_callbacks
+        if defined?(Rails) && Rails.logger
+          logger = Rails.logger
+        else
+          logger = Logger.new($stderr)
+        end
+
+        new(logger).send :run_callbacks, :prepare_dispatch
+      end
+
+      def reload_application
+        # Run prepare callbacks before every request in development mode
+        run_prepare_callbacks
+
+        Routing::Routes.reload
+      end
+
+      def cleanup_application
+        # Cleanup the application before processing the current request.
+        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+        ActiveSupport::Dependencies.clear
+        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
+      end
     end
 
     cattr_accessor :middleware
@@ -87,18 +112,6 @@ module ActionController
       dispatch
     end
 
-    def reload_application
-      # Cleanup the application before processing the current request.
-      ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-      ActiveSupport::Dependencies.clear
-      ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-
-      # Run prepare callbacks before every request in development mode
-      run_callbacks :prepare_dispatch
-
-      Routing::Routes.reload
-    end
-
     def flush_logger
       Base.logger.flush
     end
diff --git a/actionpack/lib/action_controller/layout.rb b/actionpack/lib/action_controller/layout.rb
index d6bcf7a8c1..a0db7acf72 100644
--- a/actionpack/lib/action_controller/layout.rb
+++ b/actionpack/lib/action_controller/layout.rb
@@ -172,23 +172,10 @@ module ActionController #:nodoc:
         @layout_conditions ||= read_inheritable_attribute(:layout_conditions)
       end
 
-      def default_layout(format) #:nodoc:
-        layout = read_inheritable_attribute(:layout) unless format == :js
-        return layout unless read_inheritable_attribute(:auto_layout)
-        find_layout(layout, format)
-      end
-
       def layout_list #:nodoc:
         Array(view_paths).sum([]) { |path| Dir["#{path.to_str}/layouts/**/*"] }
       end
 
-      def find_layout(layout, *formats) #:nodoc:
-        return layout if layout.respond_to?(:render)
-        view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
-      rescue ActionView::MissingTemplate
-        nil
-      end
-
       private
         def inherited_with_layout(child)
           inherited_without_layout(child)
@@ -212,35 +199,29 @@ module ActionController #:nodoc:
     # object). If the layout was defined without a directory, layouts is assumed. So <tt>layout "weblog/standard"</tt> will return
     # weblog/standard, but <tt>layout "standard"</tt> will return layouts/standard.
     def active_layout(passed_layout = nil)
-      layout = passed_layout || self.class.default_layout(default_template_format)
+      layout = passed_layout || default_layout
+      return layout if layout.respond_to?(:render)
 
       active_layout = case layout
         when Symbol then __send__(layout)
         when Proc   then layout.call(self)
         else layout
       end
-
-      if active_layout
-        if layout = self.class.find_layout(active_layout, @template.template_format)
-          layout
-        else
-          raise ActionView::MissingTemplate.new(self.class.view_paths, active_layout)
-        end
-      end
+      
+      find_layout(active_layout, @template.template_format) if active_layout
     end
 
     private
-      def candidate_for_layout?(options)
-        template = options[:template] || default_template(options[:action])
-        if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
-          begin
-            !self.view_paths.find_template(template, default_template_format).exempt_from_layout?
-          rescue ActionView::MissingTemplate
-            true
-          end
-        end
+      def default_layout #:nodoc:
+        layout = self.class.read_inheritable_attribute(:layout) unless default_template_format == :js
+        return layout unless self.class.read_inheritable_attribute(:auto_layout)
+        find_layout(layout, default_template_format)
       rescue ActionView::MissingTemplate
-        false
+        nil
+      end
+
+      def find_layout(layout, *formats) #:nodoc:
+        view_paths.find_template(layout.to_s =~ /layouts\// ? layout : "layouts/#{layout}", *formats)
       end
 
       def pick_layout(options)
@@ -273,6 +254,19 @@ module ActionController #:nodoc:
         end
       end
 
+      def candidate_for_layout?(options)
+        template = options[:template] || default_template(options[:action])
+        if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
+          begin
+            !self.view_paths.find_template(template, default_template_format).exempt_from_layout?
+          rescue ActionView::MissingTemplate
+            true
+          end
+        end
+      rescue ActionView::MissingTemplate
+        false
+      end
+
       def default_template_format
         response.template.template_format
       end
diff --git a/actionpack/lib/action_controller/middleware_stack.rb b/actionpack/lib/action_controller/middleware_stack.rb
index dbc2fda41e..b739a6d72d 100644
--- a/actionpack/lib/action_controller/middleware_stack.rb
+++ b/actionpack/lib/action_controller/middleware_stack.rb
@@ -27,7 +27,9 @@ module ActionController
       end
 
       def klass
-        if @klass.is_a?(Class)
+        if @klass.respond_to?(:call)
+          @klass.call
+        elsif @klass.is_a?(Class)
           @klass
         else
           @klass.to_s.constantize
@@ -37,6 +39,8 @@ module ActionController
       end
 
       def active?
+        return false unless klass
+
         if @conditional.respond_to?(:call)
           @conditional.call
         else
@@ -63,11 +67,17 @@ module ActionController
 
       def build(app)
         if block
-          klass.new(app, *args, &block)
+          klass.new(app, *build_args, &block)
         else
-          klass.new(app, *args)
+          klass.new(app, *build_args)
         end
       end
+
+      private
+
+        def build_args
+          Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
+        end
     end
 
     def initialize(*args, &block)
diff --git a/actionpack/lib/action_controller/middlewares.rb b/actionpack/lib/action_controller/middlewares.rb
index 8ea1b5c7ce..371cf6d8f7 100644
--- a/actionpack/lib/action_controller/middlewares.rb
+++ b/actionpack/lib/action_controller/middlewares.rb
@@ -4,17 +4,8 @@ use "Rack::Lock", :if => lambda {
 
 use "ActionController::Failsafe"
 
-["ActionController::Session::CookieStore",
- "ActionController::Session::MemCacheStore",
- "ActiveRecord::SessionStore"].each do |store|
-   use(store, ActionController::Base.session_options,
-      :if => lambda {
-        if session_store = ActionController::Base.session_store
-          session_store.name == store
-        end
-      }
-    )
-end
+use lambda { ActionController::Base.session_store },
+    lambda { ActionController::Base.session_options }
 
 use "ActionController::RewindableInput"
 use "ActionController::ParamsParser"
diff --git a/actionpack/lib/action_controller/reloader.rb b/actionpack/lib/action_controller/reloader.rb
new file mode 100644
index 0000000000..46789309cd
--- /dev/null
+++ b/actionpack/lib/action_controller/reloader.rb
@@ -0,0 +1,14 @@
+module ActionController
+  class Reloader
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      Dispatcher.reload_application
+      @app.call(env)
+    ensure
+      Dispatcher.cleanup_application
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/routing/segments.rb b/actionpack/lib/action_controller/routing/segments.rb
index 5dda3d4d00..129e87c139 100644
--- a/actionpack/lib/action_controller/routing/segments.rb
+++ b/actionpack/lib/action_controller/routing/segments.rb
@@ -191,23 +191,19 @@ module ActionController
       end
 
       def regexp_chunk
-        if regexp
-          if regexp_has_modifiers?
-            "(#{regexp.to_s})"
-          else
-            "(#{regexp.source})"
-          end
-        else
-          "([^#{Routing::SEPARATORS.join}]+)"
-        end
+        regexp ? regexp_string : default_regexp_chunk
+      end
+
+      def regexp_string
+        regexp_has_modifiers? ? "(#{regexp.to_s})" : "(#{regexp.source})"
+      end
+
+      def default_regexp_chunk
+        "([^#{Routing::SEPARATORS.join}]+)"
       end
 
       def number_of_captures
-        if regexp
-          regexp.number_of_captures + 1
-        else
-          1
-        end
+        regexp ? regexp.number_of_captures + 1 : 1
       end
 
       def build_pattern(pattern)
@@ -244,10 +240,6 @@ module ActionController
         "(?i-:(#{(regexp || Regexp.union(*possible_names)).source}))"
       end
 
-      def number_of_captures
-        1
-      end
-
       # Don't URI.escape the controller name since it may contain slashes.
       def interpolation_chunk(value_code = local_name)
         "\#{#{value_code}.to_s}"
@@ -289,8 +281,8 @@ module ActionController
         "params[:#{key}] = PathSegment::Result.new_escaped((match[#{next_capture}]#{" || " + default.inspect if default}).split('/'))#{" if match[" + next_capture + "]" if !default}"
       end
 
-      def regexp_chunk
-        regexp || "(.*)"
+      def default_regexp_chunk
+        "(.*)"
       end
 
       def number_of_captures
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index 4198725e0d..65b2062337 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -254,8 +254,8 @@ module ActionView #:nodoc:
         if options[:layout]
           _render_with_layout(options, local_assigns, &block)
         elsif options[:file]
-          tempalte = self.view_paths.find_template(options[:file], template_format)
-          tempalte.render_template(self, options[:locals])
+          template = self.view_paths.find_template(options[:file], template_format)
+          template.render_template(self, options[:locals])
         elsif options[:partial]
           render_partial(options)
         elsif options[:inline]
diff --git a/actionpack/lib/action_view/reloadable_template.rb b/actionpack/lib/action_view/reloadable_template.rb
index 3081be60fd..5ef833d75c 100644
--- a/actionpack/lib/action_view/reloadable_template.rb
+++ b/actionpack/lib/action_view/reloadable_template.rb
@@ -27,49 +27,50 @@ module ActionView #:nodoc:
           end
         else
           load_all_templates_from_dir(templates_dir_from_path(path))
-          @paths[path]
+          # don't ever hand out a template without running a stale check
+          (new_template = @paths[path]) && new_template.reset_cache_if_stale!
         end
       end
 
-      def register_template_from_file(template_file_path)
-        if !@paths[template_relative_path = template_file_path.split("#{@path}/").last] && File.file?(template_file_path)
-          register_template(ReloadableTemplate.new(template_relative_path, self))
+      private
+        def register_template_from_file(template_full_file_path)
+          if !@paths[relative_path = relative_path_for_template_file(template_full_file_path)] && File.file?(template_full_file_path)
+            register_template(ReloadableTemplate.new(relative_path, self))
+          end
         end
-      end
 
-      def register_template(template)
-        template.accessible_paths.each do |path|
-          @paths[path] = template
+        def register_template(template)
+          template.accessible_paths.each do |path|
+            @paths[path] = template
+          end
         end
-      end
 
-      # remove (probably deleted) template from cache
-      def unregister_template(template)
-        template.accessible_paths.each do |template_path|
-          @paths.delete(template_path) if @paths[template_path] == template
-        end
-        # fill in any newly created gaps
-        @paths.values.uniq.each do |template|
-          template.accessible_paths.each {|path| @paths[path] ||= template}
+        # remove (probably deleted) template from cache
+        def unregister_template(template)
+          template.accessible_paths.each do |template_path|
+            @paths.delete(template_path) if @paths[template_path] == template
+          end
+          # fill in any newly created gaps
+          @paths.values.uniq.each do |template|
+            template.accessible_paths.each {|path| @paths[path] ||= template}
+          end
         end
-      end
-
-      # load all templates from the directory of the requested template
-      def load_all_templates_from_dir(dir)
-        # hit disk only once per template-dir/request
-        @disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
-      end
 
-      def templates_dir_from_path(path)
-        dirname = File.dirname(path)
-        File.join(@path, dirname == '.' ? '' : dirname)
-      end
+        # load all templates from the directory of the requested template
+        def load_all_templates_from_dir(dir)
+          # hit disk only once per template-dir/request
+          @disk_cache[dir] ||= template_files_from_dir(dir).each {|template_file| register_template_from_file(template_file)}
+        end
 
-      # get all the template filenames from the dir
-      def template_files_from_dir(dir)
-        Dir.glob(File.join(dir, '*'))
-      end
+        def templates_dir_from_path(path)
+          dirname = File.dirname(path)
+          File.join(@path, dirname == '.' ? '' : dirname)
+        end
 
+        # get all the template filenames from the dir
+        def template_files_from_dir(dir)
+          Dir.glob(File.join(dir, '*'))
+        end
     end
 
     module Unfreezable
@@ -78,7 +79,6 @@ module ActionView #:nodoc:
 
     def initialize(*args)
       super
-      @compiled_methods = []
       
       # we don't ever want to get frozen
       extend Unfreezable
@@ -106,14 +106,11 @@ module ActionView #:nodoc:
       self
     end
 
+    # remove any compiled methods that look like they might belong to me
     def undef_my_compiled_methods!
-      @compiled_methods.each {|comp_method| ActionView::Base::CompiledTemplates.send(:remove_method, comp_method)}
-      @compiled_methods.clear
-    end
-
-    def compile!(render_symbol, local_assigns)
-      super
-      @compiled_methods << render_symbol
+      ActionView::Base::CompiledTemplates.public_instance_methods.grep(/#{Regexp.escape(method_name_without_locals)}(?:_locals_)?/).each do |m|
+        ActionView::Base::CompiledTemplates.send(:remove_method, m)
+      end
     end
 
   end
diff --git a/actionpack/lib/action_view/template.rb b/actionpack/lib/action_view/template.rb
index b8e2165ddf..ea838b9b02 100644
--- a/actionpack/lib/action_view/template.rb
+++ b/actionpack/lib/action_view/template.rb
@@ -6,12 +6,7 @@ module ActionView #:nodoc:
 
       def initialize(path)
         raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
-        @path = expand_path(path).freeze
-      end
-
-      def expand_path(path)
-        # collapse any directory dots in path ('.' or '..')
-        path.starts_with?('/') ? File.expand_path(path) : File.expand_path(path, '/').from(1)
+        @path = (path.ends_with?(File::SEPARATOR) ? path.to(-2) : path).freeze
       end
 
       def to_s
@@ -45,22 +40,23 @@ module ActionView #:nodoc:
       # will never match +hello/index.html.erb+.
       def [](path)
       end
-      
+
       def load!
       end
-      
+
       def self.new_and_loaded(path)
         returning new(path) do |path|
           path.load!
         end
       end
+
+      private
+        def relative_path_for_template_file(full_file_path)
+          full_file_path.split("#{@path}/").last
+        end
     end
 
     class EagerPath < Path
-      def initialize(path)
-        super
-      end
-
       def load!
         return if @loaded
         
@@ -79,7 +75,7 @@ module ActionView #:nodoc:
         load! unless @loaded
         @paths[path]
       end
-      
+
       private
         def templates_in_path
           (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
@@ -88,7 +84,7 @@ module ActionView #:nodoc:
         end
 
         def create_template(file)
-          Template.new(file.split("#{self}/").last, self)
+          Template.new(relative_path_for_template_file(file), self)
         end
     end
 
diff --git a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb b/actionpack/test/activerecord/render_partial_with_record_identification_test.rb
index 147b270808..0a596c7ae0 100644
--- a/actionpack/test/activerecord/render_partial_with_record_identification_test.rb
+++ b/actionpack/test/activerecord/render_partial_with_record_identification_test.rb
@@ -53,7 +53,7 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
   def test_rendering_partial_with_has_many_and_belongs_to_association
     get :render_with_has_many_and_belongs_to_association
     assert_template 'projects/_project'
-    assert_equal 'Active RecordActive Controller', @response.body
+    assert_equal assigns(:developer).projects.map(&:name).join, @response.body
   end
 
   def test_rendering_partial_with_has_many_association
@@ -82,7 +82,7 @@ class RenderPartialWithRecordIdentificationTest < ActiveRecordTestCase
 
   def test_render_with_record_collection_and_spacer_template
     get :render_with_record_collection_and_spacer_template
-    assert_equal 'Active Recordonly partialActive Controller', @response.body
+    assert_equal assigns(:developer).projects.map(&:name).join('only partial'), @response.body
   end
 
   def test_rendering_partial_with_has_one_association
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index 47226f1fc5..7887b7110c 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -6,14 +6,17 @@ class DispatcherTest < Test::Unit::TestCase
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
+    Dispatcher.middleware = ActionController::MiddlewareStack.new do |middleware|
+      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/middlewares.rb"))
+      middleware.instance_eval(File.read(middlewares))
+    end
+
     # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
     Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
     Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
     Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
     Dispatcher.stubs(:require_dependency)
-
-    @dispatcher = Dispatcher.new
   end
 
   def teardown
@@ -65,7 +68,7 @@ class DispatcherTest < Test::Unit::TestCase
     assert_nil a || b || c
 
     # Run callbacks
-    @dispatcher.send :run_callbacks, :prepare_dispatch
+    Dispatcher.run_prepare_callbacks
 
     assert_equal 1, a
     assert_equal 2, b
@@ -82,7 +85,7 @@ class DispatcherTest < Test::Unit::TestCase
     Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
     Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
-    @dispatcher.send :run_callbacks, :prepare_dispatch
+    Dispatcher.run_prepare_callbacks
     assert_equal 2, a
     assert_equal nil, b
   end
@@ -91,7 +94,7 @@ class DispatcherTest < Test::Unit::TestCase
     def dispatch(cache_classes = true)
       ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
       Dispatcher.define_dispatcher_callbacks(cache_classes)
-      @dispatcher.call({})
+      Dispatcher.new.call({})
     end
 
     def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index 2f5e830fba..28555ee3d1 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -83,6 +83,13 @@ class HasOwnLayoutController < LayoutTest
   layout 'item'
 end
 
+class PrependsViewPathController < LayoutTest
+  def hello
+    prepend_view_path File.dirname(__FILE__) + '/../fixtures/layout_tests/alt/'
+    render :layout => 'alt'
+  end
+end
+
 class SetsLayoutInRenderController < LayoutTest
   def hello
     render :layout => 'third_party_template_library'
@@ -130,6 +137,12 @@ class LayoutSetInResponseTest < ActionController::TestCase
   ensure
     ActionController::Base.exempt_from_layout.delete(/\.rhtml$/)
   end
+  
+  def test_layout_is_picked_from_the_controller_instances_view_path
+    @controller = PrependsViewPathController.new
+    get :hello
+    assert_equal 'layouts/alt', @response.layout
+  end
 end
 
 class RenderWithTemplateOptionController < LayoutTest
@@ -178,3 +191,4 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
     end
   end
 end
+
diff --git a/actionpack/test/controller/middleware_stack_test.rb b/actionpack/test/controller/middleware_stack_test.rb
index 2a141697da..918231013a 100644
--- a/actionpack/test/controller/middleware_stack_test.rb
+++ b/actionpack/test/controller/middleware_stack_test.rb
@@ -73,4 +73,18 @@ class MiddlewareStackTest < ActiveSupport::TestCase
       end
     end
   end
+
+  test "lazy evaluates middleware class" do
+    assert_difference "@stack.size" do
+      @stack.use lambda { BazMiddleware }
+    end
+    assert_equal BazMiddleware, @stack.last.klass
+  end
+
+  test "lazy evaluates middleware arguments" do
+    assert_difference "@stack.size" do
+      @stack.use BazMiddleware, lambda { :foo }
+    end
+    assert_equal [:foo], @stack.last.send(:build_args)
+  end
 end
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index d6fc6fddb2..13ba0c30dd 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -340,6 +340,30 @@ class ControllerSegmentTest < Test::Unit::TestCase
   end
 end
 
+class PathSegmentTest < Test::Unit::TestCase
+  def segment(options = {})
+    unless @segment
+      @segment = ROUTING::PathSegment.new(:path, options)
+    end
+    @segment
+  end
+
+  def test_regexp_chunk_should_return_string
+    segment = segment(:regexp => /[a-z]+/)
+    assert_kind_of String, segment.regexp_chunk
+  end
+
+  def test_regexp_chunk_should_be_wrapped_with_parenthesis
+    segment = segment(:regexp => /[a-z]+/)
+    assert_equal "([a-z]+)", segment.regexp_chunk
+  end
+
+  def test_regexp_chunk_should_respect_options
+    segment = segment(:regexp => /[a-z]+/i)
+    assert_equal "((?i-mx:[a-z]+))", segment.regexp_chunk
+  end
+end
+
 class RouteBuilderTest < Test::Unit::TestCase
   def builder
     @builder ||= ROUTING::RouteBuilder.new
@@ -852,6 +876,15 @@ class LegacyRouteSetTests < Test::Unit::TestCase
     assert_equal '/content/foo', rs.generate(:controller => "content", :action => "foo")
   end
 
+  def test_route_with_regexp_and_captures_for_controller
+    rs.draw do |map|
+      map.connect ':controller/:action/:id', :controller => /admin\/(accounts|users)/
+    end
+    assert_equal({:controller => "admin/accounts", :action => "index"}, rs.recognize_path("/admin/accounts"))
+    assert_equal({:controller => "admin/users", :action => "index"}, rs.recognize_path("/admin/users"))
+    assert_raises(ActionController::RoutingError) { rs.recognize_path("/admin/products") }
+  end
+
   def test_route_with_regexp_and_dot
     rs.draw do |map|
       map.connect ':controller/:action/:file',
@@ -1134,6 +1167,7 @@ class LegacyRouteSetTests < Test::Unit::TestCase
     assert_equal({:controller => "content", :action => 'show_page', :id => 'foo'}, rs.recognize_path("/page/foo"))
 
     token = "\321\202\320\265\320\272\321\201\321\202" # 'text' in russian
+    token.force_encoding("UTF-8") if token.respond_to?(:force_encoding)
     escaped_token = CGI::escape(token)
 
     assert_equal '/page/' + escaped_token, rs.generate(:controller => 'content', :action => 'show_page', :id => token)
diff --git a/actionpack/test/controller/session/cookie_store_test.rb b/actionpack/test/controller/session/cookie_store_test.rb
index c94d7b0915..9c93ca6539 100644
--- a/actionpack/test/controller/session/cookie_store_test.rb
+++ b/actionpack/test/controller/session/cookie_store_test.rb
@@ -23,7 +23,7 @@ class CookieStoreTest < ActionController::IntegrationTest
 
     def set_session_value
       session[:foo] = "bar"
-      render :text => Verifier.generate(session.to_hash)
+      render :text => Rack::Utils.escape(Verifier.generate(session.to_hash))
     end
 
     def get_session_value
diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb
index 6468283270..8ea13fbe98 100644
--- a/actionpack/test/controller/view_paths_test.rb
+++ b/actionpack/test/controller/view_paths_test.rb
@@ -42,34 +42,30 @@ class ViewLoadPathsTest < ActionController::TestCase
     ActiveSupport::Deprecation.behavior = @old_behavior
   end
   
-  def assert_view_path_strings_are_equal(expected, actual)
-    assert_equal(expected.map {|path| path.sub(/\.\//, '')}, actual)
-  end
-
   def test_template_load_path_was_set_correctly
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_controller_appends_view_path_correctly
     @controller.append_view_path 'foo'
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(%w(bar baz))
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(FIXTURE_LOAD_PATH)
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_controller_prepends_view_path_correctly
     @controller.prepend_view_path 'baz'
-    assert_view_path_strings_are_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_view_path_strings_are_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(FIXTURE_LOAD_PATH)
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
   end
 
   def test_template_appends_view_path_correctly
@@ -77,10 +73,10 @@ class ViewLoadPathsTest < ActionController::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.append_view_path 'foo'
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
 
     @controller.append_view_path(%w(bar baz))
-    assert_view_path_strings_are_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
+    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
     assert_equal class_view_paths, TestController.view_paths
   end
 
@@ -89,10 +85,10 @@ class ViewLoadPathsTest < ActionController::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.prepend_view_path 'baz'
-    assert_view_path_strings_are_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_view_path_strings_are_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
     assert_equal class_view_paths, TestController.view_paths
   end
 
diff --git a/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml b/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml
new file mode 100644
index 0000000000..e69de29bb2
--- /dev/null
+++ b/actionpack/test/fixtures/layout_tests/alt/layouts/alt.rhtml
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
index a8f8455a54..7d1d7634a8 100644
--- a/actionpack/test/template/compiled_templates_test.rb
+++ b/actionpack/test/template/compiled_templates_test.rb
@@ -5,18 +5,6 @@ class CompiledTemplatesTest < Test::Unit::TestCase
   
   def setup
     @compiled_templates = ActionView::Base::CompiledTemplates
-
-    # first, if we are running the whole test suite with ReloadableTemplates
-    # try to undef all the methods through ReloadableTemplate's interfaces
-    unless ActionView::Base.cache_template_loading?
-      ActionController::Base.view_paths.each do |view_path|
-        view_path.paths.values.uniq!.each do |reloadable_template|
-          reloadable_template.undef_my_compiled_methods!
-        end
-      end
-    end
-
-    # just purge anything that's left
     @compiled_templates.instance_methods.each do |m|
       @compiled_templates.send(:remove_method, m) if m =~ /^_run_/
     end
@@ -65,38 +53,124 @@ class CompiledTemplatesTest < Test::Unit::TestCase
       with_reloading(true) do
         assert_equal "Hello world!", render(:file => "test/hello_world.erb")
         modify_template "test/hello_world.erb", "Goodbye world!" do
-          reset_mtime_of('test/hello_world.erb')
           assert_equal "Goodbye world!", render(:file => "test/hello_world.erb")
         end
-        reset_mtime_of('test/hello_world.erb')
         assert_equal "Hello world!", render(:file => "test/hello_world.erb")
       end
     end
   end
 
+  def test_template_becomes_missing_if_deleted_without_cached_template_loading
+    with_reloading(true) do
+      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
+      delete_template 'test/hello_world.erb' do
+        assert_raise(ActionView::MissingTemplate) { render(:file => 'test/hello_world.erb') }
+      end
+      assert_equal 'Hello world!', render(:file => 'test/hello_world.erb')
+    end
+  end
+
+  def test_swapping_template_handler_is_working_without_cached_template_loading
+    with_reloading(true) do
+      assert_equal 'Hello world!', render(:file => 'test/hello_world')
+      delete_template 'test/hello_world.erb' do
+        rename_template 'test/hello_world_from_rxml.builder', 'test/hello_world.builder' do
+          assert_equal "<html>\n  <p>Hello</p>\n</html>\n", render(:file => 'test/hello_world')
+        end
+      end
+      assert_equal 'Hello world!', render(:file => 'test/hello_world')
+    end
+  end
+
+  def test_adding_localized_template_will_take_precedence_without_cached_template_loading
+    with_reloading(true) do
+      assert_equal 'Hello world!', render(:file => 'test/hello_world')
+      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
+        assert_equal 'Hey verden', render(:file => 'test/hello_world')
+      end
+    end
+  end
+
+  def test_deleting_localized_template_will_fall_back_to_non_localized_template_without_cached_template_loading
+    with_reloading(true) do
+      rename_template 'test/hello_world.da.html.erb', 'test/hello_world.en.html.erb' do
+        assert_equal 'Hey verden', render(:file => 'test/hello_world')
+        delete_template 'test/hello_world.en.html.erb' do
+          assert_equal 'Hello world!', render(:file => 'test/hello_world')
+        end
+        assert_equal 'Hey verden', render(:file => 'test/hello_world')
+      end
+    end
+  end
+
+  def test_parallel_reloadable_view_paths_are_working
+    with_reloading(true) do
+      view_paths_copy = new_reloadable_view_paths
+      assert_equal 'Hello world!', render(:file => 'test/hello_world')
+      with_view_paths(view_paths_copy, new_reloadable_view_paths) do
+        assert_equal 'Hello world!', render(:file => 'test/hello_world')
+      end
+      modify_template 'test/hello_world.erb', 'Goodbye world!' do
+        assert_equal 'Goodbye world!', render(:file => 'test/hello_world')
+        modify_template 'test/hello_world.erb', 'So long, world!' do
+          with_view_paths(view_paths_copy, new_reloadable_view_paths) do
+            assert_equal 'So long, world!', render(:file => 'test/hello_world')
+          end
+          assert_equal 'So long, world!', render(:file => 'test/hello_world')
+        end
+      end
+    end
+  end
+
   private
     def render(*args)
-      view_paths = ActionController::Base.view_paths
+      view_paths = @explicit_view_paths || ActionController::Base.view_paths
       ActionView::Base.new(view_paths, {}).render(*args)
     end
 
-    def reset_mtime_of(template_name)
-      unless ActionView::Base.cache_template_loading?
-        ActionController::Base.view_paths.find_template(template_name).previously_last_modified = 10.seconds.ago 
+    def with_view_paths(*args)
+      args.each do |view_paths|
+        begin
+          @explicit_view_paths = view_paths
+          yield
+        ensure
+          @explicit_view_paths = nil
+        end
       end
     end
 
-    def modify_template(template, content)
-      filename = "#{FIXTURE_LOAD_PATH}/#{template}"
+    def reset_mtime_of(template_name, view_paths_to_use)
+      view_paths_to_use.find_template(template_name).previously_last_modified = 10.seconds.ago unless ActionView::Base.cache_template_loading?
+    end
+
+    def modify_template(template, content, view_paths_to_use = ActionController::Base.view_paths)
+      filename = filename_for(template)
       old_content = File.read(filename)
       begin
         File.open(filename, "wb+") { |f| f.write(content) }
+        reset_mtime_of(template, view_paths_to_use)
         yield
       ensure
         File.open(filename, "wb+") { |f| f.write(old_content) }
+        reset_mtime_of(template, view_paths_to_use)
       end
     end
 
+    def filename_for(template)
+      File.join(FIXTURE_LOAD_PATH, template)
+    end
+
+    def rename_template(old_name, new_name)
+      File.rename(filename_for(old_name), filename_for(new_name))
+      yield
+    ensure
+      File.rename(filename_for(new_name), filename_for(old_name))
+    end
+
+    def delete_template(template, &block)
+      rename_template(template, File.join(File.dirname(template), "__#{File.basename(template)}"), &block)
+    end
+
     def with_caching(perform_caching)
       old_perform_caching = ActionController::Base.perform_caching
       begin
@@ -107,19 +181,23 @@ class CompiledTemplatesTest < Test::Unit::TestCase
       end
     end
 
-    def with_reloading(reload_templates)
-      old_view_paths, old_cache_templates = ActionController::Base.view_paths, ActionView::Base.cache_template_loading
+    def with_reloading(reload_templates, view_paths_owner = ActionController::Base)
+      old_view_paths, old_cache_templates = view_paths_owner.view_paths, ActionView::Base.cache_template_loading
       begin
         ActionView::Base.cache_template_loading = !reload_templates
-        ActionController::Base.view_paths = view_paths_for(reload_templates)
+        view_paths_owner.view_paths = view_paths_for(reload_templates)
         yield
       ensure
-        ActionController::Base.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
+        view_paths_owner.view_paths, ActionView::Base.cache_template_loading = old_view_paths, old_cache_templates
       end
     end
 
+    def new_reloadable_view_paths
+      ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s))
+    end
+
     def view_paths_for(reload_templates)
       # reloadable paths are cheap to create
-      reload_templates ? ActionView::PathSet.new(CACHED_VIEW_PATHS.map(&:to_s)) : CACHED_VIEW_PATHS
+      reload_templates ? new_reloadable_view_paths : CACHED_VIEW_PATHS
     end
 end
diff --git a/activesupport/CHANGELOG b/activesupport/CHANGELOG
index b099233698..afffc9ab1a 100644
--- a/activesupport/CHANGELOG
+++ b/activesupport/CHANGELOG
@@ -1,5 +1,7 @@
 *Edge*
 
+* Ruby 1.9.1p0 fix: URI.unescape can decode multibyte chars.  #2033 [MOROHASHI Kyosuke]
+
 * Time#to_s(:rfc822) uses #formatted_offset instead of unreliable and non-standard %z directive #1899 [Zachary Zolton]
 
 * Make TimeWithZone#to_formatted_s an alias to TimeWithZone#to_s #1796 [Levin Alexander]
diff --git a/activesupport/lib/active_support/core_ext/array/conversions.rb b/activesupport/lib/active_support/core_ext/array/conversions.rb
index 69d35dafd3..a9b50ca92d 100644
--- a/activesupport/lib/active_support/core_ext/array/conversions.rb
+++ b/activesupport/lib/active_support/core_ext/array/conversions.rb
@@ -6,14 +6,28 @@ module ActiveSupport #:nodoc:
         # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
         # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
         # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
-        def to_sentence(options = {})          
-          options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
-          
+        def to_sentence(options = {})
+   
           default_words_connector = I18n.translate(:'support.array.words_connector', :locale => options[:locale])
           default_two_words_connector = I18n.translate(:'support.array.two_words_connector', :locale => options[:locale])
-          default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])
-          options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
+          default_last_word_connector = I18n.translate(:'support.array.last_word_connector', :locale => options[:locale])          
 
+          # Try to emulate to_senteces previous to 2.3
+          if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
+            ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
+            ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
+
+            skip_last_comma = options.delete :skip_last_comma
+            if connector = options.delete(:connector)
+              options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
+            else
+              options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
+            end
+          end
+          
+          options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)       
+          options.reverse_merge! :words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector
+          
           case length
             when 0
               ""
diff --git a/activesupport/lib/active_support/core_ext/file/atomic.rb b/activesupport/lib/active_support/core_ext/file/atomic.rb
index 976d462e8e..8cc5654a4b 100644
--- a/activesupport/lib/active_support/core_ext/file/atomic.rb
+++ b/activesupport/lib/active_support/core_ext/file/atomic.rb
@@ -27,7 +27,7 @@ module ActiveSupport #:nodoc:
             old_stat = stat(file_name)
           rescue Errno::ENOENT
             # No old permissions, write a temp file to determine the defaults
-            check_name = ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}"
+            check_name = join(dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
             open(check_name, "w") { }
             old_stat = stat(check_name)
             unlink(check_name)
diff --git a/activesupport/lib/active_support/core_ext/uri.rb b/activesupport/lib/active_support/core_ext/uri.rb
new file mode 100644
index 0000000000..9a1c61d99b
--- /dev/null
+++ b/activesupport/lib/active_support/core_ext/uri.rb
@@ -0,0 +1,16 @@
+if RUBY_VERSION >= '1.9'
+  require 'uri'
+
+  str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
+  str.force_encoding(Encoding::UTF_8) if str.respond_to?(:force_encoding)
+
+  unless str == URI.unescape(URI.escape(str))
+    URI::Parser.class_eval do
+      remove_method :unescape
+      def unescape(str, escaped = @regexp[:ESCAPED])
+        enc = (str.encoding == Encoding::US_ASCII) ? Encoding::UTF_8 : str.encoding
+        str.gsub(escaped) { [$&[1, 2].hex].pack('C') }.force_encoding(enc)
+      end
+    end
+  end
+end
diff --git a/activesupport/test/core_ext/array_ext_test.rb b/activesupport/test/core_ext/array_ext_test.rb
index 367f0e0027..b70ec475ad 100644
--- a/activesupport/test/core_ext/array_ext_test.rb
+++ b/activesupport/test/core_ext/array_ext_test.rb
@@ -48,6 +48,8 @@ class ArrayExtToParamTests < Test::Unit::TestCase
 end
 
 class ArrayExtToSentenceTests < Test::Unit::TestCase
+  include ActiveSupport::Testing::Deprecation
+  
   def test_plain_array_to_sentence
     assert_equal "", [].to_sentence
     assert_equal "one", ['one'].to_sentence
@@ -56,12 +58,28 @@ class ArrayExtToSentenceTests < Test::Unit::TestCase
   end
 
   def test_to_sentence_with_words_connector
+    assert_deprecated(":connector has been deprecated. Use :words_connector instead") do
+      assert_equal "one, two, three", ['one', 'two', 'three'].to_sentence(:connector => '')
+    end
+    
+    assert_deprecated(":connector has been deprecated. Use :words_connector instead") do
+      assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence(:connector => 'and ')
+    end
+    
     assert_equal "one two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' ')
     assert_equal "one & two, and three", ['one', 'two', 'three'].to_sentence(:words_connector => ' & ')
     assert_equal "onetwo, and three", ['one', 'two', 'three'].to_sentence(:words_connector => nil)
   end
 
   def test_to_sentence_with_last_word_connector
+    assert_deprecated(":skip_last_comma has been deprecated. Use :last_word_connector instead") do
+      assert_equal "one, two and three", ['one', 'two', 'three'].to_sentence(:skip_last_comma => true)
+    end
+    
+    assert_deprecated(":skip_last_comma has been deprecated. Use :last_word_connector instead") do
+      assert_equal "one, two, and three", ['one', 'two', 'three'].to_sentence(:skip_last_comma => false)
+    end
+    
     assert_equal "one, two, and also three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ', and also ')
     assert_equal "one, twothree", ['one', 'two', 'three'].to_sentence(:last_word_connector => nil)
     assert_equal "one, two three", ['one', 'two', 'three'].to_sentence(:last_word_connector => ' ')
diff --git a/activesupport/test/core_ext/uri_ext_test.rb b/activesupport/test/core_ext/uri_ext_test.rb
new file mode 100644
index 0000000000..0837d3cb2d
--- /dev/null
+++ b/activesupport/test/core_ext/uri_ext_test.rb
@@ -0,0 +1,12 @@
+require 'abstract_unit'
+require 'uri'
+
+class URIExtTest < Test::Unit::TestCase
+  def test_uri_decode_handle_multibyte
+    str = "\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E" # Ni-ho-nn-go in UTF-8, means Japanese.
+    str.force_encoding(Encoding::UTF_8) if str.respond_to?(:force_encoding)
+
+    assert_equal str, URI.unescape(URI.escape(str))
+    assert_equal str, URI.decode(URI.escape(str))
+  end
+end
diff --git a/railties/lib/console_app.rb b/railties/lib/console_app.rb
index a35c96c957..d7cd57564f 100644
--- a/railties/lib/console_app.rb
+++ b/railties/lib/console_app.rb
@@ -24,7 +24,6 @@ end
 #reloads the environment
 def reload!
   puts "Reloading..."
-  dispatcher = ActionController::Dispatcher.new($stdout)
-  dispatcher.reload_application
+  Dispatcher.reload_application
   true
 end
diff --git a/railties/lib/initializer.rb b/railties/lib/initializer.rb
index a8b951ae58..a31ae9422e 100644
--- a/railties/lib/initializer.rb
+++ b/railties/lib/initializer.rb
@@ -167,6 +167,10 @@ module Rails
       load_gems
       check_gem_dependencies
 
+      # bail out if gems are missing - note that check_gem_dependencies will have
+      # already called abort() unless $gems_rake_task is set
+      return unless gems_dependencies_loaded
+
       load_application_initializers
 
       # the framework is now fully initialized
@@ -302,7 +306,7 @@ module Rails
       if unloaded_gems.size > 0
         @gems_dependencies_loaded = false
         # don't print if the gems rake tasks are being run
-        unless $rails_rake_task
+        unless $gems_rake_task
           abort <<-end_error
 Missing these required gems:
   #{unloaded_gems.map { |gem| "#{gem.name}  #{gem.requirement}" } * "\n  "}
@@ -479,8 +483,8 @@ Run `rake gems:install` to install the missing gems.
     def initialize_framework_views
       if configuration.frameworks.include?(:action_view)
         view_path = ActionView::PathSet.type_cast(configuration.view_path)
-        ActionMailer::Base.template_root ||= view_path if configuration.frameworks.include?(:action_mailer)
-        ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.empty?
+        ActionMailer::Base.template_root  = view_path if configuration.frameworks.include?(:action_mailer) && ActionMailer::Base.view_paths.blank?
+        ActionController::Base.view_paths = view_path if configuration.frameworks.include?(:action_controller) && ActionController::Base.view_paths.blank?
       end
     end
 
@@ -492,7 +496,7 @@ Run `rake gems:install` to install the missing gems.
 
       ActionController::Routing.controller_paths += configuration.controller_paths
       ActionController::Routing::Routes.add_configuration_file(configuration.routes_configuration_file)
-      ActionController::Routing::Routes.reload
+      ActionController::Routing::Routes.reload!
     end
 
     # Sets the dependency loading mechanism based on the value of
@@ -583,7 +587,7 @@ Run `rake gems:install` to install the missing gems.
       return unless configuration.frameworks.include?(:action_controller)
       require 'dispatcher' unless defined?(::Dispatcher)
       Dispatcher.define_dispatcher_callbacks(configuration.cache_classes)
-      Dispatcher.new(Rails.logger).send :run_callbacks, :prepare_dispatch
+      Dispatcher.run_prepare_callbacks
     end
 
     def disable_dependency_loading
diff --git a/railties/lib/rails/plugin/loader.rb b/railties/lib/rails/plugin/loader.rb
index bc0184c43d..7f85bb8966 100644
--- a/railties/lib/rails/plugin/loader.rb
+++ b/railties/lib/rails/plugin/loader.rb
@@ -16,7 +16,7 @@ module Rails
       def initialize(initializer)
         @initializer = initializer
       end
-      
+
       # Returns the plugins to be loaded, in the order they should be loaded.
       def plugins
         @plugins ||= all_plugins.select { |plugin| should_load?(plugin) }.sort { |p1, p2| order_plugins(p1, p2) }
@@ -32,9 +32,9 @@ module Rails
         @all_plugins ||= locate_plugins
         @all_plugins
       end
-    
+
       def load_plugins
-        plugins.each do |plugin| 
+        plugins.each do |plugin|
           plugin.load(initializer)
           register_plugin_as_loaded(plugin)
         end
@@ -43,12 +43,12 @@ module Rails
 
         ensure_all_registered_plugins_are_loaded!
       end
-      
+
       # Adds the load paths for every plugin into the $LOAD_PATH. Plugin load paths are
       # added *after* the application's <tt>lib</tt> directory, to ensure that an application
       # can always override code within a plugin.
       #
-      # Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.  
+      # Plugin load paths are also added to Dependencies.load_paths, and Dependencies.load_once_paths.
       def add_plugin_load_paths
         plugins.each do |plugin|
           plugin.load_paths.each do |path|
@@ -56,7 +56,7 @@ module Rails
 
             ActiveSupport::Dependencies.load_paths << path
 
-            unless Rails.configuration.reload_plugins?
+            unless configuration.reload_plugins?
               ActiveSupport::Dependencies.load_once_paths << path
             end
           end
@@ -64,8 +64,8 @@ module Rails
 
         $LOAD_PATH.uniq!
       end
-      
-      
+
+
       protected
         def configure_engines
           if engines.any?
@@ -74,20 +74,22 @@ module Rails
             add_engine_view_paths
           end
         end
-      
+
         def add_engine_routing_configurations
           engines.select(&:routed?).collect(&:routing_file).each do |routing_file|
             ActionController::Routing::Routes.add_configuration_file(routing_file)
           end
         end
-        
+
         def add_engine_controller_paths
           ActionController::Routing.controller_paths += engines.collect(&:controller_path)
         end
-        
+
         def add_engine_view_paths
           # reverse it such that the last engine can overwrite view paths from the first, like with routes
-          ActionController::Base.view_paths += ActionView::PathSet.new(engines.collect(&:view_path).reverse)
+          paths = ActionView::PathSet.new(engines.collect(&:view_path).reverse)
+          ActionController::Base.view_paths.concat(paths)
+          ActionMailer::Base.view_paths.concat(paths) if configuration.frameworks.include?(:action_mailer)
         end
 
         # The locate_plugins method uses each class in config.plugin_locators to
@@ -106,7 +108,7 @@ module Rails
         def configuration
           initializer.configuration
         end
-        
+
         def should_load?(plugin)
           # uses Plugin#name and Plugin#valid?
           enabled?(plugin) && plugin.valid?
@@ -120,21 +122,21 @@ module Rails
               plugin_a <=> plugin_b
             else
               effective_order_of(plugin_a) <=> effective_order_of(plugin_b)
-            end            
+            end
           end
         end
-        
+
         def effective_order_of(plugin)
           if explicitly_enabled?(plugin)
-            registered_plugin_names.index(plugin.name) 
+            registered_plugin_names.index(plugin.name)
           else
             registered_plugin_names.index('all')
-          end        
+          end
         end
 
         def application_lib_index
           $LOAD_PATH.index(File.join(RAILS_ROOT, 'lib')) || 0
-        end      
+        end
 
         def enabled?(plugin)
           !explicit_plugin_loading_order? || registered?(plugin)
@@ -155,23 +157,23 @@ module Rails
         def explicitly_registered?(plugin)
           explicit_plugin_loading_order? && registered_plugin_names.include?(plugin.name)
         end
-      
+
         def registered_plugins_names_plugin?(plugin)
           registered_plugin_names.include?(plugin.name) || registered_plugin_names.include?('all')
         end
-        
+
         # The plugins that have been explicitly listed with config.plugins. If this list is nil
-        # then it means the client does not care which plugins or in what order they are loaded, 
+        # then it means the client does not care which plugins or in what order they are loaded,
         # so we load all in alphabetical order. If it is an empty array, we load no plugins, if it is
         # non empty, we load the named plugins in the order specified.
         def registered_plugin_names
           configuration.plugins ? configuration.plugins.map(&:to_s) : nil
         end
-        
+
         def loaded?(plugin_name)
           initializer.loaded_plugins.detect { |plugin| plugin.name == plugin_name.to_s }
         end
-        
+
         def ensure_all_registered_plugins_are_loaded!
           if explicit_plugin_loading_order?
             if configuration.plugins.detect {|plugin| plugin != :all && !loaded?(plugin) }
@@ -180,7 +182,7 @@ module Rails
             end
           end
         end
-  
+
     end
   end
 end
\ No newline at end of file
diff --git a/railties/lib/tasks/gems.rake b/railties/lib/tasks/gems.rake
index e6731ab78c..d538e52ca6 100644
--- a/railties/lib/tasks/gems.rake
+++ b/railties/lib/tasks/gems.rake
@@ -17,13 +17,13 @@ end
 
 namespace :gems do
   task :base do
-    $rails_rake_task = true
+    $gems_rake_task = true
     Rake::Task[:environment].invoke
   end
 
   desc "Build any native extensions for unpacked gems"
   task :build do
-    $rails_rake_task = true
+    $gems_rake_task = true
     require 'rails/gem_builder'
     Dir[File.join(Rails::GemDependency.unpacked_path, '*')].each do |gem_dir|
       spec_file = File.join(gem_dir, '.specification')
diff --git a/railties/test/initializer_test.rb b/railties/test/initializer_test.rb
index 2ab4101eaf..eb9ec750da 100644
--- a/railties/test/initializer_test.rb
+++ b/railties/test/initializer_test.rb
@@ -182,6 +182,7 @@ require File.dirname(__FILE__) + '/plugin_test_helper'
 class InitializerPluginLoadingTests < Test::Unit::TestCase
   def setup
     @configuration     = Rails::Configuration.new
+    @configuration.frameworks -= [:action_mailer]
     @configuration.plugin_paths << plugin_fixture_root_path
     @initializer       = Rails::Initializer.new(@configuration)
     @valid_plugin_path = plugin_fixture_path('default/stubby')
@@ -310,8 +311,8 @@ class InitializerSetupI18nTests < Test::Unit::TestCase
 
     Rails::Initializer.run(:initialize_i18n, config)
     assert_equal [ 
-     File.expand_path("./test/../../activesupport/lib/active_support/locale/en.yml"),
-     File.expand_path("./test/../../actionpack/lib/action_view/locale/en.yml"),
+     File.expand_path(File.dirname(__FILE__) + "/../../activesupport/lib/active_support/locale/en.yml"),
+     File.expand_path(File.dirname(__FILE__) + "/../../actionpack/lib/action_view/locale/en.yml"),
      "my/test/locale.yml",
      "my/other/locale.yml" ], I18n.load_path.collect { |path| path =~ /^\./ ? File.expand_path(path) : path }
   end
diff --git a/railties/test/plugin_loader_test.rb b/railties/test/plugin_loader_test.rb
index 59491fe99e..e802b1ace7 100644
--- a/railties/test/plugin_loader_test.rb
+++ b/railties/test/plugin_loader_test.rb
@@ -1,7 +1,9 @@
 require 'plugin_test_helper'
 
 $:.unshift File.dirname(__FILE__) + "/../../actionpack/lib"
+$:.unshift File.dirname(__FILE__) + "/../../actionmailer/lib"
 require 'action_controller'
+require 'action_mailer'
 
 # Mocks out the configuration
 module Rails
@@ -125,14 +127,15 @@ class TestPluginLoader < Test::Unit::TestCase
     end
   end
   
-  def test_engine_controllers_should_have_their_view_path_set_when_loaded
+  def test_engine_controllers_and_action_mailers_should_have_their_view_path_set_when_loaded
     only_load_the_following_plugins!([ :engine ])
 
     @loader.send :add_engine_view_paths
     
-    assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views').sub(/\A\.\//, '') ], ActionController::Base.view_paths
+    assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionController::Base.view_paths
+    assert_equal [ File.join(plugin_fixture_path('engines/engine'), 'app', 'views') ], ActionMailer::Base.view_paths
   end
-
+  
   def test_should_add_plugin_load_paths_to_Dependencies_load_once_paths
     only_load_the_following_plugins! [:stubby, :acts_as_chunky_bacon]