Merge branch 'master' of git@github.com:rails/rails

56 files changed, 583 insertions, 300 deletions

diff --git a/actionpack/CHANGELOG b/actionpack/CHANGELOG
index 204f5ae272..c1dc6f2ab4 100644
--- a/actionpack/CHANGELOG
+++ b/actionpack/CHANGELOG
@@ -1,5 +1,7 @@
 *Edge*
 
+* Instead of checking Rails.env.test? in Failsafe middleware, check env["rails.raise_exceptions"] [Bryan Helmkamp]
+
 * Fixed that TestResponse.cookies was returning cookies unescaped #1867 [Doug McInnes]
 
 
diff --git a/actionpack/Rakefile b/actionpack/Rakefile
index 6ce8179646..41b190130e 100644
--- a/actionpack/Rakefile
+++ b/actionpack/Rakefile
@@ -22,7 +22,7 @@ task :default => [ :test ]
 # Run the unit tests
 
 desc "Run all unit tests"
-task :test => [:test_action_pack, :test_active_record_integration, :test_new_base]
+task :test => [:test_action_pack, :test_active_record_integration]
 
 Rake::TestTask.new(:test_action_pack) do |t|
   t.libs << "test"
diff --git a/actionpack/lib/action_controller/abstract.rb b/actionpack/lib/action_controller/abstract.rb
index 3f5c4a185f..48e33282ec 100644
--- a/actionpack/lib/action_controller/abstract.rb
+++ b/actionpack/lib/action_controller/abstract.rb
@@ -1,3 +1,6 @@
+require "active_support/core_ext/module/attr_internal"
+require "active_support/core_ext/module/delegation"
+
 module AbstractController
   autoload :Base,           "action_controller/abstract/base"
   autoload :Callbacks,      "action_controller/abstract/callbacks"
diff --git a/actionpack/lib/action_controller/abstract/base.rb b/actionpack/lib/action_controller/abstract/base.rb
index 4b8d953643..1f2f096dae 100644
--- a/actionpack/lib/action_controller/abstract/base.rb
+++ b/actionpack/lib/action_controller/abstract/base.rb
@@ -25,6 +25,15 @@ module AbstractController
       end
       
       alias_method :abstract?, :abstract
+
+      def inherited(klass)
+        ::AbstractController::Base.subclasses << klass.to_s
+        super
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
       
       def internal_methods
         controller = self
@@ -60,12 +69,13 @@ module AbstractController
     end
     
     def process(action_name)
-      unless respond_to_action?(action_name)
+      @_action_name = action_name = action_name.to_s
+
+      unless action_name = method_for_action(action_name)
         raise ActionNotFound, "The action '#{action_name}' could not be found"
       end
-      
-      @_action_name = action_name
-      process_action
+
+      process_action(action_name)
       self
     end
     
@@ -75,23 +85,31 @@ module AbstractController
       self.class.action_methods
     end
   
+    def action_method?(action)
+      action_methods.include?(action)
+    end
+  
     # It is possible for respond_to?(action_name) to be false and
     # respond_to?(:action_missing) to be false if respond_to_action?
     # is overridden in a subclass. For instance, ActionController::Base
     # overrides it to include the case where a template matching the
     # action_name is found.
-    def process_action
-      if respond_to?(action_name) then send(action_name)
-      elsif respond_to?(:action_missing, true) then action_missing(action_name)
-      end
+    def process_action(method_name)
+      send(method_name)
     end
-    
+
+    def _handle_action_missing
+      action_missing(@_action_name)
+    end
+
     # Override this to change the conditions that will raise an
     # ActionNotFound error. If you accept a difference case,
     # you must handle it by also overriding process_action and
     # handling the case.
-    def respond_to_action?(action_name)
-      action_methods.include?(action_name.to_s) || respond_to?(:action_missing, true)
+    def method_for_action(action_name)
+      if action_method?(action_name) then action_name
+      elsif respond_to?(:action_missing, true) then "_handle_action_missing"
+      end
     end
   end
-end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/abstract/callbacks.rb b/actionpack/lib/action_controller/abstract/callbacks.rb
index 3aff83a209..51b968c694 100644
--- a/actionpack/lib/action_controller/abstract/callbacks.rb
+++ b/actionpack/lib/action_controller/abstract/callbacks.rb
@@ -8,8 +8,8 @@ module AbstractController
       define_callbacks :process_action, "response_body"
     end
 
-    def process_action
-      _run_process_action_callbacks(action_name) do
+    def process_action(method_name)
+      _run_process_action_callbacks(method_name) do
         super
       end
     end
diff --git a/actionpack/lib/action_controller/abstract/logger.rb b/actionpack/lib/action_controller/abstract/logger.rb
index b154be754b..750a5c9fb6 100644
--- a/actionpack/lib/action_controller/abstract/logger.rb
+++ b/actionpack/lib/action_controller/abstract/logger.rb
@@ -4,8 +4,41 @@ module AbstractController
   module Logger
     extend ActiveSupport::DependencyModule
 
+    class DelayedLog
+      def initialize(&blk)
+        @blk = blk
+      end
+      
+      def to_s
+        @blk.call
+      end
+      alias to_str to_s
+    end
+
     included do
       cattr_accessor :logger
     end
+    
+    def process(action)
+      ret = super
+      
+      if logger
+        log = DelayedLog.new do
+          "\n\nProcessing #{self.class.name}\##{action_name} " \
+          "to #{request.formats} " \
+          "(for #{request_origin}) [#{request.method.to_s.upcase}]"
+        end
+
+        logger.info(log)
+      end
+      
+      ret
+    end
+    
+    def request_origin
+      # this *needs* to be cached!
+      # otherwise you'd get different results if calling it more than once
+      @request_origin ||= "#{request.remote_ip} at #{Time.now.to_s(:db)}"
+    end    
   end
 end
diff --git a/actionpack/lib/action_controller/base/base.rb b/actionpack/lib/action_controller/base/base.rb
index 2813e71d12..c59068c628 100644
--- a/actionpack/lib/action_controller/base/base.rb
+++ b/actionpack/lib/action_controller/base/base.rb
@@ -368,9 +368,8 @@ module ActionController #:nodoc:
     attr_reader :template
 
     def action(name, env)
-      # HACK: For global rescue to have access to the original request and response
-      request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
-      response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
+      request  = ActionDispatch::Request.new(env)
+      response = ActionDispatch::Response.new
       self.action_name = name && name.to_s
       process(request, response).to_a
     end
diff --git a/actionpack/lib/action_controller/base/chained/filters.rb b/actionpack/lib/action_controller/base/chained/filters.rb
index 9022b8b279..e121c0129d 100644
--- a/actionpack/lib/action_controller/base/chained/filters.rb
+++ b/actionpack/lib/action_controller/base/chained/filters.rb
@@ -160,7 +160,7 @@ module ActionController #:nodoc:
         def convert_only_and_except_options_to_sets_of_strings(opts)
           [:only, :except].each do |key|
             if values = opts[key]
-              opts[key] = Array(values).map(&:to_s).to_set
+              opts[key] = Array(values).map {|val| val.to_s }.to_set
             end
           end
         end
@@ -571,12 +571,7 @@ module ActionController #:nodoc:
 
       # Returns an array of Filter objects for this controller.
       def filter_chain
-        if chain = read_inheritable_attribute('filter_chain')
-          return chain
-        else
-          write_inheritable_attribute('filter_chain', FilterChain.new)
-          return filter_chain
-        end
+        read_inheritable_attribute('filter_chain') || write_inheritable_attribute('filter_chain', FilterChain.new)
       end
 
       # Returns all the before filters for this class and all its ancestors.
