Merge commit 'mainstream/master'

Conflicts:
	activerecord/lib/active_record/base.rb

54 files changed, 1426 insertions, 938 deletions

diff --git a/actionpack/CHANGELOG b/actionpack/CHANGELOG
index a8abf48441..26e40e76d5 100644
--- a/actionpack/CHANGELOG
+++ b/actionpack/CHANGELOG
@@ -1,5 +1,9 @@
 *2.3.0 [Edge]*
 
+* Added :silence option to BenchmarkHelper#benchmark and turned log_level into a hash parameter and deprecated the old use [DHH]
+
+* Fixed the AssetTagHelper cache to use the computed asset host as part of the cache key instead of just assuming the its a string #1299 [DHH]
+
 * Make ActionController#render(string) work as a shortcut for render :file/:template/:action => string. [#1435] [Pratik Naik] Examples:
 
   # Instead of render(:action => 'other_action')
diff --git a/actionpack/Rakefile b/actionpack/Rakefile
index 1a1b908122..c389e5a8d6 100644
--- a/actionpack/Rakefile
+++ b/actionpack/Rakefile
@@ -81,7 +81,7 @@ spec = Gem::Specification.new do |s|
   s.requirements << 'none'
 
   s.add_dependency('activesupport', '= 2.3.0' + PKG_BUILD)
-  s.add_dependency('rack', '= 0.4.0')
+  s.add_dependency('rack', '>= 0.9.0')
 
   s.require_path = 'lib'
   s.autorequire = 'action_controller'
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index 98fb490d64..8c022e5625 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -31,7 +31,7 @@ rescue LoadError
   end
 end
 
-gem 'rack', '~> 0.4.0'
+gem 'rack', '>= 0.9.0'
 require 'rack'
 
 module ActionController
diff --git a/actionpack/lib/action_controller/base.rb b/actionpack/lib/action_controller/base.rb
index 5b83494eb4..e22114195c 100644
--- a/actionpack/lib/action_controller/base.rb
+++ b/actionpack/lib/action_controller/base.rb
@@ -382,6 +382,13 @@ module ActionController #:nodoc:
     attr_accessor :action_name
 
     class << self
+      def call(env)
+        # HACK: For global rescue to have access to the original request and response
+        request = env["action_controller.rescue.request"] ||= Request.new(env)
+        response = env["action_controller.rescue.response"] ||= Response.new
+        process(request, response)
+      end
+
       # Factory for the standard create, process loop where the controller is discarded after processing.
       def process(request, response) #:nodoc:
         new.process(request, response)
@@ -862,7 +869,7 @@ module ActionController #:nodoc:
         validate_render_arguments(options, extra_options, block_given?)
 
         if options.nil?
-          options = { :template => default_template.filename, :layout => true }
+          options = { :template => default_template, :layout => true }
         elsif options == :update
           options = extra_options.merge({ :update => true })
         elsif options.is_a?(String) || options.is_a?(Symbol)
@@ -1118,7 +1125,7 @@ module ActionController #:nodoc:
       end
 
       # Sets the etag, last_modified, or both on the response and renders a
-      # "304 Not Modified" response if the request is already fresh. 
+      # "304 Not Modified" response if the request is already fresh.
       #
       # Example:
       #
@@ -1126,8 +1133,8 @@ module ActionController #:nodoc:
       #     @article = Article.find(params[:id])
       #     fresh_when(:etag => @article, :last_modified => @article.created_at.utc)
       #   end
-      # 
-      # This will render the show template if the request isn't sending a matching etag or 
+      #
+      # This will render the show template if the request isn't sending a matching etag or
       # If-Modified-Since header and just a "304 Not Modified" response if there's a match.
       def fresh_when(options)
         options.assert_valid_keys(:etag, :last_modified)
@@ -1232,7 +1239,7 @@ module ActionController #:nodoc:
           log_processing_for_parameters
         end
       end
-      
+
       def log_processing_for_request_id
         request_id = "\n\nProcessing #{self.class.name}\##{action_name} "
         request_id << "to #{params[:format]} " if params[:format]
@@ -1244,7 +1251,7 @@ module ActionController #:nodoc:
       def log_processing_for_parameters
         parameters = respond_to?(:filter_parameters) ? filter_parameters(params) : params.dup
         parameters = parameters.except!(:controller, :action, :format, :_method)
-        
+
         logger.info "  Parameters: #{parameters.inspect}" unless parameters.empty?
       end
 
@@ -1343,9 +1350,12 @@ module ActionController #:nodoc:
   end
 
   Base.class_eval do
-    include Flash, Filters, Layout, Benchmarking, Rescue, MimeResponds, Helpers
-    include Cookies, Caching, Verification, Streaming
-    include SessionManagement, HttpAuthentication::Basic::ControllerMethods
-    include RecordIdentifier, RequestForgeryProtection, Translation
+    [ Filters, Layout, Benchmarking, Rescue, Flash, MimeResponds, Helpers,
+      Cookies, Caching, Verification, Streaming, SessionManagement,
+      HttpAuthentication::Basic::ControllerMethods, RecordIdentifier,
+      RequestForgeryProtection, Translation
+    ].each do |mod|
+      include mod
+    end
   end
 end
diff --git a/actionpack/lib/action_controller/dispatcher.rb b/actionpack/lib/action_controller/dispatcher.rb
index 4dc76e1b49..781bc48887 100644
--- a/actionpack/lib/action_controller/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatcher.rb
@@ -8,6 +8,8 @@ module ActionController
           # Development mode callbacks
           before_dispatch :reload_application
           after_dispatch :cleanup_application
+
+          ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
 
         if defined?(ActiveRecord)
@@ -60,11 +62,10 @@ module ActionController
     def dispatch
       begin
         run_callbacks :before_dispatch
-        controller = Routing::Routes.recognize(@request)
-        controller.process(@request, @response).to_a
+        Routing::Routes.call(@env)
       rescue Exception => exception
         if controller ||= (::ApplicationController rescue Base)
-          controller.process_with_exception(@request, @response, exception).to_a
+          controller.call_with_exception(@env, exception).to_a
         else
           raise exception
         end
@@ -83,8 +84,7 @@ module ActionController
     end
 
     def _call(env)
-      @request = Request.new(env)
-      @response = Response.new
+      @env = env
       dispatch
     end
 
@@ -93,7 +93,6 @@ module ActionController
       run_callbacks :prepare_dispatch
 
       Routing::Routes.reload
-      ActionView::Helpers::AssetTagHelper::AssetTag::Cache.clear
     end
 
     # Cleanup the application by clearing out loaded classes so they can
@@ -110,8 +109,7 @@ module ActionController
 
     def checkin_connections
       # Don't return connection (and peform implicit rollback) if this request is a part of integration test
-      # TODO: This callback should have direct access to env
-      return if @request.key?("rack.test")
+      return if @env.key?("rack.test")
       ActiveRecord::Base.clear_active_connections!
     end
   end
diff --git a/actionpack/lib/action_controller/http_authentication.rb b/actionpack/lib/action_controller/http_authentication.rb
index 2ed810db7d..3cb5829eca 100644
--- a/actionpack/lib/action_controller/http_authentication.rb
+++ b/actionpack/lib/action_controller/http_authentication.rb
@@ -55,7 +55,31 @@ module ActionController
     #       end
     #   end
     # 
-    # 
+    # Simple Digest example. Note the block must return the user's password so the framework 
+    # can appropriately hash it to check the user's credentials. Returning nil will cause authentication to fail. 
+    #  
+    #   class PostsController < ApplicationController 
+    #     Users = {"dhh" => "secret"} 
+    #    
+    #     before_filter :authenticate, :except => [ :index ] 
+    #    
+    #     def index 
+    #       render :text => "Everyone can see me!" 
+    #     end 
+    #    
+    #     def edit 
+    #       render :text => "I'm only accessible if you know the password" 
+    #     end 
+    #    
+    #     private 
+    #       def authenticate 
+    #         authenticate_or_request_with_http_digest(realm) do |user_name|  
+    #           Users[user_name] 
+    #         end 
+    #       end 
+    #   end
+    #
+    #
     # In your integration tests, you can do something like this:
     # 
     #   def test_access_granted_from_xml
@@ -108,7 +132,10 @@ module ActionController
       end
     
       def decode_credentials(request)
-        ActiveSupport::Base64.decode64(authorization(request).split.last || '')
+        # Properly decode credentials spanning a new-line
+        auth = authorization(request)
+        auth.slice!('Basic ')
+        ActiveSupport::Base64.decode64(auth || '')
       end
 
       def encode_credentials(user_name, password)
@@ -120,5 +147,165 @@ module ActionController
         controller.__send__ :render, :text => "HTTP Basic: Access denied.\n", :status => :unauthorized
       end
     end