diff --git a/actionpack/lib/action_controller/base/http_authentication.rb b/actionpack/lib/action_controller/base/http_authentication.rb
index fa8ecea408..2893290efb 100644
--- a/actionpack/lib/action_controller/base/http_authentication.rb
+++ b/actionpack/lib/action_controller/base/http_authentication.rb
@@ -194,9 +194,10 @@ module ActionController
 
         if valid_nonce && realm == credentials[:realm] && opaque == credentials[:opaque]
           password = password_procedure.call(credentials[:username])
+          method = request.env['rack.methodoverride.original_method'] || request.env['REQUEST_METHOD']
 
          [true, false].any? do |password_is_ha1|
-           expected = expected_response(request.env['REQUEST_METHOD'], request.env['REQUEST_URI'], credentials, password, password_is_ha1)
+           expected = expected_response(method, request.env['REQUEST_URI'], credentials, password, password_is_ha1)
            expected == credentials[:response]
          end
         end
diff --git a/actionpack/lib/action_controller/dispatch/dispatcher.rb b/actionpack/lib/action_controller/dispatch/dispatcher.rb
index 63866caed9..9ad1cadfd3 100644
--- a/actionpack/lib/action_controller/dispatch/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatch/dispatcher.rb
@@ -1,87 +1,65 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActionController
   # Dispatches requests to the appropriate controller and takes care of
   # reloading the app after each request when Dependencies.load? is true.
   class Dispatcher
+    cattr_accessor :prepare_each_request
+    self.prepare_each_request = false
+
+    cattr_accessor :router
+    self.router = Routing::Routes
+
+    cattr_accessor :middleware
+    self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+      middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
+      middleware.instance_eval(File.read(middlewares), middlewares, 1)
+    end
+
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
+          # Run prepare callbacks before every request in development mode
+          self.prepare_each_request = true
+
           # Development mode callbacks
-          before_dispatch :reload_application
-          after_dispatch :cleanup_application
+          ActionDispatch::Callbacks.before_dispatch do |app|
+            ActionController::Dispatcher.router.reload
+          end
+
+          ActionDispatch::Callbacks.after_dispatch do
+            # 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
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
 
         if defined?(ActiveRecord)
-          to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
+          to_prepare(:activerecord_instantiate_observers) do
+            ActiveRecord::Base.instantiate_observers
+          end
         end
 
-        after_dispatch :flush_logger if Base.logger && Base.logger.respond_to?(:flush)
+        if Base.logger && Base.logger.respond_to?(:flush)
+          after_dispatch do
+            Base.logger.flush
+          end
+        end
 
         to_prepare do
           I18n.reload!
         end
       end
 
-      # Add a preparation callback. Preparation callbacks are run before every
-      # request in development mode, and before the first request in production
-      # mode.
-      #
-      # An optional identifier may be supplied for the callback. If provided,
-      # to_prepare may be called again with the same identifier to replace the
-      # existing callback. Passing an identifier is a suggested practice if the
-      # code adding a preparation block may be reloaded.
-      def to_prepare(identifier = nil, &block)
-        @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
-        callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
-        @prepare_dispatch_callbacks.replace_or_append!(callback)
-      end
+      delegate :to_prepare, :prepare_dispatch, :before_dispatch, :after_dispatch,
+        :to => ActionDispatch::Callbacks
 
-      def run_prepare_callbacks
-        new.send :run_callbacks, :prepare_dispatch
+      def new
+        @@middleware.build(@@router)
       end
     end
-
-    cattr_accessor :router
-    self.router = Routing::Routes
-
-    cattr_accessor :middleware
-    self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
-      middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
-      middleware.instance_eval(File.read(middlewares), middlewares, 1)
-    end
-
-    include ActiveSupport::Callbacks
-    define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
-
-    def initialize
-      @app = @@middleware.build(@@router)
-      freeze
-    end
-
-    def call(env)
-      run_callbacks :before_dispatch
-      @app.call(env)
-    ensure
-      run_callbacks :after_dispatch, :enumerator => :reverse_each
-    end
-
-    def reload_application
-      # Run prepare callbacks before every request in development mode
-      run_callbacks :prepare_dispatch
-
-      @@router.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
-
-    def flush_logger
-      Base.logger.flush
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/dispatch/middlewares.rb b/actionpack/lib/action_controller/dispatch/middlewares.rb
index f99637b109..b25ed3fd3f 100644
--- a/actionpack/lib/action_controller/dispatch/middlewares.rb
+++ b/actionpack/lib/action_controller/dispatch/middlewares.rb
@@ -2,10 +2,11 @@ use "Rack::Lock", :if => lambda {
   !ActionController::Base.allow_concurrency
 }
 
-use "ActionDispatch::Failsafe"
 use "ActionDispatch::ShowExceptions", lambda { ActionController::Base.consider_all_requests_local }
+use "ActionDispatch::Callbacks", lambda { ActionController::Dispatcher.prepare_each_request }
 use "ActionDispatch::Rescue", lambda {
   controller = (::ApplicationController rescue ActionController::Base)
+  # TODO: Replace with controller.action(:_rescue_action)
   controller.method(:rescue_action)
 }
 
diff --git a/actionpack/lib/action_controller/new_base.rb b/actionpack/lib/action_controller/new_base.rb
index 1f215bb6f1..bc47713529 100644
--- a/actionpack/lib/action_controller/new_base.rb
+++ b/actionpack/lib/action_controller/new_base.rb
@@ -7,6 +7,7 @@ module ActionController
   autoload :Rails2Compatibility,  "action_controller/new_base/compatibility"
   autoload :Redirector,           "action_controller/new_base/redirector"
   autoload :Renderer,             "action_controller/new_base/renderer"
+  autoload :Rescue,               "action_controller/new_base/rescuable"
   autoload :Testing,              "action_controller/new_base/testing"
   autoload :UrlFor,               "action_controller/new_base/url_for"
   
diff --git a/actionpack/lib/action_controller/new_base/base.rb b/actionpack/lib/action_controller/new_base/base.rb
index 1adcc9c71f..c25ffd5c84 100644
--- a/actionpack/lib/action_controller/new_base/base.rb
+++ b/actionpack/lib/action_controller/new_base/base.rb
@@ -12,14 +12,40 @@ module ActionController
     include ActionController::Renderer
     include ActionController::Layouts
     include ActionController::ConditionalGet
-    
+
     # Legacy modules
     include SessionManagement
     include ActionDispatch::StatusCodes
-    
+
     # Rails 2.x compatibility
     include ActionController::Rails2Compatibility
-    
+
+    # TODO: Extract into its own module
+    # This should be moved together with other normalizing behavior
+    module ImplicitRender
+      def process_action(method_name)
+        ret = super
+        render if response_body.nil?
+        ret
+      end
+
+      def _implicit_render
+        render
+      end
+
+      def method_for_action(action_name)
+        super || begin
+          if view_paths.find_by_parts?(action_name.to_s, {:formats => formats, :locales => [I18n.locale]}, controller_path)
+            "_implicit_render"
+          end
+        end
+      end
+    end
+
+    include ImplicitRender
+
+    include ActionController::Rescue
+
     def self.inherited(klass)
       ::ActionController::Base.subclasses << klass.to_s
       super
@@ -113,15 +139,5 @@ module ActionController
       
       super(url, status)
     end
-    
-    def process_action
-      ret = super
-      render if response_body.nil?
-      ret
-    end
-    
-    def respond_to_action?(action_name)
-      super || view_paths.find_by_parts?(action_name.to_s, {:formats => formats, :locales => [I18n.locale]}, controller_path)
-    end
   end
 end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base/compatibility.rb b/actionpack/lib/action_controller/new_base/compatibility.rb
index d17f498b60..0a283887b6 100644
--- a/actionpack/lib/action_controller/new_base/compatibility.rb
+++ b/actionpack/lib/action_controller/new_base/compatibility.rb
@@ -42,6 +42,17 @@ module ActionController
       # Controls the resource action separator
       cattr_accessor :resource_action_separator
       self.resource_action_separator = "/"
+      
+      cattr_accessor :use_accept_header
+      self.use_accept_header = true
+
+      cattr_accessor :page_cache_directory
+      self.page_cache_directory = defined?(Rails.public_path) ? Rails.public_path : ""
+
+      cattr_reader :cache_store
+
+      cattr_accessor :consider_all_requests_local
+      self.consider_all_requests_local = true
     end
     
     module ClassMethods
@@ -50,6 +61,11 @@ module ActionController
       def rescue_action(env)
         raise env["action_dispatch.rescue.exception"]
       end
+
+      # Defines the storage option for cached fragments
+      def cache_store=(store_option)
+        @@cache_store = ActiveSupport::Cache.lookup_store(store_option)
+      end
     end
     
     def initialize(*)
@@ -66,6 +82,14 @@ module ActionController
 
       super
     end
+
+    def _handle_method_missing
+      method_missing(@_action_name.to_sym)
+    end
+
+    def method_for_action(action_name)
+      super || (respond_to?(:method_missing) && "_handle_method_missing")
+    end    
       
     def _layout_for_name(name)
       name &&= name.sub(%r{^/?layouts/}, '')
diff --git a/actionpack/lib/action_controller/new_base/hide_actions.rb b/actionpack/lib/action_controller/new_base/hide_actions.rb
index d1857a9169..a29b09a893 100644
--- a/actionpack/lib/action_controller/new_base/hide_actions.rb
+++ b/actionpack/lib/action_controller/new_base/hide_actions.rb
@@ -12,8 +12,8 @@ module ActionController
       
   private
   
-    def respond_to_action?(action_name)
-      !hidden_actions.include?(action_name) && (super || respond_to?(:method_missing))
+    def action_method?(action_name)
+      !hidden_actions.include?(action_name) && super
     end
     
     module ClassMethods
diff --git a/actionpack/lib/action_controller/new_base/http.rb b/actionpack/lib/action_controller/new_base/http.rb
index 6852eb200a..8891a2a8c3 100644
--- a/actionpack/lib/action_controller/new_base/http.rb
+++ b/actionpack/lib/action_controller/new_base/http.rb
@@ -24,11 +24,6 @@ module ActionController
     # :api: public    
     def controller_path() self.class.controller_path end
     
-    # :api: private
-    def self.internal_methods
-      ActionController::Http.public_instance_methods(true)
-    end
-    
     # :api: private    
     def self.action_names() action_methods end
     
@@ -53,8 +48,6 @@ module ActionController
       @_response = ActionDispatch::Response.new
       @_response.request = request
       process(name)
-      @_response.body = response_body
-      @_response.prepare!
       to_rack
     end
     
@@ -67,6 +60,8 @@ module ActionController
     
     # :api: private
     def to_rack
+      @_response.body = response_body
+      @_response.prepare!
       @_response.to_a
     end
   end
diff --git a/actionpack/lib/action_controller/new_base/rescuable.rb b/actionpack/lib/action_controller/new_base/rescuable.rb
new file mode 100644
index 0000000000..29ffe19d5f
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/rescuable.rb
@@ -0,0 +1,53 @@
+module ActionController #:nodoc:
+  # Actions that fail to perform as expected throw exceptions. These
+  # exceptions can either be rescued for the public view (with a nice
+  # user-friendly explanation) or for the developers view (with tons of
+  # debugging information). The developers view is already implemented by
+  # the Action Controller, but the public view should be tailored to your
+  # specific application.
+  #
+  # The default behavior for public exceptions is to render a static html
+  # file with the name of the error code thrown.  If no such file exists, an
+  # empty response is sent with the correct status code.
+  #
+  # You can override what constitutes a local request by overriding the
+  # <tt>local_request?</tt> method in your own controller. Custom rescue
+  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
+  # and <tt>rescue_action_locally</tt> methods.
+  module Rescue
+    extend ActiveSupport::DependencyModule
+
+    included do
+      include ActiveSupport::Rescuable
+    end
+
+    module ClassMethods
+      # This can be removed once we can move action(:_rescue_action) into middlewares.rb
+      # Currently, it does controller.method(:rescue_action), which is hiding the implementation
+      # difference between the old and new base.
+      def rescue_action(env)
+        action(:_rescue_action).call(env)
+      end
+    end
+
+    attr_internal :rescued_exception
+
+  private
+
+    def method_for_action(action_name)
+      return action_name if self.rescued_exception = request.env.delete("action_dispatch.rescue.exception")
+      super
+    end
+
+    def _rescue_action
+      rescue_with_handler(rescued_exception) || raise(rescued_exception)
+    end
+
+    def process_action(*)
+      super
+    rescue Exception => exception
+      self.rescued_exception = exception
+      _rescue_action
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/testing.rb b/actionpack/lib/action_controller/new_base/testing.rb
index 106990b9ba..b39d8d539d 100644
--- a/actionpack/lib/action_controller/new_base/testing.rb
+++ b/actionpack/lib/action_controller/new_base/testing.rb
@@ -7,7 +7,7 @@ module ActionController
       @_response = response
       @_response.request = request
       ret = process(request.parameters[:action])
-      @_response.body = self.response_body
+      @_response.body = self.response_body || " "
       @_response.prepare!
       set_test_assigns
       ret
diff --git a/actionpack/lib/action_controller/routing.rb b/actionpack/lib/action_controller/routing.rb
index 7edd379bc0..ce59866531 100644
--- a/actionpack/lib/action_controller/routing.rb
+++ b/actionpack/lib/action_controller/routing.rb
@@ -4,7 +4,6 @@ require 'set'
 
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
-
 require 'action_controller/routing/optimisations'
 require 'action_controller/routing/routing_ext'
 require 'action_controller/routing/route'
diff --git a/actionpack/lib/action_controller/testing/process.rb b/actionpack/lib/action_controller/testing/process.rb
index 8f4358c33e..8831ff57e2 100644
--- a/actionpack/lib/action_controller/testing/process.rb
+++ b/actionpack/lib/action_controller/testing/process.rb
@@ -132,9 +132,6 @@ module ActionController #:nodoc:
       @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
       build_request_uri(action, parameters)
 
-      @request.env["action_controller.rescue.request"] = @request
-      @request.env["action_controller.rescue.response"] = @response
-
       Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
 
       env = @request.env
diff --git a/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb b/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
index ae20f9947c..a992f7d912 100644
--- a/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
+++ b/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
@@ -73,7 +73,7 @@ module HTML
     
     # Specifies the default Set of tags that the #sanitize helper will allow unscathed.
     self.allowed_tags           = Set.new(%w(strong em b i p code pre tt samp kbd var sub 
-      sup dfn cite big small address hr br div span h1 h2 h3 h4 h5 h6 ul ol li dt dd abbr 
+      sup dfn cite big small address hr br div span h1 h2 h3 h4 h5 h6 ul ol li dl dt dd abbr 
       acronym a img blockquote del ins))
 
     # Specifies the default Set of html attributes that the #sanitize helper will leave 
diff --git a/actionpack/lib/action_dispatch.rb b/actionpack/lib/action_dispatch.rb
index 27d229835a..6fc4ad3f21 100644
--- a/actionpack/lib/action_dispatch.rb
+++ b/actionpack/lib/action_dispatch.rb
@@ -38,7 +38,7 @@ module ActionDispatch
   autoload :Response, 'action_dispatch/http/response'
   autoload :StatusCodes, 'action_dispatch/http/status_codes'
 
-  autoload :Failsafe, 'action_dispatch/middleware/failsafe'
+  autoload :Callbacks, 'action_dispatch/middleware/callbacks'
   autoload :ParamsParser, 'action_dispatch/middleware/params_parser'
   autoload :Rescue, 'action_dispatch/middleware/rescue'
   autoload :ShowExceptions, 'action_dispatch/middleware/show_exceptions'