+    
+    module Digest
+      extend self
+    
+      module ControllerMethods
+        def authenticate_or_request_with_http_digest(realm = "Application", &password_procedure)
+          begin 
+            authenticate_with_http_digest!(realm, &password_procedure)
+          rescue ActionController::HttpAuthentication::Error => e
+            msg = e.message
+            msg = "#{msg} expected '#{e.expected}' was '#{e.was}'" unless e.expected.nil?
+            raise msg if e.fatal?
+            request_http_digest_authentication(realm, msg)
+          end
+        end
+
+        # Authenticate using HTTP Digest, throwing ActionController::HttpAuthentication::Error on failure.
+        # This allows more detailed analysis of authentication failures
+        # to be relayed to the client.
+        def authenticate_with_http_digest!(realm = "Application", &login_procedure)
+            HttpAuthentication::Digest.authenticate(self, realm, &login_procedure)
+        end
+
+        # Authenticate with HTTP Digest, returns true or false
+        def authenticate_with_http_digest(realm = "Application", &login_procedure)
+          HttpAuthentication::Digest.authenticate(self, realm, &login_procedure) rescue false
+        end
+
+        # Render output including the HTTP Digest authentication header
+        def request_http_digest_authentication(realm = "Application", message = nil)
+          HttpAuthentication::Digest.authentication_request(self, realm, message)
+        end
+        
+        # Add HTTP Digest authentication header to result headers
+        def http_digest_authentication_header(realm = "Application")
+          HttpAuthentication::Digest.authentication_header(self, realm)
+        end
+      end
+
+      # Raises error unless authentictaion succeeds, returns true otherwise
+      def authenticate(controller, realm, &password_procedure)
+        raise Error.new(false), "No authorization header found" unless authorization(controller.request)
+        validate_digest_response(controller, realm, &password_procedure)
+        true
+      end
+
+      def authorization(request)
+        request.env['HTTP_AUTHORIZATION']   ||
+        request.env['X-HTTP_AUTHORIZATION'] ||
+        request.env['X_HTTP_AUTHORIZATION'] ||
+        request.env['REDIRECT_X_HTTP_AUTHORIZATION']
+      end
+
+      # Raises error unless the request credentials response value matches the expected value.
+      def validate_digest_response(controller, realm, &password_procedure) 
+        credentials = decode_credentials(controller.request) 
+
+        # Check the nonce, opaque and realm.
+        # Ignore nc, as we have no way to validate the number of times this nonce has been used
+        validate_nonce(controller.request, credentials[:nonce])
+        raise Error.new(false, realm, credentials[:realm]), "Realm doesn't match" unless realm == credentials[:realm]
+        raise Error.new(true, opaque(controller.request), credentials[:opaque]),"Opaque doesn't match" unless opaque(controller.request) == credentials[:opaque]
+
+        password = password_procedure.call(credentials[:username])
+        raise Error.new(false), "No password" if password.nil?
+        expected = expected_response(controller.request.env['REQUEST_METHOD'], controller.request.url, credentials, password)
+        raise Error.new(false, expected, credentials[:response]), "Invalid response" unless expected == credentials[:response]
+      end 
+
+      # Returns the expected response for a request of +http_method+ to +uri+ with the decoded +credentials+ and the expected +password+ 
+      def expected_response(http_method, uri, credentials, password) 
+        ha1 = ::Digest::MD5.hexdigest([credentials[:username], credentials[:realm], password].join(':')) 
+        ha2 = ::Digest::MD5.hexdigest([http_method.to_s.upcase,uri].join(':')) 
+        ::Digest::MD5.hexdigest([ha1,credentials[:nonce], credentials[:nc], credentials[:cnonce],credentials[:qop],ha2].join(':')) 
+      end  
+
+      def encode_credentials(http_method, credentials, password) 
+        credentials[:response] = expected_response(http_method, credentials[:uri], credentials, password) 
+        "Digest " + credentials.sort_by {|x| x[0].to_s }.inject([]) {|a, v| a << "#{v[0]}='#{v[1]}'" }.join(', ') 
+      end 
+
+      def decode_credentials(request) 
+        authorization(request).to_s.gsub(/^Digest\s+/,'').split(',').inject({}) do |hash, pair| 
+          key, value = pair.split('=', 2) 
+          hash[key.strip.to_sym] = value.to_s.gsub(/^"|"$/,'').gsub(/'/, '') 
+          hash 
+        end 
+      end 
+
+      def authentication_header(controller, realm)
+        controller.headers["WWW-Authenticate"] = %(Digest realm="#{realm}", qop="auth", algorithm=MD5, nonce="#{nonce(controller.request)}", opaque="#{opaque(controller.request)}") 
+      end
+
+      def authentication_request(controller, realm, message = "HTTP Digest: Access denied")
+        authentication_header(controller, realm)
+        controller.send! :render, :text => message, :status => :unauthorized
+      end
+
+      # Uses an MD5 digest based on time to generate a value to be used only once.
+      #
+      # A server-specified data string which should be uniquely generated each time a 401 response is made.
+      # It is recommended that this string be base64 or hexadecimal data.
+      # Specifically, since the string is passed in the header lines as a quoted string, the double-quote character is not allowed.
+      #
+      # The contents of the nonce are implementation dependent.
+      # The quality of the implementation depends on a good choice.
+      # A nonce might, for example, be constructed as the base 64 encoding of
+      #
+      # => time-stamp H(time-stamp ":" ETag ":" private-key)
+      #
+      # where time-stamp is a server-generated time or other non-repeating value,
+      # ETag is the value of the HTTP ETag header associated with the requested entity,
+      # and private-key is data known only to the server.
+      # With a nonce of this form a server would recalculate the hash portion after receiving the client authentication header and
+      # reject the request if it did not match the nonce from that header or
+      # if the time-stamp value is not recent enough. In this way the server can limit the time of the nonce's validity.
+      # The inclusion of the ETag prevents a replay request for an updated version of the resource.
+      # (Note: including the IP address of the client in the nonce would appear to offer the server the ability
+      # to limit the reuse of the nonce to the same client that originally got it.
+      # However, that would break proxy farms, where requests from a single user often go through different proxies in the farm.
+      # Also, IP address spoofing is not that hard.)
+      #
+      # An implementation might choose not to accept a previously used nonce or a previously used digest, in order to
+      # protect against a replay attack. Or, an implementation might choose to use one-time nonces or digests for
+      # POST or PUT requests and a time-stamp for GET requests. For more details on the issues involved see Section 4
+      # of this document.
+      #
+      # The nonce is opaque to the client.
+      def nonce(request, time = Time.now)
+        session_id = request.is_a?(String) ? request : request.session.session_id
+        t = time.to_i
+        hashed = [t, session_id]
+        digest = ::Digest::MD5.hexdigest(hashed.join(":"))
+        Base64.encode64("#{t}:#{digest}").gsub("\n", '')
+      end
+
+      def validate_nonce(request, value)
+        t = Base64.decode64(value).split(":").first.to_i
+        raise Error.new(true), "Stale Nonce" if (t - Time.now.to_i).abs > 10 * 60
+        n = nonce(request, t)
+        raise Error.new(true, value, n), "Bad Nonce" unless n == value
+      end
+
+      # Opaque based on digest of session_id
+      def opaque(request)
+        session_id = request.is_a?(String) ? request : request.session.session_id
+        @opaque ||= Base64.encode64(::Digest::MD5::hexdigest(session_id)).gsub("\n", '')
+      end
+    end
+
+    class Error < RuntimeError
+      attr_accessor :expected, :was
+      def initialize(fatal = false, expected = nil, was = nil)
+        @fatal = fatal
+        @expected = expected
+        @was = was
+      end
+
+      def fatal?; @fatal; end
+    end
   end
 end
diff --git a/actionpack/lib/action_controller/integration.rb b/actionpack/lib/action_controller/integration.rb
index 71e2524e81..ded72a71fb 100644
--- a/actionpack/lib/action_controller/integration.rb
+++ b/actionpack/lib/action_controller/integration.rb
@@ -68,12 +68,21 @@ module ActionController
       # A running counter of the number of requests processed.
       attr_accessor :request_count
 
+      # Nonce value for Digest Authentication, implicitly set on response with WWW-Authentication
+      attr_accessor :nonce
+
+      # Opaque value for Digest Authentication, implicitly set on response with WWW-Authentication
+      attr_accessor :opaque
+
+      # Opaque value for Authentication, implicitly set on response with WWW-Authentication
+      attr_accessor :realm
+
       class MultiPartNeededException < Exception
       end
 
       # Create and initialize a new Session instance.
-      def initialize(app)
-        @application = app
+      def initialize(app = nil)
+        @application = app || ActionController::Dispatcher.new
         reset!
       end
 
@@ -243,6 +252,53 @@ module ActionController
       end
       alias xhr :xml_http_request
 
+      def request_with_noauth(http_method, uri, parameters, headers) 
+        process_with_auth http_method, uri, parameters, headers
+      end 
+
+      # Performs a request with the given http_method and parameters, including HTTP Basic authorization headers. 
+      # See get() for more details on paramters and headers. 
+      # 
+      # You can perform GET, POST, PUT, DELETE, and HEAD requests with #get_with_basic, #post_with_basic, 
+      # #put_with_basic, #delete_with_basic, and #head_with_basic. 
+      def request_with_basic(http_method, uri, parameters, headers, user_name, password) 
+        process_with_auth http_method, uri, parameters, headers.merge(:authorization => ActionController::HttpAuthentication::Basic.encode_credentials(user_name, password)) 
+      end 
+
+      # Performs a request with the given http_method and parameters, including HTTP Digest authorization headers. 
+      # See get() for more details on paramters and headers. 
+      # 
+      # You can perform GET, POST, PUT, DELETE, and HEAD requests with #get_with_digest, #post_with_digest, 
+      # #put_with_digest, #delete_with_digest, and #head_with_digest. 
+      def request_with_digest(http_method, uri, parameters, headers, user_name, password) 
+        # Realm, Nonce, and Opaque taken from previoius 401 response
+        
+        credentials = {
+          :username => user_name,
+          :realm    => @realm,
+          :nonce    => @nonce,
+          :qop      => "auth",
+          :nc       => "00000001",
+          :cnonce   => "0a4f113b",
+          :opaque   => @opaque,
+          :uri      => uri
+        }
+        
+        raise "Digest request without previous 401 response" if @opaque.nil?
+ 
+        process_with_auth http_method, uri, parameters, headers.merge(:authorization => ActionController::HttpAuthentication::Digest.encode_credentials(http_method, credentials, password)) 
+      end 
+
+      # def get_with_basic, def post_with_basic, def put_with_basic, def delete_with_basic, def head_with_basic 
+      # def get_with_digest, def post_with_digest, def put_with_digest, def delete_with_digest, def head_with_digest 
+      [:get, :post, :put, :delete, :head].each do |method| 
+        [:noauth, :basic, :digest].each do |auth_type| 
+          define_method("#{method}_with_#{auth_type}") do |uri, parameters, headers, *auth| 
+            send("request_with_#{auth_type}", method, uri, parameters, headers, *auth) 
+          end 
+        end 
+      end
+
       # Returns the URL for the given options, according to the rules specified
       # in the application's routes.
       def url_for(options)
@@ -311,8 +367,10 @@ module ActionController
             env[key] = value
           end
 
-          unless ActionController::Base.respond_to?(:clear_last_instantiation!)
-            ActionController::Base.module_eval { include ControllerCapture }
+          [ControllerCapture, ActionController::ProcessWithTest].each do |mod|
+            unless ActionController::Base < mod
+              ActionController::Base.class_eval { include mod }
+            end
           end
 
           ActionController::Base.clear_last_instantiation!
@@ -340,6 +398,7 @@ module ActionController
           if @controller = ActionController::Base.last_instantiation
             @request = @controller.request
             @response = @controller.response
+            @controller.send(:set_test_assigns)
           else
             # Decorate responses from Rack Middleware and Rails Metal
             # as an Response for the purposes of integration testing
@@ -364,6 +423,32 @@ module ActionController
           return status
         end
 
+        # Same as process, but handles authentication returns to perform
+        # Basic or Digest authentication
+        def process_with_auth(method, path, parameters = nil, headers = nil)
+          status = process(method, path, parameters, headers)
+
+          if status == 401
+            # Extract authentication information from response
+            auth_data = @response.headers['WWW-Authenticate']
+            if /^Basic /.match(auth_data)
+              # extract realm, to be used in subsequent request
+              @realm = auth_header.split(' ')[1]
+            elsif /^Digest/.match(auth_data)
+              creds = auth_data.to_s.gsub(/^Digest\s+/,'').split(',').inject({}) do |hash, pair| 
+                key, value = pair.split('=', 2) 
+                hash[key.strip.to_sym] = value.to_s.gsub(/^"|"$/,'').gsub(/'/, '') 
+                hash 
+              end 
+              @realm = creds[:realm]
+              @nonce = creds[:nonce]
+              @opaque = creds[:opaque]
+            end
+          end
+
+          return status
+        end
+
         # Encode the cookies hash in a format suitable for passing to a
         # request.
         def encode_cookies
@@ -509,7 +594,6 @@ EOF
       # can use this method to open multiple sessions that ought to be tested
       # simultaneously.
       def open_session(application = nil)
-        application ||= ActionController::Dispatcher.new
         session = Integration::Session.new(application)
 
         # delegate the fixture accessors back to the test instance
diff --git a/actionpack/lib/action_controller/middleware_stack.rb b/actionpack/lib/action_controller/middleware_stack.rb
index 74f28565c0..2bccba2ba1 100644
--- a/actionpack/lib/action_controller/middleware_stack.rb
+++ b/actionpack/lib/action_controller/middleware_stack.rb
@@ -1,6 +1,14 @@
 module ActionController
   class MiddlewareStack < Array
     class Middleware
+      def self.new(klass, *args, &block)
+        if klass.is_a?(self)
+          klass
+        else
+          super
+        end
+      end
+
       attr_reader :args, :block
 
       def initialize(klass, *args, &block)
@@ -65,6 +73,19 @@ module ActionController
       block.call(self) if block_given?
     end
 
+    def insert(index, *objs)
+      index = self.index(index) unless index.is_a?(Integer)
+      objs = objs.map { |obj| Middleware.new(obj) }
+      super(index, *objs)
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *objs)
+      index = self.index(index) unless index.is_a?(Integer)
+      insert(index + 1, *objs)
+    end
+
     def use(*args, &block)
       middleware = Middleware.new(*args, &block)
       push(middleware)
diff --git a/actionpack/lib/action_controller/request.rb b/actionpack/lib/action_controller/request.rb
index ab028b9eb2..3d13705f8f 100755
--- a/actionpack/lib/action_controller/request.rb
+++ b/actionpack/lib/action_controller/request.rb
@@ -6,24 +6,17 @@ require 'active_support/memoizable'
 require 'action_controller/cgi_ext'
 
 module ActionController
-  # CgiRequest and TestRequest provide concrete implementations.
-  class Request
+  class Request < Rack::Request
     extend ActiveSupport::Memoizable
 
-    class SessionFixationAttempt < StandardError #:nodoc:
-    end
-
-    # The hash of environment variables for this request,
-    # such as { 'RAILS_ENV' => 'production' }.
-    attr_reader :env
-
     def initialize(env)
-      @env = env
+      super
+      @parser = ActionController::RequestParser.new(env)
     end
 
-    %w[ AUTH_TYPE GATEWAY_INTERFACE PATH_INFO
+    %w[ AUTH_TYPE GATEWAY_INTERFACE
         PATH_TRANSLATED REMOTE_HOST
-        REMOTE_IDENT REMOTE_USER SCRIPT_NAME
+        REMOTE_IDENT REMOTE_USER REMOTE_ADDR
         SERVER_NAME SERVER_PROTOCOL
 
         HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
@@ -45,8 +38,7 @@ module ActionController
     # <tt>:get</tt>. If the request \method is not listed in the HTTP_METHODS
     # constant above, an UnknownHttpMethod exception is raised.
     def request_method
-      method = @env['REQUEST_METHOD']
-      HTTP_METHOD_LOOKUP[method] || raise(UnknownHttpMethod, "#{method}, accepted HTTP methods are #{HTTP_METHODS.to_sentence}")
+      HTTP_METHOD_LOOKUP[super] || raise(UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence}")
     end
     memoize :request_method
 
@@ -94,16 +86,15 @@ module ActionController
 
     # Returns the content length of the request as an integer.
     def content_length
-      @env['CONTENT_LENGTH'].to_i
+      super.to_i
     end
-    memoize :content_length
 
     # The MIME type of the HTTP request, such as Mime::XML.
     #
     # For backward compatibility, the post \format is extracted from the
     # X-Post-Data-Format HTTP header if present.
     def content_type
-      Mime::Type.lookup(parser.content_type_without_parameters)
+      Mime::Type.lookup(@parser.content_type_without_parameters)
     end
     memoize :content_type
 
@@ -391,16 +382,17 @@ EOM
     # Read the request \body. This is useful for web services that need to
     # work with raw requests directly.
     def raw_post
-      parser.raw_post
+      @parser.raw_post
     end
 
     # Returns both GET and POST \parameters in a single hash.
     def parameters
       @parameters ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
     end
+    alias_method :params, :parameters
 
     def path_parameters=(parameters) #:nodoc:
-      @path_parameters = parameters
+      @env["rack.routing_args"] = parameters
       @symbolized_path_parameters = @parameters = nil
     end
 
@@ -416,44 +408,35 @@ EOM
     #
     # See <tt>symbolized_path_parameters</tt> for symbolized keys.
     def path_parameters
-      @path_parameters ||= {}
+      @env["rack.routing_args"] ||= {}
     end
 
     def body
-      parser.body
-    end
-
-    def remote_addr
-      @env['REMOTE_ADDR']
+      @parser.body
     end
 
-    def referrer
-      @env['HTTP_REFERER']
+    # Override Rack's GET method to support nested query strings
+    def GET
+      @parser.query_parameters
     end
-    alias referer referrer
+    alias_method :query_parameters, :GET
 
-    def query_parameters
-      @query_parameters ||= parser.query_parameters
-    end
-
-    def request_parameters
-      @request_parameters ||= parser.request_parameters
+    # Override Rack's POST method to support nested query strings
+    def POST
+      @parser.request_parameters
     end
+    alias_method :request_parameters, :POST
 
     def body_stream #:nodoc:
       @env['rack.input']
     end
 
-    def cookies
-      Rack::Request.new(@env).cookies
-    end
-
     def session
       @env['rack.session'] ||= {}
     end
 
     def session=(session) #:nodoc:
-      @session = session
+      @env['rack.session'] = session
     end
 
     def reset_session
@@ -476,9 +459,5 @@ EOM
       def named_host?(host)
         !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
       end
-
-      def parser
-        @parser ||= ActionController::RequestParser.new(@env)
-      end
   end
 end
diff --git a/actionpack/lib/action_controller/request_parser.rb b/actionpack/lib/action_controller/request_parser.rb
index 82ee4c84c4..d1739ef4d0 100644
--- a/actionpack/lib/action_controller/request_parser.rb
+++ b/actionpack/lib/action_controller/request_parser.rb
@@ -2,14 +2,15 @@ module ActionController
   class RequestParser
     def initialize(env)
       @env = env
+      freeze
     end
 
     def request_parameters
-      @request_parameters ||= parse_formatted_request_parameters
+      @env["action_controller.request_parser.request_parameters"] ||= parse_formatted_request_parameters
     end
 
     def query_parameters
-      @query_parameters ||= self.class.parse_query_parameters(query_string)
+      @env["action_controller.request_parser.query_parameters"] ||= self.class.parse_query_parameters(query_string)
     end
 
     # Returns the query string, accounting for server idiosyncrasies.
@@ -90,7 +91,7 @@ module ActionController
     end
 
     def content_length
-      @content_length ||= @env['CONTENT_LENGTH'].to_i
+      @env['CONTENT_LENGTH'].to_i
     end
 
     # The raw content type string. Use when you need parameters such as
diff --git a/actionpack/lib/action_controller/rescue.rb b/actionpack/lib/action_controller/rescue.rb
index 5ef79a36ce..4b7d1e32fd 100644
--- a/actionpack/lib/action_controller/rescue.rb
+++ b/actionpack/lib/action_controller/rescue.rb
@@ -38,8 +38,8 @@ module ActionController #:nodoc:
       'ActionView::TemplateError'         => 'template_error'
     }
 
-    RESCUES_TEMPLATE_PATH = ActionView::PathSet::Path.new(
-      File.join(File.dirname(__FILE__), "templates"), true)
+    RESCUES_TEMPLATE_PATH = ActionView::Template::EagerPath.new(
+      File.join(File.dirname(__FILE__), "templates"))
 
     def self.included(base) #:nodoc:
       base.cattr_accessor :rescue_responses
@@ -59,7 +59,9 @@ module ActionController #:nodoc:
     end
 
     module ClassMethods
-      def process_with_exception(request, response, exception) #:nodoc:
+      def call_with_exception(env, exception) #:nodoc:
+        request = env["action_controller.rescue.request"] ||= Request.new(env)
+        response = env["action_controller.rescue.response"] ||= Response.new
         new.process(request, response, :rescue_action, exception)
       end
     end
diff --git a/actionpack/lib/action_controller/response.rb b/actionpack/lib/action_controller/response.rb
index 64319fe102..27860a6207 100644
--- a/actionpack/lib/action_controller/response.rb
+++ b/actionpack/lib/action_controller/response.rb
@@ -231,10 +231,13 @@ module ActionController # :nodoc:
       # Don't set the Content-Length for block-based bodies as that would mean
       # reading it all into memory. Not nice for, say, a 2GB streaming file.
       def set_content_length!
-        unless body.respond_to?(:call) || (status && status.to_s[0..2] == '304')
-          self.headers["Content-Length"] ||= body.size
+        if status && status.to_s[0..2] == '204'
+          headers.delete('Content-Length')
+        elsif length = headers['Content-Length']
+          headers['Content-Length'] = length.to_s
+        elsif !body.respond_to?(:call) && (!status || status.to_s[0..2] != '304')
+          headers["Content-Length"] = body.size.to_s
         end
-        headers["Content-Length"] = headers["Content-Length"].to_s if headers["Content-Length"]
       end
 
       def convert_language!
diff --git a/actionpack/lib/action_controller/routing/route_set.rb b/actionpack/lib/action_controller/routing/route_set.rb
index 5975977365..044ace7de1 100644
--- a/actionpack/lib/action_controller/routing/route_set.rb
+++ b/actionpack/lib/action_controller/routing/route_set.rb
@@ -195,8 +195,8 @@ module ActionController
               def formatted_#{selector}(*args)                                              # def formatted_users_url(*args)
                 ActiveSupport::Deprecation.warn(                                            #   ActiveSupport::Deprecation.warn(
                   "formatted_#{selector}() has been deprecated. " +                         #     "formatted_users_url() has been deprecated. " +
-                  "please pass format to the standard" +                                    #     "please pass format to the standard" +
-                  "#{selector}() method instead.", caller)                                  #     "users_url() method instead.", caller)
+                  "Please pass format to the standard " +                                   #     "Please pass format to the standard " +
+                  "#{selector} method instead.", caller)                                    #     "users_url method instead.", caller)
                 #{selector}(*args)                                                          #   users_url(*args)
               end                                                                           # end
               protected :#{selector}                                                        # protected :users_url
@@ -427,6 +427,12 @@ module ActionController
         end
       end
 
+      def call(env)
+        request = Request.new(env)
+        app = Routing::Routes.recognize(request)
+        app.call(env).to_a
+      end
+
       def recognize(request)
         params = recognize_path(request.path, extract_request_environment(request))
         request.path_parameters = params.with_indifferent_access
diff --git a/actionpack/lib/action_controller/test_case.rb b/actionpack/lib/action_controller/test_case.rb
index 7ed1a3e160..0b0d0c799b 100644
--- a/actionpack/lib/action_controller/test_case.rb
+++ b/actionpack/lib/action_controller/test_case.rb
@@ -1,4 +1,5 @@
 require 'active_support/test_case'
+require 'action_controller/test_process'
 
 module ActionController
   # Superclass for ActionController functional tests. Functional tests allow you to
@@ -102,6 +103,8 @@ module ActionController
   #
   #  assert_redirected_to page_url(:title => 'foo')
   class TestCase < ActiveSupport::TestCase
+    include TestProcess
+
     module Assertions
       %w(response selector tag dom routing model).each do |kind|
         include ActionController::Assertions.const_get("#{kind.camelize}Assertions")
@@ -124,17 +127,18 @@ module ActionController
     #
     # The exception is stored in the exception accessor for further inspection.
     module RaiseActionExceptions
-      attr_accessor :exception
+      protected
+        attr_accessor :exception
 
-      def rescue_action_without_handler(e)
-        self.exception = e
-        
-        if request.remote_addr == "0.0.0.0"
-          raise(e)
-        else
-          super(e)
+        def rescue_action_without_handler(e)
+          self.exception = e
+
+          if request.remote_addr == "0.0.0.0"
+            raise(e)
+          else
+            super(e)
+          end
         end
-      end
     end
 
     setup :setup_controller_request_and_response
diff --git a/actionpack/lib/action_controller/test_process.rb b/actionpack/lib/action_controller/test_process.rb
index 285a8b09e4..8180d4ee93 100644
--- a/actionpack/lib/action_controller/test_process.rb
+++ b/actionpack/lib/action_controller/test_process.rb
@@ -1,32 +1,4 @@
-require 'action_controller/test_case'
-
 module ActionController #:nodoc:
-  class Base
-    attr_reader :assigns
-
-    # Process a test request called with a TestRequest object.
-    def self.process_test(request)
-      new.process_test(request)
-    end
-
-    def process_test(request) #:nodoc:
-      process(request, TestResponse.new)
-    end
-
-    def process_with_test(*args)
-      returning process_without_test(*args) do
-        @assigns = {}
-        (instance_variable_names - @@protected_instance_variables).each do |var|
-          value = instance_variable_get(var)
-          @assigns[var[1..-1]] = value
-          response.template.assigns[var[1..-1]] = value if response
-        end
-      end
-    end
-
-    alias_method_chain :process, :test
-  end
-
   class TestRequest < Request #:nodoc:
     attr_accessor :cookies, :session_options
     attr_accessor :query_parameters, :path, :session
@@ -433,7 +405,9 @@ module ActionController #:nodoc:
       @request.session = ActionController::TestSession.new(session) unless session.nil?
       @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
       build_request_uri(action, parameters)
-      @controller.process(@request, @response)
+
+      Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
+      @controller.process_with_test(@request, @response)
     end
 
     def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
@@ -545,12 +519,24 @@ module ActionController #:nodoc:
       ActionController::Routing.const_set(:Routes, real_routes) if real_routes
     end
   end
-end
 
-module Test
-  module Unit
-    class TestCase #:nodoc:
-      include ActionController::TestProcess
+  module ProcessWithTest #:nodoc:
+    def self.included(base)
+      base.class_eval { attr_reader :assigns }
+    end
+
+    def process_with_test(*args)
+      process(*args).tap { set_test_assigns }
     end
+
+    private
+      def set_test_assigns
+        @assigns = {}
+        (instance_variable_names - self.class.protected_instance_variables).each do |var|
+          name, value = var[1..-1], instance_variable_get(var)
+          @assigns[name] = value
+          response.template.assigns[name] = value if response
+        end
+      end
   end
 end
diff --git a/actionpack/lib/action_controller/url_encoded_pair_parser.rb b/actionpack/lib/action_controller/url_encoded_pair_parser.rb
index bea96c711d..9883ad0d85 100644
--- a/actionpack/lib/action_controller/url_encoded_pair_parser.rb
+++ b/actionpack/lib/action_controller/url_encoded_pair_parser.rb
@@ -70,11 +70,12 @@ module ActionController
               top[-1][key] = value
             else
               top << {key => value}.with_indifferent_access
-              push top.last
-              value = top[key]
             end
+            push top.last
+            return top[key]
           else
             top << value
+            return value
           end
         elsif top.is_a? Hash
           key = CGI.unescape(key)
@@ -84,12 +85,10 @@ module ActionController
         else
           raise ArgumentError, "Don't know what to do: top is #{top.inspect}"
         end
-
-        return value
       end
 
       def type_conflict!(klass, value)
         raise TypeError, "Conflicting types for parameter containers. Expected an instance of #{klass} but found an instance of #{value.class}. This can be caused by colliding Array and Hash parameters like qs[]=value&qs[key]=value. (The parameters received were #{value.inspect}.)"
       end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index 8958e61e9d..70a0ba91a7 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -225,7 +225,7 @@ module ActionView #:nodoc:
     end
 
     # Returns the result of a render that's dictated by the options hash. The primary options are:
-    # 
+    #
     # * <tt>:partial</tt> - See ActionView::Partials.
     # * <tt>:update</tt> - Calls update_page with the block given.
     # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
diff --git a/actionpack/lib/action_view/helpers/asset_tag_helper.rb b/actionpack/lib/action_view/helpers/asset_tag_helper.rb
index e595c534dd..7e1110afab 100644
--- a/actionpack/lib/action_view/helpers/asset_tag_helper.rb
+++ b/actionpack/lib/action_view/helpers/asset_tag_helper.rb
@@ -157,7 +157,7 @@ module ActionView
       #   javascript_path "http://www.railsapplication.com/js/xmlhr" # => http://www.railsapplication.com/js/xmlhr.js
       #   javascript_path "http://www.railsapplication.com/js/xmlhr.js" # => http://www.railsapplication.com/js/xmlhr.js
       def javascript_path(source)
-        JavaScriptTag.new(self, @controller, source).public_path
+        compute_public_path(source, 'javascripts', 'js')
       end
       alias_method :path_to_javascript, :javascript_path # aliased to avoid conflicts with a javascript_path named route
 
@@ -255,17 +255,15 @@ module ActionView
           joined_javascript_name = (cache == true ? "all" : cache) + ".js"
           joined_javascript_path = File.join(JAVASCRIPTS_DIR, joined_javascript_name)
 
-          unless File.exists?(joined_javascript_path)
-            JavaScriptSources.create(self, @controller, sources, recursive).write_asset_file_contents(joined_javascript_path)
-          end
+          write_asset_file_contents(joined_javascript_path, compute_javascript_paths(sources, recursive)) unless File.exists?(joined_javascript_path)
           javascript_src_tag(joined_javascript_name, options)
         else
-          JavaScriptSources.create(self, @controller, sources, recursive).expand_sources.collect { |source|
-            javascript_src_tag(source, options)
-          }.join("\n")
+          expand_javascript_sources(sources, recursive).collect { |source| javascript_src_tag(source, options) }.join("\n")
         end
       end
 
+      @@javascript_expansions = { :defaults => JAVASCRIPT_DEFAULT_SOURCES.dup }
+
       # Register one or more javascript files to be included when <tt>symbol</tt>
       # is passed to <tt>javascript_include_tag</tt>. This method is typically intended
       # to be called from plugin initialization to register javascript files
@@ -278,9 +276,11 @@ module ActionView
       #     <script type="text/javascript" src="/javascripts/body.js"></script>
       #     <script type="text/javascript" src="/javascripts/tail.js"></script>
       def self.register_javascript_expansion(expansions)
-        JavaScriptSources.expansions.merge!(expansions)
+        @@javascript_expansions.merge!(expansions)
       end
 
+      @@stylesheet_expansions = {}
+
       # Register one or more stylesheet files to be included when <tt>symbol</tt>
       # is passed to <tt>stylesheet_link_tag</tt>. This method is typically intended
       # to be called from plugin initialization to register stylesheet files
@@ -293,7 +293,7 @@ module ActionView
       #     <link href="/stylesheets/body.css"  media="screen" rel="stylesheet" type="text/css" />
       #     <link href="/stylesheets/tail.css"  media="screen" rel="stylesheet" type="text/css" />
       def self.register_stylesheet_expansion(expansions)
-        StylesheetSources.expansions.merge!(expansions)
+        @@stylesheet_expansions.merge!(expansions)
       end
 
       # Register one or more additional JavaScript files to be included when
@@ -301,11 +301,11 @@ module ActionView
       # typically intended to be called from plugin initialization to register additional
       # .js files that the plugin installed in <tt>public/javascripts</tt>.
       def self.register_javascript_include_default(*sources)
-        JavaScriptSources.expansions[:defaults].concat(sources)
+        @@javascript_expansions[:defaults].concat(sources)
       end
 
       def self.reset_javascript_include_default #:nodoc:
-        JavaScriptSources.expansions[:defaults] = JAVASCRIPT_DEFAULT_SOURCES.dup
+        @@javascript_expansions[:defaults] = JAVASCRIPT_DEFAULT_SOURCES.dup
       end
 
       # Computes the path to a stylesheet asset in the public stylesheets directory.
@@ -320,7 +320,7 @@ module ActionView
       #   stylesheet_path "http://www.railsapplication.com/css/style" # => http://www.railsapplication.com/css/style.css
       #   stylesheet_path "http://www.railsapplication.com/css/style.js" # => http://www.railsapplication.com/css/style.css
       def stylesheet_path(source)
-        StylesheetTag.new(self, @controller, source).public_path
+        compute_public_path(source, 'stylesheets', 'css')
       end
       alias_method :path_to_stylesheet, :stylesheet_path # aliased to avoid conflicts with a stylesheet_path named route
 
@@ -365,7 +365,6 @@ module ActionView
       # compressed by gzip (leading to faster transfers). Caching will only happen if ActionController::Base.perform_caching
       # is set to true (which is the case by default for the Rails production environment, but not for the development
       # environment). Examples:
-      
       #
       # ==== Examples
       #   stylesheet_link_tag :all, :cache => true # when ActionController::Base.perform_caching is false =>
@@ -396,14 +395,10 @@ module ActionView
           joined_stylesheet_name = (cache == true ? "all" : cache) + ".css"
           joined_stylesheet_path = File.join(STYLESHEETS_DIR, joined_stylesheet_name)
 
-          unless File.exists?(joined_stylesheet_path)
-            StylesheetSources.create(self, @controller, sources, recursive).write_asset_file_contents(joined_stylesheet_path)
-          end
+          write_asset_file_contents(joined_stylesheet_path, compute_stylesheet_paths(sources, recursive)) unless File.exists?(joined_stylesheet_path)
           stylesheet_tag(joined_stylesheet_name, options)
         else
-          StylesheetSources.create(self, @controller, sources, recursive).expand_sources.collect { |source|
-            stylesheet_tag(source, options)
-          }.join("\n")
+          expand_stylesheet_sources(sources, recursive).collect { |source| stylesheet_tag(source, options) }.join("\n")
         end
       end
 
@@ -418,7 +413,7 @@ module ActionView
       #   image_path("/icons/edit.png")                              # => /icons/edit.png
       #   image_path("http://www.railsapplication.com/img/edit.png") # => http://www.railsapplication.com/img/edit.png
       def image_path(source)
-        ImageTag.new(self, @controller, source).public_path
+        compute_public_path(source, 'images')
       end
       alias_method :path_to_image, :image_path # aliased to avoid conflicts with an image_path named route
 
@@ -473,353 +468,190 @@ module ActionView
         tag("img", options)
       end
 
-      private
-        def javascript_src_tag(source, options)
-          content_tag("script", "", { "type" => Mime::JS, "src" => path_to_javascript(source) }.merge(options))
-        end
-
-        def stylesheet_tag(source, options)
-          tag("link", { "rel" => "stylesheet", "type" => Mime::CSS, "media" => "screen", "href" => html_escape(path_to_stylesheet(source)) }.merge(options), false, false)
-        end
-
-        module ImageAsset
-          DIRECTORY = 'images'.freeze
-
-          def directory
-            DIRECTORY
-          end
-
-          def extension
-            nil
-          end
-        end
-
-        module JavaScriptAsset
-          DIRECTORY = 'javascripts'.freeze
-          EXTENSION = 'js'.freeze
-
-          def public_directory
-            JAVASCRIPTS_DIR
-          end
-
-          def directory
-            DIRECTORY
-          end
+      def self.cache_asset_timestamps
+        @@cache_asset_timestamps
+      end
 
-          def extension
-            EXTENSION
-          end
-        end
+      # You can enable or disable the asset tag timestamps cache.
+      # With the cache enabled, the asset tag helper methods will make fewer
+      # expense file system calls. However this prevents you from modifying
+      # any asset files while the server is running.
+      #
+      #   ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
+      def self.cache_asset_timestamps=(value)
+        @@cache_asset_timestamps = value
+      end
 
-        module StylesheetAsset
-          DIRECTORY = 'stylesheets'.freeze
-          EXTENSION = 'css'.freeze
+      @@cache_asset_timestamps = true
 
-          def public_directory
-            STYLESHEETS_DIR
+      private
+        # Add the the extension +ext+ if not present. Return full URLs otherwise untouched.
+        # Prefix with <tt>/dir/</tt> if lacking a leading +/+. Account for relative URL
+        # roots. Rewrite the asset path for cache-busting asset ids. Include
+        # asset host, if configured, with the correct request protocol.
+        def compute_public_path(source, dir, ext = nil, include_host = true)
+          has_request = @controller.respond_to?(:request)
+
+          if ext && (File.extname(source).blank? || File.exist?(File.join(ASSETS_DIR, dir, "#{source}.#{ext}")))
+            source += ".#{ext}"
           end
 
-          def directory
-            DIRECTORY
-          end
+          unless source =~ %r{^[-a-z]+://}
+            source = "/#{dir}/#{source}" unless source[0] == ?/
 
-          def extension
-            EXTENSION
-          end
-        end
+            source = rewrite_asset_path(source)
 
-        class AssetTag
-          extend ActiveSupport::Memoizable
-
-          Cache = {}
-          CacheGuard = Mutex.new
-
-          ProtocolRegexp = %r{^[-a-z]+://}.freeze
-
-          def initialize(template, controller, source, include_host = true)
-            # NOTE: The template arg is temporarily needed for a legacy plugin
-            # hook that is expected to call rewrite_asset_path on the
-            # template. This should eventually be removed.
-            @template = template
-            @controller = controller
-            @source = source
-            @include_host = include_host
-            @cache_key = if controller.respond_to?(:request)
-              [self.class.name,controller.request.protocol,
-               ActionController::Base.asset_host,
-               ActionController::Base.relative_url_root,
-               source, include_host]
-            else
-              [self.class.name,ActionController::Base.asset_host, source, include_host]
+            if has_request && include_host
+              unless source =~ %r{^#{ActionController::Base.relative_url_root}/}
+                source = "#{ActionController::Base.relative_url_root}#{source}"
+              end
             end
           end
-          
-          def public_path
-            compute_public_path(@source)
-          end
-          memoize :public_path
 
-          def asset_file_path
-            File.join(ASSETS_DIR, public_path.split('?').first)
-          end
-          memoize :asset_file_path
-
-          def contents
-            File.read(asset_file_path)
-          end
-
-          def mtime
-            File.mtime(asset_file_path)
-          end
-
-          private
-            def request
-              request? && @controller.request
-            end
+          if include_host && source !~ %r{^[-a-z]+://}
+            host = compute_asset_host(source)
 
-            def request?
-              @controller.respond_to?(:request)
+            if has_request && !host.blank? && host !~ %r{^[-a-z]+://}
+              host = "#{@controller.request.protocol}#{host}"
             end
 
-            # Add the the extension +ext+ if not present. Return full URLs otherwise untouched.
-            # Prefix with <tt>/dir/</tt> if lacking a leading +/+. Account for relative URL
-            # roots. Rewrite the asset path for cache-busting asset ids. Include
-            # asset host, if configured, with the correct request protocol.
-            def compute_public_path(source)
-              if source =~ ProtocolRegexp
-                source += ".#{extension}" if missing_extension?(source)
-                source = prepend_asset_host(source)
-                source
-              else
-                CacheGuard.synchronize do
-                  Cache[@cache_key + [source]] ||= begin
-                    source += ".#{extension}" if missing_extension?(source) || file_exists_with_extension?(source)
-                    source = "/#{directory}/#{source}" unless source[0] == ?/
-                    source = rewrite_asset_path(source)
-                    source = prepend_relative_url_root(source)                
-                    source = prepend_asset_host(source)
-                    source
-                  end
-                end
-              end
-            end
-            
-            def missing_extension?(source)
-              extension && File.extname(source).blank?
-            end
-            
-            def file_exists_with_extension?(source)
-              extension && File.exist?(File.join(ASSETS_DIR, directory, "#{source}.#{extension}"))
-            end
-            
-            def prepend_relative_url_root(source)
-              relative_url_root = ActionController::Base.relative_url_root
-              if request? && @include_host && source !~ %r{^#{relative_url_root}/}
-                "#{relative_url_root}#{source}"
-              else
-                source
-              end
-            end
+            "#{host}#{source}"
+          else
+            source
+          end
+        end
 
-            def prepend_asset_host(source)
-              if @include_host && source !~ ProtocolRegexp
-                host = compute_asset_host(source)
-                if request? && !host.blank? && host !~ ProtocolRegexp
-                  host = "#{request.protocol}#{host}"
-                end
-                "#{host}#{source}"
+        # Pick an asset host for this source. Returns +nil+ if no host is set,
+        # the host if no wildcard is set, the host interpolated with the
+        # numbers 0-3 if it contains <tt>%d</tt> (the number is the source hash mod 4),
+        # or the value returned from invoking the proc if it's a proc or the value from
+        # invoking call if it's an object responding to call.
+        def compute_asset_host(source)
+          if host = ActionController::Base.asset_host
+            if host.is_a?(Proc) || host.respond_to?(:call)
+              case host.is_a?(Proc) ? host.arity : host.method(:call).arity
+              when 2
+                request = @controller.respond_to?(:request) && @controller.request
+                host.call(source, request)
               else
-                source
-              end
-            end
-
-            # Pick an asset host for this source. Returns +nil+ if no host is set,
-            # the host if no wildcard is set, the host interpolated with the
-            # numbers 0-3 if it contains <tt>%d</tt> (the number is the source hash mod 4),
-            # or the value returned from invoking the proc if it's a proc or the value from
-            # invoking call if it's an object responding to call.
-            def compute_asset_host(source)
-              if host = ActionController::Base.asset_host
-                if host.is_a?(Proc) || host.respond_to?(:call)
-                  case host.is_a?(Proc) ? host.arity : host.method(:call).arity
-                  when 2
-                    host.call(source, request)
-                  else
-                    host.call(source)
-                  end
-                else
-                  (host =~ /%d/) ? host % (source.hash % 4) : host
-                end
+                host.call(source)
               end
+            else
+              (host =~ /%d/) ? host % (source.hash % 4) : host
             end
+          end
+        end
 
-            # Use the RAILS_ASSET_ID environment variable or the source's
-            # modification time as its cache-busting asset id.
-            def rails_asset_id(source)
-              if asset_id = ENV["RAILS_ASSET_ID"]
-                asset_id
-              else
-                path = File.join(ASSETS_DIR, source)
+        @@asset_timestamps_cache = {}
+        @@asset_timestamps_cache_guard = Mutex.new
+
+        # Use the RAILS_ASSET_ID environment variable or the source's
+        # modification time as its cache-busting asset id.
+        def rails_asset_id(source)
+          if asset_id = ENV["RAILS_ASSET_ID"]
+            asset_id
+          else
+            if @@cache_asset_timestamps && (asset_id = @@asset_timestamps_cache[source])
+              asset_id
+            else
+              path = File.join(ASSETS_DIR, source)
+              asset_id = File.exist?(path) ? File.mtime(path).to_i.to_s : ''
 
-                if File.exist?(path)
-                  File.mtime(path).to_i.to_s
-                else
-                  ''
+              if @@cache_asset_timestamps
+                @@asset_timestamps_cache_guard.synchronize do
+                  @@asset_timestamps_cache[source] = asset_id
                 end
               end
-            end
 
-            # Break out the asset path rewrite in case plugins wish to put the asset id
-            # someplace other than the query string.
-            def rewrite_asset_path(source)
-              if @template.respond_to?(:rewrite_asset_path)
-                # DEPRECATE: This way to override rewrite_asset_path
-                @template.send(:rewrite_asset_path, source)
-              else
-                asset_id = rails_asset_id(source)
-                if asset_id.blank?
-                  source
-                else
-                  "#{source}?#{asset_id}"
-                end
-              end
+              asset_id
             end
+          end
         end
 
-        class ImageTag < AssetTag
-          include ImageAsset
+        # Break out the asset path rewrite in case plugins wish to put the asset id
+        # someplace other than the query string.
+        def rewrite_asset_path(source)
+          asset_id = rails_asset_id(source)
+          if asset_id.blank?
+            source
+          else
+            source + "?#{asset_id}"
+          end
         end
 
-        class JavaScriptTag < AssetTag
-          include JavaScriptAsset
+        def javascript_src_tag(source, options)
+          content_tag("script", "", { "type" => Mime::JS, "src" => path_to_javascript(source) }.merge(options))
         end
 
-        class StylesheetTag < AssetTag
-          include StylesheetAsset
+        def stylesheet_tag(source, options)
+          tag("link", { "rel" => "stylesheet", "type" => Mime::CSS, "media" => "screen", "href" => html_escape(path_to_stylesheet(source)) }.merge(options), false, false)
         end
 
-        class AssetCollection
-          extend ActiveSupport::Memoizable
-
-          Cache = {}
-          CacheGuard = Mutex.new
-
-          def self.create(template, controller, sources, recursive)
-            CacheGuard.synchronize do
-              key = [self, sources, recursive]
-              Cache[key] ||= new(template, controller, sources, recursive).freeze
-            end
-          end
+        def compute_javascript_paths(*args)
+          expand_javascript_sources(*args).collect { |source| compute_public_path(source, 'javascripts', 'js', false) }
+        end
 
-          def initialize(template, controller, sources, recursive)
-            # NOTE: The template arg is temporarily needed for a legacy plugin
-            # hook. See NOTE under AssetTag#initialize for more details
-            @template = template
-            @controller = controller
-            @sources = sources
-            @recursive = recursive
-          end
+        def compute_stylesheet_paths(*args)
+          expand_stylesheet_sources(*args).collect { |source| compute_public_path(source, 'stylesheets', 'css', false) }
+        end
 
-          def write_asset_file_contents(joined_asset_path)
-            FileUtils.mkdir_p(File.dirname(joined_asset_path))
-            File.open(joined_asset_path, "w+") { |cache| cache.write(joined_contents) }
-            mt = latest_mtime
-            File.utime(mt, mt, joined_asset_path)
+        def expand_javascript_sources(sources, recursive = false)
+          if sources.include?(:all)
+            all_javascript_files = collect_asset_files(JAVASCRIPTS_DIR, ('**' if recursive), '*.js')
+            ((determine_source(:defaults, @@javascript_expansions).dup & all_javascript_files) + all_javascript_files).uniq
+          else
+            expanded_sources = sources.collect do |source|
+              determine_source(source, @@javascript_expansions)
+            end.flatten
+            expanded_sources << "application" if sources.include?(:defaults) && File.exist?(File.join(JAVASCRIPTS_DIR, "application.js"))
+            expanded_sources
           end
-
-          private
-            def determine_source(source, collection)
-              case source
-              when Symbol
-                collection[source] || raise(ArgumentError, "No expansion found for #{source.inspect}")
-              else
-                source
-              end
-            end
-
-            def validate_sources!
-              @sources.collect { |source| determine_source(source, self.class.expansions) }.flatten
-            end
-
-            def all_asset_files
-              path = [public_directory, ('**' if @recursive), "*.#{extension}"].compact
-              Dir[File.join(*path)].collect { |file|
-                file[-(file.size - public_directory.size - 1)..-1].sub(/\.\w+$/, '')
-              }.sort
-            end
-
-            def tag_sources
-              expand_sources.collect { |source| tag_class.new(@template, @controller, source, false) }
-            end
-
-            def joined_contents
-              tag_sources.collect { |source| source.contents }.join("\n\n")
-            end
-
-            # Set mtime to the latest of the combined files to allow for
-            # consistent ETag without a shared filesystem.
-            def latest_mtime
-              tag_sources.map { |source| source.mtime }.max
-            end
         end
 
-        class JavaScriptSources < AssetCollection
-          include JavaScriptAsset
-
-          EXPANSIONS = { :defaults => JAVASCRIPT_DEFAULT_SOURCES.dup }
-
-          def self.expansions
-            EXPANSIONS
+        def expand_stylesheet_sources(sources, recursive)
+          if sources.first == :all
+            collect_asset_files(STYLESHEETS_DIR, ('**' if recursive), '*.css')
+          else
+            sources.collect do |source|
+              determine_source(source, @@stylesheet_expansions)
+            end.flatten
           end
+        end
 
-          APPLICATION_JS = "application".freeze
-          APPLICATION_FILE = "application.js".freeze
-
-          def expand_sources
-            if @sources.include?(:all)
-              assets = all_asset_files
-              ((defaults.dup & assets) + assets).uniq!
-            else
-              expanded_sources = validate_sources!
-              expanded_sources << APPLICATION_JS if include_application?
-              expanded_sources
-            end
+        def determine_source(source, collection)
+          case source
+          when Symbol
+            collection[source] || raise(ArgumentError, "No expansion found for #{source.inspect}")
+          else
+            source
           end
-          memoize :expand_sources
-
-          private
-            def tag_class
-              JavaScriptTag
-            end
-
-            def defaults
-              determine_source(:defaults, self.class.expansions)
-            end
+        end
 
-            def include_application?
-              @sources.include?(:defaults) && File.exist?(File.join(JAVASCRIPTS_DIR, APPLICATION_FILE))
-            end
+        def join_asset_file_contents(paths)
+          paths.collect { |path| File.read(asset_file_path(path)) }.join("\n\n")
         end
 
-        class StylesheetSources < AssetCollection
-          include StylesheetAsset
+        def write_asset_file_contents(joined_asset_path, asset_paths)
+          FileUtils.mkdir_p(File.dirname(joined_asset_path))
+          File.open(joined_asset_path, "w+") { |cache| cache.write(join_asset_file_contents(asset_paths)) }
 
-          EXPANSIONS = {}
+          # Set mtime to the latest of the combined files to allow for
+          # consistent ETag without a shared filesystem.
+          mt = asset_paths.map { |p| File.mtime(asset_file_path(p)) }.max
+          File.utime(mt, mt, joined_asset_path)
+        end
 
-          def self.expansions
-            EXPANSIONS
-          end
+        def asset_file_path(path)
+          File.join(ASSETS_DIR, path.split('?').first)
+        end
 
-          def expand_sources
-            @sources.first == :all ? all_asset_files : validate_sources!
-          end
-          memoize :expand_sources
+        def collect_asset_files(*path)
+          dir = path.first
 
-          private
-            def tag_class
-              StylesheetTag
-            end
+          Dir[File.join(*path.compact)].collect do |file|
+            file[-(file.size - dir.size - 1)..-1].sub(/\.\w+$/, '')
+          end.sort
         end
     end
   end
-end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_view/helpers/benchmark_helper.rb b/actionpack/lib/action_view/helpers/benchmark_helper.rb
index 372d24a22e..61c2cecb04 100644
--- a/actionpack/lib/action_view/helpers/benchmark_helper.rb
+++ b/actionpack/lib/action_view/helpers/benchmark_helper.rb
@@ -18,12 +18,33 @@ module ActionView
       # That would add something like "Process data files (345.2ms)" to the log,
       # which you can then use to compare timings when optimizing your code.
       #
-      # You may give an optional logger level as the second argument
+      # You may give an optional logger level as the :level option.
       # (:debug, :info, :warn, :error); the default value is :info.
-      def benchmark(message = "Benchmarking", level = :info)
+      #
+      #  <% benchmark "Low-level files", :level => :debug do %>
+      #    <%= lowlevel_files_operation %>
+      #  <% end %>
+      #
+      # Finally, you can pass true as the third argument to silence all log activity 
+      # inside the block. This is great for boiling down a noisy block to just a single statement:
+      #
+      #  <% benchmark "Process data files", :level => :info, :silence => true do %>
+      #    <%= expensive_and_chatty_files_operation %>
+      #  <% end %>
+      def benchmark(message = "Benchmarking", options = {})
         if controller.logger
-          ms = Benchmark.ms { yield }
-          controller.logger.send(level, '%s (%.1fms)' % [message, ms])
+          if options.is_a?(Symbol)
+            ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
+            options = { :level => options, :silence => false }
+          else
+            options.assert_valid_keys(:level, :silence)
+            options[:level] ||= :info
+          end
+          
+          result = nil
+          ms = Benchmark.ms { result = options[:silence] ? controller.logger.silence { yield } : yield }
+          controller.logger.send(options[:level], '%s (%.1fms)' % [ message, ms ])
+          result
         else
           yield
         end
diff --git a/actionpack/lib/action_view/inline_template.rb b/actionpack/lib/action_view/inline_template.rb
index 5e00cef13f..54efa543c8 100644
--- a/actionpack/lib/action_view/inline_template.rb
+++ b/actionpack/lib/action_view/inline_template.rb
@@ -12,7 +12,7 @@ module ActionView #:nodoc:
 
     private
       # Always recompile inline templates
-      def recompile?(local_assigns)
+      def recompile?
         true
       end
   end
diff --git a/actionpack/lib/action_view/paths.rb b/actionpack/lib/action_view/paths.rb
index b030156889..19207e7262 100644
--- a/actionpack/lib/action_view/paths.rb
+++ b/actionpack/lib/action_view/paths.rb
@@ -2,7 +2,7 @@ module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
     def self.type_cast(obj)
       if obj.is_a?(String)
-        Path.new(obj)
+        Template::EagerPath.new(obj)
       else
         obj
       end
@@ -32,111 +32,6 @@ module ActionView #:nodoc:
       super(*objs.map { |obj| self.class.type_cast(obj) })
     end
 
-    class Path #:nodoc:
-      attr_reader :path, :paths
-      delegate :hash, :inspect, :to => :path
-
-      def initialize(path, load = false)
-        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
-        @path = path.freeze
-        reload! if load
-      end
-
-      def to_s
-        if defined?(RAILS_ROOT)
-          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
-        else
-          path.to_s
-        end
-      end
-
-      def to_str
-        path.to_str
-      end
-
-      def ==(path)
-        to_str == path.to_str
-      end
-
-      def eql?(path)
-        to_str == path.to_str
-      end
-
-      # Returns a ActionView::Template object for the given path string. The
-      # input path should be relative to the view path directory,
-      # +hello/index.html.erb+. This method also has a special exception to
-      # match partial file names without a handler extension. So
-      # +hello/index.html+ will match the first template it finds with a
-      # known template extension, +hello/index.html.erb+. Template extensions
-      # should not be confused with format extensions +html+, +js+, +xml+,
-      # etc. A format must be supplied to match a formated file. +hello/index+
-      # will never match +hello/index.html.erb+.
-      #
-      # This method also has two different implementations, one that is "lazy"
-      # and makes file system calls every time and the other is cached,
-      # "eager" which looks up the template in an in memory index. The "lazy"
-      # version is designed for development where you want to automatically
-      # find new templates between requests. The "eager" version is designed
-      # for production mode and it is much faster but requires more time
-      # upfront to build the file index.
-      def [](path)
-        if loaded?
-          @paths[path]
-        else
-          Dir.glob("#{@path}/#{path}*").each do |file|
-            template = create_template(file)
-            if template.accessible_paths.include?(path)
-              return template
-            end
-          end
-          nil
-        end
-      end
-
-      def loaded?
-        @loaded ? true : false
-      end
-
-      def load
-        reload! unless loaded?
-        self
-      end
-
-      # Rebuild load path directory cache
-      def reload!
-        @paths = {}
-
-        templates_in_path do |template|
-          template.load!
-          template.accessible_paths.each do |path|
-            @paths[path] = template
-          end
-        end
-
-        @paths.freeze
-        @loaded = true
-      end
-
-      private
-        def templates_in_path
-          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
-            yield create_template(file) unless File.directory?(file)
-          end
-        end
-
-        def create_template(file)
-          Template.new(file.split("#{self}/").last, self)
-        end
-    end
-
-    def load
-      each { |path| path.load }
-    end
-
-    def reload!
-      each { |path| path.reload! }
-    end
-
     def find_template(original_template_path, format = nil)
       return original_template_path if original_template_path.respond_to?(:render)
       template_path = original_template_path.sub(/^\//, '')
diff --git a/actionpack/lib/action_view/renderable.rb b/actionpack/lib/action_view/renderable.rb
index d8e72f1179..153e14f68b 100644
--- a/actionpack/lib/action_view/renderable.rb
+++ b/actionpack/lib/action_view/renderable.rb
@@ -60,7 +60,7 @@ module ActionView
       def compile(local_assigns)
         render_symbol = method_name(local_assigns)
 
-        if recompile?(render_symbol)
+        if !Base::CompiledTemplates.method_defined?(render_symbol) || recompile?
           compile!(render_symbol, local_assigns)
         end
       end
@@ -89,11 +89,8 @@ module ActionView
         end
       end
 
-      # Method to check whether template compilation is necessary.
-      # The template will be compiled if the file has not been compiled yet, or
-      # if local_assigns has a new key, which isn't supported by the compiled code yet.
-      def recompile?(symbol)
-        !Base::CompiledTemplates.method_defined?(symbol) || !loaded?
+      def recompile?
+        false
       end
   end
 end
diff --git a/actionpack/lib/action_view/renderable_partial.rb b/actionpack/lib/action_view/renderable_partial.rb
index d92ff1b8d3..3ea836fa25 100644
--- a/actionpack/lib/action_view/renderable_partial.rb
+++ b/actionpack/lib/action_view/renderable_partial.rb
@@ -25,12 +25,11 @@ module ActionView
     end
 
     def render_partial(view, object = nil, local_assigns = {}, as = nil)
-      object ||= local_assigns[:object] ||
-        local_assigns[variable_name]
+      object ||= local_assigns[:object] || local_assigns[variable_name]
 
-      if view.respond_to?(:controller)
+      if object.nil? && view.respond_to?(:controller)
         ivar = :"@#{variable_name}"
-        object ||=
+        object =
           if view.controller.instance_variable_defined?(ivar)
             ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
               view.controller.instance_variable_get(ivar),
diff --git a/actionpack/lib/action_view/template.rb b/actionpack/lib/action_view/template.rb
index 5b384d0e4d..88ee07d95b 100644
--- a/actionpack/lib/action_view/template.rb
+++ b/actionpack/lib/action_view/template.rb
@@ -1,5 +1,83 @@
 module ActionView #:nodoc:
   class Template
+    class Path
+      attr_reader :path, :paths
+      delegate :hash, :inspect, :to => :path
+
+      def initialize(path)
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
+        @path = path.freeze
+      end
+
+      def to_s
+        if defined?(RAILS_ROOT)
+          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
+        else
+          path.to_s
+        end
+      end
+
+      def to_str
+        path.to_str
+      end
+
+      def ==(path)
+        to_str == path.to_str
+      end
+
+      def eql?(path)
+        to_str == path.to_str
+      end
+
+      # Returns a ActionView::Template object for the given path string. The
+      # input path should be relative to the view path directory,
+      # +hello/index.html.erb+. This method also has a special exception to
+      # match partial file names without a handler extension. So
+      # +hello/index.html+ will match the first template it finds with a
+      # known template extension, +hello/index.html.erb+. Template extensions
+      # should not be confused with format extensions +html+, +js+, +xml+,
+      # etc. A format must be supplied to match a formated file. +hello/index+
+      # will never match +hello/index.html.erb+.
+      def [](path)
+        templates_in_path do |template|
+          if template.accessible_paths.include?(path)
+            return template
+          end
+        end
+        nil
+      end
+
+      private
+        def templates_in_path
+          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
+            yield create_template(file) unless File.directory?(file)
+          end
+        end
+
+        def create_template(file)
+          Template.new(file.split("#{self}/").last, self)
+        end
+    end
+
+    class EagerPath < Path
+      def initialize(path)
+        super
+
+        @paths = {}
+        templates_in_path do |template|
+          template.load!
+          template.accessible_paths.each do |path|
+            @paths[path] = template
+          end
+        end
+        @paths.freeze
+      end
+
+      def [](path)
+        @paths[path]
+      end
+    end
+
     extend TemplateHandlers
     extend ActiveSupport::Memoizable
     include Renderable
@@ -115,13 +193,12 @@ module ActionView #:nodoc:
       File.mtime(filename) > mtime
     end
 
-    def loaded?
-      @loaded
+    def recompile?
+      !@cached
     end
 
     def load!
-      @loaded = true
-      compile({})
+      @cached = true
       freeze
     end
 
diff --git a/actionpack/lib/action_view/test_case.rb b/actionpack/lib/action_view/test_case.rb
index 1a9ef983a5..ec337bb05b 100644
--- a/actionpack/lib/action_view/test_case.rb
+++ b/actionpack/lib/action_view/test_case.rb
@@ -1,3 +1,5 @@
+require 'active_support/test_case'
+
 module ActionView
   class Base
     alias_method :initialize_without_template_tracking, :initialize
@@ -21,6 +23,7 @@ module ActionView
 
   class TestCase < ActiveSupport::TestCase
     include ActionController::TestCase::Assertions
+    include ActionController::TestProcess
 
     class_inheritable_accessor :helper_class
     @@helper_class = nil
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index 2ba056e60f..30e2d863d0 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -34,7 +34,6 @@ ActionController::Base.session_store = nil
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 ActionController::Base.view_paths = FIXTURE_LOAD_PATH
-ActionController::Base.view_paths.load
 
 def uses_mocha(test_name)
   yield
diff --git a/actionpack/test/controller/addresses_render_test.rb b/actionpack/test/controller/addresses_render_test.rb
index b26cae24fb..556b0593ea 100644
--- a/actionpack/test/controller/addresses_render_test.rb
+++ b/actionpack/test/controller/addresses_render_test.rb
@@ -19,17 +19,14 @@ class AddressesTestController < ActionController::Base
   def self.controller_path; "addresses"; end
 end
 
-class AddressesTest < Test::Unit::TestCase
-  def setup
-    @controller = AddressesTestController.new
+class AddressesTest < ActionController::TestCase
+  tests AddressesTestController
 
+  def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
 
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-
     @request.host = "www.nextangle.com"
   end
 
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index 18d185b264..9523189f41 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -129,6 +129,8 @@ class PerformActionTest < ActionController::TestCase
     @response   = ActionController::TestResponse.new
 
     @request.host = "www.nextangle.com"
+
+    rescue_action_in_public!
   end
   
   def test_get_on_priv_should_show_selector
@@ -164,14 +166,12 @@ class PerformActionTest < ActionController::TestCase
   end
 end
 
-class DefaultUrlOptionsTest < Test::Unit::TestCase
-  def setup
-    @controller = DefaultUrlOptionsController.new
-
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
+class DefaultUrlOptionsTest < ActionController::TestCase
+  tests DefaultUrlOptionsController
 
+  def setup
     @request.host = 'www.example.com'
+    rescue_action_in_public!
   end
 
   def test_default_url_options_are_used_if_set
@@ -189,14 +189,12 @@ class DefaultUrlOptionsTest < Test::Unit::TestCase
   end
 end
 
-class EmptyUrlOptionsTest < Test::Unit::TestCase
-  def setup
-    @controller = NonEmptyController.new
-
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
+class EmptyUrlOptionsTest < ActionController::TestCase
+  tests NonEmptyController
 
+  def setup
     @request.host = 'www.example.com'
+    rescue_action_in_public!
   end
 
   def test_ensure_url_for_works_as_expected_when_called_with_no_options_if_default_url_options_is_not_set
diff --git a/actionpack/test/controller/benchmark_test.rb b/actionpack/test/controller/benchmark_test.rb
index 608ea5f5a9..f9100a2313 100644
--- a/actionpack/test/controller/benchmark_test.rb
+++ b/actionpack/test/controller/benchmark_test.rb
@@ -11,17 +11,17 @@ class BenchmarkedController < ActionController::Base
   end
 end
 
-class BenchmarkTest < Test::Unit::TestCase
+class BenchmarkTest < ActionController::TestCase
+  tests BenchmarkedController
+
   class MockLogger
     def method_missing(*args)
     end
   end
 
   def setup
-    @controller = BenchmarkedController.new
     # benchmark doesn't do anything unless a logger is set
     @controller.logger = MockLogger.new
-    @request, @response = ActionController::TestRequest.new, ActionController::TestResponse.new
     @request.host = "test.actioncontroller.i"
   end
 
diff --git a/actionpack/test/controller/capture_test.rb b/actionpack/test/controller/capture_test.rb
index 5ded6a5d26..6dfa0995eb 100644
--- a/actionpack/test/controller/capture_test.rb
+++ b/actionpack/test/controller/capture_test.rb
@@ -23,17 +23,14 @@ class CaptureController < ActionController::Base
   def rescue_action(e) raise end
 end
 
-class CaptureTest < Test::Unit::TestCase
-  def setup
-    @controller = CaptureController.new
+class CaptureTest < ActionController::TestCase
+  tests CaptureController
 
+  def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
 
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-
     @request.host = "www.nextangle.com"
   end
 
diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb
index ae71d62e11..32c1757ef9 100644
--- a/actionpack/test/controller/content_type_test.rb
+++ b/actionpack/test/controller/content_type_test.rb
@@ -50,16 +50,13 @@ class ContentTypeController < ActionController::Base
   def rescue_action(e) raise end
 end
 
-class ContentTypeTest < Test::Unit::TestCase
-  def setup
-    @controller = ContentTypeController.new
+class ContentTypeTest < ActionController::TestCase
+  tests ContentTypeController
 
+  def setup
     # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
     # a more accurate simulation of what happens in "real life".
     @controller.logger = Logger.new(nil)
-
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
   end
 
   def test_render_defaults
diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb
index 3ddc5768a9..9508348ca1 100644
--- a/actionpack/test/controller/cookie_test.rb
+++ b/actionpack/test/controller/cookie_test.rb
@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class CookieTest < Test::Unit::TestCase
+class CookieTest < ActionController::TestCase
   class TestController < ActionController::Base
     def authenticate
       cookies["user_name"] = "david"
@@ -41,11 +41,9 @@ class CookieTest < Test::Unit::TestCase
     end
   end
 
-  def setup
-    @request  = ActionController::TestRequest.new
-    @response = ActionController::TestResponse.new
+  tests TestController
 
-    @controller = TestController.new
+  def setup
     @request.host = "www.nextangle.com"
   end
 
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index fd06b4ea99..7cd4e71aa1 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -32,11 +32,6 @@ class DispatcherTest < Test::Unit::TestCase
     dispatch(false)
   end
 
-  def test_clears_asset_tag_cache_before_dispatch_if_in_loading_mode
-    ActionView::Helpers::AssetTagHelper::AssetTag::Cache.expects(:clear).once
-    dispatch(false)
-  end
-
   def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
     ActionController::Routing::Routes.expects(:reload).never
     ActiveSupport::Dependencies.expects(:clear).never
@@ -96,9 +91,7 @@ class DispatcherTest < Test::Unit::TestCase
 
   private
     def dispatch(cache_classes = true)
-      controller = mock()
-      controller.stubs(:process).returns([200, {}, 'response'])
-      ActionController::Routing::Routes.stubs(:recognize).returns(controller)
+      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
       Dispatcher.define_dispatcher_callbacks(cache_classes)
       @dispatcher.call({})
     end
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index dafa344473..e83fde2349 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -634,9 +634,11 @@ class FilterTest < Test::Unit::TestCase
 
   private
     def test_process(controller, action = "show")
+      ActionController::Base.class_eval { include ActionController::ProcessWithTest } unless ActionController::Base < ActionController::ProcessWithTest
       request = ActionController::TestRequest.new
       request.action = action
-      controller.process(request, ActionController::TestResponse.new)
+      controller = controller.new if controller.is_a?(Class)
+      controller.process_with_test(request, ActionController::TestResponse.new)
     end
 end
 
@@ -874,8 +876,10 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
 
   protected
     def test_process(controller, action = "show")
+      ActionController::Base.class_eval { include ActionController::ProcessWithTest } unless ActionController::Base < ActionController::ProcessWithTest
       request = ActionController::TestRequest.new
       request.action = action
-      controller.process(request, ActionController::TestResponse.new)
+      controller = controller.new if controller.is_a?(Class)
+      controller.process_with_test(request, ActionController::TestResponse.new)
     end
 end
diff --git a/actionpack/test/controller/flash_test.rb b/actionpack/test/controller/flash_test.rb
index e562531bf3..d8a892811e 100644
--- a/actionpack/test/controller/flash_test.rb
+++ b/actionpack/test/controller/flash_test.rb
@@ -1,6 +1,6 @@
 require 'abstract_unit'
 
-class FlashTest < Test::Unit::TestCase
+class FlashTest < ActionController::TestCase
   class TestController < ActionController::Base
     def set_flash
       flash["that"] = "hello"
@@ -73,11 +73,7 @@ class FlashTest < Test::Unit::TestCase
     end
   end
 
-  def setup
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
-    @controller = TestController.new
-  end
+  tests TestController
 
   def test_flash
     get :set_flash
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
new file mode 100644
index 0000000000..d5c8636a9e
--- /dev/null
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -0,0 +1,73 @@
+require 'abstract_unit'
+
+class HttpDigestAuthenticationTest < Test::Unit::TestCase
+  include ActionController::HttpAuthentication::Digest
+  
+  class DummyController
+    attr_accessor :headers, :renders, :request, :response
+
+    def initialize
+      @headers, @renders = {}, []
+      @request = ActionController::TestRequest.new
+      @response = ActionController::TestResponse.new
+      request.session.session_id = "test_session"
+    end
+    
+    def render(options)
+      self.renderers << options
+    end
+  end
+  
+  def setup
+    @controller = DummyController.new
+    @credentials = {
+      :username => "dhh",
+      :realm    => "testrealm@host.com",
+      :nonce    => ActionController::HttpAuthentication::Digest.nonce(@controller.request),
+      :qop      => "auth",
+      :nc       => "00000001",
+      :cnonce   => "0a4f113b",
+      :opaque   => ActionController::HttpAuthentication::Digest.opaque(@controller.request),
+      :uri      => "http://test.host/"
+    }
+    @encoded_credentials = ActionController::HttpAuthentication::Digest.encode_credentials("GET", @credentials, "secret")
+  end
+
+  def test_decode_credentials
+    set_headers
+    assert_equal @credentials, decode_credentials(@controller.request) 
+  end 
+    
+  def test_nonce_format
+    assert_nothing_thrown do
+      validate_nonce(@controller.request, nonce(@controller.request))
+    end
+  end
+  
+  def test_authenticate_should_raise_for_nil_password
+    set_headers ActionController::HttpAuthentication::Digest.encode_credentials(:get, @credentials, nil)
+    assert_raise ActionController::HttpAuthentication::Error do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "secret" }
+    end
+  end 
+  
+  def test_authenticate_should_raise_for_incorrect_password 
+    set_headers
+    assert_raise ActionController::HttpAuthentication::Error do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "bad password" }
+    end
+  end 
+ 
+  def test_authenticate_should_not_raise_for_correct_password 
+    set_headers
+    assert_nothing_thrown do
+      authenticate(@controller, @credentials[:realm]) { |user| user == "dhh" && "secret" }
+    end
+  end 
+
+  private
+    def set_headers(value = @encoded_credentials, name = 'HTTP_AUTHORIZATION', method = "GET")
+      @controller.request.env[name] = value
+      @controller.request.env["REQUEST_METHOD"] = method
+    end
+end
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index c28050fe0d..7ac9d97096 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -4,11 +4,29 @@ uses_mocha 'integration' do
 
 class SessionTest < Test::Unit::TestCase
   StubApp = lambda { |env|
-    [200, {"Content-Type" => "text/html"}, "Hello, World!"]
+    [200, {"Content-Type" => "text/html", "Content-Length" => "13"}, "Hello, World!"]
   }
 
   def setup
+    @credentials = {
+      :username => "username",
+      :realm    => "MyApp",
+      :nonce    => ActionController::HttpAuthentication::Digest.nonce("session_id"),
+      :qop      => "auth",
+      :nc       => "00000001",
+      :cnonce   => "0a4f113b",
+      :opaque   => ActionController::HttpAuthentication::Digest.opaque("session_id"),
+      :uri      => "/index"
+    }
+
     @session = ActionController::Integration::Session.new(StubApp)
+    @session.nonce = @credentials[:nonce]
+    @session.opaque = @credentials[:opaque]
+    @session.realm = @credentials[:realm]
+  end
+
+  def encoded_credentials(method)
+    ActionController::HttpAuthentication::Digest.encode_credentials(method, @credentials, "password")
   end
 
   def test_https_bang_works_and_sets_truth_by_default
@@ -132,6 +150,76 @@ class SessionTest < Test::Unit::TestCase
     @session.head(path,params,headers)
   end
 
+  def test_get_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:get,path,params,expected_headers) 
+    @session.get_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_post_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:post,path,params,expected_headers) 
+    @session.post_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_put_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:put,path,params,expected_headers) 
+    @session.put_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_delete_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:delete,path,params,expected_headers) 
+    @session.delete_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_head_with_basic 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => "Basic dXNlcm5hbWU6cGFzc3dvcmQ=\n")  
+    @session.expects(:process).with(:head,path,params,expected_headers) 
+    @session.head_with_basic(path,params,headers,'username','password') 
+  end 
+ 
+  def test_get_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:get))
+    @session.expects(:process).with(:get,path,params,expected_headers) 
+    @session.get_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_post_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:post))
+    @session.expects(:process).with(:post,path,params,expected_headers) 
+    @session.post_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_put_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:put)) 
+    @session.expects(:process).with(:put,path,params,expected_headers) 
+    @session.put_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_delete_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:delete))
+    @session.expects(:process).with(:delete,path,params,expected_headers) 
+    @session.delete_with_digest(path,params,headers,'username','password') 
+  end 
+ 
+  def test_head_with_digest 
+    path = "/index"; params = "blah"; headers = {:location => 'blah'} 
+    expected_headers = headers.merge(:authorization => encoded_credentials(:head)) 
+    @session.expects(:process).with(:head,path,params,expected_headers) 
+    @session.head_with_digest(path,params,headers,'username','password') 
+  end 
+
   def test_xml_http_request_get
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
@@ -377,9 +465,9 @@ class MetalTest < ActionController::IntegrationTest
   class Poller
     def self.call(env)
       if env["PATH_INFO"] =~ /^\/success/