diff --git a/actionpack/lib/action_dispatch/middleware/callbacks.rb b/actionpack/lib/action_dispatch/middleware/callbacks.rb
new file mode 100644
index 0000000000..0a2b4cf5f7
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/callbacks.rb
@@ -0,0 +1,40 @@
+module ActionDispatch
+  class Callbacks
+    include ActiveSupport::Callbacks
+    define_callbacks :prepare, :before, :after
+
+    class << self
+      # DEPRECATED
+      alias_method :prepare_dispatch, :prepare
+      alias_method :before_dispatch, :before
+      alias_method :after_dispatch, :after
+    end
+
+    # Add a preparation callback. Preparation callbacks are run before every
+    # request in development mode, and before the first request in production
+    # mode.
+    #
+    # An optional identifier may be supplied for the callback. If provided,
+    # to_prepare may be called again with the same identifier to replace the
+    # existing callback. Passing an identifier is a suggested practice if the
+    # code adding a preparation block may be reloaded.
+    def self.to_prepare(identifier = nil, &block)
+      @prepare_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
+      callback = ActiveSupport::Callbacks::Callback.new(:prepare, block, :identifier => identifier)
+      @prepare_callbacks.replace_or_append!(callback)
+    end
+
+    def initialize(app, prepare_each_request = false)
+      @app, @prepare_each_request = app, prepare_each_request
+      run_callbacks :prepare
+    end
+
+    def call(env)
+      run_callbacks :before
+      run_callbacks :prepare if @prepare_each_request
+      @app.call(env)
+    ensure
+      run_callbacks :after, :enumerator => :reverse_each
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/failsafe.rb b/actionpack/lib/action_dispatch/middleware/failsafe.rb
deleted file mode 100644
index 836098482c..0000000000
--- a/actionpack/lib/action_dispatch/middleware/failsafe.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-module ActionDispatch
-  class Failsafe
-    cattr_accessor :error_file_path
-    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => exception
-      # Reraise exception in test environment
-      if defined?(Rails) && Rails.env.test?
-        raise exception
-      else
-        failsafe_response(exception)
-      end
-    end
-
-    private
-      def failsafe_response(exception)
-        log_failsafe_exception(exception)
-        [500, {'Content-Type' => 'text/html'}, failsafe_response_body]
-      rescue Exception => failsafe_error # Logger or IO errors
-        $stderr.puts "Error during failsafe response: #{failsafe_error}"
-      end
-
-      def failsafe_response_body
-        error_path = "#{self.class.error_file_path}/500.html"
-        if File.exist?(error_path)
-          [File.read(error_path)]
-        else
-          ["<html><body><h1>500 Internal Server Error</h1></body></html>"]
-        end
-      end
-
-      def log_failsafe_exception(exception)
-        message = "/!\\ FAILSAFE /!\\  #{Time.now}\n  Status: 500 Internal Server Error\n"
-        message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
-        failsafe_logger.fatal(message)
-      end
-
-      def failsafe_logger
-        if defined?(Rails) && Rails.logger
-          Rails.logger
-        else
-          Logger.new($stderr)
-        end
-      end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/params_parser.rb b/actionpack/lib/action_dispatch/middleware/params_parser.rb
index 58d527a6e7..e83cf9236b 100644
--- a/actionpack/lib/action_dispatch/middleware/params_parser.rb
+++ b/actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -32,16 +32,14 @@ module ActionDispatch
           when Proc
             strategy.call(request.raw_post)
           when :xml_simple, :xml_node
-            body = request.raw_post
-            body.blank? ? {} : Hash.from_xml(body).with_indifferent_access
+            request.body.size == 0 ? {} : Hash.from_xml(request.body).with_indifferent_access
           when :yaml
-            YAML.load(request.raw_post)
+            YAML.load(request.body)
           when :json
-            body = request.raw_post
-            if body.blank?
+            if request.body.size == 0
               {}
             else
-              data = ActiveSupport::JSON.decode(body)
+              data = ActiveSupport::JSON.decode(request.body)
               data = {:_json => data} unless data.is_a?(Hash)
               data.with_indifferent_access
             end
diff --git a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
index 71c1e1b9a9..108355da63 100644
--- a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -4,8 +4,11 @@ module ActionDispatch
 
     LOCALHOST = '127.0.0.1'.freeze
 
-    DEFAULT_RESCUE_RESPONSE = :internal_server_error
-    DEFAULT_RESCUE_RESPONSES = {
+    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
+
+    cattr_accessor :rescue_responses
+    @@rescue_responses = Hash.new(:internal_server_error)
+    @@rescue_responses.update({
       'ActionController::RoutingError'             => :not_found,
       'ActionController::UnknownAction'            => :not_found,
       'ActiveRecord::RecordNotFound'               => :not_found,
@@ -15,25 +18,19 @@ module ActionDispatch
       'ActionController::MethodNotAllowed'         => :method_not_allowed,
       'ActionController::NotImplemented'           => :not_implemented,
       'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
-    }
+    })
 
-    DEFAULT_RESCUE_TEMPLATE = 'diagnostics'
-    DEFAULT_RESCUE_TEMPLATES = {
+    cattr_accessor :rescue_templates
+    @@rescue_templates = Hash.new('diagnostics')
+    @@rescue_templates.update({
       'ActionView::MissingTemplate'       => 'missing_template',
       'ActionController::RoutingError'    => 'routing_error',
       'ActionController::UnknownAction'   => 'unknown_action',
       'ActionView::TemplateError'         => 'template_error'
-    }
-
-    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
-
-    cattr_accessor :rescue_responses
-    @@rescue_responses = Hash.new(DEFAULT_RESCUE_RESPONSE)
-    @@rescue_responses.update DEFAULT_RESCUE_RESPONSES
+    })
 
-    cattr_accessor :rescue_templates
-    @@rescue_templates = Hash.new(DEFAULT_RESCUE_TEMPLATE)
-    @@rescue_templates.update DEFAULT_RESCUE_TEMPLATES
+    FAILSAFE_RESPONSE = [500, {'Content-Type' => 'text/html'},
+      ['<html><body><h1>500 Internal Server Error</h1></body></html>']]
 
     def initialize(app, consider_all_requests_local = false)
       @app = app
@@ -43,34 +40,35 @@ module ActionDispatch
     def call(env)
       @app.call(env)
     rescue Exception => exception
-      raise exception if env['rack.test']
+      raise exception if env['action_dispatch.show_exceptions'] == false
+      render_exception(env, exception)
+    end
 
-      log_error(exception) if logger
+    private
+      def render_exception(env, exception)
+        log_error(exception)
 
-      request = Request.new(env)
-      if @consider_all_requests_local || local_request?(request)
-        rescue_action_locally(request, exception)
-      else
-        rescue_action_in_public(exception)
+        request = Request.new(env)
+        if @consider_all_requests_local || local_request?(request)
+          rescue_action_locally(request, exception)
+        else
+          rescue_action_in_public(exception)
+        end
+      rescue Exception => failsafe_error
+        $stderr.puts "Error during failsafe response: #{failsafe_error}"
+        FAILSAFE_RESPONSE
       end
-    end
 
-    private
       # Render detailed diagnostics for unhandled exceptions rescued from
       # a controller action.
       def rescue_action_locally(request, exception)
         template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
-          :template => template,
           :request => request,
           :exception => exception
         )
         file = "rescues/#{@@rescue_templates[exception.class.name]}.erb"
         body = template.render(:file => file, :layout => 'rescues/layout.erb')
-
-        headers = {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}
-        status = status_code(exception)
-
-        [status, headers, body]
+        render(status_code(exception), body)
       end
 
       # Attempts to render a static error page based on the
@@ -86,11 +84,11 @@ module ActionDispatch
         path = "#{public_path}/#{status}.html"
 
         if locale_path && File.exist?(locale_path)
-          render_public_file(status, locale_path)
+          render(status, File.read(locale_path))
         elsif File.exist?(path)
-          render_public_file(status, path)
+          render(status, File.read(path))
         else
-          [status, {'Content-Type' => 'text/html', 'Content-Length' => '0'}, []]
+          render(status, '')
         end
       end
 
@@ -99,24 +97,21 @@ module ActionDispatch
         request.remote_addr == LOCALHOST && request.remote_ip == LOCALHOST
       end
 
-      def render_public_file(status, path)
-        body = File.read(path)
-        [status, {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}, body]
-      end
-
       def status_code(exception)
         interpret_status(@@rescue_responses[exception.class.name]).to_i
       end
 
+      def render(status, body)
+        [status, {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}, body]
+      end
+
       def public_path
-        if defined?(Rails)
-          Rails.public_path
-        else
-          "public"
-        end
+        defined?(Rails.public_path) ? Rails.public_path : 'public_path'
       end
 
-      def log_error(exception) #:doc:
+      def log_error(exception)
+        return unless logger
+
         ActiveSupport::Deprecation.silence do
           if ActionView::TemplateError === exception
             logger.fatal(exception.to_s)
@@ -136,9 +131,7 @@ module ActionDispatch
       end
 
       def logger
-        if defined?(Rails.logger)
-          Rails.logger
-        end
+        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
       end
   end
 end
diff --git a/actionpack/lib/action_view.rb b/actionpack/lib/action_view.rb
index c3786af439..94138097e3 100644
--- a/actionpack/lib/action_view.rb
+++ b/actionpack/lib/action_view.rb
@@ -24,6 +24,7 @@
 activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
 $:.unshift activesupport_path if File.directory?(activesupport_path)
 require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
 
 require File.join(File.dirname(__FILE__), "action_pack")
 
diff --git a/actionpack/lib/action_view/helpers/form_options_helper.rb b/actionpack/lib/action_view/helpers/form_options_helper.rb
index 6b385ef77d..6adbab175f 100644
--- a/actionpack/lib/action_view/helpers/form_options_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_options_helper.rb
@@ -230,6 +230,8 @@ module ActionView
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def options_for_select(container, selected = nil)
+        return container if String === container
+
         container = container.to_a if Hash === container
         selected, disabled = extract_selected_and_disabled(selected)
 
diff --git a/actionpack/lib/action_view/helpers/number_helper.rb b/actionpack/lib/action_view/helpers/number_helper.rb
index c02692b09a..999d5b34fc 100644
--- a/actionpack/lib/action_view/helpers/number_helper.rb
+++ b/actionpack/lib/action_view/helpers/number_helper.rb
@@ -248,6 +248,11 @@ module ActionView
       #  number_to_human_size(483989, :precision => 0)                      # => 473 KB
       #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
       #
+      # Zeros after the decimal point are always stripped out, regardless of the
+      # specified precision:
+      #  helper.number_to_human_size(1234567890123, :precision => 5)        # => "1.12283 TB"
+      #  helper.number_to_human_size(524288000, :precision=>5)              # => "500 MB"
+      #
       # You can still use <tt>number_to_human_size</tt> with the old API that accepts the
       # +precision+ as its optional second parameter:
       #  number_to_human_size(1234567, 2)    # => 1.18 MB
@@ -293,7 +298,7 @@ module ActionView
               :precision => precision,
               :separator => separator,
               :delimiter => delimiter
-            ).sub(/(\d)(#{escaped_separator}[1-9]*)?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
             storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
           rescue
             number
diff --git a/actionpack/lib/action_view/helpers/tag_helper.rb b/actionpack/lib/action_view/helpers/tag_helper.rb
index af8c4d5e21..66d7592874 100644
--- a/actionpack/lib/action_view/helpers/tag_helper.rb
+++ b/actionpack/lib/action_view/helpers/tag_helper.rb
@@ -9,7 +9,7 @@ module ActionView
       include ERB::Util
 
       BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked).to_set
-      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map(&:to_sym))
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
 
       # Returns an empty HTML tag of type +name+ which by default is XHTML
       # compliant. Set +open+ to true to create an open tag compatible
diff --git a/actionpack/lib/action_view/helpers/text_helper.rb b/actionpack/lib/action_view/helpers/text_helper.rb
index 573b99b96e..8136a1cb13 100644
--- a/actionpack/lib/action_view/helpers/text_helper.rb
+++ b/actionpack/lib/action_view/helpers/text_helper.rb
@@ -535,7 +535,7 @@ module ActionView
           link_attributes = html_options.stringify_keys
           text.gsub(AUTO_LINK_RE) do
             href = $&