-        [200, {"Content-Type" => "text/plain"}, "Hello World!"]
+        [200, {"Content-Type" => "text/plain", "Content-Length" => "12"}, "Hello World!"]
       else
-        [404, {"Content-Type" => "text/plain"}, '']
+        [404, {"Content-Type" => "text/plain", "Content-Length" => "0"}, '']
       end
     end
   end
diff --git a/actionpack/test/controller/integration_upload_test.rb b/actionpack/test/controller/integration_upload_test.rb
index 39d2e164e4..d579980c19 100644
--- a/actionpack/test/controller/integration_upload_test.rb
+++ b/actionpack/test/controller/integration_upload_test.rb
@@ -10,6 +10,10 @@ class UploadTestController < ActionController::Base
     SessionUploadTest.last_request_type = ActionController::Base.param_parsers[request.content_type]
     render :text => "got here"
   end
+
+  def read
+    render :text => "File: #{params[:uploaded_data].read}"
+  end
 end
 
 class SessionUploadTest < ActionController::IntegrationTest
@@ -19,21 +23,43 @@ class SessionUploadTest < ActionController::IntegrationTest
     attr_accessor :last_request_type
   end
 
-  # def setup
-  #   @session = ActionController::Integration::Session.new
-  # end
-  def test_post_with_upload
-    uses_mocha "test_post_with_upload" do
-      ActiveSupport::Dependencies.stubs(:load?).returns(false)
+  def test_upload_and_read_file
+    with_test_routing do
+      post '/read', :uploaded_data => fixture_file_upload(FILES_DIR + "/hello.txt", "text/plain")
+      assert_equal "File: Hello", response.body
+    end
+  end
+
+  # The lint wrapper is used in integration tests
+  # instead of a normal StringIO class
+  InputWrapper = Rack::Lint::InputWrapper
+
+  def test_post_with_upload_with_unrewindable_input
+    InputWrapper.any_instance.expects(:rewind).raises(Errno::ESPIPE)
+
+    with_test_routing do
+      post '/read', :uploaded_data => fixture_file_upload(FILES_DIR + "/hello.txt", "text/plain")
+      assert_equal "File: Hello", response.body
+    end
+  end
+
+  def test_post_with_upload_with_params_parsing
+    with_test_routing do
+      params = { :uploaded_data => fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg") }
+      post '/update', params, :location => 'blah'
+      assert_equal(:multipart_form, SessionUploadTest.last_request_type)
+    end
+  end
+
+  private
+    def with_test_routing
       with_routing do |set|
         set.draw do |map|
           map.update 'update', :controller => "upload_test", :action => "update", :method => :post
+          map.read 'read', :controller => "upload_test", :action => "read", :method => :post
         end
 
-        params = { :uploaded_data => fixture_file_upload(FILES_DIR + "/mona_lisa.jpg", "image/jpg") }
-        post '/update', params, :location => 'blah'
-        assert_equal(:multipart_form, SessionUploadTest.last_request_type)
+        yield
       end
     end
-   end
 end
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index c2efe9d00b..2f5e830fba 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -146,8 +146,7 @@ class LayoutExceptionRaised < ActionController::TestCase
   def test_exception_raised_when_layout_file_not_found
     @controller = SetsNonExistentLayoutFile.new
     get :hello
-    @response.template.class.module_eval { attr_accessor :exception }
-    assert_equal ActionView::MissingTemplate, @response.template.exception.class
+    assert_kind_of ActionView::MissingTemplate, @response.template.instance_eval { @exception }
   end
 end
 
diff --git a/actionpack/test/controller/middleware_stack_test.rb b/actionpack/test/controller/middleware_stack_test.rb
new file mode 100644
index 0000000000..5029f5f609
--- /dev/null
+++ b/actionpack/test/controller/middleware_stack_test.rb
@@ -0,0 +1,70 @@
+require 'abstract_unit'
+
+class MiddlewareStackTest < ActiveSupport::TestCase
+  class FooMiddleware; end
+  class BarMiddleware; end
+  class BazMiddleware; end
+
+  def setup
+    @stack = ActionController::MiddlewareStack.new
+    @stack.use FooMiddleware
+    @stack.use BarMiddleware
+  end
+
+  test "use should push middleware as class onto the stack" do
+    assert_difference "@stack.size" do
+      @stack.use BazMiddleware
+    end
+    assert_equal BazMiddleware, @stack.last.klass
+  end
+
+  test "use should push middleware as a string onto the stack" do
+    assert_difference "@stack.size" do
+      @stack.use "MiddlewareStackTest::BazMiddleware"
+    end
+    assert_equal BazMiddleware, @stack.last.klass
+  end
+
+  test "use should push middleware as a symbol onto the stack" do
+    assert_difference "@stack.size" do
+      @stack.use :"MiddlewareStackTest::BazMiddleware"
+    end
+    assert_equal BazMiddleware, @stack.last.klass
+  end
+
+  test "use should push middleware class with arguments onto the stack" do
+    assert_difference "@stack.size" do
+      @stack.use BazMiddleware, true, :foo => "bar"
+    end
+    assert_equal BazMiddleware, @stack.last.klass
+    assert_equal([true, {:foo => "bar"}], @stack.last.args)
+  end
+
+  test "insert inserts middleware at the integer index" do
+    @stack.insert(1, BazMiddleware)
+    assert_equal BazMiddleware, @stack[1].klass
+  end
+
+  test "insert_after inserts middleware after the integer index" do
+    @stack.insert_after(1, BazMiddleware)
+    assert_equal BazMiddleware, @stack[2].klass
+  end
+
+  test "insert_before inserts middleware before another middleware class" do
+    @stack.insert_before(BarMiddleware, BazMiddleware)
+    assert_equal BazMiddleware, @stack[1].klass
+  end
+
+  test "insert_after inserts middleware after another middleware class" do
+    @stack.insert_after(BarMiddleware, BazMiddleware)
+    assert_equal BazMiddleware, @stack[2].klass
+  end
+
+  test "active returns all only enabled middleware" do
+    assert_no_difference "@stack.active.size" do
+      assert_difference "@stack.size" do
+        @stack.use BazMiddleware, :if => lambda { false }
+      end
+    end
+  end
+end
diff --git a/actionpack/test/controller/query_string_parsing_test.rb b/actionpack/test/controller/query_string_parsing_test.rb
new file mode 100644
index 0000000000..a31e326ddf
--- /dev/null
+++ b/actionpack/test/controller/query_string_parsing_test.rb
@@ -0,0 +1,120 @@
+require 'abstract_unit'
+
+class QueryStringParsingTest < ActionController::IntegrationTest
+  class TestController < ActionController::Base
+    class << self
+      attr_accessor :last_query_parameters
+    end
+
+    def parse
+      self.class.last_query_parameters = request.query_parameters
+      head :ok
+    end
+  end
+
+  def teardown
+    TestController.last_query_parameters = nil
+  end
+
+  test "query string" do
+    assert_parses(
+      {"action" => "create_customer", "full_name" => "David Heinemeier Hansson", "customerId" => "1"},
+      "action=create_customer&full_name=David%20Heinemeier%20Hansson&customerId=1"
+    )
+  end
+
+  test "deep query string" do
+    assert_parses(
+      {'x' => {'y' => {'z' => '10'}}},
+      "x[y][z]=10"
+    )
+  end
+
+  test "deep query string with array" do
+    assert_parses({'x' => {'y' => {'z' => ['10']}}}, 'x[y][z][]=10')
+    assert_parses({'x' => {'y' => {'z' => ['10', '5']}}}, 'x[y][z][]=10&x[y][z][]=5')
+  end
+
+  test "deep query string with array of hash" do
+    assert_parses({'x' => {'y' => [{'z' => '10'}]}}, 'x[y][][z]=10')
+    assert_parses({'x' => {'y' => [{'z' => '10', 'w' => '10'}]}}, 'x[y][][z]=10&x[y][][w]=10')
+    assert_parses({'x' => {'y' => [{'z' => '10', 'v' => {'w' => '10'}}]}}, 'x[y][][z]=10&x[y][][v][w]=10')
+  end
+
+  test "deep query string with array of hashes with one pair" do
+    assert_parses({'x' => {'y' => [{'z' => '10'}, {'z' => '20'}]}}, 'x[y][][z]=10&x[y][][z]=20')
+  end
+
+  test "deep query string with array of hashes with multiple pairs" do
+    assert_parses(
+      {'x' => {'y' => [{'z' => '10', 'w' => 'a'}, {'z' => '20', 'w' => 'b'}]}},
+      'x[y][][z]=10&x[y][][w]=a&x[y][][z]=20&x[y][][w]=b'
+    )
+  end
+
+  test "query string with nil" do
+    assert_parses(
+      { "action" => "create_customer", "full_name" => ''},
+      "action=create_customer&full_name="
+    )
+  end
+
+  test "query string with array" do
+    assert_parses(
+      { "action" => "create_customer", "selected" => ["1", "2", "3"]},
+      "action=create_customer&selected[]=1&selected[]=2&selected[]=3"
+    )
+  end
+
+  test "query string with amps" do
+    assert_parses(
+      { "action" => "create_customer", "name" => "Don't & Does"},
+      "action=create_customer&name=Don%27t+%26+Does"
+    )
+  end
+
+  test "query string with many equal" do
+    assert_parses(
+      { "action" => "create_customer", "full_name" => "abc=def=ghi"},
+      "action=create_customer&full_name=abc=def=ghi"
+    )
+  end
+
+  test "query string without equal" do
+    assert_parses({ "action" => nil }, "action")
+  end
+
+  test "query string with empty key" do
+    assert_parses(
+      { "action" => "create_customer", "full_name" => "David Heinemeier Hansson" },
+      "action=create_customer&full_name=David%20Heinemeier%20Hansson&=Save"
+    )
+  end
+
+  test "query string with many ampersands" do
+    assert_parses(
+      { "action" => "create_customer", "full_name" => "David Heinemeier Hansson"},
+      "&action=create_customer&&&full_name=David%20Heinemeier%20Hansson"
+    )
+  end
+
+  test "unbalanced query string with array" do
+    assert_parses(
+      {'location' => ["1", "2"], 'age_group' => ["2"]},
+      "location[]=1&location[]=2&age_group[]=2"
+    )
+  end
+
+  private
+    def assert_parses(expected, actual)
+      with_routing do |set|
+        set.draw do |map|
+          map.connect ':action', :controller => "query_string_parsing_test/test"
+        end
+
+        get "/parse", actual
+        assert_response :ok
+        assert_equal(expected, TestController.last_query_parameters)
+      end
+    end
+end
diff --git a/actionpack/test/controller/rack_test.rb b/actionpack/test/controller/rack_test.rb
index 31bff4ae6d..8fd004a9e9 100644
--- a/actionpack/test/controller/rack_test.rb
+++ b/actionpack/test/controller/rack_test.rb
@@ -236,7 +236,12 @@ class RackResponseTest < BaseRackTest
 
     status, headers, body = @response.to_a
     assert_equal 200, status
-    assert_equal({"Content-Type" => "text/html; charset=utf-8", "Cache-Control" => "no-cache", "Set-Cookie" => []}, headers)
+    assert_equal({
+      "Content-Type" => "text/html; charset=utf-8",
+      "Content-Length" => "",
+      "Cache-Control" => "no-cache",
+      "Set-Cookie" => []
+    }, headers)
 
     parts = []
     body.each { |part| parts << part }
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 5fd41d8eec..8809aa7c34 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -1218,6 +1218,11 @@ class RenderTest < ActionController::TestCase
     assert_equal "404 Not Found", @response.status
     assert_response :not_found
 
+    get :head_with_symbolic_status, :status => "no_content"
+    assert_equal "204 No Content", @response.status
+    assert !@response.headers.include?('Content-Length')
+    assert_response :no_content
+
     ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE.each do |status, code|
       get :head_with_symbolic_status, :status => status.to_s
       assert_equal code, @response.response_code
@@ -1470,7 +1475,7 @@ class EtagRenderTest < ActionController::TestCase
   def test_render_against_etag_request_should_have_no_content_length_when_match
     @request.if_none_match = etag_for("hello david")
     get :render_hello_world_from_variable
-    assert !@response.headers.has_key?("Content-Length")
+    assert !@response.headers.has_key?("Content-Length"), @response.headers['Content-Length']
   end
 
   def test_render_against_etag_request_should_200_when_no_match
diff --git a/actionpack/test/controller/request/json_params_parsing_test.rb b/actionpack/test/controller/request/json_params_parsing_test.rb
new file mode 100644
index 0000000000..a3dde72c4e
--- /dev/null
+++ b/actionpack/test/controller/request/json_params_parsing_test.rb
@@ -0,0 +1,45 @@
+require 'abstract_unit'
+
+class JsonParamsParsingTest < ActionController::IntegrationTest
+  class TestController < ActionController::Base
+    class << self
+      attr_accessor :last_request_parameters
+    end
+
+    def parse
+      self.class.last_request_parameters = request.request_parameters
+      head :ok
+    end
+  end
+
+  def teardown
+    TestController.last_request_parameters = nil
+  end
+
+  test "parses json params for application json" do
+    assert_parses(
+      {"person" => {"name" => "David"}},
+      "{\"person\": {\"name\": \"David\"}}", { 'CONTENT_TYPE' => 'application/json' }
+    )
+  end
+
+  test "parses json params for application jsonrequest" do
+    assert_parses(
+      {"person" => {"name" => "David"}},
+      "{\"person\": {\"name\": \"David\"}}", { 'CONTENT_TYPE' => 'application/jsonrequest' }
+    )
+  end
+
+  private
+    def assert_parses(expected, actual, headers = {})
+      with_routing do |set|
+        set.draw do |map|
+          map.connect ':action', :controller => "json_params_parsing_test/test"
+        end
+
+        post "/parse", actual, headers
+        assert_response :ok
+        assert_equal(expected, TestController.last_request_parameters)
+      end
+    end
+end
diff --git a/actionpack/test/controller/request/xml_params_parsing_test.rb b/actionpack/test/controller/request/xml_params_parsing_test.rb
new file mode 100644
index 0000000000..ee764e726e
--- /dev/null
+++ b/actionpack/test/controller/request/xml_params_parsing_test.rb
@@ -0,0 +1,88 @@
+require 'abstract_unit'
+
+class XmlParamsParsingTest < ActionController::IntegrationTest
+  class TestController < ActionController::Base
+    class << self
+      attr_accessor :last_request_parameters
+    end
+
+    def parse
+      self.class.last_request_parameters = request.request_parameters
+      head :ok
+    end
+  end
+
+  def teardown
+    TestController.last_request_parameters = nil
+  end
+
+  test "parses hash params" do
+    with_test_routing do
+      xml = "<person><name>David</name></person>"
+      post "/parse", xml, default_headers
+      assert_response :ok
+      assert_equal({"person" => {"name" => "David"}}, TestController.last_request_parameters)
+    end
+  end
+
+  test "parses single file" do
+    with_test_routing do
+      xml = "<person><name>David</name><avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar></person>"
+      post "/parse", xml, default_headers
+      assert_response :ok
+
+      person = TestController.last_request_parameters
+      assert_equal "image/jpg", person['person']['avatar'].content_type
+      assert_equal "me.jpg", person['person']['avatar'].original_filename
+      assert_equal "ABC", person['person']['avatar'].read
+    end
+  end
+
+  test "parses multiple files" do
+    xml = <<-end_body
+      <person>
+        <name>David</name>
+        <avatars>
+          <avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar>
+          <avatar type='file' name='you.gif' content_type='image/gif'>#{ActiveSupport::Base64.encode64('DEF')}</avatar>
+        </avatars>
+      </person>
+    end_body
+
+    with_test_routing do
+      post "/parse", xml, default_headers
+      assert_response :ok
+    end
+
+    person = TestController.last_request_parameters
+
+    assert_equal "image/jpg", person['person']['avatars']['avatar'].first.content_type
+    assert_equal "me.jpg", person['person']['avatars']['avatar'].first.original_filename
+    assert_equal "ABC", person['person']['avatars']['avatar'].first.read
+
+    assert_equal "image/gif", person['person']['avatars']['avatar'].last.content_type
+    assert_equal "you.gif", person['person']['avatars']['avatar'].last.original_filename
+    assert_equal "DEF", person['person']['avatars']['avatar'].last.read
+  end
+
+  private
+    def with_test_routing
+      with_routing do |set|
+        set.draw do |map|
+          map.connect ':action', :controller => "xml_params_parsing_test/test"
+        end
+        yield
+      end
+    end
+
+    def default_headers
+      {'CONTENT_TYPE' => 'application/xml'}
+    end
+end
+
+class LegacyXmlParamsParsingTest < XmlParamsParsingTest
+  private
+    def default_headers
+      {'HTTP_X_POST_DATA_FORMAT' => 'xml'}
+    end
+end
diff --git a/actionpack/test/controller/request_test.rb b/actionpack/test/controller/request_test.rb
index 349cea268f..c53f1bc2d9 100644
--- a/actionpack/test/controller/request_test.rb
+++ b/actionpack/test/controller/request_test.rb
@@ -391,8 +391,8 @@ class RequestTest < ActiveSupport::TestCase
   end
 
   def test_parameters
-    @request.instance_eval { @request_parameters = { "foo" => 1 } }
-    @request.instance_eval { @query_parameters = { "bar" => 2 } }
+    @request.stubs(:request_parameters).returns({ "foo" => 1 })
+    @request.stubs(:query_parameters).returns({ "bar" => 2 })
 
     assert_equal({"foo" => 1, "bar" => 2}, @request.parameters)
     assert_equal({"foo" => 1}, @request.request_parameters)
@@ -407,113 +407,10 @@ class RequestTest < ActiveSupport::TestCase
 end
 
 class UrlEncodedRequestParameterParsingTest < ActiveSupport::TestCase
-  def setup
-    @query_string = "action=create_customer&full_name=David%20Heinemeier%20Hansson&customerId=1"
-    @query_string_with_empty = "action=create_customer&full_name="
-    @query_string_with_array = "action=create_customer&selected[]=1&selected[]=2&selected[]=3"
-    @query_string_with_amps  = "action=create_customer&name=Don%27t+%26+Does"
-    @query_string_with_multiple_of_same_name =
-      "action=update_order&full_name=Lau%20Taarnskov&products=4&products=2&products=3"
-    @query_string_with_many_equal = "action=create_customer&full_name=abc=def=ghi"
-    @query_string_without_equal = "action"
-    @query_string_with_many_ampersands =
-      "&action=create_customer&&&full_name=David%20Heinemeier%20Hansson"
-    @query_string_with_empty_key = "action=create_customer&full_name=David%20Heinemeier%20Hansson&=Save"
-  end
-
-  def test_query_string
-    assert_equal(
-      { "action" => "create_customer", "full_name" => "David Heinemeier Hansson", "customerId" => "1"},
-      ActionController::RequestParser.parse_query_parameters(@query_string)
-    )
-  end
-
-  def test_deep_query_string
-    expected = {'x' => {'y' => {'z' => '10'}}}
-    assert_equal(expected, ActionController::RequestParser.parse_query_parameters('x[y][z]=10'))
-  end
-
-  def test_deep_query_string_with_array
-    assert_equal({'x' => {'y' => {'z' => ['10']}}}, ActionController::RequestParser.parse_query_parameters('x[y][z][]=10'))
-    assert_equal({'x' => {'y' => {'z' => ['10', '5']}}}, ActionController::RequestParser.parse_query_parameters('x[y][z][]=10&x[y][z][]=5'))
-  end
-
-  def test_deep_query_string_with_array_of_hash
-    assert_equal({'x' => {'y' => [{'z' => '10'}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10'))
-    assert_equal({'x' => {'y' => [{'z' => '10', 'w' => '10'}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][w]=10'))
-  end
-
-  def test_deep_query_string_with_array_of_hashes_with_one_pair
-    assert_equal({'x' => {'y' => [{'z' => '10'}, {'z' => '20'}]}}, ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][z]=20'))
-    assert_equal("10", ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][z]=20')["x"]["y"].first["z"])
-    assert_equal("10", ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][z]=20').with_indifferent_access[:x][:y].first[:z])
-  end
-
-  def test_deep_query_string_with_array_of_hashes_with_multiple_pairs
-    assert_equal(
-      {'x' => {'y' => [{'z' => '10', 'w' => 'a'}, {'z' => '20', 'w' => 'b'}]}},
-      ActionController::RequestParser.parse_query_parameters('x[y][][z]=10&x[y][][w]=a&x[y][][z]=20&x[y][][w]=b')
-    )
-  end
-
-  def test_query_string_with_nil
-    assert_equal(
-      { "action" => "create_customer", "full_name" => ''},
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_empty)
-    )
-  end
-
-  def test_query_string_with_array
-    assert_equal(
-      { "action" => "create_customer", "selected" => ["1", "2", "3"]},
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_array)
-    )
-  end
-
-  def test_query_string_with_amps
-    assert_equal(
-      { "action" => "create_customer", "name" => "Don't & Does"},
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_amps)
-    )
-  end
-
-  def test_query_string_with_many_equal
-    assert_equal(
-      { "action" => "create_customer", "full_name" => "abc=def=ghi"},
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_many_equal)
-    )
-  end
-
-  def test_query_string_without_equal
-    assert_equal(
-      { "action" => nil },
-      ActionController::RequestParser.parse_query_parameters(@query_string_without_equal)
-    )
-  end
-
-  def test_query_string_with_empty_key
-    assert_equal(
-      { "action" => "create_customer", "full_name" => "David Heinemeier Hansson" },
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_empty_key)
-    )
-  end
-
-  def test_query_string_with_many_ampersands
-    assert_equal(
-      { "action" => "create_customer", "full_name" => "David Heinemeier Hansson"},
-      ActionController::RequestParser.parse_query_parameters(@query_string_with_many_ampersands)
-    )
-  end
-
   def test_unbalanced_query_string_with_array
    assert_equal(
      {'location' => ["1", "2"], 'age_group' => ["2"]},
-  ActionController::RequestParser.parse_query_parameters("location[]=1&location[]=2&age_group[]=2")
-   )
-   assert_equal(
-     {'location' => ["1", "2"], 'age_group' => ["2"]},
-     ActionController::RequestParser.parse_request_parameters({'location[]' => ["1", "2"],
-  'age_group[]' => ["2"]})
+     ActionController::RequestParser.parse_request_parameters({'location[]' => ["1", "2"], 'age_group[]' => ["2"]})
    )
   end
 
@@ -813,79 +710,3 @@ class MultipartRequestParameterParsingTest < ActiveSupport::TestCase
       end
     end
 end
-
-class XmlParamsParsingTest < ActiveSupport::TestCase
-  def test_hash_params
-    person = parse_body("<person><name>David</name></person>")[:person]
-    assert_kind_of Hash, person
-    assert_equal 'David', person['name']
-  end
-
-  def test_single_file
-    person = parse_body("<person><name>David</name><avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar></person>")
-
-    assert_equal "image/jpg", person['person']['avatar'].content_type
-    assert_equal "me.jpg", person['person']['avatar'].original_filename
-    assert_equal "ABC", person['person']['avatar'].read
-  end
-
-  def test_multiple_files
-    person = parse_body(<<-end_body)
-      <person>
-        <name>David</name>
-        <avatars>
-          <avatar type='file' name='me.jpg' content_type='image/jpg'>#{ActiveSupport::Base64.encode64('ABC')}</avatar>
-          <avatar type='file' name='you.gif' content_type='image/gif'>#{ActiveSupport::Base64.encode64('DEF')}</avatar>
-        </avatars>
-      </person>
-    end_body
-
-    assert_equal "image/jpg", person['person']['avatars']['avatar'].first.content_type
-    assert_equal "me.jpg", person['person']['avatars']['avatar'].first.original_filename
-    assert_equal "ABC", person['person']['avatars']['avatar'].first.read
-
-    assert_equal "image/gif", person['person']['avatars']['avatar'].last.content_type
-    assert_equal "you.gif", person['person']['avatars']['avatar'].last.original_filename
-    assert_equal "DEF", person['person']['avatars']['avatar'].last.read
-  end
-
-  private
-    def parse_body(body)
-      env = { 'rack.input'     => StringIO.new(body),
-              'CONTENT_TYPE'   => 'application/xml',
-              'CONTENT_LENGTH' => body.size.to_s }
-      ActionController::Request.new(env).request_parameters
-    end
-end
-
-class LegacyXmlParamsParsingTest < XmlParamsParsingTest
-  private
-    def parse_body(body)
-      env = { 'rack.input'              => StringIO.new(body),
-              'HTTP_X_POST_DATA_FORMAT' => 'xml',
-              'CONTENT_LENGTH'          => body.size.to_s }
-      ActionController::Request.new(env).request_parameters
-    end
-end
-
-class JsonParamsParsingTest < ActiveSupport::TestCase
-  def test_hash_params_for_application_json
-    person = parse_body({:person => {:name => "David"}}.to_json,'application/json')[:person]
-    assert_kind_of Hash, person
-    assert_equal 'David', person['name']
-  end
-
-  def test_hash_params_for_application_jsonrequest
-    person = parse_body({:person => {:name => "David"}}.to_json,'application/jsonrequest')[:person]
-    assert_kind_of Hash, person
-    assert_equal 'David', person['name']
-  end
-
-  private
-    def parse_body(body,content_type)
-      env = { 'rack.input'     => StringIO.new(body),
-              'CONTENT_TYPE'   => content_type,
-              'CONTENT_LENGTH' => body.size.to_s }
-      ActionController::Request.new(env).request_parameters
-    end
-end
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 63f9827f4a..9f6b45f065 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -67,6 +67,11 @@ class RescueController < ActionController::Base
     render :text => 'no way'
   end
 
+  before_filter(:only => :before_filter_raises) { raise 'umm nice' }
+
+  def before_filter_raises
+  end
+
   def raises
     render :text => 'already rendered'
     raise "don't panic!"
@@ -154,6 +159,16 @@ class RescueControllerTest < ActionController::TestCase
     end
   end
 
+  def test_rescue_exceptions_raised_by_filters
+    with_rails_root FIXTURE_PUBLIC do
+      with_all_requests_local false do
+        get :before_filter_raises
+      end
+    end
+
+    assert_response :internal_server_error
+  end
+
   def test_rescue_action_locally_if_all_requests_local
     @controller.expects(:local_request?).never
     @controller.expects(:rescue_action_locally).with(@exception)
@@ -367,10 +382,21 @@ class RescueControllerTest < ActionController::TestCase
   end
 
   def test_rescue_dispatcher_exceptions
-    RescueController.process_with_exception(@request, @response, ActionController::RoutingError.new("Route not found"))
+    env = @request.env
+    env["action_controller.rescue.request"] = @request
+    env["action_controller.rescue.response"] = @response
+
+    RescueController.call_with_exception(env, ActionController::RoutingError.new("Route not found"))
     assert_equal "no way", @response.body
   end
 
+  def test_rescue_dispatcher_exceptions_without_request_set
+    @request.env['REQUEST_URI'] = '/no_way'
+    response = RescueController.call_with_exception(@request.env, ActionController::RoutingError.new("Route not found"))
+    assert_kind_of ActionController::Response, response
+    assert_equal "no way", response.body
+  end
+
   protected
     def with_all_requests_local(local = true)
       old_local, ActionController::Base.consider_all_requests_local =
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index d5b6bd6b2a..b981119e1e 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -706,7 +706,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       port_string = port == 80 ? '' : ":#{port}"
 
       protocol = options.delete(:protocol) || "http"
-      host     = options.delete(:host) || "named.route.test"
+      host     = options.delete(:host) || "test.host"
       anchor   = "##{options.delete(:anchor)}" if options.key?(:anchor)
 
       path = routes.generate(options)
@@ -715,27 +715,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     end
 
     def request
-      @request ||= MockRequest.new(:host => "named.route.test", :method => :get)
-    end
-  end
-
-  class MockRequest
-    attr_accessor :path, :path_parameters, :host, :subdomains, :domain, :method
-
-    def initialize(values={})
-      values.each { |key, value| send("#{key}=", value) }
-      if values[:host]
-        subdomain, self.domain = values[:host].split(/\./, 2)
-        self.subdomains = [subdomain]
-      end
-    end
-
-    def protocol
-      "http://"
-    end
-
-    def host_with_port
-      (subdomains * '.') + '.' +  domain
+      @request ||= ActionController::TestRequest.new
     end
   end
 
@@ -900,7 +880,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_basic_named_route
       rs.add_named_route :home, '', :controller => 'content', :action => 'list'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/",
+      assert_equal("http://test.host/",
                    x.send(:home_url))
     end
 
@@ -908,7 +888,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       rs.add_named_route :home, '', :controller => 'content', :action => 'list'
       x = setup_for_named_route
       ActionController::Base.relative_url_root = "/foo"
-      assert_equal("http://named.route.test/foo/",
+      assert_equal("http://test.host/foo/",
                    x.send(:home_url))
       assert_equal "/foo/", x.send(:home_path)
       ActionController::Base.relative_url_root = nil
@@ -917,14 +897,14 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_with_option
       rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page/new%20stuff",
+      assert_equal("http://test.host/page/new%20stuff",
                    x.send(:page_url, :title => 'new stuff'))
     end
 
     def test_named_route_with_default
       rs.add_named_route :page, 'page/:title', :controller => 'content', :action => 'show_page', :title => 'AboutPage'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page/AboutRails",
+      assert_equal("http://test.host/page/AboutRails",
                    x.send(:page_url, :title => "AboutRails"))
 
     end
@@ -932,21 +912,21 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_with_name_prefix
       rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :name_prefix => 'my_'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/page",
+      assert_equal("http://test.host/page",
                    x.send(:my_page_url))
     end
 
     def test_named_route_with_path_prefix
       rs.add_named_route :page, 'page', :controller => 'content', :action => 'show_page', :path_prefix => 'my'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/my/page",
+      assert_equal("http://test.host/my/page",
                    x.send(:page_url))
     end
 
     def test_named_route_with_nested_controller
       rs.add_named_route :users, 'admin/user', :controller => 'admin/user', :action => 'index'
       x = setup_for_named_route
-      assert_equal("http://named.route.test/admin/user",
+      assert_equal("http://test.host/admin/user",
                    x.send(:users_url))
     end
 
@@ -985,7 +965,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
         map.root :controller => "hello"
       end
       x = setup_for_named_route
-      assert_equal("http://named.route.test/", x.send(:root_url))
+      assert_equal("http://test.host/", x.send(:root_url))
       assert_equal("/", x.send(:root_path))
     end
 
@@ -1001,7 +981,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       #   x.send(:article_url, :title => 'hi')
       # )
       assert_equal(
-        "http://named.route.test/page/2005/6/10/hi",
+        "http://test.host/page/2005/6/10/hi",
         x.send(:article_url, :title => 'hi', :day => 10, :year => 2005, :month => 6)
       )
     end
@@ -1202,7 +1182,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       assert_equal '/test', rs.generate(:controller => 'post', :action => 'show', :year => nil)
 
       x = setup_for_named_route
-      assert_equal("http://named.route.test/test",
+      assert_equal("http://test.host/test",
                    x.send(:blog_url))
     end
 
@@ -1249,7 +1229,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       assert_equal '/', rs.generate(:controller => 'content')
 
       x = setup_for_named_route
-      assert_equal("http://named.route.test/",
+      assert_equal("http://test.host/",
                    x.send(:home_url))
     end
 
@@ -1591,7 +1571,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     end
 
     def request
-      @request ||= MockRequest.new(:host => "named.routes.test", :method => :get)
+      @request ||= ActionController::TestRequest.new
     end
 
     def test_generate_extras
@@ -1692,13 +1672,13 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_url_method
       controller = setup_named_route_test
 
-      assert_equal "http://named.route.test/people/5", controller.send(:show_url, :id => 5)
+      assert_equal "http://test.host/people/5", controller.send(:show_url, :id => 5)
       assert_equal "/people/5", controller.send(:show_path, :id => 5)
 
-      assert_equal "http://named.route.test/people", controller.send(:index_url)
+      assert_equal "http://test.host/people", controller.send(:index_url)
       assert_equal "/people", controller.send(:index_path)
 
-      assert_equal "http://named.route.test/admin/users", controller.send(:users_url)
+      assert_equal "http://test.host/admin/users", controller.send(:users_url)
       assert_equal '/admin/users', controller.send(:users_path)
       assert_equal '/admin/users', set.generate(controller.send(:hash_for_users_url), {:controller => 'users', :action => 'index'})
     end
@@ -1706,28 +1686,28 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
     def test_named_route_url_method_with_anchor
       controller = setup_named_route_test
 
-      assert_equal "http://named.route.test/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
+      assert_equal "http://test.host/people/5#location", controller.send(:show_url, :id => 5, :anchor => 'location')
       assert_equal "/people/5#location", controller.send(:show_path, :id => 5, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people#location", controller.send(:index_url, :anchor => 'location')
+      assert_equal "http://test.host/people#location", controller.send(:index_url, :anchor => 'location')
       assert_equal "/people#location", controller.send(:index_path, :anchor => 'location')
 
-      assert_equal "http://named.route.test/admin/users#location", controller.send(:users_url, :anchor => 'location')
+      assert_equal "http://test.host/admin/users#location", controller.send(:users_url, :anchor => 'location')
       assert_equal '/admin/users#location', controller.send(:users_path, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5#location",
+      assert_equal "http://test.host/people/go/7/hello/joe/5#location",
         controller.send(:multi_url, 7, "hello", 5, :anchor => 'location')
 
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5?baz=bar#location",
+      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar#location",
         controller.send(:multi_url, 7, "hello", 5, :baz => "bar", :anchor => 'location')
 
-      assert_equal "http://named.route.test/people?baz=bar#location",
+      assert_equal "http://test.host/people?baz=bar#location",
         controller.send(:index_url, :baz => "bar", :anchor => 'location')
     end
 
     def test_named_route_url_method_with_port
       controller = setup_named_route_test
-      assert_equal "http://named.route.test:8080/people/5", controller.send(:show_url, 5, :port=>8080)
+      assert_equal "http://test.host:8080/people/5", controller.send(:show_url, 5, :port=>8080)
     end
 
     def test_named_route_url_method_with_host
@@ -1737,30 +1717,30 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
 
     def test_named_route_url_method_with_protocol
       controller = setup_named_route_test
-      assert_equal "https://named.route.test/people/5", controller.send(:show_url, 5, :protocol => "https")
+      assert_equal "https://test.host/people/5", controller.send(:show_url, 5, :protocol => "https")
     end
 
     def test_named_route_url_method_with_ordered_parameters
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5",
+      assert_equal "http://test.host/people/go/7/hello/joe/5",
         controller.send(:multi_url, 7, "hello", 5)
     end
 
     def test_named_route_url_method_with_ordered_parameters_and_hash
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5?baz=bar",
+      assert_equal "http://test.host/people/go/7/hello/joe/5?baz=bar",
         controller.send(:multi_url, 7, "hello", 5, :baz => "bar")
     end
 
     def test_named_route_url_method_with_ordered_parameters_and_empty_hash
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people/go/7/hello/joe/5",
+      assert_equal "http://test.host/people/go/7/hello/joe/5",
         controller.send(:multi_url, 7, "hello", 5, {})
     end
 
     def test_named_route_url_method_with_no_positional_arguments
       controller = setup_named_route_test
-      assert_equal "http://named.route.test/people?baz=bar",
+      assert_equal "http://test.host/people?baz=bar",
         controller.send(:index_url, :baz => "bar")
     end
 
@@ -1896,49 +1876,54 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("index", request.path_parameters[:action])
+      request.recycle!
 
-      request.method = :post
+      request.env["REQUEST_METHOD"] = "POST"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("create", request.path_parameters[:action])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
+      request.recycle!
 
-      begin
-        request.method = :bacon
+      assert_raises(ActionController::UnknownHttpMethod) {
+        request.env["REQUEST_METHOD"] = "BACON"
         set.recognize(request)
-        flunk 'Should have raised NotImplemented'
-      rescue ActionController::NotImplemented => e
-        assert_equal [:get, :post, :put, :delete], e.allowed_methods
-      end
+      }
+      request.recycle!
 
       request.path = "/people/5"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :delete
+      request.env["REQUEST_METHOD"] = "DELETE"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("destroy", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
       begin
-        request.method = :post
+        request.env["REQUEST_METHOD"] = "POST"
         set.recognize(request)
         flunk 'Should have raised MethodNotAllowed'
       rescue ActionController::MethodNotAllowed => e
         assert_equal [:get, :put, :delete], e.allowed_methods
       end
+      request.recycle!
 
     ensure
       Object.send(:remove_const, :PeopleController)
@@ -1954,13 +1939,13 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
 
       request.path = "/"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -1978,7 +1963,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/articles/2005/11/05/a-very-interesting-article"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("permalink", request.path_parameters[:action])
       assert_equal("2005", request.path_parameters[:year])
@@ -2015,17 +2000,19 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/people/5"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
+      request.recycle!
 
-      request.method = :put
+      request.env["REQUEST_METHOD"] = "PUT"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("update", request.path_parameters[:action])
+      request.recycle!
 
       request.path = "/people/5.png"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("show", request.path_parameters[:action])
       assert_equal("5", request.path_parameters[:id])
@@ -2050,7 +2037,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       set.draw { |map| map.root :controller => "people" }
 
       request.path = ""
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("people", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -2070,7 +2057,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/api/inventory"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("inventory", request.path_parameters[:action])
@@ -2090,7 +2077,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/api"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
@@ -2110,7 +2097,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/prefix/inventory"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("api/products", request.path_parameters[:controller])
       assert_equal("inventory", request.path_parameters[:action])
@@ -2246,7 +2233,7 @@ uses_mocha 'LegacyRouteSet, Route, RouteSet and RouteLoading' do
       end
 
       request.path = "/projects/1/milestones"
-      request.method = :get
+      request.env["REQUEST_METHOD"] = "GET"
       assert_nothing_raised { set.recognize(request) }
       assert_equal("milestones", request.path_parameters[:controller])
       assert_equal("index", request.path_parameters[:action])
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 1b7486ad34..5fc79baa44 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -19,7 +19,8 @@ class SendFileController < ActionController::Base
   def rescue_action(e) raise end
 end
 
-class SendFileTest < Test::Unit::TestCase
+class SendFileTest < ActionController::TestCase
+  tests SendFileController
   include TestFileUtils
 
   Mime::Type.register "image/png", :png unless defined? Mime::PNG
diff --git a/actionpack/test/fixtures/multipart/hello.txt b/actionpack/test/fixtures/multipart/hello.txt
new file mode 100644
index 0000000000..5ab2f8a432
--- /dev/null
+++ b/actionpack/test/fixtures/multipart/hello.txt
@@ -0,0 +1 @@
+Hello
\ No newline at end of file
diff --git a/actionpack/test/template/asset_tag_helper_test.rb b/actionpack/test/template/asset_tag_helper_test.rb
index 7597927f6d..5e2fc20167 100644
--- a/actionpack/test/template/asset_tag_helper_test.rb
+++ b/actionpack/test/template/asset_tag_helper_test.rb
@@ -38,8 +38,6 @@ class AssetTagHelperTest < ActionView::TestCase
     @controller.request = @request
 
     ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
-    AssetTag::Cache.clear
-    AssetCollection::Cache.clear
   end
 
   def teardown
@@ -281,6 +279,26 @@ class AssetTagHelperTest < ActionView::TestCase
     assert_equal copy, source
   end
 
+  def test_caching_image_path_with_caching_and_proc_asset_host_using_request
+    ENV['RAILS_ASSET_ID'] = ''
+    ActionController::Base.asset_host = Proc.new do |source, request|
+      if request.ssl?
+        "#{request.protocol}#{request.host_with_port}"
+      else
+        "#{request.protocol}assets#{source.length}.example.com"
+      end
+    end
+    
+    ActionController::Base.perform_caching = true
+
+
+    @controller.request.stubs(:ssl?).returns(false)
+    assert_equal "http://assets15.example.com/images/xml.png", image_path("xml.png")
+
+    @controller.request.stubs(:ssl?).returns(true)
+    assert_equal "http://localhost/images/xml.png", image_path("xml.png")
+  end
+
   def test_caching_javascript_include_tag_when_caching_on
     ENV["RAILS_ASSET_ID"] = ""
     ActionController::Base.asset_host = 'http://a0.example.com'
diff --git a/actionpack/test/template/benchmark_helper_test.rb b/actionpack/test/template/benchmark_helper_test.rb
index 08d453c965..5d2af7cdd9 100644
--- a/actionpack/test/template/benchmark_helper_test.rb
+++ b/actionpack/test/template/benchmark_helper_test.rb
@@ -4,32 +4,25 @@ require 'action_view/helpers/benchmark_helper'
 class BenchmarkHelperTest < ActionView::TestCase
   tests ActionView::Helpers::BenchmarkHelper
 
-  class MockLogger
-    attr_reader :logged
-
-    def initialize
-      @logged = []
-    end
-
-    def method_missing(method, *args)
-      @logged << [method, args]
-    end
+  def teardown
+    controller.logger.send(:clear_buffer)
   end
 
   def controller
-    @controller ||= Struct.new(:logger).new(MockLogger.new)
+    logger = ActiveSupport::BufferedLogger.new(StringIO.new)
+    logger.auto_flushing = false
+    @controller ||= Struct.new(:logger).new(logger)
   end
 
   def test_without_block
     assert_raise(LocalJumpError) { benchmark }
-    assert controller.logger.logged.empty?
+    assert buffer.empty?
   end
 
   def test_defaults
     i_was_run = false
     benchmark { i_was_run = true }
     assert i_was_run
-    assert 1, controller.logger.logged.size
     assert_last_logged
   end
 
@@ -37,24 +30,57 @@ class BenchmarkHelperTest < ActionView::TestCase
     i_was_run = false
     benchmark('test_run') { i_was_run = true }
     assert i_was_run
-    assert 1, controller.logger.logged.size
     assert_last_logged 'test_run'
   end
 
-  def test_with_message_and_level
+  def test_with_message_and_deprecated_level
     i_was_run = false
-    benchmark('debug_run', :debug) { i_was_run = true }
+
+    assert_deprecated do
+      benchmark('debug_run', :debug) { i_was_run = true }
+    end
+
     assert i_was_run
-    assert 1, controller.logger.logged.size
-    assert_last_logged 'debug_run', :debug
+    assert_last_logged 'debug_run'
+  end
+
+  def test_within_level
+    controller.logger.level = ActiveSupport::BufferedLogger::DEBUG
+    benchmark('included_debug_run', :level => :debug) { }
+    assert_last_logged 'included_debug_run'
+  end
+
+  def test_outside_level
+    controller.logger.level = ActiveSupport::BufferedLogger::ERROR
+    benchmark('skipped_debug_run', :level => :debug) { }
+    assert_no_match(/skipped_debug_run/, buffer.last)
+  ensure
+    controller.logger.level = ActiveSupport::BufferedLogger::DEBUG
   end
 
+  def test_without_silencing
+    benchmark('debug_run', :silence => false) do
+      controller.logger.info "not silenced!"
+    end
+
+    assert_equal 2, buffer.size
+  end
+
+  def test_with_silencing
+    benchmark('debug_run', :silence => true) do
+      controller.logger.info "silenced!"
+    end
+
+    assert_equal 1, buffer.size
+  end
+
+
   private
-    def assert_last_logged(message = 'Benchmarking', level = :info)
-      last = controller.logger.logged.last
-      assert 2, last.size
-      assert_equal level, last.first
-      assert 1, last[1].size
-      assert last[1][0] =~ /^#{message} \(.*\)$/
+    def buffer
+      controller.logger.send(:buffer)
+    end
+  
+    def assert_last_logged(message = 'Benchmarking')
+      assert_match(/^#{message} \(.*\)$/, buffer.last)
     end
 end
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
index a68b09bb45..caea1bd643 100644
--- a/actionpack/test/template/compiled_templates_test.rb
+++ b/actionpack/test/template/compiled_templates_test.rb
@@ -31,7 +31,7 @@ uses_mocha 'TestTemplateRecompilation' do
     end
 
     def test_compiled_template_will_always_be_recompiled_when_template_is_not_cached
-      ActionView::Template.any_instance.expects(:loaded?).times(3).returns(false)
+      ActionView::Template.any_instance.expects(:recompile?).times(3).returns(true)
       assert_equal 0, @compiled_templates.instance_methods.size
       assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb")
       ActionView::Template.any_instance.expects(:compile!).times(3)
@@ -62,13 +62,14 @@ uses_mocha 'TestTemplateRecompilation' do
 
       def render_with_cache(*args)
         view_paths = ActionController::Base.view_paths
-        assert view_paths.first.loaded?
+        assert_equal ActionView::Template::EagerPath, view_paths.first.class
         ActionView::Base.new(view_paths, {}).render(*args)
       end
 
       def render_without_cache(*args)
-        view_paths = ActionView::Base.process_view_paths(FIXTURE_LOAD_PATH)
-        assert !view_paths.first.loaded?
+        path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH)
+        view_paths = ActionView::Base.process_view_paths(path)
+        assert_equal ActionView::Template::Path, view_paths.first.class
         ActionView::Base.new(view_paths, {}).render(*args)
       end
 
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 0387a11de2..4bd897efeb 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -197,7 +197,7 @@ class CachedViewRenderTest < Test::Unit::TestCase
   # Ensure view path cache is primed
   def setup
     view_paths = ActionController::Base.view_paths
-    assert view_paths.first.loaded?
+    assert_equal ActionView::Template::EagerPath, view_paths.first.class
     setup_view(view_paths)
   end
 end
@@ -208,8 +208,9 @@ class LazyViewRenderTest < Test::Unit::TestCase
   # Test the same thing as above, but make sure the view path
   # is not eager loaded
   def setup
-    view_paths = ActionView::Base.process_view_paths(FIXTURE_LOAD_PATH)
-    assert !view_paths.first.loaded?
+    path = ActionView::Template::Path.new(FIXTURE_LOAD_PATH)
+    view_paths = ActionView::Base.process_view_paths(path)
+    assert_equal ActionView::Template::Path, view_paths.first.class
     setup_view(view_paths)
   end
 end