-            punctuation = ''
+            punctuation = []
             left, right = $`, $'
             # detect already linked URLs and URLs in the middle of a tag
             if left =~ /<[^>]+$/ && right =~ /^[^>]*>/
@@ -543,17 +543,18 @@ module ActionView
               href
             else
               # don't include trailing punctuation character as part of the URL
-              if href.sub!(/[^\w\/-]$/, '') and punctuation = $& and opening = BRACKETS[punctuation]
-                if href.scan(opening).size > href.scan(punctuation).size
-                  href << punctuation
-                  punctuation = ''
+              while href.sub!(/[^\w\/-]$/, '')
+                punctuation.push $&
+                if opening = BRACKETS[punctuation.last] and href.scan(opening).size > href.scan(punctuation.last).size
+                  href << punctuation.pop
+                  break
                 end
               end
 
               link_text = block_given?? yield(href) : href
               href = 'http://' + href unless href.index('http') == 0
 
-              content_tag(:a, h(link_text), link_attributes.merge('href' => href)) + punctuation
+              content_tag(:a, h(link_text), link_attributes.merge('href' => href)) + punctuation.reverse.join('')
             end
           end
         end
diff --git a/actionpack/lib/action_view/template/handlers.rb b/actionpack/lib/action_view/template/handlers.rb
index 0590372d09..faf54b9fe5 100644
--- a/actionpack/lib/action_view/template/handlers.rb
+++ b/actionpack/lib/action_view/template/handlers.rb
@@ -33,7 +33,7 @@ module ActionView #:nodoc:
     end
 
     def template_handler_extensions
-      @@template_handlers.keys.map(&:to_s).sort
+      @@template_handlers.keys.map {|key| key.to_s }.sort
     end
 
     def registered_template_handler(extension)
diff --git a/actionpack/test/abstract_controller/abstract_controller_test.rb b/actionpack/test/abstract_controller/abstract_controller_test.rb
index 689aa99fd8..9c028e7d1e 100644
--- a/actionpack/test/abstract_controller/abstract_controller_test.rb
+++ b/actionpack/test/abstract_controller/abstract_controller_test.rb
@@ -201,11 +201,10 @@ module AbstractController
       def fail()  self.response_body = "fail"    end
         
     private
-      
-      def respond_to_action?(action_name)
-        action_name.to_s != "fail"
+
+      def method_for_action(action_name)
+        action_name.to_s != "fail" && action_name
       end
-      
     end
     
     class TestRespondToAction < ActiveSupport::TestCase
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 825ac9a46c..7982f06545 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -37,7 +37,7 @@ ActionController::Base.session_store = nil
 # Register danish language for testing
 I18n.backend.store_translations 'da', {}
 I18n.backend.store_translations 'pt-BR', {}
-ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
+ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 ActionController::Base.view_paths = FIXTURE_LOAD_PATH
diff --git a/actionpack/test/abstract_unit2.rb b/actionpack/test/abstract_unit2.rb
index 932f594ad2..519e6bea36 100644
--- a/actionpack/test/abstract_unit2.rb
+++ b/actionpack/test/abstract_unit2.rb
@@ -11,11 +11,19 @@ require 'action_controller/new_base'
 require 'fixture_template'
 require 'action_controller/testing/process2'
 require 'action_view/test_case'
+require 'action_controller/testing/integration'
+require 'active_support/dependencies'
+
+ActiveSupport::Dependencies.hook!
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 
 module ActionController
-  
+  Base.session = {
+  :key         => '_testing_session',
+  :secret      => '8273f16463985e2b3747dc25e30f2528'
+}
+
   class ActionControllerError < StandardError #:nodoc:
   end
 
@@ -126,6 +134,6 @@ module ActionController
             "Expected no partials to be rendered"
         end
       end
-    end    
+    end
   end
 end
diff --git a/actionpack/test/activerecord/active_record_store_test.rb b/actionpack/test/activerecord/active_record_store_test.rb
index 663cd259c8..47f8496181 100644
--- a/actionpack/test/activerecord/active_record_store_test.rb
+++ b/actionpack/test/activerecord/active_record_store_test.rb
@@ -28,9 +28,9 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
     end
 
     def call_reset_session
-      session[:bar]
+      session[:foo]
       reset_session
-      session[:bar] = "baz"
+      session[:foo] = "baz"
       head :ok
     end
 
@@ -91,7 +91,7 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
 
       get '/get_session_value'
       assert_response :success
-      assert_equal 'foo: nil', response.body
+      assert_equal 'foo: "baz"', response.body
 
       get '/get_session_id'
       assert_response :success
diff --git a/actionpack/test/activerecord/polymorphic_routes_test.rb b/actionpack/test/activerecord/polymorphic_routes_test.rb
index 35139fbb7f..b9f5be2361 100644
--- a/actionpack/test/activerecord/polymorphic_routes_test.rb
+++ b/actionpack/test/activerecord/polymorphic_routes_test.rb
@@ -1,4 +1,5 @@
 require 'active_record_unit'
+require 'fixtures/project'
 
 class Task < ActiveRecord::Base
   set_table_name 'projects'
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 484d3c5ce7..c3c769919a 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -12,6 +12,9 @@ class ActionPackAssertionsController < ActionController::Base
   # a standard template
   def hello_xml_world() render :template => "test/hello_xml_world"; end
 
+  # a standard partial
+  def partial() render :partial => 'test/partial'; end
+
   # a redirect to an internal location
   def redirect_internal() redirect_to "/nothing"; end
 
@@ -331,6 +334,26 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
     end
   end
 
+  def test_assert_template_with_partial
+    get :partial
+    assert_template :partial => '_partial'
+  end
+
+  def test_assert_template_with_nil
+    get :nothing
+    assert_template nil
+  end
+
+  def test_assert_template_with_string
+    get :hello_world
+    assert_template 'hello_world'
+  end
+
+  def test_assert_template_with_symbol
+    get :hello_world
+    assert_template :hello_world
+  end
+
   # check if we were rendered by a file-based template?
   def test_rendered_action
     process :nothing
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index a09db95d7d..3a4cdb81d9 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -117,7 +117,7 @@ class PerformActionTest < ActionController::TestCase
     end
 
     def method_missing(method, *args)
-      @logged << args.first
+      @logged << args.first.to_s
     end
   end
 
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index b315232a7b..9fae1fcf63 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -6,20 +6,20 @@ class DispatcherTest < Test::Unit::TestCase
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
-    Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
-      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/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)
+    ActionDispatch::Callbacks.instance_variable_set("@prepare_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.instance_variable_set("@before_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.instance_variable_set("@after_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
+    @old_router, Dispatcher.router = Dispatcher.router, mock()
+    Dispatcher.router.stubs(:call).returns([200, {}, 'response'])
+    Dispatcher.router.stubs(:reload)
     Dispatcher.stubs(:require_dependency)
   end
 
   def teardown
+    Dispatcher.router = @old_router
+    @dispatcher = nil
     ENV.delete 'REQUEST_METHOD'
   end
 
@@ -29,12 +29,12 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def test_reloads_routes_before_dispatch_if_in_loading_mode
-    ActionController::Routing::Routes.expects(:reload).once
+    Dispatcher.router.expects(:reload).once
     dispatch(false)
   end
 
   def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
-    ActionController::Routing::Routes.expects(:reload).never
+    Dispatcher.router.expects(:reload).never
     ActiveSupport::Dependencies.expects(:clear).never
 
     dispatch
@@ -55,7 +55,7 @@ class DispatcherTest < Test::Unit::TestCase
     assert_nil a || b || c
 
     # Run callbacks
-    Dispatcher.run_prepare_callbacks
+    dispatch
 
     assert_equal 1, a
     assert_equal 2, b
@@ -72,16 +72,22 @@ class DispatcherTest < Test::Unit::TestCase
     Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
     Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
-    Dispatcher.run_prepare_callbacks
+    dispatch
     assert_equal 2, a
     assert_equal nil, b
   end
 
   private
     def dispatch(cache_classes = true)
-      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
+      ActionController::Dispatcher.prepare_each_request = false
       Dispatcher.define_dispatcher_callbacks(cache_classes)
-      Dispatcher.new.call({'rack.input' => StringIO.new('')})
+      Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+        middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb"))
+        middleware.instance_eval(File.read(middlewares))
+      end
+
+      @dispatcher ||= Dispatcher.new
+      @dispatcher.call({'rack.input' => StringIO.new(''), 'action_dispatch.show_exceptions' => false})
     end
 
     def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index 9ad49e9282..afefc6a77e 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -607,7 +607,6 @@ class FilterTest < Test::Unit::TestCase
   def test_dynamic_dispatch
     %w(foo bar baz).each do |action|
       request = ActionController::TestRequest.new
-      request.env["action_controller.rescue.request"] = request
       request.query_parameters[:choose] = action
       response = DynamicDispatchController.action.call(request.env).last
       assert_equal action, response.body
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index 7b8096fccc..3bbda9eb3a 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/test/controller/helper_test.rb
@@ -104,7 +104,6 @@ class HelperTest < Test::Unit::TestCase
 
   def call_controller(klass, action)
     request  = ActionController::TestRequest.new
-    request.env["action_controller.rescue.request"] = request
     klass.action(action).call(request.env)    
   end
 
@@ -112,7 +111,6 @@ class HelperTest < Test::Unit::TestCase
     assert_equal 'hello: Iz guuut!', 
       call_controller(Fun::GamesController, "render_hello_world").last.body
     # request  = ActionController::TestRequest.new
-    # request.env["action_controller.rescue.request"] = request
     # 
     # resp = Fun::GamesController.action(:render_hello_world).call(request.env)
     # assert_equal 'hello: Iz guuut!', resp.last.body
@@ -217,7 +215,6 @@ class IsolatedHelpersTest < Test::Unit::TestCase
 
   def call_controller(klass, action)
     request  = ActionController::TestRequest.new
-    request.env["action_controller.rescue.request"] = request
     klass.action(action).call(request.env)    
   end
 
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 7bebc8cd2a..b8a2205ce6 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -149,6 +149,16 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     assert_equal 'Definitely Maybe', @response.body
   end
 
+  test "authentication request with _method" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please', :method => :post)
+    @request.env['rack.methodoverride.original_method'] = 'POST'
+    put :display
+
+    assert_response :success
+    assert assigns(:logged_in)
+    assert_equal 'Definitely Maybe', @response.body
+  end
+
   private
 
   def encode_credentials(options)
@@ -159,15 +169,22 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     # to prevent tampering of timestamp
     ActionController::Base.session_options[:secret] = "session_options_secret"
 
-    # Perform unauthenticated GET to retrieve digest parameters to use on subsequent request
-    get :index
+    # Perform unauthenticated request to retrieve digest parameters to use on subsequent request
+    method = options.delete(:method) || 'GET'
+
+    case method.to_s.upcase
+    when 'GET'
+      get :index
+    when 'POST'
+      post :index
+    end
 
     assert_response :unauthorized
 
     credentials = decode_credentials(@response.headers['WWW-Authenticate'])
     credentials.merge!(options)
     credentials.reverse_merge!(:uri => "#{@request.env['REQUEST_URI']}")
-    ActionController::HttpAuthentication::Digest.encode_credentials("GET", credentials, password, options[:password_is_ha1])
+    ActionController::HttpAuthentication::Digest.encode_credentials(method, credentials, password, options[:password_is_ha1])
   end
 
   def decode_credentials(header)
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 469e8601d0..a750f018b8 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -262,6 +262,7 @@ class TestController < ActionController::Base
     render :action => "hello_world"
   end
 
+  # :ported:
   def builder_layout_test
     render :action => "hello", :layout => "layouts/builder"
   end
@@ -271,6 +272,7 @@ class TestController < ActionController::Base
     render :action => "hello_world_container"
   end
 
+  # :ported:
   def partials_list
     @test_unchanged = 'hello'
     @customers = [ Customer.new("david"), Customer.new("mary") ]
@@ -860,6 +862,7 @@ class RenderTest < ActionController::TestCase
     assert_equal "application/xml", @response.content_type
   end
 
+  # :ported:
   def test_render_xml_as_string_template
     get :render_xml_hello_as_string_template
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
@@ -872,11 +875,13 @@ class RenderTest < ActionController::TestCase
     assert_equal "<p>This is grand!</p>\n", @response.body
   end
 
+  # :move: test in AV
   def test_render_xml_with_partial
     get :builder_partial_test
     assert_equal "<test>\n  <hello/>\n</test>\n", @response.body
   end
 
+  # :ported:
   def test_layout_rendering
     get :layout_test
     assert_equal "<html>Hello world!</html>", @response.body
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index f745926b20..490a4ff3b3 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -1,5 +1,19 @@
 require 'abstract_unit'
 
+module ActionDispatch
+  class ShowExceptions
+    private
+      def public_path
+        "#{FIXTURE_LOAD_PATH}/public"
+      end
+
+      # Silence logger
+      def logger
+        nil
+      end
+  end
+end
+
 class RescueController < ActionController::Base
   class NotAuthorized < StandardError
   end
diff --git a/actionpack/test/dispatch/show_exceptions_test.rb b/actionpack/test/dispatch/show_exceptions_test.rb
index f8f562e7c1..0c0c087340 100644
--- a/actionpack/test/dispatch/show_exceptions_test.rb
+++ b/actionpack/test/dispatch/show_exceptions_test.rb
@@ -6,6 +6,11 @@ module ActionDispatch
       def public_path
         "#{FIXTURE_LOAD_PATH}/public"
       end
+
+      # Silence logger
+      def logger
+        nil
+      end
   end
 end
 
diff --git a/actionpack/test/new_base/render_action_test.rb b/actionpack/test/new_base/render_action_test.rb
index 348d70381b..626c7b3540 100644
--- a/actionpack/test/new_base/render_action_test.rb
+++ b/actionpack/test/new_base/render_action_test.rb
@@ -92,7 +92,7 @@ module RenderAction
     
     test "raises an exception when requesting a layout and none exist" do
       assert_raise(ArgumentError, /no default layout for RenderAction::BasicController in/) do 
-        get "/render_action/basic/hello_world_with_layout"
+        get "/render_action/basic/hello_world_with_layout", {}, "action_dispatch.show_exceptions" => false
       end
     end
   end
@@ -117,7 +117,9 @@ module RenderAction
     describe "rendering a normal template with full path with layout => 'greetings'"
     
     test "raises an exception when requesting a layout that does not exist" do
-      assert_raise(ActionView::MissingTemplate) { get "/render_action/basic/hello_world_with_custom_layout" }
+      assert_raise(ActionView::MissingTemplate) do
+        get "/render_action/basic/hello_world_with_custom_layout", {}, "action_dispatch.show_exceptions" => false
+      end
     end
   end
   
@@ -131,8 +133,10 @@ module RenderActionWithApplicationLayout
     # Set the view path to an application view structure with layouts
     self.view_paths = self.view_paths = [ActionView::Template::FixturePath.new(
       "render_action_with_application_layout/basic/hello_world.html.erb" => "Hello World!",
+      "render_action_with_application_layout/basic/hello.html.builder"   => "xml.p 'Omg'",
       "layouts/application.html.erb"                                     => "OHAI <%= yield %> KTHXBAI",
-      "layouts/greetings.html.erb"                                       => "Greetings <%= yield %> Bai"
+      "layouts/greetings.html.erb"                                       => "Greetings <%= yield %> Bai",
+      "layouts/builder.html.builder"                                     => "xml.html do\n  xml << yield\nend"
     )]
     
     def hello_world
@@ -154,6 +158,10 @@ module RenderActionWithApplicationLayout
     def hello_world_with_custom_layout
       render :action => "hello_world", :layout => "greetings"
     end
+    
+    def with_builder_and_layout
+      render :action => "hello", :layout => "builder"
+    end
   end
   
   class TestDefaultLayout < SimpleRouteCase
@@ -199,6 +207,15 @@ module RenderActionWithApplicationLayout
     assert_status 200
   end
   
+  class TestLayout < SimpleRouteCase
+    testing BasicController
+    
+    test "builder works with layouts" do
+      get :with_builder_and_layout
+      assert_response "<html>\n<p>Omg</p>\n</html>\n"
+    end
+  end
+  
 end
 
 module RenderActionWithControllerLayout
diff --git a/actionpack/test/new_base/render_layout_test.rb b/actionpack/test/new_base/render_layout_test.rb
index 7f627f86ec..dc858b4f5c 100644
--- a/actionpack/test/new_base/render_layout_test.rb
+++ b/actionpack/test/new_base/render_layout_test.rb
@@ -22,8 +22,6 @@ module ControllerLayouts
       render :layout => false
     end
     
-    
-    
     def builder_override
       
     end
diff --git a/actionpack/test/new_base/render_partial_test.rb b/actionpack/test/new_base/render_partial_test.rb
new file mode 100644
index 0000000000..3a300afe5c
--- /dev/null
+++ b/actionpack/test/new_base/render_partial_test.rb
@@ -0,0 +1,27 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderPartial
+  
+  class BasicController < ActionController::Base
+    
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render_partial/basic/_basic.html.erb"    => "OMG!",
+      "render_partial/basic/basic.html.erb"      => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'basic' %><%= @test_unchanged %>"
+    )]
+    
+    def changing
+      @test_unchanged = 'hello'
+      render :action => "basic"
+    end    
+  end
+  
+  class TestPartial < SimpleRouteCase
+    testing BasicController
+    
+    test "rendering a partial in ActionView doesn't pull the ivars again from the controller" do
+      get :changing
+      assert_response("goodbyeOMG!goodbye")
+    end
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_template_test.rb b/actionpack/test/new_base/render_template_test.rb
index c09eeb1926..6c50ae4203 100644
--- a/actionpack/test/new_base/render_template_test.rb
+++ b/actionpack/test/new_base/render_template_test.rb
@@ -4,14 +4,19 @@ module RenderTemplate
   class WithoutLayoutController < ActionController::Base
     
     self.view_paths = [ActionView::Template::FixturePath.new(
-      "test/basic.html.erb" => "Hello from basic.html.erb",
-      "shared.html.erb"     => "Elastica",
-      "locals.html.erb"     => "The secret is <%= secret %>"
+      "test/basic.html.erb"      => "Hello from basic.html.erb",
+      "shared.html.erb"          => "Elastica",
+      "locals.html.erb"          => "The secret is <%= secret %>",
+      "xml_template.xml.builder" => "xml.html do\n  xml.p 'Hello'\nend"
     )]
     
     def index
       render :template => "test/basic"
     end
+    
+    def index_without_key
+      render "test/basic"
+    end
 
     def in_top_directory
       render :template => 'shared'
@@ -21,41 +26,56 @@ module RenderTemplate
       render :template => '/shared'
     end
     
+    def in_top_directory_with_slash_without_key
+      render '/shared'
+    end
+    
     def with_locals
       render :template => "locals", :locals => { :secret => 'area51' }
     end
+    
+    def builder_template
+      render :template => "xml_template"
+    end
   end
   
   class TestWithoutLayout < SimpleRouteCase
-    describe "rendering a normal template with full path without layout"
+    testing RenderTemplate::WithoutLayoutController
     
-    get "/render_template/without_layout"
-    assert_body   "Hello from basic.html.erb"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderInTopDirectory < SimpleRouteCase
-    describe "rendering a template not in a subdirectory"
+    test "rendering a normal template with full path without layout" do
+      get :index
+      assert_response "Hello from basic.html.erb"
+    end
     
-    get "/render_template/without_layout/in_top_directory"
-    assert_body   "Elastica"
-    assert_status 200
-  end
-
-  class TestTemplateRenderInTopDirectoryWithSlash < SimpleRouteCase
-    describe "rendering a template not in a subdirectory with a leading slash"
+    test "rendering a normal template with full path without layout without key" do
+      get :index_without_key
+      assert_response "Hello from basic.html.erb"
+    end
     
-    get "/render_template/without_layout/in_top_directory_with_slash"
-    assert_body   "Elastica"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithLocals < SimpleRouteCase
-    describe "rendering a template with local variables"
+    test "rendering a template not in a subdirectory" do
+      get :in_top_directory
+      assert_response "Elastica"
+    end
     
-    get "/render_template/without_layout/with_locals"
-    assert_body   "The secret is area51"
-    assert_status 200
+    test "rendering a template not in a subdirectory with a leading slash" do
+      get :in_top_directory_with_slash
+      assert_response "Elastica"
+    end
+    
+    test "rendering a template not in a subdirectory with a leading slash without key" do
+      get :in_top_directory_with_slash_without_key
+      assert_response "Elastica"
+    end
+    
+    test "rendering a template with local variables" do
+      get :with_locals
+      assert_response "The secret is area51"
+    end
+    
+    test "rendering a builder template" do
+      get :builder_template
+      assert_response "<html>\n  <p>Hello</p>\n</html>\n"
+    end
   end
     
   class WithLayoutController < ::ApplicationController
diff --git a/actionpack/test/new_base/render_test.rb b/actionpack/test/new_base/render_test.rb
index b1867fdcc2..ef5e7d89c5 100644
--- a/actionpack/test/new_base/render_test.rb
+++ b/actionpack/test/new_base/render_test.rb
@@ -48,7 +48,7 @@ module Render
     
     test "raises an exception" do
       assert_raises(AbstractController::DoubleRenderError) do
-        get "/render/double_render"
+        get "/render/double_render", {}, "action_dispatch.show_exceptions" => false
       end
     end
   end
@@ -58,13 +58,13 @@ module Render
     
     test "raises an exception when a method of Object is called" do
       assert_raises(AbstractController::ActionNotFound) do
-        get "/render/blank_render/clone"
+        get "/render/blank_render/clone", {}, "action_dispatch.show_exceptions" => false
       end
     end
     
     test "raises an exception when a private method is called" do
       assert_raises(AbstractController::ActionNotFound) do
-        get "/render/blank_render/secretz"
+        get "/render/blank_render/secretz", {}, "action_dispatch.show_exceptions" => false
       end
     end
   end
diff --git a/actionpack/test/new_base/render_xml_test.rb b/actionpack/test/new_base/render_xml_test.rb
new file mode 100644
index 0000000000..e6c40b1533
--- /dev/null
+++ b/actionpack/test/new_base/render_xml_test.rb
@@ -0,0 +1,11 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderXml
+  
+  # This has no layout and it works
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render_xml/basic/with_render_erb" => "Hello world!"
+    )]
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/test_helper.rb b/actionpack/test/new_base/test_helper.rb
index a7302af060..ec7dbffaae 100644
--- a/actionpack/test/new_base/test_helper.rb
+++ b/actionpack/test/new_base/test_helper.rb
@@ -46,7 +46,7 @@ class Rack::TestCase < ActiveSupport::TestCase
     ActionController::Routing.use_controllers!(controllers)
     
     # Move into a bootloader
-    AbstractController::Base.subclasses.each do |klass|
+    ActionController::Base.subclasses.each do |klass|
       klass = klass.constantize
       next unless klass < AbstractController::Layouts
       klass.class_eval do
diff --git a/actionpack/test/template/form_options_helper_test.rb b/actionpack/test/template/form_options_helper_test.rb
index 78db87971b..73624406be 100644
--- a/actionpack/test/template/form_options_helper_test.rb
+++ b/actionpack/test/template/form_options_helper_test.rb
@@ -80,6 +80,14 @@ class FormOptionsHelperTest < ActionView::TestCase
     )
   end
 
+  def test_string_options_for_select
+    options = "<option value=\"Denmark\">Denmark</option><option value=\"USA\">USA</option><option value=\"Sweden\">Sweden</option>"
+    assert_dom_equal(
+      options,
+      options_for_select(options)
+    )
+  end
+
   def test_array_options_for_select
     assert_dom_equal(
       "<option value=\"&lt;Denmark&gt;\">&lt;Denmark&gt;</option>\n<option value=\"USA\">USA</option>\n<option value=\"Sweden\">Sweden</option>",
@@ -324,6 +332,20 @@ class FormOptionsHelperTest < ActionView::TestCase
     )
   end
 
+  def test_select_under_fields_for_with_string_and_given_prompt
+    @post = Post.new
+    options = "<option value=\"abe\">abe</option><option value=\"mus\">mus</option><option value=\"hest\">hest</option>"
+
+    fields_for :post, @post do |f|
+      concat f.select(:category, options, :prompt => 'The prompt')
+    end
+
+    assert_dom_equal(
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">The prompt</option>\n#{options}</select>",
+      output_buffer
+    )
+  end
+
   def test_select_with_blank
     @post = Post.new
     @post.category = "<mus>"
diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb
index 29cb60fd73..b6542ef29d 100644
--- a/actionpack/test/template/number_helper_test.rb
+++ b/actionpack/test/template/number_helper_test.rb
@@ -118,6 +118,10 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
     assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
     assert_equal '10 KB',     number_to_human_size(10.000.kilobytes, :precision => 4)
+    assert_equal '1 TB', number_to_human_size(1234567890123, :precision => 0)
+    assert_equal '500 MB', number_to_human_size(524288000, :precision=>0)
+    assert_equal '40 KB', number_to_human_size(41010, :precision => 0)
+    assert_equal '40 KB', number_to_human_size(41100, :precision => 0)
   end
 
   def test_number_to_human_size_with_custom_delimiter_and_separator
diff --git a/actionpack/test/template/text_helper_test.rb b/actionpack/test/template/text_helper_test.rb
index be7163888e..a780bfc606 100644
--- a/actionpack/test/template/text_helper_test.rb
+++ b/actionpack/test/template/text_helper_test.rb
@@ -401,6 +401,13 @@ class TextHelperTest < ActionView::TestCase
       auto_link("Welcome to my new blog at http://www.myblog.com/. Please e-mail me at me@email.com.",
                 :link => :all, :html => { :class => "menu", :target => "_blank" })
   end
+  
+  def test_auto_link_with_multiple_trailing_punctuations
+    url = "http://youtube.com"
+    url_result = generate_result(url)
+    assert_equal url_result, auto_link(url)
+    assert_equal "(link: #{url_result}).", auto_link("(link: #{url}).")
+  end
 
   def test_cycle_class
     value = Cycle.new("one", 2, "3")