Merge branch 'master' into active_model

Conflicts:
	activemodel/lib/active_model/core.rb
	activemodel/test/cases/state_machine/event_test.rb
	activemodel/test/cases/state_machine/state_transition_test.rb
	activerecord/lib/active_record/validations.rb
	activerecord/test/cases/validations/i18n_validation_test.rb
	activeresource/lib/active_resource.rb
	activeresource/test/abstract_unit.rb

273 files changed, 7843 insertions, 4511 deletions

diff --git a/actionpack/CHANGELOG b/actionpack/CHANGELOG
index 204f5ae272..e758983d7a 100644
--- a/actionpack/CHANGELOG
+++ b/actionpack/CHANGELOG
@@ -1,5 +1,15 @@
 *Edge*
 
+* Ruby 1.9: ERB template encoding using a magic comment at the top of the file.  [Jeremy Kemper]
+    <%# encoding: utf-8 %>
+
+* Change integration test helpers to accept Rack environment instead of just HTTP Headers [Pratik Naik]
+
+  Before :  get '/path', {}, 'Accept' => 'text/javascript'
+  After  :  get '/path', {}, 'HTTP_ACCEPT' => 'text/javascript'
+
+* Instead of checking Rails.env.test? in Failsafe middleware, check env["rails.raise_exceptions"] [Bryan Helmkamp]
+
 * Fixed that TestResponse.cookies was returning cookies unescaped #1867 [Doug McInnes]
 
 
diff --git a/actionpack/Rakefile b/actionpack/Rakefile
index 300c2ebf81..5f5614e58f 100644
--- a/actionpack/Rakefile
+++ b/actionpack/Rakefile
@@ -4,7 +4,6 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
-require 'rake/contrib/sshpublisher'
 require File.join(File.dirname(__FILE__), 'lib', 'action_pack', 'version')
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
@@ -23,26 +22,59 @@ task :default => [ :test ]
 # Run the unit tests
 
 desc "Run all unit tests"
-task :test => [:test_action_pack, :test_active_record_integration]
+task :test => [:test_action_pack, :test_active_record_integration, :test_new_base, :test_new_base_on_old_tests]
 
+test_lib_dirs = [ENV["NEW"] ? "test/new_base" : "test", "test/lib"]
 Rake::TestTask.new(:test_action_pack) do |t|
-  t.libs << "test"
+  t.libs.concat test_lib_dirs
 
   # make sure we include the tests in alphabetical order as on some systems
   # this will not happen automatically and the tests (as a whole) will error
-  t.test_files = Dir.glob( "test/[cdft]*/**/*_test.rb" ).sort
+  t.test_files = Dir.glob( "test/{controller,dispatch,template,html-scanner}/**/*_test.rb" ).sort
 
   t.verbose = true
   #t.warning = true
 end
+task :isolated_test do
+  ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))
+  Dir.glob("test/{controller,dispatch,template}/**/*_test.rb").all? do |file|
+    system(ruby, "-Ilib:#{test_lib_dirs * ':'}", file)
+  end or raise "Failures"
+end
 
 desc 'ActiveRecord Integration Tests'
 Rake::TestTask.new(:test_active_record_integration) do |t|
-  t.libs << "test"
+  t.libs.concat test_lib_dirs
   t.test_files = Dir.glob("test/activerecord/*_test.rb")
   t.verbose = true
 end
 
+desc 'New Controller Tests'
+Rake::TestTask.new(:test_new_base) do |t|
+  t.libs << "test/new_base" << "test/lib"
+  t.test_files = Dir.glob("test/{abstract_controller,new_base}/*_test.rb")
+  t.verbose = true
+end
+
+desc 'Old Controller Tests on New Base'
+Rake::TestTask.new(:test_new_base_on_old_tests) do |t|
+  t.libs << "test/new_base" << "test/lib"
+
+  t.verbose = true
+  # ==== Not ported
+  # * filters
+
+  t.test_files = Dir.glob( "test/{dispatch,template}/**/*_test.rb" ).sort + %w(
+    action_pack_assertions addresses_render assert_select
+    base benchmark caching capture content_type cookie dispatcher
+    filter_params flash helper http_basic_authentication
+    http_digest_authentication integration layout logging mime_responds
+    record_identifier redirect render render_js render_json
+    render_other render_xml request_forgery_protection rescue
+    resources routing selector send_file test url_rewriter
+    verification view_paths webservice
+  ).map { |name| "test/controller/#{name}_test.rb" }
+end
 
 # Genereate the RDoc documentation
 
@@ -136,12 +168,14 @@ task :update_js => [ :update_scriptaculous ]
 
 desc "Publish the API documentation"
 task :pgem => [:package] do 
+  require 'rake/contrib/sshpublisher'
   Rake::SshFilePublisher.new("gems.rubyonrails.org", "/u/sites/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
   `ssh gems.rubyonrails.org '/u/sites/gems/gemupdate.sh'`
 end
 
 desc "Publish the API documentation"
 task :pdoc => [:rdoc] do 
+  require 'rake/contrib/sshpublisher'
   Rake::SshDirPublisher.new("wrath.rubyonrails.org", "public_html/ap", "doc").upload
 end
 
diff --git a/actionpack/examples/minimal.rb b/actionpack/examples/minimal.rb
new file mode 100644
index 0000000000..9eb92cd8e7
--- /dev/null
+++ b/actionpack/examples/minimal.rb
@@ -0,0 +1,58 @@
+# Pass NEW=1 to run with the new Base
+ENV['RAILS_ENV'] ||= 'production'
+ENV['NO_RELOAD'] ||= '1'
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'action_controller'
+require 'action_controller/new_base' if ENV['NEW']
+require 'benchmark'
+
+class Runner
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    env['n'].to_i.times { @app.call(env) }
+    @app.call(env).tap { |response| report(env, response) }
+  end
+
+  def report(env, response)
+    out = env['rack.errors']
+    out.puts response[0], response[1].to_yaml, '---'
+    response[2].each { |part| out.puts part }
+    out.puts '---'
+  end
+
+  def self.run(app, n, label = nil)
+    puts '=' * label.size, label, '=' * label.size if label
+    env = { 'n' => n, 'rack.input' => StringIO.new(''), 'rack.errors' => $stdout }
+    t = Benchmark.realtime { new(app).call(env) }
+    puts "%d ms / %d req = %.1f usec/req" % [10**3 * t, n, 10**6 * t / n]
+    puts
+  end
+end
+
+
+N = (ENV['N'] || 1000).to_i
+
+class BasePostController < ActionController::Base
+  def index
+    render :text => ''
+  end
+end
+
+OK = [200, {}, []]
+MetalPostController = lambda { OK }
+
+if ActionController.const_defined?(:Http)
+  class HttpPostController < ActionController::Http
+    def index
+      self.response_body = ''
+    end
+  end
+end
+
+Runner.run(MetalPostController, N, 'metal')
+Runner.run(HttpPostController.action(:index), N, 'http') if defined? HttpPostController
+Runner.run(BasePostController.action(:index), N, 'base')
diff --git a/actionpack/lib/action_controller.rb b/actionpack/lib/action_controller.rb
index 100a0be1db..dd22bfd617 100644
--- a/actionpack/lib/action_controller.rb
+++ b/actionpack/lib/action_controller.rb
@@ -21,15 +21,9 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'active_support'
-rescue LoadError
-  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
-  if File.directory?(activesupport_path)
-    $:.unshift activesupport_path
-    require 'active_support'
-  end
-end
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
 
 require File.join(File.dirname(__FILE__), "action_pack")
 
@@ -59,7 +53,7 @@ module ActionController
   autoload :Redirector, 'action_controller/base/redirect'
   autoload :Renderer, 'action_controller/base/render'
   autoload :RequestForgeryProtection, 'action_controller/base/request_forgery_protection'
-  autoload :Rescue, 'action_controller/dispatch/rescue'
+  autoload :Rescue, 'action_controller/base/rescue'
   autoload :Resources, 'action_controller/routing/resources'
   autoload :Responder, 'action_controller/base/responder'
   autoload :Routing, 'action_controller/routing'
@@ -72,6 +66,7 @@ module ActionController
   autoload :UrlRewriter, 'action_controller/routing/generation/url_rewriter'
   autoload :UrlWriter, 'action_controller/routing/generation/url_rewriter'
   autoload :Verification, 'action_controller/base/verification'
+  autoload :FilterParameterLogging, 'action_controller/base/filter_parameter_logging'
 
   module Assertions
     autoload :DomAssertions, 'action_controller/testing/assertions/dom'
diff --git a/actionpack/lib/action_controller/abstract.rb b/actionpack/lib/action_controller/abstract.rb
index 3f5c4a185f..f46b91627f 100644
--- a/actionpack/lib/action_controller/abstract.rb
+++ b/actionpack/lib/action_controller/abstract.rb
@@ -1,5 +1,9 @@
+require "active_support/core_ext/module/attr_internal"
+require "active_support/core_ext/module/delegation"
+
 module AbstractController
   autoload :Base,           "action_controller/abstract/base"
+  autoload :Benchmarker,    "action_controller/abstract/benchmarker"
   autoload :Callbacks,      "action_controller/abstract/callbacks"
   autoload :Helpers,        "action_controller/abstract/helpers"
   autoload :Layouts,        "action_controller/abstract/layouts"
@@ -7,4 +11,4 @@ module AbstractController
   autoload :Renderer,       "action_controller/abstract/renderer"
   # === Exceptions
   autoload :ActionNotFound, "action_controller/abstract/exceptions"
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/base.rb b/actionpack/lib/action_controller/abstract/base.rb
index ade7719cc0..87083a4d79 100644
--- a/actionpack/lib/action_controller/abstract/base.rb
+++ b/actionpack/lib/action_controller/abstract/base.rb
@@ -1,41 +1,115 @@
+require 'active_support/core_ext/module/attr_internal'
+
 module AbstractController
+  class Error < StandardError; end
+
+  class DoubleRenderError < Error
+    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
   class Base
-    
     attr_internal :response_body
     attr_internal :response_obj
     attr_internal :action_name
-    
-    def self.process(action)
-      new.process(action)
-    end
-    
-    def self.inherited(klass)
+
+    class << self
+      attr_reader :abstract
+
+      def abstract!
+        @abstract = true
+      end
+
+      alias_method :abstract?, :abstract
+
+      def inherited(klass)
+        ::AbstractController::Base.subclasses << klass.to_s
+        super
+      end
+
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def internal_methods
+        controller = self
+        controller = controller.superclass until controller.abstract?
+        controller.public_instance_methods(true)
+      end
+
+      def process(action)
+        new.process(action.to_s)
+      end
+
+      def hidden_actions
+        []
+      end
+
+      def action_methods
+        @action_methods ||=
+          # All public instance methods of this class, including ancestors
+          public_instance_methods(true).map { |m| m.to_s }.to_set -
+          # Except for public instance methods of Base and its ancestors
+          internal_methods.map { |m| m.to_s } +
+          # Be sure to include shadowed public instance methods of this class
+          public_instance_methods(false).map { |m| m.to_s } -
+          # And always exclude explicitly hidden actions
+          hidden_actions
+      end
     end
-    
+
+    abstract!
+
     def initialize
       self.response_obj = {}
     end
-    
-    def process(action_name)
-      unless respond_to_action?(action_name)
-        raise ActionNotFound, "The action '#{action_name}' could not be found"
+
+    def process(action)
+      @_action_name = action_name = action.to_s
+
+      unless action_name = method_for_action(action_name)
+        raise ActionNotFound, "The action '#{action}' could not be found"
       end
-      
-      @_action_name = action_name
-      process_action
-      self.response_obj[:body] = self.response_body
+
+      process_action(action_name)
       self
     end
-    
+
   private
-  
-    def process_action
-      respond_to?(action_name) ? send(action_name) : send(:action_missing, action_name)
+    def action_methods
+      self.class.action_methods
+    end
+
+    def action_method?(action)
+      action_methods.include?(action)
     end
-    
-    def respond_to_action?(action_name)
-      respond_to?(action_name) || respond_to?(:action_missing, true)
+
+    # It is possible for respond_to?(action_name) to be false and
+    # respond_to?(:action_missing) to be false if respond_to_action?
+    # is overridden in a subclass. For instance, ActionController::Base
+    # overrides it to include the case where a template matching the
+    # action_name is found.
+    def process_action(method_name)
+      send_action(method_name)
+    end
+
+    alias send_action send
+
+    def _handle_action_missing
+      action_missing(@_action_name)
+    end
+
+    # Override this to change the conditions that will raise an
+    # ActionNotFound error. If you accept a difference case,
+    # you must handle it by also overriding process_action and
+    # handling the case.
+    def method_for_action(action_name)
+      if action_method?(action_name) then action_name
+      elsif respond_to?(:action_missing, true) then "_handle_action_missing"
+      end
     end
-    
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/benchmarker.rb b/actionpack/lib/action_controller/abstract/benchmarker.rb
new file mode 100644
index 0000000000..6999329144
--- /dev/null
+++ b/actionpack/lib/action_controller/abstract/benchmarker.rb
@@ -0,0 +1,28 @@
+module AbstractController
+  module Benchmarker
+    extend ActiveSupport::Concern
+
+    depends_on Logger
+
+    module ClassMethods
+      def benchmark(title, log_level = ::Logger::DEBUG, use_silence = true)
+        if logger && logger.level >= log_level
+          result = nil
+          ms = Benchmark.ms { result = use_silence ? silence { yield } : yield }
+          logger.add(log_level, "#{title} (#{('%.1f' % ms)}ms)")
+          result
+        else
+          yield
+        end
+      end
+
+      # Silences the logger for the duration of the block.
+      def silence
+        old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
+        yield
+      ensure
+        logger.level = old_logger_level if logger
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/abstract/callbacks.rb b/actionpack/lib/action_controller/abstract/callbacks.rb
index c8b509081c..6c67315c58 100644
--- a/actionpack/lib/action_controller/abstract/callbacks.rb
+++ b/actionpack/lib/action_controller/abstract/callbacks.rb
@@ -1,28 +1,31 @@
 module AbstractController
   module Callbacks
-    setup do
-      include ActiveSupport::NewCallbacks
-      define_callbacks :process_action      
+    extend ActiveSupport::Concern
+
+    depends_on ActiveSupport::NewCallbacks
+
+    included do
+      define_callbacks :process_action, "response_body"
     end
-    
-    def process_action
-      _run_process_action_callbacks(action_name) do
+
+    def process_action(method_name)
+      _run_process_action_callbacks(method_name) do
         super
       end
     end
-    
+
     module ClassMethods
       def _normalize_callback_options(options)
         if only = options[:only]
-          only = Array(only).map {|o| "action_name == :#{o}"}.join(" || ")
+          only = Array(only).map {|o| "action_name == '#{o}'"}.join(" || ")
           options[:per_key] = {:if => only}
         end
         if except = options[:except]
-          except = Array(except).map {|e| "action_name == :#{e}"}.join(" || ")          
+          except = Array(except).map {|e| "action_name == '#{e}'"}.join(" || ")
           options[:per_key] = {:unless => except}
         end
       end
-      
+
       [:before, :after, :around].each do |filter|
         class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
           def #{filter}_filter(*names, &blk)
@@ -33,8 +36,28 @@ module AbstractController
               process_action_callback(:#{filter}, name, options)
             end
           end
+
+          def prepend_#{filter}_filter(*names, &blk)
+            options = names.last.is_a?(Hash) ? names.pop : {}
+            _normalize_callback_options(options)
+            names.push(blk) if block_given?
+            names.each do |name|
+              process_action_callback(:#{filter}, name, options.merge(:prepend => true))
+            end
+          end
+
+          def skip_#{filter}_filter(*names, &blk)
+            options = names.last.is_a?(Hash) ? names.pop : {}
+            _normalize_callback_options(options)
+            names.push(blk) if block_given?
+            names.each do |name|
+              skip_process_action_callback(:#{filter}, name, options)
+            end
+          end
+
+          alias_method :append_#{filter}_filter, :#{filter}_filter
         RUBY_EVAL
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/exceptions.rb b/actionpack/lib/action_controller/abstract/exceptions.rb
index ec4680629b..2f6c55f068 100644
--- a/actionpack/lib/action_controller/abstract/exceptions.rb
+++ b/actionpack/lib/action_controller/abstract/exceptions.rb
@@ -1,3 +1,3 @@
 module AbstractController
-  class ActionNotFound < StandardError ; end
-end
\ No newline at end of file
+  class ActionNotFound < StandardError; end
+end
diff --git a/actionpack/lib/action_controller/abstract/helpers.rb b/actionpack/lib/action_controller/abstract/helpers.rb
index 1f0b38417b..43832f1e2d 100644
--- a/actionpack/lib/action_controller/abstract/helpers.rb
+++ b/actionpack/lib/action_controller/abstract/helpers.rb
@@ -1,19 +1,14 @@
 module AbstractController
   module Helpers
+    extend ActiveSupport::Concern
+
     depends_on Renderer
-    
-    setup do
+
+    included do
       extlib_inheritable_accessor :master_helper_module
       self.master_helper_module = Module.new
     end
-  
-    # def self.included(klass)
-    #   klass.class_eval do
-    #     extlib_inheritable_accessor :master_helper_module
-    #     self.master_helper_module = Module.new
-    #   end
-    # end
-    
+
     def _action_view
       @_action_view ||= begin
         av = super
@@ -21,19 +16,38 @@ module AbstractController
         av
       end
     end
-    
+
     module ClassMethods
       def inherited(klass)
         klass.master_helper_module = Module.new
         klass.master_helper_module.__send__ :include, master_helper_module
-        
+
         super
       end
-      
+
+      # Makes all the (instance) methods in the helper module available to templates rendered through this controller.
+      # See ActionView::Helpers (link:classes/ActionView/Helpers.html) for more about making your own helper modules
+      # available to the templates.
       def add_template_helper(mod)
         master_helper_module.module_eval { include mod }
       end
-      
+
+      # Declare a controller method as a helper. For example, the following
+      # makes the +current_user+ controller method available to the view:
+      #   class ApplicationController < ActionController::Base
+      #     helper_method :current_user, :logged_in?
+      #
+      #     def current_user
+      #       @current_user ||= User.find_by_id(session[:user])
+      #     end
+      #
+      #      def logged_in?
+      #        current_user != nil
+      #      end
+      #   end
+      #
+      # In a view:
+      #  <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
       def helper_method(*meths)
         meths.flatten.each do |meth|
           master_helper_module.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
@@ -43,17 +57,16 @@ module AbstractController
           ruby_eval
         end
       end
-      
-      def helper(*args, &blk)
+
+      def helper(*args, &block)
         args.flatten.each do |arg|
           case arg
           when Module
             add_template_helper(arg)
           end
         end
-        master_helper_module.module_eval(&blk) if block_given?
+        master_helper_module.module_eval(&block) if block_given?
       end
     end
-    
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/layouts.rb b/actionpack/lib/action_controller/abstract/layouts.rb
index 478b301a26..b3f21f7b22 100644
--- a/actionpack/lib/action_controller/abstract/layouts.rb
+++ b/actionpack/lib/action_controller/abstract/layouts.rb
@@ -1,25 +1,34 @@
 module AbstractController
   module Layouts
-    
+    extend ActiveSupport::Concern
+
     depends_on Renderer
-        
+
+    included do
+      extlib_inheritable_accessor :_layout_conditions
+      self._layout_conditions = {}
+    end
+
     module ClassMethods
-      def layout(layout)
+      def layout(layout, conditions = {})
         unless [String, Symbol, FalseClass, NilClass].include?(layout.class)
           raise ArgumentError, "Layouts must be specified as a String, Symbol, false, or nil"
         end
-        
+
+        conditions.each {|k, v| conditions[k] = Array(v).map {|a| a.to_s} }
+        self._layout_conditions = conditions
+
         @_layout = layout || false # Converts nil to false
         _write_layout_method
       end
-      
+
       def _implied_layout_name
         name.underscore
       end
-      
+
       # Takes the specified layout and creates a _layout method to be called
       # by _default_layout
-      # 
+      #
       # If the specified layout is a:
       # String:: return the string
       # Symbol:: call the method specified by the symbol
@@ -30,15 +39,15 @@ module AbstractController
       def _write_layout_method
         case @_layout
         when String
-          self.class_eval %{def _layout() #{@_layout.inspect} end}
+          self.class_eval %{def _layout(details) #{@_layout.inspect} end}
         when Symbol
-          self.class_eval %{def _layout() #{@_layout} end}
+          self.class_eval %{def _layout(details) #{@_layout} end}
         when false
-          self.class_eval %{def _layout() end}
+          self.class_eval %{def _layout(details) end}
         else
           self.class_eval %{
-            def _layout
-              if view_paths.find_by_parts?("#{_implied_layout_name}", formats, "layouts")
+            def _layout(details)
+              if view_paths.find_by_parts?("#{_implied_layout_name}", details, "layouts")
                 "#{_implied_layout_name}"
               else
                 super
@@ -48,35 +57,51 @@ module AbstractController
         end
       end
     end
-    
-    def _render_template(template, options)
-      _action_view._render_template_with_layout(template, options[:_layout])
-    end
-        
+
   private
-  
-    def _layout() end # This will be overwritten
-    
-    def _layout_for_name(name)
+    # This will be overwritten
+    def _layout(details)
+    end
+
+    # :api: plugin
+    # ====
+    # Override this to mutate the inbound layout name
+    def _layout_for_name(name, details = {:formats => formats})
       unless [String, FalseClass, NilClass].include?(name.class)
         raise ArgumentError, "String, false, or nil expected; you passed #{name.inspect}"
       end
-      
-      name && view_paths.find_by_parts(name, formats, "layouts")
+
+      name && view_paths.find_by_parts(name, details, _layout_prefix(name))
     end
-    
-    def _default_layout(require_layout = false)
-      if require_layout && !_layout
-        raise ArgumentError, 
+
+    # TODO: Decide if this is the best hook point for the feature
+    def _layout_prefix(name)
+      "layouts"
+    end
+
+    def _default_layout(require_layout = false, details = {:formats => formats})
+      if require_layout && _action_has_layout? && !_layout(details)
+        raise ArgumentError,
           "There was no default layout for #{self.class} in #{view_paths.inspect}"
       end
-        
+
       begin
-        layout = _layout_for_name(_layout)
+        _layout_for_name(_layout(details), details) if _action_has_layout?
       rescue NameError => e
-        raise NoMethodError, 
+        raise NoMethodError,
           "You specified #{@_layout.inspect} as the layout, but no such method was found"
       end
     end
+
+    def _action_has_layout?
+      conditions = _layout_conditions
+      if only = conditions[:only]
+        only.include?(action_name)
+      elsif except = conditions[:except]
+        !except.include?(action_name)
+      else
+        true
+      end
+    end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/logger.rb b/actionpack/lib/action_controller/abstract/logger.rb
index 4117369bd4..d6fa843485 100644
--- a/actionpack/lib/action_controller/abstract/logger.rb
+++ b/actionpack/lib/action_controller/abstract/logger.rb
@@ -1,7 +1,45 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/logger'
+
 module AbstractController
   module Logger
-    setup do
+    extend ActiveSupport::Concern
+
+    class DelayedLog
+      def initialize(&blk)
+        @blk = blk
+      end
+
+      def to_s
+        @blk.call
+      end
+      alias to_str to_s
+    end
+
+    included do
       cattr_accessor :logger
     end
+
+    def process(action)
+      ret = super
+
+      if logger
+        log = DelayedLog.new do
+          "\n\nProcessing #{self.class.name}\##{action_name} " \
+          "to #{request.formats} " \
+          "(for #{request_origin}) [#{request.method.to_s.upcase}]"
+        end
+
+        logger.info(log)
+      end
+
+      ret
+    end
+
+    def request_origin
+      # this *needs* to be cached!
+      # otherwise you'd get different results if calling it more than once
+      @request_origin ||= "#{request.remote_ip} at #{Time.now.to_s(:db)}"
+    end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/abstract/renderer.rb b/actionpack/lib/action_controller/abstract/renderer.rb
index a86eef889e..cd3e87d861 100644
--- a/actionpack/lib/action_controller/abstract/renderer.rb
+++ b/actionpack/lib/action_controller/abstract/renderer.rb
@@ -2,52 +2,63 @@ require "action_controller/abstract/logger"
 
 module AbstractController
   module Renderer
+    extend ActiveSupport::Concern
+
     depends_on AbstractController::Logger
-    
-    setup do
+
+    included do
       attr_internal :formats
-      
+
       extlib_inheritable_accessor :_view_paths
-      
+
       self._view_paths ||= ActionView::PathSet.new
     end
-        
+
     def _action_view
-      @_action_view ||= ActionView::Base.new(self.class.view_paths, {}, self)      
+      @_action_view ||= ActionView::Base.new(self.class.view_paths, {}, self)
     end
-        
-    def render(options = {})
-      self.response_body = render_to_body(options)
+
+    def render(*args)
+      if response_body
+        raise AbstractController::DoubleRenderError, "OMG"
+      end
+
+      self.response_body = render_to_body(*args)
     end
-    
+
     # Raw rendering of a template to a Rack-compatible body.
     # ====
     # @option _prefix<String> The template's path prefix
     # @option _layout<String> The relative path to the layout template to use
-    # 
+    #
     # :api: plugin
     def render_to_body(options = {})
-      name = options[:_template_name] || action_name
-      
-      template = options[:_template] || view_paths.find_by_parts(name.to_s, formats, options[:_prefix])
-      _render_template(template, options)
+      # TODO: Refactor so we can just use the normal template logic for this
+      if options[:_partial_object]
+        _action_view._render_partial_from_controller(options)
+      else
+        _determine_template(options)
+        _render_template(options)
+      end
     end
 
     # Raw rendering of a template to a string.
     # ====
     # @option _prefix<String> The template's path prefix
     # @option _layout<String> The relative path to the layout template to use
-    # 
+    #
     # :api: plugin
     def render_to_string(options = {})
       AbstractController::Renderer.body_to_s(render_to_body(options))
     end
 
-    def _render_template(template, options)
-      _action_view._render_template_with_layout(template)
+    def _render_template(options)
+      _action_view._render_template_from_controller(options[:_template], options[:_layout], options, options[:_partial])
+    end
+
+    def view_paths()
+      _view_paths
     end
-    
-    def view_paths() _view_paths end
 
     # Return a string representation of a Rack-compatible response body.
     def self.body_to_s(body)
@@ -61,16 +72,28 @@ module AbstractController
       end
     end
 
+  private
+    def _determine_template(options)
+      name = (options[:_template_name] || action_name).to_s
+
+      options[:_template] ||= view_paths.find_by_parts(
+        name, { :formats => formats }, options[:_prefix], options[:_partial]
+      )
+    end
+
     module ClassMethods
-      
       def append_view_path(path)
         self.view_paths << path
       end
-      
+
+      def prepend_view_path(path)
+        self.view_paths.unshift(path)
+      end
+
       def view_paths
         self._view_paths
       end
-      
+
       def view_paths=(paths)
         self._view_paths = paths.is_a?(ActionView::PathSet) ?
                             paths : ActionView::Base.process_view_paths(paths)
diff --git a/actionpack/lib/action_controller/base/base.rb b/actionpack/lib/action_controller/base/base.rb
index 3000b3d12f..67369eb122 100644
--- a/actionpack/lib/action_controller/base/base.rb
+++ b/actionpack/lib/action_controller/base/base.rb
@@ -1,5 +1,7 @@
 require 'action_controller/deprecated'
 require 'set'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/core_ext/module/attr_internal'
 
 module ActionController #:nodoc:
   class ActionControllerError < StandardError #:nodoc:
@@ -30,10 +32,6 @@ module ActionController #:nodoc:
     def allowed_methods_header
       allowed_methods.map { |method_symbol| method_symbol.to_s.upcase } * ', '
     end
-
-    def handle_response!(response)
-      response.headers['Allow'] ||= allowed_methods_header
-    end
   end
 
   class NotImplemented < MethodNotAllowed #:nodoc:
@@ -238,13 +236,12 @@ module ActionController #:nodoc:
     cattr_reader :protected_instance_variables
     # Controller specific instance variables which will not be accessible inside views.
     @@protected_instance_variables = %w(@assigns @performed_redirect @performed_render @variables_added @request_origin @url @parent_controller
-                                        @action_name @before_filter_chain_aborted @action_cache_path @_session @_headers @_params
+                                        @action_name @before_filter_chain_aborted @action_cache_path @_headers @_params
                                         @_flash @_response)
 
     # Prepends all the URL-generating helpers from AssetHelper. This makes it possible to easily move javascripts, stylesheets,
     # and images to a dedicated asset server away from the main web server. Example:
     #   ActionController::Base.asset_host = "http://assets.example.com"
-    @@asset_host = ""
     cattr_accessor :asset_host
 
     # All requests are considered local by default, so everyone will be exposed to detailed debugging screens on errors.
@@ -356,7 +353,9 @@ module ActionController #:nodoc:
 
     # Holds a hash of objects in the session. Accessed like <tt>session[:person]</tt> to get the object tied to the "person"
     # key. The session will hold any type of object as values, but the key should be a string or symbol.
-    attr_internal :session
+    def session
+      request.session
+    end
 
     # Holds a hash of header names and values. Accessed like <tt>headers["Cache-Control"]</tt> to get the value of the Cache-Control
     # directive. Values should always be specified as strings.
@@ -365,19 +364,24 @@ module ActionController #:nodoc:
     # Returns the name of the action this controller is processing.
     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"] ||= ActionDispatch::Request.new(env)
-        response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
-        process(request, response)
-      end
+    attr_reader :template
 
-      # Factory for the standard create, process loop where the controller is discarded after processing.
-      def process(request, response) #:nodoc:
-        new.process(request, response)
-      end
+    def action(name, env)
+      request  = ActionDispatch::Request.new(env)
+      response = ActionDispatch::Response.new
+      self.action_name = name && name.to_s
+      process(request, response).to_a
+    end
 
+
+    class << self
+      def action(name = nil)
+        @actions ||= {}
+        @actions[name] ||= proc do |env|
+          new.action(name, env)
+        end
+      end
+      
       # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
       def controller_class_name
         @controller_class_name ||= name.demodulize
@@ -443,60 +447,27 @@ module ActionController #:nodoc:
         @view_paths = superclass.view_paths.dup if @view_paths.nil?
         @view_paths.push(*path)
       end
-
-      # Replace sensitive parameter data from the request log.
-      # Filters parameters that have any of the arguments as a substring.
-      # Looks in all subhashes of the param hash for keys to filter.
-      # If a block is given, each key and value of the parameter hash and all
-      # subhashes is passed to it, the value or key
-      # can be replaced using String#replace or similar method.
-      #
-      # Examples:
-      #   filter_parameter_logging
-      #   => Does nothing, just slows the logging process down
-      #
-      #   filter_parameter_logging :password
-      #   => replaces the value to all keys matching /password/i with "[FILTERED]"
-      #
-      #   filter_parameter_logging :foo, "bar"
-      #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
-      #
-      #   filter_parameter_logging { |k,v| v.reverse! if k =~ /secret/i }
-      #   => reverses the value to all keys matching /secret/i
-      #
-      #   filter_parameter_logging(:foo, "bar") { |k,v| v.reverse! if k =~ /secret/i }
-      #   => reverses the value to all keys matching /secret/i, and
-      #      replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
-      def filter_parameter_logging(*filter_words, &block)
-        parameter_filter = Regexp.new(filter_words.collect{ |s| s.to_s }.join('|'), true) if filter_words.length > 0
-
-        define_method(:filter_parameters) do |unfiltered_parameters|
-          filtered_parameters = {}
-
-          unfiltered_parameters.each do |key, value|
-            if key =~ parameter_filter
-              filtered_parameters[key] = '[FILTERED]'
-            elsif value.is_a?(Hash)
-              filtered_parameters[key] = filter_parameters(value)
-            elsif block_given?
-              key = key.dup
-              value = value.dup if value
-              yield key, value
-              filtered_parameters[key] = value
-            else
-              filtered_parameters[key] = value
-            end
-          end
-
-          filtered_parameters
+      
+      @@exempt_from_layout = [ActionView::TemplateHandlers::RJS]
+      
+      def exempt_from_layout(*types)
+        types.each do |type|
+          @@exempt_from_layout << 
+            ActionView::Template.handler_class_for_extension(type)
         end
-        protected :filter_parameters
+        
+        @@exempt_from_layout
       end
 
-      delegate :exempt_from_layout, :to => 'ActionView::Template'
     end
 
     public
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        response = ActionDispatch::Response.new
+        process(request, response).to_a
+      end
+
       # Extracts the action_name from the request parameters and performs that action.
       def process(request, response, method = :perform_action, *arguments) #:nodoc:
         response.request = request
@@ -504,7 +475,6 @@ module ActionController #:nodoc:
         assign_shortcuts(request, response)
         initialize_template_class(response)
         initialize_current_url
-        assign_names
 
         log_processing
         send(method, *arguments)
@@ -787,7 +757,6 @@ module ActionController #:nodoc:
       # Resets the session by clearing out all the objects stored within and initializing a new session object.
       def reset_session #:doc:
         request.reset_session
-        @_session = request.session
       end
 
     private
@@ -804,20 +773,14 @@ module ActionController #:nodoc:
       end
 
       def initialize_template_class(response)
-        @template = response.template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
-        response.template.helpers.send :include, self.class.master_helper_module
-        response.redirected_to = nil
+        @template = ActionView::Base.new(self.class.view_paths, {}, self, formats)
+        response.template = @template if response.respond_to?(:template=)
+        @template.helpers.send :include, self.class.master_helper_module
         @performed_render = @performed_redirect = false
       end
 
       def assign_shortcuts(request, response)
-        @_request, @_params = request, request.parameters
-
-        @_response         = response
-        @_response.session = request.session
-
-        @_session = @_response.session
-
+        @_request, @_response, @_params = request, response, request.parameters
         @_headers = @_response.headers
       end
 
@@ -840,13 +803,6 @@ module ActionController #:nodoc:
         logger.info(request_id)
       end
 
-      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
-
       def default_render #:nodoc:
         render
       end
@@ -861,13 +817,13 @@ module ActionController #:nodoc:
         return (performed? ? ret : default_render) if called
         
         begin
-          default_render
-        rescue ActionView::MissingTemplate => e
-          raise e unless e.action_name == action_name
-          # If the path is the same as the action_name, the action is completely missing
+          view_paths.find_by_parts(action_name, {:formats => formats, :locales => [I18n.locale]}, controller_path)
+        rescue => e
           raise UnknownAction, "No action responded to #{action_name}. Actions: " +
             "#{action_methods.sort.to_sentence}", caller
         end
+        
+        default_render
       end
 
       # Returns true if a render or redirect has already been performed.
@@ -875,10 +831,6 @@ module ActionController #:nodoc:
         @performed_render || @performed_redirect
       end
 
-      def assign_names
-        @action_name = (params['action'] || 'index')
-      end
-
       def reset_variables_added_to_assigns
         @template.instance_variable_set("@assigns_added", nil)
       end
@@ -894,10 +846,6 @@ module ActionController #:nodoc:
         "#{request.protocol}#{request.host}#{request.request_uri}"
       end
 
-      def close_session
-        # @_session.close if @_session && @_session.respond_to?(:close)
-      end
-
       def default_template(action_name = self.action_name)
         self.view_paths.find_template(default_template_name(action_name), default_template_format)
       end
@@ -921,7 +869,6 @@ module ActionController #:nodoc:
       end
 
       def process_cleanup
-        close_session
       end
   end
 
@@ -929,7 +876,7 @@ module ActionController #:nodoc:
     [ Filters, Layout, Renderer, Redirector, Responder, Benchmarking, Rescue, Flash, MimeResponds, Helpers,
       Cookies, Caching, Verification, Streaming, SessionManagement,
       HttpAuthentication::Basic::ControllerMethods, HttpAuthentication::Digest::ControllerMethods, RecordIdentifier,
-      RequestForgeryProtection, Translation
+      RequestForgeryProtection, Translation, FilterParameterLogging
     ].each do |mod|
       include mod
     end
diff --git a/actionpack/lib/action_controller/base/chained/benchmarking.rb b/actionpack/lib/action_controller/base/chained/benchmarking.rb
index 066150f58a..57a1ac8314 100644
--- a/actionpack/lib/action_controller/base/chained/benchmarking.rb
+++ b/actionpack/lib/action_controller/base/chained/benchmarking.rb
@@ -1,4 +1,4 @@
-require 'benchmark'
+require 'active_support/core_ext/benchmark'
 
 module ActionController #:nodoc:
   # The benchmarking module times the performance of actions and reports to the logger. If the Active Record
@@ -21,7 +21,7 @@ module ActionController #:nodoc:
       # easy to include benchmarking statements in production software that will remain inexpensive because the benchmark
       # will only be conducted if the log level is low enough.
       def benchmark(title, log_level = Logger::DEBUG, use_silence = true)
-        if logger && logger.level == log_level
+        if logger && logger.level >= log_level
           result = nil
           ms = Benchmark.ms { result = use_silence ? silence { yield } : yield }
           logger.add(log_level, "#{title} (#{('%.1f' % ms)}ms)")
diff --git a/actionpack/lib/action_controller/base/chained/filters.rb b/actionpack/lib/action_controller/base/chained/filters.rb
index 9022b8b279..e121c0129d 100644
--- a/actionpack/lib/action_controller/base/chained/filters.rb
+++ b/actionpack/lib/action_controller/base/chained/filters.rb
@@ -160,7 +160,7 @@ module ActionController #:nodoc:
         def convert_only_and_except_options_to_sets_of_strings(opts)
           [:only, :except].each do |key|
             if values = opts[key]
-              opts[key] = Array(values).map(&:to_s).to_set
+              opts[key] = Array(values).map {|val| val.to_s }.to_set
             end
           end
         end
@@ -571,12 +571,7 @@ module ActionController #:nodoc:
 
       # Returns an array of Filter objects for this controller.
       def filter_chain
-        if chain = read_inheritable_attribute('filter_chain')
-          return chain
-        else
-          write_inheritable_attribute('filter_chain', FilterChain.new)
-          return filter_chain
-        end
+        read_inheritable_attribute('filter_chain') || write_inheritable_attribute('filter_chain', FilterChain.new)
       end
 
       # Returns all the before filters for this class and all its ancestors.
diff --git a/actionpack/lib/action_controller/base/chained/flash.rb b/actionpack/lib/action_controller/base/chained/flash.rb
index 56ee9c67e2..04d27bf090 100644
--- a/actionpack/lib/action_controller/base/chained/flash.rb
+++ b/actionpack/lib/action_controller/base/chained/flash.rb
@@ -26,9 +26,18 @@ module ActionController #:nodoc:
   #
   # See docs on the FlashHash class for more details about the flash.
   module Flash
-    def self.included(base)
-      base.class_eval do
-        include InstanceMethods
+    extend ActiveSupport::Concern
+
+    # TODO : Remove the defined? check when new base is the main base
+    depends_on Session if defined?(ActionController::Http)
+
+    included do
+      # TODO : Remove the defined? check when new base is the main base
+      if defined?(ActionController::Http)
+        include InstanceMethodsForNewBase
+      else
+        include InstanceMethodsForBase
+
         alias_method_chain :perform_action, :flash
         alias_method_chain :reset_session,  :flash
       end
@@ -120,44 +129,68 @@ module ActionController #:nodoc:
         (@used.keys - keys).each{ |k| @used.delete(k) }
       end
 
+      def store(session, key = "flash")
+        return if self.empty?
+        session[key] = self
+      end
+
       private
         # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
         #     use()               # marks the entire flash as used
         #     use('msg')          # marks the "msg" entry as used
         #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
         #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
-        def use(k=nil, v=true)
-          unless k.nil?
-            @used[k] = v
-          else
-            keys.each{ |key| use(key, v) }
-          end
+        # Returns the single value for the key you asked to be marked (un)used or the FlashHash itself
+        # if no key is passed.
+        def use(key = nil, used = true)
+          Array(key || keys).each { |k| @used[k] = used }
+          return key ? self[key] : self
         end
     end
 
-    module InstanceMethods #:nodoc:
+    module InstanceMethodsForBase #:nodoc:
       protected
         def perform_action_with_flash
           perform_action_without_flash
-          remove_instance_variable(:@_flash) if defined? @_flash
+          if defined? @_flash
+            @_flash.store(session)
+            remove_instance_variable(:@_flash)
+          end
         end
 
         def reset_session_with_flash
           reset_session_without_flash
-          remove_instance_variable(:@_flash) if defined? @_flash
+          remove_instance_variable(:@_flash) if defined?(@_flash)
         end
+    end
 
-        # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
-        # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
-        # to put a new one.
-        def flash #:doc:
-          unless defined? @_flash
-            @_flash = session["flash"] ||= FlashHash.new
-            @_flash.sweep
+    module InstanceMethodsForNewBase #:nodoc:
+      protected
+        def process_action(method_name)
+          super
+          if defined? @_flash
+            @_flash.store(session)
+            remove_instance_variable(:@_flash)
           end
+        end
 
-          @_flash
+        def reset_session
+          super
+          remove_instance_variable(:@_flash) if defined?(@_flash)
         end
     end
+
+    protected
+      # Access the contents of the flash. Use <tt>flash["notice"]</tt> to
+      # read a notice you put there or <tt>flash["notice"] = "hello"</tt>
+      # to put a new one.
+      def flash #:doc:
+        if !defined?(@_flash)
+          @_flash = session["flash"] || FlashHash.new
+          @_flash.sweep
+        end
+
+        @_flash
+      end
   end
 end
diff --git a/actionpack/lib/action_controller/base/cookies.rb b/actionpack/lib/action_controller/base/cookies.rb
index ca380e98d0..d4806623c3 100644
--- a/actionpack/lib/action_controller/base/cookies.rb
+++ b/actionpack/lib/action_controller/base/cookies.rb
@@ -51,7 +51,7 @@ module ActionController #:nodoc:
     protected
       # Returns the cookie container, which operates as described above.
       def cookies
-        CookieJar.new(self)
+        @cookies ||= CookieJar.new(self)
       end
   end
 
diff --git a/actionpack/lib/action_controller/base/filter_parameter_logging.rb b/actionpack/lib/action_controller/base/filter_parameter_logging.rb
new file mode 100644
index 0000000000..9df286ee24
--- /dev/null
+++ b/actionpack/lib/action_controller/base/filter_parameter_logging.rb
@@ -0,0 +1,97 @@
+module ActionController
+  module FilterParameterLogging
+    extend ActiveSupport::Concern
+
+    # TODO : Remove the defined? check when new base is the main base
+    if defined?(ActionController::Http)
+      depends_on AbstractController::Logger
+    end
+
+    included do
+      if defined?(ActionController::Http)
+        include InstanceMethodsForNewBase
+      end
+    end
+
+    module ClassMethods
+      # Replace sensitive parameter data from the request log.
+      # Filters parameters that have any of the arguments as a substring.
+      # Looks in all subhashes of the param hash for keys to filter.
+      # If a block is given, each key and value of the parameter hash and all
+      # subhashes is passed to it, the value or key
+      # can be replaced using String#replace or similar method.
+      #
+      # Examples:
+      #   filter_parameter_logging
+      #   => Does nothing, just slows the logging process down
+      #
+      #   filter_parameter_logging :password
+      #   => replaces the value to all keys matching /password/i with "[FILTERED]"
+      #
+      #   filter_parameter_logging :foo, "bar"
+      #   => replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
+      #
+      #   filter_parameter_logging { |k,v| v.reverse! if k =~ /secret/i }
+      #   => reverses the value to all keys matching /secret/i
+      #
+      #   filter_parameter_logging(:foo, "bar") { |k,v| v.reverse! if k =~ /secret/i }
+      #   => reverses the value to all keys matching /secret/i, and
+      #      replaces the value to all keys matching /foo|bar/i with "[FILTERED]"
+      def filter_parameter_logging(*filter_words, &block)
+        parameter_filter = Regexp.new(filter_words.collect{ |s| s.to_s }.join('|'), true) if filter_words.length > 0
+
+        define_method(:filter_parameters) do |unfiltered_parameters|
+          filtered_parameters = {}
+
+          unfiltered_parameters.each do |key, value|
+            if key =~ parameter_filter
+              filtered_parameters[key] = '[FILTERED]'
+            elsif value.is_a?(Hash)
+              filtered_parameters[key] = filter_parameters(value)
+            elsif block_given?
+              key = key.dup
+              value = value.dup if value
+              yield key, value
+              filtered_parameters[key] = value
+            else
+              filtered_parameters[key] = value
+            end
+          end
+
+          filtered_parameters
+        end
+        protected :filter_parameters
+      end
+    end
+
+    module InstanceMethodsForNewBase
+      # TODO : Fix the order of information inside such that it's exactly same as the old base
+      def process(*)
+        ret = super
+
+        if logger
+          parameters = respond_to?(:filter_parameters) ? filter_parameters(params) : params.dup
+          parameters = parameters.except!(:controller, :action, :format, :_method, :only_path)
+
+          unless parameters.empty?
+            # TODO : Move DelayedLog to AS
+            log = AbstractController::Logger::DelayedLog.new { "  Parameters: #{parameters.inspect}" }
+            logger.info(log)
+          end
+        end
+
+        ret
+      end
+    end
+
+    private
+
+    # TODO : This method is not needed for the new base
+    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
+  end
+end
diff --git a/actionpack/lib/action_controller/base/helpers.rb b/actionpack/lib/action_controller/base/helpers.rb
index ba65032f6a..f74158bc13 100644
--- a/actionpack/lib/action_controller/base/helpers.rb
+++ b/actionpack/lib/action_controller/base/helpers.rb
@@ -3,23 +3,19 @@ require 'active_support/dependencies'
 # FIXME: helper { ... } is broken on Ruby 1.9
 module ActionController #:nodoc:
   module Helpers #:nodoc:
-    def self.included(base)
+    extend ActiveSupport::Concern
+
+    included do
       # Initialize the base module to aggregate its helpers.
-      base.class_inheritable_accessor :master_helper_module
-      base.master_helper_module = Module.new
+      class_inheritable_accessor :master_helper_module
+      self.master_helper_module = Module.new
 
       # Set the default directory for helpers
-      base.class_inheritable_accessor :helpers_dir
-      base.helpers_dir = (defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/app/helpers" : "app/helpers")
-
-      # Extend base with class methods to declare helpers.
-      base.extend(ClassMethods)
+      class_inheritable_accessor :helpers_dir
+      self.helpers_dir = (defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/app/helpers" : "app/helpers")
 
-      base.class_eval do
-        # Wrap inherited to create a new master helper module for subclasses.
-        class << self
-          alias_method_chain :inherited, :helper
-        end
+      class << self
+        alias_method_chain :inherited, :helper
       end
     end
 
diff --git a/actionpack/lib/action_controller/base/http_authentication.rb b/actionpack/lib/action_controller/base/http_authentication.rb
index b6b5267c66..2893290efb 100644
--- a/actionpack/lib/action_controller/base/http_authentication.rb
+++ b/actionpack/lib/action_controller/base/http_authentication.rb
@@ -1,3 +1,5 @@
+require 'active_support/base64'
+
 module ActionController
   module HttpAuthentication
     # Makes it dead easy to do HTTP Basic authentication.
@@ -192,9 +194,10 @@ module ActionController
 
         if valid_nonce && realm == credentials[:realm] && opaque == credentials[:opaque]
           password = password_procedure.call(credentials[:username])
+          method = request.env['rack.methodoverride.original_method'] || request.env['REQUEST_METHOD']
 
          [true, false].any? do |password_is_ha1|
-           expected = expected_response(request.env['REQUEST_METHOD'], request.env['REQUEST_URI'], credentials, password, password_is_ha1)
+           expected = expected_response(method, request.env['REQUEST_URI'], credentials, password, password_is_ha1)
            expected == credentials[:response]
          end
         end
@@ -276,7 +279,7 @@ module ActionController
         t = time.to_i
         hashed = [t, secret_key]
         digest = ::Digest::MD5.hexdigest(hashed.join(":"))
-        Base64.encode64("#{t}:#{digest}").gsub("\n", '')
+        ActiveSupport::Base64.encode64("#{t}:#{digest}").gsub("\n", '')
       end
 
       # Might want a shorter timeout depending on whether the request
@@ -285,7 +288,7 @@ module ActionController
       # allow a user to use new nonce without prompting user again for their
       # username and password.
       def validate_nonce(request, value, seconds_to_timeout=5*60)
-        t = Base64.decode64(value).split(":").first.to_i
+        t = ActiveSupport::Base64.decode64(value).split(":").first.to_i
         nonce(t) == value && (t - Time.now.to_i).abs <= seconds_to_timeout
       end
 
diff --git a/actionpack/lib/action_controller/base/layout.rb b/actionpack/lib/action_controller/base/layout.rb
index 4fcef6c5d9..cf5f46a32b 100644
--- a/actionpack/lib/action_controller/base/layout.rb
+++ b/actionpack/lib/action_controller/base/layout.rb
@@ -1,3 +1,7 @@
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/class/delegating_attributes'
+require 'active_support/core_ext/class/inheritable_attributes'
+
 module ActionController #:nodoc:
   module Layout #:nodoc:
     def self.included(base)
@@ -182,7 +186,7 @@ module ActionController #:nodoc:
       def memoized_find_layout(layout, formats) #:nodoc:
         return layout if layout.nil? || layout.respond_to?(:render)
         prefix = layout.to_s =~ /layouts\// ? nil : "layouts"
-        view_paths.find_by_parts(layout.to_s, formats, prefix)
+        view_paths.find_by_parts(layout.to_s, {:formats => formats}, prefix)
       end
 
       def find_layout(*args)
diff --git a/actionpack/lib/action_controller/base/mime_responds.rb b/actionpack/lib/action_controller/base/mime_responds.rb
index bac225ab2a..3c17dda1a1 100644
--- a/actionpack/lib/action_controller/base/mime_responds.rb
+++ b/actionpack/lib/action_controller/base/mime_responds.rb
@@ -1,111 +1,103 @@
 module ActionController #:nodoc:
   module MimeResponds #:nodoc:
-    def self.included(base)
-      base.module_eval do
-        include ActionController::MimeResponds::InstanceMethods
-      end
-    end
-
-    module InstanceMethods
-      # Without web-service support, an action which collects the data for displaying a list of people
-      # might look something like this:
-      #
-      #   def index
-      #     @people = Person.find(:all)
-      #   end
-      #
-      # Here's the same action, with web-service support baked in:
-      #
-      #   def index
-      #     @people = Person.find(:all)
-      #
-      #     respond_to do |format|
-      #       format.html
-      #       format.xml { render :xml => @people.to_xml }
-      #     end
-      #   end
-      #
-      # What that says is, "if the client wants HTML in response to this action, just respond as we
-      # would have before, but if the client wants XML, return them the list of people in XML format."
-      # (Rails determines the desired response format from the HTTP Accept header submitted by the client.)
-      #
-      # Supposing you have an action that adds a new person, optionally creating their company
-      # (by name) if it does not already exist, without web-services, it might look like this:
-      #
-      #   def create
-      #     @company = Company.find_or_create_by_name(params[:company][:name])
-      #     @person  = @company.people.create(params[:person])
-      #
-      #     redirect_to(person_list_url)
-      #   end
-      #
-      # Here's the same action, with web-service support baked in:
-      #
-      #   def create
-      #     company  = params[:person].delete(:company)
-      #     @company = Company.find_or_create_by_name(company[:name])
-      #     @person  = @company.people.create(params[:person])
-      #
-      #     respond_to do |format|
-      #       format.html { redirect_to(person_list_url) }
-      #       format.js
-      #       format.xml  { render :xml => @person.to_xml(:include => @company) }
-      #     end
-      #   end
-      #
-      # If the client wants HTML, we just redirect them back to the person list. If they want Javascript
-      # (format.js), then it is an RJS request and we render the RJS template associated with this action.
-      # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
-      # include the person's company in the rendered XML, so you get something like this:
-      #
-      #   <person>
-      #     <id>...</id>
-      #     ...
-      #     <company>
-      #       <id>...</id>
-      #       <name>...</name>
-      #       ...
-      #     </company>
-      #   </person>
-      #
-      # Note, however, the extra bit at the top of that action:
-      #
-      #   company  = params[:person].delete(:company)
-      #   @company = Company.find_or_create_by_name(company[:name])
-      #
-      # This is because the incoming XML document (if a web-service request is in process) can only contain a
-      # single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
-      #
-      #   person[name]=...&person[company][name]=...&...
-      #
-      # And, like this (xml-encoded):
-      #
-      #   <person>
-      #     <name>...</name>
-      #     <company>
-      #       <name>...</name>
-      #     </company>
-      #   </person>
-      #
-      # In other words, we make the request so that it operates on a single entity's person. Then, in the action,
-      # we extract the company data from the request, find or create the company, and then create the new person
-      # with the remaining data.
-      #
-      # Note that you can define your own XML parameter parser which would allow you to describe multiple entities
-      # in a single request (i.e., by wrapping them all in a single root node), but if you just go with the flow
-      # and accept Rails' defaults, life will be much easier.
-      #
-      # If you need to use a MIME type which isn't supported by default, you can register your own handlers in
-      # environment.rb as follows.
-      #
-      #   Mime::Type.register "image/jpg", :jpg
-      def respond_to(*types, &block)
-        raise ArgumentError, "respond_to takes either types or a block, never both" unless types.any? ^ block
-        block ||= lambda { |responder| types.each { |type| responder.send(type) } }
-        responder = Responder.new(self)
-        block.call(responder)
-        responder.respond
-      end
+    # Without web-service support, an action which collects the data for displaying a list of people
+    # might look something like this:
+    #
+    #   def index
+    #     @people = Person.find(:all)
+    #   end
+    #
+    # Here's the same action, with web-service support baked in:
+    #
+    #   def index
+    #     @people = Person.find(:all)
+    #
+    #     respond_to do |format|
+    #       format.html
+    #       format.xml { render :xml => @people.to_xml }
+    #     end
+    #   end
+    #
+    # What that says is, "if the client wants HTML in response to this action, just respond as we
+    # would have before, but if the client wants XML, return them the list of people in XML format."
+    # (Rails determines the desired response format from the HTTP Accept header submitted by the client.)
+    #
+    # Supposing you have an action that adds a new person, optionally creating their company
+    # (by name) if it does not already exist, without web-services, it might look like this:
+    #
+    #   def create
+    #     @company = Company.find_or_create_by_name(params[:company][:name])
+    #     @person  = @company.people.create(params[:person])
+    #
+    #     redirect_to(person_list_url)
+    #   end
+    #
+    # Here's the same action, with web-service support baked in:
+    #
+    #   def create
+    #     company  = params[:person].delete(:company)
+    #     @company = Company.find_or_create_by_name(company[:name])
+    #     @person  = @company.people.create(params[:person])
+    #
+    #     respond_to do |format|
+    #       format.html { redirect_to(person_list_url) }
+    #       format.js
+    #       format.xml  { render :xml => @person.to_xml(:include => @company) }
+    #     end
+    #   end
+    #
+    # If the client wants HTML, we just redirect them back to the person list. If they want Javascript
+    # (format.js), then it is an RJS request and we render the RJS template associated with this action.
+    # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
+    # include the person's company in the rendered XML, so you get something like this:
+    #
+    #   <person>
+    #     <id>...</id>
+    #     ...
+    #     <company>
+    #       <id>...</id>
+    #       <name>...</name>
+    #       ...
+    #     </company>
+    #   </person>
+    #
+    # Note, however, the extra bit at the top of that action:
+    #
+    #   company  = params[:person].delete(:company)
+    #   @company = Company.find_or_create_by_name(company[:name])
+    #
+    # This is because the incoming XML document (if a web-service request is in process) can only contain a
+    # single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
+    #
+    #   person[name]=...&person[company][name]=...&...
+    #
+    # And, like this (xml-encoded):
+    #
+    #   <person>
+    #     <name>...</name>
+    #     <company>
+    #       <name>...</name>
+    #     </company>
+    #   </person>
+    #
+    # In other words, we make the request so that it operates on a single entity's person. Then, in the action,
+    # we extract the company data from the request, find or create the company, and then create the new person
+    # with the remaining data.
+    #
+    # Note that you can define your own XML parameter parser which would allow you to describe multiple entities
+    # in a single request (i.e., by wrapping them all in a single root node), but if you just go with the flow
+    # and accept Rails' defaults, life will be much easier.
+    #
+    # If you need to use a MIME type which isn't supported by default, you can register your own handlers in
+    # environment.rb as follows.
+    #
+    #   Mime::Type.register "image/jpg", :jpg
+    def respond_to(*types, &block)
+      raise ArgumentError, "respond_to takes either types or a block, never both" unless types.any? ^ block
+      block ||= lambda { |responder| types.each { |type| responder.send(type) } }
+      responder = Responder.new(self)
+      block.call(responder)
+      responder.respond
     end
 
     class Responder #:nodoc:
@@ -127,8 +119,14 @@ module ActionController #:nodoc:
         @order << mime_type
 
         @responses[mime_type] ||= Proc.new do
-          @response.template.formats = [mime_type.to_sym]
+          # TODO: Remove this when new base is merged in
+          if defined?(Http)
+            @controller.formats = [mime_type.to_sym]
+          end
+
+          @controller.template.formats = [mime_type.to_sym]
           @response.content_type = mime_type.to_s
+
           block_given? ? block.call : @controller.send(:render, :action => @controller.action_name)
         end
       end
diff --git a/actionpack/lib/action_controller/base/redirect.rb b/actionpack/lib/action_controller/base/redirect.rb
index 2e92117e7c..7e10f614e2 100644
--- a/actionpack/lib/action_controller/base/redirect.rb
+++ b/actionpack/lib/action_controller/base/redirect.rb
@@ -48,8 +48,6 @@ module ActionController
         status = 302
       end
 
-      response.redirected_to = options
-
       case options
         # The scheme name consist of a letter followed by any combination of
         # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
@@ -72,7 +70,9 @@ module ActionController
     def redirect_to_full_url(url, status)
       raise DoubleRenderError if performed?
       logger.info("Redirected to #{url}") if logger && logger.info?
-      response.redirect(url, interpret_status(status))
+      response.status = interpret_status(status)
+      response.location = url.gsub(/[\r\n]/, '')
+      response.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"      
       @performed_redirect = true
     end
     
@@ -82,8 +82,6 @@ module ActionController
     # The response body is not reset here, see +erase_render_results+
     def erase_redirect_results #:nodoc:
       @performed_redirect = false
-      response.redirected_to = nil
-      response.redirected_to_method_params = nil
       response.status = DEFAULT_RENDER_STATUS_CODE
       response.headers.delete('Location')
     end
diff --git a/actionpack/lib/action_controller/base/render.rb b/actionpack/lib/action_controller/base/render.rb
index 606df58518..cc0d878e01 100644
--- a/actionpack/lib/action_controller/base/render.rb
+++ b/actionpack/lib/action_controller/base/render.rb
@@ -253,8 +253,9 @@ module ActionController
         response.content_type ||= Mime::JS
         render_for_text(js)
 
-      elsif json = options[:json]
-        json = json.to_json unless json.is_a?(String)
+      elsif options.include?(:json)
+        json = options[:json]
+        json = ActiveSupport::JSON.encode(json) unless json.respond_to?(:to_str)
         json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
         response.content_type ||= Mime::JSON
         render_for_text(json)
@@ -374,12 +375,18 @@ module ActionController
         render_for_file(name.sub(/^\//, ''), [layout, true], options)
       end
     end
-  
-    def render_for_parts(parts, layout, options = {})
+
+    # ==== Arguments
+    # parts<Array[String, Array[Symbol*], String, Boolean]>::
+    #     Example: ["show", [:html, :xml], "users", false]
+    def render_for_parts(parts, layout_details, options = {})
+      parts[1] = {:formats => parts[1], :locales => [I18n.locale]}
+      
       tmp = view_paths.find_by_parts(*parts)
       
-      layout = _pick_layout(*layout) unless tmp.exempt_from_layout?
-            
+      layout = _pick_layout(*layout_details) unless 
+        self.class.exempt_from_layout.include?(tmp.handler)
+      
       render_for_text(
         @template._render_template_with_layout(tmp, layout, options, parts[3]))
     end
diff --git a/actionpack/lib/action_controller/base/request_forgery_protection.rb b/actionpack/lib/action_controller/base/request_forgery_protection.rb
index 3067122ceb..368c6e9de8 100644
--- a/actionpack/lib/action_controller/base/request_forgery_protection.rb
+++ b/actionpack/lib/action_controller/base/request_forgery_protection.rb
@@ -3,12 +3,26 @@ module ActionController #:nodoc:
   end
 
   module RequestForgeryProtection
-    def self.included(base)
-      base.class_eval do
-        helper_method :form_authenticity_token
-        helper_method :protect_against_forgery?
+    extend ActiveSupport::Concern
+
+    # TODO : Remove the defined? check when new base is the main base
+    if defined?(ActionController::Http)
+      depends_on AbstractController::Helpers, Session
+    end
+
+    included do
+      if defined?(ActionController::Http)
+        # Sets the token parameter name for RequestForgery. Calling +protect_from_forgery+
+        # sets it to <tt>:authenticity_token</tt> by default.
+        cattr_accessor :request_forgery_protection_token
+
+        # Controls whether request forgergy protection is turned on or not. Turned off by default only in test mode.
+        class_inheritable_accessor :allow_forgery_protection
+        self.allow_forgery_protection = true
       end
-      base.extend(ClassMethods)
+
+      helper_method :form_authenticity_token
+      helper_method :protect_against_forgery?
     end
     
     # Protecting controller actions from CSRF attacks by ensuring that all forms are coming from the current web application, not a
diff --git a/actionpack/lib/action_controller/base/rescue.rb b/actionpack/lib/action_controller/base/rescue.rb
new file mode 100644
index 0000000000..2717a06a37
--- /dev/null
+++ b/actionpack/lib/action_controller/base/rescue.rb
@@ -0,0 +1,50 @@
+module ActionController #:nodoc:
+  # Actions that fail to perform as expected throw exceptions. These
+  # exceptions can either be rescued for the public view (with a nice
+  # user-friendly explanation) or for the developers view (with tons of
+  # debugging information). The developers view is already implemented by
+  # the Action Controller, but the public view should be tailored to your
+  # specific application.
+  #
+  # The default behavior for public exceptions is to render a static html
+  # file with the name of the error code thrown.  If no such file exists, an
+  # empty response is sent with the correct status code.
+  #
+  # You can override what constitutes a local request by overriding the
+  # <tt>local_request?</tt> method in your own controller. Custom rescue
+  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
+  # and <tt>rescue_action_locally</tt> methods.
+  module Rescue
+    def self.included(base) #:nodoc:
+      base.send :include, ActiveSupport::Rescuable
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        alias_method_chain :perform_action, :rescue
+      end
+    end
+
+    module ClassMethods
+      def rescue_action(env)
+        exception = env.delete('action_dispatch.rescue.exception')
+        request   = ActionDispatch::Request.new(env)
+        response  = ActionDispatch::Response.new
+        new.process(request, response, :rescue_action, exception).to_a
+      end
+    end
+
+    protected
+      # Exception handler called when the performance of an action raises
+      # an exception.
+      def rescue_action(exception)
+        rescue_with_handler(exception) || raise(exception)
+      end
+
+    private
+      def perform_action_with_rescue
+        perform_action_without_rescue
+      rescue Exception => exception
+        rescue_action(exception)
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/base/streaming.rb b/actionpack/lib/action_controller/base/streaming.rb
index 9f80f48c3d..5f56c95483 100644
--- a/actionpack/lib/action_controller/base/streaming.rb
+++ b/actionpack/lib/action_controller/base/streaming.rb
@@ -2,6 +2,13 @@ module ActionController #:nodoc:
   # Methods for sending arbitrary data and for streaming files to the browser,
   # instead of rendering.
   module Streaming
+    extend ActiveSupport::Concern
+
+    # TODO : Remove the defined? check when new base is the main base
+    if defined?(ActionController::Http)
+      depends_on ActionController::Renderer
+    end
+
     DEFAULT_SEND_FILE_OPTIONS = {
       :type         => 'application/octet-stream'.freeze,
       :disposition  => 'attachment'.freeze,
@@ -88,6 +95,7 @@ module ActionController #:nodoc:
           head options[:status], X_SENDFILE_HEADER => path
         else
           if options[:stream]
+            # TODO : Make render :text => proc {} work with the new base
             render :status => options[:status], :text => Proc.new { |response, output|
               logger.info "Streaming file #{path}" unless logger.nil?
               len = options[:buffer_size] || 4096
diff --git a/actionpack/lib/action_controller/base/verification.rb b/actionpack/lib/action_controller/base/verification.rb
index c62b81b666..31654e36f3 100644
--- a/actionpack/lib/action_controller/base/verification.rb
+++ b/actionpack/lib/action_controller/base/verification.rb
@@ -1,7 +1,10 @@
 module ActionController #:nodoc:
   module Verification #:nodoc:
-    def self.included(base) #:nodoc:
-      base.extend(ClassMethods)
+    extend ActiveSupport::Concern
+
+    # TODO : Remove the defined? check when new base is the main base
+    if defined?(ActionController::Http)
+      depends_on AbstractController::Callbacks, Session, Flash, Renderer
     end
 
     # This module provides a class-level method for specifying that certain
@@ -102,7 +105,7 @@ module ActionController #:nodoc:
     end
  
     def verify_presence_of_keys_in_hash_flash_or_params(options) # :nodoc:
-      [*options[:params] ].find { |v| params[v].nil?  } ||
+      [*options[:params] ].find { |v| v && params[v.to_sym].nil?  } ||
       [*options[:session]].find { |v| session[v].nil? } ||
       [*options[:flash]  ].find { |v| flash[v].nil?   }
     end
diff --git a/actionpack/lib/action_controller/caching.rb b/actionpack/lib/action_controller/caching.rb
index ffd8081edc..38cf1da6a8 100644
--- a/actionpack/lib/action_controller/caching.rb
+++ b/actionpack/lib/action_controller/caching.rb
@@ -24,31 +24,31 @@ module ActionController #:nodoc:
   #   ActionController::Base.cache_store = :mem_cache_store, "localhost"
   #   ActionController::Base.cache_store = MyOwnStore.new("parameter")
   module Caching
+    extend ActiveSupport::Concern
+
     autoload :Actions, 'action_controller/caching/actions'
     autoload :Fragments, 'action_controller/caching/fragments'
     autoload :Pages, 'action_controller/caching/pages'
     autoload :Sweeper, 'action_controller/caching/sweeping'
     autoload :Sweeping, 'action_controller/caching/sweeping'
 
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        @@cache_store = nil
-        cattr_reader :cache_store
+    included do
+      @@cache_store = nil
+      cattr_reader :cache_store
 
-        # Defines the storage option for cached fragments
-        def self.cache_store=(store_option)
-          @@cache_store = ActiveSupport::Cache.lookup_store(store_option)
-        end
+      # Defines the storage option for cached fragments
+      def self.cache_store=(store_option)
+        @@cache_store = ActiveSupport::Cache.lookup_store(store_option)
+      end
 
-        include Pages, Actions, Fragments
-        include Sweeping if defined?(ActiveRecord)
+      include Pages, Actions, Fragments
+      include Sweeping if defined?(ActiveRecord)
 
-        @@perform_caching = true
-        cattr_accessor :perform_caching
+      @@perform_caching = true
+      cattr_accessor :perform_caching
 
-        def self.cache_configured?
-          perform_caching && cache_store
-        end
+      def self.cache_configured?
+        perform_caching && cache_store
       end
     end
 
diff --git a/actionpack/lib/action_controller/caching/actions.rb b/actionpack/lib/action_controller/caching/actions.rb
index b99feddf77..54148b55d8 100644
--- a/actionpack/lib/action_controller/caching/actions.rb
+++ b/actionpack/lib/action_controller/caching/actions.rb
@@ -61,7 +61,15 @@ module ActionController #:nodoc:
           filter_options = { :only => actions, :if => options.delete(:if), :unless => options.delete(:unless) }
 
           cache_filter = ActionCacheFilter.new(:layout => options.delete(:layout), :cache_path => options.delete(:cache_path), :store_options => options)
-          around_filter(cache_filter, filter_options)
+
+          # TODO: Remove this once new base is swapped in.
+          if defined?(ActionController::Http)
+            around_filter cache_filter, filter_options
+          else
+            around_filter(filter_options) do |controller, action|
+              cache_filter.filter(controller, action)
+            end
+          end
         end
       end
 
@@ -83,8 +91,24 @@ module ActionController #:nodoc:
           @options = options
         end
 
+        # TODO: Remove once New Base is merged
+        if defined?(ActionController::Http)
+          def filter(controller)
+            should_continue = before(controller)
+            yield if should_continue
+            after(controller)
+          end
+        else
+          def filter(controller, action)
+            should_continue = before(controller)
+            action.call if should_continue
+            after(controller)
+          end
+        end
+
         def before(controller)
           cache_path = ActionCachePath.new(controller, path_options_for(controller, @options.slice(:cache_path)))
+
           if cache = controller.read_fragment(cache_path.path, @options[:store_options])
             controller.rendered_action_cache = true
             set_content_type!(controller, cache_path.extension)
@@ -121,7 +145,9 @@ module ActionController #:nodoc:
           end
 
           def content_for_layout(controller)
-            controller.response.layout && controller.response.template.instance_variable_get('@cached_content_for_layout')
+            # TODO: Remove this when new base is merged in
+            template = controller.respond_to?(:template) ? controller.template : controller._action_view
+            template.layout && template.instance_variable_get('@cached_content_for_layout')
           end
       end
 
diff --git a/actionpack/lib/action_controller/dispatch/dispatcher.rb b/actionpack/lib/action_controller/dispatch/dispatcher.rb
index bb9d8bd063..9ad1cadfd3 100644
--- a/actionpack/lib/action_controller/dispatch/dispatcher.rb
+++ b/actionpack/lib/action_controller/dispatch/dispatcher.rb
@@ -1,96 +1,65 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActionController
   # Dispatches requests to the appropriate controller and takes care of
   # reloading the app after each request when Dependencies.load? is true.
   class Dispatcher
+    cattr_accessor :prepare_each_request
+    self.prepare_each_request = false
+
+    cattr_accessor :router
+    self.router = Routing::Routes
+
+    cattr_accessor :middleware
+    self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+      middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
+      middleware.instance_eval(File.read(middlewares), middlewares, 1)
+    end
+
     class << self
       def define_dispatcher_callbacks(cache_classes)
         unless cache_classes
-          unless self.middleware.include?(ActionDispatch::Reloader)
-            self.middleware.insert_after(ActionDispatch::Failsafe, ActionDispatch::Reloader)
+          # Run prepare callbacks before every request in development mode
+          self.prepare_each_request = true
+
+          # Development mode callbacks
+          ActionDispatch::Callbacks.before_dispatch do |app|
+            ActionController::Dispatcher.router.reload
+          end
+
+          ActionDispatch::Callbacks.after_dispatch do
+            # Cleanup the application before processing the current request.
+            ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
+            ActiveSupport::Dependencies.clear
+            ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
           end
 
           ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
         end
 
         if defined?(ActiveRecord)
-          to_prepare(:activerecord_instantiate_observers) { ActiveRecord::Base.instantiate_observers }
+          to_prepare(:activerecord_instantiate_observers) do
+            ActiveRecord::Base.instantiate_observers
+          end
         end
 
-        after_dispatch :flush_logger if Base.logger && Base.logger.respond_to?(:flush)
+        if Base.logger && Base.logger.respond_to?(:flush)
+          after_dispatch do
+            Base.logger.flush
+          end
+        end
 
         to_prepare do
           I18n.reload!
         end
       end
 
-      # Add a preparation callback. Preparation callbacks are run before every
-      # request in development mode, and before the first request in production
-      # mode.
-      #
-      # An optional identifier may be supplied for the callback. If provided,
-      # to_prepare may be called again with the same identifier to replace the
-      # existing callback. Passing an identifier is a suggested practice if the
-      # code adding a preparation block may be reloaded.
-      def to_prepare(identifier = nil, &block)
-        @prepare_dispatch_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
-        callback = ActiveSupport::Callbacks::Callback.new(:prepare_dispatch, block, :identifier => identifier)
-        @prepare_dispatch_callbacks.replace_or_append!(callback)
-      end
-
-      def run_prepare_callbacks
-        new.send :run_callbacks, :prepare_dispatch
-      end
-
-      def reload_application
-        # Run prepare callbacks before every request in development mode
-        run_prepare_callbacks
+      delegate :to_prepare, :prepare_dispatch, :before_dispatch, :after_dispatch,
+        :to => ActionDispatch::Callbacks
 
-        Routing::Routes.reload
+      def new
+        @@middleware.build(@@router)
       end
-
-      def cleanup_application
-        # Cleanup the application before processing the current request.
-        ActiveRecord::Base.reset_subclasses if defined?(ActiveRecord)
-        ActiveSupport::Dependencies.clear
-        ActiveRecord::Base.clear_reloadable_connections! if defined?(ActiveRecord)
-      end
-    end
-
-    cattr_accessor :middleware
-    self.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
-      middlewares = File.join(File.dirname(__FILE__), "middlewares.rb")
-      middleware.instance_eval(File.read(middlewares))
-    end
-
-    include ActiveSupport::Callbacks
-    define_callbacks :prepare_dispatch, :before_dispatch, :after_dispatch
-
-    def initialize
-      @app = @@middleware.build(lambda { |env| self._call(env) })
-      freeze
-    end
-
-    def call(env)
-      @app.call(env)
-    end
-
-    def _call(env)
-      begin
-        run_callbacks :before_dispatch
-        Routing::Routes.call(env)
-      rescue Exception => exception
-        if controller ||= (::ApplicationController rescue Base)
-          controller.call_with_exception(env, exception).to_a
-        else
-          raise exception
-        end
-      ensure
-        run_callbacks :after_dispatch, :enumerator => :reverse_each
-      end
-    end
-
-    def flush_logger
-      Base.logger.flush
     end
   end
 end
diff --git a/actionpack/lib/action_controller/dispatch/middlewares.rb b/actionpack/lib/action_controller/dispatch/middlewares.rb
index b62b4f84a1..b25ed3fd3f 100644
--- a/actionpack/lib/action_controller/dispatch/middlewares.rb
+++ b/actionpack/lib/action_controller/dispatch/middlewares.rb
@@ -2,12 +2,17 @@ use "Rack::Lock", :if => lambda {
   !ActionController::Base.allow_concurrency
 }
 
-use "ActionDispatch::Failsafe"
+use "ActionDispatch::ShowExceptions", lambda { ActionController::Base.consider_all_requests_local }
+use "ActionDispatch::Callbacks", lambda { ActionController::Dispatcher.prepare_each_request }
+use "ActionDispatch::Rescue", lambda {
+  controller = (::ApplicationController rescue ActionController::Base)
+  # TODO: Replace with controller.action(:_rescue_action)
+  controller.method(:rescue_action)
+}
 
 use lambda { ActionController::Base.session_store },
     lambda { ActionController::Base.session_options }
 
-use "ActionDispatch::RewindableInput"
 use "ActionDispatch::ParamsParser"
 use "Rack::MethodOverride"
-use "Rack::Head"
+use "Rack::Head"
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/dispatch/rescue.rb b/actionpack/lib/action_controller/dispatch/rescue.rb
deleted file mode 100644
index df80ac0909..0000000000
--- a/actionpack/lib/action_controller/dispatch/rescue.rb
+++ /dev/null
@@ -1,185 +0,0 @@
-module ActionController #:nodoc:
-  # Actions that fail to perform as expected throw exceptions. These
-  # exceptions can either be rescued for the public view (with a nice
-  # user-friendly explanation) or for the developers view (with tons of
-  # debugging information). The developers view is already implemented by
-  # the Action Controller, but the public view should be tailored to your
-  # specific application.
-  #
-  # The default behavior for public exceptions is to render a static html
-  # file with the name of the error code thrown.  If no such file exists, an
-  # empty response is sent with the correct status code.
-  #
-  # You can override what constitutes a local request by overriding the
-  # <tt>local_request?</tt> method in your own controller. Custom rescue
-  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
-  # and <tt>rescue_action_locally</tt> methods.
-  module Rescue
-    LOCALHOST = '127.0.0.1'.freeze
-
-    DEFAULT_RESCUE_RESPONSE = :internal_server_error
-    DEFAULT_RESCUE_RESPONSES = {
-      'ActionController::RoutingError'             => :not_found,
-      'ActionController::UnknownAction'            => :not_found,
-      'ActiveRecord::RecordNotFound'               => :not_found,
-      'ActiveRecord::StaleObjectError'             => :conflict,
-      'ActiveRecord::RecordInvalid'                => :unprocessable_entity,
-      'ActiveRecord::RecordNotSaved'               => :unprocessable_entity,
-      'ActionController::MethodNotAllowed'         => :method_not_allowed,
-      'ActionController::NotImplemented'           => :not_implemented,
-      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
-    }
-
-    DEFAULT_RESCUE_TEMPLATE = 'diagnostics'
-    DEFAULT_RESCUE_TEMPLATES = {
-      'ActionView::MissingTemplate'       => 'missing_template',
-      'ActionController::RoutingError'    => 'routing_error',
-      'ActionController::UnknownAction'   => 'unknown_action',
-      'ActionView::TemplateError'         => 'template_error'
-    }
-
-    RESCUES_TEMPLATE_PATH = ActionView::Template::FileSystemPath.new(
-      File.join(File.dirname(__FILE__), "templates"))
-
-    def self.included(base) #:nodoc:
-      base.cattr_accessor :rescue_responses
-      base.rescue_responses = Hash.new(DEFAULT_RESCUE_RESPONSE)
-      base.rescue_responses.update DEFAULT_RESCUE_RESPONSES
-
-      base.cattr_accessor :rescue_templates
-      base.rescue_templates = Hash.new(DEFAULT_RESCUE_TEMPLATE)
-      base.rescue_templates.update DEFAULT_RESCUE_TEMPLATES
-
-      base.extend(ClassMethods)
-      base.send :include, ActiveSupport::Rescuable
-
-      base.class_eval do
-        alias_method_chain :perform_action, :rescue
-      end
-    end
-
-    module ClassMethods
-      def call_with_exception(env, exception) #:nodoc:
-        request = env["action_controller.rescue.request"] ||= ActionDispatch::Request.new(env)
-        response = env["action_controller.rescue.response"] ||= ActionDispatch::Response.new
-        new.process(request, response, :rescue_action, exception)
-      end
-    end
-
-    protected
-      # Exception handler called when the performance of an action raises
-      # an exception.
-      def rescue_action(exception)
-        rescue_with_handler(exception) ||
-          rescue_action_without_handler(exception)
-      end
-
-      # Overwrite to implement custom logging of errors. By default
-      # logs as fatal.
-      def log_error(exception) #:doc:
-        ActiveSupport::Deprecation.silence do
-          if ActionView::TemplateError === exception
-            logger.fatal(exception.to_s)
-          else
-            logger.fatal(
-              "\n#{exception.class} (#{exception.message}):\n  " +
-              clean_backtrace(exception).join("\n  ") + "\n\n"
-            )
-          end
-        end
-      end
-
-      # Overwrite to implement public exception handling (for requests
-      # answering false to <tt>local_request?</tt>).  By default will call
-      # render_optional_error_file.  Override this method to provide more
-      # user friendly error messages.
-      def rescue_action_in_public(exception) #:doc:
-        render_optional_error_file response_code_for_rescue(exception)
-      end
-
-      # Attempts to render a static error page based on the
-      # <tt>status_code</tt> thrown, or just return headers if no such file
-      # exists. At first, it will try to render a localized static page.
-      # For example, if a 500 error is being handled Rails and locale is :da,
-      # it will first attempt to render the file at <tt>public/500.da.html</tt>
-      # then attempt to render <tt>public/500.html</tt>. If none of them exist,
-      # the body of the response will be left empty.
-      def render_optional_error_file(status_code)
-        status = interpret_status(status_code)
-        locale_path = "#{Rails.public_path}/#{status[0,3]}.#{I18n.locale}.html" if I18n.locale
-        path = "#{Rails.public_path}/#{status[0,3]}.html"
-
-        if locale_path && File.exist?(locale_path)
-          render :file => locale_path, :status => status, :content_type => Mime::HTML
-        elsif File.exist?(path)
-          render :file => path, :status => status, :content_type => Mime::HTML
-        else
-          head status
-        end
-      end
-
-      # True if the request came from localhost, 127.0.0.1. Override this
-      # method if you wish to redefine the meaning of a local request to
-      # include remote IP addresses or other criteria.
-      def local_request? #:doc:
-        request.remote_addr == LOCALHOST && request.remote_ip == LOCALHOST
-      end
-
-      # Render detailed diagnostics for unhandled exceptions rescued from
-      # a controller action.
-      def rescue_action_locally(exception)
-        @template.instance_variable_set("@exception", exception)
-        @template.instance_variable_set("@rescues_path", RESCUES_TEMPLATE_PATH)
-        @template.instance_variable_set("@contents",
-          @template._render_template(template_path_for_local_rescue(exception)))
-
-        response.content_type = Mime::HTML
-        response.status = interpret_status(response_code_for_rescue(exception))
-        
-        content = @template._render_template(rescues_path("layout"))
-        render_for_text(content)
-      end
-
-      def rescue_action_without_handler(exception)
-        log_error(exception) if logger
-        erase_results if performed?
-
-        # Let the exception alter the response if it wants.
-        # For example, MethodNotAllowed sets the Allow header.
-        if exception.respond_to?(:handle_response!)
-          exception.handle_response!(response)
-        end
-
-        if consider_all_requests_local || local_request?
-          rescue_action_locally(exception)
-        else
-          rescue_action_in_public(exception)
-        end
-      end
-
-    private
-      def perform_action_with_rescue #:nodoc:
-        perform_action_without_rescue
-      rescue Exception => exception
-        rescue_action(exception)
-      end
-
-      def rescues_path(template_name)
-        RESCUES_TEMPLATE_PATH.find_by_parts("rescues/#{template_name}.erb")
-      end
-
-      def template_path_for_local_rescue(exception)
-        rescues_path(rescue_templates[exception.class.name])
-      end
-
-      def response_code_for_rescue(exception)
-        rescue_responses[exception.class.name]
-      end
-
-      def clean_backtrace(exception)
-        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
-          Rails.backtrace_cleaner.clean(exception.backtrace) :
-          exception.backtrace
-      end
-  end
-end
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb b/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
deleted file mode 100644
index e5c647c826..0000000000
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/diagnostics.erb
+++ /dev/null
@@ -1,10 +0,0 @@
-<h1>
-  <%=h @exception.class.to_s %>
-  <% if request.parameters['controller'] %>
-    in <%=h request.parameters['controller'].humanize %>Controller<% if request.parameters['action'] %>#<%=h request.parameters['action'] %><% end %>
-  <% end %>
-</h1>
-<pre><%=h @exception.clean_message %></pre>
-
-<%= @template._render_template(@rescues_path.find_by_parts("rescues/_trace.erb")) %>
-<%= @template._render_template(@rescues_path.find_by_parts("rescues/_request_and_response.erb")) %>
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/new_base.rb b/actionpack/lib/action_controller/new_base.rb
index 7c65f1cdc1..df256985ac 100644
--- a/actionpack/lib/action_controller/new_base.rb
+++ b/actionpack/lib/action_controller/new_base.rb
@@ -1,7 +1,47 @@
 module ActionController
-  autoload :AbstractBase, "action_controller/new_base/base"
-  autoload :HideActions,  "action_controller/new_base/hide_actions"
-  autoload :Layouts,      "action_controller/new_base/layouts"
-  autoload :Renderer,     "action_controller/new_base/renderer"
-  autoload :UrlFor,       "action_controller/new_base/url_for"
-end
\ No newline at end of file
+  autoload :Base,                 "action_controller/new_base/base"
+  autoload :ConditionalGet,       "action_controller/new_base/conditional_get"
+  autoload :HideActions,          "action_controller/new_base/hide_actions"
+  autoload :Http,                 "action_controller/new_base/http"
+  autoload :Layouts,              "action_controller/new_base/layouts"
+  autoload :RackConvenience,      "action_controller/new_base/rack_convenience"
+  autoload :Rails2Compatibility,  "action_controller/new_base/compatibility"
+  autoload :Redirector,           "action_controller/new_base/redirector"
+  autoload :Renderer,             "action_controller/new_base/renderer"
+  autoload :RenderOptions,        "action_controller/new_base/render_options"
+  autoload :Renderers,            "action_controller/new_base/render_options"
+  autoload :Rescue,               "action_controller/new_base/rescuable"
+  autoload :Testing,              "action_controller/new_base/testing"
+  autoload :UrlFor,               "action_controller/new_base/url_for"
+  autoload :Session,              "action_controller/new_base/session"
+  autoload :Helpers,              "action_controller/new_base/helpers"
+
+  # Ported modules
+  # require 'action_controller/routing'
+  autoload :Caching,           'action_controller/caching'
+  autoload :Dispatcher,        'action_controller/dispatch/dispatcher'
+  autoload :MimeResponds,      'action_controller/base/mime_responds'
+  autoload :PolymorphicRoutes, 'action_controller/routing/generation/polymorphic_routes'
+  autoload :RecordIdentifier,  'action_controller/record_identifier'
+  autoload :Resources,         'action_controller/routing/resources'
+  autoload :SessionManagement, 'action_controller/base/session_management'
+  autoload :TestCase,          'action_controller/testing/test_case'
+  autoload :UrlRewriter,       'action_controller/routing/generation/url_rewriter'
+  autoload :UrlWriter,         'action_controller/routing/generation/url_rewriter'
+
+  autoload :Verification,             'action_controller/base/verification'
+  autoload :Flash,                    'action_controller/base/chained/flash'
+  autoload :RequestForgeryProtection, 'action_controller/base/request_forgery_protection'
+  autoload :Streaming,                'action_controller/base/streaming'
+  autoload :HttpAuthentication,       'action_controller/base/http_authentication'
+  autoload :FilterParameterLogging,   'action_controller/base/filter_parameter_logging'
+  autoload :Translation,              'action_controller/translation'
+  autoload :Cookies,                  'action_controller/base/cookies'
+
+  require 'action_controller/routing'
+end
+
+autoload :HTML, 'action_controller/vendor/html-scanner'
+
+require 'action_dispatch'
+require 'action_view'
diff --git a/actionpack/lib/action_controller/new_base/base.rb b/actionpack/lib/action_controller/new_base/base.rb
index 08e7a1a0e7..d7b65d37fa 100644
--- a/actionpack/lib/action_controller/new_base/base.rb
+++ b/actionpack/lib/action_controller/new_base/base.rb
@@ -1,60 +1,173 @@
 module ActionController
-  class AbstractBase < AbstractController::Base
-    
-    # :api: public
-    attr_internal :request, :response, :params
-
-    # :api: public
-    def self.controller_name
-      @controller_name ||= controller_path.split("/").last
-    end
-
-    # :api: public
-    def controller_name() self.class.controller_name end
-
-    # :api: public    
-    def self.controller_path
-      @controller_path ||= self.name.sub(/Controller$/, '').underscore
-    end
-    
-    # :api: public    
-    def controller_path() self.class.controller_path end
-      
-    # :api: private      
-    def self.action_methods
-      @action_names ||= Set.new(self.public_instance_methods - self::CORE_METHODS)
-    end
-    
-    # :api: private    
-    def self.action_names() action_methods end
-    
-    # :api: private        
-    def action_methods() self.class.action_names end
-
-    # :api: private
-    def action_names() action_methods end
-    
-    # :api: plugin
-    def self.call(env)
-      controller = new
-      controller.call(env).to_rack
-    end
-    
-    # :api: plugin
-    def response_body=(body)
-      @_response.body = body
-    end
-    
-    # :api: private
-    def call(env)
-      @_request = ActionDispatch::Request.new(env)
-      @_response = ActionDispatch::Response.new
-      process(@_request.parameters[:action])
-    end
-    
-    # :api: private
-    def to_rack
-      response.to_a
+  class Base < Http
+    abstract!
+
+    include AbstractController::Benchmarker
+    include AbstractController::Callbacks
+    include AbstractController::Logger
+
+    include ActionController::Helpers
+    include ActionController::HideActions
+    include ActionController::UrlFor
+    include ActionController::Redirector
+    include ActionController::Renderer
+    include ActionController::Renderers::All
+    include ActionController::Layouts
+    include ActionController::ConditionalGet
+    include ActionController::RackConvenience
+
+    # Legacy modules
+    include SessionManagement
+    include ActionDispatch::StatusCodes
+    include ActionController::Caching
+    include ActionController::MimeResponds
+
+    # Rails 2.x compatibility
+    include ActionController::Rails2Compatibility
+
+    include ActionController::Cookies
+    include ActionController::Session
+    include ActionController::Flash
+    include ActionController::Verification
+    include ActionController::RequestForgeryProtection
+    include ActionController::Streaming
+    include ActionController::HttpAuthentication::Basic::ControllerMethods
+    include ActionController::HttpAuthentication::Digest::ControllerMethods
+    include ActionController::FilterParameterLogging
+    include ActionController::Translation
+
+    # TODO: Extract into its own module
+    # This should be moved together with other normalizing behavior
+    module ImplicitRender
+      def send_action(method_name)
+        ret = super
+        default_render unless performed?
+        ret
+      end
+
+      def default_render
+        render
+      end
+
+      def method_for_action(action_name)
+        super || begin
+          if view_paths.find_by_parts?(action_name.to_s, {:formats => formats, :locales => [I18n.locale]}, controller_path)
+            "default_render"
+          end
+        end
+      end
+    end
+
+    include ImplicitRender
+
+    include ActionController::Rescue
+
+    def self.inherited(klass)
+      ::ActionController::Base.subclasses << klass.to_s
+      super
+    end
+
+    def self.subclasses
+      @subclasses ||= []
+    end
+
+    def self.app_loaded!
+      @subclasses.each do |subclass|
+        subclass.constantize._write_layout_method
+      end
+    end
+
+    def _normalize_options(action = nil, options = {}, &blk)
+      if action.is_a?(Hash)
+        options, action = action, nil
+      elsif action.is_a?(String) || action.is_a?(Symbol)
+        key = case action = action.to_s
+        when %r{^/} then :file
+        when %r{/}  then :template
+        else             :action
+        end
+        options.merge! key => action
+      elsif action
+        options.merge! :partial => action
+      end
+
+      if options.key?(:action) && options[:action].to_s.index("/")
+        options[:template] = options.delete(:action)
+      end
+
+      if options[:status]
+        options[:status] = interpret_status(options[:status]).to_i
+      end
+
+      options[:update] = blk if block_given?
+      options
+    end
+
+    def render(action = nil, options = {}, &blk)
+      options = _normalize_options(action, options, &blk)
+      super(options)
+    end
+
+    def render_to_string(action = nil, options = {}, &blk)
+      options = _normalize_options(action, options, &blk)
+      super(options)
+    end
+
+    # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
+    #
+    # * <tt>Hash</tt> - The URL will be generated by calling url_for with the +options+.
+    # * <tt>Record</tt> - The URL will be generated by calling url_for with the +options+, which will reference a named URL for that record.
+    # * <tt>String</tt> starting with <tt>protocol://</tt> (like <tt>http://</tt>) - Is passed straight through as the target for redirection.
+    # * <tt>String</tt> not containing a protocol - The current protocol and host is prepended to the string.
+    # * <tt>:back</tt> - Back to the page that issued the request. Useful for forms that are triggered from multiple places.
+    #   Short-hand for <tt>redirect_to(request.env["HTTP_REFERER"])</tt>
+    #
+    # Examples:
+    #   redirect_to :action => "show", :id => 5
+    #   redirect_to post
+    #   redirect_to "http://www.rubyonrails.org"
+    #   redirect_to "/images/screenshot.jpg"
+    #   redirect_to articles_url
+    #   redirect_to :back
+    #
+    # The redirection happens as a "302 Moved" header unless otherwise specified.
+    #
+    # Examples:
+    #   redirect_to post_url(@post), :status=>:found
+    #   redirect_to :action=>'atom', :status=>:moved_permanently
+    #   redirect_to post_url(@post), :status=>301
+    #   redirect_to :action=>'atom', :status=>302
+    #
+    # When using <tt>redirect_to :back</tt>, if there is no referrer,
+    # RedirectBackError will be raised. You may specify some fallback
+    # behavior for this case by rescuing RedirectBackError.
+    def redirect_to(options = {}, response_status = {}) #:doc:
+      raise ActionControllerError.new("Cannot redirect to nil!") if options.nil?
+
+      status = if options.is_a?(Hash) && options.key?(:status)
+        interpret_status(options.delete(:status))
+      elsif response_status.key?(:status)
+        interpret_status(response_status[:status])
+      else
+        302
+      end
+
+      url = case options
+      # The scheme name consist of a letter followed by any combination of
+      # letters, digits, and the plus ("+"), period ("."), or hyphen ("-")
+      # characters; and is terminated by a colon (":").
+      when %r{^\w[\w\d+.-]*:.*}
+        options
+      when String
+        request.protocol + request.host_with_port + options
+      when :back
+        raise RedirectBackError unless refer = request.headers["Referer"]
+        refer
+      else
+        url_for(options)
+      end
+
+      super(url, status)
     end
   end
 end
diff --git a/actionpack/lib/action_controller/new_base/compatibility.rb b/actionpack/lib/action_controller/new_base/compatibility.rb
new file mode 100644
index 0000000000..f278c2da14
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/compatibility.rb
@@ -0,0 +1,138 @@
+module ActionController
+  module Rails2Compatibility
+    extend ActiveSupport::Concern
+
+    class ::ActionController::ActionControllerError < StandardError #:nodoc:
+    end
+
+    # Temporary hax
+    included do
+      ::ActionController::UnknownAction = ::AbstractController::ActionNotFound
+      ::ActionController::DoubleRenderError = ::AbstractController::DoubleRenderError
+
+      cattr_accessor :session_options
+      self.session_options = {}
+
+      cattr_accessor :allow_concurrency
+      self.allow_concurrency = false
+
+      cattr_accessor :param_parsers
+      self.param_parsers = { Mime::MULTIPART_FORM   => :multipart_form,
+                             Mime::URL_ENCODED_FORM => :url_encoded_form,
+                             Mime::XML              => :xml_simple,
+                             Mime::JSON             => :json }
+
+      cattr_accessor :relative_url_root
+      self.relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
+
+      cattr_accessor :default_charset
+      self.default_charset = "utf-8"
+
+      # cattr_reader :protected_instance_variables
+      cattr_accessor :protected_instance_variables
+      self.protected_instance_variables = %w(@assigns @performed_redirect @performed_render @variables_added @request_origin @url @parent_controller
+                                          @action_name @before_filter_chain_aborted @action_cache_path @_headers @_params
+                                          @_flash @_response)
+
+      # Indicates whether or not optimise the generated named
+      # route helper methods
+      cattr_accessor :optimise_named_routes
+      self.optimise_named_routes = true
+
+      cattr_accessor :resources_path_names
+      self.resources_path_names = { :new => 'new', :edit => 'edit' }
+
+      # Controls the resource action separator
+      cattr_accessor :resource_action_separator
+      self.resource_action_separator = "/"
+
+      cattr_accessor :use_accept_header
+      self.use_accept_header = true
+
+      cattr_accessor :page_cache_directory
+      self.page_cache_directory = defined?(Rails.public_path) ? Rails.public_path : ""
+
+      cattr_reader :cache_store
+
+      cattr_accessor :consider_all_requests_local
+      self.consider_all_requests_local = true
+
+      # Prepends all the URL-generating helpers from AssetHelper. This makes it possible to easily move javascripts, stylesheets,
+      # and images to a dedicated asset server away from the main web server. Example:
+      #   ActionController::Base.asset_host = "http://assets.example.com"
+      cattr_accessor :asset_host
+
+      cattr_accessor :ip_spoofing_check
+      self.ip_spoofing_check = true
+    end
+
+    # For old tests
+    def initialize_template_class(*) end
+    def assign_shortcuts(*) end
+
+    # TODO: Remove this after we flip
+    def template
+      @template ||= _action_view
+    end
+
+    def process_action(*)
+      template
+      super
+    end
+
+    module ClassMethods
+      def consider_all_requests_local
+      end
+
+      def rescue_action(env)
+        raise env["action_dispatch.rescue.exception"]
+      end
+
+      # Defines the storage option for cached fragments
+      def cache_store=(store_option)
+        @@cache_store = ActiveSupport::Cache.lookup_store(store_option)
+      end
+    end
+
+    def render_to_body(options)
+      if options.is_a?(Hash) && options.key?(:template)
+        options[:template].sub!(/^\//, '')
+      end
+
+      options[:text] = nil if options[:nothing] == true
+
+      body = super
+      body = [' '] if body.blank?
+      body
+    end
+
+    def _handle_method_missing
+      method_missing(@_action_name.to_sym)
+    end
+
+    def method_for_action(action_name)
+      super || (respond_to?(:method_missing) && "_handle_method_missing")
+    end
+
+    def _layout_prefix(name)
+      super unless name =~ /\blayouts/
+    end
+
+    def performed?
+      response_body
+    end
+
+    # ==== Request only view path switching ====
+    def append_view_path(path)
+      view_paths.push(*path)
+    end
+
+    def prepend_view_path(path)
+      view_paths.unshift(*path)
+    end
+
+    def view_paths
+      _action_view.view_paths
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/conditional_get.rb b/actionpack/lib/action_controller/new_base/conditional_get.rb
new file mode 100644
index 0000000000..8bd6db500b
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/conditional_get.rb
@@ -0,0 +1,133 @@
+module ActionController
+  module ConditionalGet
+    extend ActiveSupport::Concern
+
+    depends_on RackConvenience
+
+    # Sets the etag, last_modified, or both on the response and renders a
+    # "304 Not Modified" response if the request is already fresh.
+    #
+    # Parameters:
+    # * <tt>:etag</tt>
+    # * <tt>:last_modified</tt>
+    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
+    #
+    # Example:
+    #
+    #   def show
+    #     @article = Article.find(params[:id])
+    #     fresh_when(:etag => @article, :last_modified => @article.created_at.utc, :public => true)
+    #   end
+    #
+    # 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, :public)
+
+      response.etag          = options[:etag]          if options[:etag]
+      response.last_modified = options[:last_modified] if options[:last_modified]
+
+      if options[:public]
+        cache_control = response.headers["Cache-Control"].split(",").map {|k| k.strip }
+        cache_control.delete("private")
+        cache_control.delete("no-cache")
+        cache_control << "public"
+        response.headers["Cache-Control"] = cache_control.join(', ')
+      end
+
+      if request.fresh?(response)
+        head :not_modified
+      end
+    end
+
+    # Return a response that has no content (merely headers). The options
+    # argument is interpreted to be a hash of header names and values.
+    # This allows you to easily return a response that consists only of
+    # significant headers:
+    #
+    #   head :created, :location => person_path(@person)
+    #
+    # It can also be used to return exceptional conditions:
+    #
+    #   return head(:method_not_allowed) unless request.post?
+    #   return head(:bad_request) unless valid_request?
+    #   render
+    def head(*args)
+      if args.length > 2
+        raise ArgumentError, "too many arguments to head"
+      elsif args.empty?
+        raise ArgumentError, "too few arguments to head"
+      end
+      options = args.extract_options!
+      status = args.shift || options.delete(:status) || :ok
+
+      options.each do |key, value|
+        headers[key.to_s.dasherize.split(/-/).map { |v| v.capitalize }.join("-")] = value.to_s
+      end
+
+      render :nothing => true, :status => status
+    end
+
+    # Sets the etag and/or last_modified on the response and checks it against
+    # the client request. If the request doesn't match the options provided, the
+    # request is considered stale and should be generated from scratch. Otherwise,
+    # it's fresh and we don't need to generate anything and a reply of "304 Not Modified" is sent.
+    #
+    # Parameters:
+    # * <tt>:etag</tt>
+    # * <tt>:last_modified</tt>
+    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
+    #
+    # Example:
+    #
+    #   def show
+    #     @article = Article.find(params[:id])
+    #
+    #     if stale?(:etag => @article, :last_modified => @article.created_at.utc)
+    #       @statistics = @article.really_expensive_call
+    #       respond_to do |format|
+    #         # all the supported formats
+    #       end
+    #     end
+    #   end
+    def stale?(options)
+      fresh_when(options)
+      !request.fresh?(response)
+    end
+
+    # Sets a HTTP 1.1 Cache-Control header. Defaults to issuing a "private" instruction, so that
+    # intermediate caches shouldn't cache the response.
+    #
+    # Examples:
+    #   expires_in 20.minutes
+    #   expires_in 3.hours, :public => true
+    #   expires in 3.hours, 'max-stale' => 5.hours, :public => true
+    #
+    # This method will overwrite an existing Cache-Control header.
+    # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
+    def expires_in(seconds, options = {}) #:doc:
+      cache_control = response.headers["Cache-Control"].split(",").map {|k| k.strip }
+
+      cache_control << "max-age=#{seconds}"
+      cache_control.delete("no-cache")
+      if options[:public]
+        cache_control.delete("private")
+        cache_control << "public"
+      else
+        cache_control << "private"
+      end
+
+      # This allows for additional headers to be passed through like 'max-stale' => 5.hours
+      cache_control += options.symbolize_keys.reject{|k,v| k == :public || k == :private }.map{ |k,v| v == true ? k.to_s : "#{k.to_s}=#{v.to_s}"}
+
+      response.headers["Cache-Control"] = cache_control.join(', ')
+    end
+
+    # Sets a HTTP 1.1 Cache-Control header of "no-cache" so no caching should occur by the browser or
+    # intermediate caches (like caching proxy servers).
+    def expires_now #:doc:
+      response.headers["Cache-Control"] = "no-cache"
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/helpers.rb b/actionpack/lib/action_controller/new_base/helpers.rb
new file mode 100644
index 0000000000..c2ebd343e3
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/helpers.rb
@@ -0,0 +1,129 @@
+require 'active_support/core_ext/load_error'
+require 'active_support/core_ext/name_error'
+require 'active_support/dependencies'
+
+module ActionController
+  module Helpers
+    extend ActiveSupport::Concern
+
+    depends_on AbstractController::Helpers
+
+    included do
+      # Set the default directory for helpers
+      class_inheritable_accessor :helpers_dir
+      self.helpers_dir = (defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/app/helpers" : "app/helpers")
+    end
+
+    module ClassMethods
+      def inherited(klass)
+        klass.__send__ :default_helper_module!
+        super
+      end
+
+      # The +helper+ class method can take a series of helper module names, a block, or both.
+      #
+      # * <tt>*args</tt>: One or more modules, strings or symbols, or the special symbol <tt>:all</tt>.
+      # * <tt>&block</tt>: A block defining helper methods.
+      #
+      # ==== Examples
+      # When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
+      # and include the module in the template class.  The second form illustrates how to include custom helpers
+      # when working with namespaced controllers, or other cases where the file containing the helper definition is not
+      # in one of Rails' standard load paths:
+      #   helper :foo             # => requires 'foo_helper' and includes FooHelper
+      #   helper 'resources/foo'  # => requires 'resources/foo_helper' and includes Resources::FooHelper
+      #
+      # When the argument is a module it will be included directly in the template class.
+      #   helper FooHelper # => includes FooHelper
+      #
+      # When the argument is the symbol <tt>:all</tt>, the controller will include all helpers beneath
+      # <tt>ActionController::Base.helpers_dir</tt> (defaults to <tt>app/helpers/**/*.rb</tt> under RAILS_ROOT).
+      #   helper :all
+      #
+      # Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
+      # to the template.
+      #   # One line
+      #   helper { def hello() "Hello, world!" end }
+      #   # Multi-line
+      #   helper do
+      #     def foo(bar)
+      #       "#{bar} is the very best"
+      #     end
+      #   end
+      #
+      # Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
+      # +symbols+, +strings+, +modules+ and blocks.
+      #   helper(:three, BlindHelper) { def mice() 'mice' end }
+      #
+      def helper(*args, &block)
+        args.flatten.each do |arg|
+          case arg
+          when :all
+            helper all_application_helpers
+          when String, Symbol
+            file_name  = arg.to_s.underscore + '_helper'
+            class_name = file_name.camelize
+
+            begin
+              require_dependency(file_name)
+            rescue LoadError => load_error
+              requiree = / -- (.*?)(\.rb)?$/.match(load_error.message).to_a[1]
+              if requiree == file_name
+                msg = "Missing helper file helpers/#{file_name}.rb"
+                raise LoadError.new(msg).copy_blame!(load_error)
+              else
+                raise
+              end
+            end
+
+            super class_name.constantize
+          else
+            super args
+          end
+        end
+
+        # Evaluate block in template class if given.
+        master_helper_module.module_eval(&block) if block_given?
+      end
+
+      # Declares helper accessors for controller attributes. For example, the
+      # following adds new +name+ and <tt>name=</tt> instance methods to a
+      # controller and makes them available to the view:
+      #   helper_attr :name
+      #   attr_accessor :name
+      def helper_attr(*attrs)
+        attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") }
+      end
+
+      # Provides a proxy to access helpers methods from outside the view.
+      def helpers
+        unless @helper_proxy
+          @helper_proxy = ActionView::Base.new
+          @helper_proxy.extend master_helper_module
+        else
+          @helper_proxy
+        end
+      end
+
+      private
+        def default_helper_module!
+          unless name.blank?
+            module_name = name.sub(/Controller$|$/, 'Helper')
+            module_path = module_name.split('::').map { |m| m.underscore }.join('/')
+            require_dependency module_path
+            helper module_name.constantize
+          end
+        rescue MissingSourceFile => e
+          raise unless e.is_missing? module_path
+        rescue NameError => e
+          raise unless e.missing_name? module_name
+        end
+
+        # Extract helper names from files in app/helpers/**/*.rb
+        def all_application_helpers
+          extract = /^#{Regexp.quote(helpers_dir)}\/?(.*)_helper.rb$/
+          Dir["#{helpers_dir}/**/*_helper.rb"].map { |file| file.sub extract, '\1' }
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/hide_actions.rb b/actionpack/lib/action_controller/new_base/hide_actions.rb
index 473a8ea72b..b45e520bee 100644
--- a/actionpack/lib/action_controller/new_base/hide_actions.rb
+++ b/actionpack/lib/action_controller/new_base/hide_actions.rb
@@ -1,31 +1,39 @@
 module ActionController
   module HideActions
-    setup do
+    extend ActiveSupport::Concern
+
+    included do
       extlib_inheritable_accessor :hidden_actions
-      self.hidden_actions ||= Set.new      
+      self.hidden_actions ||= Set.new
     end
-    
-    def action_methods() self.class.action_names end
-    def action_names() action_methods end    
-      
-  private
-  
-    def respond_to_action?(action_name)
-      !hidden_actions.include?(action_name) && (super || respond_to?(:method_missing))
+
+    def action_methods
+      self.class.action_names
     end
-    
-    module ClassMethods
-      def hide_action(*args)
-        args.each do |arg|
-          self.hidden_actions << arg.to_s
-        end
-      end
-      
-      def action_methods
-        @action_names ||= Set.new(super.reject {|name| self.hidden_actions.include?(name.to_s)})
-      end
 
-      def self.action_names() action_methods end
+    def action_names
+      action_methods
     end
+
+    private
+      def action_method?(action_name)
+        !hidden_actions.include?(action_name) && super
+      end
+
+      module ClassMethods
+        def hide_action(*args)
+          args.each do |arg|
+            self.hidden_actions << arg.to_s
+          end
+        end
+
+        def action_methods
+          @action_names ||= Set.new(super.reject {|name| self.hidden_actions.include?(name.to_s)})
+        end
+
+        def self.action_names
+          action_methods
+        end
+      end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/new_base/http.rb b/actionpack/lib/action_controller/new_base/http.rb
new file mode 100644
index 0000000000..c96aaaa865
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/http.rb
@@ -0,0 +1,91 @@
+require 'action_controller/abstract'
+require 'active_support/core_ext/module/delegation'
+
+module ActionController
+  class Http < AbstractController::Base
+    abstract!
+
+    # :api: public
+    attr_internal :params, :env
+
+    # :api: public
+    def self.controller_name
+      @controller_name ||= controller_path.split("/").last
+    end
+
+    # :api: public
+    def controller_name
+      self.class.controller_name
+    end
+
+    # :api: public
+    def self.controller_path
+      @controller_path ||= self.name.sub(/Controller$/, '').underscore
+    end
+
+    # :api: public
+    def controller_path
+      self.class.controller_path
+    end
+
+    # :api: private
+    def self.action_names
+      action_methods
+    end
+
+    # :api: private
+    def action_names
+      action_methods
+    end
+
+    # :api: plugin
+    def self.call(env)
+      controller = new
+      controller.call(env).to_rack
+    end
+
+    # The details below can be overridden to support a specific
+    # Request and Response object. The default ActionController::Base
+    # implementation includes RackConvenience, which makes a request
+    # and response object available. You might wish to control the
+    # environment and response manually for performance reasons.
+
+    attr_internal :status, :headers, :content_type
+
+    def initialize(*)
+      @_headers = {}
+      super
+    end
+
+    # Basic implements for content_type=, location=, and headers are
+    # provided to reduce the dependency on the RackConvenience module
+    # in Renderer and Redirector.
+
+    def content_type=(type)
+      headers["Content-Type"] = type.to_s
+    end
+
+    def location=(url)
+      headers["Location"] = url
+    end
+
+    # :api: private
+    def call(name, env)
+      @_env = env
+      process(name)
+      to_rack
+    end
+
+    # :api: private
+    def to_rack
+      [status, headers, response_body]
+    end
+
+    def self.action(name)
+      @actions ||= {}
+      @actions[name.to_s] ||= proc do |env|
+        new.call(name, env)
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/layouts.rb b/actionpack/lib/action_controller/new_base/layouts.rb
index a8e0809ac6..727358c394 100644
--- a/actionpack/lib/action_controller/new_base/layouts.rb
+++ b/actionpack/lib/action_controller/new_base/layouts.rb
@@ -1,37 +1,34 @@
 module ActionController
   module Layouts
+    extend ActiveSupport::Concern
+
     depends_on ActionController::Renderer
     depends_on AbstractController::Layouts
-    
+
     module ClassMethods
       def _implied_layout_name
         controller_path
       end
     end
-    
-    def render_to_body(options)
-      # render :text => ..., :layout => ...
-      # or
-      # render :anything_else
-      if !options.key?(:text) || options.key?(:layout)
-        options[:_layout] = options.key?(:layout) ? _layout_for_option(options[:layout]) : _default_layout
+
+    private
+      def _determine_template(options)
+        super
+        if (!options.key?(:text) && !options.key?(:inline) && !options.key?(:partial)) || options.key?(:layout)
+          options[:_layout] = _layout_for_option(options.key?(:layout) ? options[:layout] : :none, options[:_template].details)
+        end
       end
-      
-      super
-    end
-    
-  private
-  
-    def _layout_for_option(name)
-      case name
-      when String     then _layout_for_name(name)
-      when true       then _default_layout(true)
-      when false, nil then nil
-      else
-        raise ArgumentError, 
-          "String, true, or false, expected for `layout'; you passed #{name.inspect}"        
+
+      def _layout_for_option(name, details)
+        case name
+        when String     then _layout_for_name(name, details)
+        when true       then _default_layout(true, details)
+        when :none      then _default_layout(false, details)
+        when false, nil then nil
+        else
+          raise ArgumentError,
+            "String, true, or false, expected for `layout'; you passed #{name.inspect}"
+        end
       end
-    end
-    
   end
 end
diff --git a/actionpack/lib/action_controller/new_base/rack_convenience.rb b/actionpack/lib/action_controller/new_base/rack_convenience.rb
new file mode 100644
index 0000000000..5dfa7d12f3
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/rack_convenience.rb
@@ -0,0 +1,33 @@
+module ActionController
+  module RackConvenience
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :headers, :status=, :location=,
+               :status, :location, :content_type, :to => "@_response"
+      attr_internal :request, :response
+    end
+
+    def call(name, env)
+      @_request = ActionDispatch::Request.new(env)
+      @_response = ActionDispatch::Response.new
+      @_response.request = request
+      super
+    end
+
+    def params
+      @_params ||= @_request.parameters
+    end
+
+    # :api: private
+    def to_rack
+      @_response.prepare!
+      @_response.to_a
+    end
+
+    def response_body=(body)
+      response.body = body if response
+      super
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/redirector.rb b/actionpack/lib/action_controller/new_base/redirector.rb
new file mode 100644
index 0000000000..20060b001f
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/redirector.rb
@@ -0,0 +1,19 @@
+module ActionController
+  class RedirectBackError < AbstractController::Error #:nodoc:
+    DEFAULT_MESSAGE = 'No HTTP_REFERER was set in the request to this action, so redirect_to :back could not be called successfully. If this is a test, make sure to specify request.env["HTTP_REFERER"].'
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  module Redirector
+    def redirect_to(url, status) #:doc:
+      raise AbstractController::DoubleRenderError if response_body
+      logger.info("Redirected to #{url}") if logger && logger.info?
+      self.status = status
+      self.location = url.gsub(/[\r\n]/, '')
+      self.response_body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/render_options.rb b/actionpack/lib/action_controller/new_base/render_options.rb
new file mode 100644
index 0000000000..04b954134f
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/render_options.rb
@@ -0,0 +1,103 @@
+module ActionController
+  module RenderOptions
+    extend ActiveSupport::Concern
+
+    included do
+      extlib_inheritable_accessor :_renderers
+      self._renderers = []
+    end
+
+    module ClassMethods
+      def _write_render_options
+        renderers = _renderers.map do |r|
+          <<-RUBY_EVAL
+            if options.key?(:#{r})
+              _process_options(options)
+              return _render_#{r}(options[:#{r}], options)
+            end
+          RUBY_EVAL
+        end
+
+        class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def _handle_render_options(options)
+            #{renderers.join}
+          end
+        RUBY_EVAL
+      end
+
+      def _add_render_option(name)
+        _renderers << name
+        _write_render_options
+      end
+    end
+
+    def render_to_body(options)
+      _handle_render_options(options) || super
+    end
+  end
+
+  module RenderOption #:nodoc:
+    def self.extended(base)
+      base.extend ActiveSupport::Concern
+      base.depends_on ::ActionController::RenderOptions
+
+      def base.register_renderer(name)
+        included { _add_render_option(name) }
+      end
+    end
+  end
+
+  module Renderers
+    module Json
+      extend RenderOption
+      register_renderer :json
+
+      def _render_json(json, options)
+        json = ActiveSupport::JSON.encode(json) unless json.respond_to?(:to_str)
+        json = "#{options[:callback]}(#{json})" unless options[:callback].blank?
+        self.content_type ||= Mime::JSON
+        self.response_body = json
+      end
+    end
+
+    module Js
+      extend RenderOption
+      register_renderer :js
+
+      def _render_js(js, options)
+        self.content_type ||= Mime::JS
+        self.response_body = js
+      end
+    end
+
+    module Xml
+      extend RenderOption
+      register_renderer :xml
+
+      def _render_xml(xml, options)
+        self.content_type ||= Mime::XML
+        self.response_body  = xml.respond_to?(:to_xml) ? xml.to_xml : xml
+      end
+    end
+
+    module RJS
+      extend RenderOption
+      register_renderer :update
+
+      def _render_update(proc, options)
+        generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(_action_view, &proc)
+        self.content_type = Mime::JS
+        self.response_body = generator.to_s
+      end
+    end
+
+    module All
+      extend ActiveSupport::Concern
+
+      depends_on ActionController::Renderers::Json
+      depends_on ActionController::Renderers::Js
+      depends_on ActionController::Renderers::Xml
+      depends_on ActionController::Renderers::RJS
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/renderer.rb b/actionpack/lib/action_controller/new_base/renderer.rb
index ed34c46aed..e132d4fdbb 100644
--- a/actionpack/lib/action_controller/new_base/renderer.rb
+++ b/actionpack/lib/action_controller/new_base/renderer.rb
@@ -1,62 +1,78 @@
 module ActionController
   module Renderer
+    extend ActiveSupport::Concern
+
     depends_on AbstractController::Renderer
-    
-    def initialize(*)
-      self.formats = [:html]
+
+    def process_action(*)
+      self.formats = request.formats.map {|x| x.to_sym}
       super
     end
-    
-    def render(action, options = {})
-      # TODO: Move this into #render_to_body
-      if action.is_a?(Hash)
-        options, action = action, nil 
-      else
-        options.merge! :action => action
+
+    def render(options)
+      super
+      options[:_template] ||= _action_view._partial
+      self.content_type ||= begin
+        mime = options[:_template].mime_type
+        formats.include?(mime && mime.to_sym) || formats.include?(:all) ? mime : Mime::Type.lookup_by_extension(formats.first)
       end
-      
-      _process_options(options)
-      
-      self.response_body = render_to_body(options)
+      response_body
     end
 
     def render_to_body(options)
-      unless options.is_a?(Hash)
-        options = {:action => options}
-      end
+      _process_options(options)
 
-      if options.key?(:text)
-        options[:_template] = ActionView::TextTemplate.new(_text(options))
-        template = nil
-      elsif options.key?(:template)
-        options[:_template_name] = options[:template]
-      elsif options.key?(:action)
-        options[:_template_name] = options[:action].to_s
-        options[:_prefix] = _prefix 
+      if options.key?(:partial)
+        _render_partial(options[:partial], options)
       end
-      
-      super(options)
+
+      super
     end
-    
-  private
-  
-    def _prefix
-      controller_path
-    end  
-  
-    def _text(options)
-      text = options[:text]
-
-      case text
-      when nil then " "
-      else text.to_s
+
+    private
+      def _prefix
+        controller_path
       end
-    end
-  
-    def _process_options(options)
-      if status = options[:status]
-        response.status = status.to_i
+
+      def _determine_template(options)
+        if options.key?(:text)
+          options[:_template] = ActionView::TextTemplate.new(options[:text], formats.first)
+        elsif options.key?(:inline)
+          handler = ActionView::Template.handler_class_for_extension(options[:type] || "erb")
+          template = ActionView::Template.new(options[:inline], "inline #{options[:inline].inspect}", handler, {})
+          options[:_template] = template
+        elsif options.key?(:template)
+          options[:_template_name] = options[:template]
+        elsif options.key?(:file)
+          options[:_template_name] = options[:file]
+        elsif !options.key?(:partial)
+          options[:_template_name] = (options[:action] || action_name).to_s
+          options[:_prefix] = _prefix
+        end
+
+        super
+      end
+
+      def _render_partial(partial, options)
+        case partial
+        when true
+          options[:_prefix] = _prefix
+        when String
+          options[:_prefix] = _prefix unless partial.index('/')
+          options[:_template_name] = partial
+        else
+          options[:_partial_object] = true
+          return
+        end
+
+        options[:_partial] = options[:object] || true
+      end
+
+      def _process_options(options)
+        status, content_type, location = options.values_at(:status, :content_type, :location)
+        self.status = status if status
+        self.content_type = content_type if content_type
+        self.headers["Location"] = url_for(location) if location
       end
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/new_base/rescuable.rb b/actionpack/lib/action_controller/new_base/rescuable.rb
new file mode 100644
index 0000000000..029e643d93
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/rescuable.rb
@@ -0,0 +1,52 @@
+module ActionController #:nodoc:
+  # Actions that fail to perform as expected throw exceptions. These
+  # exceptions can either be rescued for the public view (with a nice
+  # user-friendly explanation) or for the developers view (with tons of
+  # debugging information). The developers view is already implemented by
+  # the Action Controller, but the public view should be tailored to your
+  # specific application.
+  #
+  # The default behavior for public exceptions is to render a static html
+  # file with the name of the error code thrown.  If no such file exists, an
+  # empty response is sent with the correct status code.
+  #
+  # You can override what constitutes a local request by overriding the
+  # <tt>local_request?</tt> method in your own controller. Custom rescue
+  # behavior is achieved by overriding the <tt>rescue_action_in_public</tt>
+  # and <tt>rescue_action_locally</tt> methods.
+  module Rescue
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Rescuable
+    end
+
+    module ClassMethods
+      # This can be removed once we can move action(:_rescue_action) into middlewares.rb
+      # Currently, it does controller.method(:rescue_action), which is hiding the implementation
+      # difference between the old and new base.
+      def rescue_action(env)
+        action(:_rescue_action).call(env)
+      end
+    end
+
+    attr_internal :rescued_exception
+
+    private
+      def method_for_action(action_name)
+        return action_name if self.rescued_exception = request.env.delete("action_dispatch.rescue.exception")
+        super
+      end
+
+      def _rescue_action
+        rescue_with_handler(rescued_exception) || raise(rescued_exception)
+      end
+
+      def process_action(*)
+        super
+      rescue Exception => exception
+        self.rescued_exception = exception
+        _rescue_action
+      end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/session.rb b/actionpack/lib/action_controller/new_base/session.rb
new file mode 100644
index 0000000000..a585630230
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/session.rb
@@ -0,0 +1,15 @@
+module ActionController
+  module Session
+    extend ActiveSupport::Concern
+
+    depends_on RackConvenience
+
+    def session
+      @_request.session
+    end
+
+    def reset_session
+      @_request.reset_session
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/testing.rb b/actionpack/lib/action_controller/new_base/testing.rb
new file mode 100644
index 0000000000..e8d210d149
--- /dev/null
+++ b/actionpack/lib/action_controller/new_base/testing.rb
@@ -0,0 +1,39 @@
+module ActionController
+  module Testing
+    extend ActiveSupport::Concern
+
+    depends_on RackConvenience
+
+    # OMG MEGA HAX
+    def process_with_new_base_test(request, response)
+      @_request = request
+      @_response = response
+      @_response.request = request
+      ret = process(request.parameters[:action])
+      @_response.body ||= self.response_body
+      @_response.prepare!
+      set_test_assigns
+      ret
+    end
+
+    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
+      end
+    end
+
+    # TODO : Rewrite tests using controller.headers= to use Rack env
+    def headers=(new_headers)
+      @_response ||= ActionDispatch::Response.new
+      @_response.headers.replace(new_headers)
+    end
+
+    module ClassMethods
+      def before_filters
+        _process_action_callbacks.find_all{|x| x.kind == :before}.map{|x| x.name}
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/new_base/url_for.rb b/actionpack/lib/action_controller/new_base/url_for.rb
index af5b21012b..902cac4d15 100644
--- a/actionpack/lib/action_controller/new_base/url_for.rb
+++ b/actionpack/lib/action_controller/new_base/url_for.rb
@@ -1,5 +1,14 @@
 module ActionController
   module UrlFor
+    extend ActiveSupport::Concern
+
+    depends_on RackConvenience
+
+    def process_action(*)
+      initialize_current_url
+      super
+    end
+
     def initialize_current_url
       @url = UrlRewriter.new(request, params.clone)
     end
@@ -16,7 +25,7 @@ module ActionController
     # by this method.
     def default_url_options(options = nil)
     end
-    
+
     def rewrite_options(options) #:nodoc:
       if defaults = default_url_options(options)
         defaults.merge(options)
@@ -24,7 +33,7 @@ module ActionController
         options
       end
     end
-    
+
     def url_for(options = {})
       options ||= {}
       case options
@@ -37,4 +46,4 @@ module ActionController
       end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_controller/record_identifier.rb b/actionpack/lib/action_controller/record_identifier.rb
index 6bda27e23a..b4408e4e1d 100644
--- a/actionpack/lib/action_controller/record_identifier.rb
+++ b/actionpack/lib/action_controller/record_identifier.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module'
+
 module ActionController
   # The record identifier encapsulates a number of naming conventions for dealing with records, like Active Records or 
   # Active Resources or pretty much any other model type that has an id. These patterns are then used to try elevate
diff --git a/actionpack/lib/action_controller/routing.rb b/actionpack/lib/action_controller/routing.rb
index c0eb61340b..ce59866531 100644
--- a/actionpack/lib/action_controller/routing.rb
+++ b/actionpack/lib/action_controller/routing.rb
@@ -1,5 +1,9 @@
 require 'cgi'
 require 'uri'
+require 'set'
+
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'action_controller/routing/optimisations'
 require 'action_controller/routing/routing_ext'
 require 'action_controller/routing/route'
diff --git a/actionpack/lib/action_controller/routing/builder.rb b/actionpack/lib/action_controller/routing/builder.rb
index d9590c88b8..42ad12e1ea 100644
--- a/actionpack/lib/action_controller/routing/builder.rb
+++ b/actionpack/lib/action_controller/routing/builder.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/except'
+
 module ActionController
   module Routing
     class RouteBuilder #:nodoc:
diff --git a/actionpack/lib/action_controller/routing/route.rb b/actionpack/lib/action_controller/routing/route.rb
index e2077edad8..eba05a3c5a 100644
--- a/actionpack/lib/action_controller/routing/route.rb
+++ b/actionpack/lib/action_controller/routing/route.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/misc'
+
 module ActionController
   module Routing
     class Route #:nodoc:
@@ -65,7 +67,7 @@ module ActionController
       #   map.connect '/page/:id', :controller => 'pages', :action => 'show', :id => /\d+/
       #
       def parameter_shell
-        @parameter_shell ||= returning({}) do |shell|
+        @parameter_shell ||= {}.tap do |shell|
           requirements.each do |key, requirement|
             shell[key] = requirement unless requirement.is_a? Regexp
           end
@@ -76,7 +78,7 @@ module ActionController
       # includes keys that appear inside the path, and keys that have requirements
       # placed upon them.
       def significant_keys
-        @significant_keys ||= returning([]) do |sk|
+        @significant_keys ||= [].tap do |sk|
           segments.each { |segment| sk << segment.key if segment.respond_to? :key }
           sk.concat requirements.keys
           sk.uniq!
@@ -86,7 +88,7 @@ module ActionController
       # Return a hash of key/value pairs representing the keys in the route that
       # have defaults, or which are specified by non-regexp requirements.
       def defaults
-        @defaults ||= returning({}) do |hash|
+        @defaults ||= {}.tap do |hash|
           segments.each do |segment|
             next unless segment.respond_to? :default
             hash[segment.key] = segment.default unless segment.default.nil?
diff --git a/actionpack/lib/action_controller/routing/route_set.rb b/actionpack/lib/action_controller/routing/route_set.rb
index 70cd1f642d..45ad8a3a3b 100644
--- a/actionpack/lib/action_controller/routing/route_set.rb
+++ b/actionpack/lib/action_controller/routing/route_set.rb
@@ -430,7 +430,7 @@ module ActionController
       def call(env)
         request = ActionDispatch::Request.new(env)
         app = Routing::Routes.recognize(request)
-        app.call(env).to_a
+        app.action(request.parameters[:action] || 'index').call(env)
       end
 
       def recognize(request)
diff --git a/actionpack/lib/action_controller/routing/segments.rb b/actionpack/lib/action_controller/routing/segments.rb
index 4f936d51d2..2603855476 100644
--- a/actionpack/lib/action_controller/routing/segments.rb
+++ b/actionpack/lib/action_controller/routing/segments.rb
@@ -1,7 +1,7 @@
 module ActionController
   module Routing
     class Segment #:nodoc:
-      RESERVED_PCHAR = ':@&=+$,;'
+      RESERVED_PCHAR = ':@&=+$,;%'
       SAFE_PCHAR = "#{URI::REGEXP::PATTERN::UNRESERVED}#{RESERVED_PCHAR}"
       if RUBY_VERSION >= '1.9'
         UNSAFE_PCHAR = Regexp.new("[^#{SAFE_PCHAR}]", false).freeze
diff --git a/actionpack/lib/action_controller/testing/assertions/response.rb b/actionpack/lib/action_controller/testing/assertions/response.rb
deleted file mode 100644
index ca0a9bbf52..0000000000
--- a/actionpack/lib/action_controller/testing/assertions/response.rb
+++ /dev/null
@@ -1,150 +0,0 @@
-module ActionController
-  module Assertions
-    # A small suite of assertions that test responses from Rails applications.
-    module ResponseAssertions
-      # Asserts that the response is one of the following types:
-      #
-      # * <tt>:success</tt>   - Status code was 200
-      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
-      # * <tt>:missing</tt>   - Status code was 404
-      # * <tt>:error</tt>     - Status code was in the 500-599 range
-      #
-      # You can also pass an explicit status number like assert_response(501)
-      # or its symbolic equivalent assert_response(:not_implemented).
-      # See ActionDispatch::StatusCodes for a full list.
-      #
-      # ==== Examples
-      #
-      #   # assert that the response was a redirection
-      #   assert_response :redirect
-      #
-      #   # assert that the response code was status code 401 (unauthorized)
-      #   assert_response 401
-      #
-      def assert_response(type, message = nil)
-        clean_backtrace do
-          if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
-            assert_block("") { true } # to count the assertion
-          elsif type.is_a?(Fixnum) && @response.response_code == type
-            assert_block("") { true } # to count the assertion
-          elsif type.is_a?(Symbol) && @response.response_code == ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
-            assert_block("") { true } # to count the assertion
-          else
-            if @response.error?
-              exception = @response.template.instance_variable_get(:@exception)
-              exception_message = exception && exception.message
-              assert_block(build_message(message, "Expected response to be a <?>, but was <?>\n<?>", type, @response.response_code, exception_message.to_s)) { false }
-            else
-              assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
-            end
-          end
-        end
-      end
-
-      # Assert that the redirection options passed in match those of the redirect called in the latest action.
-      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
-      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
-      #
-      # ==== Examples
-      #
-      #   # assert that the redirection was to the "index" action on the WeblogController
-      #   assert_redirected_to :controller => "weblog", :action => "index"
-      #
-      #   # assert that the redirection was to the named route login_url
-      #   assert_redirected_to login_url
-      #
-      #   # assert that the redirection was to the url for @customer
-      #   assert_redirected_to @customer
-      #
-      def assert_redirected_to(options = {}, message=nil)
-        clean_backtrace do
-          assert_response(:redirect, message)
-          return true if options == @response.redirected_to
-
-          # Support partial arguments for hash redirections
-          if options.is_a?(Hash) && @response.redirected_to.is_a?(Hash)
-            return true if options.all? {|(key, value)| @response.redirected_to[key] == value}
-          end
-
-          redirected_to_after_normalisation = normalize_argument_to_redirection(@response.redirected_to)
-          options_after_normalisation       = normalize_argument_to_redirection(options)
-
-          if redirected_to_after_normalisation != options_after_normalisation
-            flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
-          end
-        end
-      end
-
-      # Asserts that the request was rendered with the appropriate template file or partials
-      #
-      # ==== Examples
-      #
-      #   # assert that the "new" view template was rendered
-      #   assert_template "new"
-      #
-      #   # assert that the "_customer" partial was rendered twice
-      #   assert_template :partial => '_customer', :count => 2
-      #
-      #   # assert that no partials were rendered
-      #   assert_template :partial => false
-      #
-      def assert_template(options = {}, message = nil)
-        clean_backtrace do
-          case options
-           when NilClass, String
-            rendered = @response.rendered[:template].to_s
-            msg = build_message(message,
-                    "expecting <?> but rendering with <?>",
-                    options, rendered)
-            assert_block(msg) do
-              if options.nil?
-                @response.rendered[:template].blank?
-              else
-                rendered.to_s.match(options)
-              end
-            end
-          when Hash
-            if expected_partial = options[:partial]
-              partials = @response.rendered[:partials]
-              if expected_count = options[:count]
-                found = partials.detect { |p, _| p.to_s.match(expected_partial) }
-                actual_count = found.nil? ? 0 : found.second
-                msg = build_message(message,
-                        "expecting ? to be rendered ? time(s) but rendered ? time(s)",
-                         expected_partial, expected_count, actual_count)
-                assert(actual_count == expected_count.to_i, msg)
-              else
-                msg = build_message(message,
-                        "expecting partial <?> but action rendered <?>",
-                        options[:partial], partials.keys)
-                assert(partials.keys.any? { |p| p.to_s.match(expected_partial) }, msg)
-              end
-            else
-              assert @response.rendered[:partials].empty?,
-                "Expected no partials to be rendered"
-            end
-          end
-        end
-      end
-
-      private
-        # Proxy to to_param if the object will respond to it.
-        def parameterize(value)
-          value.respond_to?(:to_param) ? value.to_param : value
-        end
-
-        def normalize_argument_to_redirection(fragment)
-          after_routing = @controller.url_for(fragment)
-          if after_routing =~ %r{^\w+://.*}
-            after_routing
-          else
-            # FIXME - this should probably get removed.
-            if after_routing.first != '/'
-              after_routing = '/' + after_routing
-            end
-            @request.protocol + @request.host_with_port + after_routing
-          end
-        end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/testing/integration.rb b/actionpack/lib/action_controller/testing/integration.rb
index d51b9b63ff..af4ccb7837 100644
--- a/actionpack/lib/action_controller/testing/integration.rb
+++ b/actionpack/lib/action_controller/testing/integration.rb
@@ -2,8 +2,119 @@ require 'stringio'
 require 'uri'
 require 'active_support/test_case'
 
+require 'rack/mock_session'
+require 'rack/test/cookie_jar'
+
 module ActionController
   module Integration #:nodoc:
+    module RequestHelpers
+      # Performs a GET request with the given parameters.
+      #
+      # - +path+: The URI (as a String) on which you want to perform a GET
+      #   request.
+      # - +parameters+: The HTTP parameters that you want to pass. This may
+      #   be +nil+,
+      #   a Hash, or a String that is appropriately encoded
+      #   (<tt>application/x-www-form-urlencoded</tt> or
+      #   <tt>multipart/form-data</tt>).
+      # - +headers+: Additional HTTP headers to pass, as a Hash. The keys will
+      #   automatically be upcased, with the prefix 'HTTP_' added if needed.
+      #
+      # This method returns an Response object, which one can use to
+      # inspect the details of the response. Furthermore, if this method was
+      # called from an ActionController::IntegrationTest object, then that
+      # object's <tt>@response</tt> instance variable will point to the same
+      # response object.
+      #
+      # You can also perform POST, PUT, DELETE, and HEAD requests with +post+,
+      # +put+, +delete+, and +head+.
+      def get(path, parameters = nil, headers = nil)
+        process :get, path, parameters, headers
+      end
+
+      # Performs a POST request with the given parameters. See get() for more
+      # details.
+      def post(path, parameters = nil, headers = nil)
+        process :post, path, parameters, headers
+      end
+
+      # Performs a PUT request with the given parameters. See get() for more
+      # details.
+      def put(path, parameters = nil, headers = nil)
+        process :put, path, parameters, headers
+      end
+
+      # Performs a DELETE request with the given parameters. See get() for
+      # more details.
+      def delete(path, parameters = nil, headers = nil)
+        process :delete, path, parameters, headers
+      end
+
+      # Performs a HEAD request with the given parameters. See get() for more
+      # details.
+      def head(path, parameters = nil, headers = nil)
+        process :head, path, parameters, headers
+      end
+
+      # Performs an XMLHttpRequest request with the given parameters, mirroring
+      # a request from the Prototype library.
+      #
+      # The request_method is :get, :post, :put, :delete or :head; the
+      # parameters are +nil+, a hash, or a url-encoded or multipart string;
+      # the headers are a hash.  Keys are automatically upcased and prefixed
+      # with 'HTTP_' if not already.
+      def xml_http_request(request_method, path, parameters = nil, headers = nil)
+        headers ||= {}
+        headers['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest'
+        headers['HTTP_ACCEPT'] ||= [Mime::JS, Mime::HTML, Mime::XML, 'text/xml', Mime::ALL].join(', ')
+        process(request_method, path, parameters, headers)
+      end
+      alias xhr :xml_http_request
+
+      # Follow a single redirect response. If the last response was not a
+      # redirect, an exception will be raised. Otherwise, the redirect is
+      # performed on the location header.
+      def follow_redirect!
+        raise "not a redirect! #{status} #{status_message}" unless redirect?
+        get(response.location)
+        status
+      end
+
+      # Performs a request using the specified method, following any subsequent
+      # redirect. Note that the redirects are followed until the response is
+      # not a redirect--this means you may run into an infinite loop if your
+      # redirect loops back to itself.
+      def request_via_redirect(http_method, path, parameters = nil, headers = nil)
+        process(http_method, path, parameters, headers)
+        follow_redirect! while redirect?
+        status
+      end
+
+      # Performs a GET request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def get_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:get, path, parameters, headers)
+      end
+
+      # Performs a POST request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def post_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:post, path, parameters, headers)
+      end
+
+      # Performs a PUT request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def put_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:put, path, parameters, headers)
+      end
+
+      # Performs a DELETE request, following any subsequent redirect.
+      # See +request_via_redirect+ for more information.
+      def delete_via_redirect(path, parameters = nil, headers = nil)
+        request_via_redirect(:delete, path, parameters, headers)
+      end
+    end
+
     # An integration Session instance represents a set of requests and responses
     # performed sequentially by some virtual user. Because you can instantiate
     # multiple sessions and run them side-by-side, you can also mimic (to some
@@ -13,24 +124,20 @@ module ActionController
     # IntegrationTest#open_session, rather than instantiating
     # Integration::Session directly.
     class Session
+      DEFAULT_HOST = "www.example.com"
+
       include Test::Unit::Assertions
-      include ActionController::TestCase::Assertions
+      include ActionDispatch::Assertions
       include ActionController::TestProcess
+      include RequestHelpers
 
-      # Rack application to use
-      attr_accessor :application
-
-      # The integer HTTP status code of the last request.
-      attr_reader :status
-
-      # The status message that accompanied the status code of the last request.
-      attr_reader :status_message
-
-      # The body of the last request.
-      attr_reader :body
+      %w( status status_message headers body redirect? ).each do |method|
+        delegate method, :to => :response, :allow_nil => true
+      end
 
-      # The URI of the last request.
-      attr_reader :path
+      %w( path ).each do |method|
+        delegate method, :to => :request, :allow_nil => true
+      end
 
       # The hostname used in the last request.
       attr_accessor :host
@@ -43,10 +150,9 @@ module ActionController
 
       # A map of the cookies returned by the last response, and which will be
       # sent with the next request.
-      attr_reader :cookies
-
-      # A map of the headers returned by the last response.
-      attr_reader :headers
+      def cookies
+        @mock_session.cookie_jar
+      end
 
       # A reference to the controller instance used by the last request.
       attr_reader :controller
@@ -60,12 +166,9 @@ module ActionController
       # A running counter of the number of requests processed.
       attr_accessor :request_count
 
-      class MultiPartNeededException < Exception
-      end
-
       # Create and initialize a new Session instance.
       def initialize(app = nil)
-        @application = app || ActionController::Dispatcher.new
+        @app = app || ActionController::Dispatcher.new
         reset!
       end
 
@@ -75,14 +178,12 @@ module ActionController
       #
       #   session.reset!
       def reset!
-        @status = @path = @headers = nil
-        @result = @status_message = nil
         @https = false
-        @cookies = {}
+        @mock_session = Rack::MockSession.new(@app, DEFAULT_HOST)
         @controller = @request = @response = nil
         @request_count = 0
 
-        self.host        = "www.example.com"
+        self.host        = DEFAULT_HOST
         self.remote_addr = "127.0.0.1"
         self.accept      = "text/xml,application/xml,application/xhtml+xml," +
                            "text/html;q=0.9,text/plain;q=0.8,image/png," +
@@ -124,117 +225,6 @@ module ActionController
         @host = name
       end
 
-      # Follow a single redirect response. If the last response was not a
-      # redirect, an exception will be raised. Otherwise, the redirect is
-      # performed on the location header.
-      def follow_redirect!
-        raise "not a redirect! #{@status} #{@status_message}" unless redirect?
-        get(interpret_uri(headers['location']))
-        status
-      end
-
-      # Performs a request using the specified method, following any subsequent
-      # redirect. Note that the redirects are followed until the response is
-      # not a redirect--this means you may run into an infinite loop if your
-      # redirect loops back to itself.
-      def request_via_redirect(http_method, path, parameters = nil, headers = nil)
-        send(http_method, path, parameters, headers)
-        follow_redirect! while redirect?
-        status
-      end
-
-      # Performs a GET request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def get_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:get, path, parameters, headers)
-      end
-
-      # Performs a POST request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def post_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:post, path, parameters, headers)
-      end
-
-      # Performs a PUT request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def put_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:put, path, parameters, headers)
-      end
-
-      # Performs a DELETE request, following any subsequent redirect.
-      # See +request_via_redirect+ for more information.
-      def delete_via_redirect(path, parameters = nil, headers = nil)
-        request_via_redirect(:delete, path, parameters, headers)
-      end
-
-      # Returns +true+ if the last response was a redirect.
-      def redirect?
-        status/100 == 3
-      end
-
-      # Performs a GET request with the given parameters.
-      #
-      # - +path+: The URI (as a String) on which you want to perform a GET
-      #   request.
-      # - +parameters+: The HTTP parameters that you want to pass. This may
-      #   be +nil+,
-      #   a Hash, or a String that is appropriately encoded
-      #   (<tt>application/x-www-form-urlencoded</tt> or
-      #   <tt>multipart/form-data</tt>).
-      # - +headers+: Additional HTTP headers to pass, as a Hash. The keys will
-      #   automatically be upcased, with the prefix 'HTTP_' added if needed.
-      #
-      # This method returns an Response object, which one can use to
-      # inspect the details of the response. Furthermore, if this method was
-      # called from an ActionController::IntegrationTest object, then that
-      # object's <tt>@response</tt> instance variable will point to the same
-      # response object.
-      #
-      # You can also perform POST, PUT, DELETE, and HEAD requests with +post+,
-      # +put+, +delete+, and +head+.
-      def get(path, parameters = nil, headers = nil)
-        process :get, path, parameters, headers
-      end
-
-      # Performs a POST request with the given parameters. See get() for more
-      # details.
-      def post(path, parameters = nil, headers = nil)
-        process :post, path, parameters, headers
-      end
-
-      # Performs a PUT request with the given parameters. See get() for more
-      # details.
-      def put(path, parameters = nil, headers = nil)
-        process :put, path, parameters, headers
-      end
-
-      # Performs a DELETE request with the given parameters. See get() for
-      # more details.
-      def delete(path, parameters = nil, headers = nil)
-        process :delete, path, parameters, headers
-      end
-
-      # Performs a HEAD request with the given parameters. See get() for more
-      # details.
-      def head(path, parameters = nil, headers = nil)
-        process :head, path, parameters, headers
-      end
-
-      # Performs an XMLHttpRequest request with the given parameters, mirroring
-      # a request from the Prototype library.
-      #
-      # The request_method is :get, :post, :put, :delete or :head; the
-      # parameters are +nil+, a hash, or a url-encoded or multipart string;
-      # the headers are a hash.  Keys are automatically upcased and prefixed
-      # with 'HTTP_' if not already.
-      def xml_http_request(request_method, path, parameters = nil, headers = nil)
-        headers ||= {}
-        headers['X-Requested-With'] = 'XMLHttpRequest'
-        headers['Accept'] ||= [Mime::JS, Mime::HTML, Mime::XML, 'text/xml', Mime::ALL].join(', ')
-        process(request_method, path, parameters, headers)
-      end
-      alias xhr :xml_http_request
-
       # Returns the URL for the given options, according to the rules specified
       # in the application's routes.
       def url_for(options)
@@ -244,137 +234,54 @@ module ActionController
       end
 
       private
-        # Tailors the session based on the given URI, setting the HTTPS value
-        # and the hostname.
-        def interpret_uri(path)
-          location = URI.parse(path)
-          https! URI::HTTPS === location if location.scheme
-          host! location.host if location.host
-          location.query ? "#{location.path}?#{location.query}" : location.path
-        end
 
         # Performs the actual request.
-        def process(method, path, parameters = nil, headers = nil)
-          data = requestify(parameters)
-          path = interpret_uri(path) if path =~ %r{://}
-          path = "/#{path}" unless path[0] == ?/
-          @path = path
-          env = {}
-
-          if method == :get
-            env["QUERY_STRING"] = data
-            data = nil
+        def process(method, path, parameters = nil, rack_environment = nil)
+          if path =~ %r{://}
+            location = URI.parse(path)
+            https! URI::HTTPS === location if location.scheme
+            host! location.host if location.host
+            path = location.query ? "#{location.path}?#{location.query}" : location.path
           end
 
-          env["QUERY_STRING"] ||= ""
+          [ControllerCapture, ActionController::ProcessWithTest].each do |mod|
+            unless ActionController::Base < mod
+              ActionController::Base.class_eval { include mod }
+            end
+          end
 
-          data = data.is_a?(IO) ? data : StringIO.new(data || '')
+          opts = {
+            :method => method,
+            :params => parameters,
 
-          env.update(
-            "REQUEST_METHOD"  => method.to_s.upcase,
             "SERVER_NAME"     => host,
             "SERVER_PORT"     => (https? ? "443" : "80"),
             "HTTPS"           => https? ? "on" : "off",
             "rack.url_scheme" => https? ? "https" : "http",
-            "SCRIPT_NAME"     => "",
 
             "REQUEST_URI"    => path,
             "PATH_INFO"      => path,
             "HTTP_HOST"      => host,
             "REMOTE_ADDR"    => remote_addr,
             "CONTENT_TYPE"   => "application/x-www-form-urlencoded",
-            "CONTENT_LENGTH" => data ? data.length.to_s : nil,
-            "HTTP_COOKIE"    => encode_cookies,
-            "HTTP_ACCEPT"    => accept,
-
-            "rack.version"      => [0,1],
-            "rack.input"        => data,
-            "rack.errors"       => StringIO.new,
-            "rack.multithread"  => true,
-            "rack.multiprocess" => true,
-            "rack.run_once"     => false,
-
-            "rack.test" => true
-          )
-
-          (headers || {}).each do |key, value|
-            key = key.to_s.upcase.gsub(/-/, "_")
-            key = "HTTP_#{key}" unless env.has_key?(key) || key =~ /^HTTP_/
-            env[key] = value
-          end
+            "HTTP_ACCEPT"    => accept
+          }
+          env = Rack::MockRequest.env_for(path, opts)
 
-          [ControllerCapture, ActionController::ProcessWithTest].each do |mod|
-            unless ActionController::Base < mod
-              ActionController::Base.class_eval { include mod }
-            end
+          (rack_environment || {}).each do |key, value|
+            env[key] = value
           end
 
-          ActionController::Base.clear_last_instantiation!
-
-          app = @application
-          # Rack::Lint doesn't accept String headers or bodies in Ruby 1.9
-          unless RUBY_VERSION >= '1.9.0' && Rack.release <= '0.9.0'
-            app = Rack::Lint.new(app)
+          @controller = ActionController::Base.capture_instantiation do
+            @mock_session.request(URI.parse(path), env)
           end
 
-          status, headers, body = app.call(env)
           @request_count += 1
-
+          @request  = ActionDispatch::Request.new(env)
+          @response = ActionDispatch::TestResponse.from_response(@mock_session.last_response)
           @html_document = nil
 
-          @status = status.to_i
-          @status_message = ActionDispatch::StatusCodes::STATUS_CODES[@status]
-
-          @headers = Rack::Utils::HeaderHash.new(headers)
-
-          (@headers['Set-Cookie'] || "").split("\n").each do |cookie|
-            name, value = cookie.match(/^([^=]*)=([^;]*);/)[1,2]
-            @cookies[name] = value
-          end
-
-          if body.is_a?(String)
-            @body_parts = [body]
-            @body = body
-          else
-            @body_parts = []
-            body.each { |part| @body_parts << part.to_s }
-            @body = @body_parts.join
-          end
-
-          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
-            @response = ActionDispatch::Response.new
-            @response.status = status.to_s
-            @response.headers.replace(@headers)
-            @response.body = @body_parts
-          end
-
-          # Decorate the response with the standard behavior of the
-          # TestResponse so that things like assert_response can be
-          # used in integration tests.
-          @response.extend(TestResponseBehavior)
-
-          return @status
-        rescue MultiPartNeededException
-          boundary = "----------XnJLe9ZIbbGUYtzPQJ16u1"
-          status = process(method, path,
-            multipart_body(parameters, boundary),
-            (headers || {}).merge(
-              {"CONTENT_TYPE" => "multipart/form-data; boundary=#{boundary}"}))
-          return status
-        end
-
-        # Encode the cookies hash in a format suitable for passing to a
-        # request.
-        def encode_cookies
-          cookies.inject("") do |string, (name, value)|
-            string << "#{name}=#{value}; "
-          end
+          return response.status
         end
 
         # Get a temporary URL writer object
@@ -389,97 +296,29 @@ module ActionController
           }
           UrlRewriter.new(ActionDispatch::Request.new(env), {})
         end
-
-        def name_with_prefix(prefix, name)
-          prefix ? "#{prefix}[#{name}]" : name.to_s
-        end
-
-        # Convert the given parameters to a request string. The parameters may
-        # be a string, +nil+, or a Hash.
-        def requestify(parameters, prefix=nil)
-          if TestUploadedFile === parameters
-            raise MultiPartNeededException
-          elsif Hash === parameters
-            return nil if parameters.empty?
-            parameters.map { |k,v|
-              requestify(v, name_with_prefix(prefix, k))
-            }.join("&")
-          elsif Array === parameters
-            parameters.map { |v|
-              requestify(v, name_with_prefix(prefix, ""))
-            }.join("&")
-          elsif prefix.nil?
-            parameters
-          else
-            "#{CGI.escape(prefix)}=#{CGI.escape(parameters.to_s)}"
-          end
-        end
-
-        def multipart_requestify(params, first=true)
-          returning Hash.new do |p|
-            params.each do |key, value|
-              k = first ? CGI.escape(key.to_s) : "[#{CGI.escape(key.to_s)}]"
-              if Hash === value
-                multipart_requestify(value, false).each do |subkey, subvalue|
-                  p[k + subkey] = subvalue
-                end
-              else
-                p[k] = value
-              end
-            end
-          end
-        end
-
-        def multipart_body(params, boundary)
-          multipart_requestify(params).map do |key, value|
-            if value.respond_to?(:original_filename)
-              File.open(value.path, "rb") do |f|
-                f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
-
-                <<-EOF
---#{boundary}\r
-Content-Disposition: form-data; name="#{key}"; filename="#{CGI.escape(value.original_filename)}"\r
-Content-Type: #{value.content_type}\r
-Content-Length: #{File.stat(value.path).size}\r
-\r
-#{f.read}\r
-EOF
-              end
-            else
-<<-EOF
---#{boundary}\r
-Content-Disposition: form-data; name="#{key}"\r
-\r
-#{value}\r
-EOF
-            end
-          end.join("")+"--#{boundary}--\r"
-        end
     end
 
     # A module used to extend ActionController::Base, so that integration tests
     # can capture the controller used to satisfy a request.
     module ControllerCapture #:nodoc:
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.class_eval do
-          class << self
-            alias_method_chain :new, :capture
-          end
-        end
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :initialize, :capture
+      end
+
+      def initialize_with_capture(*args)
+        initialize_without_capture
+        self.class.last_instantiation ||= self
       end
 
       module ClassMethods #:nodoc:
         mattr_accessor :last_instantiation
 
-        def clear_last_instantiation!
+        def capture_instantiation
           self.last_instantiation = nil
-        end
-
-        def new_with_capture(*args)
-          controller = new_without_capture(*args)
-          self.last_instantiation ||= controller
-          controller
+          yield
+          return last_instantiation
         end
       end
     end
@@ -513,8 +352,8 @@ EOF
       # By default, a single session is automatically created for you, but you
       # can use this method to open multiple sessions that ought to be tested
       # simultaneously.
-      def open_session(application = nil)
-        session = Integration::Session.new(application)
+      def open_session(app = nil)
+        session = Integration::Session.new(app)
 
         # delegate the fixture accessors back to the test instance
         extras = Module.new { attr_accessor :delegate, :test_result }
@@ -636,54 +475,5 @@ EOF
   #   end
   class IntegrationTest < ActiveSupport::TestCase
     include Integration::Runner
-
-    # Work around a bug in test/unit caused by the default test being named
-    # as a symbol (:default_test), which causes regex test filters
-    # (like "ruby test.rb -n /foo/") to fail because =~ doesn't work on
-    # symbols.
-    def initialize(name) #:nodoc:
-      super(name.to_s)
-    end
-
-    # Work around test/unit's requirement that every subclass of TestCase have
-    # at least one test method. Note that this implementation extends to all
-    # subclasses, as well, so subclasses of IntegrationTest may also exist
-    # without any test methods.
-    def run(*args) #:nodoc:
-      return if @method_name == "default_test"
-      super
-    end
-
-    # Because of how use_instantiated_fixtures and use_transactional_fixtures
-    # are defined, we need to treat them as special cases. Otherwise, users
-    # would potentially have to set their values for both Test::Unit::TestCase
-    # ActionController::IntegrationTest, since by the time the value is set on
-    # TestCase, IntegrationTest has already been defined and cannot inherit
-    # changes to those variables. So, we make those two attributes
-    # copy-on-write.
-
-    class << self
-      def use_transactional_fixtures=(flag) #:nodoc:
-        @_use_transactional_fixtures = true
-        @use_transactional_fixtures = flag
-      end
-
-      def use_instantiated_fixtures=(flag) #:nodoc:
-        @_use_instantiated_fixtures = true
-        @use_instantiated_fixtures = flag
-      end
-
-      def use_transactional_fixtures #:nodoc:
-        @_use_transactional_fixtures ?
-          @use_transactional_fixtures :
-          superclass.use_transactional_fixtures
-      end
-
-      def use_instantiated_fixtures #:nodoc:
-        @_use_instantiated_fixtures ?
-          @use_instantiated_fixtures :
-          superclass.use_instantiated_fixtures
-      end
-    end
   end
 end
diff --git a/actionpack/lib/action_controller/testing/process.rb b/actionpack/lib/action_controller/testing/process.rb
index 7e2857614c..9647f8ce45 100644
--- a/actionpack/lib/action_controller/testing/process.rb
+++ b/actionpack/lib/action_controller/testing/process.rb
@@ -1,94 +1,13 @@
 require 'rack/session/abstract/id'
-module ActionController #:nodoc:
-  class TestRequest < ActionDispatch::Request #:nodoc:
-    attr_accessor :cookies, :session_options
-    attr_accessor :query_parameters, :path, :session
-    attr_accessor :host
-
-    def self.new(env = {})
-      super
-    end
+require 'active_support/core_ext/object/conversions'
 
+module ActionController #:nodoc:
+  class TestRequest < ActionDispatch::TestRequest #:nodoc:
     def initialize(env = {})
-      super(Rack::MockRequest.env_for("/").merge(env))
-
-      @query_parameters   = {}
-      @session            = TestSession.new
-      default_rack_options = Rack::Session::Abstract::ID::DEFAULT_OPTIONS
-      @session_options    ||= {:id => generate_sid(default_rack_options[:sidbits])}.merge(default_rack_options)
-
-      initialize_default_values
-      initialize_containers
-    end
-
-    def reset_session
-      @session.reset
-    end
-
-    # Wraps raw_post in a StringIO.
-    def body_stream #:nodoc:
-      StringIO.new(raw_post)
-    end
-
-    # Either the RAW_POST_DATA environment variable or the URL-encoded request
-    # parameters.
-    def raw_post
-      @env['RAW_POST_DATA'] ||= begin
-        data = url_encoded_request_parameters
-        data.force_encoding(Encoding::BINARY) if data.respond_to?(:force_encoding)
-        data
-      end
-    end
-
-    def port=(number)
-      @env["SERVER_PORT"] = number.to_i
-    end
-
-    def action=(action_name)
-      @query_parameters.update({ "action" => action_name })
-      @parameters = nil
-    end
-
-    # Used to check AbstractRequest's request_uri functionality.
-    # Disables the use of @path and @request_uri so superclass can handle those.
-    def set_REQUEST_URI(value)
-      @env["REQUEST_URI"] = value
-      @request_uri = nil
-      @path = nil
-    end
-
-    def request_uri=(uri)
-      @request_uri = uri
-      @path = uri.split("?").first
-    end
-
-    def request_method=(method)
-      @request_method = method
-    end
-
-    def accept=(mime_types)
-      @env["HTTP_ACCEPT"] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
-      @accepts = nil
-    end
-
-    def if_modified_since=(last_modified)
-      @env["HTTP_IF_MODIFIED_SINCE"] = last_modified
-    end
-
-    def if_none_match=(etag)
-      @env["HTTP_IF_NONE_MATCH"] = etag
-    end
-
-    def remote_addr=(addr)
-      @env['REMOTE_ADDR'] = addr
-    end
-
-    def request_uri(*args)
-      @request_uri || super()
-    end
+      super
 
-    def path(*args)
-      @path || super()
+      self.session = TestSession.new
+      self.session_options = TestSession::DEFAULT_OPTIONS.merge(:id => ActiveSupport::SecureRandom.hex(16))
     end
 
     def assign_parameters(controller_path, action, parameters)
@@ -108,247 +27,46 @@ module ActionController #:nodoc:
           path_parameters[key.to_s] = value
         end
       end
-      raw_post # populate env['RAW_POST_DATA']
-      @parameters = nil # reset TestRequest#parameters to use the new path_parameters
-    end
 
-    def recycle!
-      @env["action_controller.request.request_parameters"] = {}
-      self.query_parameters   = {}
-      self.path_parameters    = {}
-      @headers, @request_method, @accepts, @content_type = nil, nil, nil, nil
-    end
-
-    def user_agent=(user_agent)
-      @env['HTTP_USER_AGENT'] = user_agent
-    end
-
-    private
-      def generate_sid(sidbits)
-        "%0#{sidbits / 4}x" % rand(2**sidbits - 1)
-      end
-
-      def initialize_containers
-        @cookies = {}
-      end
-
-      def initialize_default_values
-        @host                    = "test.host"
-        @request_uri             = "/"
-        @env['HTTP_USER_AGENT']  = "Rails Testing"
-        @env['REMOTE_ADDR']      = "0.0.0.0"
-        @env["SERVER_PORT"]      = 80
-        @env['REQUEST_METHOD']   = "GET"
-      end
-
-      def url_encoded_request_parameters
-        params = self.request_parameters.dup
-
-        %w(controller action only_path).each do |k|
-          params.delete(k)
-          params.delete(k.to_sym)
-        end
+      params = self.request_parameters.dup
 
-        params.to_query
+      %w(controller action only_path).each do |k|
+        params.delete(k)
+        params.delete(k.to_sym)
       end
-  end
-
-  # A refactoring of TestResponse to allow the same behavior to be applied
-  # to the "real" CgiResponse class in integration tests.
-  module TestResponseBehavior #:nodoc:
-    # The response code of the request
-    def response_code
-      status.to_s[0,3].to_i rescue 0
-    end
-
-    # Returns a String to ensure compatibility with Net::HTTPResponse
-    def code
-      status.to_s.split(' ')[0]
-    end
-
-    def message
-      status.to_s.split(' ',2)[1]
-    end
-
-    # Was the response successful?
-    def success?
-      (200..299).include?(response_code)
-    end
 
-    # Was the URL not found?
-    def missing?
-      response_code == 404
+      data = params.to_query
+      @env['CONTENT_LENGTH'] = data.length.to_s
+      @env['rack.input'] = StringIO.new(data)
     end
 
-    # Were we redirected?
-    def redirect?
-      (300..399).include?(response_code)
-    end
-
-    # Was there a server-side error?
-    def error?
-      (500..599).include?(response_code)
-    end
-
-    alias_method :server_error?, :error?
-
-    # Was there a client client?
-    def client_error?
-      (400..499).include?(response_code)
-    end
-
-    # Returns the redirection location or nil
-    def redirect_url
-      headers['Location']
-    end
-
-    # Does the redirect location match this regexp pattern?
-    def redirect_url_match?( pattern )
-      return false if redirect_url.nil?
-      p = Regexp.new(pattern) if pattern.class == String
-      p = pattern if pattern.class == Regexp
-      return false if p.nil?
-      p.match(redirect_url) != nil
-    end
-
-    # Returns the template of the file which was used to
-    # render this response (or nil)
-    def rendered
-      template.instance_variable_get(:@_rendered)
-    end
-
-    # A shortcut to the flash. Returns an empty hash if no session flash exists.
-    def flash
-      session['flash'] || {}
-    end
-
-    # Do we have a flash?
-    def has_flash?
-      !flash.empty?
-    end
-
-    # Do we have a flash that has contents?
-    def has_flash_with_contents?
-      !flash.empty?
-    end
-
-    # Does the specified flash object exist?
-    def has_flash_object?(name=nil)
-      !flash[name].nil?
-    end
-
-    # Does the specified object exist in the session?
-    def has_session_object?(name=nil)
-      !session[name].nil?
-    end
-
-    # A shortcut to the template.assigns
-    def template_objects
-      template.assigns || {}
-    end
-
-    # Does the specified template object exist?
-    def has_template_object?(name=nil)
-      !template_objects[name].nil?
-    end
-
-    # Returns the response cookies, converted to a Hash of (name => value) pairs
-    #
-    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
-    def cookies
-      cookies = {}
-      Array(headers['Set-Cookie']).each do |cookie|
-        key, value = cookie.split(";").first.split("=").map {|val| Rack::Utils.unescape(val)}
-        cookies[key] = value
-      end
-      cookies
-    end
-
-    # Returns binary content (downloadable file), converted to a String
-    def binary_content
-      raise "Response body is not a Proc: #{body_parts.inspect}" unless body_parts.kind_of?(Proc)
-      require 'stringio'
-
-      sio = StringIO.new
-      body_parts.call(self, sio)
-
-      sio.rewind
-      sio.read
-    end
-  end
-
-  # Integration test methods such as ActionController::Integration::Session#get
-  # and ActionController::Integration::Session#post return objects of class
-  # TestResponse, which represent the HTTP response results of the requested
-  # controller actions.
-  #
-  # See Response for more information on controller response objects.
-  class TestResponse < ActionDispatch::Response
-    include TestResponseBehavior
-
     def recycle!
-      body_parts.clear
-      headers.delete('ETag')
-      headers.delete('Last-Modified')
+      @formats = nil
+      @env.delete_if { |k, v| k =~ /^(action_dispatch|rack)\.request/ }
+      @env.delete_if { |k, v| k =~ /^action_dispatch\.rescue/ }
+      @env['action_dispatch.request.query_parameters'] = {}
     end
   end
 
-  class TestSession < Hash #:nodoc:
-    attr_accessor :session_id
-
-    def initialize(attributes = nil)
-      reset_session_id
-      replace_attributes(attributes)
-    end
-
-    def reset
-      reset_session_id
-      replace_attributes({ })
-    end
-
-    def data
-      to_hash
-    end
-
-    def [](key)
-      super(key.to_s)
-    end
-
-    def []=(key, value)
-      super(key.to_s, value)
-    end
-
-    def update(hash = nil)
-      if hash.nil?
-        ActiveSupport::Deprecation.warn('use replace instead', caller)
-        replace({})
-      else
-        super(hash)
-      end
-    end
-
-    def delete(key = nil)
-      if key.nil?
-        ActiveSupport::Deprecation.warn('use clear instead', caller)
-        clear
-      else
-        super(key.to_s)
-      end
-    end
+  class TestResponse < ActionDispatch::TestResponse
+    def recycle!
+      @status = 200
+      @header = Rack::Utils::HeaderHash.new(DEFAULT_HEADERS)
+      @writer = lambda { |x| @body << x }
+      @block = nil
+      @length = 0
+      @body = []
 
-    def close
-      ActiveSupport::Deprecation.warn('sessions should no longer be closed', caller)
+      @request = @template = nil
     end
+  end
 
-  private
-
-    def reset_session_id
-      @session_id = ''
-    end
+  class TestSession < ActionDispatch::Session::AbstractStore::SessionHash #:nodoc:
+    DEFAULT_OPTIONS = ActionDispatch::Session::AbstractStore::DEFAULT_OPTIONS
 
-    def replace_attributes(attributes = nil)
-      attributes ||= {}
-      replace(attributes.stringify_keys)
+    def initialize(session = {})
+      replace(session.stringify_keys)
+      @loaded = true
     end
   end
 
@@ -363,34 +81,7 @@ module ActionController #:nodoc:
   #
   # Pass a true third parameter to ensure the uploaded file is opened in binary mode (only required for Windows):
   #   post :change_avatar, :avatar => ActionController::TestUploadedFile.new(ActionController::TestCase.fixture_path + '/files/spongebob.png', 'image/png', :binary)
-  require 'tempfile'
-  class TestUploadedFile
-    # The filename, *not* including the path, of the "uploaded" file
-    attr_reader :original_filename
-
-    # The content type of the "uploaded" file
-    attr_accessor :content_type
-
-    def initialize(path, content_type = Mime::TEXT, binary = false)
-      raise "#{path} file does not exist" unless File.exist?(path)
-      @content_type = content_type
-      @original_filename = path.sub(/^.*#{File::SEPARATOR}([^#{File::SEPARATOR}]+)$/) { $1 }
-      @tempfile = Tempfile.new(@original_filename)
-      @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
-      @tempfile.binmode if binary
-      FileUtils.copy_file(path, @tempfile.path)
-    end
-
-    def path #:nodoc:
-      @tempfile.path
-    end
-
-    alias local_path path
-
-    def method_missing(method_name, *args, &block) #:nodoc:
-      @tempfile.__send__(method_name, *args, &block)
-    end
-  end
+  TestUploadedFile = Rack::Utils::Multipart::UploadedFile
 
   module TestProcess
     def self.included(base)
@@ -433,9 +124,7 @@ module ActionController #:nodoc:
       @response.recycle!
 
       @html_document = nil
-      @request.env['REQUEST_METHOD'] = http_method
-
-      @request.action = action.to_s
+      @request.request_method = http_method
 
       parameters ||= {}
       @request.assign_parameters(@controller.class.controller_path, action.to_s, parameters)
@@ -445,7 +134,19 @@ module ActionController #:nodoc:
       build_request_uri(action, parameters)
 
       Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
-      @controller.process_with_test(@request, @response)
+
+      env = @request.env
+      app = @controller
+
+      # TODO: Enable Lint
+      # app = Rack::Lint.new(app)
+
+      status, headers, body = app.action(action, env)
+      response = Rack::MockResponse.new(status, headers, body)
+
+      @response.request, @response.template = @request, @controller.template
+      @response.status, @response.headers, @response.body = response.status, response.headers, response.body
+      @response
     end
 
     def xml_http_request(request_method, action, parameters = nil, session = nil, flash = nil)
@@ -459,11 +160,13 @@ module ActionController #:nodoc:
     alias xhr :xml_http_request
 
     def assigns(key = nil)
-      if key.nil?
-        @response.template.assigns
-      else
-        @response.template.assigns[key.to_s]
+      assigns = {}
+      @controller.instance_variable_names.each do |ivar|
+        next if ActionController::Base.protected_instance_variables.include?(ivar)
+        assigns[ivar[1..-1]] = @controller.instance_variable_get(ivar)
       end
+      
+      key.nil? ? assigns : assigns[key.to_s]
     end
 
     def session
@@ -471,7 +174,7 @@ module ActionController #:nodoc:
     end
 
     def flash
-      @response.flash
+      @request.flash
     end
 
     def cookies
@@ -488,7 +191,7 @@ module ActionController #:nodoc:
         options.update(:only_path => true, :action => action)
 
         url = ActionController::UrlRewriter.new(@request, parameters)
-        @request.set_REQUEST_URI(url.rewrite(options))
+        @request.request_uri = url.rewrite(options)
       end
     end
 
@@ -561,11 +264,14 @@ module ActionController #:nodoc:
 
   module ProcessWithTest #:nodoc:
     def self.included(base)
-      base.class_eval { attr_reader :assigns }
+      base.class_eval {
+        attr_reader :assigns
+        alias_method_chain :process, :test
+      }
     end
 
     def process_with_test(*args)
-      process(*args).tap { set_test_assigns }
+      process_without_test(*args).tap { set_test_assigns }
     end
 
     private
@@ -574,7 +280,7 @@ module ActionController #:nodoc:
         (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
+          @template.assigns[name] = value if response
         end
       end
   end
diff --git a/actionpack/lib/action_controller/testing/process2.rb b/actionpack/lib/action_controller/testing/process2.rb
new file mode 100644
index 0000000000..1c6fd2d80a
--- /dev/null
+++ b/actionpack/lib/action_controller/testing/process2.rb
@@ -0,0 +1,74 @@
+require "action_controller/testing/process"
+
+module ActionController
+  module TestProcess
+    
+    # Executes a request simulating GET HTTP method and set/volley the response
+    def get(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "GET")
+    end
+
+    # Executes a request simulating POST HTTP method and set/volley the response
+    def post(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "POST")
+    end
+
+    # Executes a request simulating PUT HTTP method and set/volley the response
+    def put(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "PUT")
+    end
+
+    # Executes a request simulating DELETE HTTP method and set/volley the response
+    def delete(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "DELETE")
+    end
+
+    # Executes a request simulating HEAD HTTP method and set/volley the response
+    def head(action, parameters = nil, session = nil, flash = nil)
+      process(action, parameters, session, flash, "HEAD")
+    end
+
+    def process(action, parameters = nil, session = nil, flash = nil, http_method = 'GET')
+      # Sanity check for required instance variables so we can give an
+      # understandable error message.
+      %w(@controller @request @response).each do |iv_name|
+        if !(instance_variable_names.include?(iv_name) || instance_variable_names.include?(iv_name.to_sym)) || instance_variable_get(iv_name).nil?
+          raise "#{iv_name} is nil: make sure you set it in your test's setup method."
+        end
+      end
+
+      @request.recycle!
+      @response.recycle!
+      @controller.response_body = nil
+      @controller.formats = nil
+      @controller.params = nil
+
+      @html_document = nil
+      @request.env['REQUEST_METHOD'] = http_method
+
+      parameters ||= {}
+      @request.assign_parameters(@controller.class.controller_path, action.to_s, parameters)
+
+      @request.session = ActionController::TestSession.new(session) unless session.nil?
+      @request.session["flash"] = ActionController::Flash::FlashHash.new.update(flash) if flash
+
+      @controller.request = @request
+      @controller.params.merge!(parameters)
+      build_request_uri(action, parameters)
+      # Base.class_eval { include ProcessWithTest } unless Base < ProcessWithTest
+      @controller.process_with_new_base_test(@request, @response)
+      @response
+    end
+    
+    def build_request_uri(action, parameters)
+      unless @request.env['REQUEST_URI']
+        options = @controller.__send__(:rewrite_options, parameters)
+        options.update(:only_path => true, :action => action)
+
+        url = ActionController::UrlRewriter.new(@request, parameters)
+        @request.request_uri = url.rewrite(options)
+      end
+    end      
+      
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_controller/testing/test_case.rb b/actionpack/lib/action_controller/testing/test_case.rb
index b020b755a0..7b4eda58e5 100644
--- a/actionpack/lib/action_controller/testing/test_case.rb
+++ b/actionpack/lib/action_controller/testing/test_case.rb
@@ -105,20 +105,7 @@ module ActionController
   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")
-      end
-
-      def clean_backtrace(&block)
-        yield
-      rescue ActiveSupport::TestCase::Assertion => error
-        framework_path = Regexp.new(File.expand_path("#{File.dirname(__FILE__)}/assertions"))
-        error.backtrace.reject! { |line| File.expand_path(line) =~ framework_path }
-        raise
-      end
-    end
-    include Assertions
+    include ActionDispatch::Assertions
 
     # When the request.remote_addr remains the default for testing, which is 0.0.0.0, the exception is simply raised inline
     # (bystepping the regular exception handling from rescue_action). If the request.remote_addr is anything else, the regular
diff --git a/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb b/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
index ae20f9947c..a992f7d912 100644
--- a/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
+++ b/actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
@@ -73,7 +73,7 @@ module HTML
     
     # Specifies the default Set of tags that the #sanitize helper will allow unscathed.
     self.allowed_tags           = Set.new(%w(strong em b i p code pre tt samp kbd var sub 
-      sup dfn cite big small address hr br div span h1 h2 h3 h4 h5 h6 ul ol li dt dd abbr 
+      sup dfn cite big small address hr br div span h1 h2 h3 h4 h5 h6 ul ol li dl dt dd abbr 
       acronym a img blockquote del ins))
 
     # Specifies the default Set of html attributes that the #sanitize helper will leave 
diff --git a/actionpack/lib/action_dispatch.rb b/actionpack/lib/action_dispatch.rb
index bd5a38cc82..884828a01a 100644
--- a/actionpack/lib/action_dispatch.rb
+++ b/actionpack/lib/action_dispatch.rb
@@ -21,35 +21,36 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'active_support'
-rescue LoadError
-  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
-  if File.directory?(activesupport_path)
-    $:.unshift activesupport_path
-    require 'active_support'
-  end
-end
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
 
-$:.unshift "#{File.dirname(__FILE__)}/action_dispatch/vendor/rack-1.0"
 begin
-  gem 'rack', '~> 1.0.0'
-  require 'rack'
-rescue Gem::LoadError
-  require 'action_dispatch/vendor/rack-1.0/rack'
+  gem 'rack', '~> 1.1.pre'
+rescue Gem::LoadError, ArgumentError
+  $:.unshift "#{File.dirname(__FILE__)}/action_dispatch/vendor/rack-1.1.pre"
 end
 
+require 'rack'
+
+$:.unshift "#{File.dirname(__FILE__)}/action_dispatch/vendor/rack-test"
+
 module ActionDispatch
   autoload :Request, 'action_dispatch/http/request'
   autoload :Response, 'action_dispatch/http/response'
   autoload :StatusCodes, 'action_dispatch/http/status_codes'
 
-  autoload :Failsafe, 'action_dispatch/middleware/failsafe'
+  autoload :Callbacks, 'action_dispatch/middleware/callbacks'
   autoload :ParamsParser, 'action_dispatch/middleware/params_parser'
-  autoload :Reloader, 'action_dispatch/middleware/reloader'
-  autoload :RewindableInput, 'action_dispatch/middleware/rewindable_input'
+  autoload :Rescue, 'action_dispatch/middleware/rescue'
+  autoload :ShowExceptions, 'action_dispatch/middleware/show_exceptions'
   autoload :MiddlewareStack, 'action_dispatch/middleware/stack'
 
+  autoload :HTML, 'action_controller/vendor/html-scanner'
+  autoload :Assertions, 'action_dispatch/testing/assertions'
+  autoload :TestRequest, 'action_dispatch/testing/test_request'
+  autoload :TestResponse, 'action_dispatch/testing/test_response'
+
   module Http
     autoload :Headers, 'action_dispatch/http/headers'
   end
diff --git a/actionpack/lib/action_dispatch/http/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index 02ad7f7d94..25156a4c75 100644
--- a/actionpack/lib/action_dispatch/http/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -1,8 +1,9 @@
 require 'set'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module Mime
   SET              = []
-  EXTENSION_LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
+  EXTENSION_LOOKUP = {}
   LOOKUP           = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
 
   def self.[](type)
diff --git a/actionpack/lib/action_dispatch/http/mime_types.rb b/actionpack/lib/action_dispatch/http/mime_types.rb
index 2d7fba1173..7c28cac419 100644
--- a/actionpack/lib/action_dispatch/http/mime_types.rb
+++ b/actionpack/lib/action_dispatch/http/mime_types.rb
@@ -1,9 +1,9 @@
 # Build list of Mime types for HTTP responses
 # http://www.iana.org/assignments/media-types/
 
+Mime::Type.register "text/html", :html, %w( application/xhtml+xml ), %w( xhtml )
 Mime::Type.register "*/*", :all
 Mime::Type.register "text/plain", :text, [], %w(txt)
-Mime::Type.register "text/html", :html, %w( application/xhtml+xml ), %w( xhtml )
 Mime::Type.register "text/javascript", :js, %w( application/javascript application/x-javascript )
 Mime::Type.register "text/css", :css
 Mime::Type.register "text/calendar", :ics
diff --git a/actionpack/lib/action_dispatch/http/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index 523ab32b35..140feb9a68 100755
--- a/actionpack/lib/action_dispatch/http/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -3,6 +3,9 @@ require 'stringio'
 require 'strscan'
 
 require 'active_support/memoizable'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/tap'
 
 module ActionDispatch
   class Request < Rack::Request
@@ -31,7 +34,7 @@ module ActionDispatch
     # <tt>:get</tt>. If the request \method is not listed in the HTTP_METHODS
     # constant above, an UnknownHttpMethod exception is raised.
     def request_method
-      @request_method ||= HTTP_METHOD_LOOKUP[super] || raise(ActionController::UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
+      HTTP_METHOD_LOOKUP[super] || raise(ActionController::UnknownHttpMethod, "#{super}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
     end
 
     # Returns the HTTP request \method used for action processing as a
@@ -85,7 +88,7 @@ module ActionDispatch
     # For backward compatibility, the post \format is extracted from the
     # X-Post-Data-Format HTTP header if present.
     def content_type
-      @content_type ||= begin
+      @env["action_dispatch.request.content_type"] ||= begin
         if @env['CONTENT_TYPE'] =~ /^([^,\;]*)/
           Mime::Type.lookup($1.strip.downcase)
         else
@@ -93,10 +96,14 @@ module ActionDispatch
         end
       end
     end
-    
+
+    def media_type
+      content_type.to_s
+    end
+
     # Returns the accepted MIME type for the request.
     def accepts
-      @accepts ||= begin
+      @env["action_dispatch.request.accepts"] ||= begin
         header = @env['HTTP_ACCEPT'].to_s.strip
 
         fallback = xhr? ? Mime::JS : Mime::HTML
@@ -156,7 +163,7 @@ module ActionDispatch
     #   GET /posts/5       | request.format => Mime::HTML or MIME::JS, or request.accepts.first depending on the value of <tt>ActionController::Base.use_accept_header</tt>
 
     def format(view_path = [])
-      @format ||=
+      @env["action_dispatch.request.format"] ||=
         if parameters[:format]
                         Mime[parameters[:format]]
         elsif ActionController::Base.use_accept_header && !(accepts == ONLY_ALL)
@@ -167,12 +174,23 @@ module ActionDispatch
     end
 
     def formats
-      @formats = 
-        if ActionController::Base.use_accept_header
-          Array(Mime[parameters[:format]] || accepts)
+      if ActionController::Base.use_accept_header
+        if param = parameters[:format]
+          Array.wrap(Mime[param])
         else
-          [format]
+          accepts.dup
+        end.tap do |ret|
+          if defined?(ActionController::Http)
+            if ret == ONLY_ALL
+              ret.replace Mime::SET
+            elsif all = ret.index(Mime::ALL)
+              ret.delete_at(all) && ret.insert(all, *Mime::SET)
+            end
+          end
         end
+      else
+        [format] + Mime::SET
+      end
     end
 
     # Sets the \format by string extension, which can be used to force custom formats
@@ -188,7 +206,7 @@ module ActionDispatch
     #   end
     def format=(extension)
       parameters[:format] = extension.to_s
-      @format = Mime::Type.lookup_by_extension(parameters[:format])
+      @env["action_dispatch.request.format"] = Mime::Type.lookup_by_extension(parameters[:format])
     end
 
     # Returns a symbolized version of the <tt>:format</tt> parameter of the request.
@@ -324,6 +342,10 @@ EOM
       port == standard_port ? '' : ":#{port}"
     end
 
+    def server_port
+      @env['SERVER_PORT'].to_i
+    end
+
     # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
     # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
     def domain(tld_length = 1)
@@ -344,7 +366,7 @@ EOM
 
     # Returns the query string, accounting for server idiosyncrasies.
     def query_string
-      @env['QUERY_STRING'].present? ? @env['QUERY_STRING'] : (@env['REQUEST_URI'].split('?', 2)[1] || '')
+      @env['QUERY_STRING'].present? ? @env['QUERY_STRING'] : (@env['REQUEST_URI'].to_s.split('?', 2)[1] || '')
     end
 
     # Returns the request URI, accounting for server idiosyncrasies.
@@ -392,18 +414,19 @@ EOM
 
     # Returns both GET and POST \parameters in a single hash.
     def parameters
-      @parameters ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
+      @env["action_dispatch.request.parameters"] ||= request_parameters.merge(query_parameters).update(path_parameters).with_indifferent_access
     end
     alias_method :params, :parameters
 
     def path_parameters=(parameters) #:nodoc:
-      @env["rack.routing_args"] = parameters
-      @symbolized_path_parameters = @parameters = nil
+      @env.delete("action_dispatch.request.symbolized_path_parameters")
+      @env.delete("action_dispatch.request.parameters")
+      @env["action_dispatch.request.path_parameters"] = parameters
     end
 
     # The same as <tt>path_parameters</tt> with explicitly symbolized keys.
     def symbolized_path_parameters
-      @symbolized_path_parameters ||= path_parameters.symbolize_keys
+      @env["action_dispatch.request.symbolized_path_parameters"] ||= path_parameters.symbolize_keys
     end
 
     # Returns a hash with the \parameters used to form the \path of the request.
@@ -413,7 +436,7 @@ EOM
     #
     # See <tt>symbolized_path_parameters</tt> for symbolized keys.
     def path_parameters
-      @env["rack.routing_args"] ||= {}
+      @env["action_dispatch.request.path_parameters"] ||= {}
     end
 
     # The request body is an IO input stream. If the RAW_POST_DATA environment
@@ -433,13 +456,13 @@ EOM
 
     # Override Rack's GET method to support indifferent access
     def GET
-      @env["action_controller.request.query_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.query_parameters"] ||= normalize_parameters(super)
     end
     alias_method :query_parameters, :GET
 
     # Override Rack's POST method to support indifferent access
     def POST
-      @env["action_controller.request.request_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.request_parameters"] ||= normalize_parameters(super)
     end
     alias_method :request_parameters, :POST
 
@@ -447,29 +470,21 @@ EOM
       @env['rack.input']
     end
 
-    def session
-      @env['rack.session'] ||= {}
+    def reset_session
+      self.session_options.delete(:id)
+      self.session = {}
     end
 
     def session=(session) #:nodoc:
       @env['rack.session'] = session
     end
 
-    def reset_session
-      @env['rack.session.options'].delete(:id)
-      @env['rack.session'] = {}
-    end
-
-    def session_options
-      @env['rack.session.options'] ||= {}
-    end
-
     def session_options=(options)
       @env['rack.session.options'] = options
     end
 
-    def server_port
-      @env['SERVER_PORT'].to_i
+    def flash
+      session['flash'] || {}
     end
 
     private
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index ecf40b8103..b9db7a4508 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -1,4 +1,5 @@
 require 'digest/md5'
+require 'active_support/core_ext/module/delegation'
 
 module ActionDispatch # :nodoc:
   # Represents an HTTP response generated by a controller action. One can use
@@ -34,17 +35,31 @@ module ActionDispatch # :nodoc:
     DEFAULT_HEADERS = { "Cache-Control" => "no-cache" }
     attr_accessor :request
 
-    attr_accessor :session, :assigns, :template, :layout
-    attr_accessor :redirected_to, :redirected_to_method_params
+    attr_writer :header
+    alias_method :headers=, :header=
 
     delegate :default_charset, :to => 'ActionController::Base'
 
     def initialize
       super
       @header = Rack::Utils::HeaderHash.new(DEFAULT_HEADERS)
-      @session, @assigns = [], []
     end
 
+    # The response code of the request
+    def response_code
+      status.to_s[0,3].to_i rescue 0
+    end
+
+    # Returns a String to ensure compatibility with Net::HTTPResponse
+    def code
+      status.to_s.split(' ')[0]
+    end
+
+    def message
+      status.to_s.split(' ',2)[1] || StatusCodes::STATUS_CODES[response_code]
+    end
+    alias_method :status_message, :message
+
     def body
       str = ''
       each { |part| str << part.to_s }
@@ -53,7 +68,7 @@ module ActionDispatch # :nodoc:
 
     def body=(body)
       @body =
-        if body.is_a?(String)
+        if body.respond_to?(:to_str)
           [body]
         else
           body
@@ -64,9 +79,14 @@ module ActionDispatch # :nodoc:
       @body
     end
 
-    def location; headers['Location'] end
-    def location=(url) headers['Location'] = url end
+    def location
+      headers['Location']
+    end
+    alias_method :redirect_url, :location
 
+    def location=(url)
+      headers['Location'] = url
+    end
 
     # Sets the HTTP response's content MIME type. For example, in the controller
     # you could write this:
@@ -137,19 +157,20 @@ module ActionDispatch # :nodoc:
       end
     end
 
-    def redirect(url, status)
-      self.status = status
-      self.location = url.gsub(/[\r\n]/, '')
-      self.body = "<html><body>You are being <a href=\"#{CGI.escapeHTML(url)}\">redirected</a>.</body></html>"
-    end
-
     def sending_file?
       headers["Content-Transfer-Encoding"] == "binary"
     end
 
     def assign_default_content_type_and_charset!
-      self.content_type ||= Mime::HTML
-      self.charset ||= default_charset unless sending_file?
+      if type = headers['Content-Type'] || headers['type']
+        unless type =~ /charset=/ || sending_file?
+          headers['Content-Type'] = "#{type}; charset=#{default_charset}"
+        end
+      else
+        type = Mime::HTML.to_s
+        type += "; charset=#{default_charset}" unless sending_file?
+        headers['Content-Type'] = type
+      end
     end
 
     def prepare!
@@ -165,10 +186,8 @@ module ActionDispatch # :nodoc:
       if @body.respond_to?(:call)
         @writer = lambda { |x| callback.call(x) }
         @body.call(self, self)
-      elsif @body.is_a?(String)
-        callback.call(@body)
       else
-        @body.each(&callback)
+        @body.each { |part| callback.call(part.to_s) }
       end
 
       @writer = callback
@@ -192,6 +211,23 @@ module ActionDispatch # :nodoc:
       super(key, value)
     end
 
+    # Returns the response cookies, converted to a Hash of (name => value) pairs
+    #
+    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
+    def cookies
+      cookies = {}
+      if header = headers['Set-Cookie']
+        header = header.split("\n") if header.respond_to?(:to_str)
+        header.each do |cookie|
+          if pair = cookie.split(';').first
+            key, value = pair.split("=").map { |v| Rack::Utils.unescape(v) }
+            cookies[key] = value
+          end
+        end
+      end
+      cookies
+    end
+
     private
       def handle_conditional_get!
         if etag? || last_modified?
@@ -245,7 +281,13 @@ module ActionDispatch # :nodoc:
       end
 
       def convert_cookies!
-        headers['Set-Cookie'] = Array(headers['Set-Cookie']).compact
+        headers['Set-Cookie'] =
+          if header = headers['Set-Cookie']
+            header = header.split("\n") if header.respond_to?(:to_str)
+            header.compact
+          else
+            []
+          end
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/http/status_codes.rb b/actionpack/lib/action_dispatch/http/status_codes.rb
index 830de2a6db..5bac842ec1 100644
--- a/actionpack/lib/action_dispatch/http/status_codes.rb
+++ b/actionpack/lib/action_dispatch/http/status_codes.rb
@@ -1,3 +1,5 @@
+require 'active_support/inflector'
+
 module ActionDispatch
   module StatusCodes #:nodoc:
     STATUS_CODES = Rack::Utils::HTTP_STATUS_CODES.merge({
@@ -16,7 +18,7 @@ module ActionDispatch
     # :created or :not_implemented) into its corresponding HTTP status
     # code (like 200 or 501).
     SYMBOL_TO_STATUS_CODE = STATUS_CODES.inject({}) { |hash, (code, message)|
-      hash[message.gsub(/ /, "").underscore.to_sym] = code
+      hash[ActiveSupport::Inflector.underscore(message.gsub(/ /, "")).to_sym] = code
       hash
     }.freeze
 
@@ -37,4 +39,4 @@ module ActionDispatch
         end
       end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/middleware/callbacks.rb b/actionpack/lib/action_dispatch/middleware/callbacks.rb
new file mode 100644
index 0000000000..0a2b4cf5f7
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/callbacks.rb
@@ -0,0 +1,40 @@
+module ActionDispatch
+  class Callbacks
+    include ActiveSupport::Callbacks
+    define_callbacks :prepare, :before, :after
+
+    class << self
+      # DEPRECATED
+      alias_method :prepare_dispatch, :prepare
+      alias_method :before_dispatch, :before
+      alias_method :after_dispatch, :after
+    end
+
+    # Add a preparation callback. Preparation callbacks are run before every
+    # request in development mode, and before the first request in production
+    # mode.
+    #
+    # An optional identifier may be supplied for the callback. If provided,
+    # to_prepare may be called again with the same identifier to replace the
+    # existing callback. Passing an identifier is a suggested practice if the
+    # code adding a preparation block may be reloaded.
+    def self.to_prepare(identifier = nil, &block)
+      @prepare_callbacks ||= ActiveSupport::Callbacks::CallbackChain.new
+      callback = ActiveSupport::Callbacks::Callback.new(:prepare, block, :identifier => identifier)
+      @prepare_callbacks.replace_or_append!(callback)
+    end
+
+    def initialize(app, prepare_each_request = false)
+      @app, @prepare_each_request = app, prepare_each_request
+      run_callbacks :prepare
+    end
+
+    def call(env)
+      run_callbacks :before
+      run_callbacks :prepare if @prepare_each_request
+      @app.call(env)
+    ensure
+      run_callbacks :after, :enumerator => :reverse_each
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/failsafe.rb b/actionpack/lib/action_dispatch/middleware/failsafe.rb
deleted file mode 100644
index 7379a696aa..0000000000
--- a/actionpack/lib/action_dispatch/middleware/failsafe.rb
+++ /dev/null
@@ -1,52 +0,0 @@
-module ActionDispatch
-  class Failsafe
-    cattr_accessor :error_file_path
-    self.error_file_path = Rails.public_path if defined?(Rails.public_path)
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => exception
-      # Reraise exception in test environment
-      if env["rack.test"]
-        raise exception
-      else
-        failsafe_response(exception)
-      end
-    end
-
-    private
-      def failsafe_response(exception)
-        log_failsafe_exception(exception)
-        [500, {'Content-Type' => 'text/html'}, failsafe_response_body]
-      rescue Exception => failsafe_error # Logger or IO errors
-        $stderr.puts "Error during failsafe response: #{failsafe_error}"
-      end
-
-      def failsafe_response_body
-        error_path = "#{self.class.error_file_path}/500.html"
-        if File.exist?(error_path)
-          File.read(error_path)
-        else
-          "<html><body><h1>500 Internal Server Error</h1></body></html>"
-        end
-      end
-
-      def log_failsafe_exception(exception)
-        message = "/!\\ FAILSAFE /!\\  #{Time.now}\n  Status: 500 Internal Server Error\n"
-        message << "  #{exception}\n    #{exception.backtrace.join("\n    ")}" if exception
-        failsafe_logger.fatal(message)
-      end
-
-      def failsafe_logger
-        if defined?(Rails) && Rails.logger
-          Rails.logger
-        else
-          Logger.new($stderr)
-        end
-      end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/params_parser.rb b/actionpack/lib/action_dispatch/middleware/params_parser.rb
index 6df572268c..e83cf9236b 100644
--- a/actionpack/lib/action_dispatch/middleware/params_parser.rb
+++ b/actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -1,3 +1,5 @@
+require 'active_support/json'
+
 module ActionDispatch
   class ParamsParser
     ActionController::Base.param_parsers[Mime::XML] = :xml_simple
@@ -9,7 +11,7 @@ module ActionDispatch
 
     def call(env)
       if params = parse_formatted_parameters(env)
-        env["action_controller.request.request_parameters"] = params
+        env["action_dispatch.request.request_parameters"] = params
       end
 
       @app.call(env)
@@ -30,16 +32,14 @@ module ActionDispatch
           when Proc
             strategy.call(request.raw_post)
           when :xml_simple, :xml_node
-            body = request.raw_post
-            body.blank? ? {} : Hash.from_xml(body).with_indifferent_access
+            request.body.size == 0 ? {} : Hash.from_xml(request.body).with_indifferent_access
           when :yaml
-            YAML.load(request.raw_post)
+            YAML.load(request.body)
           when :json
-            body = request.raw_post
-            if body.blank?
+            if request.body.size == 0
               {}
             else
-              data = ActiveSupport::JSON.decode(body)
+              data = ActiveSupport::JSON.decode(request.body)
               data = {:_json => data} unless data.is_a?(Hash)
               data.with_indifferent_access
             end
diff --git a/actionpack/lib/action_dispatch/middleware/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
deleted file mode 100644
index 67313e30e4..0000000000
--- a/actionpack/lib/action_dispatch/middleware/reloader.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-module ActionDispatch
-  class Reloader
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      ActionController::Dispatcher.reload_application
-      @app.call(env)
-    ensure
-      ActionController::Dispatcher.cleanup_application
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/rescue.rb b/actionpack/lib/action_dispatch/middleware/rescue.rb
new file mode 100644
index 0000000000..1456825526
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/rescue.rb
@@ -0,0 +1,14 @@
+module ActionDispatch
+  class Rescue
+    def initialize(app, rescuer)
+      @app, @rescuer = app, rescuer
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      env['action_dispatch.rescue.exception'] = exception
+      @rescuer.call(env)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/rewindable_input.rb b/actionpack/lib/action_dispatch/middleware/rewindable_input.rb
deleted file mode 100644
index c818f28cce..0000000000
--- a/actionpack/lib/action_dispatch/middleware/rewindable_input.rb
+++ /dev/null
@@ -1,19 +0,0 @@
-module ActionDispatch
-  class RewindableInput
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      begin
-        env['rack.input'].rewind
-      rescue NoMethodError, Errno::ESPIPE
-        # Handles exceptions raised by input streams that cannot be rewound
-        # such as when using plain CGI under Apache
-        env['rack.input'] = StringIO.new(env['rack.input'].read)
-      end
-
-      @app.call(env)
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
index 6c039cf62d..6d109f4624 100644
--- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -15,6 +15,7 @@ module ActionDispatch
           @by = by
           @env = env
           @loaded = false
+          @updated = false
         end
 
         def session_id
@@ -26,12 +27,13 @@ module ActionDispatch
 
         def [](key)
           load! unless @loaded
-          super
+          super(key.to_s)
         end
 
         def []=(key, value)
           load! unless @loaded
-          super
+          super(key.to_s, value)
+          @updated = true
         end
 
         def to_hash
@@ -40,6 +42,24 @@ module ActionDispatch
           h
         end
 
+        def update(hash = nil)
+          if hash.nil?
+            ActiveSupport::Deprecation.warn('use replace instead', caller)
+            replace({})
+          else
+            super(hash.stringify_keys)
+          end
+        end
+
+        def delete(key = nil)
+          if key.nil?
+            ActiveSupport::Deprecation.warn('use clear instead', caller)
+            clear
+          else
+            super(key.to_s)
+          end
+        end
+
         def data
          ActiveSupport::Deprecation.warn(
            "ActionController::Session::AbstractStore::SessionHash#data " +
@@ -47,6 +67,10 @@ module ActionDispatch
           to_hash
         end
 
+        def close
+          ActiveSupport::Deprecation.warn('sessions should no longer be closed', caller)
+        end
+
         def inspect
           load! unless @loaded
           super
@@ -57,11 +81,15 @@ module ActionDispatch
             @loaded
           end
 
+          def updated?
+            @updated
+          end
+
           def load!
             stale_session_check! do
               id, session = @by.send(:load_session, @env)
               (@env[ENV_SESSION_OPTIONS_KEY] ||= {})[:id] = id
-              replace(session)
+              replace(session.stringify_keys)
               @loaded = true
             end
           end
@@ -74,7 +102,7 @@ module ActionDispatch
                 # Note that the regexp does not allow $1 to end with a ':'
                 $1.constantize
               rescue LoadError, NameError => const_error
-                raise ActionController::SessionRestoreError, "Session contains objects whose class definition isn\\'t available.\nRemember to require the classes for all objects kept in the session.\n(Original exception: \#{const_error.message} [\#{const_error.class}])\n"
+                raise ActionController::SessionRestoreError, "Session contains objects whose class definition isn't available.\nRemember to require the classes for all objects kept in the session.\n(Original exception: #{const_error.message} [#{const_error.class}])\n"
               end
 
               retry
@@ -125,7 +153,10 @@ module ActionDispatch
         options = env[ENV_SESSION_OPTIONS_KEY]
 
         if !session_data.is_a?(AbstractStore::SessionHash) || session_data.send(:loaded?) || options[:expire_after]
-          session_data.send(:load!) if session_data.is_a?(AbstractStore::SessionHash) && !session_data.send(:loaded?)
+          if session_data.is_a?(AbstractStore::SessionHash)
+            session_data.send(:load!) if !session_data.send(:loaded?)
+            return response if !session_data.send(:updated?)
+          end
 
           sid = options[:id] || generate_sid
 
diff --git a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
index 433c4cc070..547a2d2062 100644
--- a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
@@ -143,7 +143,8 @@ module ActionDispatch
           request = Rack::Request.new(env)
           session_data = request.cookies[@key]
           data = unmarshal(session_data) || persistent_session_id!({})
-          [data[:session_id], data]
+          data.stringify_keys!
+          [data["session_id"], data]
         end
 
         # Marshal a session hash into safe cookie data. Include an integrity hash.
@@ -206,12 +207,12 @@ module ActionDispatch
         end
 
         def inject_persistent_session_id(data)
-          requires_session_id?(data) ? { :session_id => generate_sid } : {}
+          requires_session_id?(data) ? { "session_id" => generate_sid } : {}
         end
 
         def requires_session_id?(data)
           if data
-            data.respond_to?(:key?) && !data.key?(:session_id)
+            data.respond_to?(:key?) && !data.key?("session_id")
           else
             true
           end
diff --git a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
new file mode 100644
index 0000000000..bfff307669
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -0,0 +1,141 @@
+module ActionDispatch
+  class ShowExceptions
+    include StatusCodes
+
+    LOCALHOST = '127.0.0.1'.freeze
+
+    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
+
+    cattr_accessor :rescue_responses
+    @@rescue_responses = Hash.new(:internal_server_error)
+    @@rescue_responses.update({
+      'ActionController::RoutingError'             => :not_found,
+      # TODO: Clean this up after the switch
+      ActionController::UnknownAction.name         => :not_found,
+      'ActiveRecord::RecordNotFound'               => :not_found,
+      'ActiveRecord::StaleObjectError'             => :conflict,
+      'ActiveRecord::RecordInvalid'                => :unprocessable_entity,
+      'ActiveRecord::RecordNotSaved'               => :unprocessable_entity,
+      'ActionController::MethodNotAllowed'         => :method_not_allowed,
+      'ActionController::NotImplemented'           => :not_implemented,
+      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
+    })
+
+    cattr_accessor :rescue_templates
+    @@rescue_templates = Hash.new('diagnostics')
+    @@rescue_templates.update({
+      'ActionView::MissingTemplate'         => 'missing_template',
+      'ActionController::RoutingError'      => 'routing_error',
+      ActionController::UnknownAction.name  => 'unknown_action',
+      'ActionView::TemplateError'           => 'template_error'
+    })
+
+    FAILSAFE_RESPONSE = [500, {'Content-Type' => 'text/html'},
+      ["<html><body><h1>500 Internal Server Error</h1>" <<
+       "If you are the administrator of this website, then please read this web " <<
+       "application's log file and/or the web server's log file to find out what " <<
+       "went wrong.</body></html>"]]
+
+    def initialize(app, consider_all_requests_local = false)
+      @app = app
+      @consider_all_requests_local = consider_all_requests_local
+    end
+
+    def call(env)
+      @app.call(env)
+    rescue Exception => exception
+      raise exception if env['action_dispatch.show_exceptions'] == false
+      render_exception(env, exception)
+    end
+
+    private
+      def render_exception(env, exception)
+        log_error(exception)
+
+        request = Request.new(env)
+        if @consider_all_requests_local || local_request?(request)
+          rescue_action_locally(request, exception)
+        else
+          rescue_action_in_public(exception)
+        end
+      rescue Exception => failsafe_error
+        $stderr.puts "Error during failsafe response: #{failsafe_error}"
+        FAILSAFE_RESPONSE
+      end
+
+      # Render detailed diagnostics for unhandled exceptions rescued from
+      # a controller action.
+      def rescue_action_locally(request, exception)
+        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
+          :request => request,
+          :exception => exception
+        )
+        file = "rescues/#{@@rescue_templates[exception.class.name]}.erb"
+        body = template.render(:file => file, :layout => 'rescues/layout.erb')
+        render(status_code(exception), body)
+      end
+
+      # Attempts to render a static error page based on the
+      # <tt>status_code</tt> thrown, or just return headers if no such file
+      # exists. At first, it will try to render a localized static page.
+      # For example, if a 500 error is being handled Rails and locale is :da,
+      # it will first attempt to render the file at <tt>public/500.da.html</tt>
+      # then attempt to render <tt>public/500.html</tt>. If none of them exist,
+      # the body of the response will be left empty.
+      def rescue_action_in_public(exception)
+        status = status_code(exception)
+        locale_path = "#{public_path}/#{status}.#{I18n.locale}.html" if I18n.locale
+        path = "#{public_path}/#{status}.html"
+
+        if locale_path && File.exist?(locale_path)
+          render(status, File.read(locale_path))
+        elsif File.exist?(path)
+          render(status, File.read(path))
+        else
+          render(status, '')
+        end
+      end
+
+      # True if the request came from localhost, 127.0.0.1.
+      def local_request?(request)
+        request.remote_addr == LOCALHOST && request.remote_ip == LOCALHOST
+      end
+
+      def status_code(exception)
+        interpret_status(@@rescue_responses[exception.class.name]).to_i
+      end
+
+      def render(status, body)
+        [status, {'Content-Type' => 'text/html', 'Content-Length' => body.length.to_s}, [body]]
+      end
+
+      def public_path
+        defined?(Rails.public_path) ? Rails.public_path : 'public_path'
+      end
+
+      def log_error(exception)
+        return unless logger
+
+        ActiveSupport::Deprecation.silence do
+          if ActionView::TemplateError === exception
+            logger.fatal(exception.to_s)
+          else
+            logger.fatal(
+              "\n#{exception.class} (#{exception.message}):\n  " +
+              clean_backtrace(exception).join("\n  ") + "\n\n"
+            )
+          end
+        end
+      end
+
+      def clean_backtrace(exception)
+        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
+          Rails.backtrace_cleaner.clean(exception.backtrace) :
+          exception.backtrace
+      end
+
+      def logger
+        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/stack.rb b/actionpack/lib/action_dispatch/middleware/stack.rb
index ee5f28d5cb..ade2d6f05e 100644
--- a/actionpack/lib/action_dispatch/middleware/stack.rb
+++ b/actionpack/lib/action_dispatch/middleware/stack.rb
@@ -34,8 +34,6 @@ module ActionDispatch
         else
           @klass.to_s.constantize
         end
-      rescue NameError
-        @klass
       end
 
       def active?
@@ -61,7 +59,7 @@ module ActionDispatch
 
       def inspect
         str = klass.to_s
-        args.each { |arg| str += ", #{arg.inspect}" }
+        args.each { |arg| str += ", #{build_args.inspect}" }
         str
       end
 
@@ -74,7 +72,6 @@ module ActionDispatch
       end
 
       private
-
         def build_args
           Array(args).map { |arg| arg.respond_to?(:call) ? arg.call : arg }
         end
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
index 64b34650b1..5224403dab 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/_request_and_response.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
@@ -6,7 +6,7 @@
 <% end %>
 
 <%
-  clean_params = request.parameters.clone
+  clean_params = @request.parameters.clone
   clean_params.delete("action")
   clean_params.delete("controller")
 
@@ -17,8 +17,8 @@
 <p><b>Parameters</b>: <pre><%=h request_dump %></pre></p>
 
 <p><a href="#" onclick="document.getElementById('session_dump').style.display='block'; return false;">Show session dump</a></p>
-<div id="session_dump" style="display:none"><%= debug(request.session.instance_variable_get("@data")) %></div>
+<div id="session_dump" style="display:none"><%= debug(@request.session.instance_variable_get("@data")) %></div>
 
 
 <h2 style="margin-top: 30px">Response</h2>
-<p><b>Headers</b>: <pre><%=h response ? response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>
+<p><b>Headers</b>: <pre><%=h @response ? @response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
index bb2d8375bd..bb2d8375bd 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/_trace.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
new file mode 100644
index 0000000000..693e56270a
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
@@ -0,0 +1,10 @@
+<h1>
+  <%=h @exception.class.to_s %>
+  <% if @request.parameters['controller'] %>
+    in <%=h @request.parameters['controller'].humanize %>Controller<% if @request.parameters['action'] %>#<%=h @request.parameters['action'] %><% end %>
+  <% end %>
+</h1>
+<pre><%=h @exception.clean_message %></pre>
+
+<%= render :file => "rescues/_trace.erb" %>
+<%= render :file => "rescues/_request_and_response.erb" %>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
index 4a04742e40..6c32fb17b8 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/layout.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
@@ -23,7 +23,7 @@
 </head>
 <body>
 
-<%= @contents %>
+<%= yield %>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.erb
index dbfdf76947..dbfdf76947 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/missing_template.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/missing_template.erb
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
index ccfa858cce..ccfa858cce 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/routing_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
index 2e34e03bd5..02fa18211d 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/template_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
@@ -1,6 +1,6 @@
 <h1>
   <%=h @exception.original_exception.class.to_s %> in
-  <%=h request.parameters["controller"].capitalize if request.parameters["controller"]%>#<%=h request.parameters["action"] %>
+  <%=h @request.parameters["controller"].capitalize if @request.parameters["controller"]%>#<%=h @request.parameters["action"] %>
 </h1>
 
 <p>
@@ -15,7 +15,7 @@
 
 <% @real_exception = @exception
    @exception = @exception.original_exception || @exception %>
-<%= render :file => @rescues_path["rescues/_trace.erb"] %>
+<%= render :file => "rescues/_trace.erb" %>
 <% @exception = @real_exception %>
 
-<%= render :file => @rescues_path["rescues/_request_and_response.erb"] %>
+<%= render :file => "rescues/_request_and_response.erb" %>
diff --git a/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.erb
index 683379da10..683379da10 100644
--- a/actionpack/lib/action_controller/dispatch/templates/rescues/unknown_action.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/unknown_action.erb
diff --git a/actionpack/lib/action_dispatch/testing/assertions.rb b/actionpack/lib/action_dispatch/testing/assertions.rb
new file mode 100644
index 0000000000..96f08f2355
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/assertions.rb
@@ -0,0 +1,8 @@
+module ActionDispatch
+  module Assertions
+    %w(response selector tag dom routing model).each do |kind|
+      require "action_dispatch/testing/assertions/#{kind}"
+      include const_get("#{kind.camelize}Assertions")
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/testing/assertions/dom.rb b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
index 5ffe5f1883..9a917f704a 100644
--- a/actionpack/lib/action_controller/testing/assertions/dom.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     module DomAssertions
       # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
@@ -9,13 +9,11 @@ module ActionController
       #   assert_dom_equal '<a href="http://www.example.com">Apples</a>', link_to("Apples", "http://www.example.com")
       #
       def assert_dom_equal(expected, actual, message = "")
-        clean_backtrace do
-          expected_dom = HTML::Document.new(expected).root
-          actual_dom   = HTML::Document.new(actual).root
-          full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be == to\n<?>.", expected_dom.to_s, actual_dom.to_s)
 
-          assert_block(full_message) { expected_dom == actual_dom }
-        end
+        assert_block(full_message) { expected_dom == actual_dom }
       end
       
       # The negated form of +assert_dom_equivalent+.
@@ -26,13 +24,11 @@ module ActionController
       #   assert_dom_not_equal '<a href="http://www.example.com">Apples</a>', link_to("Oranges", "http://www.example.com")
       #
       def assert_dom_not_equal(expected, actual, message = "")
-        clean_backtrace do
-          expected_dom = HTML::Document.new(expected).root
-          actual_dom   = HTML::Document.new(actual).root
-          full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
+        expected_dom = HTML::Document.new(expected).root
+        actual_dom   = HTML::Document.new(actual).root
+        full_message = build_message(message, "<?> expected to be != to\n<?>.", expected_dom.to_s, actual_dom.to_s)
 
-          assert_block(full_message) { expected_dom != actual_dom }
-        end
+        assert_block(full_message) { expected_dom != actual_dom }
       end
     end
   end
diff --git a/actionpack/lib/action_controller/testing/assertions/model.rb b/actionpack/lib/action_dispatch/testing/assertions/model.rb
index 3a7b39b106..46714418c6 100644
--- a/actionpack/lib/action_controller/testing/assertions/model.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/model.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     module ModelAssertions
       # Ensures that the passed record is valid by Active Record standards and
@@ -12,9 +12,7 @@ module ActionController
       #
       def assert_valid(record)
         ::ActiveSupport::Deprecation.warn("assert_valid is deprecated. Use assert record.valid? instead", caller)
-        clean_backtrace do
-          assert record.valid?, record.errors.full_messages.join("\n")
-        end
+        assert record.valid?, record.errors.full_messages.join("\n")
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/assertions/response.rb b/actionpack/lib/action_dispatch/testing/assertions/response.rb
new file mode 100644
index 0000000000..501a7c4dfb
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/assertions/response.rb
@@ -0,0 +1,145 @@
+module ActionDispatch
+  module Assertions
+    # A small suite of assertions that test responses from Rails applications.
+    module ResponseAssertions
+      # Asserts that the response is one of the following types:
+      #
+      # * <tt>:success</tt>   - Status code was 200
+      # * <tt>:redirect</tt>  - Status code was in the 300-399 range
+      # * <tt>:missing</tt>   - Status code was 404
+      # * <tt>:error</tt>     - Status code was in the 500-599 range
+      #
+      # You can also pass an explicit status number like assert_response(501)
+      # or its symbolic equivalent assert_response(:not_implemented).
+      # See ActionDispatch::StatusCodes for a full list.
+      #
+      # ==== Examples
+      #
+      #   # assert that the response was a redirection
+      #   assert_response :redirect
+      #
+      #   # assert that the response code was status code 401 (unauthorized)
+      #   assert_response 401
+      #
+      def assert_response(type, message = nil)
+        validate_request!
+
+        if [ :success, :missing, :redirect, :error ].include?(type) && @response.send("#{type}?")
+          assert_block("") { true } # to count the assertion
+        elsif type.is_a?(Fixnum) && @response.response_code == type
+          assert_block("") { true } # to count the assertion
+        elsif type.is_a?(Symbol) && @response.response_code == ActionDispatch::StatusCodes::SYMBOL_TO_STATUS_CODE[type]
+          assert_block("") { true } # to count the assertion
+        else
+          assert_block(build_message(message, "Expected response to be a <?>, but was <?>", type, @response.response_code)) { false }
+        end
+      end
+
+      # Assert that the redirection options passed in match those of the redirect called in the latest action.
+      # This match can be partial, such that assert_redirected_to(:controller => "weblog") will also
+      # match the redirection of redirect_to(:controller => "weblog", :action => "show") and so on.
+      #
+      # ==== Examples
+      #
+      #   # assert that the redirection was to the "index" action on the WeblogController
+      #   assert_redirected_to :controller => "weblog", :action => "index"
+      #
+      #   # assert that the redirection was to the named route login_url
+      #   assert_redirected_to login_url
+      #
+      #   # assert that the redirection was to the url for @customer
+      #   assert_redirected_to @customer
+      #
+      def assert_redirected_to(options = {}, message=nil)
+        validate_request!
+
+        assert_response(:redirect, message)
+        return true if options == @response.location
+
+        redirected_to_after_normalisation = normalize_argument_to_redirection(@response.location)
+        options_after_normalisation       = normalize_argument_to_redirection(options)
+
+        if redirected_to_after_normalisation != options_after_normalisation
+          flunk "Expected response to be a redirect to <#{options_after_normalisation}> but was a redirect to <#{redirected_to_after_normalisation}>"
+        end
+      end
+
+      # Asserts that the request was rendered with the appropriate template file or partials
+      #
+      # ==== Examples
+      #
+      #   # assert that the "new" view template was rendered
+      #   assert_template "new"
+      #
+      #   # assert that the "_customer" partial was rendered twice
+      #   assert_template :partial => '_customer', :count => 2
+      #
+      #   # assert that no partials were rendered
+      #   assert_template :partial => false
+      #
+      def assert_template(options = {}, message = nil)
+        validate_request!
+
+        case options
+         when NilClass, String
+          rendered = (@controller.template.rendered[:template] || []).map { |t| t.identifier }
+          msg = build_message(message,
+                  "expecting <?> but rendering with <?>",
+                  options, rendered.join(', '))
+          assert_block(msg) do
+            if options.nil?
+              @controller.template.rendered[:template].blank?
+            else
+              rendered.any? { |t| t.match(options) }
+            end
+          end
+        when Hash
+          if expected_partial = options[:partial]
+            partials = @controller.template.rendered[:partials]
+            if expected_count = options[:count]
+              found = partials.detect { |p, _| p.identifier.match(expected_partial) }
+              actual_count = found.nil? ? 0 : found.second
+              msg = build_message(message,
+                      "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+                       expected_partial, expected_count, actual_count)
+              assert(actual_count == expected_count.to_i, msg)
+            else
+              msg = build_message(message,
+                      "expecting partial <?> but action rendered <?>",
+                      options[:partial], partials.keys)
+              assert(partials.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
+            end
+          else
+            assert @controller.template.rendered[:partials].empty?,
+              "Expected no partials to be rendered"
+          end
+        end
+      end
+
+      private
+        # Proxy to to_param if the object will respond to it.
+        def parameterize(value)
+          value.respond_to?(:to_param) ? value.to_param : value
+        end
+
+        def normalize_argument_to_redirection(fragment)
+          after_routing = @controller.url_for(fragment)
+          if after_routing =~ %r{^\w+://.*}
+            after_routing
+          else
+            # FIXME - this should probably get removed.
+            if after_routing.first != '/'
+              after_routing = '/' + after_routing
+            end
+            @request.protocol + @request.host_with_port + after_routing
+          end
+        end
+
+        def validate_request!
+          unless @request.is_a?(ActionDispatch::Request)
+            raise ArgumentError, "@request must be an ActionDispatch::Request"
+          end
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_controller/testing/assertions/routing.rb b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
index 5101751cea..89d1a49403 100644
--- a/actionpack/lib/action_controller/testing/assertions/routing.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     # Suite of assertions to test routes generated by Rails and the handling of requests made to them.
     module RoutingAssertions
@@ -44,19 +44,17 @@ module ActionController
           request_method = nil
         end
 
-        clean_backtrace do
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
-          request = recognized_request_for(path, request_method)
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        request = recognized_request_for(path, request_method)
 
-          expected_options = expected_options.clone
-          extras.each_key { |key| expected_options.delete key } unless extras.nil?
+        expected_options = expected_options.clone
+        extras.each_key { |key| expected_options.delete key } unless extras.nil?
 
-          expected_options.stringify_keys!
-          routing_diff = expected_options.diff(request.path_parameters)
-          msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
-              request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
-          assert_block(msg) { request.path_parameters == expected_options }
-        end
+        expected_options.stringify_keys!
+        routing_diff = expected_options.diff(request.path_parameters)
+        msg = build_message(message, "The recognized options <?> did not match <?>, difference: <?>",
+            request.path_parameters, expected_options, expected_options.diff(request.path_parameters))
+        assert_block(msg) { request.path_parameters == expected_options }
       end
 
       # Asserts that the provided options can be used to generate the provided path.  This is the inverse of +assert_recognizes+.
@@ -78,21 +76,19 @@ module ActionController
       #   # Asserts that the generated route gives us our custom route
       #   assert_generates "changesets/12", { :controller => 'scm', :action => 'show_diff', :revision => "12" }
       def assert_generates(expected_path, options, defaults={}, extras = {}, message=nil)
-        clean_backtrace do
-          expected_path = "/#{expected_path}" unless expected_path[0] == ?/
-          # Load routes.rb if it hasn't been loaded.
-          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+        expected_path = "/#{expected_path}" unless expected_path[0] == ?/
+        # Load routes.rb if it hasn't been loaded.
+        ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
 
-          generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
-          found_extras = options.reject {|k, v| ! extra_keys.include? k}
+        generated_path, extra_keys = ActionController::Routing::Routes.generate_extras(options, defaults)
+        found_extras = options.reject {|k, v| ! extra_keys.include? k}
 
-          msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
-          assert_block(msg) { found_extras == extras }
+        msg = build_message(message, "found extras <?>, not <?>", found_extras, extras)
+        assert_block(msg) { found_extras == extras }
 
-          msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
-              expected_path)
-          assert_block(msg) { expected_path == generated_path }
-        end
+        msg = build_message(message, "The generated path <?> did not match <?>", generated_path,
+            expected_path)
+        assert_block(msg) { expected_path == generated_path }
       end
 
       # Asserts that path and options match both ways; in other words, it verifies that <tt>path</tt> generates
diff --git a/actionpack/lib/action_controller/testing/assertions/selector.rb b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
index 0d56ea5ef7..dd75cda6b9 100644
--- a/actionpack/lib/action_controller/testing/assertions/selector.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
@@ -3,7 +3,7 @@
 # Under MIT and/or CC By license.
 #++
 
-module ActionController
+module ActionDispatch
   module Assertions
     unless const_defined?(:NO_STRIP)
       NO_STRIP = %w{pre script style textarea}
diff --git a/actionpack/lib/action_controller/testing/assertions/tag.rb b/actionpack/lib/action_dispatch/testing/assertions/tag.rb
index 80249e0e83..ef6867576e 100644
--- a/actionpack/lib/action_controller/testing/assertions/tag.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/tag.rb
@@ -1,4 +1,4 @@
-module ActionController
+module ActionDispatch
   module Assertions
     # Pair of assertions to testing elements in the HTML output of the response.
     module TagAssertions
@@ -94,11 +94,9 @@ module ActionController
       # that allow optional closing tags (p, li, td). <em>You must explicitly
       # close all of your tags to use these assertions.</em>
       def assert_tag(*opts)
-        clean_backtrace do
-          opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-          tag = find_tag(opts)
-          assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
-        end
+        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
+        tag = find_tag(opts)
+        assert tag, "expected tag, but no tag found matching #{opts.inspect} in:\n#{@response.body.inspect}"
       end
       
       # Identical to +assert_tag+, but asserts that a matching tag does _not_
@@ -116,11 +114,9 @@ module ActionController
       #   assert_no_tag :tag => "p",
       #              :children => { :count => 1..3, :only => { :tag => "img" } }
       def assert_no_tag(*opts)
-        clean_backtrace do
-          opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
-          tag = find_tag(opts)
-          assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
-        end
+        opts = opts.size > 1 ? opts.last.merge({ :tag => opts.first.to_s }) : opts.first
+        tag = find_tag(opts)
+        assert !tag, "expected no tag, but found tag matching #{opts.inspect} in:\n#{@response.body.inspect}"
       end
     end
   end
diff --git a/actionpack/lib/action_dispatch/testing/test_request.rb b/actionpack/lib/action_dispatch/testing/test_request.rb
new file mode 100644
index 0000000000..20288aa7a5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/test_request.rb
@@ -0,0 +1,83 @@
+module ActionDispatch
+  class TestRequest < Request
+    DEFAULT_ENV = Rack::MockRequest.env_for('/')
+
+    def self.new(env = {})
+      super
+    end
+
+    def initialize(env = {})
+      super(DEFAULT_ENV.merge(env))
+
+      self.host        = 'test.host'
+      self.remote_addr = '0.0.0.0'
+      self.user_agent  = 'Rails Testing'
+    end
+
+    def env
+      write_cookies!
+      delete_nil_values!
+      super
+    end
+
+    def request_method=(method)
+      @env['REQUEST_METHOD'] = method.to_s.upcase
+    end
+
+    def host=(host)
+      @env['HTTP_HOST'] = host
+    end
+
+    def port=(number)
+      @env['SERVER_PORT'] = number.to_i
+    end
+
+    def request_uri=(uri)
+      @env['REQUEST_URI'] = uri
+    end
+
+    def path=(path)
+      @env['PATH_INFO'] = path
+    end
+
+    def action=(action_name)
+      path_parameters["action"] = action_name.to_s
+    end
+
+    def if_modified_since=(last_modified)
+      @env['HTTP_IF_MODIFIED_SINCE'] = last_modified
+    end
+
+    def if_none_match=(etag)
+      @env['HTTP_IF_NONE_MATCH'] = etag
+    end
+
+    def remote_addr=(addr)
+      @env['REMOTE_ADDR'] = addr
+    end
+
+    def user_agent=(user_agent)
+      @env['HTTP_USER_AGENT'] = user_agent
+    end
+
+    def accept=(mime_types)
+      @env.delete('action_dispatch.request.accepts')
+      @env['HTTP_ACCEPT'] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
+    end
+
+    def cookies
+      @cookies ||= super
+    end
+
+    private
+      def write_cookies!
+        unless @cookies.blank?
+          @env['HTTP_COOKIE'] = @cookies.map { |name, value| "#{name}=#{value};" }.join(' ')
+        end
+      end
+
+      def delete_nil_values!
+        @env.delete_if { |k, v| v.nil? }
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/testing/test_response.rb b/actionpack/lib/action_dispatch/testing/test_response.rb
new file mode 100644
index 0000000000..c35982e075
--- /dev/null
+++ b/actionpack/lib/action_dispatch/testing/test_response.rb
@@ -0,0 +1,131 @@
+module ActionDispatch
+  # Integration test methods such as ActionController::Integration::Session#get
+  # and ActionController::Integration::Session#post return objects of class
+  # TestResponse, which represent the HTTP response results of the requested
+  # controller actions.
+  #
+  # See Response for more information on controller response objects.
+  class TestResponse < Response
+    def self.from_response(response)
+      new.tap do |resp|
+        resp.status  = response.status
+        resp.headers = response.headers
+        resp.body    = response.body
+      end
+    end
+
+    module DeprecatedHelpers
+      def template
+        ActiveSupport::Deprecation.warn("response.template has been deprecated. Use controller.template instead", caller)
+        @template
+      end
+      attr_writer :template
+
+      def session
+        ActiveSupport::Deprecation.warn("response.session has been deprecated. Use request.session instead", caller)
+        @request.session
+      end
+
+      def assigns
+        ActiveSupport::Deprecation.warn("response.assigns has been deprecated. Use controller.assigns instead", caller)
+        @template.controller.assigns
+      end
+
+      def layout
+        ActiveSupport::Deprecation.warn("response.layout has been deprecated. Use template.layout instead", caller)
+        @template.layout
+      end
+
+      def redirect_url_match?(pattern)
+        ::ActiveSupport::Deprecation.warn("response.redirect_url_match? is deprecated. Use assert_match(/foo/, response.redirect_url) instead", caller)
+        return false if redirect_url.nil?
+        p = Regexp.new(pattern) if pattern.class == String
+        p = pattern if pattern.class == Regexp
+        return false if p.nil?
+        p.match(redirect_url) != nil
+      end
+
+      # Returns the template of the file which was used to
+      # render this response (or nil)
+      def rendered
+        ActiveSupport::Deprecation.warn("response.rendered has been deprecated. Use tempate.rendered instead", caller)
+        @template.instance_variable_get(:@_rendered)
+      end
+
+      # A shortcut to the flash. Returns an empty hash if no session flash exists.
+      def flash
+        ActiveSupport::Deprecation.warn("response.flash has been deprecated. Use request.flash instead", caller)
+        request.session['flash'] || {}
+      end
+
+      # Do we have a flash?
+      def has_flash?
+        ActiveSupport::Deprecation.warn("response.has_flash? has been deprecated. Use flash.any? instead", caller)
+        !flash.empty?
+      end
+
+      # Do we have a flash that has contents?
+      def has_flash_with_contents?
+        ActiveSupport::Deprecation.warn("response.has_flash_with_contents? has been deprecated. Use flash.any? instead", caller)
+        !flash.empty?
+      end
+
+      # Does the specified flash object exist?
+      def has_flash_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_flash_object? has been deprecated. Use flash[name] instead", caller)
+        !flash[name].nil?
+      end
+
+      # Does the specified object exist in the session?
+      def has_session_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_session_object? has been deprecated. Use session[name] instead", caller)
+        !session[name].nil?
+      end
+
+      # A shortcut to the template.assigns
+      def template_objects
+        ActiveSupport::Deprecation.warn("response.template_objects has been deprecated. Use tempate.assigns instead", caller)
+        @template.assigns || {}
+      end
+
+      # Does the specified template object exist?
+      def has_template_object?(name=nil)
+        ActiveSupport::Deprecation.warn("response.has_template_object? has been deprecated. Use tempate.assigns[name].nil? instead", caller)
+        !template_objects[name].nil?
+      end
+
+      # Returns binary content (downloadable file), converted to a String
+      def binary_content
+        ActiveSupport::Deprecation.warn("response.binary_content has been deprecated. Use response.body instead", caller)
+        body
+      end
+    end
+    include DeprecatedHelpers
+
+    # Was the response successful?
+    def success?
+      (200..299).include?(response_code)
+    end
+
+    # Was the URL not found?
+    def missing?
+      response_code == 404
+    end
+
+    # Were we redirected?
+    def redirect?
+      (300..399).include?(response_code)
+    end
+
+    # Was there a server-side error?
+    def error?
+      (500..599).include?(response_code)
+    end
+    alias_method :server_error?, :error?
+
+    # Was there a client client?
+    def client_error?
+      (400..499).include?(response_code)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/reloader.rb b/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/reloader.rb
deleted file mode 100644
index b17d8c0926..0000000000
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/reloader.rb
+++ /dev/null
@@ -1,64 +0,0 @@
-require 'thread'
-
-module Rack
-  # Rack::Reloader checks on every request, but at most every +secs+
-  # seconds, if a file loaded changed, and reloads it, logging to
-  # rack.errors.
-  #
-  # It is recommended you use ShowExceptions to catch SyntaxErrors etc.
-
-  class Reloader
-    def initialize(app, secs=10)
-      @app = app
-      @secs = secs              # reload every @secs seconds max
-      @last = Time.now
-    end
-
-    def call(env)
-      if Time.now > @last + @secs
-        Thread.exclusive {
-          reload!(env['rack.errors'])
-          @last = Time.now
-        }
-      end
-
-      @app.call(env)
-    end
-
-    def reload!(stderr=$stderr)
-      need_reload = $LOADED_FEATURES.find_all { |loaded|
-        begin
-          if loaded =~ /\A[.\/]/  # absolute filename or 1.9
-            abs = loaded
-          else
-            abs = $LOAD_PATH.map { |path| ::File.join(path, loaded) }.
-                             find { |file| ::File.exist? file }
-          end
-
-          if abs
-            ::File.mtime(abs) > @last - @secs  rescue false
-          else
-            false
-          end
-        end
-      }
-
-      need_reload.each { |l|
-        $LOADED_FEATURES.delete l
-      }
-
-      need_reload.each { |to_load|
-        begin
-          if require to_load
-            stderr.puts "#{self.class}: reloaded `#{to_load}'"
-          end
-        rescue LoadError, SyntaxError => e
-          raise e                 # Possibly ShowExceptions
-        end
-      }
-
-      stderr.flush
-      need_reload
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack.rb
index 6349b95094..371d015690 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack.rb
@@ -3,7 +3,8 @@
 # Rack is freely distributable under the terms of an MIT-style license.
 # See COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-$:.unshift(File.expand_path(File.dirname(__FILE__)))
+path = File.expand_path(File.dirname(__FILE__))
+$:.unshift(path) unless $:.include?(path)
 
 
 # The Rack main module, serving as a namespace for all core Rack
@@ -14,7 +15,7 @@ $:.unshift(File.expand_path(File.dirname(__FILE__)))
 
 module Rack
   # The Rack protocol version number implemented.
-  VERSION = [0,1]
+  VERSION = [1,0]
 
   # Return the Rack protocol version as a dotted string.
   def self.version
@@ -23,7 +24,7 @@ module Rack
 
   # Return the Rack release as a dotted string.
   def self.release
-    "1.0 bundled"
+    "1.0"
   end
 
   autoload :Builder, "rack/builder"
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/adapter/camping.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/adapter/camping.rb
index 63bc787f54..63bc787f54 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/adapter/camping.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/adapter/camping.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/handler.rb
index 214df6299e..214df6299e 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/handler.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/handler.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/request.rb
index 1d9ccec685..1d9ccec685 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/abstract/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/abstract/request.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/basic.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/basic.rb
index 9557224648..9557224648 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/basic.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/basic.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/md5.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/md5.rb
index e579dc9632..e579dc9632 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/md5.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/md5.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/nonce.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/nonce.rb
index dbe109f29a..dbe109f29a 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/nonce.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/nonce.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/params.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/params.rb
index 730e2efdc8..730e2efdc8 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/params.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/params.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/request.rb
index a8aa3bf996..a8aa3bf996 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/digest/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/digest/request.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/openid.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/openid.rb
index c5f6a5143e..c5f6a5143e 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/auth/openid.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/auth/openid.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/builder.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/builder.rb
index 295235e56a..295235e56a 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/builder.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/builder.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/cascade.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/cascade.rb
index a038aa1105..a038aa1105 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/cascade.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/cascade.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/chunked.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/chunked.rb
index 280d89dd65..280d89dd65 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/chunked.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/chunked.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/commonlogger.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/commonlogger.rb
index 5e68ac626d..5e68ac626d 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/commonlogger.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/commonlogger.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/conditionalget.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/conditionalget.rb
index 7bec824181..046ebdb00a 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/conditionalget.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/conditionalget.rb
@@ -26,6 +26,8 @@ module Rack
       headers = Utils::HeaderHash.new(headers)
       if etag_matches?(env, headers) || modified_since?(env, headers)
         status = 304
+        headers.delete('Content-Type')
+        headers.delete('Content-Length')
         body = []
       end
       [status, headers, body]
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_length.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_length.rb
index 1e56d43853..1e56d43853 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_length.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_length.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_type.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_type.rb
index 0c1e1ca3e1..0c1e1ca3e1 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/content_type.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/content_type.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/deflater.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/deflater.rb
index a42b7477ae..14137a944d 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/deflater.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/deflater.rb
@@ -33,17 +33,15 @@ module Rack
 
       case encoding
       when "gzip"
+        headers['Content-Encoding'] = "gzip"
+        headers.delete('Content-Length')
         mtime = headers.key?("Last-Modified") ?
           Time.httpdate(headers["Last-Modified"]) : Time.now
-        body = self.class.gzip(body, mtime)
-        size = Rack::Utils.bytesize(body)
-        headers = headers.merge("Content-Encoding" => "gzip", "Content-Length" => size.to_s)
-        [status, headers, [body]]
+        [status, headers, GzipStream.new(body, mtime)]
       when "deflate"
-        body = self.class.deflate(body)
-        size = Rack::Utils.bytesize(body)
-        headers = headers.merge("Content-Encoding" => "deflate", "Content-Length" => size.to_s)
-        [status, headers, [body]]
+        headers['Content-Encoding'] = "deflate"
+        headers.delete('Content-Length')
+        [status, headers, DeflateStream.new(body)]
       when "identity"
         [status, headers, body]
       when nil
@@ -52,34 +50,47 @@ module Rack
       end
     end
 
-    def self.gzip(body, mtime)
-      io = StringIO.new
-      gzip = Zlib::GzipWriter.new(io)
-      gzip.mtime = mtime
+    class GzipStream
+      def initialize(body, mtime)
+        @body = body
+        @mtime = mtime
+      end
 
-      # TODO: Add streaming
-      body.each { |part| gzip << part }
+      def each(&block)
+        @writer = block
+        gzip  =::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime
+        @body.each { |part| gzip << part }
+        @body.close if @body.respond_to?(:close)
+        gzip.close
+        @writer = nil
+      end
 
-      gzip.close
-      return io.string
+      def write(data)
+        @writer.call(data)
+      end
     end
 
-    DEFLATE_ARGS = [
-      Zlib::DEFAULT_COMPRESSION,
-      # drop the zlib header which causes both Safari and IE to choke
-     -Zlib::MAX_WBITS,
-      Zlib::DEF_MEM_LEVEL,
-      Zlib::DEFAULT_STRATEGY
-    ]
+    class DeflateStream
+      DEFLATE_ARGS = [
+        Zlib::DEFAULT_COMPRESSION,
+        # drop the zlib header which causes both Safari and IE to choke
+        -Zlib::MAX_WBITS,
+        Zlib::DEF_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      ]
 
-    # Loosely based on Mongrel's Deflate handler
-    def self.deflate(body)
-      deflater = Zlib::Deflate.new(*DEFLATE_ARGS)
-
-      # TODO: Add streaming
-      body.each { |part| deflater << part }
+      def initialize(body)
+        @body = body
+      end
 
-      return deflater.finish
+      def each
+        deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
+        @body.each { |part| yield deflater.deflate(part) }
+        @body.close if @body.respond_to?(:close)
+        yield deflater.finish
+        nil
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/directory.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/directory.rb
index acdd3029d3..acdd3029d3 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/directory.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/directory.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/file.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/file.rb
index fe62bd6b86..fe62bd6b86 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/file.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/file.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler.rb
index 1018af64c7..5624a1e79d 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler.rb
@@ -10,16 +10,37 @@ module Rack
   module Handler
     def self.get(server)
       return unless server
+      server = server.to_s
 
       if klass = @handlers[server]
         obj = Object
         klass.split("::").each { |x| obj = obj.const_get(x) }
         obj
       else
-        Rack::Handler.const_get(server.capitalize)
+        try_require('rack/handler', server)
+        const_get(server)
       end
     end
 
+    # Transforms server-name constants to their canonical form as filenames,
+    # then tries to require them but silences the LoadError if not found
+    #
+    # Naming convention:
+    #
+    #   Foo # => 'foo'
+    #   FooBar # => 'foo_bar.rb'
+    #   FooBAR # => 'foobar.rb'
+    #   FOObar # => 'foobar.rb'
+    #   FOOBAR # => 'foobar.rb'
+    #   FooBarBaz # => 'foo_bar_baz.rb'
+    def self.try_require(prefix, const_name)
+      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
+        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
+
+      require(::File.join(prefix, file))
+    rescue LoadError
+    end
+
     def self.register(server, klass)
       @handlers ||= {}
       @handlers[server] = klass
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/cgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/cgi.rb
index e38156c7f0..f45f3d735a 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/cgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/cgi.rb
@@ -15,7 +15,7 @@ module Rack
 
         env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
 
-        env.update({"rack.version" => [0,1],
+        env.update({"rack.version" => [1,0],
                      "rack.input" => $stdin,
                      "rack.errors" => $stderr,
 
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/evented_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/evented_mongrel.rb
index 0f5cbf7293..0f5cbf7293 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/evented_mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/evented_mongrel.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/fastcgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/fastcgi.rb
index 6324c7d274..11e1fcaa74 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/fastcgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/fastcgi.rb
@@ -1,6 +1,17 @@
 require 'fcgi'
 require 'socket'
 require 'rack/content_length'
+require 'rack/rewindable_input'
+
+class FCGI::Stream
+  alias _rack_read_without_buffer read
+
+  def read(n, buffer=nil)
+    buf = _rack_read_without_buffer n
+    buffer.replace(buf.to_s)  if buffer
+    buf
+  end
+end
 
 module Rack
   module Handler
@@ -13,34 +24,18 @@ module Rack
         }
       end
 
-      module ProperStream       # :nodoc:
-        def each                # This is missing by default.
-          while line = gets
-            yield line
-          end
-        end
-
-        def read(*args)
-          if args.empty?
-            super || ""           # Empty string on EOF.
-          else
-            super
-          end
-        end
-      end
-
       def self.serve(request, app)
         app = Rack::ContentLength.new(app)
 
         env = request.env
         env.delete "HTTP_CONTENT_LENGTH"
 
-        request.in.extend ProperStream
-
         env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
+        
+        rack_input = RewindableInput.new(request.in)
 
-        env.update({"rack.version" => [0,1],
-                     "rack.input" => request.in,
+        env.update({"rack.version" => [1,0],
+                     "rack.input" => rack_input,
                      "rack.errors" => request.err,
 
                      "rack.multithread" => false,
@@ -57,12 +52,16 @@ module Rack
         env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
         env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
 
-        status, headers, body = app.call(env)
         begin
-          send_headers request.out, status, headers
-          send_body request.out, body
+          status, headers, body = app.call(env)
+          begin
+            send_headers request.out, status, headers
+            send_body request.out, body
+          ensure
+            body.close  if body.respond_to? :close
+          end
         ensure
-          body.close  if body.respond_to? :close
+          rack_input.close
           request.finish
         end
       end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/lsws.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/lsws.rb
index c65ba3ec8e..7231336d7b 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/lsws.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/lsws.rb
@@ -15,7 +15,7 @@ module Rack
         env = ENV.to_hash
         env.delete "HTTP_CONTENT_LENGTH"
         env["SCRIPT_NAME"] = "" if env["SCRIPT_NAME"] == "/"
-        env.update({"rack.version" => [0,1],
+        env.update({"rack.version" => [1,0],
                      "rack.input" => StringIO.new($stdin.read.to_s),
                      "rack.errors" => $stderr,
                      "rack.multithread" => false,
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/mongrel.rb
index f0c0d58330..3a5ef32d4b 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/mongrel.rb
@@ -45,7 +45,7 @@ module Rack
 
         env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
 
-        env.update({"rack.version" => [0,1],
+        env.update({"rack.version" => [1,0],
                      "rack.input" => request.body || StringIO.new(""),
                      "rack.errors" => $stderr,
 
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/scgi.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/scgi.rb
index 9495c66374..6c4932df95 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/scgi.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/scgi.rb
@@ -32,7 +32,7 @@ module Rack
         env["PATH_INFO"] = env["REQUEST_PATH"]
         env["QUERY_STRING"] ||= ""
         env["SCRIPT_NAME"] = ""
-        env.update({"rack.version" => [0,1],
+        env.update({"rack.version" => [1,0],
                      "rack.input" => StringIO.new(input_body),
                      "rack.errors" => $stderr,
 
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/swiftiplied_mongrel.rb
index 4bafd0b953..4bafd0b953 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/swiftiplied_mongrel.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/swiftiplied_mongrel.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/thin.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/thin.rb
index 3d4fedff75..3d4fedff75 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/thin.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/thin.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/webrick.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/webrick.rb
index 829e7d6bf8..2bdc83a9ff 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/handler/webrick.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/handler/webrick.rb
@@ -22,7 +22,7 @@ module Rack
         env = req.meta_vars
         env.delete_if { |k, v| v.nil? }
 
-        env.update({"rack.version" => [0,1],
+        env.update({"rack.version" => [1,0],
                      "rack.input" => StringIO.new(req.body.to_s),
                      "rack.errors" => $stderr,
 
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/head.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/head.rb
index deab822a99..deab822a99 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/head.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/head.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lint.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lint.rb
index 44a33ce36e..bf2e9787a1 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lint.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lint.rb
@@ -88,9 +88,9 @@ module Rack
       ##                      within the application. This may be an
       ##                      empty string, if the request URL targets
       ##                      the application root and does not have a
-      ##                      trailing slash. This information should be
-      ##                      decoded by the server if it comes from a
-      ##                      URL.
+      ##                      trailing slash. This value may be
+      ##                      percent-encoded when I originating from
+      ##                      a URL.
 
       ## <tt>QUERY_STRING</tt>:: The portion of the request URL that
       ##                         follows the <tt>?</tt>, if any. May be
@@ -111,19 +111,48 @@ module Rack
       ## In addition to this, the Rack environment must include these
       ## Rack-specific variables:
 
-      ## <tt>rack.version</tt>:: The Array [0,1], representing this version of Rack.
+      ## <tt>rack.version</tt>:: The Array [1,0], representing this version of Rack.
       ## <tt>rack.url_scheme</tt>:: +http+ or +https+, depending on the request URL.
       ## <tt>rack.input</tt>:: See below, the input stream.
       ## <tt>rack.errors</tt>:: See below, the error stream.
       ## <tt>rack.multithread</tt>:: true if the application object may be simultaneously invoked by another thread in the same process, false otherwise.
       ## <tt>rack.multiprocess</tt>:: true if an equivalent application object may be simultaneously invoked by another process, false otherwise.
       ## <tt>rack.run_once</tt>:: true if the server expects (but does not guarantee!) that the application will only be invoked this one time during the life of its containing process. Normally, this will only be true for a server based on CGI (or something similar).
+      ##
+
+      ## Additional environment specifications have approved to
+      ## standardized middleware APIs.  None of these are required to
+      ## be implemented by the server.
+
+      ## <tt>rack.session</tt>:: A hash like interface for storing request session data.
+      ##                         The store must implement:
+      if session = env['rack.session']
+        ##                         store(key, value)         (aliased as []=);
+        assert("session #{session.inspect} must respond to store and []=") {
+          session.respond_to?(:store) && session.respond_to?(:[]=)
+        }
+
+        ##                         fetch(key, default = nil) (aliased as []);
+        assert("session #{session.inspect} must respond to fetch and []") {
+          session.respond_to?(:fetch) && session.respond_to?(:[])
+        }
+
+        ##                         delete(key);
+        assert("session #{session.inspect} must respond to delete") {
+          session.respond_to?(:delete)
+        }
+
+        ##                         clear;
+        assert("session #{session.inspect} must respond to clear") {
+          session.respond_to?(:clear)
+        }
+      end
 
       ## The server or the application can store their own data in the
       ## environment, too.  The keys must contain at least one dot,
       ## and should be prefixed uniquely.  The prefix <tt>rack.</tt>
-      ## is reserved for use with the Rack core distribution and must
-      ## not be used otherwise.
+      ## is reserved for use with the Rack core distribution and other
+      ## accepted specifications and must not be used otherwise.
       ##
 
       %w[REQUEST_METHOD SERVER_NAME SERVER_PORT
@@ -202,9 +231,12 @@ module Rack
     end
 
     ## === The Input Stream
+    ##
+    ## The input stream is an IO-like object which contains the raw HTTP
+    ## POST data. If it is a file then it must be opened in binary mode.
     def check_input(input)
-      ## The input stream must respond to +gets+, +each+ and +read+.
-      [:gets, :each, :read].each { |method|
+      ## The input stream must respond to +gets+, +each+, +read+ and +rewind+.
+      [:gets, :each, :read, :rewind].each { |method|
         assert("rack.input #{input} does not respond to ##{method}") {
           input.respond_to? method
         }
@@ -222,10 +254,6 @@ module Rack
         @input.size
       end
 
-      def rewind
-        @input.rewind
-      end
-
       ## * +gets+ must be called without arguments and return a string,
       ##   or +nil+ on EOF.
       def gets(*args)
@@ -237,21 +265,44 @@ module Rack
         v
       end
 
-      ## * +read+ must be called without or with one integer argument
-      ##   and return a string, or +nil+ on EOF.
+      ## * +read+ behaves like IO#read. Its signature is <tt>read([length, [buffer]])</tt>.
+      ##   If given, +length+ must be an non-negative Integer (>= 0) or +nil+, and +buffer+ must
+      ##   be a String and may not be nil. If +length+ is given and not nil, then this method
+      ##   reads at most +length+ bytes from the input stream. If +length+ is not given or nil,
+      ##   then this method reads all data until EOF.
+      ##   When EOF is reached, this method returns nil if +length+ is given and not nil, or ""
+      ##   if +length+ is not given or is nil.
+      ##   If +buffer+ is given, then the read data will be placed into +buffer+ instead of a
+      ##   newly created String object.
       def read(*args)
         assert("rack.input#read called with too many arguments") {
-          args.size <= 1
+          args.size <= 2
         }
-        if args.size == 1
-          assert("rack.input#read called with non-integer argument") {
-            args.first.kind_of? Integer
+        if args.size >= 1
+          assert("rack.input#read called with non-integer and non-nil length") {
+            args.first.kind_of?(Integer) || args.first.nil?
+          }
+          assert("rack.input#read called with a negative length") {
+            args.first.nil? || args.first >= 0
           }
         end
+        if args.size >= 2
+          assert("rack.input#read called with non-String buffer") {
+            args[1].kind_of?(String)
+          }
+        end
+        
         v = @input.read(*args)
-        assert("rack.input#read didn't return a String") {
+        
+        assert("rack.input#read didn't return nil or a String") {
           v.nil? or v.instance_of? String
         }
+        if args[0].nil?
+          assert("rack.input#read(nil) returned nil on EOF") {
+            !v.nil?
+          }
+        end
+        
         v
       end
 
@@ -265,6 +316,23 @@ module Rack
           yield line
         }
       end
+      
+      ## * +rewind+ must be called without arguments. It rewinds the input
+      ##   stream back to the beginning. It must not raise Errno::ESPIPE:
+      ##   that is, it may not be a pipe or a socket. Therefore, handler
+      ##   developers must buffer the input data into some rewindable object
+      ##   if the underlying input stream is not rewindable.
+      def rewind(*args)
+        assert("rack.input#rewind called with arguments") { args.size == 0 }
+        assert("rack.input#rewind raised Errno::ESPIPE") {
+          begin
+            @input.rewind
+            true
+          rescue Errno::ESPIPE
+            false
+          end
+        }
+      end
 
       ## * +close+ must never be called on the input stream.
       def close(*args)
@@ -316,13 +384,14 @@ module Rack
 
     ## === The Status
     def check_status(status)
-      ## The status, if parsed as integer (+to_i+), must be greater than or equal to 100.
+      ## This is an HTTP status. When parsed as integer (+to_i+), it must be
+      ## greater than or equal to 100.
       assert("Status must be >=100 seen as integer") { status.to_i >= 100 }
     end
 
     ## === The Headers
     def check_headers(header)
-      ## The header must respond to each, and yield values of key and value.
+      ## The header must respond to +each+, and yield values of key and value.
       assert("headers object should respond to #each, but doesn't (got #{header.class} as headers)") {
          header.respond_to? :each
       }
@@ -344,7 +413,8 @@ module Rack
         ## The values of the header must be Strings,
         assert("a header value must be a String, but the value of " +
           "'#{key}' is a #{value.class}") { value.kind_of? String }
-        ## consisting of lines (for multiple header values) seperated by "\n".
+        ## consisting of lines (for multiple header values, e.g. multiple
+        ## <tt>Set-Cookie</tt> values) seperated by "\n".
         value.split("\n").each { |item|
           ## The lines must not contain characters below 037.
           assert("invalid header value #{key}: #{item.inspect}") {
@@ -416,7 +486,7 @@ module Rack
     ## === The Body
     def each
       @closed = false
-      ## The Body must respond to #each
+      ## The Body must respond to +each+
       @body.each { |part|
         ## and must only yield String values.
         assert("Body yielded non-string value #{part.inspect}") {
@@ -425,14 +495,19 @@ module Rack
         yield part
       }
       ##
-      ## If the Body responds to #close, it will be called after iteration.
+      ## The Body itself should not be an instance of String, as this will
+      ## break in Ruby 1.9.
+      ##
+      ## If the Body responds to +close+, it will be called after iteration.
       # XXX howto: assert("Body has not been closed") { @closed }
 
 
       ##
-      ## If the Body responds to #to_path, it must return a String
+      ## If the Body responds to +to_path+, it must return a String
       ## identifying the location of a file whose contents are identical
-      ## to that produced by calling #each.
+      ## to that produced by calling +each+; this may be used by the
+      ## server as an alternative, possibly more efficient way to
+      ## transport the response.
 
       if @body.respond_to?(:to_path)
         assert("The file identified by body.to_path does not exist") {
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lobster.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lobster.rb
index f63f419a49..f63f419a49 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lobster.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lobster.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lock.rb
index 93238528c4..93238528c4 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/lock.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/lock.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/methodoverride.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/methodoverride.rb
index 0eed29f471..0eed29f471 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/methodoverride.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/methodoverride.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mime.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mime.rb
index 5a6a73a97b..5a6a73a97b 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mime.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mime.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mock.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mock.rb
index 70852da3db..fdefb0340a 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/mock.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/mock.rb
@@ -40,7 +40,7 @@ module Rack
     end
 
     DEFAULT_ENV = {
-      "rack.version" => [0,1],
+      "rack.version" => [1,0],
       "rack.input" => StringIO.new,
       "rack.errors" => StringIO.new,
       "rack.multithread" => true,
@@ -73,14 +73,17 @@ module Rack
     # Return the Rack environment used for a request to +uri+.
     def self.env_for(uri="", opts={})
       uri = URI(uri)
+      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+
       env = DEFAULT_ENV.dup
 
-      env["REQUEST_METHOD"] = opts[:method] || "GET"
+      env["REQUEST_METHOD"] = opts[:method] ? opts[:method].to_s.upcase : "GET"
       env["SERVER_NAME"] = uri.host || "example.org"
       env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
       env["QUERY_STRING"] = uri.query.to_s
       env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
       env["rack.url_scheme"] = uri.scheme || "http"
+      env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
 
       env["SCRIPT_NAME"] = opts[:script_name] || ""
 
@@ -90,6 +93,27 @@ module Rack
         env["rack.errors"] = StringIO.new
       end
 
+      if params = opts[:params]
+        if env["REQUEST_METHOD"] == "GET"
+          params = Utils.parse_nested_query(params) if params.is_a?(String)
+          params.update(Utils.parse_nested_query(env["QUERY_STRING"]))
+          env["QUERY_STRING"] = Utils.build_nested_query(params)
+        elsif !opts.has_key?(:input)
+          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          if params.is_a?(Hash)
+            if data = Utils::Multipart.build_multipart(params)
+              opts[:input] = data
+              opts["CONTENT_LENGTH"] ||= data.length.to_s
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
+            else
+              opts[:input] = Utils.build_nested_query(params)
+            end
+          else
+            opts[:input] = params
+          end
+        end
+      end
+
       opts[:input] ||= ""
       if String === opts[:input]
         env["rack.input"] = StringIO.new(opts[:input])
@@ -125,7 +149,7 @@ module Rack
       @body = ""
       body.each { |part| @body << part }
 
-      @errors = errors.string
+      @errors = errors.string if errors.respond_to?(:string)
     end
 
     # Status
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/recursive.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/recursive.rb
index bf8b965925..bf8b965925 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/recursive.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/recursive.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb
new file mode 100644
index 0000000000..aa2f060be5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/reloader.rb
@@ -0,0 +1,106 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called.
+  #
+  # It is performing a check/reload cycle at the start of every request, but
+  # also respects a cool down time, during which nothing will be done.
+  class Reloader
+    def initialize(app, cooldown = 10, backend = Stat)
+      @app = app
+      @cooldown = cooldown
+      @last = (Time.now - cooldown)
+      @cache = {}
+      @mtimes = {}
+
+      extend backend
+    end
+
+    def call(env)
+      if @cooldown and Time.now > @last + @cooldown
+        if Thread.list.size > 1
+          Thread.exclusive{ reload! }
+        else
+          reload!
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def reload!(stderr = $stderr)
+      rotation do |file, mtime|
+        previous_mtime = @mtimes[file] ||= mtime
+        safe_load(file, mtime, stderr) if mtime > previous_mtime
+      end
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime, stderr = $stderr)
+      load(file)
+      stderr.puts "#{self.class}: reloaded `#{file}'"
+      file
+    rescue LoadError, SyntaxError => ex
+      stderr.puts ex
+    ensure
+      @mtimes[file] = mtime
+    end
+
+    module Stat
+      def rotation
+        files = [$0, *$LOADED_FEATURES].uniq
+        paths = ['./', *$LOAD_PATH].uniq
+
+        files.map{|file|
+          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
+
+          found, stat = figure_path(file, paths)
+          next unless found and stat and mtime = stat.mtime
+
+          @cache[file] = found
+
+          yield(found, mtime)
+        }.compact
+      end
+
+      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
+      # the +file+ might reside in. Returns the full path and File::Stat for the
+      # path.
+      def figure_path(file, paths)
+        found = @cache[file]
+        found = file if !found and Pathname.new(file).absolute?
+        found, stat = safe_stat(found)
+        return found, stat if found
+
+        paths.each do |possible_path|
+          path = ::File.join(possible_path, file)
+          found, stat = safe_stat(path)
+          return ::File.expand_path(found), stat if found
+        end
+      end
+
+      def safe_stat(file)
+        return unless file
+        stat = ::File.stat(file)
+        return file, stat if stat.file?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        @cache.delete(file) and false
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/request.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/request.rb
index d77fa26575..0bff7af038 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/request.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/request.rb
@@ -17,7 +17,7 @@ module Rack
     # The environment of the request.
     attr_reader :env
 
-    def self.new(env)
+    def self.new(env, *args)
       if self == Rack::Request
         env["rack.request"] ||= super
       else
@@ -38,6 +38,8 @@ module Rack
     def query_string;    @env["QUERY_STRING"].to_s                end
     def content_length;  @env['CONTENT_LENGTH']                   end
     def content_type;    @env['CONTENT_TYPE']                     end
+    def session;         @env['rack.session'] ||= {}              end
+    def session_options; @env['rack.session.options'] ||= {}      end
 
     # The media type (type/subtype) portion of the CONTENT_TYPE header
     # without any media type parameters. e.g., when CONTENT_TYPE is
@@ -46,7 +48,7 @@ module Rack
     # For more information on the use of media types in HTTP, see:
     # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7
     def media_type
-      content_type && content_type.split(/\s*[;,]\s*/, 2)[0].downcase
+      content_type && content_type.split(/\s*[;,]\s*/, 2).first.downcase
     end
 
     # The media type parameters provided in CONTENT_TYPE as a Hash, or
@@ -92,6 +94,14 @@ module Rack
       'multipart/form-data'
     ]
 
+    # The set of media-types. Requests that do not indicate
+    # one of the media types presents in this list will not be eligible
+    # for param parsing like soap attachments or generic multiparts
+    PARSEABLE_DATA_MEDIA_TYPES = [
+      'multipart/related',
+      'multipart/mixed'
+    ]  
+
     # Determine whether the request body contains form-data by checking
     # the request media_type against registered form-data media-types:
     # "application/x-www-form-urlencoded" and "multipart/form-data". The
@@ -101,6 +111,12 @@ module Rack
       FORM_DATA_MEDIA_TYPES.include?(media_type)
     end
 
+    # Determine whether the request body contains data by checking
+    # the request media_type against registered parse-data media-types
+    def parseable_data?
+      PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
+    end
+
     # Returns the data recieved in the query string.
     def GET
       if @env["rack.request.query_string"] == query_string
@@ -119,7 +135,7 @@ module Rack
     def POST
       if @env["rack.request.form_input"].eql? @env["rack.input"]
         @env["rack.request.form_hash"]
-      elsif form_data?
+      elsif form_data? || parseable_data?
         @env["rack.request.form_input"] = @env["rack.input"]
         unless @env["rack.request.form_hash"] =
             Utils::Multipart.parse_multipart(env)
@@ -131,12 +147,7 @@ module Rack
           @env["rack.request.form_vars"] = form_vars
           @env["rack.request.form_hash"] = Utils.parse_nested_query(form_vars)
 
-          begin
-            @env["rack.input"].rewind if @env["rack.input"].respond_to?(:rewind)
-          rescue Errno::ESPIPE
-            # Handles exceptions raised by input streams that cannot be rewound
-            # such as when using plain CGI under Apache
-          end
+          @env["rack.input"].rewind
         end
         @env["rack.request.form_hash"]
       else
@@ -211,11 +222,13 @@ module Rack
 
       url
     end
-
+    
+    def path
+      script_name + path_info
+    end
+    
     def fullpath
-      path = script_name + path_info
-      path << "?" << query_string  unless query_string.empty?
-      path
+      query_string.empty? ? path : "#{path}?#{query_string}"
     end
 
     def accept_encoding
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/response.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/response.rb
index caf60d5b19..28b4d8302f 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/response.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/response.rb
@@ -95,6 +95,10 @@ module Rack
                    :expires => Time.at(0) }.merge(value))
     end
 
+    def redirect(target, status=302)
+      self.status = status
+      self["Location"] = target
+    end
 
     def finish(&block)
       @block = block
@@ -120,7 +124,7 @@ module Rack
     #
     def write(str)
       s = str.to_s
-      @length += s.size
+      @length += Rack::Utils.bytesize(s)
       @writer.call s
 
       header["Content-Length"] = @length.to_s
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb
new file mode 100644
index 0000000000..9e9b21ff99
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/rewindable_input.rb
@@ -0,0 +1,98 @@
+require 'tempfile'
+
+module Rack
+  # Class which can make any IO object rewindable, including non-rewindable ones. It does
+  # this by buffering the data into a tempfile, which is rewindable.
+  #
+  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
+  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
+  # to easily make it rewindable.
+  #
+  # Don't forget to call #close when you're done. This frees up temporary resources that
+  # RewindableInput uses, though it does *not* close the original IO object.
+  class RewindableInput
+    def initialize(io)
+      @io = io
+      @rewindable_io = nil
+      @unlinked = false
+    end
+    
+    def gets
+      make_rewindable unless @rewindable_io
+      @rewindable_io.gets
+    end
+    
+    def read(*args)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.read(*args)
+    end
+    
+    def each(&block)
+      make_rewindable unless @rewindable_io
+      @rewindable_io.each(&block)
+    end
+    
+    def rewind
+      make_rewindable unless @rewindable_io
+      @rewindable_io.rewind
+    end
+    
+    # Closes this RewindableInput object without closing the originally
+    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
+    # has created.
+    #
+    # This method may be called multiple times. It does nothing on subsequent calls.
+    def close
+      if @rewindable_io
+        if @unlinked
+          @rewindable_io.close
+        else
+          @rewindable_io.close!
+        end
+        @rewindable_io = nil
+      end
+    end
+    
+    private
+    
+    # Ruby's Tempfile class has a bug. Subclass it and fix it.
+    class Tempfile < ::Tempfile
+      def _close
+        @tmpfile.close if @tmpfile
+        @data[1] = nil if @data
+        @tmpfile = nil
+      end
+    end
+
+    def make_rewindable
+      # Buffer all data into a tempfile. Since this tempfile is private to this
+      # RewindableInput object, we chmod it so that nobody else can read or write
+      # it. On POSIX filesystems we also unlink the file so that it doesn't
+      # even have a file entry on the filesystem anymore, though we can still
+      # access it because we have the file handle open.
+      @rewindable_io = Tempfile.new('RackRewindableInput')
+      @rewindable_io.chmod(0000)
+      if filesystem_has_posix_semantics?
+        @rewindable_io.unlink
+        @unlinked = true
+      end
+      
+      buffer = ""
+      while @io.read(1024 * 4, buffer)
+        entire_buffer_written_out = false
+        while !entire_buffer_written_out
+          written = @rewindable_io.write(buffer)
+          entire_buffer_written_out = written == buffer.size
+          if !entire_buffer_written_out
+            buffer.slice!(0 .. written - 1)
+          end
+        end
+      end
+      @rewindable_io.rewind
+    end
+    
+    def filesystem_has_posix_semantics?
+      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/abstract/id.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/abstract/id.rb
index 218144c17f..218144c17f 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/abstract/id.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/abstract/id.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/cookie.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/cookie.rb
index eace9bd0c6..eace9bd0c6 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/cookie.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/cookie.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/memcache.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/memcache.rb
index 4a65cbf35d..4a65cbf35d 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/memcache.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/memcache.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/pool.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/pool.rb
index f6f87408bb..f6f87408bb 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/session/pool.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/session/pool.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showexceptions.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showexceptions.rb
index 697bc41fdb..697bc41fdb 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showexceptions.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showexceptions.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showstatus.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showstatus.rb
index 28258c7c89..28258c7c89 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/showstatus.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/showstatus.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/static.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/static.rb
index 168e8f83b2..168e8f83b2 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/static.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/static.rb
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/urlmap.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/urlmap.rb
index 0ff32df181..fcf6616c58 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/urlmap.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/urlmap.rb
@@ -30,7 +30,7 @@ module Rack
         location = location.chomp('/')
 
         [host, location, app]
-      }.sort_by { |(h, l, a)| [-l.size, h.to_s.size] }  # Longest path first
+      }.sort_by { |(h, l, a)| [h ? -h.size : (-1.0 / 0.0), -l.size] }  # Longest path first
     end
 
     def call(env)
diff --git a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/utils.rb
index 0a61bce707..42e2e698f4 100644
--- a/actionpack/lib/action_dispatch/vendor/rack-1.0/rack/utils.rb
+++ b/actionpack/lib/action_dispatch/vendor/rack-1.1.pre/rack/utils.rb
@@ -1,3 +1,5 @@
+# -*- encoding: binary -*-
+
 require 'set'
 require 'tempfile'
 
@@ -63,7 +65,7 @@ module Rack
     module_function :parse_nested_query
 
     def normalize_params(params, name, v = nil)
-      name =~ %r([\[\]]*([^\[\]]+)\]*)
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
       k = $1 || ''
       after = $' || ''
 
@@ -73,12 +75,12 @@ module Rack
         params[k] = v
       elsif after == "[]"
         params[k] ||= []
-        raise TypeError unless params[k].is_a?(Array)
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
         params[k] << v
       elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
         child_key = $1
         params[k] ||= []
-        raise TypeError unless params[k].is_a?(Array)
+        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
         if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
           normalize_params(params[k].last, child_key, v)
         else
@@ -86,6 +88,7 @@ module Rack
         end
       else
         params[k] ||= {}
+        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
         params[k] = normalize_params(params[k], after, v)
       end
 
@@ -104,6 +107,25 @@ module Rack
     end
     module_function :build_query
 
+    def build_nested_query(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          build_nested_query(v, "#{prefix}[]")
+        }.join("&")
+      when Hash
+        value.map { |k, v|
+          build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        }.join("&")
+      when String
+        raise ArgumentError, "value must be a Hash" if prefix.nil?
+        "#{prefix}=#{escape(value)}"
+      else
+        prefix
+      end
+    end
+    module_function :build_nested_query
+
     # Escape ampersands, brackets and quotes to their HTML/XML entities.
     def escape_html(string)
       string.to_s.gsub("&", "&amp;").
@@ -288,11 +310,39 @@ module Rack
     # Usually, Rack::Request#POST takes care of calling this.
 
     module Multipart
+      class UploadedFile
+        # The filename, *not* including the path, of the "uploaded" file
+        attr_reader :original_filename
+
+        # The content type of the "uploaded" file
+        attr_accessor :content_type
+
+        def initialize(path, content_type = "text/plain", binary = false)
+          raise "#{path} file does not exist" unless ::File.exist?(path)
+          @content_type = content_type
+          @original_filename = ::File.basename(path)
+          @tempfile = Tempfile.new(@original_filename)
+          @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+          @tempfile.binmode if binary
+          FileUtils.copy_file(path, @tempfile.path)
+        end
+
+        def path
+          @tempfile.path
+        end
+        alias_method :local_path, :path
+
+        def method_missing(method_name, *args, &block) #:nodoc:
+          @tempfile.__send__(method_name, *args, &block)
+        end
+      end
+
       EOL = "\r\n"
+      MULTIPART_BOUNDARY = "AaB03x"
 
       def self.parse_multipart(env)
         unless env['CONTENT_TYPE'] =~
-            %r|\Amultipart/form-data.*boundary=\"?([^\";,]+)\"?|n
+            %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
           nil
         else
           boundary = "--#{$1}"
@@ -301,13 +351,16 @@ module Rack
           buf = ""
           content_length = env['CONTENT_LENGTH'].to_i
           input = env['rack.input']
+          input.rewind
 
-          boundary_size = boundary.size + EOL.size
+          boundary_size = Utils.bytesize(boundary) + EOL.size
           bufsize = 16384
 
           content_length -= boundary_size
 
-          status = input.read(boundary_size)
+          read_buffer = ''
+
+          status = input.read(boundary_size, read_buffer)
           raise EOFError, "bad content body"  unless status == boundary + EOL
 
           rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/n
@@ -318,15 +371,15 @@ module Rack
             filename = content_type = name = nil
 
             until head && buf =~ rx
-              if !head && i = buf.index("\r\n\r\n")
+              if !head && i = buf.index(EOL+EOL)
                 head = buf.slice!(0, i+2) # First \r\n
                 buf.slice!(0, 2)          # Second \r\n
 
                 filename = head[/Content-Disposition:.* filename="?([^\";]*)"?/ni, 1]
-                content_type = head[/Content-Type: (.*)\r\n/ni, 1]
-                name = head[/Content-Disposition:.* name="?([^\";]*)"?/ni, 1]
+                content_type = head[/Content-Type: (.*)#{EOL}/ni, 1]
+                name = head[/Content-Disposition:.*\s+name="?([^\";]*)"?/ni, 1] || head[/Content-ID:\s*([^#{EOL}]*)/ni, 1]
 
-                if filename
+                if content_type || filename
                   body = Tempfile.new("RackMultipart")
                   body.binmode  if body.respond_to?(:binmode)
                 end
@@ -339,7 +392,7 @@ module Rack
                 body << buf.slice!(0, buf.size - (boundary_size+4))
               end
 
-              c = input.read(bufsize < content_length ? bufsize : content_length)
+              c = input.read(bufsize < content_length ? bufsize : content_length, read_buffer)
               raise EOFError, "bad content body"  if c.nil? || c.empty?
               buf << c
               content_length -= c.size
@@ -368,6 +421,12 @@ module Rack
 
               data = {:filename => filename, :type => content_type,
                       :name => name, :tempfile => body, :head => head}
+            elsif !filename && content_type
+              body.rewind
+
+              # Generic multipart cases, not coming from a form
+              data = {:type => content_type,
+                      :name => name, :tempfile => body, :head => head}
             else
               data = body
             end
@@ -377,16 +436,81 @@ module Rack
             break  if buf.empty? || content_length == -1
           }
 
-          begin
-            input.rewind if input.respond_to?(:rewind)
-          rescue Errno::ESPIPE
-            # Handles exceptions raised by input streams that cannot be rewound
-            # such as when using plain CGI under Apache
-          end
+          input.rewind
 
           params
         end
       end
+
+      def self.build_multipart(params, first = true)
+        if first
+          unless params.is_a?(Hash)
+            raise ArgumentError, "value must be a Hash"
+          end
+
+          multipart = false
+          query = lambda { |value|
+            case value
+            when Array
+              value.each(&query)
+            when Hash
+              value.values.each(&query)
+            when UploadedFile
+              multipart = true
+            end
+          }
+          params.values.each(&query)
+          return nil unless multipart
+        end
+
+        flattened_params = Hash.new
+
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+
+          case value
+          when Array
+            value.map { |v|
+              build_multipart(v, false).each { |subkey, subvalue|
+                flattened_params["#{k}[]#{subkey}"] = subvalue
+              }
+            }
+          when Hash
+            build_multipart(value, false).each { |subkey, subvalue|
+              flattened_params[k + subkey] = subvalue
+            }
+          else
+            flattened_params[k] = value
+          end
+        end
+
+        if first
+          flattened_params.map { |name, file|
+            if file.respond_to?(:original_filename)
+              ::File.open(file.path, "rb") do |f|
+                f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
+Content-Type: #{file.content_type}\r
+Content-Length: #{::File.stat(file.path).size}\r
+\r
+#{f.read}\r
+EOF
+              end
+            else
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{name}"\r
+\r
+#{file}\r
+EOF
+            end
+          }.join + "--#{MULTIPART_BOUNDARY}--\r"
+        else
+          flattened_params
+        end
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/mock_session.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/mock_session.rb
new file mode 100644
index 0000000000..eba6226538
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/mock_session.rb
@@ -0,0 +1,50 @@
+module Rack
+
+  class MockSession
+    attr_writer :cookie_jar
+    attr_reader :last_response
+
+    def initialize(app, default_host = Rack::Test::DEFAULT_HOST)
+      @app = app
+      @default_host = default_host
+    end
+
+    def clear_cookies
+      @cookie_jar = Rack::Test::CookieJar.new([], @default_host)
+    end
+
+    def set_cookie(cookie, uri = nil)
+      cookie_jar.merge(cookie, uri)
+    end
+
+    def request(uri, env)
+      env["HTTP_COOKIE"] ||= cookie_jar.for(uri)
+      @last_request = Rack::Request.new(env)
+      status, headers, body = @app.call(@last_request.env)
+      @last_response = MockResponse.new(status, headers, body, env["rack.errors"].flush)
+      cookie_jar.merge(last_response.headers["Set-Cookie"], uri)
+
+      @last_response
+    end
+
+    # Return the last request issued in the session. Raises an error if no
+    # requests have been sent yet.
+    def last_request
+      raise Rack::Test::Error.new("No request yet. Request a page first.") unless @last_request
+      @last_request
+    end
+
+    # Return the last response received in the session. Raises an error if
+    # no requests have been sent yet.
+    def last_response
+      raise Rack::Test::Error.new("No response yet. Request a page first.") unless @last_response
+      @last_response
+    end
+
+    def cookie_jar
+      @cookie_jar ||= Rack::Test::CookieJar.new([], @default_host)
+    end
+
+  end
+
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test.rb
new file mode 100644
index 0000000000..70384b1d76
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test.rb
@@ -0,0 +1,239 @@
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__) + "/.."))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + "/.."))
+end
+
+require "uri"
+require "rack"
+require "rack/mock_session"
+require "rack/test/cookie_jar"
+require "rack/test/mock_digest_request"
+require "rack/test/utils"
+require "rack/test/methods"
+require "rack/test/uploaded_file"
+
+module Rack
+  module Test
+
+    VERSION = "0.3.0"
+
+    DEFAULT_HOST = "example.org"
+    MULTIPART_BOUNDARY = "----------XnJLe9ZIbbGUYtzPQJ16u1"
+
+    # The common base class for exceptions raised by Rack::Test
+    class Error < StandardError; end
+
+    class Session
+      extend Forwardable
+      include Rack::Test::Utils
+
+      def_delegators :@rack_mock_session, :clear_cookies, :set_cookie, :last_response, :last_request
+
+      # Initialize a new session for the given Rack app
+      def initialize(app, default_host = DEFAULT_HOST)
+        @headers = {}
+        @default_host = default_host
+        @rack_mock_session = Rack::MockSession.new(app, default_host)
+      end
+
+      # Issue a GET request for the given URI with the given params and Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      #
+      # Example:
+      #   get "/"
+      def get(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "GET", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a POST request for the given URI. See #get
+      #
+      # Example:
+      #   post "/signup", "name" => "Bryan"
+      def post(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "POST", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a PUT request for the given URI. See #get
+      #
+      # Example:
+      #   put "/"
+      def put(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "PUT", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a DELETE request for the given URI. See #get
+      #
+      # Example:
+      #   delete "/"
+      def delete(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "DELETE", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a HEAD request for the given URI. See #get
+      #
+      # Example:
+      #   head "/"
+      def head(uri, params = {}, env = {}, &block)
+        env = env_for(uri, env.merge(:method => "HEAD", :params => params))
+        process_request(uri, env, &block)
+      end
+
+      # Issue a request to the Rack app for the given URI and optional Rack
+      # environment. Stores the issues request object in #last_request and
+      # the app's response in #last_response. Yield #last_response to a block
+      # if given.
+      #
+      # Example:
+      #   request "/"
+      def request(uri, env = {}, &block)
+        env = env_for(uri, env)
+        process_request(uri, env, &block)
+      end
+
+      # Set a header to be included on all subsequent requests through the
+      # session. Use a value of nil to remove a previously configured header.
+      #
+      # Example:
+      #   header "User-Agent", "Firefox"
+      def header(name, value)
+        if value.nil?
+          @headers.delete(name)
+        else
+          @headers[name] = value
+        end
+      end
+
+      # Set the username and password for HTTP Basic authorization, to be
+      # included in subsequent requests in the HTTP_AUTHORIZATION header.
+      #
+      # Example:
+      #   basic_authorize "bryan", "secret"
+      def basic_authorize(username, password)
+        encoded_login = ["#{username}:#{password}"].pack("m*")
+        header('HTTP_AUTHORIZATION', "Basic #{encoded_login}")
+      end
+
+      alias_method :authorize, :basic_authorize
+
+      def digest_authorize(username, password)
+        @digest_username = username
+        @digest_password = password
+      end
+
+      # Rack::Test will not follow any redirects automatically. This method
+      # will follow the redirect returned in the last response. If the last
+      # response was not a redirect, an error will be raised.
+      def follow_redirect!
+        unless last_response.redirect?
+          raise Error.new("Last response was not a redirect. Cannot follow_redirect!")
+        end
+
+        get(last_response["Location"])
+      end
+
+    private
+
+      def env_for(path, env)
+        uri = URI.parse(path)
+        uri.host ||= @default_host
+
+        env = default_env.merge(env)
+
+        env.update("HTTPS" => "on")                if URI::HTTPS === uri
+        env["X-Requested-With"] = "XMLHttpRequest" if env[:xhr]
+
+        if (env[:method] == "POST" || env["REQUEST_METHOD"] == "POST") && !env.has_key?(:input)
+          env["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+
+          multipart = (Hash === env[:params]) &&
+            env[:params].any? { |_, v| UploadedFile === v }
+
+          if multipart
+            env[:input] = multipart_body(env.delete(:params))
+            env["CONTENT_LENGTH"] ||= env[:input].length.to_s
+            env["CONTENT_TYPE"] = "multipart/form-data; boundary=#{MULTIPART_BOUNDARY}"
+          else
+            env[:input] = params_to_string(env.delete(:params))
+          end
+        end
+
+        params = env[:params] || {}
+        params.update(parse_query(uri.query))
+
+        uri.query = requestify(params)
+
+        if env.has_key?(:cookie)
+          set_cookie(env.delete(:cookie), uri)
+        end
+
+        Rack::MockRequest.env_for(uri.to_s, env)
+      end
+
+      def process_request(uri, env)
+        uri = URI.parse(uri)
+        uri.host ||= @default_host
+
+        @rack_mock_session.request(uri, env)
+
+        if retry_with_digest_auth?(env)
+          auth_env = env.merge({
+            "HTTP_AUTHORIZATION"          => digest_auth_header,
+            "rack-test.digest_auth_retry" => true
+          })
+          auth_env.delete('rack.request')
+          process_request(uri.path, auth_env)
+        else
+          yield last_response if block_given?
+
+          last_response
+        end
+      end
+
+      def digest_auth_header
+        challenge = last_response["WWW-Authenticate"].split(" ", 2).last
+        params = Rack::Auth::Digest::Params.parse(challenge)
+
+        params.merge!({
+          "username"  => @digest_username,
+          "nc"        => "00000001",
+          "cnonce"    => "nonsensenonce",
+          "uri"       => last_request.path_info,
+          "method"    => last_request.env["REQUEST_METHOD"],
+        })
+
+        params["response"] = MockDigestRequest.new(params).response(@digest_password)
+
+        "Digest #{params}"
+      end
+
+      def retry_with_digest_auth?(env)
+        last_response.status == 401 &&
+        digest_auth_configured? &&
+        !env["rack-test.digest_auth_retry"]
+      end
+
+      def digest_auth_configured?
+        @digest_username
+      end
+
+      def default_env
+        { "rack.test" => true, "REMOTE_ADDR" => "127.0.0.1" }.merge(@headers)
+      end
+
+      def params_to_string(params)
+        case params
+        when Hash then requestify(params)
+        when nil  then ""
+        else params
+        end
+      end
+
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/cookie_jar.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/cookie_jar.rb
new file mode 100644
index 0000000000..d58c914c9b
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/cookie_jar.rb
@@ -0,0 +1,169 @@
+require "uri"
+module Rack
+  module Test
+
+    class Cookie
+      include Rack::Utils
+
+      # :api: private
+      attr_reader :name, :value
+
+      # :api: private
+      def initialize(raw, uri = nil, default_host = DEFAULT_HOST)
+        @default_host = default_host
+        uri ||= default_uri
+
+        # separate the name / value pair from the cookie options
+        @name_value_raw, options = raw.split(/[;,] */n, 2)
+
+        @name, @value = parse_query(@name_value_raw, ';').to_a.first
+        @options = parse_query(options, ';')
+
+        @options["domain"]  ||= (uri.host || default_host)
+        @options["path"]    ||= uri.path.sub(/\/[^\/]*\Z/, "")
+      end
+
+      def replaces?(other)
+        [name.downcase, domain, path] == [other.name.downcase, other.domain, other.path]
+      end
+
+      # :api: private
+      def raw
+        @name_value_raw
+      end
+
+      # :api: private
+      def empty?
+        @value.nil? || @value.empty?
+      end
+
+      # :api: private
+      def domain
+        @options["domain"]
+      end
+
+      def secure?
+        @options.has_key?("secure")
+      end
+
+      # :api: private
+      def path
+        @options["path"].strip || "/"
+      end
+
+      # :api: private
+      def expires
+        Time.parse(@options["expires"]) if @options["expires"]
+      end
+
+      # :api: private
+      def expired?
+        expires && expires < Time.now
+      end
+
+      # :api: private
+      def valid?(uri)
+        uri ||= default_uri
+
+        if uri.host.nil?
+          uri.host = @default_host
+        end
+
+        (!secure? || (secure? && uri.scheme == "https")) &&
+        uri.host =~ Regexp.new("#{Regexp.escape(domain)}$", Regexp::IGNORECASE) &&
+        uri.path =~ Regexp.new("^#{Regexp.escape(path)}")
+      end
+
+      # :api: private
+      def matches?(uri)
+        ! expired? && valid?(uri)
+      end
+
+      # :api: private
+      def <=>(other)
+        # Orders the cookies from least specific to most
+        [name, path, domain.reverse] <=> [other.name, other.path, other.domain.reverse]
+      end
+
+    protected
+
+      def default_uri
+        URI.parse("//" + @default_host + "/")
+      end
+
+    end
+
+    class CookieJar
+
+      # :api: private
+      def initialize(cookies = [], default_host = DEFAULT_HOST)
+        @default_host = default_host
+        @cookies = cookies
+        @cookies.sort!
+      end
+
+      def [](name)
+        cookies = hash_for(nil)
+        # TODO: Should be case insensitive
+        cookies[name] && cookies[name].value
+      end
+
+      def []=(name, value)
+        # TODO: needs proper escaping
+        merge("#{name}=#{value}")
+      end
+
+      def merge(raw_cookies, uri = nil)
+        return unless raw_cookies
+
+        raw_cookies.each_line do |raw_cookie|
+          cookie = Cookie.new(raw_cookie, uri, @default_host)
+          self << cookie if cookie.valid?(uri)
+        end
+      end
+
+      def <<(new_cookie)
+        @cookies.reject! do |existing_cookie|
+          new_cookie.replaces?(existing_cookie)
+        end
+
+        @cookies << new_cookie
+        @cookies.sort!
+      end
+
+      # :api: private
+      def for(uri)
+        hash_for(uri).values.map { |c| c.raw }.join(';')
+      end
+
+      def to_hash
+        cookies = {}
+
+        hash_for(nil).each do |name, cookie|
+          cookies[name] = cookie.value
+        end
+
+        return cookies
+      end
+
+    protected
+
+      def hash_for(uri = nil)
+        cookies = {}
+
+        # The cookies are sorted by most specific first. So, we loop through
+        # all the cookies in order and add it to a hash by cookie name if
+        # the cookie can be sent to the current URI. It's added to the hash
+        # so that when we are done, the cookies will be unique by name and
+        # we'll have grabbed the most specific to the URI.
+        @cookies.each do |cookie|
+          cookies[cookie.name] = cookie if cookie.matches?(uri)
+        end
+
+        return cookies
+      end
+
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/methods.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/methods.rb
new file mode 100644
index 0000000000..a191fa23d8
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/methods.rb
@@ -0,0 +1,45 @@
+require "forwardable"
+
+module Rack
+  module Test
+    module Methods
+      extend Forwardable
+
+      def rack_test_session
+        @_rack_test_session ||= Rack::Test::Session.new(app)
+      end
+
+      def rack_mock_session
+        @_rack_mock_session ||= Rack::MockSession.new(app)
+      end
+
+      METHODS = [
+        :request,
+
+        # HTTP verbs
+        :get,
+        :post,
+        :put,
+        :delete,
+        :head,
+
+        # Redirects
+        :follow_redirect!,
+
+        # Header-related features
+        :header,
+        :set_cookie,
+        :clear_cookies,
+        :authorize,
+        :basic_authorize,
+        :digest_authorize,
+
+        # Expose the last request and response
+        :last_response,
+        :last_request
+      ]
+
+      def_delegators :rack_test_session, *METHODS
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/mock_digest_request.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/mock_digest_request.rb
new file mode 100644
index 0000000000..81c398ba51
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/mock_digest_request.rb
@@ -0,0 +1,27 @@
+module Rack
+  module Test
+
+    class MockDigestRequest
+      def initialize(params)
+        @params = params
+      end
+
+      def method_missing(sym)
+        if @params.has_key? k = sym.to_s
+          return @params[k]
+        end
+
+        super
+      end
+
+      def method
+        @params['method']
+      end
+
+      def response(password)
+        Rack::Auth::Digest::MD5.new(nil).send :digest, self, password
+      end
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/uploaded_file.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/uploaded_file.rb
new file mode 100644
index 0000000000..239302fbe4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/uploaded_file.rb
@@ -0,0 +1,36 @@
+require "tempfile"
+
+module Rack
+  module Test
+
+    class UploadedFile
+      # The filename, *not* including the path, of the "uploaded" file
+      attr_reader :original_filename
+
+      # The content type of the "uploaded" file
+      attr_accessor :content_type
+
+      def initialize(path, content_type = "text/plain", binary = false)
+        raise "#{path} file does not exist" unless ::File.exist?(path)
+        @content_type = content_type
+        @original_filename = ::File.basename(path)
+        @tempfile = Tempfile.new(@original_filename)
+        @tempfile.set_encoding(Encoding::BINARY) if @tempfile.respond_to?(:set_encoding)
+        @tempfile.binmode if binary
+        FileUtils.copy_file(path, @tempfile.path)
+      end
+
+      def path
+        @tempfile.path
+      end
+
+      alias_method :local_path, :path
+
+      def method_missing(method_name, *args, &block) #:nodoc:
+        @tempfile.__send__(method_name, *args, &block)
+      end
+
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/utils.rb b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/utils.rb
new file mode 100644
index 0000000000..d25b849709
--- /dev/null
+++ b/actionpack/lib/action_dispatch/vendor/rack-test/rack/test/utils.rb
@@ -0,0 +1,75 @@
+module Rack
+  module Test
+
+    module Utils
+      include Rack::Utils
+
+      def requestify(value, prefix = nil)
+        case value
+        when Array
+          value.map do |v|
+            requestify(v, "#{prefix}[]")
+          end.join("&")
+        when Hash
+          value.map do |k, v|
+            requestify(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+          end.join("&")
+        else
+          "#{prefix}=#{escape(value)}"
+        end
+      end
+
+      module_function :requestify
+
+      def multipart_requestify(params, first=true)
+        p = Hash.new
+
+        params.each do |key, value|
+          k = first ? key.to_s : "[#{key}]"
+
+          if Hash === value
+            multipart_requestify(value, false).each do |subkey, subvalue|
+              p[k + subkey] = subvalue
+            end
+          else
+            p[k] = value
+          end
+        end
+
+        return p
+      end
+
+      module_function :multipart_requestify
+
+      def multipart_body(params)
+        multipart_requestify(params).map do |key, value|
+          if value.respond_to?(:original_filename)
+            ::File.open(value.path, "rb") do |f|
+              f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
+
+              <<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{key}"; filename="#{escape(value.original_filename)}"\r
+Content-Type: #{value.content_type}\r
+Content-Length: #{::File.stat(value.path).size}\r
+\r
+#{f.read}\r
+EOF
+            end
+          else
+<<-EOF
+--#{MULTIPART_BOUNDARY}\r
+Content-Disposition: form-data; name="#{key}"\r
+\r
+#{value}\r
+EOF
+          end
+        end.join("")+"--#{MULTIPART_BOUNDARY}--\r"
+      end
+
+      module_function :multipart_body
+
+    end
+
+  end
+end
diff --git a/actionpack/lib/action_view.rb b/actionpack/lib/action_view.rb
index e604c2a581..94138097e3 100644
--- a/actionpack/lib/action_view.rb
+++ b/actionpack/lib/action_view.rb
@@ -21,15 +21,10 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-begin
-  require 'active_support'
-rescue LoadError
-  activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
-  if File.directory?(activesupport_path)
-    $:.unshift activesupport_path
-    require 'active_support'
-  end
-end
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift activesupport_path if File.directory?(activesupport_path)
+require 'active_support'
+require 'active_support/core_ext/class/attribute_accessors'
 
 require File.join(File.dirname(__FILE__), "action_pack")
 
diff --git a/actionpack/lib/action_view/base.rb b/actionpack/lib/action_view/base.rb
index efed19a21d..4ab568b44c 100644
--- a/actionpack/lib/action_view/base.rb
+++ b/actionpack/lib/action_view/base.rb
@@ -1,3 +1,6 @@
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/delegation'
+
 module ActionView #:nodoc:
   class ActionViewError < StandardError #:nodoc:
   end
@@ -191,12 +194,14 @@ module ActionView #:nodoc:
       ActionController::Base.allow_concurrency || (cache_template_loading.nil? ? !ActiveSupport::Dependencies.load? : cache_template_loading)
     end
 
-    attr_internal :request
+    attr_internal :request, :layout
 
     delegate :controller_path, :to => :controller, :allow_nil => true
 
     delegate :request_forgery_protection_token, :template, :params, :session, :cookies, :response, :headers,
-             :flash, :logger, :action_name, :controller_name, :to => :controller
+             :flash, :action_name, :controller_name, :to => :controller
+
+    delegate :logger, :to => :controller, :allow_nil => true
 
     delegate :find_by_parts, :to => :view_paths
 
@@ -264,15 +269,16 @@ module ActionView #:nodoc:
       nil
     end
 
-    private
-      # Evaluates the local assigns and controller ivars, pushes them to the view.
-      def _evaluate_assigns_and_ivars #:nodoc:
-        unless @assigns_added
-          @assigns.each { |key, value| instance_variable_set("@#{key}", value) }
-          _copy_ivars_from_controller
-          @assigns_added = true
-        end
+    # Evaluates the local assigns and controller ivars, pushes them to the view.
+    def _evaluate_assigns_and_ivars #:nodoc:
+      unless @assigns_added
+        @assigns.each { |key, value| instance_variable_set("@#{key}", value) }
+        _copy_ivars_from_controller
+        @assigns_added = true
       end
+    end
+
+    private
 
       def _copy_ivars_from_controller #:nodoc:
         if @controller
@@ -283,8 +289,11 @@ module ActionView #:nodoc:
       end
 
       def _set_controller_content_type(content_type) #:nodoc:
-        if controller.respond_to?(:response)
-          controller.response.content_type ||= content_type
+        # TODO: Remove this method when new base is switched
+        unless defined?(ActionController::Http)
+          if controller.respond_to?(:response)
+            controller.response.content_type ||= content_type
+          end
         end
       end
   end
diff --git a/actionpack/lib/action_view/helpers/active_record_helper.rb b/actionpack/lib/action_view/helpers/active_record_helper.rb
index 7c0dfdab10..b4b9f6e34b 100644
--- a/actionpack/lib/action_view/helpers/active_record_helper.rb
+++ b/actionpack/lib/action_view/helpers/active_record_helper.rb
@@ -1,5 +1,6 @@
 require 'cgi'
 require 'action_view/helpers/form_helper'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module ActionView
   class Base
diff --git a/actionpack/lib/action_view/helpers/capture_helper.rb b/actionpack/lib/action_view/helpers/capture_helper.rb
index 9e39536653..b4197479a0 100644
--- a/actionpack/lib/action_view/helpers/capture_helper.rb
+++ b/actionpack/lib/action_view/helpers/capture_helper.rb
@@ -124,7 +124,11 @@ module ActionView
 
       # Use an alternate output buffer for the duration of the block.
       # Defaults to a new empty string.
-      def with_output_buffer(buf = '') #:nodoc:
+      def with_output_buffer(buf = nil) #:nodoc:
+        unless buf
+          buf = ''
+          buf.force_encoding(output_buffer.encoding) if buf.respond_to?(:force_encoding)
+        end
         self.output_buffer, old_buffer = buf, output_buffer
         yield
         output_buffer
@@ -134,9 +138,12 @@ module ActionView
 
       # Add the output buffer to the response body and start a new one.
       def flush_output_buffer #:nodoc:
-        if output_buffer && output_buffer != ''
+        if output_buffer && !output_buffer.empty?
           response.body_parts << output_buffer
-          self.output_buffer = ''
+          new = ''
+          new.force_encoding(output_buffer.encoding) if new.respond_to?(:force_encoding)
+          self.output_buffer = new
+          nil
         end
       end
     end
diff --git a/actionpack/lib/action_view/helpers/form_helper.rb b/actionpack/lib/action_view/helpers/form_helper.rb
index a59829b23f..beef661a37 100644
--- a/actionpack/lib/action_view/helpers/form_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_helper.rb
@@ -2,6 +2,7 @@ require 'cgi'
 require 'action_view/helpers/date_helper'
 require 'action_view/helpers/tag_helper'
 require 'action_view/helpers/form_tag_helper'
+require 'active_support/core_ext/class/inheritable_attributes'
 
 module ActionView
   module Helpers
@@ -1039,8 +1040,8 @@ module ActionView
     end
   end
 
-  class Base
-    cattr_accessor :default_form_builder
-    self.default_form_builder = ::ActionView::Helpers::FormBuilder
+  class << Base
+    attr_accessor :default_form_builder
   end
-end
\ No newline at end of file
+  Base.default_form_builder = ::ActionView::Helpers::FormBuilder
+end
diff --git a/actionpack/lib/action_view/helpers/form_options_helper.rb b/actionpack/lib/action_view/helpers/form_options_helper.rb
index 6b385ef77d..6adbab175f 100644
--- a/actionpack/lib/action_view/helpers/form_options_helper.rb
+++ b/actionpack/lib/action_view/helpers/form_options_helper.rb
@@ -230,6 +230,8 @@ module ActionView
       #
       # NOTE: Only the option tags are returned, you have to wrap this call in a regular HTML select tag.
       def options_for_select(container, selected = nil)
+        return container if String === container
+
         container = container.to_a if Hash === container
         selected, disabled = extract_selected_and_disabled(selected)
 
diff --git a/actionpack/lib/action_view/helpers/number_helper.rb b/actionpack/lib/action_view/helpers/number_helper.rb
index dea958deaf..999d5b34fc 100644
--- a/actionpack/lib/action_view/helpers/number_helper.rb
+++ b/actionpack/lib/action_view/helpers/number_helper.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/float/rounding'
+
 module ActionView
   module Helpers #:nodoc:
     # Provides methods for converting numbers into formatted strings.
@@ -246,6 +248,11 @@ module ActionView
       #  number_to_human_size(483989, :precision => 0)                      # => 473 KB
       #  number_to_human_size(1234567, :precision => 2, :separator => ',')  # => 1,18 MB
       #
+      # Zeros after the decimal point are always stripped out, regardless of the
+      # specified precision:
+      #  helper.number_to_human_size(1234567890123, :precision => 5)        # => "1.12283 TB"
+      #  helper.number_to_human_size(524288000, :precision=>5)              # => "500 MB"
+      #
       # You can still use <tt>number_to_human_size</tt> with the old API that accepts the
       # +precision+ as its optional second parameter:
       #  number_to_human_size(1234567, 2)    # => 1.18 MB
@@ -291,7 +298,7 @@ module ActionView
               :precision => precision,
               :separator => separator,
               :delimiter => delimiter
-            ).sub(/(\d)(#{escaped_separator}[1-9]*)?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
+            ).sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
             storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
           rescue
             number
diff --git a/actionpack/lib/action_view/helpers/prototype_helper.rb b/actionpack/lib/action_view/helpers/prototype_helper.rb
index 6bad11e354..c0f5df3468 100644
--- a/actionpack/lib/action_view/helpers/prototype_helper.rb
+++ b/actionpack/lib/action_view/helpers/prototype_helper.rb
@@ -1,5 +1,6 @@
 require 'set'
 require 'active_support/json'
+require 'active_support/core_ext/object/extending'
 
 module ActionView
   module Helpers
@@ -572,6 +573,7 @@ module ActionView
       # #include_helpers_from_context has nothing to overwrite.
       class JavaScriptGenerator #:nodoc:
         def initialize(context, &block) #:nodoc:
+          context._evaluate_assigns_and_ivars
           @context, @lines = context, []
           include_helpers_from_context
           @context.with_output_buffer(@lines) do
@@ -686,7 +688,7 @@ module ActionView
           # Returns an object whose <tt>to_json</tt> evaluates to +code+. Use this to pass a literal JavaScript
           # expression as an argument to another JavaScriptGenerator method.
           def literal(code)
-            ActiveSupport::JSON::Variable.new(code.to_s)
+            ::ActiveSupport::JSON::Variable.new(code.to_s)
           end
 
           # Returns a collection reference by finding it through a CSS +pattern+ in the DOM. This collection can then be
@@ -973,7 +975,7 @@ module ActionView
             def loop_on_multiple_args(method, ids)
               record(ids.size>1 ?
                 "#{javascript_object_for(ids)}.each(#{method})" :
-                "#{method}(#{ids.first.to_json})")
+                "#{method}(#{javascript_object_for(ids.first)})")
             end
 
             def page
@@ -997,7 +999,7 @@ module ActionView
             end
 
             def javascript_object_for(object)
-              object.respond_to?(:to_json) ? object.to_json : object.inspect
+              ::ActiveSupport::JSON.encode(object)
             end
 
             def arguments_for_call(arguments, block = nil)
@@ -1139,7 +1141,7 @@ module ActionView
     class JavaScriptElementProxy < JavaScriptProxy #:nodoc:
       def initialize(generator, id)
         @id = id
-        super(generator, "$(#{id.to_json})")
+        super(generator, "$(#{::ActiveSupport::JSON.encode(id)})")
       end
 
       # Allows access of element attributes through +attribute+. Examples:
@@ -1180,11 +1182,11 @@ module ActionView
 
       # The JSON Encoder calls this to check for the +to_json+ method
       # Since it's a blank slate object, I suppose it responds to anything.
-      def respond_to?(method)
+      def respond_to?(*)
         true
       end
 
-      def to_json(options = nil)
+      def rails_to_json(*)
         @variable
       end
 
@@ -1211,7 +1213,7 @@ module ActionView
           enumerate :eachSlice, :variable => variable, :method_args => [number], :yield_args => %w(value index), :return => true, &block
         else
           add_variable_assignment!(variable)
-          append_enumerable_function!("eachSlice(#{number.to_json});")
+          append_enumerable_function!("eachSlice(#{::ActiveSupport::JSON.encode(number)});")
         end
       end
 
@@ -1232,7 +1234,7 @@ module ActionView
 
       def pluck(variable, property)
         add_variable_assignment!(variable)
-        append_enumerable_function!("pluck(#{property.to_json});")
+        append_enumerable_function!("pluck(#{::ActiveSupport::JSON.encode(property)});")
       end
 
       def zip(variable, *arguments, &block)
@@ -1296,7 +1298,7 @@ module ActionView
 
     class JavaScriptElementCollectionProxy < JavaScriptCollectionProxy #:nodoc:\
       def initialize(generator, pattern)
-        super(generator, "$$(#{pattern.to_json})")
+        super(generator, "$$(#{::ActiveSupport::JSON.encode(pattern)})")
       end
     end
   end
diff --git a/actionpack/lib/action_view/helpers/scriptaculous_helper.rb b/actionpack/lib/action_view/helpers/scriptaculous_helper.rb
index e16935ea87..04af2781d7 100644
--- a/actionpack/lib/action_view/helpers/scriptaculous_helper.rb
+++ b/actionpack/lib/action_view/helpers/scriptaculous_helper.rb
@@ -43,7 +43,7 @@ module ActionView
       # You can change the behaviour with various options, see
       # http://script.aculo.us for more documentation.
       def visual_effect(name, element_id = false, js_options = {})
-        element = element_id ? element_id.to_json : "element"
+        element = element_id ? ActiveSupport::JSON.encode(element_id) : "element"
         
         js_options[:queue] = if js_options[:queue].is_a?(Hash)
           '{' + js_options[:queue].map {|k, v| k == :limit ? "#{k}:#{v}" : "#{k}:'#{v}'" }.join(',') + '}'
@@ -138,7 +138,7 @@ module ActionView
       end
       
       def sortable_element_js(element_id, options = {}) #:nodoc:
-        options[:with]     ||= "Sortable.serialize(#{element_id.to_json})"
+        options[:with]     ||= "Sortable.serialize(#{ActiveSupport::JSON.encode(element_id)})"
         options[:onUpdate] ||= "function(){" + remote_function(options) + "}"
         options.delete_if { |key, value| PrototypeHelper::AJAX_OPTIONS.include?(key) }
   
@@ -149,7 +149,7 @@ module ActionView
         options[:containment] = array_or_string_for_javascript(options[:containment]) if options[:containment]
         options[:only] = array_or_string_for_javascript(options[:only]) if options[:only]
   
-        %(Sortable.create(#{element_id.to_json}, #{options_for_javascript(options)});)
+        %(Sortable.create(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
       end
 
       # Makes the element with the DOM ID specified by +element_id+ draggable.
@@ -164,7 +164,7 @@ module ActionView
       end
       
       def draggable_element_js(element_id, options = {}) #:nodoc:
-        %(new Draggable(#{element_id.to_json}, #{options_for_javascript(options)});)
+        %(new Draggable(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
       end
 
       # Makes the element with the DOM ID specified by +element_id+ receive
@@ -219,7 +219,7 @@ module ActionView
         # Confirmation happens during the onDrop callback, so it can be removed from the options
         options.delete(:confirm) if options[:confirm]
 
-        %(Droppables.add(#{element_id.to_json}, #{options_for_javascript(options)});)
+        %(Droppables.add(#{ActiveSupport::JSON.encode(element_id)}, #{options_for_javascript(options)});)
       end
     end
   end
diff --git a/actionpack/lib/action_view/helpers/tag_helper.rb b/actionpack/lib/action_view/helpers/tag_helper.rb
index af8c4d5e21..66d7592874 100644
--- a/actionpack/lib/action_view/helpers/tag_helper.rb
+++ b/actionpack/lib/action_view/helpers/tag_helper.rb
@@ -9,7 +9,7 @@ module ActionView
       include ERB::Util
 
       BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked).to_set
-      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map(&:to_sym))
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attr| attr.to_sym })
 
       # Returns an empty HTML tag of type +name+ which by default is XHTML
       # compliant. Set +open+ to true to create an open tag compatible
diff --git a/actionpack/lib/action_view/helpers/text_helper.rb b/actionpack/lib/action_view/helpers/text_helper.rb
index 573b99b96e..ad0733a7e1 100644
--- a/actionpack/lib/action_view/helpers/text_helper.rb
+++ b/actionpack/lib/action_view/helpers/text_helper.rb
@@ -34,12 +34,16 @@ module ActionView
 
       # Truncates a given +text+ after a given <tt>:length</tt> if +text+ is longer than <tt>:length</tt>
       # (defaults to 30). The last characters will be replaced with the <tt>:omission</tt> (defaults to "...").
+      # Pass a <tt>:separator</tt> to truncate +text+ at a natural break.
       #
       # ==== Examples
       #
       #   truncate("Once upon a time in a world far far away")
       #   # => Once upon a time in a world f...
       #
+      #   truncate("Once upon a time in a world far far away", :separator => ' ')
+      #   # => Once upon a time in a world...
+      #
       #   truncate("Once upon a time in a world far far away", :length => 14)
       #   # => Once upon a...
       #
@@ -71,7 +75,8 @@ module ActionView
         if text
           l = options[:length] - options[:omission].mb_chars.length
           chars = text.mb_chars
-          (chars.length > options[:length] ? chars[0...l] + options[:omission] : text).to_s
+          stop = options[:separator] ? (chars.rindex(options[:separator].mb_chars, l) || l) : l
+          (chars.length > options[:length] ? chars[0...stop] + options[:omission] : text).to_s
         end
       end
 
@@ -535,7 +540,7 @@ module ActionView
           link_attributes = html_options.stringify_keys
           text.gsub(AUTO_LINK_RE) do
             href = $&
-            punctuation = ''
+            punctuation = []
             left, right = $`, $'
             # detect already linked URLs and URLs in the middle of a tag
             if left =~ /<[^>]+$/ && right =~ /^[^>]*>/
@@ -543,17 +548,18 @@ module ActionView
               href
             else
               # don't include trailing punctuation character as part of the URL
-              if href.sub!(/[^\w\/-]$/, '') and punctuation = $& and opening = BRACKETS[punctuation]
-                if href.scan(opening).size > href.scan(punctuation).size
-                  href << punctuation
-                  punctuation = ''
+              while href.sub!(/[^\w\/-]$/, '')
+                punctuation.push $&
+                if opening = BRACKETS[punctuation.last] and href.scan(opening).size > href.scan(punctuation.last).size
+                  href << punctuation.pop
+                  break
                 end
               end
 
               link_text = block_given?? yield(href) : href
               href = 'http://' + href unless href.index('http') == 0
 
-              content_tag(:a, h(link_text), link_attributes.merge('href' => href)) + punctuation
+              content_tag(:a, h(link_text), link_attributes.merge('href' => href)) + punctuation.reverse.join('')
             end
           end
         end
diff --git a/actionpack/lib/action_view/paths.rb b/actionpack/lib/action_view/paths.rb
index 1d0279889c..95c56faf9c 100644
--- a/actionpack/lib/action_view/paths.rb
+++ b/actionpack/lib/action_view/paths.rb
@@ -2,8 +2,8 @@ module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
     def self.type_cast(obj)
       if obj.is_a?(String)
-        cache = !Object.const_defined?(:Rails) || Rails.configuration.cache_classes
-        Template::FileSystemPath.new(obj, :cache => cache)
+        cache = !defined?(Rails) || !Rails.respond_to?(:configuration) || Rails.configuration.cache_classes
+        Template::FileSystemPathWithFallback.new(obj, :cache => cache)
       else
         obj
       end
@@ -33,19 +33,19 @@ module ActionView #:nodoc:
       super(*objs.map { |obj| self.class.type_cast(obj) })
     end
 
-    def find_by_parts(path, extension = nil, prefix = nil, partial = false)
-      template_path = path.sub(/^\//, '')
+    def find_by_parts(path, details = {}, prefix = nil, partial = false)
+      # template_path = path.sub(/^\//, '')
+      template_path = path
 
       each do |load_path|
-        if template = load_path.find_by_parts(template_path, extension, prefix, partial)
+        if template = load_path.find_by_parts(template_path, details, prefix, partial)
           return template
         end
       end
-
-      Template.new(path, self)
-    rescue ActionView::MissingTemplate => e
-      extension ||= []
-      raise ActionView::MissingTemplate.new(self, "#{prefix}/#{path}.{#{extension.join(",")}}")
+      
+      # TODO: Have a fallback absolute path?
+      extension = details[:formats] || []
+      raise ActionView::MissingTemplate.new(self, "#{prefix}/#{path} - #{details.inspect} - partial: #{!!partial}")
     end
     
     def find_by_parts?(path, extension = nil, prefix = nil, partial = false)
diff --git a/actionpack/lib/action_view/render/partials.rb b/actionpack/lib/action_view/render/partials.rb
index e337dcb63b..eacf117bea 100644
--- a/actionpack/lib/action_view/render/partials.rb
+++ b/actionpack/lib/action_view/render/partials.rb
@@ -171,11 +171,21 @@ module ActionView
   #   <% end %>
   module Partials
     extend ActiveSupport::Memoizable
+    extend ActiveSupport::Concern
+    
+    included do
+      attr_accessor :_partial      
+    end
+
+    def _render_partial_from_controller(*args)
+      @assigns_added = false
+      _render_partial(*args)
+    end
 
     def _render_partial(options = {}) #:nodoc:
       options[:locals] ||= {}
 
-      case path = partial = options[:partial]        
+      case path = partial = options[:partial]
       when *_array_like_objects
         return _render_partial_collection(partial, options)
       else
@@ -187,6 +197,7 @@ module ActionView
           path = ActionController::RecordIdentifier.partial_path(object, controller_path)
         end
         _, _, prefix, object = parts = partial_parts(path, options)
+        parts[1] = {:formats => parts[1]}
         template = find_by_parts(*parts)
         _render_partial_object(template, options, (object unless object == true))
       end
@@ -221,16 +232,7 @@ module ActionView
       ensure
         @_proc_for_layout = nil
       end
-  
-      def _render_partial_with_layout(layout, options)
-        if layout
-          prefix = controller && !layout.include?("/") ? controller.controller_path : nil
-          layout = find_by_parts(layout, formats, prefix, true)
-        end
-        content = _render_partial(options)
-        return _render_content_with_layout(content, layout, options[:locals])
-      end
-    
+      
       def _deprecated_ivar_assign(template)
         if respond_to?(:controller)
           ivar = :"@#{template.variable_name}"
@@ -253,7 +255,7 @@ module ActionView
       def _render_partial_with_layout(layout, options)
         if layout
           prefix = controller && !layout.include?("/") ? controller.controller_path : nil
-          layout = find_by_parts(layout, formats, prefix, true)
+          layout = find_by_parts(layout, {:formats => formats}, prefix, true)
         end
         content = _render_partial(options)
         return _render_content_with_layout(content, layout, options[:locals])
@@ -286,13 +288,17 @@ module ActionView
           locals = (options[:locals] ||= {})
           object ||= locals[:object] || locals[template.variable_name]
           
-          _set_locals(object, locals, template, options)          
+          _set_locals(object, locals, template, options)
+          
+          self._partial = template
+          
           _render_template(template, locals)
         end
       end
 
       def _set_locals(object, locals, template, options)
         object ||= _deprecated_ivar_assign(template)
+        
         locals[:object] = locals[template.variable_name] = object
         locals[options[:as]] = object if options[:as]
       end
@@ -315,13 +321,16 @@ module ActionView
           locals[template.counter_name] = index
           
           index += 1
+          
+          self._partial = template
+          
           _render_template(template, locals)
         end.join(spacer)
       end
 
       def _pick_partial_template(partial_path) #:nodoc:
         prefix = controller_path unless partial_path.include?('/')
-        find_by_parts(partial_path, formats, prefix, true)
+        find_by_parts(partial_path, {:formats => formats}, prefix, true)
       end
       memoize :_pick_partial_template
   end
diff --git a/actionpack/lib/action_view/render/rendering.rb b/actionpack/lib/action_view/render/rendering.rb
index a9b2acecd5..fe785e7b20 100644
--- a/actionpack/lib/action_view/render/rendering.rb
+++ b/actionpack/lib/action_view/render/rendering.rb
@@ -23,10 +23,10 @@ module ActionView
         return _render_partial_with_layout(layout, options) if options.key?(:partial)
         return _render_partial_with_block(layout, block, options) if block_given?
     
-        layout = find_by_parts(layout, formats) if layout
+        layout = find_by_parts(layout, {:formats => formats}) if layout
     
         if file = options[:file]
-          template = find_by_parts(file, formats)
+          template = find_by_parts(file, {:formats => formats})
           _render_template_with_layout(template, layout, :locals => options[:locals])
         elsif inline = options[:inline]
           _render_inline(inline, layout, options)
@@ -46,8 +46,8 @@ module ActionView
       locals ||= {}
 
       if controller && layout
-        response.layout = layout.path_without_format_and_extension if controller.respond_to?(:response)
-        logger.info("Rendering template within #{layout.path_without_format_and_extension}") if logger
+        @_layout = layout.identifier
+        logger.info("Rendering template within #{layout.identifier}") if logger
       end
   
       begin
@@ -76,7 +76,6 @@ module ActionView
         end
       end
     rescue Exception => e
-      raise e if template.is_a?(InlineTemplate) || !template.filename
       if TemplateError === e
         e.sub_template_of(template)
         raise e
@@ -86,7 +85,9 @@ module ActionView
     end
 
     def _render_inline(inline, layout, options)
-      content = _render_template(InlineTemplate.new(options[:inline], options[:type]), options[:locals] || {})
+      handler = Template.handler_class_for_extension(options[:type] || "erb")
+      template = Template.new(options[:inline], "inline #{options[:inline].inspect}", handler, {})
+      content = _render_template(template, options[:locals] || {})
       layout ? _render_content_with_layout(content, layout, options[:locals]) : content
     end
 
@@ -94,9 +95,14 @@ module ActionView
       layout ? _render_content_with_layout(text, layout, options[:locals]) : text
     end
 
+    def _render_template_from_controller(*args)
+      @assigns_added = nil
+      _render_template_with_layout(*args)
+    end
+
     def _render_template_with_layout(template, layout = nil, options = {}, partial = false)
       if controller && logger
-        logger.info("Rendering #{template.path_without_extension}" + 
+        logger.info("Rendering #{template.identifier}" + 
           (options[:status] ? " (#{options[:status]})" : ''))
       end
   
@@ -107,7 +113,7 @@ module ActionView
         _render_template(template, options[:locals] || {})
       end
   
-      return content unless layout && !template.exempt_from_layout?
+      return content unless layout
       _render_content_with_layout(content, layout, options[:locals] || {})
     end
   end
diff --git a/actionpack/lib/action_view/template/error.rb b/actionpack/lib/action_view/template/error.rb
index 37cb1c7c6c..a06e80b294 100644
--- a/actionpack/lib/action_view/template/error.rb
+++ b/actionpack/lib/action_view/template/error.rb
@@ -12,7 +12,7 @@ module ActionView
     end
 
     def file_name
-      @template.relative_path
+      @template.identifier
     end
 
     def message
@@ -30,7 +30,7 @@ module ActionView
     def sub_template_message
       if @sub_templates
         "Trace of template inclusion: " +
-        @sub_templates.collect { |template| template.relative_path }.join(", ")
+        @sub_templates.collect { |template| template.identifier }.join(", ")
       else
         ""
       end
diff --git a/actionpack/lib/action_view/template/handler.rb b/actionpack/lib/action_view/template/handler.rb
index 672da0ed2b..3071c78174 100644
--- a/actionpack/lib/action_view/template/handler.rb
+++ b/actionpack/lib/action_view/template/handler.rb
@@ -1,3 +1,6 @@
+require "active_support/core_ext/class/inheritable_attributes"
+require "action_dispatch/http/mime_type"
+
 # Legacy TemplateHandler stub
 module ActionView
   module TemplateHandlers #:nodoc:
@@ -19,6 +22,9 @@ module ActionView
   end
 
   class TemplateHandler
+    extlib_inheritable_accessor :default_format
+    self.default_format = Mime::HTML
+
     def self.call(template)
       "#{name}.new(self).render(template, local_assigns)"
     end
diff --git a/actionpack/lib/action_view/template/handlers.rb b/actionpack/lib/action_view/template/handlers.rb
index fb85f28851..faf54b9fe5 100644
--- a/actionpack/lib/action_view/template/handlers.rb
+++ b/actionpack/lib/action_view/template/handlers.rb
@@ -16,6 +16,10 @@ module ActionView #:nodoc:
 
     @@template_handlers = {}
     @@default_template_handlers = nil
+    
+    def self.extensions
+      @@template_handlers.keys
+    end
 
     # Register a class that knows how to handle template files with the given
     # extension. This can be used to implement new template types.
@@ -29,7 +33,7 @@ module ActionView #:nodoc:
     end
 
     def template_handler_extensions
-      @@template_handlers.keys.map(&:to_s).sort
+      @@template_handlers.keys.map {|key| key.to_s }.sort
     end
 
     def registered_template_handler(extension)
@@ -42,7 +46,7 @@ module ActionView #:nodoc:
     end
 
     def handler_class_for_extension(extension)
-      registered_template_handler(extension) || @@default_template_handlers
+      (extension && registered_template_handler(extension.to_sym)) || @@default_template_handlers
     end
   end
 end
diff --git a/actionpack/lib/action_view/template/handlers/builder.rb b/actionpack/lib/action_view/template/handlers/builder.rb
index 788dc93326..f412228752 100644
--- a/actionpack/lib/action_view/template/handlers/builder.rb
+++ b/actionpack/lib/action_view/template/handlers/builder.rb
@@ -5,6 +5,8 @@ module ActionView
     class Builder < TemplateHandler
       include Compilable
 
+      self.default_format = Mime::XML
+
       def compile(template)
         "_set_controller_content_type(Mime::XML);" +
           "xml = ::Builder::XmlMarkup.new(:indent => 2);" +
diff --git a/actionpack/lib/action_view/template/handlers/erb.rb b/actionpack/lib/action_view/template/handlers/erb.rb
index a20b1b0cd3..d773df7d29 100644
--- a/actionpack/lib/action_view/template/handlers/erb.rb
+++ b/actionpack/lib/action_view/template/handlers/erb.rb
@@ -1,4 +1,5 @@
 require 'erb'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module ActionView
   module TemplateHandlers
@@ -12,12 +13,10 @@ module ActionView
       cattr_accessor :erb_trim_mode
       self.erb_trim_mode = '-'
 
-      def compile(template)
-        src = ::ERB.new("<% __in_erb_template=true %>#{template.source}", nil, erb_trim_mode, '@output_buffer').src
+      self.default_format = Mime::HTML
 
-        # Ruby 1.9 prepends an encoding to the source. However this is
-        # useless because you can only set an encoding on the first line
-        RUBY_VERSION >= '1.9' ? src.sub(/\A#coding:.*\n/, '') : src
+      def compile(template)
+        ::ERB.new("<% __in_erb_template=true %>#{template.source}", nil, erb_trim_mode, '@output_buffer').src
       end
     end
   end
diff --git a/actionpack/lib/action_view/template/handlers/rjs.rb b/actionpack/lib/action_view/template/handlers/rjs.rb
index 802a79b3fc..a36744c2b7 100644
--- a/actionpack/lib/action_view/template/handlers/rjs.rb
+++ b/actionpack/lib/action_view/template/handlers/rjs.rb
@@ -3,11 +3,17 @@ module ActionView
     class RJS < TemplateHandler
       include Compilable
 
+      self.default_format = Mime::JS
+
       def compile(template)
         "@formats = [:html];" +
         "controller.response.content_type ||= Mime::JS;" +
           "update_page do |page|;#{template.source}\nend"
       end
+
+      def default_format
+        Mime::JS
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_view/template/path.rb b/actionpack/lib/action_view/template/path.rb
index 9709549b70..478bf96c9a 100644
--- a/actionpack/lib/action_view/template/path.rb
+++ b/actionpack/lib/action_view/template/path.rb
@@ -1,23 +1,82 @@
+require "pathname"
+
 module ActionView
   class Template
+  # Abstract super class
     class Path
-      attr_reader :path, :paths
-      delegate :hash, :inspect, :to => :path
-      
       def initialize(options)
-        @cache = options[:cache]
+        @cache  = options[:cache]
+        @cached = {}
+      end
+    
+      # Normalizes the arguments and passes it on to find_template
+      def find_by_parts(*args)
+        find_all_by_parts(*args).first
+      end
+      
+      def find_all_by_parts(name, details = {}, prefix = nil, partial = nil)
+        details[:locales] = [I18n.locale]
+        name = name.to_s.gsub(handler_matcher, '').split("/")
+        find_templates(name.pop, details, [prefix, *name].compact.join("/"), partial)
+      end
+    
+    private
+      
+      # This is what child classes implement. No defaults are needed
+      # because Path guarentees that the arguments are present and
+      # normalized.
+      def find_templates(name, details, prefix, partial)
+        raise NotImplementedError
+      end
+      
+      def valid_handlers
+        @valid_handlers ||= TemplateHandlers.extensions
+      end
+      
+      def handler_matcher
+        @handler_matcher ||= begin
+          e = valid_handlers.join('|')
+          /\.(?:#{e})$/
+        end
+      end
+       
+      def handler_glob
+        e = TemplateHandlers.extensions.map{|h| ".#{h},"}.join
+        "{#{e}}"
+      end
+      
+      def formats_glob
+        @formats_glob ||= begin
+          formats = Mime::SET.map { |m| m.symbol }
+          '{' + formats.map { |l| ".#{l}," }.join + '}'
+        end
+      end
+      
+      def cached(key)
+        return yield unless @cache
+        return @cached[key] if @cached.key?(key)
+        @cached[key] = yield
+      end
+    end
+  
+    class FileSystemPath < Path
+    
+      def initialize(path, options = {})
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
+        super(options)
+        @path = Pathname.new(path).expand_path
       end
 
+      # TODO: This is the currently needed API. Make this suck less
+      # ==== <suck>
+      attr_reader :path
+    
       def to_s
-        if defined?(RAILS_ROOT)
-          path.to_s.sub(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '')
-        else
-          path.to_s
-        end
+        path.to_s
       end
 
       def to_str
-        path.to_str
+        path.to_s
       end
 
       def ==(path)
@@ -27,59 +86,65 @@ module ActionView
       def eql?(path)
         to_str == path.to_str
       end
-
-      def find_by_parts(name, extensions = nil, prefix = nil, partial = nil)
-        path = prefix ? "#{prefix}/" : ""
-    
-        name = name.to_s.split("/")
-        name[-1] = "_#{name[-1]}" if partial
+      # ==== </suck>
     
-        path << name.join("/")
-
-        template = nil
-
-        Array(extensions).each do |extension|
-          extensioned_path = extension ? "#{path}.#{extension}" : path
-          break if (template = find_template(extensioned_path))
+      def find_templates(name, details, prefix, partial, root = "#{@path}/")
+        if glob = details_to_glob(name, details, prefix, partial, root)
+          cached(glob) do
+            Dir[glob].map do |path|
+              next if File.directory?(path)
+              source = File.read(path)
+              identifier = Pathname.new(path).expand_path.to_s
+              
+              Template.new(source, identifier, *path_to_details(path))
+            end.compact
+          end
         end
-        template || find_template(path)
       end
-  
+    
     private
-      def create_template(file)
-        Template.new(file.split("#{self}/").last, self)
-      end
-    end
-
-    class FileSystemPath < Path
-      def initialize(path, options = {})
-        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)        
-        
-        super(options)
-        @path, @paths = path, {}
+  
+      # :api: plugin
+      def details_to_glob(name, details, prefix, partial, root)
+        path = ""
+        path << "#{prefix}/" unless prefix.empty?
+        path << (partial ? "_#{name}" : name)
+      
+        extensions = ""
+        [:locales, :formats].each do |k|
+          extensions << if exts = details[k]
+            '{' + exts.map {|e| ".#{e},"}.join + '}'
+          else
+            k == :formats ? formats_glob : ''
+          end
+        end
         
-        # **/*/** is a hax for symlinked directories
-        load_templates("#{@path}/{**/*,**}/**") if @cache
+        "#{root}#{path}#{extensions}#{handler_glob}"
       end
+      
+      # TODO: fix me
+      # :api: plugin
+      def path_to_details(path)
+        # [:erb, :format => :html, :locale => :en, :partial => true/false]
+        if m = path.match(%r'/(_)?[\w-]+(\.[\w-]+)*\.(\w+)$')
+          partial = m[1] == '_'
+          details = (m[2]||"").split('.').reject { |e| e.empty? }
+          handler = Template.handler_class_for_extension(m[3])
 
-    private
-    
-      def load_template(template)
-        template.load!
-        template.accessible_paths.each do |path|
-          @paths[path] = template
+          format  = Mime[details.last] && details.pop.to_sym
+          locale  = details.last && details.pop.to_sym
+          
+          return handler, :format => format, :locale => locale, :partial => partial
         end
       end
-    
-      def find_template(path)
-        load_templates("#{@path}/#{path}{,.*}") unless @cache
-        @paths[path]
-      end    
-    
-      def load_templates(glob)
-        Dir[glob].each do |file|
-          load_template(create_template(file)) unless File.directory?(file)
-        end
+    end
+
+    class FileSystemPathWithFallback < FileSystemPath
+      
+      def find_templates(name, details, prefix, partial)
+        templates = super
+        return super(name, details, prefix, partial, '') if templates.empty?
+        templates
       end
       
     end
diff --git a/actionpack/lib/action_view/template/template.rb b/actionpack/lib/action_view/template/template.rb
index 0d2f201458..a9897258d2 100644
--- a/actionpack/lib/action_view/template/template.rb
+++ b/actionpack/lib/action_view/template/template.rb
@@ -1,187 +1,92 @@
+# encoding: utf-8
+# This is so that templates compiled in this file are UTF-8
+
+require 'set'
 require "action_view/template/path"
 
-module ActionView #:nodoc:
+module ActionView
   class Template
     extend TemplateHandlers
-    extend ActiveSupport::Memoizable
-    
-    module Loading
-      def load!
-        @cached = true
-        # freeze
-      end    
-    end
-    include Loading    
+    attr_reader :source, :identifier, :handler, :mime_type, :details
     
-    include Renderable
-
-    # Templates that are exempt from layouts
-    @@exempt_from_layout = Set.new([/\.rjs$/])
-
-    # Don't render layouts for templates with the given extensions.
-    def self.exempt_from_layout(*extensions)
-      regexps = extensions.collect do |extension|
-        extension.is_a?(Regexp) ? extension : /\.#{Regexp.escape(extension.to_s)}$/
+    def initialize(source, identifier, handler, details)
+      @source     = source
+      @identifier = identifier
+      @handler    = handler
+      @details    = details
+
+      format = details.delete(:format) || begin
+        # TODO: Clean this up
+        handler.respond_to?(:default_format) ? handler.default_format.to_sym.to_s : "html"
       end
-      @@exempt_from_layout.merge(regexps)
-    end
-
-    attr_accessor :template_path, :filename, :load_path, :base_path
-    attr_accessor :locale, :name, :format, :extension
-    delegate :to_s, :to => :path
-
-    def initialize(template_path, load_paths = [])
-      template_path = template_path.dup
-      @load_path, @filename = find_full_path(template_path, load_paths)
-      @base_path, @name, @locale, @format, @extension = split(template_path)
-      @base_path.to_s.gsub!(/\/$/, '') # Push to split method
-
-      # Extend with partial super powers
-      extend RenderablePartial if @name =~ /^_/
+      @mime_type = Mime::Type.lookup_by_extension(format.to_s)
+      @details[:formats] = Array.wrap(format && format.to_sym)
     end
     
-    def accessible_paths
-      paths = []
-
-      if valid_extension?(extension)
-        paths << path
-        paths << path_without_extension
-        if multipart?
-          formats = format.split(".")
-          paths << "#{path_without_format_and_extension}.#{formats.first}"
-          paths << "#{path_without_format_and_extension}.#{formats.second}"
-        end
-      else
-        # template without explicit template handler should only be reachable through its exact path
-        paths << template_path
-      end
-
-      paths
-    end
-    
-    def relative_path
-      path = File.expand_path(filename)
-      path.sub!(/^#{Regexp.escape(File.expand_path(RAILS_ROOT))}\//, '') if defined?(RAILS_ROOT)
-      path
+    def render(view, locals, &blk)
+      method_name = compile(locals, view)
+      view.send(method_name, locals, &blk)
     end
-    memoize :relative_path
     
-    def source
-      File.read(filename)
+    # TODO: Figure out how to abstract this
+    def variable_name
+      identifier[%r'_?(\w+)(\.\w+)*$', 1].to_sym
     end
-    memoize :source
-    
-    def exempt_from_layout?
-      @@exempt_from_layout.any? { |exempted| path =~ exempted }
-    end    
-    
-    def path_without_extension
-      [base_path, [name, locale, format].compact.join('.')].compact.join('/')
-    end
-    memoize :path_without_extension    
 
-    def path_without_format_and_extension
-      [base_path, [name, locale].compact.join('.')].compact.join('/')
-    end
-    memoize :path_without_format_and_extension
-    
-    def path
-      [base_path, [name, locale, format, extension].compact.join('.')].compact.join('/')
-    end
-    memoize :path
-    
-    def mime_type
-      Mime::Type.lookup_by_extension(format) if format && defined?(::Mime)
+    # TODO: Figure out how to abstract this
+    def counter_name
+      "#{variable_name}_counter".to_sym
     end
-    memoize :mime_type      
     
-    def multipart?
-      format && format.include?('.')
-    end    
-    
-    def content_type
-      format.gsub('.', '/')
-    end    
-    
-  private
-    
-    def format_and_extension
-      (extensions = [format, extension].compact.join(".")).blank? ? nil : extensions
-    end
-    memoize :format_and_extension
-
-    def mtime
-      File.mtime(filename)
-    end
-    memoize :mtime
-
-    def method_segment
-      relative_path.to_s.gsub(/([^a-zA-Z0-9_])/) { $1.ord }
-    end
-    memoize :method_segment
-
-    def stale?
-      File.mtime(filename) > mtime
-    end
-
-    def recompile?
-      !@cached
+    # TODO: kill hax
+    def partial?
+      @details[:partial]
     end
 
-    def valid_extension?(extension)
-      !Template.registered_template_handler(extension).nil?
-    end
-
-    def valid_locale?(locale)
-      I18n.available_locales.include?(locale.to_sym)
-    end
+  private
 
-    def find_full_path(path, load_paths)
-      load_paths = Array(load_paths) + [nil]
-      load_paths.each do |load_path|
-        file = load_path ? "#{load_path.to_str}/#{path}" : path
-        return load_path, file if File.file?(file)
-      end
-      raise MissingTemplate.new(load_paths, path)
-    end
+    def compile(locals, view)
+      method_name = build_method_name(locals)
+      
+      return method_name if view.respond_to?(method_name)
+      
+      locals_code = locals.keys.map! { |key| "#{key} = local_assigns[:#{key}];" }.join
+
+      code = @handler.call(self)
+      encoding_comment = $1 if code.sub!(/\A(#.*coding.*)\n/, '')
+
+      source = <<-end_src
+        def #{method_name}(local_assigns)
+          old_output_buffer = output_buffer;#{locals_code};#{code}
+        ensure
+          self.output_buffer = old_output_buffer
+        end
+      end_src
 
-    # Returns file split into an array
-    #   [base_path, name, locale, format, extension]
-    def split(file)
-      if m = file.to_s.match(/^(.*\/)?([^\.]+)\.(.*)$/)
-        base_path = m[1]
-        name = m[2]
-        extensions = m[3]
+      if encoding_comment
+        source = "#{encoding_comment}\n#{source}"
+        line = -1
       else
-        return
+        line = 0
       end
 
-      locale = nil
-      format = nil
-      extension = nil
-
-      if m = extensions.split(".")
-        if valid_locale?(m[0]) && m[1] && valid_extension?(m[2]) # All three
-          locale = m[0]
-          format = m[1]
-          extension = m[2]
-        elsif m[0] && m[1] && valid_extension?(m[2]) # Multipart formats
-          format = "#{m[0]}.#{m[1]}"
-          extension = m[2]
-        elsif valid_locale?(m[0]) && valid_extension?(m[1]) # locale and extension
-          locale = m[0]
-          extension = m[1]
-        elsif valid_extension?(m[1]) # format and extension
-          format = m[0]
-          extension = m[1]
-        elsif valid_extension?(m[0]) # Just extension
-          extension = m[0]
-        else # No extension
-          format = m[0]
+      begin
+        ActionView::Base::CompiledTemplates.module_eval(source, identifier, line)
+        method_name
+      rescue Exception => e # errors from template code
+        if logger = (view && view.logger)
+          logger.debug "ERROR: compiling #{method_name} RAISED #{e}"
+          logger.debug "Function body: #{source}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
         end
-      end
 
-      [base_path, name, locale, format, extension]
+        raise ActionView::TemplateError.new(self, {}, e)
+      end
+    end
+  
+    def build_method_name(locals)
+      # TODO: is locals.keys.hash reliably the same?
+      "_render_template_#{@identifier.hash}_#{__id__}_#{locals.keys.hash}".gsub('-', "_")
     end
   end
 end
diff --git a/actionpack/lib/action_view/template/text.rb b/actionpack/lib/action_view/template/text.rb
index f81174d707..fd57b1677e 100644
--- a/actionpack/lib/action_view/template/text.rb
+++ b/actionpack/lib/action_view/template/text.rb
@@ -1,9 +1,21 @@
 module ActionView #:nodoc:
   class TextTemplate < String #:nodoc:
+
+    def initialize(string, content_type = Mime[:html])
+      super(string.to_s)
+      @content_type = Mime[content_type]
+    end
+
+    def details
+      {:formats => [@content_type.to_sym]}
+    end
+
+    def identifier() self end
     
     def render(*) self end
     
-    def exempt_from_layout?() false end
-    
+    def mime_type() @content_type end
+      
+    def partial?() false end
   end
 end
diff --git a/actionpack/lib/action_view/test_case.rb b/actionpack/lib/action_view/test_case.rb
index c8f204046b..7355af4192 100644
--- a/actionpack/lib/action_view/test_case.rb
+++ b/actionpack/lib/action_view/test_case.rb
@@ -7,19 +7,21 @@ module ActionView
       @_rendered = { :template => nil, :partials => Hash.new(0) }
       initialize_without_template_tracking(*args)
     end
-    
+
+    attr_internal :rendered
     alias_method :_render_template_without_template_tracking, :_render_template
     def _render_template(template, local_assigns = {})
-      if template.respond_to?(:path) && !template.is_a?(InlineTemplate)
-        @_rendered[:partials][template] += 1 if template.is_a?(RenderablePartial)
-        @_rendered[:template] ||= template
+      if template.respond_to?(:identifier) && template.present?
+        @_rendered[:partials][template] += 1 if template.partial?
+        @_rendered[:template] ||= []
+        @_rendered[:template] << template
       end
       _render_template_without_template_tracking(template, local_assigns)
-    end    
+    end
   end
 
   class TestCase < ActiveSupport::TestCase
-    include ActionController::TestCase::Assertions
+    include ActionDispatch::Assertions
     include ActionController::TestProcess
 
     class_inheritable_accessor :helper_class
diff --git a/actionpack/test/abstract_controller/abstract_controller_test.rb b/actionpack/test/abstract_controller/abstract_controller_test.rb
index 918062c7db..9c028e7d1e 100644
--- a/actionpack/test/abstract_controller/abstract_controller_test.rb
+++ b/actionpack/test/abstract_controller/abstract_controller_test.rb
@@ -20,14 +20,14 @@ module AbstractController
     class TestBasic < ActiveSupport::TestCase
       test "dispatching works" do
         result = Me.process(:index)
-        assert_equal "Hello world", result.response_obj[:body]
+        assert_equal "Hello world", result.response_body
       end
     end
     
     # Test Render mixin
     # ====
     class RenderingController < AbstractController::Base
-      use Renderer
+      include Renderer
 
       def _prefix() end
 
@@ -58,38 +58,38 @@ module AbstractController
       end
 
       def rendering_to_body
-        render_to_body "naked_render.erb"
+        self.response_body = render_to_body :_template_name => "naked_render.erb"
       end
 
       def rendering_to_string
-        render_to_string "naked_render.erb"
+        self.response_body = render_to_string :_template_name => "naked_render.erb"
       end
     end
     
     class TestRenderer < ActiveSupport::TestCase
       test "rendering templates works" do
         result = Me2.process(:index)
-        assert_equal "Hello from index.erb", result.response_obj[:body]
+        assert_equal "Hello from index.erb", result.response_body
       end
       
       test "rendering passes ivars to the view" do
         result = Me2.process(:action_with_ivars)
-        assert_equal "Hello from index_with_ivars.erb", result.response_obj[:body]
+        assert_equal "Hello from index_with_ivars.erb", result.response_body
       end
       
       test "rendering with no template name" do
         result = Me2.process(:naked_render)
-        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+        assert_equal "Hello from naked_render.erb", result.response_body
       end
 
       test "rendering to a rack body" do
         result = Me2.process(:rendering_to_body)
-        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+        assert_equal "Hello from naked_render.erb", result.response_body
       end
 
       test "rendering to a string" do
         result = Me2.process(:rendering_to_string)
-        assert_equal "Hello from naked_render.erb", result.response_obj[:body]
+        assert_equal "Hello from naked_render.erb", result.response_body
       end
     end
     
@@ -121,12 +121,12 @@ module AbstractController
     class TestPrefixedViews < ActiveSupport::TestCase
       test "templates are located inside their 'prefix' folder" do
         result = Me3.process(:index)
-        assert_equal "Hello from me3/index.erb", result.response_obj[:body]
+        assert_equal "Hello from me3/index.erb", result.response_body
       end
 
       test "templates included their format" do
         result = Me3.process(:formatted)
-        assert_equal "Hello from me3/formatted.html.erb", result.response_obj[:body]
+        assert_equal "Hello from me3/formatted.html.erb", result.response_body
       end
     end
     
@@ -134,26 +134,27 @@ module AbstractController
     # ====
     # self._layout is used when defined
     class WithLayouts < PrefixedViews
-      use Layouts
+      include Layouts
+      
+      def self.inherited(klass)
+        klass._write_layout_method
+        super
+      end
       
       private
       def self.layout(formats)
         begin
-          view_paths.find_by_parts(name.underscore, formats, "layouts")
+          view_paths.find_by_parts(name.underscore, {:formats => formats}, "layouts")
         rescue ActionView::MissingTemplate
           begin
-            view_paths.find_by_parts("application", formats, "layouts")
+            view_paths.find_by_parts("application", {:formats => formats}, "layouts")
           rescue ActionView::MissingTemplate
           end
         end
       end
-      
-      def _layout
-        self.class.layout(formats)
-      end      
-      
+
       def render_to_body(options = {})
-        options[:_layout] = options[:layout] || _layout
+        options[:_layout] = options[:layout] || _default_layout
         super
       end  
     end
@@ -173,12 +174,7 @@ module AbstractController
     class TestLayouts < ActiveSupport::TestCase
       test "layouts are included" do
         result = Me4.process(:index)
-        assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_obj[:body]
-      end
-      
-      test "it can fall back to the application layout" do
-        result = Me5.process(:index)
-        assert_equal "Application Enter : Hello from me5/index.erb : Exit", result.response_obj[:body]        
+        assert_equal "Me4 Enter : Hello from me4/index.erb : Exit", result.response_body
       end
     end
     
@@ -205,17 +201,16 @@ module AbstractController
       def fail()  self.response_body = "fail"    end
         
     private
-      
-      def respond_to_action?(action_name)
-        action_name != :fail
+
+      def method_for_action(action_name)
+        action_name.to_s != "fail" && action_name
       end
-      
     end
     
     class TestRespondToAction < ActiveSupport::TestCase
       
       def assert_dispatch(klass, body = "success", action = :index)
-        response = klass.process(action).response_obj[:body]
+        response = klass.process(action).response_body
         assert_equal body, response
       end
       
diff --git a/actionpack/test/abstract_controller/callbacks_test.rb b/actionpack/test/abstract_controller/callbacks_test.rb
index 5fce30f478..1de60868c3 100644
--- a/actionpack/test/abstract_controller/callbacks_test.rb
+++ b/actionpack/test/abstract_controller/callbacks_test.rb
@@ -4,7 +4,7 @@ module AbstractController
   module Testing
   
     class ControllerWithCallbacks < AbstractController::Base
-      use AbstractController::Callbacks
+      include AbstractController::Callbacks
     end
     
     class Callback1 < ControllerWithCallbacks
@@ -22,7 +22,7 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "basic callbacks work" do
         result = Callback1.process(:index)
-        assert_equal "Hello world", result.response_obj[:body]
+        assert_equal "Hello world", result.response_body
       end
     end
 
@@ -53,7 +53,7 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "before_filter works" do
         result = Callback2.process(:index)
-        assert_equal "Hello world", result.response_obj[:body]
+        assert_equal "Hello world", result.response_body
       end
       
       test "after_filter works" do
@@ -84,7 +84,7 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "before_filter works with procs" do
         result = Callback3.process(:index)
-        assert_equal "Hello world", result.response_obj[:body]
+        assert_equal "Hello world", result.response_body
       end
       
       test "after_filter works with procs" do
@@ -119,12 +119,12 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "when :only is specified, a before filter is triggered on that action" do
         result = CallbacksWithConditions.process(:index)
-        assert_equal "Hello, World", result.response_obj[:body]
+        assert_equal "Hello, World", result.response_body
       end
       
       test "when :only is specified, a before filter is not triggered on other actions" do
         result = CallbacksWithConditions.process(:sekrit_data)
-        assert_equal "true", result.response_obj[:body]
+        assert_equal "true", result.response_body
       end
       
       test "when :except is specified, an after filter is not triggered on that action" do
@@ -159,12 +159,12 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "when :only is specified with an array, a before filter is triggered on that action" do
         result = CallbacksWithArrayConditions.process(:index)
-        assert_equal "Hello, World", result.response_obj[:body]
+        assert_equal "Hello, World", result.response_body
       end
       
       test "when :only is specified with an array, a before filter is not triggered on other actions" do
         result = CallbacksWithArrayConditions.process(:sekrit_data)
-        assert_equal "true", result.response_obj[:body]
+        assert_equal "true", result.response_body
       end
       
       test "when :except is specified with an array, an after filter is not triggered on that action" do
@@ -184,12 +184,31 @@ module AbstractController
     class TestCallbacks < ActiveSupport::TestCase
       test "when a callback is modified in a child with :only, it works for the :only action" do
         result = ChangedConditions.process(:index)
-        assert_equal "Hello world", result.response_obj[:body]
+        assert_equal "Hello world", result.response_body
       end
       
       test "when a callback is modified in a child with :only, it does not work for other actions" do
         result = ChangedConditions.process(:not_index)
-        assert_equal "", result.response_obj[:body]        
+        assert_equal "", result.response_body        
+      end
+    end
+    
+    class SetsResponseBody < ControllerWithCallbacks
+      before_filter :set_body
+      
+      def index
+        self.response_body = "Fail"
+      end
+      
+      def set_body
+        self.response_body = "Success"
+      end
+    end
+    
+    class TestHalting < ActiveSupport::TestCase
+      test "when a callback sets the response body, the action should not be invoked" do
+        result = SetsResponseBody.process(:index)
+        assert_equal "Success", result.response_body
       end
     end
     
diff --git a/actionpack/test/abstract_controller/helper_test.rb b/actionpack/test/abstract_controller/helper_test.rb
index 6284fa4f70..f91aefe606 100644
--- a/actionpack/test/abstract_controller/helper_test.rb
+++ b/actionpack/test/abstract_controller/helper_test.rb
@@ -4,8 +4,8 @@ module AbstractController
   module Testing
   
     class ControllerWithHelpers < AbstractController::Base
-      use Renderer
-      use Helpers
+      include Renderer
+      include Helpers
       
       def render(string)
         super(:_template_name => string)
@@ -35,7 +35,7 @@ module AbstractController
     class TestHelpers < ActiveSupport::TestCase
       def test_helpers
         result = MyHelpers1.process(:index)
-        assert_equal "Hello World : Included", result.response_obj[:body]
+        assert_equal "Hello World : Included", result.response_body
       end
     end
     
diff --git a/actionpack/test/abstract_controller/layouts_test.rb b/actionpack/test/abstract_controller/layouts_test.rb
index 3d4570bfef..d3440c3de0 100644
--- a/actionpack/test/abstract_controller/layouts_test.rb
+++ b/actionpack/test/abstract_controller/layouts_test.rb
@@ -1,14 +1,15 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+require 'active_support/core_ext/class/removal'
 
 module AbstractControllerTests
   module Layouts
 
     # Base controller for these tests
     class Base < AbstractController::Base
-      use AbstractController::Renderer
-      use AbstractController::Layouts
-      
-      self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+      include AbstractController::Renderer
+      include AbstractController::Layouts
+
+      self.view_paths = [ActionView::Template::FixturePath.new(
         "layouts/hello.erb"                     => "With String <%= yield %>",
         "layouts/hello_override.erb"            => "With Override <%= yield %>",
         "layouts/abstract_controller_tests/layouts/with_string_implied_child.erb" =>
@@ -152,12 +153,12 @@ module AbstractControllerTests
     class TestBase < ActiveSupport::TestCase
       test "when no layout is specified, and no default is available, render without a layout" do
         result = Blank.process(:index)
-        assert_equal "Hello blank!", result.response_obj[:body]
+        assert_equal "Hello blank!", result.response_body
       end
       
       test "when layout is specified as a string, render with that layout" do
         result = WithString.process(:index)
-        assert_equal "With String Hello string!", result.response_obj[:body]
+        assert_equal "With String Hello string!", result.response_body
       end
       
       test "when layout is specified as a string, but the layout is missing, raise an exception" do
@@ -166,22 +167,22 @@ module AbstractControllerTests
       
       test "when layout is specified as false, do not use a layout" do
         result = WithFalseLayout.process(:index)
-        assert_equal "Hello false!", result.response_obj[:body]
+        assert_equal "Hello false!", result.response_body
       end
       
       test "when layout is specified as nil, do not use a layout" do
         result = WithNilLayout.process(:index)
-        assert_equal "Hello nil!", result.response_obj[:body]
+        assert_equal "Hello nil!", result.response_body
       end
       
       test "when layout is specified as a symbol, call the requested method and use the layout returned" do
         result = WithSymbol.process(:index)
-        assert_equal "OMGHI2U Hello symbol!", result.response_obj[:body]
+        assert_equal "OMGHI2U Hello symbol!", result.response_body
       end
       
       test "when layout is specified as a symbol and the method returns nil, don't use a layout" do
         result = WithSymbolReturningNil.process(:index)
-        assert_equal "Hello nilz!", result.response_obj[:body]
+        assert_equal "Hello nilz!", result.response_body
       end
       
       test "when the layout is specified as a symbol and the method doesn't exist, raise an exception" do
@@ -194,28 +195,28 @@ module AbstractControllerTests
       
       test "when a child controller does not have a layout, use the parent controller layout" do
         result = WithStringChild.process(:index)
-        assert_equal "With String Hello string!", result.response_obj[:body]
+        assert_equal "With String Hello string!", result.response_body
       end
       
       test "when a child controller has specified a layout, use that layout and not the parent controller layout" do
         result = WithStringOverriddenChild.process(:index)
-        assert_equal "With Override Hello string!", result.response_obj[:body]
+        assert_equal "With Override Hello string!", result.response_body
       end
       
       test "when a child controller has an implied layout, use that layout and not the parent controller layout" do
         result = WithStringImpliedChild.process(:index)
-        assert_equal "With Implied Hello string!", result.response_obj[:body]
+        assert_equal "With Implied Hello string!", result.response_body
       end
       
       test "when a child controller specifies layout nil, do not use the parent layout" do
         result = WithNilChild.process(:index)
-        assert_equal "Hello string!", result.response_obj[:body]
+        assert_equal "Hello string!", result.response_body
       end
             
       test "when a grandchild has no layout specified, the child has an implied layout, and the " \
         "parent has specified a layout, use the child controller layout" do
           result = WithChildOfImplied.process(:index)
-          assert_equal "With Implied Hello string!", result.response_obj[:body]
+          assert_equal "With Implied Hello string!", result.response_body
       end
       
       test "raises an exception when specifying layout true" do
diff --git a/actionpack/test/abstract_controller/test_helper.rb b/actionpack/test/abstract_controller/test_helper.rb
index b9248c6bbd..915054f7fb 100644
--- a/actionpack/test/abstract_controller/test_helper.rb
+++ b/actionpack/test/abstract_controller/test_helper.rb
@@ -2,11 +2,14 @@ $:.unshift(File.dirname(__FILE__) + '/../../lib')
 $:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
+require 'rubygems'
 require 'test/unit'
 require 'active_support'
 require 'active_support/test_case'
-require 'action_controller'
+require 'action_controller/abstract'
+require 'action_view'
 require 'action_view/base'
+require 'action_dispatch'
 require 'fixture_template'
 
 begin
@@ -16,10 +19,3 @@ begin
 rescue LoadError
   # Debugging disabled. `gem install ruby-debug` to enable.
 end
-
-require 'action_controller/abstract'
-# require 'action_controller/abstract/base'
-# require 'action_controller/abstract/renderer'
-# require 'action_controller/abstract/layouts'
-# require 'action_controller/abstract/callbacks'
-# require 'action_controller/abstract/helpers'
\ No newline at end of file
diff --git a/actionpack/test/abstract_unit.rb b/actionpack/test/abstract_unit.rb
index b07e6e5f3a..c71da7fa6c 100644
--- a/actionpack/test/abstract_unit.rb
+++ b/actionpack/test/abstract_unit.rb
@@ -1,3 +1,7 @@
+if ENV['new_base']
+  puts *caller
+  raise 'new_base/abstract_unit already loaded'
+end
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 $:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib')
 $:.unshift(File.dirname(__FILE__) + '/fixtures/helpers')
@@ -23,6 +27,8 @@ require 'action_controller'
 require 'action_controller/testing/process'
 require 'action_view/test_case'
 
+$tags[:old_base] = true
+
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
 
@@ -34,7 +40,7 @@ ActionController::Base.session_store = nil
 # Register danish language for testing
 I18n.backend.store_translations 'da', {}
 I18n.backend.store_translations 'pt-BR', {}
-ORIGINAL_LOCALES = I18n.available_locales.map(&:to_s).sort
+ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
 
 FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), 'fixtures')
 ActionController::Base.view_paths = FIXTURE_LOAD_PATH
diff --git a/actionpack/test/activerecord/active_record_store_test.rb b/actionpack/test/activerecord/active_record_store_test.rb
index 34f18806a2..9ac33b3417 100644
--- a/actionpack/test/activerecord/active_record_store_test.rb
+++ b/actionpack/test/activerecord/active_record_store_test.rb
@@ -13,6 +13,7 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
     end
 
     def set_session_value
+      raise "missing session!" unless session
       session[:foo] = params[:foo] || "bar"
       head :ok
     end
@@ -21,15 +22,20 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
       render :text => "foo: #{session[:foo].inspect}"
     end
 
+    def set_cookie_and_get_session_value
+      cookies["kittens"] = { :value => "fluffy" }
+      render :text => "foo: #{session[:foo].inspect}"
+    end
+
     def get_session_id
       session[:foo]
       render :text => "#{request.session_options[:id]}"
     end
 
     def call_reset_session
-      session[:bar]
+      session[:foo]
       reset_session
-      session[:bar] = "baz"
+      session[:foo] = "baz"
       head :ok
     end
 
@@ -77,6 +83,23 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
     end
   end
 
+  def test_getting_session_value_does_not_set_cookie
+    with_test_route_set do
+      get '/get_session_value'
+      assert_response :success
+      assert_equal "", headers["Set-Cookie"]
+    end
+  end
+
+  def test_getting_session_value_and_setting_a_cookie_doesnt_delete_all_cookies
+    with_test_route_set do
+      get '/set_cookie_and_get_session_value'
+      assert_response :success
+      assert_equal 'foo: nil', response.body
+      assert_equal({"kittens" => "fluffy"}, response.cookies)
+    end
+  end
+
   def test_setting_session_value_after_session_reset
     with_test_route_set do
       get '/set_session_value'
@@ -90,7 +113,7 @@ class ActiveRecordStoreTest < ActionController::IntegrationTest
 
       get '/get_session_value'
       assert_response :success
-      assert_equal 'foo: nil', response.body
+      assert_equal 'foo: "baz"', response.body
 
       get '/get_session_id'
       assert_response :success
diff --git a/actionpack/test/activerecord/polymorphic_routes_test.rb b/actionpack/test/activerecord/polymorphic_routes_test.rb
index 35139fbb7f..b9f5be2361 100644
--- a/actionpack/test/activerecord/polymorphic_routes_test.rb
+++ b/actionpack/test/activerecord/polymorphic_routes_test.rb
@@ -1,4 +1,5 @@
 require 'active_record_unit'
+require 'fixtures/project'
 
 class Task < ActiveRecord::Base
   set_table_name 'projects'
diff --git a/actionpack/test/adv_attr_test.rb b/actionpack/test/adv_attr_test.rb
deleted file mode 100644
index fdda4ad92d..0000000000
--- a/actionpack/test/adv_attr_test.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-require File.dirname(__FILE__) + '/abstract_unit'
-require 'action_mailer/adv_attr_accessor'
-
-class AdvAttrTest < Test::Unit::TestCase
-  class Person
-    include ActionMailer::AdvAttrAccessor
-    adv_attr_accessor :name
-  end
-
-  def test_adv_attr
-    bob = Person.new
-    assert_nil bob.name
-    bob.name 'Bob'
-    assert_equal 'Bob', bob.name
-
-    assert_raise(ArgumentError) {bob.name 'x', 'y'}
-  end
-
-
-end
\ No newline at end of file
diff --git a/actionpack/test/controller/action_pack_assertions_test.rb b/actionpack/test/controller/action_pack_assertions_test.rb
index 96f7a42c9b..24686ab4b6 100644
--- a/actionpack/test/controller/action_pack_assertions_test.rb
+++ b/actionpack/test/controller/action_pack_assertions_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'action_controller/vendor/html-scanner'
 
 # a controller class to facilitate the tests
 class ActionPackAssertionsController < ActionController::Base
@@ -12,6 +13,9 @@ class ActionPackAssertionsController < ActionController::Base
   # a standard template
   def hello_xml_world() render :template => "test/hello_xml_world"; end
 
+  # a standard partial
+  def partial() render :partial => 'test/partial'; end
+
   # a redirect to an internal location
   def redirect_internal() redirect_to "/nothing"; end
 
@@ -292,47 +296,73 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
   # make sure that the template objects exist
   def test_template_objects_alive
     process :assign_this
-    assert !@response.has_template_object?('hi')
-    assert @response.has_template_object?('howdy')
+    assert !@controller.template.instance_variable_get(:"@hi")
+    assert @controller.template.instance_variable_get(:"@howdy")
   end
 
   # make sure we don't have template objects when we shouldn't
   def test_template_object_missing
     process :nothing
-    assert_nil @response.template_objects['howdy']
+    assert_nil @controller.template.assigns['howdy']
   end
 
   # check the empty flashing
   def test_flash_me_naked
     process :flash_me_naked
-    assert !@response.has_flash?
-    assert !@response.has_flash_with_contents?
+    assert_deprecated do
+      assert !@response.has_flash?
+      assert !@response.has_flash_with_contents?
+    end
   end
 
   # check if we have flash objects
   def test_flash_haves
     process :flash_me
-    assert @response.has_flash?
-    assert @response.has_flash_with_contents?
-    assert @response.has_flash_object?('hello')
+    assert_deprecated do
+      assert @response.has_flash?
+      assert @response.has_flash_with_contents?
+      assert @response.has_flash_object?('hello')
+    end
   end
 
   # ensure we don't have flash objects
   def test_flash_have_nots
     process :nothing
-    assert !@response.has_flash?
-    assert !@response.has_flash_with_contents?
-    assert_nil @response.flash['hello']
+    assert_deprecated do
+      assert !@response.has_flash?
+      assert !@response.has_flash_with_contents?
+      assert_nil @response.flash['hello']
+    end
+  end
+
+  def test_assert_template_with_partial
+    get :partial
+    assert_template :partial => '_partial'
+  end
+
+  def test_assert_template_with_nil
+    get :nothing
+    assert_template nil
+  end
+
+  def test_assert_template_with_string
+    get :hello_world
+    assert_template 'hello_world'
+  end
+
+  def test_assert_template_with_symbol
+    get :hello_world
+    assert_template :hello_world
   end
 
   # check if we were rendered by a file-based template?
   def test_rendered_action
     process :nothing
-    assert_nil @response.rendered[:template]
+    assert_nil @controller.template.rendered[:template]
 
     process :hello_world
-    assert @response.rendered[:template]
-    assert 'hello_world', @response.rendered[:template].to_s
+    assert @controller.template.rendered[:template]
+    assert 'hello_world', @controller.template.rendered[:template].to_s
   end
 
   # check the redirection location
@@ -378,10 +408,12 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
   def test_redirect_url_match
     process :redirect_external
     assert @response.redirect?
-    assert @response.redirect_url_match?("rubyonrails")
-    assert @response.redirect_url_match?(/rubyonrails/)
-    assert !@response.redirect_url_match?("phpoffrails")
-    assert !@response.redirect_url_match?(/perloffrails/)
+    assert_deprecated do
+      assert @response.redirect_url_match?("rubyonrails")
+      assert @response.redirect_url_match?(/rubyonrails/)
+      assert !@response.redirect_url_match?("phpoffrails")
+      assert !@response.redirect_url_match?(/perloffrails/)
+    end
   end
 
   # check for a redirection
@@ -413,7 +445,6 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
     assert_equal "Mr. David", @response.body
   end
 
-
   def test_assert_redirection_fails_with_incorrect_controller
     process :redirect_to_controller
     assert_raise(ActiveSupport::TestCase::Assertion) do
@@ -481,7 +512,7 @@ class ActionPackAssertionsControllerTest < ActionController::TestCase
     get :index
     assert_response :success
     flunk 'Expected non-success response'
-  rescue ActiveSupport::TestCase::Assertion => e
+  rescue RuntimeError => e
     assert e.message.include?('FAIL')
   end
 
@@ -506,9 +537,11 @@ class ActionPackHeaderTest < ActionController::TestCase
   end
 
   def test_rendering_xml_respects_content_type
-    @response.headers['type'] = 'application/pdf'
-    process :hello_xml_world
-    assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
+    pending do
+      @response.headers['type'] = 'application/pdf'
+      process :hello_xml_world
+      assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
+    end
   end
 
   def test_render_text_with_custom_content_type
diff --git a/actionpack/test/controller/addresses_render_test.rb b/actionpack/test/controller/addresses_render_test.rb
index 2f092b6731..2d2a2745b0 100644
--- a/actionpack/test/controller/addresses_render_test.rb
+++ b/actionpack/test/controller/addresses_render_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'logger'
 
 class Address
   def Address.count(conditions = nil, join = nil)
diff --git a/actionpack/test/controller/base_test.rb b/actionpack/test/controller/base_test.rb
index f4517d06c4..3a4cdb81d9 100644
--- a/actionpack/test/controller/base_test.rb
+++ b/actionpack/test/controller/base_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'logger'
 require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
 
 # Provide some controller to run the tests on.
@@ -27,6 +28,7 @@ class EmptyController < ActionController::Base
 end
 class NonEmptyController < ActionController::Base
   def public_action
+    render :nothing => true
   end
   
   hide_action :hidden_action
@@ -51,6 +53,7 @@ end
 
 class DefaultUrlOptionsController < ActionController::Base
   def default_url_options_action
+    render :nothing => true
   end
 
   def default_url_options(options = nil)
@@ -114,7 +117,7 @@ class PerformActionTest < ActionController::TestCase
     end
 
     def method_missing(method, *args)
-      @logged << args.first
+      @logged << args.first.to_s
     end
   end
 
@@ -151,11 +154,8 @@ class PerformActionTest < ActionController::TestCase
   
   def test_get_on_hidden_should_fail
     use_controller NonEmptyController
-    get :hidden_action
-    assert_response 404
-    
-    get :another_hidden_action
-    assert_response 404
+    assert_raise(ActionController::UnknownAction) { get :hidden_action }
+    assert_raise(ActionController::UnknownAction) { get :another_hidden_action }
   end
 
   def test_namespaced_action_should_log_module_name
diff --git a/actionpack/test/controller/caching_test.rb b/actionpack/test/controller/caching_test.rb
index b61a58dd09..c286976315 100644
--- a/actionpack/test/controller/caching_test.rb
+++ b/actionpack/test/controller/caching_test.rb
@@ -1,5 +1,6 @@
 require 'fileutils'
 require 'abstract_unit'
+require 'active_record_unit'
 
 CACHE_DIR = 'test_cache'
 # Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
@@ -47,6 +48,8 @@ class PageCachingTest < ActionController::TestCase
     super
     ActionController::Base.perform_caching = true
 
+    ActionController::Routing::Routes.clear!
+
     ActionController::Routing::Routes.draw do |map|
       map.main '', :controller => 'posts'
       map.formatted_posts 'posts.:format', :controller => 'posts'
@@ -110,7 +113,7 @@ class PageCachingTest < ActionController::TestCase
   end
 
   def test_should_cache_ok_at_custom_path
-    @request.stubs(:path).returns("/index.html")
+    @request.request_uri = "/index.html"
     get :ok
     assert_response :ok
     assert File.exist?("#{FILE_STORE_PATH}/index.html")
@@ -148,11 +151,15 @@ class PageCachingTest < ActionController::TestCase
 end
 
 class ActionCachingTestController < ActionController::Base
+  rescue_from(Exception) { head 500 }
+  rescue_from(ActiveRecord::RecordNotFound) { head :not_found }
+
   caches_action :index, :redirected, :forbidden, :if => Proc.new { |c| !c.request.format.json? }, :expires_in => 1.hour
   caches_action :show, :cache_path => 'http://test.host/custom/show'
   caches_action :edit, :cache_path => Proc.new { |c| c.params[:id] ? "http://test.host/#{c.params[:id]};edit" : "http://test.host/edit" }
   caches_action :with_layout
   caches_action :layout_false, :layout => false
+  caches_action :record_not_found, :four_oh_four, :simple_runtime_error
 
   layout 'talk_from_action.erb'
 
@@ -175,6 +182,18 @@ class ActionCachingTestController < ActionController::Base
     render :text => @cache_this, :layout => true
   end
 
+  def record_not_found
+    raise ActiveRecord::RecordNotFound, "oops!"
+  end
+
+  def four_oh_four
+    render :text => "404'd!", :status => 404
+  end
+
+  def simple_runtime_error
+    raise "oops!"
+  end
+
   alias_method :show, :index
   alias_method :edit, :index
   alias_method :destroy, :index
@@ -345,7 +364,7 @@ class ActionCacheTest < ActionController::TestCase
     cached_time = content_to_cache
     reset!
 
-    @request.set_REQUEST_URI "/action_caching_test/expire.xml"
+    @request.request_uri = "/action_caching_test/expire.xml"
     get :expire, :format => :xml
     reset!
 
@@ -458,6 +477,27 @@ class ActionCacheTest < ActionController::TestCase
     assert_response :success
   end
 
+  def test_record_not_found_returns_404_for_multiple_requests
+    get :record_not_found
+    assert_response 404
+    get :record_not_found
+    assert_response 404
+  end
+
+  def test_four_oh_four_returns_404_for_multiple_requests
+    get :four_oh_four
+    assert_response 404
+    get :four_oh_four
+    assert_response 404
+  end
+
+  def test_simple_runtime_error_returns_500_for_multiple_requests
+    get :simple_runtime_error
+    assert_response 500
+    get :simple_runtime_error
+    assert_response 500
+  end
+
   private
     def content_to_cache
       assigns(:cache_this)
diff --git a/actionpack/test/controller/capture_test.rb b/actionpack/test/controller/capture_test.rb
index 9a0976ca9f..06a5af6b32 100644
--- a/actionpack/test/controller/capture_test.rb
+++ b/actionpack/test/controller/capture_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'logger'
 
 class CaptureController < ActionController::Base
   def self.controller_name; "test"; end
diff --git a/actionpack/test/controller/content_type_test.rb b/actionpack/test/controller/content_type_test.rb
index 7377546631..d622ac1e85 100644
--- a/actionpack/test/controller/content_type_test.rb
+++ b/actionpack/test/controller/content_type_test.rb
@@ -1,24 +1,29 @@
 require 'abstract_unit'
 
 class ContentTypeController < ActionController::Base
+  # :ported:
   def render_content_type_from_body
     response.content_type = Mime::RSS
     render :text => "hello world!"
   end
 
+  # :ported:
   def render_defaults
     render :text => "hello world!"
   end
 
+  # :ported:
   def render_content_type_from_render
     render :text => "hello world!", :content_type => Mime::RSS
   end
 
+  # :ported:
   def render_charset_from_body
     response.charset = "utf-16"
     render :text => "hello world!"
   end
 
+  # :ported:
   def render_nil_charset_from_body
     response.charset = nil
     render :text => "hello world!"
@@ -60,6 +65,7 @@ class ContentTypeTest < ActionController::TestCase
     @controller.logger = Logger.new(nil)
   end
 
+  # :ported:
   def test_render_defaults
     get :render_defaults
     assert_equal "utf-8", @response.charset
@@ -74,24 +80,28 @@ class ContentTypeTest < ActionController::TestCase
     ContentTypeController.default_charset = "utf-8"
   end
 
+  # :ported:
   def test_content_type_from_body
     get :render_content_type_from_body
     assert_equal "application/rss+xml", @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
+  # :ported:
   def test_content_type_from_render
     get :render_content_type_from_render
     assert_equal "application/rss+xml", @response.content_type
     assert_equal "utf-8", @response.charset
   end
 
+  # :ported:
   def test_charset_from_body
     get :render_charset_from_body
     assert_equal Mime::HTML, @response.content_type
     assert_equal "utf-16", @response.charset
   end
 
+  # :ported:
   def test_nil_charset_from_body
     get :render_nil_charset_from_body
     assert_equal Mime::HTML, @response.content_type
@@ -138,12 +148,13 @@ class AcceptBasedContentTypeTest < ActionController::TestCase
 
   def setup
     super
+    @_old_accept_header = ActionController::Base.use_accept_header
     ActionController::Base.use_accept_header = true
   end
 
   def teardown
     super
-    ActionController::Base.use_accept_header = false
+    ActionController::Base.use_accept_header = @_old_accept_header
   end
 
 
diff --git a/actionpack/test/controller/cookie_test.rb b/actionpack/test/controller/cookie_test.rb
index c861982698..7199da3441 100644
--- a/actionpack/test/controller/cookie_test.rb
+++ b/actionpack/test/controller/cookie_test.rb
@@ -4,44 +4,48 @@ class CookieTest < ActionController::TestCase
   class TestController < ActionController::Base
     def authenticate
       cookies["user_name"] = "david"
+      head :ok
     end
 
     def set_with_with_escapable_characters
       cookies["that & guy"] = "foo & bar => baz"
+      head :ok
     end
 
     def authenticate_for_fourteen_days
       cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
+      head :ok
     end
 
     def authenticate_for_fourteen_days_with_symbols
       cookies[:user_name] = { :value => "david", :expires => Time.utc(2005, 10, 10,5) }
+      head :ok
     end
 
     def set_multiple_cookies
       cookies["user_name"] = { "value" => "david", "expires" => Time.utc(2005, 10, 10,5) }
       cookies["login"]     = "XJ-122"
+      head :ok
     end
 
     def access_frozen_cookies
       cookies["will"] = "work"
+      head :ok
     end
 
     def logout
       cookies.delete("user_name")
+      head :ok
     end
 
     def delete_cookie_with_path
       cookies.delete("user_name", :path => '/beaten')
-      render :text => "hello world"
+      head :ok
     end
 
     def authenticate_with_http_only
       cookies["user_name"] = { :value => "david", :httponly => true }
-    end
-
-    def rescue_action(e)
-      raise unless ActionView::MissingTemplate # No templates here, and we don't care about the output
+      head :ok
     end
   end
 
@@ -54,39 +58,38 @@ class CookieTest < ActionController::TestCase
 
   def test_setting_cookie
     get :authenticate
-    assert_equal ["user_name=david; path=/"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=david; path=/"
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
   def test_setting_with_escapable_characters
     get :set_with_with_escapable_characters
-    assert_equal ["that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"], @response.headers["Set-Cookie"]
+    assert_cookie_header "that+%26+guy=foo+%26+bar+%3D%3E+baz; path=/"
     assert_equal({"that & guy" => "foo & bar => baz"}, @response.cookies)
   end
 
   def test_setting_cookie_for_fourteen_days
     get :authenticate_for_fourteen_days
-    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
   def test_setting_cookie_for_fourteen_days_with_symbols
     get :authenticate_for_fourteen_days_with_symbols
-    assert_equal ["user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT"
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
   def test_setting_cookie_with_http_only
     get :authenticate_with_http_only
-    assert_equal ["user_name=david; path=/; HttpOnly"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=david; path=/; HttpOnly"
     assert_equal({"user_name" => "david"}, @response.cookies)
   end
 
   def test_multiple_cookies
     get :set_multiple_cookies
     assert_equal 2, @response.cookies.size
-    assert_equal "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT", @response.headers["Set-Cookie"][0]
-    assert_equal "login=XJ-122; path=/", @response.headers["Set-Cookie"][1]
+    assert_cookie_header "user_name=david; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT\nlogin=XJ-122; path=/"
     assert_equal({"login" => "XJ-122", "user_name" => "david"}, @response.cookies)
   end
 
@@ -96,7 +99,7 @@ class CookieTest < ActionController::TestCase
 
   def test_expiring_cookie
     get :logout
-    assert_equal ["user_name=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=; path=/; expires=Thu, 01-Jan-1970 00:00:00 GMT"
     assert_equal({"user_name" => nil}, @response.cookies)
   end
 
@@ -117,6 +120,22 @@ class CookieTest < ActionController::TestCase
 
   def test_delete_cookie_with_path
     get :delete_cookie_with_path
-    assert_equal ["user_name=; path=/beaten; expires=Thu, 01-Jan-1970 00:00:00 GMT"], @response.headers["Set-Cookie"]
+    assert_cookie_header "user_name=; path=/beaten; expires=Thu, 01-Jan-1970 00:00:00 GMT"
+  end
+
+  def test_cookies_persist_throughout_request
+    get :authenticate
+    cookies = @controller.send(:cookies)
+    assert_equal 'david', cookies['user_name']
   end
+  
+  private
+    def assert_cookie_header(expected)
+      header = @response.headers["Set-Cookie"]
+      if header.respond_to?(:to_str)
+        assert_equal expected, header
+      else
+        assert_equal expected.split("\n"), header
+      end
+    end
 end
diff --git a/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb b/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb
index dd69a63020..0c02afea36 100644
--- a/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb
+++ b/actionpack/test/controller/deprecation/deprecated_base_methods_test.rb
@@ -15,12 +15,6 @@ class DeprecatedBaseMethodsTest < ActionController::TestCase
 
   tests Target
 
-  def test_log_error_silences_deprecation_warnings
-    get :raises_name_error
-  rescue => e
-    assert_not_deprecated { @controller.send :log_error, e }
-  end
-
   if defined? Test::Unit::Error
     def test_assertion_failed_error_silences_deprecation_warnings
       get :raises_name_error
diff --git a/actionpack/test/controller/dispatcher_test.rb b/actionpack/test/controller/dispatcher_test.rb
index 569d698a03..9fae1fcf63 100644
--- a/actionpack/test/controller/dispatcher_test.rb
+++ b/actionpack/test/controller/dispatcher_test.rb
@@ -6,20 +6,20 @@ class DispatcherTest < Test::Unit::TestCase
   def setup
     ENV['REQUEST_METHOD'] = 'GET'
 
-    Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
-      middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb"))
-      middleware.instance_eval(File.read(middlewares))
-    end
-
     # Clear callbacks as they are redefined by Dispatcher#define_dispatcher_callbacks
-    Dispatcher.instance_variable_set("@prepare_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
-    Dispatcher.instance_variable_set("@before_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
-    Dispatcher.instance_variable_set("@after_dispatch_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.instance_variable_set("@prepare_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.instance_variable_set("@before_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    ActionDispatch::Callbacks.instance_variable_set("@after_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
 
+    @old_router, Dispatcher.router = Dispatcher.router, mock()
+    Dispatcher.router.stubs(:call).returns([200, {}, 'response'])
+    Dispatcher.router.stubs(:reload)
     Dispatcher.stubs(:require_dependency)
   end
 
   def teardown
+    Dispatcher.router = @old_router
+    @dispatcher = nil
     ENV.delete 'REQUEST_METHOD'
   end
 
@@ -29,12 +29,12 @@ class DispatcherTest < Test::Unit::TestCase
   end
 
   def test_reloads_routes_before_dispatch_if_in_loading_mode
-    ActionController::Routing::Routes.expects(:reload).once
+    Dispatcher.router.expects(:reload).once
     dispatch(false)
   end
 
   def test_leaves_dependencies_after_dispatch_if_not_in_loading_mode
-    ActionController::Routing::Routes.expects(:reload).never
+    Dispatcher.router.expects(:reload).never
     ActiveSupport::Dependencies.expects(:clear).never
 
     dispatch
@@ -45,19 +45,6 @@ class DispatcherTest < Test::Unit::TestCase
     def log_failsafe_exception(status, exception); end
   end
 
-  def test_failsafe_response
-    Dispatcher.any_instance.expects(:_call).raises('b00m')
-    ActionDispatch::Failsafe.any_instance.expects(:log_failsafe_exception)
-
-    assert_nothing_raised do
-      assert_equal [
-        500,
-        {"Content-Type" => "text/html"},
-        "<html><body><h1>500 Internal Server Error</h1></body></html>"
-      ], dispatch
-    end
-  end
-
   def test_prepare_callbacks
     a = b = c = nil
     Dispatcher.to_prepare { |*args| a = b = c = 1 }
@@ -68,7 +55,7 @@ class DispatcherTest < Test::Unit::TestCase
     assert_nil a || b || c
 
     # Run callbacks
-    Dispatcher.run_prepare_callbacks
+    dispatch
 
     assert_equal 1, a
     assert_equal 2, b
@@ -85,16 +72,22 @@ class DispatcherTest < Test::Unit::TestCase
     Dispatcher.to_prepare(:unique_id) { |*args| a = b = 1 }
     Dispatcher.to_prepare(:unique_id) { |*args| a = 2 }
 
-    Dispatcher.run_prepare_callbacks
+    dispatch
     assert_equal 2, a
     assert_equal nil, b
   end
 
   private
     def dispatch(cache_classes = true)
-      ActionController::Routing::RouteSet.any_instance.stubs(:call).returns([200, {}, 'response'])
+      ActionController::Dispatcher.prepare_each_request = false
       Dispatcher.define_dispatcher_callbacks(cache_classes)
-      Dispatcher.new.call({'rack.input' => StringIO.new('')})
+      Dispatcher.middleware = ActionDispatch::MiddlewareStack.new do |middleware|
+        middlewares = File.expand_path(File.join(File.dirname(__FILE__), "../../lib/action_controller/dispatch/middlewares.rb"))
+        middleware.instance_eval(File.read(middlewares))
+      end
+
+      @dispatcher ||= Dispatcher.new
+      @dispatcher.call({'rack.input' => StringIO.new(''), 'action_dispatch.show_exceptions' => false})
     end
 
     def assert_subclasses(howmany, klass, message = klass.subclasses.inspect)
diff --git a/actionpack/test/controller/filter_params_test.rb b/actionpack/test/controller/filter_params_test.rb
index 0b259a7980..8c9e4f81de 100644
--- a/actionpack/test/controller/filter_params_test.rb
+++ b/actionpack/test/controller/filter_params_test.rb
@@ -1,13 +1,30 @@
 require 'abstract_unit'
 
 class FilterParamController < ActionController::Base
+  def payment
+    head :ok
+  end
 end
 
-class FilterParamTest < Test::Unit::TestCase
-  def setup
-    @controller = FilterParamController.new
+class FilterParamTest < ActionController::TestCase
+  tests FilterParamController
+
+  class MockLogger
+    attr_reader :logged
+    attr_accessor :level
+    
+    def initialize
+      @level = Logger::DEBUG
+    end
+    
+    def method_missing(method, *args)
+      @logged ||= []
+      @logged << args.first
+    end
   end
 
+  setup :set_logger
+
   def test_filter_parameters
     assert FilterParamController.respond_to?(:filter_parameter_logging)
     assert !@controller.respond_to?(:filter_parameters)
@@ -46,4 +63,26 @@ class FilterParamTest < Test::Unit::TestCase
     assert !FilterParamController.action_methods.include?('filter_parameters')
     assert_raise(NoMethodError) { @controller.filter_parameters([{'password' => '[FILTERED]'}]) }
   end
+
+  def test_filter_parameters_inside_logs
+    FilterParamController.filter_parameter_logging(:lifo, :amount)
+
+    get :payment, :lifo => 'Pratik', :amount => '420', :step => '1'
+
+    filtered_params_logs = logs.detect {|l| l =~ /\AParameters/ }
+
+    assert filtered_params_logs.index('"amount"=>"[FILTERED]"')
+    assert filtered_params_logs.index('"lifo"=>"[FILTERED]"')
+    assert filtered_params_logs.index('"step"=>"1"')
+  end
+
+  private
+
+  def set_logger
+    @controller.logger = MockLogger.new
+  end
+  
+  def logs
+    @logs ||= @controller.logger.logged.compact.map {|l| l.to_s.strip}
+  end
 end
diff --git a/actionpack/test/controller/filters_test.rb b/actionpack/test/controller/filters_test.rb
index e83fde2349..b0b7274690 100644
--- a/actionpack/test/controller/filters_test.rb
+++ b/actionpack/test/controller/filters_test.rb
@@ -1,7 +1,37 @@
 require 'abstract_unit'
+require 'active_support/core_ext/symbol'
+
+class ActionController::Base
+  class << self
+    %w(append_around_filter prepend_after_filter prepend_around_filter prepend_before_filter skip_after_filter skip_before_filter skip_filter).each do |pending|
+      define_method(pending) do |*args|
+        $stderr.puts "#{pending} unimplemented: #{args.inspect}"
+      end unless method_defined?(pending)
+    end
+
+    if defined?(ActionController::Http)
+      def before_filters
+        filters = _process_action_callbacks.select { |c| c.kind == :before }
+        filters.map! { |c| c.instance_variable_get(:@raw_filter) }
+      end
+    end
+  end
+
+  if defined?(ActionController::Http)
+    def assigns(key = nil)
+      assigns = {}
+      instance_variable_names.each do |ivar|
+        next if ActionController::Base.protected_instance_variables.include?(ivar)
+        assigns[ivar[1..-1]] = instance_variable_get(ivar)
+      end
+
+      key.nil? ? assigns : assigns[key.to_s]
+    end
+  end
+end
+
+class FilterTest < ActionController::TestCase
 
-# FIXME: crashes Ruby 1.9
-class FilterTest < Test::Unit::TestCase
   class TestController < ActionController::Base
     before_filter :ensure_login
     after_filter  :clean_up
@@ -139,14 +169,6 @@ class FilterTest < Test::Unit::TestCase
     before_filter :clean_up_tmp, :if => Proc.new { |c| false }
   end
 
-  class EmptyFilterChainController < TestController
-    self.filter_chain.clear
-    def show
-      @action_executed = true
-      render :text => "yawp!"
-    end
-  end
-
   class PrependingController < TestController
     prepend_before_filter :wonderful_life
     # skip_before_filter :fire_flash
@@ -165,16 +187,21 @@ class FilterTest < Test::Unit::TestCase
     def index
       render :text => 'ok'
     end
-    
+
     def public
+      render :text => 'ok'
     end
   end
-  
+
   class SkippingAndReorderingController < TestController
     skip_before_filter :ensure_login
     before_filter :find_record
     before_filter :ensure_login
 
+    def index
+      render :text => 'ok'
+    end
+
     private
       def find_record
         @ran_filter ||= []
@@ -448,11 +475,6 @@ class FilterTest < Test::Unit::TestCase
     assert_equal ["filter_one", "zomg it didn't yield"], controller.assigns['filters']
   end
 
-  def test_empty_filter_chain
-    assert_equal 0, EmptyFilterChainController.filter_chain.size
-    assert test_process(EmptyFilterChainController).template.assigns['action_executed']
-  end
-
   def test_added_filter_to_inheritance_graph
     assert_equal [ :ensure_login ], TestController.before_filters
   end
@@ -466,88 +488,109 @@ class FilterTest < Test::Unit::TestCase
   end
 
   def test_running_filters
-    assert_equal %w( wonderful_life ensure_login ), test_process(PrependingController).template.assigns["ran_filter"]
+    test_process(PrependingController)
+    assert_equal %w( wonderful_life ensure_login ), assigns["ran_filter"]
   end
 
   def test_running_filters_with_proc
-    assert test_process(ProcController).template.assigns["ran_proc_filter"]
+    test_process(ProcController)
+    assert assigns["ran_proc_filter"]
   end
 
   def test_running_filters_with_implicit_proc
-    assert test_process(ImplicitProcController).template.assigns["ran_proc_filter"]
+    test_process(ImplicitProcController)
+    assert assigns["ran_proc_filter"]
   end
 
   def test_running_filters_with_class
-    assert test_process(AuditController).template.assigns["was_audited"]
+    test_process(AuditController)
+    assert assigns["was_audited"]
   end
 
   def test_running_anomolous_yet_valid_condition_filters
-    response = test_process(AnomolousYetValidConditionController)
-    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
-    assert response.template.assigns["ran_class_filter"]
-    assert response.template.assigns["ran_proc_filter1"]
-    assert response.template.assigns["ran_proc_filter2"]
+    test_process(AnomolousYetValidConditionController)
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
+    assert assigns["ran_class_filter"]
+    assert assigns["ran_proc_filter1"]
+    assert assigns["ran_proc_filter2"]
 
-    response = test_process(AnomolousYetValidConditionController, "show_without_filter")
-    assert_equal nil, response.template.assigns["ran_filter"]
-    assert !response.template.assigns["ran_class_filter"]
-    assert !response.template.assigns["ran_proc_filter1"]
-    assert !response.template.assigns["ran_proc_filter2"]
+    test_process(AnomolousYetValidConditionController, "show_without_filter")
+    assert_equal nil, assigns["ran_filter"]
+    assert !assigns["ran_class_filter"]
+    assert !assigns["ran_proc_filter1"]
+    assert !assigns["ran_proc_filter2"]
   end
 
   def test_running_conditional_options
-    response = test_process(ConditionalOptionsFilter)
-    assert_equal %w( ensure_login ), response.template.assigns["ran_filter"]
+    test_process(ConditionalOptionsFilter)
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
   end
 
   def test_running_collection_condition_filters
-    assert_equal %w( ensure_login ), test_process(ConditionalCollectionFilterController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "show_without_filter").template.assigns["ran_filter"]
-    assert_equal nil, test_process(ConditionalCollectionFilterController, "another_action").template.assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController)
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController, "show_without_filter")
+    assert_equal nil, assigns["ran_filter"]
+    test_process(ConditionalCollectionFilterController, "another_action")
+    assert_equal nil, assigns["ran_filter"]
   end
 
   def test_running_only_condition_filters
-    assert_equal %w( ensure_login ), test_process(OnlyConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(OnlyConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(OnlyConditionSymController)
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
+    test_process(OnlyConditionSymController, "show_without_filter")
+    assert_equal nil, assigns["ran_filter"]
 
-    assert test_process(OnlyConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(OnlyConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+    test_process(OnlyConditionProcController)
+    assert assigns["ran_proc_filter"]
+    test_process(OnlyConditionProcController, "show_without_filter")
+    assert !assigns["ran_proc_filter"]
 
-    assert test_process(OnlyConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(OnlyConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+    test_process(OnlyConditionClassController)
+    assert assigns["ran_class_filter"]
+    test_process(OnlyConditionClassController, "show_without_filter")
+    assert !assigns["ran_class_filter"]
   end
 
   def test_running_except_condition_filters
-    assert_equal %w( ensure_login ), test_process(ExceptConditionSymController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(ExceptConditionSymController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(ExceptConditionSymController)
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
+    test_process(ExceptConditionSymController, "show_without_filter")
+    assert_equal nil, assigns["ran_filter"]
 
-    assert test_process(ExceptConditionProcController).template.assigns["ran_proc_filter"]
-    assert !test_process(ExceptConditionProcController, "show_without_filter").template.assigns["ran_proc_filter"]
+    test_process(ExceptConditionProcController)
+    assert assigns["ran_proc_filter"]
+    test_process(ExceptConditionProcController, "show_without_filter")
+    assert !assigns["ran_proc_filter"]
 
-    assert test_process(ExceptConditionClassController).template.assigns["ran_class_filter"]
-    assert !test_process(ExceptConditionClassController, "show_without_filter").template.assigns["ran_class_filter"]
+    test_process(ExceptConditionClassController)
+    assert assigns["ran_class_filter"]
+    test_process(ExceptConditionClassController, "show_without_filter")
+    assert !assigns["ran_class_filter"]
   end
 
   def test_running_before_and_after_condition_filters
-    assert_equal %w( ensure_login clean_up_tmp), test_process(BeforeAndAfterConditionController).template.assigns["ran_filter"]
-    assert_equal nil, test_process(BeforeAndAfterConditionController, "show_without_filter").template.assigns["ran_filter"]
+    test_process(BeforeAndAfterConditionController)
+    assert_equal %w( ensure_login clean_up_tmp), assigns["ran_filter"]
+    test_process(BeforeAndAfterConditionController, "show_without_filter")
+    assert_equal nil, assigns["ran_filter"]
   end
 
   def test_around_filter
-    controller = test_process(AroundFilterController)
-    assert controller.template.assigns["before_ran"]
-    assert controller.template.assigns["after_ran"]
+    test_process(AroundFilterController)
+    assert assigns["before_ran"]
+    assert assigns["after_ran"]
   end
 
   def test_before_after_class_filter
-    controller = test_process(BeforeAfterClassFilterController)
-    assert controller.template.assigns["before_ran"]
-    assert controller.template.assigns["after_ran"]
+    test_process(BeforeAfterClassFilterController)
+    assert assigns["before_ran"]
+    assert assigns["after_ran"]
   end
 
   def test_having_properties_in_around_filter
-    controller = test_process(AroundFilterController)
-    assert_equal "before and after", controller.template.assigns["execution_log"]
+    test_process(AroundFilterController)
+    assert_equal "before and after", assigns["execution_log"]
   end
 
   def test_prepending_and_appending_around_filter
@@ -560,7 +603,7 @@ class FilterTest < Test::Unit::TestCase
   def test_rendering_breaks_filtering_chain
     response = test_process(RenderingController)
     assert_equal "something else", response.body
-    assert !response.template.assigns["ran_action"]
+    assert !assigns["ran_action"]
   end
 
   def test_filters_with_mixed_specialization_run_in_order
@@ -579,47 +622,59 @@ class FilterTest < Test::Unit::TestCase
     %w(foo bar baz).each do |action|
       request = ActionController::TestRequest.new
       request.query_parameters[:choose] = action
-      response = DynamicDispatchController.process(request, ActionController::TestResponse.new)
+      response = DynamicDispatchController.action.call(request.env).last
       assert_equal action, response.body
     end
   end
 
   def test_running_prepended_before_and_after_filter
-    assert_equal 3, PrependingBeforeAndAfterController.filter_chain.length
-    response = test_process(PrependingBeforeAndAfterController)
-    assert_equal %w( before_all between_before_all_and_after_all after_all ), response.template.assigns["ran_filter"]
+    test_process(PrependingBeforeAndAfterController)
+    assert_equal %w( before_all between_before_all_and_after_all after_all ), assigns["ran_filter"]
   end
-  
+
   def test_skipping_and_limiting_controller
-    assert_equal %w( ensure_login ), test_process(SkippingAndLimitedController, "index").template.assigns["ran_filter"]
-    assert_nil test_process(SkippingAndLimitedController, "public").template.assigns["ran_filter"]
+    test_process(SkippingAndLimitedController, "index")
+    assert_equal %w( ensure_login ), assigns["ran_filter"]
+    test_process(SkippingAndLimitedController, "public")
+    assert_nil assigns["ran_filter"]
   end
 
   def test_skipping_and_reordering_controller
-    assert_equal %w( find_record ensure_login ), test_process(SkippingAndReorderingController, "index").template.assigns["ran_filter"]
+    test_process(SkippingAndReorderingController, "index")
+    assert_equal %w( find_record ensure_login ), assigns["ran_filter"]
   end
 
   def test_conditional_skipping_of_filters
-    assert_nil test_process(ConditionalSkippingController, "login").template.assigns["ran_filter"]
-    assert_equal %w( ensure_login find_user ), test_process(ConditionalSkippingController, "change_password").template.assigns["ran_filter"]
+    test_process(ConditionalSkippingController, "login")
+    assert_nil assigns["ran_filter"]
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( ensure_login find_user ), assigns["ran_filter"]
 
-    assert_nil test_process(ConditionalSkippingController, "login").template.controller.instance_variable_get("@ran_after_filter")
-    assert_equal %w( clean_up ), test_process(ConditionalSkippingController, "change_password").template.controller.instance_variable_get("@ran_after_filter")
+    test_process(ConditionalSkippingController, "login")
+    assert_nil @controller.template.controller.instance_variable_get("@ran_after_filter")
+    test_process(ConditionalSkippingController, "change_password")
+    assert_equal %w( clean_up ), @controller.template.controller.instance_variable_get("@ran_after_filter")
   end
 
   def test_conditional_skipping_of_filters_when_parent_filter_is_also_conditional
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
-    assert_nil test_process(ChildOfConditionalParentController, 'another_action').template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), assigns['ran_filter']
+    test_process(ChildOfConditionalParentController, 'another_action')
+    assert_nil assigns['ran_filter']
   end
 
   def test_condition_skipping_of_filters_when_siblings_also_have_conditions
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter'], "1"
-    assert_equal nil, test_process(AnotherChildOfConditionalParentController).template.assigns['ran_filter']
-    assert_equal %w( conditional_in_parent conditional_in_parent ), test_process(ChildOfConditionalParentController).template.assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), assigns['ran_filter'], "1"
+    test_process(AnotherChildOfConditionalParentController)
+    assert_equal nil, assigns['ran_filter']
+    test_process(ChildOfConditionalParentController)
+    assert_equal %w( conditional_in_parent conditional_in_parent ), assigns['ran_filter']
   end
 
   def test_changing_the_requirements
-    assert_equal nil, test_process(ChangingTheRequirementsController, "go_wild").template.assigns['ran_filter']
+    test_process(ChangingTheRequirementsController, "go_wild")
+    assert_equal nil, assigns['ran_filter']
   end
 
   def test_a_rescuing_around_filter
@@ -634,11 +689,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 = controller.new if controller.is_a?(Class)
-      controller.process_with_test(request, ActionController::TestResponse.new)
+      @controller = controller.is_a?(Class) ? controller.new : controller
+      @request    = ActionController::TestRequest.new
+      @response   = ActionController::TestResponse.new
+
+      process(action)
     end
 end
 
@@ -772,18 +827,9 @@ class ControllerWithTwoLessFilters < ControllerWithAllTypesOfFilters
   skip_filter :after
 end
 
-class YieldingAroundFiltersTest < Test::Unit::TestCase
+class YieldingAroundFiltersTest < ActionController::TestCase
   include PostsController::AroundExceptions
 
-  def test_filters_registering
-    assert_equal 1, ControllerWithFilterMethod.filter_chain.size
-    assert_equal 1, ControllerWithFilterClass.filter_chain.size
-    assert_equal 1, ControllerWithFilterInstance.filter_chain.size
-    assert_equal 3, ControllerWithSymbolAsFilter.filter_chain.size
-    assert_equal 6, ControllerWithNestedFilters.filter_chain.size
-    assert_equal 4, ControllerWithAllTypesOfFilters.filter_chain.size
-  end
-
   def test_base
     controller = PostsController
     assert_nothing_raised { test_process(controller,'no_raise') }
@@ -819,9 +865,9 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   end
 
   def test_with_proc
-    controller = test_process(ControllerWithProcFilter,'no_raise')
-    assert controller.template.assigns['before']
-    assert controller.template.assigns['after']
+    test_process(ControllerWithProcFilter,'no_raise')
+    assert assigns['before']
+    assert assigns['after']
   end
 
   def test_nested_filters
@@ -841,13 +887,13 @@ class YieldingAroundFiltersTest < Test::Unit::TestCase
   end
 
   def test_filter_order_with_all_filter_types
-    controller = test_process(ControllerWithAllTypesOfFilters,'no_raise')
-    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after',controller.template.assigns['ran_filter'].join(' ')
+    test_process(ControllerWithAllTypesOfFilters,'no_raise')
+    assert_equal 'before around (before yield) around_again (before yield) around_again (after yield) around (after yield) after', assigns['ran_filter'].join(' ')
   end
 
   def test_filter_order_with_skip_filter_method
-    controller = test_process(ControllerWithTwoLessFilters,'no_raise')
-    assert_equal 'before around (before yield) around (after yield)',controller.template.assigns['ran_filter'].join(' ')
+    test_process(ControllerWithTwoLessFilters,'no_raise')
+    assert_equal 'before around (before yield) around (after yield)', assigns['ran_filter'].join(' ')
   end
 
   def test_first_filter_in_multiple_before_filter_chain_halts
@@ -876,10 +922,7 @@ 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 = controller.new if controller.is_a?(Class)
-      controller.process_with_test(request, ActionController::TestResponse.new)
+      @controller = controller.is_a?(Class) ? controller.new : controller
+      process(action)
     end
 end
diff --git a/actionpack/test/controller/flash_test.rb b/actionpack/test/controller/flash_test.rb
index d8a892811e..c448f36cb3 100644
--- a/actionpack/test/controller/flash_test.rb
+++ b/actionpack/test/controller/flash_test.rb
@@ -60,6 +60,7 @@ class FlashTest < ActionController::TestCase
 
     def std_action
       @flash_copy = {}.update(flash)
+      render :nothing => true
     end
 
     def filter_halting_action
@@ -79,64 +80,84 @@ class FlashTest < ActionController::TestCase
     get :set_flash
 
     get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", assigns["flash_copy"]["that"]
+    assert_equal "hello", assigns["flashy"]
 
     get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_nil assigns["flash_copy"]["that"], "On second flash"
   end
 
   def test_keep_flash
     get :set_flash
     
     get :use_flash_and_keep_it
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", assigns["flash_copy"]["that"]
+    assert_equal "hello", assigns["flashy"]
 
     get :use_flash
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"], "On second flash"
+    assert_equal "hello", assigns["flash_copy"]["that"], "On second flash"
 
     get :use_flash
-    assert_nil @response.template.assigns["flash_copy"]["that"], "On third flash"
+    assert_nil assigns["flash_copy"]["that"], "On third flash"
   end
   
   def test_flash_now
     get :set_flash_now
-    assert_equal "hello", @response.template.assigns["flash_copy"]["that"]
-    assert_equal "bar"  , @response.template.assigns["flash_copy"]["foo"]
-    assert_equal "hello", @response.template.assigns["flashy"]
+    assert_equal "hello", assigns["flash_copy"]["that"]
+    assert_equal "bar"  , assigns["flash_copy"]["foo"]
+    assert_equal "hello", assigns["flashy"]
 
     get :attempt_to_use_flash_now
-    assert_nil @response.template.assigns["flash_copy"]["that"]
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
-    assert_nil @response.template.assigns["flashy"]
+    assert_nil assigns["flash_copy"]["that"]
+    assert_nil assigns["flash_copy"]["foo"]
+    assert_nil assigns["flashy"]
   end 
   
   def test_update_flash
     get :set_flash
     get :use_flash_and_update_it
-    assert_equal "hello",       @response.template.assigns["flash_copy"]["that"]
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"]
+    assert_equal "hello",       assigns["flash_copy"]["that"]
+    assert_equal "hello again", assigns["flash_copy"]["this"]
     get :use_flash
-    assert_nil                  @response.template.assigns["flash_copy"]["that"], "On second flash"
-    assert_equal "hello again", @response.template.assigns["flash_copy"]["this"], "On second flash"
+    assert_nil                  assigns["flash_copy"]["that"], "On second flash"
+    assert_equal "hello again", assigns["flash_copy"]["this"], "On second flash"
   end
-  
+
   def test_flash_after_reset_session
     get :use_flash_after_reset_session
-    assert_equal "hello",    @response.template.assigns["flashy_that"]
-    assert_equal "good-bye", @response.template.assigns["flashy_this"]
-    assert_nil   @response.template.assigns["flashy_that_reset"]
+    assert_equal "hello",    assigns["flashy_that"]
+    assert_equal "good-bye", assigns["flashy_this"]
+    assert_nil   assigns["flashy_that_reset"]
   end 
 
+  def test_does_not_set_the_session_if_the_flash_is_empty
+    get :std_action
+    assert_nil session["flash"]
+  end
+
   def test_sweep_after_halted_filter_chain
     get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
+    assert_nil assigns["flash_copy"]["foo"]
     get :filter_halting_action
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    assert_equal "bar", assigns["flash_copy"]["foo"]
     get :std_action # follow redirection
-    assert_equal "bar", @response.template.assigns["flash_copy"]["foo"]
+    assert_equal "bar", assigns["flash_copy"]["foo"]
     get :std_action
-    assert_nil @response.template.assigns["flash_copy"]["foo"]
+    assert_nil assigns["flash_copy"]["foo"]
+  end
+
+  def test_keep_and_discard_return_values
+    flash = ActionController::Flash::FlashHash.new
+    flash.update(:foo => :foo_indeed, :bar => :bar_indeed)
+
+    assert_equal(:foo_indeed, flash.discard(:foo)) # valid key passed
+    assert_nil flash.discard(:unknown) # non existant key passed
+    assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.discard()) # nothing passed
+    assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.discard(nil)) # nothing passed      
+
+    assert_equal(:foo_indeed, flash.keep(:foo)) # valid key passed
+    assert_nil flash.keep(:unknown) # non existant key passed
+    assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.keep()) # nothing passed
+    assert_equal({:foo => :foo_indeed, :bar => :bar_indeed}, flash.keep(nil)) # nothing passed     
   end
 end
diff --git a/actionpack/test/controller/helper_test.rb b/actionpack/test/controller/helper_test.rb
index 5f36461b89..5b9feb3630 100644
--- a/actionpack/test/controller/helper_test.rb
+++ b/actionpack/test/controller/helper_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'active_support/core_ext/kernel/reporting'
 
 ActionController::Base.helpers_dir = File.dirname(__FILE__) + '/../fixtures/helpers'
 
@@ -26,7 +27,7 @@ module Fun
   end
 end
 
-class ApplicationController < ActionController::Base
+class AllHelpersController < ActionController::Base
   helper :all
 end
 
@@ -101,24 +102,32 @@ class HelperTest < Test::Unit::TestCase
     assert master_helper_methods.include?('delegate_attr=')
   end
 
-  def test_helper_for_nested_controller
+  def call_controller(klass, action)
     request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'render_hello_world'
+    klass.action(action).call(request.env)    
+  end
 
-    assert_equal 'hello: Iz guuut!', Fun::GamesController.process(request, response).body
+  def test_helper_for_nested_controller
+    assert_equal 'hello: Iz guuut!', 
+      call_controller(Fun::GamesController, "render_hello_world").last.body
+    # request  = ActionController::TestRequest.new
+    # 
+    # resp = Fun::GamesController.action(:render_hello_world).call(request.env)
+    # assert_equal 'hello: Iz guuut!', resp.last.body
   end
 
   def test_helper_for_acronym_controller
-    request  = ActionController::TestRequest.new
-    response = ActionController::TestResponse.new
-    request.action = 'test'
-
-    assert_equal 'test: baz', Fun::PdfController.process(request, response).body
+    assert_equal "test: baz", call_controller(Fun::PdfController, "test").last.body
+    # 
+    # request  = ActionController::TestRequest.new
+    # response = ActionController::TestResponse.new
+    # request.action = 'test'
+    # 
+    # assert_equal 'test: baz', Fun::PdfController.process(request, response).body
   end
 
   def test_all_helpers
-    methods = ApplicationController.master_helper_module.instance_methods.map(&:to_s)
+    methods = AllHelpersController.master_helper_module.instance_methods.map(&:to_s)
 
     # abc_helper.rb
     assert methods.include?('bare_a')
@@ -145,7 +154,7 @@ class HelperTest < Test::Unit::TestCase
   end
 
   def test_helper_proxy
-    methods = ApplicationController.helpers.methods.map(&:to_s)
+    methods = AllHelpersController.helpers.methods.map(&:to_s)
 
     # ActionView
     assert methods.include?('pluralize')
@@ -204,6 +213,11 @@ class IsolatedHelpersTest < Test::Unit::TestCase
     end
   end
 
+  def call_controller(klass, action)
+    request  = ActionController::TestRequest.new
+    klass.action(action).call(request.env)    
+  end
+
   def setup
     @request    = ActionController::TestRequest.new
     @response   = ActionController::TestResponse.new
@@ -211,14 +225,14 @@ class IsolatedHelpersTest < Test::Unit::TestCase
   end
 
   def test_helper_in_a
-    assert_raise(NameError) { A.process(@request, @response) }
+    assert_raise(ActionView::TemplateError) { call_controller(A, "index") }
   end
 
   def test_helper_in_b
-    assert_equal 'B', B.process(@request, @response).body
+    assert_equal 'B', call_controller(B, "index").last.body
   end
 
   def test_helper_in_c
-    assert_equal 'C', C.process(@request, @response).body
+    assert_equal 'C', call_controller(C, "index").last.body
   end
 end
diff --git a/actionpack/test/controller/http_digest_authentication_test.rb b/actionpack/test/controller/http_digest_authentication_test.rb
index 00789eea38..15a11395bb 100644
--- a/actionpack/test/controller/http_digest_authentication_test.rb
+++ b/actionpack/test/controller/http_digest_authentication_test.rb
@@ -38,6 +38,15 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
 
   tests DummyDigestController
 
+  setup do
+    # Used as secret in generating nonce to prevent tampering of timestamp
+    @old_secret, ActionController::Base.session_options[:secret] = ActionController::Base.session_options[:secret], "session_options_secret"
+  end
+
+  teardown do
+    ActionController::Base.session_options[:secret] = @old_secret
+  end
+
   AUTH_HEADERS.each do |header|
     test "successful authentication with #{header.downcase}" do
       @request.env[header] = encode_credentials(:username => 'lifo', :password => 'world')
@@ -111,8 +120,6 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
   test "authentication request with valid credential and nil session" do
     @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please')
 
-    # session_id = "" in functional test, but is +nil+ in real life
-    @request.session.session_id = nil
     get :display
 
     assert_response :success
@@ -151,25 +158,38 @@ class HttpDigestAuthenticationTest < ActionController::TestCase
     assert_equal 'Definitely Maybe', @response.body
   end
 
+  test "authentication request with _method" do
+    @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please', :method => :post)
+    @request.env['rack.methodoverride.original_method'] = 'POST'
+    put :display
+
+    assert_response :success
+    assert assigns(:logged_in)
+    assert_equal 'Definitely Maybe', @response.body
+  end
+
   private
 
   def encode_credentials(options)
     options.reverse_merge!(:nc => "00000001", :cnonce => "0a4f113b", :password_is_ha1 => false)
     password = options.delete(:password)
 
-    # Set in /initializers/session_store.rb. Used as secret in generating nonce
-    # to prevent tampering of timestamp
-    ActionController::Base.session_options[:secret] = "session_options_secret"
+    # Perform unauthenticated request to retrieve digest parameters to use on subsequent request
+    method = options.delete(:method) || 'GET'
 
-    # Perform unauthenticated GET to retrieve digest parameters to use on subsequent request
-    get :index
+    case method.to_s.upcase
+    when 'GET'
+      get :index
+    when 'POST'
+      post :index
+    end
 
     assert_response :unauthorized
 
     credentials = decode_credentials(@response.headers['WWW-Authenticate'])
     credentials.merge!(options)
     credentials.reverse_merge!(:uri => "#{@request.env['REQUEST_URI']}")
-    ActionController::HttpAuthentication::Digest.encode_credentials("GET", credentials, password, options[:password_is_ha1])
+    ActionController::HttpAuthentication::Digest.encode_credentials(method, credentials, password, options[:password_is_ha1])
   end
 
   def decode_credentials(header)
diff --git a/actionpack/test/controller/integration_test.rb b/actionpack/test/controller/integration_test.rb
index e39a934c24..197ba0c69c 100644
--- a/actionpack/test/controller/integration_test.rb
+++ b/actionpack/test/controller/integration_test.rb
@@ -1,4 +1,5 @@
 require 'abstract_unit'
+require 'action_controller/vendor/html-scanner'
 
 class SessionTest < Test::Unit::TestCase
   StubApp = lambda { |env|
@@ -30,7 +31,7 @@ class SessionTest < Test::Unit::TestCase
 
   def test_request_via_redirect_uses_given_method
     path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"}
-    @session.expects(:put).with(path, args, headers)
+    @session.expects(:process).with(:put, path, args, headers)
     @session.stubs(:redirect?).returns(false)
     @session.request_via_redirect(:put, path, args, headers)
   end
@@ -90,16 +91,6 @@ class SessionTest < Test::Unit::TestCase
     assert_equal '/show', @session.url_for(options)
   end
 
-  def test_redirect_bool_with_status_in_300s
-    @session.stubs(:status).returns 301
-    assert @session.redirect?
-  end
-
-  def test_redirect_bool_with_status_in_200s
-    @session.stubs(:status).returns 200
-    assert !@session.redirect?
-  end
-
   def test_get
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     @session.expects(:process).with(:get,path,params,headers)
@@ -133,8 +124,8 @@ class SessionTest < Test::Unit::TestCase
   def test_xml_http_request_get
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest",
-      "Accept"           => "text/javascript, text/html, application/xml, text/xml, */*"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+      "HTTP_ACCEPT"           => "text/javascript, text/html, application/xml, text/xml, */*"
     )
     @session.expects(:process).with(:get,path,params,headers_after_xhr)
     @session.xml_http_request(:get,path,params,headers)
@@ -143,8 +134,8 @@ class SessionTest < Test::Unit::TestCase
   def test_xml_http_request_post
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest",
-      "Accept"           => "text/javascript, text/html, application/xml, text/xml, */*"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+      "HTTP_ACCEPT"           => "text/javascript, text/html, application/xml, text/xml, */*"
     )
     @session.expects(:process).with(:post,path,params,headers_after_xhr)
     @session.xml_http_request(:post,path,params,headers)
@@ -153,8 +144,8 @@ class SessionTest < Test::Unit::TestCase
   def test_xml_http_request_put
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest",
-      "Accept"           => "text/javascript, text/html, application/xml, text/xml, */*"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+      "HTTP_ACCEPT"           => "text/javascript, text/html, application/xml, text/xml, */*"
     )
     @session.expects(:process).with(:put,path,params,headers_after_xhr)
     @session.xml_http_request(:put,path,params,headers)
@@ -163,8 +154,8 @@ class SessionTest < Test::Unit::TestCase
   def test_xml_http_request_delete
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest",
-      "Accept"           => "text/javascript, text/html, application/xml, text/xml, */*"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+      "HTTP_ACCEPT"           => "text/javascript, text/html, application/xml, text/xml, */*"
     )
     @session.expects(:process).with(:delete,path,params,headers_after_xhr)
     @session.xml_http_request(:delete,path,params,headers)
@@ -173,17 +164,17 @@ class SessionTest < Test::Unit::TestCase
   def test_xml_http_request_head
     path = "/index"; params = "blah"; headers = {:location => 'blah'}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest",
-      "Accept"           => "text/javascript, text/html, application/xml, text/xml, */*"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest",
+      "HTTP_ACCEPT"           => "text/javascript, text/html, application/xml, text/xml, */*"
     )
     @session.expects(:process).with(:head,path,params,headers_after_xhr)
     @session.xml_http_request(:head,path,params,headers)
   end
 
   def test_xml_http_request_override_accept
-    path = "/index"; params = "blah"; headers = {:location => 'blah', "Accept" => "application/xml"}
+    path = "/index"; params = "blah"; headers = {:location => 'blah', "HTTP_ACCEPT" => "application/xml"}
     headers_after_xhr = headers.merge(
-      "X-Requested-With" => "XMLHttpRequest"
+      "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"
     )
     @session.expects(:process).with(:post,path,params,headers_after_xhr)
     @session.xml_http_request(:post,path,params,headers)
@@ -263,7 +254,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_response 200
       assert_response :success
       assert_response :ok
-      assert_equal({}, cookies)
+      assert_equal({}, cookies.to_hash)
       assert_equal "OK", body
       assert_equal "OK", response.body
       assert_kind_of HTML::Document, html_document
@@ -279,7 +270,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_response 201
       assert_response :success
       assert_response :created
-      assert_equal({}, cookies)
+      assert_equal({}, cookies.to_hash)
       assert_equal "Created", body
       assert_equal "Created", response.body
       assert_kind_of HTML::Document, html_document
@@ -297,7 +288,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       assert_response 410
       assert_response :gone
       assert_equal "cookie_1=; path=/\ncookie_3=chocolate; path=/", headers["Set-Cookie"]
-      assert_equal({"cookie_1"=>"", "cookie_2"=>"oatmeal", "cookie_3"=>"chocolate"}, cookies)
+      assert_equal({"cookie_1"=>"", "cookie_2"=>"oatmeal", "cookie_3"=>"chocolate"}, cookies.to_hash)
       assert_equal "Gone", response.body
     end
   end
@@ -337,7 +328,7 @@ class IntegrationProcessTest < ActionController::IntegrationTest
       get '/get_with_params?foo=bar'
       assert_equal '/get_with_params?foo=bar', request.env["REQUEST_URI"]
       assert_equal '/get_with_params?foo=bar', request.request_uri
-      assert_equal "", request.env["QUERY_STRING"]
+      assert_equal "foo=bar", request.env["QUERY_STRING"]
       assert_equal 'foo=bar', request.query_string
       assert_equal 'bar', request.parameters['foo']
 
diff --git a/actionpack/test/controller/layout_test.rb b/actionpack/test/controller/layout_test.rb
index f2721e274d..cb9bdf57bb 100644
--- a/actionpack/test/controller/layout_test.rb
+++ b/actionpack/test/controller/layout_test.rb
@@ -9,8 +9,11 @@ ActionView::Template::register_template_handler :mab,
 
 ActionController::Base.view_paths = [ File.dirname(__FILE__) + '/../fixtures/layout_tests/' ]
 
+require "fixture_template"
+
 class LayoutTest < ActionController::Base
   def self.controller_path; 'views' end
+  def self._implied_layout_name; to_s.underscore.gsub(/_controller$/, '') ; end
   self.view_paths = ActionController::Base.view_paths.dup
 end
 
@@ -35,6 +38,15 @@ end
 class MultipleExtensions < LayoutTest
 end
 
+if defined?(ActionController::Http)
+  LayoutTest._write_layout_method
+  ProductController._write_layout_method
+  ItemController._write_layout_method
+  ThirdPartyTemplateLibraryController._write_layout_method
+  MultipleExtensions._write_layout_method
+  ControllerNameSpace::NestedController._write_layout_method
+end
+
 class LayoutAutoDiscoveryTest < ActionController::TestCase
   def setup
     super
@@ -56,23 +68,19 @@ class LayoutAutoDiscoveryTest < ActionController::TestCase
   def test_third_party_template_library_auto_discovers_layout
     @controller = ThirdPartyTemplateLibraryController.new
     get :hello
-    assert_equal 'layouts/third_party_template_library.mab', @controller.active_layout(true).to_s
-    assert_equal 'layouts/third_party_template_library', @response.layout
     assert_response :success
-    assert_equal 'Mab', @response.body
+    assert_equal 'layouts/third_party_template_library.mab', @response.body
   end
 
-  def test_namespaced_controllers_auto_detect_layouts
+  def test_namespaced_controllers_auto_detect_layouts1
     @controller = ControllerNameSpace::NestedController.new
     get :hello
-    assert_equal 'layouts/controller_name_space/nested', @controller.active_layout(true).to_s
     assert_equal 'controller_name_space/nested.rhtml hello.rhtml', @response.body
   end
 
-  def test_namespaced_controllers_auto_detect_layouts
+  def test_namespaced_controllers_auto_detect_layouts2
     @controller = MultipleExtensions.new
     get :hello
-    assert_equal 'layouts/multiple_extensions.html.erb', @controller.active_layout(true).to_s
     assert_equal 'multiple_extensions.html.erb hello.rhtml', @response.body.strip
   end
 end
@@ -116,70 +124,75 @@ class RendersNoLayoutController < LayoutTest
 end
 
 class LayoutSetInResponseTest < ActionController::TestCase
+  include ActionView::TemplateHandlers
+  
   def test_layout_set_when_using_default_layout
     @controller = DefaultLayoutController.new
     get :hello
-    assert_equal 'layouts/layout_test', @response.layout
+    assert @controller.template.layout.include?('layouts/layout_test')
   end
 
   def test_layout_set_when_set_in_controller
     @controller = HasOwnLayoutController.new
     get :hello
-    assert_equal 'layouts/item', @response.layout
+    assert @controller.template.layout.include?('layouts/item')
   end
   
   def test_layout_only_exception_when_included
     @controller = OnlyLayoutController.new
     get :hello
-    assert_equal 'layouts/item', @response.layout
+    assert @controller.template.layout.include?('layouts/item')
   end
 
   def test_layout_only_exception_when_excepted
     @controller = OnlyLayoutController.new
     get :goodbye
-    assert_equal nil, @response.layout
+    assert !@response.body.include?("item.rhtml"), "#{@response.body.inspect} included 'item.rhtml'"
   end
 
   def test_layout_except_exception_when_included
     @controller = ExceptLayoutController.new
     get :hello
-    assert_equal 'layouts/item', @response.layout
+    assert @controller.template.layout.include?('layouts/item')
   end
 
   def test_layout_except_exception_when_excepted
     @controller = ExceptLayoutController.new
     get :goodbye
-    assert_equal nil, @response.layout
+    assert !@response.body.include?("item.rhtml"), "#{@response.body.inspect} included 'item.rhtml'"
   end
 
   def test_layout_set_when_using_render
     @controller = SetsLayoutInRenderController.new
     get :hello
-    assert_equal 'layouts/third_party_template_library', @response.layout
+    assert @controller.template.layout.include?('layouts/third_party_template_library')
   end
 
   def test_layout_is_not_set_when_none_rendered
     @controller = RendersNoLayoutController.new
     get :hello
-    assert_nil @response.layout
+    assert_nil @controller.template.layout
   end
 
-  def test_exempt_from_layout_honored_by_render_template
-    ActionController::Base.exempt_from_layout :rhtml
-    @controller = RenderWithTemplateOptionController.new
+  for_tag(:old_base) do
+    # exempt_from_layout is deprecated
+    def test_exempt_from_layout_honored_by_render_template
+      ActionController::Base.exempt_from_layout :erb
+      @controller = RenderWithTemplateOptionController.new
 
-    get :hello
-    assert_equal "alt/hello.rhtml", @response.body.strip
+      get :hello
+      assert_equal "alt/hello.rhtml", @response.body.strip
 
-  ensure
-    ActionController::Base.exempt_from_layout.delete(/\.rhtml$/)
+    ensure
+      ActionController::Base.exempt_from_layout.delete(ERB)
+    end
   end
 
   def test_layout_is_picked_from_the_controller_instances_view_path
     pending do
       @controller = PrependsViewPathController.new
       get :hello
-      assert_equal 'layouts/alt', @response.layout
+      assert_equal 'layouts/alt', @controller.template.layout
     end
   end
 
@@ -203,8 +216,7 @@ end
 class LayoutExceptionRaised < ActionController::TestCase
   def test_exception_raised_when_layout_file_not_found
     @controller = SetsNonExistentLayoutFile.new
-    get :hello
-    assert_kind_of ActionView::MissingTemplate, @response.template.instance_eval { @exception }
+    assert_raise(ActionView::MissingTemplate) { get :hello }
   end
 end
 
@@ -232,7 +244,7 @@ unless RUBY_PLATFORM =~ /(:?mswin|mingw|bccwin)/
       @controller = LayoutSymlinkedTest.new
       get :hello
       assert_response 200
-      assert_equal "layouts/symlinked/symlinked_layout", @response.layout
+      assert @controller.template.layout.include?("layouts/symlinked/symlinked_layout")
     end
   end
 end
diff --git a/actionpack/test/controller/logging_test.rb b/actionpack/test/controller/logging_test.rb
index 1f3ff4ef52..a7ed1b8665 100644
--- a/actionpack/test/controller/logging_test.rb
+++ b/actionpack/test/controller/logging_test.rb
@@ -11,6 +11,11 @@ class LoggingTest < ActionController::TestCase
 
   class MockLogger
     attr_reader :logged
+    attr_accessor :level
+    
+    def initialize
+      @level = Logger::DEBUG
+    end
     
     def method_missing(method, *args)
       @logged ||= []
@@ -30,7 +35,7 @@ class LoggingTest < ActionController::TestCase
   end
 
   def test_logging_with_parameters
-    get :show, :id => 10
+    get :show, :id => '10'
     assert_equal 3, logs.size
 
     params = logs.detect {|l| l =~ /Parameters/ }
@@ -44,6 +49,6 @@ class LoggingTest < ActionController::TestCase
   end
   
   def logs
-    @logs ||= @controller.logger.logged.compact.map {|l| l.strip}
+    @logs ||= @controller.logger.logged.compact.map {|l| l.to_s.strip}
   end
 end
diff --git a/actionpack/test/controller/mime_responds_test.rb b/actionpack/test/controller/mime_responds_test.rb
index 7cd5145a2f..56b49251c6 100644
--- a/actionpack/test/controller/mime_responds_test.rb
+++ b/actionpack/test/controller/mime_responds_test.rb
@@ -375,9 +375,11 @@ class MimeControllerTest < ActionController::TestCase
   end
 
   def test_rjs_type_skips_layout
-    @request.accept = "text/javascript"
-    get :all_types_with_layout
-    assert_equal 'RJS for all_types_with_layout', @response.body
+    pending(:new_base) do
+      @request.accept = "text/javascript"
+      get :all_types_with_layout
+      assert_equal 'RJS for all_types_with_layout', @response.body
+    end
   end
 
   def test_html_type_with_layout
@@ -437,7 +439,7 @@ class MimeControllerTest < ActionController::TestCase
     @controller.instance_eval do
       def render(*args)
         unless args.empty?
-          @action = args.first[:action]
+          @action = args.first[:action] || action_name
         end
         response.body = "#{@action} - #{@template.formats}"
       end
@@ -490,14 +492,15 @@ class PostController < AbstractPostController
     end
   end
 
-  protected
-    def with_iphone
-      Mime::Type.register_alias("text/html", :iphone)
-      request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
-      yield
-    ensure
-      Mime.module_eval { remove_const :IPHONE if const_defined?(:IPHONE) }
-    end
+protected
+
+  def with_iphone
+    Mime::Type.register_alias("text/html", :iphone)
+    request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
+    yield
+  ensure
+    Mime.module_eval { remove_const :IPHONE if const_defined?(:IPHONE) }
+  end
 end
 
 class SuperPostController < PostController
@@ -509,6 +512,11 @@ class SuperPostController < PostController
   end
 end
 
+if defined?(ActionController::Http)
+  PostController._write_layout_method
+  SuperPostController._write_layout_method
+end
+
 class MimeControllerLayoutsTest < ActionController::TestCase
   tests PostController
 
@@ -526,14 +534,16 @@ class MimeControllerLayoutsTest < ActionController::TestCase
     assert_equal 'Hello iPhone', @response.body
   end
 
-  def test_format_with_inherited_layouts
-    @controller = SuperPostController.new
+  for_tag(:old_base) do
+    def test_format_with_inherited_layouts
+      @controller = SuperPostController.new
 
-    get :index
-    assert_equal 'Super Firefox', @response.body
+      get :index
+      assert_equal 'Super Firefox', @response.body
 
-    @request.accept = "text/iphone"
-    get :index
-    assert_equal '<html><div id="super_iphone">Super iPhone</div></html>', @response.body
+      @request.accept = "text/iphone"
+      get :index
+      assert_equal '<html><div id="super_iphone">Super iPhone</div></html>', @response.body
+    end
   end
 end
diff --git a/actionpack/test/controller/redirect_test.rb b/actionpack/test/controller/redirect_test.rb
index 91e21db854..13247f2d08 100644
--- a/actionpack/test/controller/redirect_test.rb
+++ b/actionpack/test/controller/redirect_test.rb
@@ -233,11 +233,6 @@ class RedirectTest < ActionController::TestCase
     assert_redirected_to Workshop.new(5, true)
   end
 
-  def test_redirect_with_partial_params
-    get :module_redirect
-    assert_redirected_to :action => 'hello_world'
-  end
-
   def test_redirect_to_nil
     assert_raise(ActionController::ActionControllerError) do
       get :redirect_to_nil
diff --git a/actionpack/test/controller/render_js_test.rb b/actionpack/test/controller/render_js_test.rb
new file mode 100644
index 0000000000..d02fd3fd4c
--- /dev/null
+++ b/actionpack/test/controller/render_js_test.rb
@@ -0,0 +1,39 @@
+require 'abstract_unit'
+require 'controller/fake_models'
+require 'pathname'
+
+class TestController < ActionController::Base
+  protect_from_forgery
+
+  def render_vanilla_js_hello
+    render :js => "alert('hello')"
+  end
+  
+  def greeting
+    # let's just rely on the template
+  end
+  
+  def partial
+    render :partial => 'partial'
+  end  
+end
+
+class RenderTest < ActionController::TestCase
+  tests TestController
+
+  def test_render_vanilla_js
+    get :render_vanilla_js_hello
+    assert_equal "alert('hello')", @response.body
+    assert_equal "text/javascript", @response.content_type
+  end
+  
+  def test_render_with_default_from_accept_header
+    xhr :get, :greeting
+    assert_equal "$(\"body\").visualEffect(\"highlight\");", @response.body
+  end
+  
+  def test_should_render_js_partial
+    xhr :get, :partial, :format => 'js'
+    assert_equal 'partial js', @response.body
+  end  
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/render_json_test.rb b/actionpack/test/controller/render_json_test.rb
new file mode 100644
index 0000000000..233b2dfd89
--- /dev/null
+++ b/actionpack/test/controller/render_json_test.rb
@@ -0,0 +1,80 @@
+require 'abstract_unit'
+require 'controller/fake_models'
+require 'pathname'
+
+class TestController < ActionController::Base
+  protect_from_forgery
+  
+  def render_json_nil
+    render :json => nil
+  end
+
+  def render_json_hello_world
+    render :json => ActiveSupport::JSON.encode(:hello => 'world')
+  end
+
+  def render_json_hello_world_with_callback
+    render :json => ActiveSupport::JSON.encode(:hello => 'world'), :callback => 'alert'
+  end
+
+  def render_json_with_custom_content_type
+    render :json => ActiveSupport::JSON.encode(:hello => 'world'), :content_type => 'text/javascript'
+  end
+
+  def render_symbol_json
+    render :json => ActiveSupport::JSON.encode(:hello => 'world')
+  end
+
+  def render_json_with_render_to_string
+    render :json => {:hello => render_to_string(:partial => 'partial')}
+  end  
+end
+
+class RenderTest < ActionController::TestCase
+  tests TestController
+
+  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".
+    super
+    @controller.logger = Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end  
+  
+  def test_render_json_nil
+    get :render_json_nil
+    assert_equal 'null', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json
+    get :render_json_hello_world
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_with_callback
+    get :render_json_hello_world_with_callback
+    assert_equal 'alert({"hello":"world"})', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_with_custom_content_type
+    get :render_json_with_custom_content_type
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'text/javascript', @response.content_type
+  end
+
+  def test_render_symbol_json
+    get :render_symbol_json
+    assert_equal '{"hello":"world"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end
+
+  def test_render_json_with_render_to_string
+    get :render_json_with_render_to_string
+    assert_equal '{"hello":"partial html"}', @response.body
+    assert_equal 'application/json', @response.content_type
+  end  
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/render_other_test.rb b/actionpack/test/controller/render_other_test.rb
new file mode 100644
index 0000000000..05645e47fa
--- /dev/null
+++ b/actionpack/test/controller/render_other_test.rb
@@ -0,0 +1,238 @@
+require 'abstract_unit'
+require 'controller/fake_models'
+require 'pathname'
+
+class TestController < ActionController::Base
+  protect_from_forgery
+  layout :determine_layout
+
+  module RenderTestHelper
+    def rjs_helper_method_from_module
+      page.visual_effect :highlight
+    end
+  end
+
+  helper RenderTestHelper
+  helper do
+    def rjs_helper_method(value)
+      page.visual_effect :highlight, value
+    end
+  end
+
+  def enum_rjs_test
+    render :update do |page|
+      page.select('.product').each do |value|
+        page.rjs_helper_method_from_module
+        page.rjs_helper_method(value)
+        page.sortable(value, :url => { :action => "order" })
+        page.draggable(value)
+      end
+    end
+  end
+  
+  def render_explicit_html_template
+  end
+  
+  def render_custom_code_rjs
+    render :update, :status => 404 do |page|
+      page.replace :foo, :partial => 'partial'
+    end
+  end
+  
+  def render_implicit_html_template
+  end
+  
+  def render_js_with_explicit_template
+    @project_id = 4
+    render :template => 'test/delete_with_js'
+  end
+
+  def render_js_with_explicit_action_template
+    @project_id = 4
+    render :action => 'delete_with_js'
+  end
+  
+  def delete_with_js
+    @project_id = 4
+  end
+  
+  def update_page
+    render :update do |page|
+      page.replace_html 'balance', '$37,000,000.00'
+      page.visual_effect :highlight, 'balance'
+    end
+  end
+
+  def update_page_with_instance_variables
+    @money = '$37,000,000.00'
+    @div_id = 'balance'
+    render :update do |page|
+      page.replace_html @div_id, @money
+      page.visual_effect :highlight, @div_id
+    end
+  end
+
+  def update_page_with_view_method
+    render :update do |page|
+      page.replace_html 'person', pluralize(2, 'person')
+    end
+  end
+  
+  def partial_as_rjs
+    render :update do |page|
+      page.replace :foo, :partial => 'partial'
+    end
+  end
+
+  def respond_to_partial_as_rjs
+    respond_to do |format|
+      format.js do
+        render :update do |page|
+          page.replace :foo, :partial => 'partial'
+        end
+      end
+    end
+  end
+  
+  def render_alternate_default
+    # For this test, the method "default_render" is overridden:
+    @alternate_default_render = lambda do
+      render :update do |page|
+        page.replace :foo, :partial => 'partial'
+      end
+    end
+  end  
+  
+private
+  def default_render
+    if @alternate_default_render
+      @alternate_default_render.call
+    else
+      super
+    end
+  end
+
+  def determine_layout
+    case action_name
+      when "hello_world", "layout_test", "rendering_without_layout",
+           "rendering_nothing_on_layout", "render_text_hello_world",
+           "render_text_hello_world_with_layout",
+           "hello_world_with_layout_false",
+           "partial_only", "partial_only_with_layout",
+           "accessing_params_in_template",
+           "accessing_params_in_template_with_layout",
+           "render_with_explicit_template",
+           "render_with_explicit_string_template",
+           "update_page", "update_page_with_instance_variables"
+
+        "layouts/standard"
+      when "action_talk_to_layout", "layout_overriding_layout"
+        "layouts/talk_from_action"
+      when "render_implicit_html_template_from_xhr_request"
+        (request.xhr? ? 'layouts/xhr' : 'layouts/standard')
+    end
+  end    
+end
+
+class RenderTest < ActionController::TestCase
+  tests TestController
+
+  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".
+    super
+    @controller.logger = Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end  
+  
+  def test_enum_rjs_test
+    ActiveSupport::SecureRandom.stubs(:base64).returns("asdf")
+    get :enum_rjs_test
+    body = %{
+      $$(".product").each(function(value, index) {
+      new Effect.Highlight(element,{});
+      new Effect.Highlight(value,{});
+      Sortable.create(value, {onUpdate:function(){new Ajax.Request('/test/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize(value) + '&authenticity_token=' + encodeURIComponent('asdf')})}});
+      new Draggable(value, {});
+      });
+    }.gsub(/^      /, '').strip
+    assert_equal body, @response.body
+  end
+  
+  def test_explicitly_rendering_an_html_template_with_implicit_html_template_renders_should_be_possible_from_an_rjs_template
+    [:js, "js"].each do |format|
+      assert_nothing_raised do
+        get :render_explicit_html_template, :format => format
+        assert_equal %(document.write("Hello world\\n");), @response.body
+      end
+    end
+  end 
+  
+  def test_render_custom_code_rjs
+    get :render_custom_code_rjs
+    assert_response 404
+    assert_equal %(Element.replace("foo", "partial html");), @response.body
+  end
+  
+  def test_render_in_an_rjs_template_should_pick_html_templates_when_available
+    [:js, "js"].each do |format|
+      assert_nothing_raised do
+        get :render_implicit_html_template, :format => format
+        assert_equal %(document.write("Hello world\\n");), @response.body
+      end
+    end
+  end
+  
+  def test_render_rjs_template_explicitly
+    get :render_js_with_explicit_template
+    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
+  end
+
+  def test_rendering_rjs_action_explicitly
+    get :render_js_with_explicit_action_template
+    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
+  end
+  
+  def test_render_rjs_with_default
+    get :delete_with_js
+    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
+  end
+  
+  def test_update_page
+    get :update_page
+    assert_template nil
+    assert_equal 'text/javascript; charset=utf-8', @response.headers['Content-Type']
+    assert_equal 2, @response.body.split($/).length
+  end
+
+  def test_update_page_with_instance_variables
+    get :update_page_with_instance_variables
+    assert_template nil
+    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
+    assert_match /balance/, @response.body
+    assert_match /\$37/, @response.body
+  end
+
+  def test_update_page_with_view_method
+    get :update_page_with_view_method
+    assert_template nil
+    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
+    assert_match /2 people/, @response.body
+  end  
+  
+  def test_should_render_html_formatted_partial_with_rjs
+    xhr :get, :partial_as_rjs
+    assert_equal %(Element.replace("foo", "partial html");), @response.body
+  end
+
+  def test_should_render_html_formatted_partial_with_rjs_and_js_format
+    xhr :get, :respond_to_partial_as_rjs
+    assert_equal %(Element.replace("foo", "partial html");), @response.body
+  end
+  
+  def test_should_render_with_alternate_default_render
+    xhr :get, :render_alternate_default
+    assert_equal %(Element.replace("foo", "partial html");), @response.body
+  end  
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/render_test.rb b/actionpack/test/controller/render_test.rb
index 9a34bcebe6..9e42d1738a 100644
--- a/actionpack/test/controller/render_test.rb
+++ b/actionpack/test/controller/render_test.rb
@@ -1,8 +1,10 @@
 require 'abstract_unit'
 require 'controller/fake_models'
+require 'pathname'
 
 module Fun
   class GamesController < ActionController::Base
+    # :ported:
     def hello_world
     end
   end
@@ -79,6 +81,7 @@ class TestController < ActionController::Base
     fresh_when(:last_modified => Time.now.utc.beginning_of_day, :etag => [ :foo, 123 ])
   end
 
+  # :ported:
   def render_hello_world
     render :template => "test/hello_world"
   end
@@ -93,23 +96,28 @@ class TestController < ActionController::Base
     render :template => "test/hello_world"
   end
 
+  # :ported: compatibility
   def render_hello_world_with_forward_slash
     render :template => "/test/hello_world"
   end
 
+  # :ported:
   def render_template_in_top_directory
     render :template => 'shared'
   end
 
+  # :deprecated:
   def render_template_in_top_directory_with_slash
     render :template => '/shared'
   end
 
+  # :ported:
   def render_hello_world_from_variable
     @person = "david"
     render :text => "hello #{@person}"
   end
 
+  # :ported:
   def render_action_hello_world
     render :action => "hello_world"
   end
@@ -122,10 +130,12 @@ class TestController < ActionController::Base
     render :action => :hello_world
   end
 
+  # :ported:
   def render_text_hello_world
     render :text => "hello world"
   end
 
+  # :ported:
   def render_text_hello_world_with_layout
     @variable_for_layout = ", I'm here!"
     render :text => "hello world", :layout => true
@@ -135,18 +145,21 @@ class TestController < ActionController::Base
     render :layout => false
   end
 
+  # :ported:
   def render_file_with_instance_variables
     @secret = 'in the sauce'
     path = File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar.erb')
     render :file => path
   end
 
+  # :ported:
   def render_file_as_string_with_instance_variables
     @secret = 'in the sauce'
     path = File.expand_path(File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar.erb'))
     render path
   end
 
+  # :ported:
   def render_file_not_using_full_path
     @secret = 'in the sauce'
     render :file => 'test/render_file_with_ivar'
@@ -193,52 +206,30 @@ class TestController < ActionController::Base
     render :inline =>  "<%= controller_name %>"
   end
 
-  def render_json_hello_world
-    render :json => {:hello => 'world'}.to_json
-  end
-
-  def render_json_hello_world_with_callback
-    render :json => {:hello => 'world'}.to_json, :callback => 'alert'
-  end
-
-  def render_json_with_custom_content_type
-    render :json => {:hello => 'world'}.to_json, :content_type => 'text/javascript'
-  end
-
-  def render_symbol_json
-    render :json => {:hello => 'world'}.to_json
-  end
-
-  def render_json_with_render_to_string
-    render :json => {:hello => render_to_string(:partial => 'partial')}
-  end
-
+  # :ported:
   def render_custom_code
     render :text => "hello world", :status => 404
   end
 
-  def render_custom_code_rjs
-    render :update, :status => 404 do |page|
-      page.replace :foo, :partial => 'partial'
-    end
-  end
-
+  # :ported:
   def render_text_with_nil
     render :text => nil
   end
 
+  # :ported:
   def render_text_with_false
     render :text => false
   end
 
+  # :ported:
   def render_nothing_with_appendix
     render :text => "appended"
   end
 
-  def render_vanilla_js_hello
-    render :js => "alert('hello')"
-  end
-
+  # This test is testing 3 things:
+  #   render :file in AV      :ported:
+  #   render :template in AC  :ported:
+  #   setting content type
   def render_xml_hello
     @name = "David"
     render :template => "test/hello"
@@ -249,10 +240,6 @@ class TestController < ActionController::Base
     render "test/hello"
   end
 
-  def render_xml_with_custom_content_type
-    render :xml => "<blah/>", :content_type => "application/atomsvc+xml"
-  end
-
   def render_line_offset
     render :inline => '<% raise %>', :locals => {:foo => 'bar'}
   end
@@ -265,22 +252,27 @@ class TestController < ActionController::Base
     # let's just rely on the template
   end
 
+  # :ported:
   def blank_response
     render :text => ' '
   end
 
+  # :ported:
   def layout_test
     render :action => "hello_world"
   end
 
+  # :ported:
   def builder_layout_test
     render :action => "hello", :layout => "layouts/builder"
   end
-
+  
+  # :move: test this in ActionView
   def builder_partial_test
     render :action => "hello_world_container"
   end
 
+  # :ported:
   def partials_list
     @test_unchanged = 'hello'
     @customers = [ Customer.new("david"), Customer.new("mary") ]
@@ -306,12 +298,6 @@ class TestController < ActionController::Base
            :locals => { :local_name => name }
   end
 
-  def render_implicit_html_template
-  end
-
-  def render_explicit_html_template
-  end
-
   def render_implicit_html_template_from_xhr_request
   end
 
@@ -386,6 +372,7 @@ class TestController < ActionController::Base
     render :layout => true, :inline =>  "Hello: <%= params[:name] %>"
   end
 
+  # :ported:
   def render_with_explicit_template
     render :template => "test/hello_world"
   end
@@ -394,10 +381,12 @@ class TestController < ActionController::Base
     render "test/hello_world"
   end
 
+  # :ported:
   def render_with_explicit_template_with_locals
     render :template => "test/render_file_with_locals", :locals => { :secret => 'area51' }
   end
 
+  # :ported:
   def double_render
     render :text => "hello"
     render :text => "world"
@@ -429,78 +418,24 @@ class TestController < ActionController::Base
     render :action => "potential_conflicts"
   end
 
+  # :deprecated:
+  # Tests being able to pick a .builder template over a .erb
+  # For instance, being able to have hello.xml.builder and hello.xml.erb
+  # and select one via "hello.builder" or "hello.erb"
   def hello_world_from_rxml_using_action
     render :action => "hello_world_from_rxml.builder"
   end
 
+  # :deprecated:
   def hello_world_from_rxml_using_template
     render :template => "test/hello_world_from_rxml.builder"
   end
 
-  module RenderTestHelper
-    def rjs_helper_method_from_module
-      page.visual_effect :highlight
-    end
-  end
-
-  helper RenderTestHelper
-  helper do
-    def rjs_helper_method(value)
-      page.visual_effect :highlight, value
-    end
-  end
-
-  def enum_rjs_test
-    render :update do |page|
-      page.select('.product').each do |value|
-        page.rjs_helper_method_from_module
-        page.rjs_helper_method(value)
-        page.sortable(value, :url => { :action => "order" })
-        page.draggable(value)
-      end
-    end
-  end
-
-  def delete_with_js
-    @project_id = 4
-  end
-
-  def render_js_with_explicit_template
-    @project_id = 4
-    render :template => 'test/delete_with_js'
-  end
-
-  def render_js_with_explicit_action_template
-    @project_id = 4
-    render :action => 'delete_with_js'
-  end
-
-  def update_page
-    render :update do |page|
-      page.replace_html 'balance', '$37,000,000.00'
-      page.visual_effect :highlight, 'balance'
-    end
-  end
-
-  def update_page_with_instance_variables
-    @money = '$37,000,000.00'
-    @div_id = 'balance'
-    render :update do |page|
-      page.replace_html @div_id, @money
-      page.visual_effect :highlight, @div_id
-    end
-  end
-
-  def update_page_with_view_method
-    render :update do |page|
-      page.replace_html 'person', pluralize(2, 'person')
-    end
-  end
-
   def action_talk_to_layout
     # Action template sets variable that's picked up by layout
   end
 
+  # :addressed:
   def render_text_with_assigns
     @hello = "world"
     render :text => "foo"
@@ -539,25 +474,6 @@ class TestController < ActionController::Base
     head :forbidden, :x_custom_header => "something"
   end
 
-  def render_with_location
-    render :xml => "<hello/>", :location => "http://example.com", :status => 201
-  end
-
-  def render_with_object_location
-    customer = Customer.new("Some guy", 1)
-    render :xml => "<customer/>", :location => customer_url(customer), :status => :created
-  end
-
-  def render_with_to_xml
-    to_xmlable = Class.new do
-      def to_xml
-        "<i-am-xml/>"
-      end
-    end.new
-
-    render :xml => to_xmlable
-  end
-
   def render_using_layout_around_block
     render :action => "using_layout_around_block"
   end
@@ -574,22 +490,6 @@ class TestController < ActionController::Base
     render :partial => 'partial.html.erb'
   end
 
-  def partial_as_rjs
-    render :update do |page|
-      page.replace :foo, :partial => 'partial'
-    end
-  end
-
-  def respond_to_partial_as_rjs
-    respond_to do |format|
-      format.js do
-        render :update do |page|
-          page.replace :foo, :partial => 'partial'
-        end
-      end
-    end
-  end
-
   def partial
     render :partial => 'partial'
   end
@@ -725,9 +625,7 @@ class TestController < ActionController::Base
              "accessing_params_in_template_with_layout",
              "render_with_explicit_template",
              "render_with_explicit_string_template",
-             "render_js_with_explicit_template",
-             "render_js_with_explicit_action_template",
-             "delete_with_js", "update_page", "update_page_with_instance_variables"
+             "update_page", "update_page_with_instance_variables"
 
           "layouts/standard"
         when "action_talk_to_layout", "layout_overriding_layout"
@@ -750,6 +648,7 @@ class RenderTest < ActionController::TestCase
     @request.host = "www.nextangle.com"
   end
 
+  # :ported:
   def test_simple_show
     get :hello_world
     assert_response 200
@@ -758,11 +657,13 @@ class RenderTest < ActionController::TestCase
     assert_equal "<html>Hello world!</html>", @response.body
   end
 
+  # :ported:
   def test_renders_default_template_for_missing_action
     get :'hyphen-ated'
     assert_template 'test/hyphen-ated'
   end
 
+  # :ported:
   def test_render
     get :render_hello_world
     assert_template "test/hello_world"
@@ -772,7 +673,7 @@ class RenderTest < ActionController::TestCase
     begin
       get :render_line_offset
       flunk "the action should have raised an exception"
-    rescue RuntimeError => exc
+    rescue StandardError => exc
       line = exc.backtrace.first
       assert(line =~ %r{:(\d+):})
       assert_equal "1", $1,
@@ -780,129 +681,118 @@ class RenderTest < ActionController::TestCase
     end
   end
 
+  # :ported: compatibility
   def test_render_with_forward_slash
     get :render_hello_world_with_forward_slash
     assert_template "test/hello_world"
   end
 
+  # :ported:
   def test_render_in_top_directory
     get :render_template_in_top_directory
     assert_template "shared"
     assert_equal "Elastica", @response.body
   end
 
+  # :ported:
   def test_render_in_top_directory_with_slash
     get :render_template_in_top_directory_with_slash
     assert_template "shared"
     assert_equal "Elastica", @response.body
   end
 
+  # :ported:
   def test_render_from_variable
     get :render_hello_world_from_variable
     assert_equal "hello david", @response.body
   end
 
+  # :ported:
   def test_render_action
     get :render_action_hello_world
     assert_template "test/hello_world"
   end
 
+  # :ported:
   def test_render_action_hello_world_as_string
     get :render_action_hello_world_as_string
     assert_equal "Hello world!", @response.body
     assert_template "test/hello_world"
   end
 
+  # :ported:
   def test_render_action_with_symbol
     get :render_action_hello_world_with_symbol
     assert_template "test/hello_world"
   end
 
+  # :ported:
   def test_render_text
     get :render_text_hello_world
     assert_equal "hello world", @response.body
   end
 
+  # :ported:
   def test_do_with_render_text_and_layout
     get :render_text_hello_world_with_layout
     assert_equal "<html>hello world, I'm here!</html>", @response.body
   end
 
+  # :ported:
   def test_do_with_render_action_and_layout_false
     get :hello_world_with_layout_false
     assert_equal 'Hello world!', @response.body
   end
 
+  # :ported:
   def test_render_file_with_instance_variables
     get :render_file_with_instance_variables
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_as_string_with_instance_variables
     get :render_file_as_string_with_instance_variables
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_not_using_full_path
     get :render_file_not_using_full_path
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_not_using_full_path_with_dot_in_path
     get :render_file_not_using_full_path_with_dot_in_path
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_using_pathname
     get :render_file_using_pathname
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_with_locals
     get :render_file_with_locals
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :ported:
   def test_render_file_as_string_with_locals
     get :render_file_as_string_with_locals
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
+  # :assessed:
   def test_render_file_from_template
     get :render_file_from_template
     assert_equal "The secret is in the sauce\n", @response.body
   end
 
-  def test_render_json
-    get :render_json_hello_world
-    assert_equal '{"hello": "world"}', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_render_json_with_callback
-    get :render_json_hello_world_with_callback
-    assert_equal 'alert({"hello": "world"})', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_render_json_with_custom_content_type
-    get :render_json_with_custom_content_type
-    assert_equal '{"hello": "world"}', @response.body
-    assert_equal 'text/javascript', @response.content_type
-  end
-
-  def test_render_symbol_json
-    get :render_symbol_json
-    assert_equal '{"hello": "world"}', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
-  def test_render_json_with_render_to_string
-    get :render_json_with_render_to_string
-    assert_equal '{"hello": "partial html"}', @response.body
-    assert_equal 'application/json', @response.content_type
-  end
-
+  # :ported:
   def test_render_custom_code
     get :render_custom_code
     assert_response 404
@@ -910,37 +800,37 @@ class RenderTest < ActionController::TestCase
     assert_equal 'hello world', @response.body
   end
 
-  def test_render_custom_code_rjs
-    get :render_custom_code_rjs
-    assert_response 404
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
+  # :ported:
   def test_render_text_with_nil
     get :render_text_with_nil
     assert_response 200
     assert_equal ' ', @response.body
   end
 
+  # :ported:
   def test_render_text_with_false
     get :render_text_with_false
     assert_equal 'false', @response.body
   end
 
+  # :ported:
   def test_render_nothing_with_appendix
     get :render_nothing_with_appendix
     assert_response 200
     assert_equal 'appended', @response.body
   end
 
+  # :ported:
   def test_attempt_to_access_object_method
     assert_raise(ActionController::UnknownAction, "No action responded to [clone]") { get :clone }
   end
 
+  # :ported:
   def test_private_methods
     assert_raise(ActionController::UnknownAction, "No action responded to [determine_layout]") { get :determine_layout }
   end
 
+  # :ported:
   def test_access_to_request_in_view
     get :accessing_request_in_template
     assert_equal "Hello: www.nextangle.com", @response.body
@@ -951,58 +841,45 @@ class RenderTest < ActionController::TestCase
     assert_equal "Logger", @response.body
   end
 
+  # :ported:
   def test_access_to_action_name_in_view
     get :accessing_action_name_in_template
     assert_equal "accessing_action_name_in_template", @response.body
   end
 
+  # :ported:
   def test_access_to_controller_name_in_view
     get :accessing_controller_name_in_template
     assert_equal "test", @response.body # name is explicitly set to 'test' inside the controller.
   end
 
-  def test_render_vanilla_js
-    get :render_vanilla_js_hello
-    assert_equal "alert('hello')", @response.body
-    assert_equal "text/javascript", @response.content_type
-  end
-
+  # :ported:
   def test_render_xml
     get :render_xml_hello
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
     assert_equal "application/xml", @response.content_type
   end
 
+  # :ported:
   def test_render_xml_as_string_template
     get :render_xml_hello_as_string_template
     assert_equal "<html>\n  <p>Hello David</p>\n<p>This is grand!</p>\n</html>\n", @response.body
     assert_equal "application/xml", @response.content_type
   end
 
+  # :ported:
   def test_render_xml_with_default
     get :greeting
     assert_equal "<p>This is grand!</p>\n", @response.body
   end
 
+  # :move: test in AV
   def test_render_xml_with_partial
     get :builder_partial_test
     assert_equal "<test>\n  <hello/>\n</test>\n", @response.body
   end
 
-  def test_enum_rjs_test
-    ActiveSupport::SecureRandom.stubs(:base64).returns("asdf")
-    get :enum_rjs_test
-    body = %{
-      $$(".product").each(function(value, index) {
-      new Effect.Highlight(element,{});
-      new Effect.Highlight(value,{});
-      Sortable.create(value, {onUpdate:function(){new Ajax.Request('/test/order', {asynchronous:true, evalScripts:true, parameters:Sortable.serialize(value) + '&authenticity_token=' + encodeURIComponent('asdf')})}});
-      new Draggable(value, {});
-      });
-    }.gsub(/^      /, '').strip
-    assert_equal body, @response.body
-  end
-
+  # :ported:
   def test_layout_rendering
     get :layout_test
     assert_equal "<html>Hello world!</html>", @response.body
@@ -1033,6 +910,7 @@ class RenderTest < ActionController::TestCase
     assert_template "test/hello_world"
   end
 
+  # :ported:
   def test_nested_rendering
     @controller = Fun::GamesController.new
     get :hello_world
@@ -1049,29 +927,10 @@ class RenderTest < ActionController::TestCase
     assert_equal "Goodbye, Local David", @response.body
   end
 
-  def test_render_in_an_rjs_template_should_pick_html_templates_when_available
-    [:js, "js"].each do |format|
-      assert_nothing_raised do
-        get :render_implicit_html_template, :format => format
-        assert_equal %(document.write("Hello world\\n");), @response.body
-      end
-    end
-  end
-
-  def test_explicitly_rendering_an_html_template_with_implicit_html_template_renders_should_be_possible_from_an_rjs_template
-    [:js, "js"].each do |format|
-      assert_nothing_raised do
-        get :render_explicit_html_template, :format => format
-        assert_equal %(document.write("Hello world\\n");), @response.body
-      end
-    end
-  end
-
   def test_should_implicitly_render_html_template_from_xhr_request
-    pending do
-      xhr :get, :render_implicit_html_template_from_xhr_request
-      assert_equal "XHR!\nHello HTML!", @response.body
-    end
+    pending
+    # xhr :get, :render_implicit_html_template_from_xhr_request
+    # assert_equal "XHR!\nHello HTML!", @response.body
   end
 
   def test_should_implicitly_render_js_template_without_layout
@@ -1086,11 +945,6 @@ class RenderTest < ActionController::TestCase
     assert_equal 'formatted html erb', @response.body
   end
 
-  def test_should_render_formatted_xml_erb_template
-    get :formatted_xml_erb, :format => :xml
-    assert_equal '<test>passed formatted xml erb</test>', @response.body
-  end
-
   def test_should_render_formatted_html_erb_template
     get :formatted_xml_erb
     assert_equal '<test>passed formatted html erb</test>', @response.body
@@ -1102,31 +956,6 @@ class RenderTest < ActionController::TestCase
     assert_equal '<test>passed formatted html erb</test>', @response.body
   end
 
-  def test_should_render_xml_but_keep_custom_content_type
-    get :render_xml_with_custom_content_type
-    assert_equal "application/atomsvc+xml", @response.content_type
-  end
-
-  def test_render_with_default_from_accept_header
-    xhr :get, :greeting
-    assert_equal "$(\"body\").visualEffect(\"highlight\");", @response.body
-  end
-
-  def test_render_rjs_with_default
-    get :delete_with_js
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
-  def test_render_rjs_template_explicitly
-    get :render_js_with_explicit_template
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
-  def test_rendering_rjs_action_explicitly
-    get :render_js_with_explicit_action_template
-    assert_equal %!Element.remove("person");\nnew Effect.Highlight(\"project-4\",{});!, @response.body
-  end
-
   def test_layout_test_with_different_layout
     get :layout_test_with_different_layout
     assert_equal "<html>Hello world!</html>", @response.body
@@ -1193,6 +1022,7 @@ class RenderTest < ActionController::TestCase
     assert_equal "<html>Hello world!</html>", @response.body
   end
 
+  # :ported:
   def test_double_render
     assert_raise(ActionController::DoubleRenderError) { get :double_render }
   end
@@ -1221,38 +1051,18 @@ class RenderTest < ActionController::TestCase
     assert_equal "<title>Talking to the layout</title>\nAction was here!", @response.body
   end
 
+  # :addressed:
   def test_render_text_with_assigns
     get :render_text_with_assigns
     assert_equal "world", assigns["hello"]
   end
 
+  # :ported:
   def test_template_with_locals
     get :render_with_explicit_template_with_locals
     assert_equal "The secret is area51\n", @response.body
   end
 
-  def test_update_page
-    get :update_page
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers['Content-Type']
-    assert_equal 2, @response.body.split($/).length
-  end
-
-  def test_update_page_with_instance_variables
-    get :update_page_with_instance_variables
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
-    assert_match /balance/, @response.body
-    assert_match /\$37/, @response.body
-  end
-
-  def test_update_page_with_view_method
-    get :update_page_with_view_method
-    assert_template nil
-    assert_equal 'text/javascript; charset=utf-8', @response.headers["Content-Type"]
-    assert_match /2 people/, @response.body
-  end
-
   def test_yield_content_for
     assert_not_deprecated { get :yield_content_for }
     assert_equal "<title>Putting stuff in the title!</title>\n\nGreat stuff!\n", @response.body
@@ -1282,15 +1092,15 @@ class RenderTest < ActionController::TestCase
 
   def test_head_with_symbolic_status
     get :head_with_symbolic_status, :status => "ok"
-    assert_equal "200 OK", @response.status
+    assert_equal 200, @response.status
     assert_response :ok
 
     get :head_with_symbolic_status, :status => "not_found"
-    assert_equal "404 Not Found", @response.status
+    assert_equal 404, @response.status
     assert_response :not_found
 
     get :head_with_symbolic_status, :status => "no_content"
-    assert_equal "204 No Content", @response.status
+    assert_equal 204, @response.status
     assert !@response.headers.include?('Content-Length')
     assert_response :no_content
 
@@ -1311,7 +1121,7 @@ class RenderTest < ActionController::TestCase
   def test_head_with_string_status
     get :head_with_string_status, :status => "404 Eat Dirt"
     assert_equal 404, @response.response_code
-    assert_equal "Eat Dirt", @response.message
+    assert_equal "Not Found", @response.message
     assert_response :not_found
   end
 
@@ -1323,31 +1133,6 @@ class RenderTest < ActionController::TestCase
     assert_response :forbidden
   end
 
-  def test_rendering_with_location_should_set_header
-    get :render_with_location
-    assert_equal "http://example.com", @response.headers["Location"]
-  end
-
-  def test_rendering_xml_should_call_to_xml_if_possible
-    get :render_with_to_xml
-    assert_equal "<i-am-xml/>", @response.body
-  end
-
-  def test_rendering_with_object_location_should_set_header_with_url_for
-    ActionController::Routing::Routes.draw do |map|
-      map.resources :customers
-      map.connect ':controller/:action/:id'
-    end
-
-    get :render_with_object_location
-    assert_equal "http://www.nextangle.com/customers/1", @response.headers["Location"]
-  end
-
-  def test_should_use_implicit_content_type
-    get :implicit_content_type, :format => 'atom'
-    assert_equal Mime::ATOM, @response.content_type
-  end
-
   def test_using_layout_around_block
     get :render_using_layout_around_block
     assert_equal "Before (David)\nInside from block\nAfter", @response.body
@@ -1378,26 +1163,6 @@ class RenderTest < ActionController::TestCase
     assert_equal 'partial html', @response.body
   end
 
-  def test_should_render_html_formatted_partial_with_rjs
-    xhr :get, :partial_as_rjs
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_should_render_html_formatted_partial_with_rjs_and_js_format
-    xhr :get, :respond_to_partial_as_rjs
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
-  def test_should_render_js_partial
-    xhr :get, :partial, :format => 'js'
-    assert_equal 'partial js', @response.body
-  end
-
-  def test_should_render_with_alternate_default_render
-    xhr :get, :render_alternate_default
-    assert_equal %(Element.replace("foo", "partial html");), @response.body
-  end
-
   def test_partial_only_with_layout
     get :partial_only_with_layout
     assert_equal "<html>only partial</html>", @response.body
@@ -1579,7 +1344,7 @@ class EtagRenderTest < ActionController::TestCase
   def test_render_against_etag_request_should_304_when_match
     @request.if_none_match = etag_for("hello david")
     get :render_hello_world_from_variable
-    assert_equal "304 Not Modified", @response.status
+    assert_equal 304, @response.status.to_i
     assert @response.body.empty?
   end
 
@@ -1592,13 +1357,13 @@ class EtagRenderTest < ActionController::TestCase
   def test_render_against_etag_request_should_200_when_no_match
     @request.if_none_match = etag_for("hello somewhere else")
     get :render_hello_world_from_variable
-    assert_equal "200 OK", @response.status
+    assert_equal 200, @response.status.to_i
     assert !@response.body.empty?
   end
 
   def test_render_should_not_set_etag_when_last_modified_has_been_specified
     get :render_hello_world_with_last_modified_set
-    assert_equal "200 OK", @response.status
+    assert_equal 200, @response.status.to_i
     assert_not_nil @response.last_modified
     assert_nil @response.etag
     assert @response.body.present?
@@ -1612,11 +1377,12 @@ class EtagRenderTest < ActionController::TestCase
 
     @request.if_none_match = expected_etag
     get :render_hello_world_from_variable
-    assert_equal "304 Not Modified", @response.status
+    assert_equal 304, @response.status.to_i
 
+    @response = ActionController::TestResponse.new
     @request.if_none_match = "\"diftag\""
     get :render_hello_world_from_variable
-    assert_equal "200 OK", @response.status
+    assert_equal 200, @response.status.to_i
   end
 
   def render_with_404_shouldnt_have_etag
@@ -1684,7 +1450,7 @@ class LastModifiedRenderTest < ActionController::TestCase
   def test_request_not_modified
     @request.if_modified_since = @last_modified
     get :conditional_hello
-    assert_equal "304 Not Modified", @response.status
+    assert_equal 304, @response.status.to_i
     assert @response.body.blank?, @response.body
     assert_equal @last_modified, @response.headers['Last-Modified']
   end
@@ -1699,7 +1465,7 @@ class LastModifiedRenderTest < ActionController::TestCase
   def test_request_modified
     @request.if_modified_since = 'Thu, 16 Jul 2008 00:00:00 GMT'
     get :conditional_hello
-    assert_equal "200 OK", @response.status
+    assert_equal 200, @response.status.to_i
     assert !@response.body.blank?
     assert_equal @last_modified, @response.headers['Last-Modified']
   end
@@ -1735,7 +1501,7 @@ class RenderingLoggingTest < ActionController::TestCase
     @controller.logger = MockLogger.new
     get :layout_test
     logged = @controller.logger.logged.find_all {|l| l =~ /render/i }
-    assert_equal "Rendering test/hello_world", logged[0]
-    assert_equal "Rendering template within layouts/standard", logged[1]
+    assert logged[0] =~ %r{Rendering.*test/hello_world}
+    assert logged[1] =~ %r{Rendering template within.*layouts/standard}
   end
 end
diff --git a/actionpack/test/controller/render_xml_test.rb b/actionpack/test/controller/render_xml_test.rb
new file mode 100644
index 0000000000..052b4f0b52
--- /dev/null
+++ b/actionpack/test/controller/render_xml_test.rb
@@ -0,0 +1,81 @@
+require 'abstract_unit'
+require 'controller/fake_models'
+require 'pathname'
+
+class TestController < ActionController::Base
+  protect_from_forgery
+
+  def render_with_location
+    render :xml => "<hello/>", :location => "http://example.com", :status => 201
+  end
+
+  def render_with_object_location
+    customer = Customer.new("Some guy", 1)
+    render :xml => "<customer/>", :location => customer_url(customer), :status => :created
+  end
+
+  def render_with_to_xml
+    to_xmlable = Class.new do
+      def to_xml
+        "<i-am-xml/>"
+      end
+    end.new
+
+    render :xml => to_xmlable
+  end
+  
+  def formatted_xml_erb
+  end
+  
+  def render_xml_with_custom_content_type
+    render :xml => "<blah/>", :content_type => "application/atomsvc+xml"
+  end    
+end
+
+class RenderTest < ActionController::TestCase
+  tests TestController
+
+  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".
+    super
+    @controller.logger = Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end  
+  
+  def test_rendering_with_location_should_set_header
+    get :render_with_location
+    assert_equal "http://example.com", @response.headers["Location"]
+  end
+
+  def test_rendering_xml_should_call_to_xml_if_possible
+    get :render_with_to_xml
+    assert_equal "<i-am-xml/>", @response.body
+  end
+  
+  def test_rendering_with_object_location_should_set_header_with_url_for
+    ActionController::Routing::Routes.draw do |map|
+      map.resources :customers
+      map.connect ':controller/:action/:id'
+    end
+
+    get :render_with_object_location
+    assert_equal "http://www.nextangle.com/customers/1", @response.headers["Location"]
+  end
+  
+  def test_should_render_formatted_xml_erb_template
+    get :formatted_xml_erb, :format => :xml
+    assert_equal '<test>passed formatted xml erb</test>', @response.body
+  end
+  
+  def test_should_render_xml_but_keep_custom_content_type
+    get :render_xml_with_custom_content_type
+    assert_equal "application/atomsvc+xml", @response.content_type
+  end
+  
+  def test_should_use_implicit_content_type
+    get :implicit_content_type, :format => 'atom'
+    assert_equal Mime::ATOM, @response.content_type
+  end    
+end
\ No newline at end of file
diff --git a/actionpack/test/controller/request/test_request_test.rb b/actionpack/test/controller/request/test_request_test.rb
index 81551b4ba7..0a39feb7fe 100644
--- a/actionpack/test/controller/request/test_request_test.rb
+++ b/actionpack/test/controller/request/test_request_test.rb
@@ -10,26 +10,27 @@ class ActionController::TestRequestTest < ActiveSupport::TestCase
   def test_test_request_has_session_options_initialized
     assert @request.session_options
   end
-  
-  Rack::Session::Abstract::ID::DEFAULT_OPTIONS.each_key do |option|
-    test "test_rack_default_session_options_#{option}_exists_in_session_options_and_is_default" do
-      assert_equal(Rack::Session::Abstract::ID::DEFAULT_OPTIONS[option], 
-                   @request.session_options[option], 
+
+  ActionDispatch::Session::AbstractStore::DEFAULT_OPTIONS.each_key do |option|
+    test "rack default session options #{option} exists in session options and is default" do
+      assert_equal(ActionDispatch::Session::AbstractStore::DEFAULT_OPTIONS[option],
+                   @request.session_options[option],
                    "Missing rack session default option #{option} in request.session_options")
     end
-    test "test_rack_default_session_options_#{option}_exists_in_session_options" do
-      assert(@request.session_options.has_key?(option), 
+
+    test "rack default session options #{option} exists in session options" do
+      assert(@request.session_options.has_key?(option),
                    "Missing rack session option #{option} in request.session_options")
     end
   end
-  
+
   def test_session_id_exists_by_default
     assert_not_nil(@request.session_options[:id])
   end
-  
+
   def test_session_id_different_on_each_call
-    prev_id = 
+    prev_id =
     assert_not_equal(@request.session_options[:id], ActionController::TestRequest.new.session_options[:id])
   end
-  
+
 end
\ No newline at end of file
diff --git a/actionpack/test/controller/rescue_test.rb b/actionpack/test/controller/rescue_test.rb
index 894420a910..490a4ff3b3 100644
--- a/actionpack/test/controller/rescue_test.rb
+++ b/actionpack/test/controller/rescue_test.rb
@@ -1,5 +1,19 @@
 require 'abstract_unit'
 
+module ActionDispatch
+  class ShowExceptions
+    private
+      def public_path
+        "#{FIXTURE_LOAD_PATH}/public"
+      end
+
+      # Silence logger
+      def logger
+        nil
+      end
+  end
+end
+
 class RescueController < ActionController::Base
   class NotAuthorized < StandardError
   end
@@ -138,213 +152,88 @@ class RescueController < ActionController::Base
     end
 end
 
-class RescueControllerTest < ActionController::TestCase
-  FIXTURE_PUBLIC = "#{File.dirname(__FILE__)}/../fixtures".freeze
-
-  def setup
-    super
-    set_all_requests_local
-    populate_exception_object
-  end
-
-  def set_all_requests_local
-    RescueController.consider_all_requests_local = true
-    @request.remote_addr = '1.2.3.4'
-    @request.host = 'example.com'
-  end
-
-  def populate_exception_object
-    begin
-      raise 'foo'
-    rescue => @exception
-    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
+class ExceptionInheritanceRescueController < ActionController::Base
 
-    assert_response :internal_server_error
+  class ParentException < StandardError
   end
 
-  def test_rescue_action_locally_if_all_requests_local
-    @controller.expects(:local_request?).never
-    @controller.expects(:rescue_action_locally).with(@exception)
-    @controller.expects(:rescue_action_in_public).never
-
-    with_all_requests_local do
-      @controller.send :rescue_action, @exception
-    end
+  class ChildException < ParentException
   end
 
-  def test_rescue_action_locally_if_remote_addr_is_localhost
-    @controller.expects(:local_request?).returns(true)
-    @controller.expects(:rescue_action_locally).with(@exception)
-    @controller.expects(:rescue_action_in_public).never
-
-    with_all_requests_local false do
-      @controller.send :rescue_action, @exception
-    end
+  class GrandchildException < ChildException
   end
 
-  def test_rescue_action_in_public_otherwise
-    @controller.expects(:local_request?).returns(false)
-    @controller.expects(:rescue_action_locally).never
-    @controller.expects(:rescue_action_in_public).with(@exception)
+  rescue_from ChildException,      :with => lambda { head :ok }
+  rescue_from ParentException,     :with => lambda { head :created }
+  rescue_from GrandchildException, :with => lambda { head :no_content }
 
-    with_all_requests_local false do
-      @controller.send :rescue_action, @exception
-    end
+  def raise_parent_exception
+    raise ParentException
   end
 
-  def test_rescue_action_in_public_with_localized_error_file
-    # Change locale
-    old_locale = I18n.locale
-    I18n.locale = :da
-
-    with_rails_root FIXTURE_PUBLIC do
-      with_all_requests_local false do
-        get :raises
-      end
-    end
-
-    assert_response :internal_server_error
-    body = File.read("#{FIXTURE_PUBLIC}/public/500.da.html")
-    assert_equal body, @response.body
-  ensure
-    I18n.locale = old_locale
+  def raise_child_exception
+    raise ChildException
   end
 
-  def test_rescue_action_in_public_with_error_file
-    with_rails_root FIXTURE_PUBLIC do
-      with_all_requests_local false do
-        get :raises
-      end
-    end
-
-    assert_response :internal_server_error
-    body = File.read("#{FIXTURE_PUBLIC}/public/500.html")
-    assert_equal body, @response.body
+  def raise_grandchild_exception
+    raise GrandchildException
   end
+end
 
-  def test_rescue_action_in_public_without_error_file
-    with_rails_root '/tmp' do
-      with_all_requests_local false do
-        get :raises
-      end
-    end
-
-    assert_response :internal_server_error
-    assert_equal ' ', @response.body
+class ExceptionInheritanceRescueControllerTest < ActionController::TestCase
+  def test_bottom_first
+    get :raise_grandchild_exception
+    assert_response :no_content
   end
 
-  def test_rescue_unknown_action_in_public_with_error_file
-    with_rails_root FIXTURE_PUBLIC do
-      with_all_requests_local false do
-        get :foobar_doesnt_exist
-      end
-    end
-
-    assert_response :not_found
-    body = File.read("#{FIXTURE_PUBLIC}/public/404.html")
-    assert_equal body, @response.body
+  def test_inheritance_works
+    get :raise_child_exception
+    assert_response :created
   end
+end
 
-  def test_rescue_unknown_action_in_public_without_error_file
-    with_rails_root '/tmp' do
-      with_all_requests_local false do
-        get :foobar_doesnt_exist
-      end
-    end
-
-    assert_response :not_found
-    assert_equal ' ', @response.body
+class ControllerInheritanceRescueController < ExceptionInheritanceRescueController
+  class FirstExceptionInChildController < StandardError
   end
 
-  def test_rescue_missing_template_in_public
-    with_rails_root FIXTURE_PUBLIC do
-      with_all_requests_local true do
-        get :missing_template
-      end
-    end
-
-    assert_response :internal_server_error
-    assert @response.body.include?('missing_template'), "Response should include the template name."
+  class SecondExceptionInChildController < StandardError
   end
 
-  def test_rescue_action_locally
-    get :raises
-    assert_response :internal_server_error
-    assert_template 'diagnostics.erb'
-    assert @response.body.include?('RescueController#raises'), "Response should include controller and action."
-    assert @response.body.include?("don't panic"), "Response should include exception message."
-  end
+  rescue_from FirstExceptionInChildController, 'SecondExceptionInChildController', :with => lambda { head :gone }
 
-  def test_local_request_when_remote_addr_is_localhost
-    @controller.expects(:request).returns(@request).at_least_once
-    with_remote_addr '127.0.0.1' do
-      assert @controller.send(:local_request?)
-    end
+  def raise_first_exception_in_child_controller
+    raise FirstExceptionInChildController
   end
 
-  def test_local_request_when_remote_addr_isnt_locahost
-    @controller.expects(:request).returns(@request)
-    with_remote_addr '1.2.3.4' do
-      assert !@controller.send(:local_request?)
-    end
+  def raise_second_exception_in_child_controller
+    raise SecondExceptionInChildController
   end
+end
 
-  def test_rescue_responses
-    responses = ActionController::Base.rescue_responses
-
-    assert_equal ActionController::Rescue::DEFAULT_RESCUE_RESPONSE, responses.default
-    assert_equal ActionController::Rescue::DEFAULT_RESCUE_RESPONSE, responses[Exception.new]
-
-    assert_equal :not_found, responses[ActionController::RoutingError.name]
-    assert_equal :not_found, responses[ActionController::UnknownAction.name]
-    assert_equal :not_found, responses['ActiveRecord::RecordNotFound']
-    assert_equal :conflict, responses['ActiveRecord::StaleObjectError']
-    assert_equal :unprocessable_entity, responses['ActiveRecord::RecordInvalid']
-    assert_equal :unprocessable_entity, responses['ActiveRecord::RecordNotSaved']
-    assert_equal :method_not_allowed, responses['ActionController::MethodNotAllowed']
-    assert_equal :not_implemented, responses['ActionController::NotImplemented']
+class ControllerInheritanceRescueControllerTest < ActionController::TestCase
+  def test_first_exception_in_child_controller
+    get :raise_first_exception_in_child_controller
+    assert_response :gone
   end
 
-  def test_rescue_templates
-    templates = ActionController::Base.rescue_templates
-
-    assert_equal ActionController::Rescue::DEFAULT_RESCUE_TEMPLATE, templates.default
-    assert_equal ActionController::Rescue::DEFAULT_RESCUE_TEMPLATE, templates[Exception.new]
-
-    assert_equal 'missing_template',  templates[ActionView::MissingTemplate.name]
-    assert_equal 'routing_error',     templates[ActionController::RoutingError.name]
-    assert_equal 'unknown_action',    templates[ActionController::UnknownAction.name]
-    assert_equal 'template_error',    templates[ActionView::TemplateError.name]
+  def test_second_exception_in_child_controller
+    get :raise_second_exception_in_child_controller
+    assert_response :gone
   end
 
-  def test_not_implemented
-    with_all_requests_local false do
-      with_rails_public_path(".") do
-        head :not_implemented
-      end
-    end
-    assert_response :not_implemented
-    assert_equal "GET, PUT", @response.headers['Allow']
+  def test_exception_in_parent_controller
+    get :raise_parent_exception
+    assert_response :created
   end
+end
 
-  def test_method_not_allowed
-    with_all_requests_local false do
-      with_rails_public_path(".") do
-        get :method_not_allowed
-      end
-    end
-    assert_response :method_not_allowed
-    assert_equal "GET, HEAD, PUT", @response.headers['Allow']
+class ApplicationController < ActionController::Base
+  rescue_from ActionController::RoutingError do
+    render :text => 'no way'
   end
+end
 
+class RescueControllerTest < ActionController::TestCase
   def test_rescue_handler
     get :not_authorized
     assert_response :forbidden
@@ -399,133 +288,6 @@ class RescueControllerTest < ActionController::TestCase
     get :resource_unavailable_raise_as_string
     assert_equal "RescueController::ResourceUnavailableToRescueAsString", @response.body
   end
-
-  protected
-    def with_all_requests_local(local = true)
-      old_local, ActionController::Base.consider_all_requests_local =
-        ActionController::Base.consider_all_requests_local, local
-      yield
-    ensure
-      ActionController::Base.consider_all_requests_local = old_local
-    end
-
-    def with_remote_addr(addr)
-      old_remote_addr, @request.remote_addr = @request.remote_addr, addr
-      yield
-    ensure
-      @request.remote_addr = old_remote_addr
-    end
-
-    def with_rails_public_path(rails_root)
-      old_rails = Object.const_get(:Rails) rescue nil
-      mod = Object.const_set(:Rails, Module.new)
-      (class << mod; self; end).instance_eval do
-        define_method(:public_path) { "#{rails_root}/public" }
-      end
-      yield
-    ensure
-      Object.module_eval { remove_const(:Rails) } if defined?(Rails)
-      Object.const_set(:Rails, old_rails) if old_rails
-    end
-
-    def with_rails_root(path = nil,&block)
-      old_rails_root = RAILS_ROOT if defined?(RAILS_ROOT)
-      if path
-        silence_warnings { Object.const_set(:RAILS_ROOT, path) }
-      else
-        Object.remove_const(:RAILS_ROOT) rescue nil
-      end
-
-      with_rails_public_path(path, &block)
-
-    ensure
-      if old_rails_root
-        silence_warnings { Object.const_set(:RAILS_ROOT, old_rails_root) }
-      else
-        Object.remove_const(:RAILS_ROOT) rescue nil
-      end
-    end
-end
-
-class ExceptionInheritanceRescueController < ActionController::Base
-
-  class ParentException < StandardError
-  end
-
-  class ChildException < ParentException
-  end
-
-  class GrandchildException < ChildException
-  end
-
-  rescue_from ChildException,      :with => lambda { head :ok }
-  rescue_from ParentException,     :with => lambda { head :created }
-  rescue_from GrandchildException, :with => lambda { head :no_content }
-
-  def raise_parent_exception
-    raise ParentException
-  end
-
-  def raise_child_exception
-    raise ChildException
-  end
-
-  def raise_grandchild_exception
-    raise GrandchildException
-  end
-end
-
-class ExceptionInheritanceRescueControllerTest < ActionController::TestCase
-  def test_bottom_first
-    get :raise_grandchild_exception
-    assert_response :no_content
-  end
-
-  def test_inheritance_works
-    get :raise_child_exception
-    assert_response :created
-  end
-end
-
-class ControllerInheritanceRescueController < ExceptionInheritanceRescueController
-  class FirstExceptionInChildController < StandardError
-  end
-
-  class SecondExceptionInChildController < StandardError
-  end
-
-  rescue_from FirstExceptionInChildController, 'SecondExceptionInChildController', :with => lambda { head :gone }
-
-  def raise_first_exception_in_child_controller
-    raise FirstExceptionInChildController
-  end
-
-  def raise_second_exception_in_child_controller
-    raise SecondExceptionInChildController
-  end
-end
-
-class ControllerInheritanceRescueControllerTest < ActionController::TestCase
-  def test_first_exception_in_child_controller
-    get :raise_first_exception_in_child_controller
-    assert_response :gone
-  end
-
-  def test_second_exception_in_child_controller
-    get :raise_second_exception_in_child_controller
-    assert_response :gone
-  end
-
-  def test_exception_in_parent_controller
-    get :raise_parent_exception
-    assert_response :created
-  end
-end
-
-class ApplicationController < ActionController::Base
-  rescue_from ActionController::RoutingError do
-    render :text => 'no way'
-  end
 end
 
 class RescueTest < ActionController::IntegrationTest
diff --git a/actionpack/test/controller/resources_test.rb b/actionpack/test/controller/resources_test.rb
index c807e71cd7..30ab110ef7 100644
--- a/actionpack/test/controller/resources_test.rb
+++ b/actionpack/test/controller/resources_test.rb
@@ -120,6 +120,14 @@ class ResourcesTest < ActionController::TestCase
     end
   end
 
+  def test_irregular_id_requirements_should_get_passed_to_member_actions
+    expected_options = {:controller => 'messages', :action => 'custom', :id => '1.1.1'}
+
+    with_restful_routing(:messages, :member => {:custom => :get}, :requirements => {:id => /[0-9]\.[0-9]\.[0-9]/}) do
+      assert_recognizes(expected_options, :path => 'messages/1.1.1/custom', :method => :get)
+    end
+  end
+
   def test_with_path_prefix
     with_restful_routing :messages, :path_prefix => '/thread/:thread_id' do
       assert_simply_restful_for :messages, :path_prefix => 'thread/5/', :options => { :thread_id => '5' }
diff --git a/actionpack/test/controller/routing_test.rb b/actionpack/test/controller/routing_test.rb
index ef56119751..1694fc8f3e 100644
--- a/actionpack/test/controller/routing_test.rb
+++ b/actionpack/test/controller/routing_test.rb
@@ -1,5 +1,6 @@
 require 'abstract_unit'
 require 'controller/fake_controllers'
+require 'active_support/dependencies'
 
 class MilestonesController < ActionController::Base
   def index() head :ok end
@@ -89,6 +90,11 @@ class StaticSegmentTest < Test::Unit::TestCase
     assert_equal 'Hello World', s.interpolation_chunk
   end
 
+  def test_value_should_not_be_double_unescaped
+    s = ROUTING::StaticSegment.new('%D0%9A%D0%B0%D1%80%D1%82%D0%B0') # Карта
+    assert_equal '%D0%9A%D0%B0%D1%80%D1%82%D0%B0', s.interpolation_chunk
+  end
+
   def test_regexp_chunk_should_escape_specials
     s = ROUTING::StaticSegment.new('Hello*World')
     assert_equal 'Hello\*World', s.regexp_chunk
@@ -1923,7 +1929,7 @@ class RouteSetTest < Test::Unit::TestCase
       end
     end
 
-    request.path = "/people"
+    request.request_uri = "/people"
     request.env["REQUEST_METHOD"] = "GET"
     assert_nothing_raised { set.recognize(request) }
     assert_equal("index", request.path_parameters[:action])
@@ -1945,7 +1951,7 @@ class RouteSetTest < Test::Unit::TestCase
     }
     request.recycle!
 
-    request.path = "/people/5"
+    request.request_uri = "/people/5"
     request.env["REQUEST_METHOD"] = "GET"
     assert_nothing_raised { set.recognize(request) }
     assert_equal("show", request.path_parameters[:action])
@@ -2047,7 +2053,7 @@ class RouteSetTest < Test::Unit::TestCase
       end
     end
 
-    request.path = "/people/5"
+    request.request_uri = "/people/5"
     request.env["REQUEST_METHOD"] = "GET"
     assert_nothing_raised { set.recognize(request) }
     assert_equal("show", request.path_parameters[:action])
@@ -2059,7 +2065,7 @@ class RouteSetTest < Test::Unit::TestCase
     assert_equal("update", request.path_parameters[:action])
     request.recycle!
 
-    request.path = "/people/5.png"
+    request.request_uri = "/people/5.png"
     request.env["REQUEST_METHOD"] = "GET"
     assert_nothing_raised { set.recognize(request) }
     assert_equal("show", request.path_parameters[:action])
diff --git a/actionpack/test/controller/selector_test.rb b/actionpack/test/controller/selector_test.rb
index 9d0613d1e2..5a5dc840b5 100644
--- a/actionpack/test/controller/selector_test.rb
+++ b/actionpack/test/controller/selector_test.rb
@@ -5,6 +5,7 @@
 
 require 'abstract_unit'
 require 'controller/fake_controllers'
+require 'action_controller/vendor/html-scanner'
 
 class SelectorTest < Test::Unit::TestCase
   #
diff --git a/actionpack/test/controller/send_file_test.rb b/actionpack/test/controller/send_file_test.rb
index 2e14a0a32c..0bc0eb2df6 100644
--- a/actionpack/test/controller/send_file_test.rb
+++ b/actionpack/test/controller/send_file_test.rb
@@ -11,12 +11,17 @@ class SendFileController < ActionController::Base
   layout "layouts/standard" # to make sure layouts don't interfere
 
   attr_writer :options
-  def options() @options ||= {} end
+  def options
+    @options ||= {}
+  end
 
-  def file() send_file(file_path, options) end
-  def data() send_data(file_data, options) end
+  def file
+    send_file(file_path, options)
+  end
 
-  def rescue_action(e) raise end
+  def data
+    send_data(file_data, options)
+  end
 end
 
 class SendFileTest < ActionController::TestCase
@@ -40,17 +45,19 @@ class SendFileTest < ActionController::TestCase
     assert_equal file_data, response.body
   end
 
-  def test_file_stream
-    response = nil
-    assert_nothing_raised { response = process('file') }
-    assert_not_nil response
-    assert_kind_of Proc, response.body_parts
-
-    require 'stringio'
-    output = StringIO.new
-    output.binmode
-    assert_nothing_raised { response.body_parts.call(response, output) }
-    assert_equal file_data, output.string
+  for_tag(:old_base) do
+    def test_file_stream
+      response = nil
+      assert_nothing_raised { response = process('file') }
+      assert_not_nil response
+      assert_kind_of Array, response.body_parts
+
+      require 'stringio'
+      output = StringIO.new
+      output.binmode
+      assert_nothing_raised { response.body_parts.each { |part| output << part.to_s } }
+      assert_equal file_data, output.string
+    end
   end
 
   def test_file_url_based_filename
@@ -149,13 +156,13 @@ class SendFileTest < ActionController::TestCase
     define_method "test_send_#{method}_status" do
       @controller.options = { :stream => false, :status => 500 }
       assert_nothing_raised { assert_not_nil process(method) }
-      assert_equal '500 Internal Server Error', @response.status
+      assert_equal 500, @response.status
     end
 
     define_method "test_default_send_#{method}_status" do
       @controller.options = { :stream => false }
       assert_nothing_raised { assert_not_nil process(method) }
-      assert_equal ActionController::DEFAULT_RENDER_STATUS_CODE, @response.status
+      assert_equal 200, @response.status
     end
   end
 end
diff --git a/actionpack/test/controller/test_test.rb b/actionpack/test/controller/test_test.rb
index 124e259ef6..9e88188b9a 100644
--- a/actionpack/test/controller/test_test.rb
+++ b/actionpack/test/controller/test_test.rb
@@ -184,12 +184,6 @@ XML
     assert_equal Hash.new, @controller.session.to_hash
   end
 
-  def test_session_is_cleared_from_response_after_reset_session
-    process :set_session
-    process :reset_the_session
-    assert_equal Hash.new, @response.session.to_hash
-  end
-
   def test_session_is_cleared_from_request_after_reset_session
     process :set_session
     process :reset_the_session
@@ -207,7 +201,7 @@ XML
   end
 
   def test_process_with_request_uri_with_params_with_explicit_uri
-    @request.set_REQUEST_URI "/explicit/uri"
+    @request.request_uri = "/explicit/uri"
     process :test_uri, :id => 7
     assert_equal "/explicit/uri", @response.body
   end
@@ -218,7 +212,7 @@ XML
   end
 
   def test_process_with_query_string_with_explicit_uri
-    @request.set_REQUEST_URI "/explicit/uri?q=test?extra=question"
+    @request.request_uri = "/explicit/uri?q=test?extra=question"
     process :test_query_string
     assert_equal "q=test?extra=question", @response.body
   end
@@ -620,7 +614,9 @@ XML
 
   def test_binary_content_works_with_send_file
     get :test_send_file
-    assert_nothing_raised(NoMethodError) { @response.binary_content }
+    assert_deprecated do
+      assert_nothing_raised(NoMethodError) { @response.binary_content }
+    end
   end
 
   protected
@@ -635,33 +631,6 @@ XML
     end
 end
 
-class CleanBacktraceTest < ActionController::TestCase
-  def test_should_reraise_the_same_object
-    exception = ActiveSupport::TestCase::Assertion.new('message')
-    clean_backtrace { raise exception }
-  rescue Exception => caught
-    assert_equal exception.object_id, caught.object_id
-    assert_equal exception.message, caught.message
-  end
-
-  def test_should_clean_assertion_lines_from_backtrace
-    path = File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller/testing")
-    exception = ActiveSupport::TestCase::Assertion.new('message')
-    exception.set_backtrace ["#{path}/abc", "#{path}/assertions/def"]
-    clean_backtrace { raise exception }
-  rescue Exception => caught
-    assert_equal ["#{path}/abc"], caught.backtrace
-  end
-
-  def test_should_only_clean_assertion_failure_errors
-    clean_backtrace do
-      raise "can't touch this", [File.expand_path("#{File.dirname(__FILE__)}/../../lib/action_controller/assertions/abc")]
-    end
-  rescue => caught
-    assert !caught.backtrace.empty?
-  end
-end
-
 class InferringClassNameTest < ActionController::TestCase
   def test_determine_controller_class
     assert_equal ContentController, determine_class("ContentControllerTest")
diff --git a/actionpack/test/controller/verification_test.rb b/actionpack/test/controller/verification_test.rb
index 418a81baa8..d568030e41 100644
--- a/actionpack/test/controller/verification_test.rb
+++ b/actionpack/test/controller/verification_test.rb
@@ -103,17 +103,15 @@ class VerificationTest < ActionController::TestCase
     end
 
     protected
-      def rescue_action(e) raise end
 
-      def unconditional_redirect
-        redirect_to :action => "unguarded"
-      end
+    def unconditional_redirect
+      redirect_to :action => "unguarded"
+    end
   end
 
-  def setup
-    @controller = TestController.new
-    @request    = ActionController::TestRequest.new
-    @response   = ActionController::TestResponse.new
+  tests TestController
+
+  setup do
     ActionController::Routing::Routes.add_named_route :foo, '/foo', :controller => 'test', :action => 'foo'
   end
 
@@ -184,7 +182,7 @@ class VerificationTest < ActionController::TestCase
 
   def test_unguarded_without_params
     get :unguarded
-    assert_equal "", @response.body
+    assert @response.body.blank?
   end
 
   def test_guarded_in_session_with_prereqs
diff --git a/actionpack/test/controller/view_paths_test.rb b/actionpack/test/controller/view_paths_test.rb
index 1539f8f506..c732d1c910 100644
--- a/actionpack/test/controller/view_paths_test.rb
+++ b/actionpack/test/controller/view_paths_test.rb
@@ -20,9 +20,9 @@ class ViewLoadPathsTest < ActionController::TestCase
     layout 'test/sub'
     def hello_world; render(:template => 'test/hello_world'); end
   end
-
+  
   def setup
-    TestController.view_paths = nil
+    # TestController.view_paths = nil
 
     @request  = ActionController::TestRequest.new
     @response = ActionController::TestResponse.new
@@ -42,30 +42,39 @@ class ViewLoadPathsTest < ActionController::TestCase
     ActiveSupport::Deprecation.behavior = @old_behavior
   end
 
+  def expand(array)
+    array.map {|x| File.expand_path(x)}
+  end
+
+  def assert_paths(*paths)
+    controller = paths.first.is_a?(Class) ? paths.shift : @controller
+    assert_equal expand(paths), controller.view_paths.map { |p| p.to_s }
+  end
+
   def test_template_load_path_was_set_correctly
-    assert_equal [FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths FIXTURE_LOAD_PATH
   end
 
   def test_controller_appends_view_path_correctly
     @controller.append_view_path 'foo'
-    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
+    assert_paths(FIXTURE_LOAD_PATH, "foo")
 
     @controller.append_view_path(%w(bar baz))
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
-
+    assert_paths(FIXTURE_LOAD_PATH, "foo", "bar", "baz")
+    
     @controller.append_view_path(FIXTURE_LOAD_PATH)
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths(FIXTURE_LOAD_PATH, "foo", "bar", "baz", FIXTURE_LOAD_PATH)
   end
 
   def test_controller_prepends_view_path_correctly
     @controller.prepend_view_path 'baz'
-    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths("baz", FIXTURE_LOAD_PATH)
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths "foo", "bar", "baz", FIXTURE_LOAD_PATH
 
     @controller.prepend_view_path(FIXTURE_LOAD_PATH)
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths FIXTURE_LOAD_PATH, "foo", "bar", "baz", FIXTURE_LOAD_PATH
   end
 
   def test_template_appends_view_path_correctly
@@ -73,11 +82,11 @@ class ViewLoadPathsTest < ActionController::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.append_view_path 'foo'
-    assert_equal [FIXTURE_LOAD_PATH, 'foo'], @controller.view_paths.map(&:to_s)
+    assert_paths FIXTURE_LOAD_PATH, "foo"
 
     @controller.append_view_path(%w(bar baz))
-    assert_equal [FIXTURE_LOAD_PATH, 'foo', 'bar', 'baz'], @controller.view_paths.map(&:to_s)
-    assert_equal class_view_paths, TestController.view_paths
+    assert_paths FIXTURE_LOAD_PATH, "foo", "bar", "baz"
+    assert_paths TestController, *class_view_paths
   end
 
   def test_template_prepends_view_path_correctly
@@ -85,11 +94,11 @@ class ViewLoadPathsTest < ActionController::TestCase
     class_view_paths = TestController.view_paths
 
     @controller.prepend_view_path 'baz'
-    assert_equal ['baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
+    assert_paths "baz", FIXTURE_LOAD_PATH
 
     @controller.prepend_view_path(%w(foo bar))
-    assert_equal ['foo', 'bar', 'baz', FIXTURE_LOAD_PATH], @controller.view_paths.map(&:to_s)
-    assert_equal class_view_paths, TestController.view_paths
+    assert_paths "foo", "bar", "baz", FIXTURE_LOAD_PATH
+    assert_paths TestController, *class_view_paths
   end
 
   def test_view_paths
@@ -130,12 +139,12 @@ class ViewLoadPathsTest < ActionController::TestCase
 
     A.view_paths = ['a/path']
 
-    assert_equal ['a/path'], A.view_paths.map(&:to_s)
-    assert_equal A.view_paths, B.view_paths
-    assert_equal original_load_paths, C.view_paths
-
+    assert_paths A, "a/path"
+    assert_paths A, *B.view_paths
+    assert_paths C, *original_load_paths
+    
     C.view_paths = []
     assert_nothing_raised { C.view_paths << 'c/path' }
-    assert_equal ['c/path'], C.view_paths.map(&:to_s)
+    assert_paths C, "c/path"
   end
 end
diff --git a/actionpack/test/controller/webservice_test.rb b/actionpack/test/controller/webservice_test.rb
index e89d6bb960..9bf8da7276 100644
--- a/actionpack/test/controller/webservice_test.rb
+++ b/actionpack/test/controller/webservice_test.rb
@@ -34,7 +34,7 @@ class WebServiceTest < ActionController::IntegrationTest
   def test_check_parameters
     with_test_route_set do
       get "/"
-      assert_equal '', @controller.response.body
+      assert @controller.response.body.blank?
     end
   end
 
@@ -163,7 +163,7 @@ class WebServiceTest < ActionController::IntegrationTest
     with_test_route_set do
       ActionController::Base.param_parsers[Mime::XML] = :xml_simple
       assert_nothing_raised { post "/", "", {'CONTENT_TYPE' => 'application/xml'} }
-      assert_equal "", @controller.response.body
+      assert @controller.response.body.blank?
     end
   end
 
diff --git a/actionpack/test/dispatch/rack_test.rb b/actionpack/test/dispatch/rack_test.rb
index 9fad4b22ee..94eba2a24f 100644
--- a/actionpack/test/dispatch/rack_test.rb
+++ b/actionpack/test/dispatch/rack_test.rb
@@ -201,93 +201,3 @@ class RackRequestNeedsRewoundTest < BaseRackTest
     assert_equal 0, request.body.pos
   end
 end
-
-class RackResponseTest < BaseRackTest
-  def setup
-    super
-    @response = ActionDispatch::Response.new
-  end
-
-  test "simple output" do
-    @response.body = "Hello, World!"
-    @response.prepare!
-
-    status, headers, body = @response.to_a
-    assert_equal 200, status
-    assert_equal({
-      "Content-Type" => "text/html; charset=utf-8",
-      "Cache-Control" => "private, max-age=0, must-revalidate",
-      "ETag" => '"65a8e27d8879283831b664bd8b7f0ad4"',
-      "Set-Cookie" => "",
-      "Content-Length" => "13"
-    }, headers)
-
-    parts = []
-    body.each { |part| parts << part }
-    assert_equal ["Hello, World!"], parts
-  end
-
-  def test_utf8_output
-    @response.body = [1090, 1077, 1089, 1090].pack("U*")
-    @response.prepare!
-
-    status, headers, body = @response.to_a
-    assert_equal 200, status
-    assert_equal({
-      "Content-Type" => "text/html; charset=utf-8",
-      "Cache-Control" => "private, max-age=0, must-revalidate",
-      "ETag" => '"ebb5e89e8a94e9dd22abf5d915d112b2"',
-      "Set-Cookie" => "",
-      "Content-Length" => "8"
-    }, headers)
-  end
-
-  def test_streaming_block
-    @response.body = Proc.new do |response, output|
-      5.times { |n| output.write(n) }
-    end
-    @response.prepare!
-
-    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)
-
-    parts = []
-    body.each { |part| parts << part.to_s }
-    assert_equal ["0", "1", "2", "3", "4"], parts
-  end
-end
-
-class RackResponseHeadersTest < BaseRackTest
-  def setup
-    super
-    @response = ActionDispatch::Response.new
-    @response.status = "200 OK"
-  end
-
-  test "content type" do
-    [204, 304].each do |c|
-      @response.status = c.to_s
-      assert !response_headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
-    end
-
-    [200, 302, 404, 500].each do |c|
-      @response.status = c.to_s
-      assert response_headers.has_key?("Content-Type"), "#{c} did not have Content-Type header"
-    end
-  end
-
-  test "status" do
-    assert !response_headers.has_key?('Status')
-  end
-
-  private
-    def response_headers
-      @response.prepare!
-      @response.to_a[1]
-    end
-end
diff --git a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
index 88b81dc493..9e008a9ae8 100644
--- a/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/multipart_params_parsing_test.rb
@@ -94,9 +94,8 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
     assert_equal %w(files foo), params.keys.sort
     assert_equal 'bar', params['foo']
 
-    # Ruby CGI doesn't handle multipart/mixed for us.
+    # Rack doesn't handle multipart/mixed for us.
     files = params['files']
-    assert_kind_of String, files
     files.force_encoding('ASCII-8BIT') if files.respond_to?(:force_encoding)
     assert_equal 19756, files.size
   end
@@ -133,46 +132,6 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
     end
   end
 
-  # The lint wrapper is used in integration tests
-  # instead of a normal StringIO class
-  InputWrapper = Rack::Lint::InputWrapper
-
-  test "parses unwindable stream" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-    params = parse_multipart('large_text_file')
-    assert_equal %w(file foo), params.keys.sort
-    assert_equal 'bar', params['foo']
-  end
-
-  test "uploads and reads file with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-
-    with_test_routing do
-      post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-      assert_equal "File: Hello", response.body
-    end
-  end
-
-  test "passes through rack middleware and uploads file" do
-    with_muck_middleware do
-      with_test_routing do
-        post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-        assert_equal "File: Hello", response.body
-      end
-    end
-  end
-
-  test "passes through rack middleware and uploads file with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-
-    with_muck_middleware do
-      with_test_routing do
-        post '/read', :uploaded_data => fixture_file_upload(FIXTURE_PATH + "/hello.txt", "text/plain")
-        assert_equal "File: Hello", response.body
-      end
-    end
-  end
-
   private
     def fixture(name)
       File.open(File.join(FIXTURE_PATH, name), 'rb') do |file|
@@ -199,25 +158,4 @@ class MultipartParamsParsingTest < ActionController::IntegrationTest
         yield
       end
     end
-
-    class MuckMiddleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        env['rack.input'].read
-        env['rack.input'].rewind
-        @app.call(env)
-      end
-    end
-
-    def with_muck_middleware
-      original_middleware = ActionController::Dispatcher.middleware
-      middleware = original_middleware.dup
-      middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware
-      ActionController::Dispatcher.middleware = middleware
-      yield
-      ActionController::Dispatcher.middleware = original_middleware
-    end
 end
diff --git a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
index 8de4a83d76..7167cdafac 100644
--- a/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
+++ b/actionpack/test/dispatch/request/url_encoded_params_parsing_test.rb
@@ -126,45 +126,7 @@ class UrlEncodedParamsParsingTest < ActionController::IntegrationTest
     assert_parses expected, query
   end
 
-  test "passes through rack middleware and parses params" do
-    with_muck_middleware do
-      assert_parses({ "a" => { "b" => "c" } }, "a[b]=c")
-    end
-  end
-
-  # The lint wrapper is used in integration tests
-  # instead of a normal StringIO class
-  InputWrapper = Rack::Lint::InputWrapper
-
-  test "passes through rack middleware and parses params with unwindable input" do
-    InputWrapper.any_instance.stubs(:rewind).raises(Errno::ESPIPE)
-    with_muck_middleware do
-      assert_parses({ "a" => { "b" => "c" } }, "a[b]=c")
-    end
-  end
-
   private
-    class MuckMiddleware
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        env['rack.input'].read
-        env['rack.input'].rewind
-        @app.call(env)
-      end
-    end
-
-    def with_muck_middleware
-      original_middleware = ActionController::Dispatcher.middleware
-      middleware = original_middleware.dup
-      middleware.insert_after ActionDispatch::RewindableInput, MuckMiddleware
-      ActionController::Dispatcher.middleware = middleware
-      yield
-      ActionController::Dispatcher.middleware = original_middleware
-    end
-
     def with_test_routing
       with_routing do |set|
         set.draw do |map|
diff --git a/actionpack/test/dispatch/request_test.rb b/actionpack/test/dispatch/request_test.rb
index d57a2a611f..3a85db8aa5 100644
--- a/actionpack/test/dispatch/request_test.rb
+++ b/actionpack/test/dispatch/request_test.rb
@@ -307,7 +307,7 @@ class RequestTest < ActiveSupport::TestCase
   test "restrict method hacking" do
     [:get, :put, :delete].each do |method|
       request = stub_request 'REQUEST_METHOD' => method.to_s.upcase,
-        'action_controller.request.request_parameters' => { :_method => 'put' }
+        'action_dispatch.request.request_parameters' => { :_method => 'put' }
       assert_equal method, request.method
     end
   end
diff --git a/actionpack/test/dispatch/response_test.rb b/actionpack/test/dispatch/response_test.rb
new file mode 100644
index 0000000000..2ddc6cb2b5
--- /dev/null
+++ b/actionpack/test/dispatch/response_test.rb
@@ -0,0 +1,130 @@
+require 'abstract_unit'
+
+class ResponseTest < ActiveSupport::TestCase
+  def setup
+    @response = ActionDispatch::Response.new
+  end
+
+  test "simple output" do
+    @response.body = "Hello, World!"
+    @response.prepare!
+
+    status, headers, body = @response.to_a
+    assert_equal 200, status
+    assert_equal({
+      "Content-Type" => "text/html; charset=utf-8",
+      "Cache-Control" => "private, max-age=0, must-revalidate",
+      "ETag" => '"65a8e27d8879283831b664bd8b7f0ad4"',
+      "Set-Cookie" => "",
+      "Content-Length" => "13"
+    }, headers)
+
+    parts = []
+    body.each { |part| parts << part }
+    assert_equal ["Hello, World!"], parts
+  end
+
+  test "utf8 output" do
+    @response.body = [1090, 1077, 1089, 1090].pack("U*")
+    @response.prepare!
+
+    status, headers, body = @response.to_a
+    assert_equal 200, status
+    assert_equal({
+      "Content-Type" => "text/html; charset=utf-8",
+      "Cache-Control" => "private, max-age=0, must-revalidate",
+      "ETag" => '"ebb5e89e8a94e9dd22abf5d915d112b2"',
+      "Set-Cookie" => "",
+      "Content-Length" => "8"
+    }, headers)
+  end
+
+  test "streaming block" do
+    @response.body = Proc.new do |response, output|
+      5.times { |n| output.write(n) }
+    end
+    @response.prepare!
+
+    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)
+
+    parts = []
+    body.each { |part| parts << part.to_s }
+    assert_equal ["0", "1", "2", "3", "4"], parts
+  end
+
+  test "content type" do
+    [204, 304].each do |c|
+      @response.status = c.to_s
+      @response.prepare!
+      status, headers, body = @response.to_a
+      assert !headers.has_key?("Content-Type"), "#{c} should not have Content-Type header"
+    end
+
+    [200, 302, 404, 500].each do |c|
+      @response.status = c.to_s
+      @response.prepare!
+      status, headers, body = @response.to_a
+      assert headers.has_key?("Content-Type"), "#{c} did not have Content-Type header"
+    end
+  end
+
+  test "does not include Status header" do
+    @response.status = "200 OK"
+    @response.prepare!
+    status, headers, body = @response.to_a
+    assert !headers.has_key?('Status')
+  end
+
+  test "response code" do
+    @response.status = "200 OK"
+    assert_equal 200, @response.response_code
+
+    @response.status = "200"
+    assert_equal 200, @response.response_code
+
+    @response.status = 200
+    assert_equal 200, @response.response_code
+  end
+
+  test "code" do
+    @response.status = "200 OK"
+    assert_equal "200", @response.code
+
+    @response.status = "200"
+    assert_equal "200", @response.code
+
+    @response.status = 200
+    assert_equal "200", @response.code
+  end
+
+  test "message" do
+    @response.status = "200 OK"
+    assert_equal "OK", @response.message
+
+    @response.status = "200"
+    assert_equal "OK", @response.message
+
+    @response.status = 200
+    assert_equal "OK", @response.message
+  end
+
+  test "cookies" do
+    @response.set_cookie("user_name", :value => "david", :path => "/")
+    @response.prepare!
+    status, headers, body = @response.to_a
+    assert_equal "user_name=david; path=/", headers["Set-Cookie"]
+    assert_equal({"user_name" => "david"}, @response.cookies)
+
+    @response.set_cookie("login", :value => "foo&bar", :path => "/", :expires => Time.utc(2005, 10, 10,5))
+    @response.prepare!
+    status, headers, body = @response.to_a
+    assert_equal "user_name=david; path=/\nlogin=foo%26bar; path=/; expires=Mon, 10-Oct-2005 05:00:00 GMT", headers["Set-Cookie"]
+    assert_equal({"login" => "foo&bar", "user_name" => "david"}, @response.cookies)
+  end
+end
diff --git a/actionpack/test/dispatch/session/cookie_store_test.rb b/actionpack/test/dispatch/session/cookie_store_test.rb
index b9bf8cf411..2db76818ac 100644
--- a/actionpack/test/dispatch/session/cookie_store_test.rb
+++ b/actionpack/test/dispatch/session/cookie_store_test.rb
@@ -5,13 +5,15 @@ class CookieStoreTest < ActionController::IntegrationTest
   SessionKey = '_myapp_session'
   SessionSecret = 'b3c631c314c0bbca50c1b2843150fe33'
 
+  # Make sure Session middleware doesnt get included in the middleware stack
+  ActionController::Base.session_store = nil
+
   DispatcherApp = ActionController::Dispatcher.new
   CookieStoreApp = ActionDispatch::Session::CookieStore.new(DispatcherApp,
                      :key => SessionKey, :secret => SessionSecret)
 
   Verifier = ActiveSupport::MessageVerifier.new(SessionSecret, 'SHA1')
-
-  SignedBar = "BAh7BjoIZm9vIghiYXI%3D--fef868465920f415f2c0652d6910d3af288a0367"
+  SignedBar = Verifier.generate(:foo => "bar", :session_id => ActiveSupport::SecureRandom.hex(16))
 
   class TestController < ActionController::Base
     def no_session_access
diff --git a/actionpack/test/dispatch/session/mem_cache_store_test.rb b/actionpack/test/dispatch/session/mem_cache_store_test.rb
index 7561c93e4a..278f2c83ea 100644
--- a/actionpack/test/dispatch/session/mem_cache_store_test.rb
+++ b/actionpack/test/dispatch/session/mem_cache_store_test.rb
@@ -61,6 +61,14 @@ class MemCacheStoreTest < ActionController::IntegrationTest
       end
     end
 
+    def test_getting_session_value_does_not_set_cookie
+      with_test_route_set do
+        get '/get_session_value'
+        assert_response :success
+        assert_equal "", headers["Set-Cookie"]
+      end
+    end
+
     def test_setting_session_value_after_session_reset
       with_test_route_set do
         get '/set_session_value'
diff --git a/actionpack/test/dispatch/session/test_session_test.rb b/actionpack/test/dispatch/session/test_session_test.rb
index de6539e1cc..0ff93f1c5d 100644
--- a/actionpack/test/dispatch/session/test_session_test.rb
+++ b/actionpack/test/dispatch/session/test_session_test.rb
@@ -2,37 +2,30 @@ require 'abstract_unit'
 require 'stringio'
 
 class ActionController::TestSessionTest < ActiveSupport::TestCase
-  
   def test_calling_delete_without_parameters_raises_deprecation_warning_and_calls_to_clear_test_session
     assert_deprecated(/use clear instead/){ ActionController::TestSession.new.delete }
   end
-  
+
   def test_calling_update_without_parameters_raises_deprecation_warning_and_calls_to_clear_test_session
     assert_deprecated(/use replace instead/){ ActionController::TestSession.new.update }
   end
-  
+
   def test_calling_close_raises_deprecation_warning
     assert_deprecated(/sessions should no longer be closed/){ ActionController::TestSession.new.close }
   end
-  
-  def test_defaults
-    session = ActionController::TestSession.new
-    assert_equal({}, session.data)
-    assert_equal('', session.session_id)
-  end
-  
+
   def test_ctor_allows_setting
     session = ActionController::TestSession.new({:one => 'one', :two => 'two'})
     assert_equal('one', session[:one])
     assert_equal('two', session[:two])
   end
-  
+
   def test_setting_session_item_sets_item
     session = ActionController::TestSession.new
     session[:key] = 'value'
     assert_equal('value', session[:key])
   end
-  
+
   def test_calling_delete_removes_item
     session = ActionController::TestSession.new
     session[:key] = 'value'
@@ -40,13 +33,13 @@ class ActionController::TestSessionTest < ActiveSupport::TestCase
     session.delete(:key)
     assert_nil(session[:key])
   end
-  
+
   def test_calling_update_with_params_passes_to_attributes
     session = ActionController::TestSession.new()
     session.update('key' => 'value')
     assert_equal('value', session[:key])
   end
-  
+
   def test_clear_emptys_session
     params = {:one => 'one', :two => 'two'}
     session = ActionController::TestSession.new({:one => 'one', :two => 'two'})
@@ -54,5 +47,4 @@ class ActionController::TestSessionTest < ActiveSupport::TestCase
     assert_nil(session[:one])
     assert_nil(session[:two])
   end
-  
-end
\ No newline at end of file
+end
diff --git a/actionpack/test/dispatch/show_exceptions_test.rb b/actionpack/test/dispatch/show_exceptions_test.rb
new file mode 100644
index 0000000000..ce1973853e
--- /dev/null
+++ b/actionpack/test/dispatch/show_exceptions_test.rb
@@ -0,0 +1,108 @@
+require 'abstract_unit'
+
+module ActionDispatch
+  class ShowExceptions
+    private
+      def public_path
+        "#{FIXTURE_LOAD_PATH}/public"
+      end
+
+      # Silence logger
+      def logger
+        nil
+      end
+  end
+end
+
+class ShowExceptionsTest < ActionController::IntegrationTest
+  Boomer = lambda do |env|
+    req = ActionDispatch::Request.new(env)
+    case req.path
+    when "/not_found"
+      raise ActionController::UnknownAction
+    when "/method_not_allowed"
+      raise ActionController::MethodNotAllowed
+    when "/not_implemented"
+      raise ActionController::NotImplemented
+    when "/unprocessable_entity"
+      raise ActionController::InvalidAuthenticityToken
+    else
+      raise "puke!"
+    end
+  end
+
+  ProductionApp = ActionDispatch::ShowExceptions.new(Boomer, false)
+  DevelopmentApp = ActionDispatch::ShowExceptions.new(Boomer, true)
+
+  test "rescue in public from a remote ip" do
+    @integration_session = open_session(ProductionApp)
+    self.remote_addr = '208.77.188.166'
+
+    get "/"
+    assert_response 500
+    assert_equal "500 error fixture\n", body
+
+    get "/not_found"
+    assert_response 404
+    assert_equal "404 error fixture\n", body
+
+    get "/method_not_allowed"
+    assert_response 405
+    assert_equal "", body
+  end
+
+  test "rescue locally from a local request" do
+    @integration_session = open_session(ProductionApp)
+    self.remote_addr = '127.0.0.1'
+
+    get "/"
+    assert_response 500
+    assert_match /puke/, body
+
+    get "/not_found"
+    assert_response 404
+    assert_match /#{ActionController::UnknownAction.name}/, body
+
+    get "/method_not_allowed"
+    assert_response 405
+    assert_match /ActionController::MethodNotAllowed/, body
+  end
+
+  test "localize public rescue message" do
+    # Change locale
+    old_locale = I18n.locale
+    I18n.locale = :da
+
+    begin
+      @integration_session = open_session(ProductionApp)
+      self.remote_addr = '208.77.188.166'
+
+      get "/"
+      assert_response 500
+      assert_equal "500 localized error fixture\n", body
+
+      get "/not_found"
+      assert_response 404
+      assert_equal "404 error fixture\n", body
+    ensure
+      I18n.locale = old_locale
+    end
+  end
+
+  test "always rescue locally in development mode" do
+    @integration_session = open_session(DevelopmentApp)
+    self.remote_addr = '208.77.188.166'
+
+    get "/"
+    assert_response 500
+    assert_match /puke/, body
+
+    get "/not_found"
+    assert_response 404
+    assert_match /#{ActionController::UnknownAction.name}/, body
+
+    get "/method_not_allowed"
+    assert_response 405
+    assert_match /ActionController::MethodNotAllowed/, body
+  end
+end
diff --git a/actionpack/test/dispatch/test_request_test.rb b/actionpack/test/dispatch/test_request_test.rb
new file mode 100644
index 0000000000..5da02b2ea6
--- /dev/null
+++ b/actionpack/test/dispatch/test_request_test.rb
@@ -0,0 +1,45 @@
+require 'abstract_unit'
+
+class TestRequestTest < ActiveSupport::TestCase
+  test "sane defaults" do
+    env = ActionDispatch::TestRequest.new.env
+
+    assert_equal "GET", env.delete("REQUEST_METHOD")
+    assert_equal "off", env.delete("HTTPS")
+    assert_equal "http", env.delete("rack.url_scheme")
+    assert_equal "example.org", env.delete("SERVER_NAME")
+    assert_equal "80", env.delete("SERVER_PORT")
+    assert_equal "/", env.delete("PATH_INFO")
+    assert_equal "", env.delete("SCRIPT_NAME")
+    assert_equal "", env.delete("QUERY_STRING")
+    assert_equal "0", env.delete("CONTENT_LENGTH")
+
+    assert_equal "test.host", env.delete("HTTP_HOST")
+    assert_equal "0.0.0.0", env.delete("REMOTE_ADDR")
+    assert_equal "Rails Testing", env.delete("HTTP_USER_AGENT")
+
+    assert_equal [1, 0], env.delete("rack.version")
+    assert_equal "", env.delete("rack.input").string
+    assert_kind_of StringIO, env.delete("rack.errors")
+    assert_equal true, env.delete("rack.multithread")
+    assert_equal true, env.delete("rack.multiprocess")
+    assert_equal false, env.delete("rack.run_once")
+
+    assert env.empty?, env.inspect
+  end
+
+  test "cookie jar" do
+    req = ActionDispatch::TestRequest.new
+
+    assert_equal({}, req.cookies)
+    assert_equal nil, req.env["HTTP_COOKIE"]
+
+    req.cookies["user_name"] = "david"
+    assert_equal({"user_name" => "david"}, req.cookies)
+    assert_equal "user_name=david;", req.env["HTTP_COOKIE"]
+
+    req.cookies["login"] = "XJ-122"
+    assert_equal({"user_name" => "david", "login" => "XJ-122"}, req.cookies)
+    assert_equal %w(login=XJ-122 user_name=david), req.env["HTTP_COOKIE"].split(/; ?/).sort
+  end
+end
diff --git a/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab b/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab
index 018abfb0ac..fcee620d82 100644
--- a/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab
+++ b/actionpack/test/fixtures/layout_tests/layouts/third_party_template_library.mab
@@ -1 +1 @@
-Mab
\ No newline at end of file
+layouts/third_party_template_library.mab
\ No newline at end of file
diff --git a/actionpack/test/fixtures/layouts/standard.erb b/actionpack/test/fixtures/layouts/standard.html.erb
index 368764e6f4..368764e6f4 100644
--- a/actionpack/test/fixtures/layouts/standard.erb
+++ b/actionpack/test/fixtures/layouts/standard.html.erb
diff --git a/actionpack/test/fixtures/test/greeting.erb b/actionpack/test/fixtures/test/greeting.html.erb
index 62fb0293f0..62fb0293f0 100644
--- a/actionpack/test/fixtures/test/greeting.erb
+++ b/actionpack/test/fixtures/test/greeting.html.erb
diff --git a/actionpack/test/fixtures/test/render_file_with_locals_and_default.erb b/actionpack/test/fixtures/test/render_file_with_locals_and_default.erb
new file mode 100644
index 0000000000..9b4900acc5
--- /dev/null
+++ b/actionpack/test/fixtures/test/render_file_with_locals_and_default.erb
@@ -0,0 +1 @@
+<%= secret ||= 'one' %>
\ No newline at end of file
diff --git a/actionpack/test/fixtures/test/utf8.html.erb b/actionpack/test/fixtures/test/utf8.html.erb
index 0b4d19aa0e..58cd03b439 100644
--- a/actionpack/test/fixtures/test/utf8.html.erb
+++ b/actionpack/test/fixtures/test/utf8.html.erb
@@ -1,2 +1,5 @@
+<%# encoding: utf-8 -%>
 Русский текст
-日本語のテキスト
\ No newline at end of file
+<%= "日".encoding %>
+<%= @output_buffer.encoding %>
+<%= __ENCODING__ %>
diff --git a/actionpack/test/controller/html-scanner/cdata_node_test.rb b/actionpack/test/html-scanner/cdata_node_test.rb
index 1822cc565a..1822cc565a 100644
--- a/actionpack/test/controller/html-scanner/cdata_node_test.rb
+++ b/actionpack/test/html-scanner/cdata_node_test.rb
diff --git a/actionpack/test/controller/html-scanner/document_test.rb b/actionpack/test/html-scanner/document_test.rb
index c68f04fa75..c68f04fa75 100644
--- a/actionpack/test/controller/html-scanner/document_test.rb
+++ b/actionpack/test/html-scanner/document_test.rb
diff --git a/actionpack/test/controller/html-scanner/node_test.rb b/actionpack/test/html-scanner/node_test.rb
index b0df36877e..b0df36877e 100644
--- a/actionpack/test/controller/html-scanner/node_test.rb
+++ b/actionpack/test/html-scanner/node_test.rb
diff --git a/actionpack/test/controller/html-scanner/sanitizer_test.rb b/actionpack/test/html-scanner/sanitizer_test.rb
index e85a5c7abf..e85a5c7abf 100644
--- a/actionpack/test/controller/html-scanner/sanitizer_test.rb
+++ b/actionpack/test/html-scanner/sanitizer_test.rb
diff --git a/actionpack/test/controller/html-scanner/tag_node_test.rb b/actionpack/test/html-scanner/tag_node_test.rb
index d1d4667378..d1d4667378 100644
--- a/actionpack/test/controller/html-scanner/tag_node_test.rb
+++ b/actionpack/test/html-scanner/tag_node_test.rb
diff --git a/actionpack/test/controller/html-scanner/text_node_test.rb b/actionpack/test/html-scanner/text_node_test.rb
index 1ab3f4454e..1ab3f4454e 100644
--- a/actionpack/test/controller/html-scanner/text_node_test.rb
+++ b/actionpack/test/html-scanner/text_node_test.rb
diff --git a/actionpack/test/controller/html-scanner/tokenizer_test.rb b/actionpack/test/html-scanner/tokenizer_test.rb
index a001bcbbad..a001bcbbad 100644
--- a/actionpack/test/controller/html-scanner/tokenizer_test.rb
+++ b/actionpack/test/html-scanner/tokenizer_test.rb
diff --git a/actionpack/test/active_record_unit.rb b/actionpack/test/lib/active_record_unit.rb
index 9e0c66055d..1ba308e9d7 100644
--- a/actionpack/test/active_record_unit.rb
+++ b/actionpack/test/lib/active_record_unit.rb
@@ -16,7 +16,7 @@ if defined?(ActiveRecord) && defined?(Fixtures)
 else
   $stderr.print 'Attempting to load Active Record... '
   begin
-    PATH_TO_AR = "#{File.dirname(__FILE__)}/../../activerecord/lib"
+    PATH_TO_AR = "#{File.dirname(__FILE__)}/../../../activerecord/lib"
     raise LoadError, "#{PATH_TO_AR} doesn't exist" unless File.directory?(PATH_TO_AR)
     $LOAD_PATH.unshift PATH_TO_AR
     require 'active_record'
@@ -72,13 +72,13 @@ class ActiveRecordTestConnector
 
       # Load actionpack sqlite tables
       def load_schema
-        File.read(File.dirname(__FILE__) + "/fixtures/db_definitions/sqlite.sql").split(';').each do |sql|
+        File.read(File.dirname(__FILE__) + "/../fixtures/db_definitions/sqlite.sql").split(';').each do |sql|
           ActiveRecord::Base.connection.execute(sql) unless sql.blank?
         end
       end
 
       def require_fixture_models
-        Dir.glob(File.dirname(__FILE__) + "/fixtures/*.rb").each {|f| require f}
+        Dir.glob(File.dirname(__FILE__) + "/../fixtures/*.rb").each {|f| require f}
       end
   end
 end
diff --git a/actionpack/test/controller/fake_controllers.rb b/actionpack/test/lib/controller/fake_controllers.rb
index 75c114c103..75c114c103 100644
--- a/actionpack/test/controller/fake_controllers.rb
+++ b/actionpack/test/lib/controller/fake_controllers.rb
diff --git a/actionpack/test/controller/fake_models.rb b/actionpack/test/lib/controller/fake_models.rb
index 0b30c79b10..0b30c79b10 100644
--- a/actionpack/test/controller/fake_models.rb
+++ b/actionpack/test/lib/controller/fake_models.rb
diff --git a/actionpack/test/lib/fixture_template.rb b/actionpack/test/lib/fixture_template.rb
index 26f6ec2d0c..59fb6819ed 100644
--- a/actionpack/test/lib/fixture_template.rb
+++ b/actionpack/test/lib/fixture_template.rb
@@ -1,35 +1,104 @@
 module ActionView #:nodoc:
-  class FixtureTemplate < Template
-    class FixturePath < Template::Path
-      def initialize(hash = {})
-        @hash = {}
-        
-        hash.each do |k, v|
-          @hash[k.sub(/\.\w+$/, '')] = FixtureTemplate.new(v, k.split("/").last, self)
+class Template
+  class FixturePath < Path
+    def initialize(hash = {}, options = {})
+      super(options)
+      @hash = hash
+    end
+    
+    def find_templates(name, details, prefix, partial)
+      if regexp = details_to_regexp(name, details, prefix, partial)
+        cached(regexp) do
+          templates = []
+          @hash.select { |k,v| k =~ regexp }.each do |path, source|
+            templates << Template.new(source, path, *path_to_details(path))
+          end
+          templates
         end
-        
-        super("fixtures://root")
-      end
-      
-      def find_template(path)
-        @hash[path]
       end
     end
     
-    def initialize(body, *args)
-      @body = body
-      super(*args)
+  private
+  
+    def formats_regexp
+      @formats_regexp ||= begin
+        formats = Mime::SET.map { |m| m.symbol }
+        '(?:' + formats.map { |l| "\\.#{Regexp.escape(l.to_s)}" }.join('|') + ')?'
+      end
     end
     
-    def source
-      @body
+    def handler_regexp
+      e = TemplateHandlers.extensions.map{|h| "\\.#{Regexp.escape(h.to_s)}"}.join("|")
+      "(?:#{e})?"
     end
   
-  private
-  
-    def find_full_path(path, load_paths)
-      return '/', path
+    def details_to_regexp(name, details, prefix, partial)
+      path = ""
+      path << "#{prefix}/" unless prefix.empty?
+      path << (partial ? "_#{name}" : name)
+    
+      extensions = ""
+      [:locales, :formats].each do |k|
+        extensions << if exts = details[k]
+          '(?:' + exts.map {|e| "\\.#{Regexp.escape(e.to_s)}"}.join('|') + ')?'
+        else
+          k == :formats ? formats_regexp : ''
+        end
+      end
+      
+      %r'^#{Regexp.escape(path)}#{extensions}#{handler_regexp}$'
+    end
+    
+    # TODO: fix me
+    # :api: plugin
+    def path_to_details(path)
+      # [:erb, :format => :html, :locale => :en, :partial => true/false]
+      if m = path.match(%r'(_)?[\w-]+(\.[\w-]+)*\.(\w+)$')
+        partial = m[1] == '_'
+        details = (m[2]||"").split('.').reject { |e| e.empty? }
+        handler = Template.handler_class_for_extension(m[3])
+    
+        format  = Mime[details.last] && details.pop.to_sym
+        locale  = details.last && details.pop.to_sym
+        
+        return handler, :format => format, :locale => locale, :partial => partial
+      end
     end
-  
   end
+  
+  
+  # class FixtureTemplate < Template
+  #   class FixturePath < Template::Path
+  #     def initialize(hash = {})
+  #       @hash = {}
+  #       
+  #       hash.each do |k, v|
+  #         @hash[k.sub(/\.\w+$/, '')] = FixtureTemplate.new(v, k.split("/").last, self)
+  #       end
+  #       
+  #       super("fixtures://root")
+  #     end
+  #     
+  #     def find_template(path)
+  #       @hash[path]
+  #     end
+  #   end
+  #   
+  #   def initialize(body, *args)
+  #     @body = body
+  #     super(*args)
+  #   end
+  #   
+  #   def source
+  #     @body
+  #   end
+  # 
+  # private
+  # 
+  #   def find_full_path(path, load_paths)
+  #     return '/', path
+  #   end
+  # 
+  # end
+end
 end
\ No newline at end of file
diff --git a/actionpack/test/testing_sandbox.rb b/actionpack/test/lib/testing_sandbox.rb
index c36585104f..c36585104f 100644
--- a/actionpack/test/testing_sandbox.rb
+++ b/actionpack/test/lib/testing_sandbox.rb
diff --git a/actionpack/test/new_base/abstract_unit.rb b/actionpack/test/new_base/abstract_unit.rb
new file mode 100644
index 0000000000..e6690d41d9
--- /dev/null
+++ b/actionpack/test/new_base/abstract_unit.rb
@@ -0,0 +1,166 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+$:.unshift(File.dirname(__FILE__) + '/../fixtures/helpers')
+$:.unshift(File.dirname(__FILE__) + '/../fixtures/alternate_helpers')
+
+ENV['new_base'] = "true"
+$stderr.puts "Running old tests on new_base"
+
+require 'test/unit'
+require 'active_support'
+
+# TODO : Revisit requiring all the core extensions here
+require 'active_support/core_ext'
+
+require 'active_support/test_case'
+require 'action_controller/abstract'
+require 'action_controller/new_base'
+require 'fixture_template'
+require 'action_controller/testing/process2'
+require 'action_view/test_case'
+require 'action_controller/testing/integration'
+require 'active_support/dependencies'
+
+$tags[:new_base] = true
+
+begin
+  require 'ruby-debug'
+  Debugger.settings[:autoeval] = true
+  Debugger.start
+rescue LoadError
+  # Debugging disabled. `gem install ruby-debug` to enable.
+end
+
+ActiveSupport::Dependencies.hook!
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+# Register danish language for testing
+I18n.backend.store_translations 'da', {}
+I18n.backend.store_translations 'pt-BR', {}
+ORIGINAL_LOCALES = I18n.available_locales.map {|locale| locale.to_s }.sort
+
+FIXTURE_LOAD_PATH = File.join(File.dirname(__FILE__), '../fixtures')
+
+module ActionController
+  Base.session = {
+  :key         => '_testing_session',
+  :secret      => '8273f16463985e2b3747dc25e30f2528'
+}
+
+  class ActionControllerError < StandardError #:nodoc:
+  end
+
+  class SessionRestoreError < ActionControllerError #:nodoc:
+  end
+
+  class RenderError < ActionControllerError #:nodoc:
+  end
+
+  class RoutingError < ActionControllerError #:nodoc:
+    attr_reader :failures
+    def initialize(message, failures=[])
+      super(message)
+      @failures = failures
+    end
+  end
+
+  class MethodNotAllowed < ActionControllerError #:nodoc:
+    attr_reader :allowed_methods
+
+    def initialize(*allowed_methods)
+      super("Only #{allowed_methods.to_sentence(:locale => :en)} requests are allowed.")
+      @allowed_methods = allowed_methods
+    end
+
+    def allowed_methods_header
+      allowed_methods.map { |method_symbol| method_symbol.to_s.upcase } * ', '
+    end
+
+    def handle_response!(response)
+      response.headers['Allow'] ||= allowed_methods_header
+    end
+  end
+
+  class NotImplemented < MethodNotAllowed #:nodoc:
+  end
+
+  class UnknownController < ActionControllerError #:nodoc:
+  end
+
+  class MissingFile < ActionControllerError #:nodoc:
+  end
+
+  class RenderError < ActionControllerError #:nodoc:
+  end
+
+  class SessionOverflowError < ActionControllerError #:nodoc:
+    DEFAULT_MESSAGE = 'Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data.'
+
+    def initialize(message = nil)
+      super(message || DEFAULT_MESSAGE)
+    end
+  end
+
+  class UnknownHttpMethod < ActionControllerError #:nodoc:
+  end
+  
+  class Base
+    include ActionController::Testing
+  end
+  
+  Base.view_paths = FIXTURE_LOAD_PATH
+  
+  class TestCase
+    include TestProcess
+    setup do
+      ActionController::Routing::Routes.draw do |map|
+        map.connect ':controller/:action/:id'
+      end
+    end
+    
+    def assert_template(options = {}, message = nil)
+      validate_request!
+
+      hax = @controller._action_view.instance_variable_get(:@_rendered)
+
+      case options
+      when NilClass, String
+        rendered = (hax[:template] || []).map { |t| t.identifier }
+        msg = build_message(message,
+                "expecting <?> but rendering with <?>",
+                options, rendered.join(', '))
+        assert_block(msg) do
+          if options.nil?
+            hax[:template].blank?
+          else
+            rendered.any? { |t| t.match(options) }
+          end
+        end
+      when Hash
+        if expected_partial = options[:partial]
+          partials = hax[:partials]
+          if expected_count = options[:count]
+            found = partials.detect { |p, _| p.identifier.match(expected_partial) }
+            actual_count = found.nil? ? 0 : found.second
+            msg = build_message(message,
+                    "expecting ? to be rendered ? time(s) but rendered ? time(s)",
+                     expected_partial, expected_count, actual_count)
+            assert(actual_count == expected_count.to_i, msg)
+          else
+            msg = build_message(message,
+                    "expecting partial <?> but action rendered <?>",
+                    options[:partial], partials.keys)
+            assert(partials.keys.any? { |p| p.identifier.match(expected_partial) }, msg)
+          end
+        else
+          assert hax[:partials].empty?,
+            "Expected no partials to be rendered"
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/test/new_base/base_test.rb b/actionpack/test/new_base/base_test.rb
index 4f46cb6492..d9d552f9e5 100644
--- a/actionpack/test/new_base/base_test.rb
+++ b/actionpack/test/new_base/base_test.rb
@@ -1,8 +1,8 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
 # Tests the controller dispatching happy path
-module HappyPath
-  class SimpleDispatchController < ActionController::Base2
+module Dispatching
+  class SimpleController < ActionController::Base
     def index
       render :text => "success"
     end
@@ -10,81 +10,62 @@ module HappyPath
     def modify_response_body
       self.response_body = "success"
     end
-    
+
     def modify_response_body_twice
       ret = (self.response_body = "success") 
       self.response_body = "#{ret}!"
     end
-    
+
     def modify_response_headers
-      
     end
   end
-  
-  class TestSimpleDispatch < SimpleRouteCase
-    
-    get "/happy_path/simple_dispatch/index"
-        
-    test "sets the body" do
+
+  class EmptyController < ActionController::Base ; end
+
+  module Submodule
+    class ContainedEmptyController < ActionController::Base ; end
+  end
+
+  class BaseTest < SimpleRouteCase
+    # :api: plugin
+    test "simple dispatching" do
+      get "/dispatching/simple/index"
+
       assert_body "success"
-    end
-    
-    test "sets the status code" do
       assert_status 200
+      assert_content_type "text/html; charset=utf-8"
+      assert_header "Content-Length", "7"
     end
-    
-    test "sets the content type" do
-      assert_content_type Mime::HTML
-    end
-    
-    test "sets the content length" do
-      assert_header "Content-Length", 7
-    end
-        
-  end
-  
-  # :api: plugin
-  class TestDirectResponseMod < SimpleRouteCase
-    get "/happy_path/simple_dispatch/modify_response_body"
-        
-    test "sets the body" do
+
+    # :api: plugin
+    test "directly modifying response body" do
+      get "/dispatching/simple/modify_response_body"
+
       assert_body "success"
+      assert_header "Content-Length", "7" # setting the body manually sets the content length
     end
-    
-    test "setting the body manually sets the content length" do
-      assert_header "Content-Length", 7
-    end
-  end
-  
-  # :api: plugin
-  class TestDirectResponseModTwice < SimpleRouteCase
-    get "/happy_path/simple_dispatch/modify_response_body_twice"
-    
-    test "self.response_body= returns the body being set" do
+
+    # :api: plugin
+    test "directly modifying response body twice" do
+      get "/dispatching/simple/modify_response_body_twice"
+
       assert_body "success!"
+      assert_header "Content-Length", "8"
     end
-    
-    test "updating the response body updates the content length" do
-      assert_header "Content-Length", 8
-    end
-  end
-end
 
+    test "controller path" do
+      assert_equal 'dispatching/empty', EmptyController.controller_path
+      assert_equal EmptyController.controller_path, EmptyController.new.controller_path
+    end
 
-class EmptyController < ActionController::Base2 ; end
-module Submodule
-  class ContainedEmptyController < ActionController::Base2 ; end
-end
+    test "namespaced controller path" do
+      assert_equal 'dispatching/submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
+      assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
+    end
 
-class ControllerClassTests < Test::Unit::TestCase
-  def test_controller_path
-    assert_equal 'empty', EmptyController.controller_path
-    assert_equal EmptyController.controller_path, EmptyController.new.controller_path
-    assert_equal 'submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
-    assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
+    test "controller name" do
+      assert_equal 'empty', EmptyController.controller_name
+      assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
+    end
   end
-  def test_controller_name
-    assert_equal 'empty', EmptyController.controller_name
-    assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
- end
 end
\ No newline at end of file
diff --git a/actionpack/test/new_base/content_type_test.rb b/actionpack/test/new_base/content_type_test.rb
new file mode 100644
index 0000000000..82b817a5a3
--- /dev/null
+++ b/actionpack/test/new_base/content_type_test.rb
@@ -0,0 +1,111 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module ContentType
+  class BaseController < ActionController::Base
+    def index
+      render :text => "Hello world!"
+    end
+
+    def set_on_response_obj
+      response.content_type = Mime::RSS
+      render :text => "Hello world!"
+    end
+
+    def set_on_render
+      render :text => "Hello world!", :content_type => Mime::RSS
+    end
+  end
+
+  class ImpliedController < ActionController::Base
+    # Template's mime type is used if no content_type is specified
+
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "content_type/implied/i_am_html_erb.html.erb"         => "Hello world!",
+      "content_type/implied/i_am_xml_erb.xml.erb"          => "<xml>Hello world!</xml>",
+      "content_type/implied/i_am_html_builder.html.builder" => "xml.p 'Hello'",
+      "content_type/implied/i_am_xml_builder.xml.builder"  => "xml.awesome 'Hello'"
+    )]
+
+    def i_am_html_erb()     end
+    def i_am_xml_erb()      end
+    def i_am_html_builder() end
+    def i_am_xml_builder()  end
+  end
+
+  class CharsetController < ActionController::Base
+    def set_on_response_obj
+      response.charset = "utf-16"
+      render :text => "Hello world!"
+    end
+
+    def set_as_nil_on_response_obj
+      response.charset = nil
+      render :text => "Hello world!"
+    end
+  end
+
+  class ExplicitContentTypeTest < SimpleRouteCase
+    test "default response is HTML and UTF8" do
+      get "/content_type/base"
+
+      assert_body "Hello world!"
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+
+    test "setting the content type of the response directly on the response object" do
+      get "/content_type/base/set_on_response_obj"
+
+      assert_body "Hello world!"
+      assert_header "Content-Type", "application/rss+xml; charset=utf-8"
+    end
+
+    test "setting the content type of the response as an option to render" do
+      get "/content_type/base/set_on_render"
+
+      assert_body "Hello world!"
+      assert_header "Content-Type", "application/rss+xml; charset=utf-8"
+    end
+  end
+
+  class ImpliedContentTypeTest < SimpleRouteCase
+    test "sets Content-Type as text/html when rendering *.html.erb" do
+      get "/content_type/implied/i_am_html_erb"
+
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+
+    test "sets Content-Type as application/xml when rendering *.xml.erb" do
+      get "/content_type/implied/i_am_xml_erb"
+
+      assert_header "Content-Type", "application/xml; charset=utf-8"
+    end
+
+    test "sets Content-Type as text/html when rendering *.html.builder" do
+      get "/content_type/implied/i_am_html_builder"
+
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+
+    test "sets Content-Type as application/xml when rendering *.xml.builder" do
+      get "/content_type/implied/i_am_xml_builder"
+
+      assert_header "Content-Type", "application/xml; charset=utf-8"
+    end
+  end
+
+  class ExplicitCharsetTest < SimpleRouteCase
+    test "setting the charset of the response directly on the response object" do
+      get "/content_type/charset/set_on_response_obj"
+
+      assert_body   "Hello world!"
+      assert_header "Content-Type", "text/html; charset=utf-16"
+    end
+
+    test "setting the charset of the response as nil directly on the response object" do
+      get "/content_type/charset/set_as_nil_on_response_obj"
+
+      assert_body   "Hello world!"
+      assert_header "Content-Type", "text/html; charset=utf-8"
+    end
+  end
+end
diff --git a/actionpack/test/new_base/etag_test.rb b/actionpack/test/new_base/etag_test.rb
new file mode 100644
index 0000000000..a40d3c936a
--- /dev/null
+++ b/actionpack/test/new_base/etag_test.rb
@@ -0,0 +1,46 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module Etags
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "etags/basic/base.html.erb" => "Hello from without_layout.html.erb",
+      "layouts/etags.html.erb"    => "teh <%= yield %> tagz"
+    )]
+
+    def without_layout
+      render :action => "base"
+    end
+
+    def with_layout
+      render :action => "base", :layout => "etags"
+    end
+  end
+
+  class EtagTest < SimpleRouteCase
+    describe "Rendering without any special etag options returns an etag that is an MD5 hash of its text"
+
+    test "an action without a layout" do
+      get "/etags/basic/without_layout"
+
+      body = "Hello from without_layout.html.erb"
+      assert_body body
+      assert_header "Etag", etag_for(body)
+      assert_status 200
+    end
+
+    test "an action with a layout" do
+      get "/etags/basic/with_layout"
+
+      body = "teh Hello from without_layout.html.erb tagz"
+      assert_body body
+      assert_header "Etag", etag_for(body)
+      assert_status 200      
+    end
+
+    private
+
+    def etag_for(text)
+      %("#{Digest::MD5.hexdigest(text)}")
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/redirect_test.rb b/actionpack/test/new_base/redirect_test.rb
new file mode 100644
index 0000000000..e591ebd05f
--- /dev/null
+++ b/actionpack/test/new_base/redirect_test.rb
@@ -0,0 +1 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_action_test.rb b/actionpack/test/new_base/render_action_test.rb
index 2bfb374a31..4402eadf42 100644
--- a/actionpack/test/new_base/render_action_test.rb
+++ b/actionpack/test/new_base/render_action_test.rb
@@ -1,26 +1,24 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
 module RenderAction
-  
   # This has no layout and it works
-  class BasicController < ActionController::Base2
-    
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new(
       "render_action/basic/hello_world.html.erb" => "Hello world!"
     )]
-    
+
     def hello_world
       render :action => "hello_world"
     end
-    
+
     def hello_world_as_string
       render "hello_world"
     end
-    
+
     def hello_world_as_string_with_options
       render "hello_world", :status => 404
     end
-    
+
     def hello_world_as_symbol
       render :hello_world
     end
@@ -28,298 +26,295 @@ module RenderAction
     def hello_world_with_symbol
       render :action => :hello_world
     end
-    
+
     def hello_world_with_layout
       render :action => "hello_world", :layout => true
     end
-    
+
     def hello_world_with_layout_false
       render :action => "hello_world", :layout => false
     end
-    
+
     def hello_world_with_layout_nil
       render :action => "hello_world", :layout => nil
     end
-    
+
     def hello_world_with_custom_layout
       render :action => "hello_world", :layout => "greetings"
     end
-    
-  end
-  
-  class TestBasic < SimpleRouteCase
-    describe "Rendering an action using :action => <String>"
-    
-    get "/render_action/basic/hello_world"
-    assert_body   "Hello world!"
-    assert_status 200
-  end
-  
-  class TestWithString < SimpleRouteCase
-    describe "Render an action using 'hello_world'"
-    
-    get "/render_action/basic/hello_world_as_string"
-    assert_body   "Hello world!"
-    assert_status 200
-  end
-  
-  class TestWithStringAndOptions < SimpleRouteCase
-    describe "Render an action using 'hello_world'"
-    
-    get "/render_action/basic/hello_world_as_string_with_options"
-    assert_body   "Hello world!"
-    assert_status 404
-  end
-  
-  class TestAsSymbol < SimpleRouteCase
-    describe "Render an action using :hello_world"
-    
-    get "/render_action/basic/hello_world_as_symbol"
-    assert_body   "Hello world!"
-    assert_status 200
+
   end
-  
-  class TestWithSymbol < SimpleRouteCase
-    describe "Render an action using :action => :hello_world"
-    
-    get "/render_action/basic/hello_world_with_symbol"
-    assert_body   "Hello world!"
-    assert_status 200
+
+  class RenderActionTest < SimpleRouteCase
+    test "rendering an action using :action => <String>" do
+      get "/render_action/basic/hello_world"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering an action using '<action>'" do
+      get "/render_action/basic/hello_world_as_string"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering an action using '<action>' and options" do
+      get "/render_action/basic/hello_world_as_string_with_options"
+
+      assert_body "Hello world!"
+      assert_status 404
+    end
+
+    test "rendering an action using :action" do
+      get "/render_action/basic/hello_world_as_symbol"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering an action using :action => :hello_world" do
+      get "/render_action/basic/hello_world_with_symbol"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
   end
-  
-  class TestLayoutTrue < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => true"
-    
-    test "raises an exception when requesting a layout and none exist" do
-      assert_raise(ArgumentError, /no default layout for RenderAction::BasicController in/) do 
-        get "/render_action/basic/hello_world_with_layout"
+
+  class RenderLayoutTest < SimpleRouteCase
+    describe "Both <controller_path>.html.erb and application.html.erb are missing"
+
+    test "rendering with layout => true" do
+      assert_raise(ArgumentError, /no default layout for RenderAction::BasicController in/) do
+        get "/render_action/basic/hello_world_with_layout", {}, "action_dispatch.show_exceptions" => false
       end
     end
-  end
-  
-  class TestLayoutFalse < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => false"
-    
-    get "/render_action/basic/hello_world_with_layout_false"
-    assert_body   "Hello world!"
-    assert_status 200
-  end
-  
-  class TestLayoutNil < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :nil"
-    
-    get "/render_action/basic/hello_world_with_layout_nil"
-    assert_body   "Hello world!"
-    assert_status 200
-  end
-  
-  class TestCustomLayout < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => 'greetings'"
-    
-    test "raises an exception when requesting a layout that does not exist" do
-      assert_raise(ActionView::MissingTemplate) { get "/render_action/basic/hello_world_with_custom_layout" }
+
+    test "rendering with layout => false" do
+      get "/render_action/basic/hello_world_with_layout_false"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :nil" do
+      get "/render_action/basic/hello_world_with_layout_nil"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering with layout => 'greetings'" do
+      assert_raise(ActionView::MissingTemplate) do
+        get "/render_action/basic/hello_world_with_custom_layout", {}, "action_dispatch.show_exceptions" => false
+      end
     end
   end
-  
 end
 
 module RenderActionWithApplicationLayout
-  
   # # ==== Render actions with layouts ====
-
   class BasicController < ::ApplicationController
     # Set the view path to an application view structure with layouts
-    self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+    self.view_paths = self.view_paths = [ActionView::Template::FixturePath.new(
       "render_action_with_application_layout/basic/hello_world.html.erb" => "Hello World!",
+      "render_action_with_application_layout/basic/hello.html.builder"   => "xml.p 'Omg'",
       "layouts/application.html.erb"                                     => "OHAI <%= yield %> KTHXBAI",
-      "layouts/greetings.html.erb"                                       => "Greetings <%= yield %> Bai"
+      "layouts/greetings.html.erb"                                       => "Greetings <%= yield %> Bai",
+      "layouts/builder.html.builder"                                     => "xml.html do\n  xml << yield\nend"
     )]
-    
+
     def hello_world
       render :action => "hello_world"
     end
-    
+
     def hello_world_with_layout
       render :action => "hello_world", :layout => true
     end
-    
+
     def hello_world_with_layout_false
       render :action => "hello_world", :layout => false
     end
-    
+
     def hello_world_with_layout_nil
       render :action => "hello_world", :layout => nil
     end
-    
+
     def hello_world_with_custom_layout
       render :action => "hello_world", :layout => "greetings"
     end
+
+    def with_builder_and_layout
+      render :action => "hello", :layout => "builder"
+    end
   end
-  
-  class TestDefaultLayout < SimpleRouteCase
-    describe %(
-      Render hello_world and implicitly use application.html.erb as a layout if 
-      no layout is specified and no controller layout is present
-    )
-      
-    get "/render_action_with_application_layout/basic/hello_world"
-    assert_body   "OHAI Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutTrue < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => true"
-    
-    get "/render_action_with_application_layout/basic/hello_world_with_layout"
-    assert_body   "OHAI Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutFalse < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => false"
-    
-    get "/render_action_with_application_layout/basic/hello_world_with_layout_false"
-    assert_body   "Hello World!"
-    assert_status 200
-  end
-  
-  class TestLayoutNil < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :nil"
-    
-    get "/render_action_with_application_layout/basic/hello_world_with_layout_nil"
-    assert_body   "Hello World!"
-    assert_status 200
+
+  class LayoutTest < SimpleRouteCase
+    describe "Only application.html.erb is present and <controller_path>.html.erb is missing"
+
+    test "rendering implicit application.html.erb as layout" do
+      get "/render_action_with_application_layout/basic/hello_world"
+
+      assert_body "OHAI Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => true" do
+      get "/render_action_with_application_layout/basic/hello_world_with_layout"
+
+      assert_body "OHAI Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => false" do
+      get "/render_action_with_application_layout/basic/hello_world_with_layout_false"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :nil" do
+      get "/render_action_with_application_layout/basic/hello_world_with_layout_nil"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
+
+    test "rendering with layout => 'greetings'" do
+      get "/render_action_with_application_layout/basic/hello_world_with_custom_layout"
+
+      assert_body "Greetings Hello World! Bai"
+      assert_status 200
+    end
   end
-  
-  class TestCustomLayout < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => 'greetings'"
-    
-    get "/render_action_with_application_layout/basic/hello_world_with_custom_layout"
-    assert_body   "Greetings Hello World! Bai"
-    assert_status 200
+
+  class TestLayout < SimpleRouteCase
+    testing BasicController
+
+    test "builder works with layouts" do
+      get :with_builder_and_layout
+      assert_response "<html>\n<p>Omg</p>\n</html>\n"
+    end
   end
-  
+
 end
 
 module RenderActionWithControllerLayout
-  
-  class BasicController < ActionController::Base2
-    self.view_paths = self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+  class BasicController < ActionController::Base
+    self.view_paths = self.view_paths = [ActionView::Template::FixturePath.new(
       "render_action_with_controller_layout/basic/hello_world.html.erb" => "Hello World!",
       "layouts/render_action_with_controller_layout/basic.html.erb"     => "With Controller Layout! <%= yield %> KTHXBAI"
     )]
-    
+
     def hello_world
       render :action => "hello_world"
     end
-    
+
     def hello_world_with_layout
       render :action => "hello_world", :layout => true
     end
-    
+
     def hello_world_with_layout_false
       render :action => "hello_world", :layout => false
     end
-    
+
     def hello_world_with_layout_nil
       render :action => "hello_world", :layout => nil
     end
-    
+
     def hello_world_with_custom_layout
       render :action => "hello_world", :layout => "greetings"
     end
   end
-  
-  class TestControllerLayout < SimpleRouteCase
-    describe "Render hello_world and implicitly use <controller_path>.html.erb as a layout."
 
-    get "/render_action_with_controller_layout/basic/hello_world"
-    assert_body   "With Controller Layout! Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutTrue < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => true"
-    
-    get "/render_action_with_controller_layout/basic/hello_world_with_layout"
-    assert_body   "With Controller Layout! Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutFalse < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => false"
-    
-    get "/render_action_with_controller_layout/basic/hello_world_with_layout_false"
-    assert_body   "Hello World!"
-    assert_status 200
-  end
-  
-  class TestLayoutNil < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :nil"
-    
-    get "/render_action_with_controller_layout/basic/hello_world_with_layout_nil"
-    assert_body   "Hello World!"
-    assert_status 200
+  class ControllerLayoutTest < SimpleRouteCase
+    describe "Only <controller_path>.html.erb is present and application.html.erb is missing"
+
+    test "render hello_world and implicitly use <controller_path>.html.erb as a layout." do
+      get "/render_action_with_controller_layout/basic/hello_world"
+
+      assert_body "With Controller Layout! Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => true" do
+      get "/render_action_with_controller_layout/basic/hello_world_with_layout"
+
+      assert_body "With Controller Layout! Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => false" do
+      get "/render_action_with_controller_layout/basic/hello_world_with_layout_false"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :nil" do
+      get "/render_action_with_controller_layout/basic/hello_world_with_layout_nil"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
   end
-  
 end
 
 module RenderActionWithBothLayouts
-  
-  class BasicController < ActionController::Base2
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new({
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new({
       "render_action_with_both_layouts/basic/hello_world.html.erb" => "Hello World!",
       "layouts/application.html.erb"                                => "OHAI <%= yield %> KTHXBAI",
       "layouts/render_action_with_both_layouts/basic.html.erb"      => "With Controller Layout! <%= yield %> KTHXBAI"
     })]
-    
+
     def hello_world
       render :action => "hello_world"
     end
-    
+
     def hello_world_with_layout
       render :action => "hello_world", :layout => true
     end
-    
+
     def hello_world_with_layout_false
       render :action => "hello_world", :layout => false
     end
-    
+
     def hello_world_with_layout_nil
       render :action => "hello_world", :layout => nil
     end
   end
-  
-  class TestControllerLayoutFirst < SimpleRouteCase
-    describe "Render hello_world and implicitly use <controller_path>.html.erb over application.html.erb as a layout"
 
-    get "/render_action_with_both_layouts/basic/hello_world"
-    assert_body   "With Controller Layout! Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutTrue < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => true"
-    
-    get "/render_action_with_both_layouts/basic/hello_world_with_layout"
-    assert_body   "With Controller Layout! Hello World! KTHXBAI"
-    assert_status 200
-  end
-  
-  class TestLayoutFalse < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => false"
-    
-    get "/render_action_with_both_layouts/basic/hello_world_with_layout_false"
-    assert_body   "Hello World!"
-    assert_status 200
-  end
-  
-  class TestLayoutNil < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :nil"
-    
-    get "/render_action_with_both_layouts/basic/hello_world_with_layout_nil"
-    assert_body   "Hello World!"
-    assert_status 200
+  class ControllerLayoutTest < SimpleRouteCase
+    describe "Both <controller_path>.html.erb and application.html.erb are present"
+
+    test "rendering implicitly use <controller_path>.html.erb over application.html.erb as a layout" do
+      get "/render_action_with_both_layouts/basic/hello_world"
+
+      assert_body   "With Controller Layout! Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => true" do
+      get "/render_action_with_both_layouts/basic/hello_world_with_layout"
+
+      assert_body "With Controller Layout! Hello World! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering with layout => false" do
+      get "/render_action_with_both_layouts/basic/hello_world_with_layout_false"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :nil" do
+      get "/render_action_with_both_layouts/basic/hello_world_with_layout_nil"
+
+      assert_body "Hello World!"
+      assert_status 200
+    end
   end
-  
 end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_file_test.rb b/actionpack/test/new_base/render_file_test.rb
new file mode 100644
index 0000000000..769949be0c
--- /dev/null
+++ b/actionpack/test/new_base/render_file_test.rb
@@ -0,0 +1,110 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderFile
+  
+  class BasicController < ActionController::Base
+    self.view_paths = "."
+    
+    def index
+      render :file => File.join(File.dirname(__FILE__), *%w[.. fixtures test hello_world])
+    end
+    
+    def with_instance_variables
+      @secret = 'in the sauce'
+      render :file => File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar.erb')
+    end
+    
+    def without_file_key
+      render File.join(File.dirname(__FILE__), *%w[.. fixtures test hello_world])
+    end
+    
+    def without_file_key_with_instance_variable
+      @secret = 'in the sauce'
+      render File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_ivar.erb')
+    end
+    
+    def relative_path
+      @secret = 'in the sauce'
+      render :file => '../fixtures/test/render_file_with_ivar'
+    end
+    
+    def relative_path_with_dot
+      @secret = 'in the sauce'
+      render :file => '../fixtures/test/dot.directory/render_file_with_ivar'
+    end
+    
+    def pathname
+      @secret = 'in the sauce'
+      render :file => Pathname.new(File.dirname(__FILE__)).join(*%w[.. fixtures test dot.directory render_file_with_ivar.erb])
+    end
+    
+    def with_locals
+      path = File.join(File.dirname(__FILE__), '../fixtures/test/render_file_with_locals.erb')
+      render :file => path, :locals => {:secret => 'in the sauce'}
+    end
+    
+    def without_file_key_with_locals
+      path = File.expand_path('../fixtures/test/render_file_with_locals.erb')
+      render path, :locals => {:secret => 'in the sauce'}
+    end
+  end
+  
+  class TestBasic < SimpleRouteCase
+    testing RenderFile::BasicController
+    
+    def setup
+      @old_pwd = Dir.pwd
+      Dir.chdir(File.dirname(__FILE__))
+    end
+    
+    def teardown
+      Dir.chdir(@old_pwd)
+    end
+    
+    test "rendering simple template" do
+      get :index
+      assert_response "Hello world!"
+    end
+    
+    test "rendering template with ivar" do
+      get :with_instance_variables
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering path without specifying the :file key" do
+      get :without_file_key
+      assert_response "Hello world!"
+    end
+    
+    test "rendering path without specifying the :file key with ivar" do
+      get :without_file_key_with_instance_variable
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering a relative path" do
+      get :relative_path
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering a relative path with dot" do
+      get :relative_path_with_dot
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering a Pathname" do
+      get :pathname
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering file with locals" do
+      get :with_locals
+      assert_response "The secret is in the sauce\n"
+    end
+    
+    test "rendering path without specifying the :file key with locals" do
+      get :without_file_key_with_locals
+      assert_response "The secret is in the sauce\n"
+    end
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_implicit_action_test.rb b/actionpack/test/new_base/render_implicit_action_test.rb
index 798505b539..2846df48da 100644
--- a/actionpack/test/new_base/render_implicit_action_test.rb
+++ b/actionpack/test/new_base/render_implicit_action_test.rb
@@ -1,16 +1,28 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
-module HappyPath
-  
-  class RenderImplicitActionController < ActionController::Base2
-    # No actions yet, they are implicit
+module RenderImplicitAction
+  class SimpleController < ::ApplicationController
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render_implicit_action/simple/hello_world.html.erb" => "Hello world!",
+      "render_implicit_action/simple/hyphen-ated.html.erb" => "Hello hyphen-ated!"
+    )]
+    
+    def hello_world() end
   end
   
-  class TestRendersActionImplicitly < SimpleRouteCase
-  
-    test "renders action implicitly" do
-      assert true
+  class RenderImplicitActionTest < SimpleRouteCase
+    test "render a simple action with new explicit call to render" do
+      get "/render_implicit_action/simple/hello_world"
+
+      assert_body   "Hello world!"
+      assert_status 200
+    end
+
+    test "render an action with a missing method and has special characters" do
+      get "/render_implicit_action/simple/hyphen-ated"
+
+      assert_body   "Hello hyphen-ated!"
+      assert_status 200
     end
-  
   end
 end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_layout_test.rb b/actionpack/test/new_base/render_layout_test.rb
index facf67ea85..f32c60d683 100644
--- a/actionpack/test/new_base/render_layout_test.rb
+++ b/actionpack/test/new_base/render_layout_test.rb
@@ -2,44 +2,100 @@ require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
 module ControllerLayouts
   class ImplicitController < ::ApplicationController
-    
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+    self.view_paths = [ActionView::Template::FixturePath.new(
       "layouts/application.html.erb" => "OMG <%= yield %> KTHXBAI",
-      "basic.html.erb" => "Hello world!"
+      "layouts/override.html.erb"    => "Override! <%= yield %>",
+      "basic.html.erb"               => "Hello world!",
+      "controller_layouts/implicit/layout_false.html.erb" => "hai(layout_false.html.erb)"
     )]
-    
+
     def index
       render :template => "basic"
     end
+
+    def override
+      render :template => "basic", :layout => "override"
+    end
+
+    def layout_false
+      render :layout => false
+    end
+
+    def builder_override
+    end
   end
-  
-  class TestImplicitLayout < SimpleRouteCase
-    describe "rendering a normal template, but using the implicit layout"
-    
-    get "/controller_layouts/implicit/index"
-    assert_body   "OMG Hello world! KTHXBAI"
-    assert_status 200
-  end
-  
+
   class ImplicitNameController < ::ApplicationController
-    
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+    self.view_paths = [ActionView::Template::FixturePath.new(
       "layouts/controller_layouts/implicit_name.html.erb" => "OMGIMPLICIT <%= yield %> KTHXBAI",
       "basic.html.erb" => "Hello world!"
     )]
-        
+
     def index
       render :template => "basic"
     end
   end
-  
-  class TestImplicitNamedLayout < SimpleRouteCase
-    describe "rendering a normal template, but using an implicit NAMED layout"
-    
-    get "/controller_layouts/implicit_name/index"
-    assert_body   "OMGIMPLICIT Hello world! KTHXBAI"
-    assert_status 200
+
+  class RenderLayoutTest < SimpleRouteCase
+    test "rendering a normal template, but using the implicit layout" do
+      get "/controller_layouts/implicit/index"
+
+      assert_body   "OMG Hello world! KTHXBAI"
+      assert_status 200
+    end
+
+    test "rendering a normal template, but using an implicit NAMED layout" do
+      get "/controller_layouts/implicit_name/index"
+
+      assert_body "OMGIMPLICIT Hello world! KTHXBAI"
+      assert_status 200
+    end
+
+    test "overriding an implicit layout with render :layout option" do
+      get "/controller_layouts/implicit/override"
+      assert_body "Override! Hello world!"
+    end
+
+  end
+
+  class LayoutOptionsTest < SimpleRouteCase
+    testing ControllerLayouts::ImplicitController
+
+    test "rendering with :layout => false leaves out the implicit layout" do
+      get :layout_false
+      assert_response "hai(layout_false.html.erb)"
+    end
+  end
+
+  class MismatchFormatController < ::ApplicationController
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "layouts/application.html.erb" => "<html><%= yield %></html>",
+      "controller_layouts/mismatch_format/index.js.rjs" => "page[:test].omg",
+      "controller_layouts/mismatch_format/implicit.rjs" => "page[:test].omg"      
+    )]
+
+    def explicit
+      render :layout => "application"
+    end
+  end
+
+  class MismatchFormatTest < SimpleRouteCase
+    testing ControllerLayouts::MismatchFormatController
+
+    test "if JS is selected, an HTML template is not also selected" do
+      get :index
+      assert_response "$(\"test\").omg();"
+    end
+
+    test "if JS is implicitly selected, an HTML template is not also selected" do
+      get :implicit
+      assert_response "$(\"test\").omg();"
+    end
+
+    test "if an HTML template is explicitly provides for a JS template, an error is raised" do
+      assert_raises ActionView::MissingTemplate do
+        get :explicit, {}, "action_dispatch.show_exceptions" => false
+      end
+    end
   end
-  
-  
 end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_partial_test.rb b/actionpack/test/new_base/render_partial_test.rb
new file mode 100644
index 0000000000..3a300afe5c
--- /dev/null
+++ b/actionpack/test/new_base/render_partial_test.rb
@@ -0,0 +1,27 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderPartial
+  
+  class BasicController < ActionController::Base
+    
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render_partial/basic/_basic.html.erb"    => "OMG!",
+      "render_partial/basic/basic.html.erb"      => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'basic' %><%= @test_unchanged %>"
+    )]
+    
+    def changing
+      @test_unchanged = 'hello'
+      render :action => "basic"
+    end    
+  end
+  
+  class TestPartial < SimpleRouteCase
+    testing BasicController
+    
+    test "rendering a partial in ActionView doesn't pull the ivars again from the controller" do
+      get :changing
+      assert_response("goodbyeOMG!goodbye")
+    end
+  end
+  
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_template_test.rb b/actionpack/test/new_base/render_template_test.rb
index c6c0269b40..face5b7571 100644
--- a/actionpack/test/new_base/render_template_test.rb
+++ b/actionpack/test/new_base/render_template_test.rb
@@ -1,133 +1,170 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
-module HappyPath
-  
-  class RenderTemplateWithoutLayoutController < ActionController::Base2
-    
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
-      "test/basic.html.erb" => "Hello from basic.html.erb",
-      "shared.html.erb"     => "Elastica"
+module RenderTemplate
+  class WithoutLayoutController < ActionController::Base
+    
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "test/basic.html.erb"      => "Hello from basic.html.erb",
+      "shared.html.erb"          => "Elastica",
+      "locals.html.erb"          => "The secret is <%= secret %>",
+      "xml_template.xml.builder" => "xml.html do\n  xml.p 'Hello'\nend"
     )]
     
-    def render_hello_world
+    def index
       render :template => "test/basic"
     end
-
-    def render_hello_world_with_forward_slash
-      render :template => "/test/basic"
+    
+    def index_without_key
+      render "test/basic"
     end
 
-    def render_template_in_top_directory
+    def in_top_directory
       render :template => 'shared'
     end
 
-    def render_template_in_top_directory_with_slash
+    def in_top_directory_with_slash
       render :template => '/shared'
     end
-  end
-  
-  class TestTemplateRenderWithoutLayout < SimpleRouteCase
-    describe "rendering a normal template with full path without layout"
     
-    get "/happy_path/render_template_without_layout/render_hello_world"
-    assert_body   "Hello from basic.html.erb"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithForwardSlash < SimpleRouteCase
-    describe "rendering a normal template with full path starting with a leading slash"
+    def in_top_directory_with_slash_without_key
+      render '/shared'
+    end
+    
+    def with_locals
+      render :template => "locals", :locals => { :secret => 'area51' }
+    end
     
-    get "/happy_path/render_template_without_layout/render_hello_world_with_forward_slash"
-    assert_body   "Hello from basic.html.erb"
-    assert_status 200
+    def builder_template
+      render :template => "xml_template"
+    end
   end
   
-  class TestTemplateRenderInTopDirectory < SimpleRouteCase
-    describe "rendering a template not in a subdirectory"
+  class TestWithoutLayout < SimpleRouteCase
+    testing RenderTemplate::WithoutLayoutController
     
-    get "/happy_path/render_template_without_layout/render_template_in_top_directory"
-    assert_body   "Elastica"
-    assert_status 200
-  end
-
-  class TestTemplateRenderInTopDirectoryWithSlash < SimpleRouteCase
-    describe "rendering a template not in a subdirectory with a leading slash"
+    test "rendering a normal template with full path without layout" do
+      get :index
+      assert_response "Hello from basic.html.erb"
+    end
     
-    get "/happy_path/render_template_without_layout/render_template_in_top_directory_with_slash"
-    assert_body   "Elastica"
-    assert_status 200
-  end
+    test "rendering a normal template with full path without layout without key" do
+      get :index_without_key
+      assert_response "Hello from basic.html.erb"
+    end
+    
+    test "rendering a template not in a subdirectory" do
+      get :in_top_directory
+      assert_response "Elastica"
+    end
+    
+    test "rendering a template not in a subdirectory with a leading slash" do
+      get :in_top_directory_with_slash
+      assert_response "Elastica"
+    end
+    
+    test "rendering a template not in a subdirectory with a leading slash without key" do
+      get :in_top_directory_with_slash_without_key
+      assert_response "Elastica"
+    end
+    
+    test "rendering a template with local variables" do
+      get :with_locals
+      assert_response "The secret is area51"
+    end
     
-  class RenderTemplateWithLayoutController < ::ApplicationController
+    test "rendering a builder template" do
+      get :builder_template
+      assert_response "<html>\n  <p>Hello</p>\n</html>\n"
+    end
+  end
     
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+  class WithLayoutController < ::ApplicationController
+    self.view_paths = [ActionView::Template::FixturePath.new(
       "test/basic.html.erb"          => "Hello from basic.html.erb",
       "shared.html.erb"              => "Elastica",
       "layouts/application.html.erb" => "<%= yield %>, I'm here!",
       "layouts/greetings.html.erb"   => "<%= yield %>, I wish thee well."
     )]
     
-    def render_hello_world
+    def index
       render :template => "test/basic"
     end
     
-    def render_hello_world_with_layout
+    def with_layout
       render :template => "test/basic", :layout => true
     end
     
-    def render_hello_world_with_layout_false
+    def with_layout_false
       render :template => "test/basic", :layout => false
     end
     
-    def render_hello_world_with_layout_nil
+    def with_layout_nil
       render :template => "test/basic", :layout => nil
     end
     
-    def render_hello_world_with_custom_layout
+    def with_custom_layout
       render :template => "test/basic", :layout => "greetings"
     end
   end
   
-  class TestTemplateRenderWithLayout < SimpleRouteCase
-    describe "rendering a normal template with full path with layout"
-    
-    get "/happy_path/render_template_with_layout/render_hello_world"
-    assert_body   "Hello from basic.html.erb, I'm here!"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithLayoutTrue < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :true"
-    
-    get "/happy_path/render_template_with_layout/render_hello_world_with_layout"
-    assert_body   "Hello from basic.html.erb, I'm here!"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithLayoutFalse < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :false"
-    
-    get "/happy_path/render_template_with_layout/render_hello_world_with_layout_false"
-    assert_body   "Hello from basic.html.erb"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithLayoutNil < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => :nil"
-    
-    get "/happy_path/render_template_with_layout/render_hello_world_with_layout_nil"
-    assert_body   "Hello from basic.html.erb"
-    assert_status 200
-  end
-  
-  class TestTemplateRenderWithCustomLayout < SimpleRouteCase
-    describe "rendering a normal template with full path with layout => 'greetings'"
-    
-    get "/happy_path/render_template_with_layout/render_hello_world_with_custom_layout"
-    assert_body   "Hello from basic.html.erb, I wish thee well."
-    assert_status 200
+  class TestWithLayout < SimpleRouteCase
+    describe "Rendering with :template using implicit or explicit layout"
+
+    test "rendering with implicit layout" do
+      get "/render_template/with_layout"
+
+      assert_body "Hello from basic.html.erb, I'm here!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :true" do
+      get "/render_template/with_layout/with_layout"
+
+      assert_body "Hello from basic.html.erb, I'm here!"
+      assert_status 200
+    end
+
+    test "rendering with layout => :false" do
+      get "/render_template/with_layout/with_layout_false"
+
+      assert_body "Hello from basic.html.erb"
+      assert_status 200
+    end
+
+    test "rendering with layout => :nil" do
+      get "/render_template/with_layout/with_layout_nil"
+
+      assert_body "Hello from basic.html.erb"
+      assert_status 200
+    end
+
+    test "rendering layout => 'greetings'" do
+      get "/render_template/with_layout/with_custom_layout"
+
+      assert_body "Hello from basic.html.erb, I wish thee well."
+      assert_status 200
+    end
   end
-  
-  
 
+  module Compatibility
+    class WithoutLayoutController < ActionController::Base
+      self.view_paths = [ActionView::Template::FixturePath.new(
+        "test/basic.html.erb" => "Hello from basic.html.erb",
+        "shared.html.erb"     => "Elastica"
+      )]
+
+      def with_forward_slash
+        render :template => "/test/basic"
+      end
+    end
+
+    class TestTemplateRenderWithForwardSlash < SimpleRouteCase
+      test "rendering a normal template with full path starting with a leading slash" do
+        get "/render_template/compatibility/without_layout/with_forward_slash"
+
+        assert_body "Hello from basic.html.erb"
+        assert_status 200
+      end
+    end
+  end
 end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_test.rb b/actionpack/test/new_base/render_test.rb
new file mode 100644
index 0000000000..ed3d50fa0b
--- /dev/null
+++ b/actionpack/test/new_base/render_test.rb
@@ -0,0 +1,85 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module Render
+  class BlankRenderController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render/blank_render/index.html.erb"                  => "Hello world!",
+      "render/blank_render/access_request.html.erb"         => "The request: <%= request.method.to_s.upcase %>",
+      "render/blank_render/access_action_name.html.erb"     => "Action Name: <%= action_name %>",
+      "render/blank_render/access_controller_name.html.erb" => "Controller Name: <%= controller_name %>"
+    )]
+
+    def index
+      render
+    end
+
+    def access_request
+      render :action => "access_request"
+    end
+
+    def render_action_name
+      render :action => "access_action_name"
+    end
+
+    private
+
+    def secretz
+      render :text => "FAIL WHALE!"
+    end
+  end
+
+  class DoubleRenderController < ActionController::Base
+    def index
+      render :text => "hello"
+      render :text => "world"
+    end
+  end
+
+  class RenderTest < SimpleRouteCase
+    test "render with blank" do
+      get "/render/blank_render"
+
+      assert_body "Hello world!"
+      assert_status 200
+    end
+
+    test "rendering more than once raises an exception" do
+      assert_raises(AbstractController::DoubleRenderError) do
+        get "/render/double_render", {}, "action_dispatch.show_exceptions" => false
+      end
+    end
+  end
+
+  class TestOnlyRenderPublicActions < SimpleRouteCase
+    describe "Only public methods on actual controllers are callable actions"
+
+    test "raises an exception when a method of Object is called" do
+      assert_raises(AbstractController::ActionNotFound) do
+        get "/render/blank_render/clone", {}, "action_dispatch.show_exceptions" => false
+      end
+    end
+
+    test "raises an exception when a private method is called" do
+      assert_raises(AbstractController::ActionNotFound) do
+        get "/render/blank_render/secretz", {}, "action_dispatch.show_exceptions" => false
+      end
+    end
+  end
+  
+  class TestVariousObjectsAvailableInView < SimpleRouteCase
+    test "The request object is accessible in the view" do
+      get "/render/blank_render/access_request"
+      assert_body "The request: GET"
+    end
+
+    test "The action_name is accessible in the view" do
+      get "/render/blank_render/render_action_name"
+      assert_body "Action Name: render_action_name"
+    end
+
+    test "The controller_name is accessible in the view" do
+      get "/render/blank_render/access_controller_name"
+      assert_body "Controller Name: blank_render"
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/render_text_test.rb b/actionpack/test/new_base/render_text_test.rb
index a20ca5fb8c..ffc149283b 100644
--- a/actionpack/test/new_base/render_text_test.rb
+++ b/actionpack/test/new_base/render_text_test.rb
@@ -1,144 +1,139 @@
 require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
 
-class ApplicationController < ActionController::Base2
-end
-
-module HappyPath
-  
-  class RenderTextWithoutLayoutsController < ActionController::Base2
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new]
+module RenderText
+  class SimpleController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new]
     
-    def render_hello_world
+    def index
       render :text => "hello david"
     end
   end
-  
-  class RenderTextWithLayoutsController < ::ApplicationController
-    self.view_paths = [ActionView::FixtureTemplate::FixturePath.new(
+
+  class WithLayoutController < ::ApplicationController
+    self.view_paths = [ActionView::Template::FixturePath.new(
       "layouts/application.html.erb" => "<%= yield %>, I'm here!",
-      "layouts/greetings.html.erb"   => "<%= yield %>, I wish thee well."
+      "layouts/greetings.html.erb"   => "<%= yield %>, I wish thee well.",
+      "layouts/ivar.html.erb"        => "<%= yield %>, <%= @ivar %>"
     )]    
     
-    def render_hello_world
+    def index
       render :text => "hello david"
     end
     
-    def render_custom_code
+    def custom_code
       render :text => "hello world", :status => 404
     end
     
-    def render_with_custom_code_as_string
+    def with_custom_code_as_string
       render :text => "hello world", :status => "404 Not Found"
     end
     
-    def render_text_with_nil
+    def with_nil
       render :text => nil
     end
     
-    def render_text_with_nil_and_status
+    def with_nil_and_status
       render :text => nil, :status => 403
     end
 
-    def render_text_with_false
+    def with_false
       render :text => false
     end
     
-    def render_text_with_layout
+    def with_layout_true
       render :text => "hello world", :layout => true
     end
     
-    def render_text_with_layout_false
+    def with_layout_false
       render :text => "hello world", :layout => false
     end
     
-    def render_text_with_layout_nil
+    def with_layout_nil
       render :text => "hello world", :layout => nil
     end
     
-    def render_text_with_custom_layout
+    def with_custom_layout
       render :text => "hello world", :layout => "greetings"
     end
-  end
-  
-  class TestSimpleTextRenderWithNoLayout < SimpleRouteCase
-    describe "Rendering text from a action with default options renders the text with the layout"
-    
-    get "/happy_path/render_text_without_layouts/render_hello_world"
-    assert_body   "hello david"
-    assert_status 200
-  end
-  
-  class TestSimpleTextRenderWithLayout < SimpleRouteCase    
-    describe "Rendering text from a action with default options renders the text without the layout"
-    
-    get "/happy_path/render_text_with_layouts/render_hello_world"
-    assert_body   "hello david"
-    assert_status 200
-  end
-  
-  class TestTextRenderWithStatus < SimpleRouteCase
-    describe "Rendering text, while also providing a custom status code"
-    
-    get "/happy_path/render_text_with_layouts/render_custom_code"
-    assert_body   "hello world"
-    assert_status 404
-  end
-  
-  class TestTextRenderWithNil < SimpleRouteCase
-    describe "Rendering text with nil returns a single space character"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_nil"
-    assert_body   " "
-    assert_status 200
-  end
-  
-  class TestTextRenderWithNilAndStatus < SimpleRouteCase
-    describe "Rendering text with nil and custom status code returns a single space character with the status"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_nil_and_status"
-    assert_body   " "
-    assert_status 403
-  end
-  
-  class TestTextRenderWithFalse < SimpleRouteCase
-    describe "Rendering text with false returns the string 'false'"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_false"
-    assert_body   "false"
-    assert_status 200
-  end
-  
-  class TestTextRenderWithLayoutTrue < SimpleRouteCase
-    describe "Rendering text with :layout => true"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_layout"
-    assert_body "hello world, I'm here!"
-    assert_status 200
-  end
-  
-  class TestTextRenderWithCustomLayout < SimpleRouteCase
-    describe "Rendering text with :layout => 'greetings'"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_custom_layout"
-    assert_body "hello world, I wish thee well."
-    assert_status 200
-  end
-  
-  class TestTextRenderWithLayoutFalse < SimpleRouteCase
-    describe "Rendering text with :layout => false"
     
-    get "/happy_path/render_text_with_layouts/render_text_with_layout_false"
-    assert_body "hello world"
-    assert_status 200
+    def with_ivar_in_layout
+      @ivar = "hello world"
+      render :text => "hello world", :layout => "ivar"
+    end
   end
-  
-  class TestTextRenderWithLayoutNil < SimpleRouteCase
-    describe "Rendering text with :layout => nil"
-    
-    get "/happy_path/render_text_with_layouts/render_text_with_layout_nil"
-    assert_body "hello world"
-    assert_status 200
+
+  class RenderTextTest < SimpleRouteCase
+    describe "Rendering text using render :text"
+
+    test "rendering text from a action with default options renders the text with the layout" do
+      get "/render_text/simple"
+      assert_body "hello david"
+      assert_status 200
+    end
+
+    test "rendering text from a action with default options renders the text without the layout" do
+      get "/render_text/with_layout"
+
+      assert_body "hello david"
+      assert_status 200
+    end
+
+    test "rendering text, while also providing a custom status code" do
+      get "/render_text/with_layout/custom_code"
+
+      assert_body "hello world"
+      assert_status 404
+    end
+
+    test "rendering text with nil returns an empty body padded for Safari" do
+      get "/render_text/with_layout/with_nil"
+
+      assert_body " "
+      assert_status 200
+    end
+
+    test "Rendering text with nil and custom status code returns an empty body padded for Safari and the status" do
+      get "/render_text/with_layout/with_nil_and_status"
+
+      assert_body " "
+      assert_status 403
+    end
+
+    test "rendering text with false returns the string 'false'" do
+      get "/render_text/with_layout/with_false"
+
+      assert_body "false"
+      assert_status 200
+    end
+
+    test "rendering text with :layout => true" do
+      get "/render_text/with_layout/with_layout_true"
+
+      assert_body "hello world, I'm here!"
+      assert_status 200
+    end
+
+    test "rendering text with :layout => 'greetings'" do
+      get "/render_text/with_layout/with_custom_layout"
+
+      assert_body "hello world, I wish thee well."
+      assert_status 200
+    end
+
+    test "rendering text with :layout => false" do
+      get "/render_text/with_layout/with_layout_false"
+
+      assert_body "hello world"
+      assert_status 200
+    end
+
+    test "rendering text with :layout => nil" do
+      get "/render_text/with_layout/with_layout_nil"
+
+      assert_body "hello world"
+      assert_status 200
+    end
   end
 end
 
-ActionController::Base2.app_loaded!
\ No newline at end of file
+ActionController::Base.app_loaded!
diff --git a/actionpack/test/new_base/render_xml_test.rb b/actionpack/test/new_base/render_xml_test.rb
new file mode 100644
index 0000000000..e6c40b1533
--- /dev/null
+++ b/actionpack/test/new_base/render_xml_test.rb
@@ -0,0 +1,11 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), "test_helper")
+
+module RenderXml
+  
+  # This has no layout and it works
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::Template::FixturePath.new(
+      "render_xml/basic/with_render_erb" => "Hello world!"
+    )]
+  end
+end
\ No newline at end of file
diff --git a/actionpack/test/new_base/test_helper.rb b/actionpack/test/new_base/test_helper.rb
index d29449ddc1..d92029df7f 100644
--- a/actionpack/test/new_base/test_helper.rb
+++ b/actionpack/test/new_base/test_helper.rb
@@ -5,8 +5,7 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 require 'test/unit'
 require 'active_support'
 require 'active_support/test_case'
-require 'action_controller'
-require 'action_view/base'
+require 'action_view'
 require 'fixture_template'
 
 begin
@@ -21,118 +20,85 @@ require 'action_controller/abstract'
 require 'action_controller/new_base'
 require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
 
-require 'rubygems'
-require 'rack/test'
-
-module ActionController
-  class Base2 < AbstractBase
-    use AbstractController::Callbacks
-    use AbstractController::Helpers
-    use AbstractController::Logger
-
-    use ActionController::HideActions
-    use ActionController::UrlFor
-    use ActionController::Renderer
-    use ActionController::Layouts
-    
-    def self.inherited(klass)
-      ::ActionController::Base2.subclasses << klass.to_s
-      super
-    end
-    
-    def self.subclasses
-      @subclasses ||= []
-    end
-    
-    def self.app_loaded!
-      @subclasses.each do |subclass|
-        subclass.constantize._write_layout_method
-      end
-    end
-    
-    # append_view_path File.join(File.dirname(__FILE__), '..', 'fixtures')
-        
-    CORE_METHODS = self.public_instance_methods
+require 'action_controller/testing/process'
+require 'action_controller/testing/integration'
+
+module Rails
+  def self.env
+    x = Object.new
+    def x.test?() true end
+    x
   end
 end
 
 # Temporary base class
-class Rack::TestCase < ActiveSupport::TestCase
-  include Rack::Test::Methods
-  
+class Rack::TestCase < ActionController::IntegrationTest
   setup do
     ActionController::Base.session_options[:key] = "abc"
     ActionController::Base.session_options[:secret] = ("*" * 30)
-    
-    controllers = ActionController::Base2.subclasses.map do |k| 
+
+    controllers = ActionController::Base.subclasses.map do |k| 
       k.underscore.sub(/_controller$/, '')
     end
-    
+
     ActionController::Routing.use_controllers!(controllers)
-    
+
     # Move into a bootloader
-    AbstractController::Base.subclasses.each do |klass|
+    ActionController::Base.subclasses.each do |klass|
       klass = klass.constantize
       next unless klass < AbstractController::Layouts
       klass.class_eval do
         _write_layout_method
       end
-    end    
+    end
   end
-    
+
   def app
     @app ||= ActionController::Dispatcher.new
   end
-  
-  def self.get(url)
-    setup do |test|
-      test.get url
+
+  def self.testing(klass = nil)
+    if klass
+      @testing = "/#{klass.name.underscore}".sub!(/_controller$/, '')
+    else
+      @testing
     end
   end
-  
-  def assert_body(body)
-    assert_equal [body], last_response.body
-  end
-  
-  def self.assert_body(body)
-    test "body is set to '#{body}'" do
-      assert_body body
+
+  def get(thing, *args)
+    if thing.is_a?(Symbol)
+      super("#{self.class.testing}/#{thing}", *args)
+    else
+      super
     end
   end
-  
+
+  def assert_body(body)
+    assert_equal body, Array.wrap(response.body).join
+  end
+
   def assert_status(code)
-    assert_equal code, last_response.status
+    assert_equal code, response.status
   end
-  
-  def self.assert_status(code)
-    test "status code is set to #{code}" do
-      assert_status code
+
+  def assert_response(body, status = 200, headers = {})
+    assert_body   body
+    assert_status status
+    headers.each do |header, value|
+      assert_header header, value
     end
   end
-  
+
   def assert_content_type(type)
-    assert_equal type, last_response.headers["Content-Type"]
-  end
-  
-  def self.assert_content_type(type)
-    test "content type is set to #{type}" do
-      assert_content_type(type)
-    end
+    assert_equal type, response.headers["Content-Type"]
   end
-  
+
   def assert_header(name, value)
-    assert_equal value, last_response.headers[name]
-  end
-  
-  def self.assert_header(name, value)
-    test "'#{name}' header is set to #{value.inspect}" do
-      assert_header(name, value)
-    end
+    assert_equal value, response.headers[name]
   end
-  
 end
 
-class ::ApplicationController < ActionController::Base2
+class ::ApplicationController < ActionController::Base
 end
 
 class SimpleRouteCase < Rack::TestCase
diff --git a/actionpack/test/template/body_parts_test.rb b/actionpack/test/template/body_parts_test.rb
index 4c82b75cdc..4e7aa63f96 100644
--- a/actionpack/test/template/body_parts_test.rb
+++ b/actionpack/test/template/body_parts_test.rb
@@ -4,9 +4,12 @@ class BodyPartsTest < ActionController::TestCase
   RENDERINGS = [Object.new, Object.new, Object.new]
 
   class TestController < ActionController::Base
+    def performed?
+      defined?(ActionController::Http) ? true : super
+    end
     def index
       RENDERINGS.each do |rendering|
-        response.template.punctuate_body! rendering
+        @template.punctuate_body! rendering
       end
       @performed_render = true
     end
@@ -16,7 +19,11 @@ class BodyPartsTest < ActionController::TestCase
 
   def test_body_parts
     get :index
-    assert_equal RENDERINGS, @response.body_parts
+    pending(:old_base) do
+      # TestProcess buffers body_parts into body
+      # TODO: Rewrite test w/o going through process
+      assert_equal RENDERINGS, @response.body_parts
+    end
     assert_equal RENDERINGS.join, @response.body
   end
 end
diff --git a/actionpack/test/template/compiled_templates_test.rb b/actionpack/test/template/compiled_templates_test.rb
index c75e29ed9a..b29b03f99d 100644
--- a/actionpack/test/template/compiled_templates_test.rb
+++ b/actionpack/test/template/compiled_templates_test.rb
@@ -5,37 +5,13 @@ class CompiledTemplatesTest < Test::Unit::TestCase
   def setup
     @compiled_templates = ActionView::Base::CompiledTemplates
     @compiled_templates.instance_methods.each do |m|
-      @compiled_templates.send(:remove_method, m) if m =~ /^_run_/
+      @compiled_templates.send(:remove_method, m) if m =~ /^_render_template_/
     end
   end
-
-  def test_template_gets_compiled
-    assert_equal 0, @compiled_templates.instance_methods.size
-    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-    assert_equal 1, @compiled_templates.instance_methods.size
-  end
-
+  
   def test_template_gets_recompiled_when_using_different_keys_in_local_assigns
-    assert_equal 0, @compiled_templates.instance_methods.size
-    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-    assert_equal "Hello world!", render(:file => "test/hello_world.erb", :locals => {:foo => "bar"})
-    assert_equal 2, @compiled_templates.instance_methods.size
-  end
-
-  def test_compiled_template_will_not_be_recompiled_when_rendered_with_identical_local_assigns
-    assert_equal 0, @compiled_templates.instance_methods.size
-    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-    ActionView::Template.any_instance.expects(:compile!).never
-    assert_equal "Hello world!", render(:file => "test/hello_world.erb")
-  end
-
-  def test_compiled_template_will_always_be_recompiled_when_template_is_not_cached
-    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)
-    3.times { assert_equal "Hello world!", render(:file => "#{FIXTURE_LOAD_PATH}/test/hello_world.erb") }
-    assert_equal 1, @compiled_templates.instance_methods.size
+    assert_equal "one", render(:file => "test/render_file_with_locals_and_default.erb")
+    assert_equal "two", render(:file => "test/render_file_with_locals_and_default.erb", :locals => { :secret => "two" })
   end
 
   def test_template_changes_are_not_reflected_with_cached_templates
@@ -61,14 +37,12 @@ class CompiledTemplatesTest < Test::Unit::TestCase
 
     def render_with_cache(*args)
       view_paths = ActionController::Base.view_paths
-      assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
       ActionView::Base.new(view_paths, {}).render(*args)
     end
 
     def render_without_cache(*args)
-      path = ActionView::Template::FileSystemPath.new(FIXTURE_LOAD_PATH)
+      path = ActionView::Template::FileSystemPathWithFallback.new(FIXTURE_LOAD_PATH)
       view_paths = ActionView::Base.process_view_paths(path)
-      assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
       ActionView::Base.new(view_paths, {}).render(*args)
     end
 
diff --git a/actionpack/test/template/form_options_helper_test.rb b/actionpack/test/template/form_options_helper_test.rb
index 78db87971b..73624406be 100644
--- a/actionpack/test/template/form_options_helper_test.rb
+++ b/actionpack/test/template/form_options_helper_test.rb
@@ -80,6 +80,14 @@ class FormOptionsHelperTest < ActionView::TestCase
     )
   end
 
+  def test_string_options_for_select
+    options = "<option value=\"Denmark\">Denmark</option><option value=\"USA\">USA</option><option value=\"Sweden\">Sweden</option>"
+    assert_dom_equal(
+      options,
+      options_for_select(options)
+    )
+  end
+
   def test_array_options_for_select
     assert_dom_equal(
       "<option value=\"&lt;Denmark&gt;\">&lt;Denmark&gt;</option>\n<option value=\"USA\">USA</option>\n<option value=\"Sweden\">Sweden</option>",
@@ -324,6 +332,20 @@ class FormOptionsHelperTest < ActionView::TestCase
     )
   end
 
+  def test_select_under_fields_for_with_string_and_given_prompt
+    @post = Post.new
+    options = "<option value=\"abe\">abe</option><option value=\"mus\">mus</option><option value=\"hest\">hest</option>"
+
+    fields_for :post, @post do |f|
+      concat f.select(:category, options, :prompt => 'The prompt')
+    end
+
+    assert_dom_equal(
+      "<select id=\"post_category\" name=\"post[category]\"><option value=\"\">The prompt</option>\n#{options}</select>",
+      output_buffer
+    )
+  end
+
   def test_select_with_blank
     @post = Post.new
     @post.category = "<mus>"
diff --git a/actionpack/test/template/javascript_helper_test.rb b/actionpack/test/template/javascript_helper_test.rb
index f9bc92c7c9..8caabfc3e1 100644
--- a/actionpack/test/template/javascript_helper_test.rb
+++ b/actionpack/test/template/javascript_helper_test.rb
@@ -3,6 +3,8 @@ require 'abstract_unit'
 class JavaScriptHelperTest < ActionView::TestCase
   tests ActionView::Helpers::JavaScriptHelper
 
+  def _evaluate_assigns_and_ivars() end
+
   attr_accessor :formats, :output_buffer
 
   def setup
@@ -10,6 +12,8 @@ class JavaScriptHelperTest < ActionView::TestCase
     @template = self
   end
 
+  def _evaluate_assigns_and_ivars() end
+
   def test_escape_javascript
     assert_equal '', escape_javascript(nil)
     assert_equal %(This \\"thing\\" is really\\n netos\\'), escape_javascript(%(This "thing" is really\n netos'))
diff --git a/actionpack/test/template/number_helper_test.rb b/actionpack/test/template/number_helper_test.rb
index 29cb60fd73..b6542ef29d 100644
--- a/actionpack/test/template/number_helper_test.rb
+++ b/actionpack/test/template/number_helper_test.rb
@@ -118,6 +118,10 @@ class NumberHelperTest < ActionView::TestCase
     assert_equal '1.01 KB',   number_to_human_size(1.0123.kilobytes, :precision => 2)
     assert_equal '1.01 KB',   number_to_human_size(1.0100.kilobytes, :precision => 4)
     assert_equal '10 KB',     number_to_human_size(10.000.kilobytes, :precision => 4)
+    assert_equal '1 TB', number_to_human_size(1234567890123, :precision => 0)
+    assert_equal '500 MB', number_to_human_size(524288000, :precision=>0)
+    assert_equal '40 KB', number_to_human_size(41010, :precision => 0)
+    assert_equal '40 KB', number_to_human_size(41100, :precision => 0)
   end
 
   def test_number_to_human_size_with_custom_delimiter_and_separator
diff --git a/actionpack/test/template/output_buffer_test.rb b/actionpack/test/template/output_buffer_test.rb
index 6d8eab63dc..36bbaf9099 100644
--- a/actionpack/test/template/output_buffer_test.rb
+++ b/actionpack/test/template/output_buffer_test.rb
@@ -9,27 +9,52 @@ class OutputBufferTest < ActionController::TestCase
 
   tests TestController
 
-  def test_flush_output_buffer
-    # Start with the default body parts
+  def setup
     get :index
-    assert_equal ['foo'], @response.body_parts
-    assert_nil @response.template.output_buffer
-
-    # Nil output buffer is skipped
-    @response.template.flush_output_buffer
-    assert_nil @response.template.output_buffer
-    assert_equal ['foo'], @response.body_parts
-
-    # Empty output buffer is skipped
-    @response.template.output_buffer = ''
-    @response.template.flush_output_buffer
-    assert_equal '', @response.template.output_buffer
-    assert_equal ['foo'], @response.body_parts
-
-    # Flushing appends the output buffer to the body parts
-    @response.template.output_buffer = 'bar'
-    @response.template.flush_output_buffer
-    assert_equal '', @response.template.output_buffer
-    assert_equal ['foo', 'bar'], @response.body_parts
+    assert_equal ['foo'], body_parts
   end
+
+  test 'output buffer is nil after rendering' do
+    assert_nil output_buffer
+  end
+
+  test 'flushing ignores nil output buffer' do
+    @controller.template.flush_output_buffer
+    assert_nil output_buffer
+    assert_equal ['foo'], body_parts
+  end
+
+  test 'flushing ignores empty output buffer' do
+    @controller.template.output_buffer = ''
+    @controller.template.flush_output_buffer
+    assert_equal '', output_buffer
+    assert_equal ['foo'], body_parts
+  end
+
+  test 'flushing appends the output buffer to the body parts' do
+    @controller.template.output_buffer = 'bar'
+    @controller.template.flush_output_buffer
+    assert_equal '', output_buffer
+    assert_equal ['foo', 'bar'], body_parts
+  end
+
+  if '1.9'.respond_to?(:force_encoding)
+    test 'flushing preserves output buffer encoding' do
+      original_buffer = ' '.force_encoding(Encoding::EUC_JP)
+      @controller.template.output_buffer = original_buffer
+      @controller.template.flush_output_buffer
+      assert_equal ['foo', original_buffer], body_parts
+      assert_not_equal original_buffer, output_buffer
+      assert_equal Encoding::EUC_JP, output_buffer.encoding
+    end
+  end
+
+  protected
+    def output_buffer
+      @controller.template.output_buffer
+    end
+
+    def body_parts
+      @controller.template.response.body_parts
+    end
 end
diff --git a/actionpack/test/template/prototype_helper_test.rb b/actionpack/test/template/prototype_helper_test.rb
index cd6ee6ea11..f9f418aec9 100644
--- a/actionpack/test/template/prototype_helper_test.rb
+++ b/actionpack/test/template/prototype_helper_test.rb
@@ -61,6 +61,8 @@ class PrototypeHelperBaseTest < ActionView::TestCase
 end
 
 class PrototypeHelperTest < PrototypeHelperBaseTest
+  def _evaluate_assigns_and_ivars() end
+
   def setup
     @record = @author = Author.new
     @article = Article.new
@@ -304,6 +306,8 @@ class JavaScriptGeneratorTest < PrototypeHelperBaseTest
     @generator = create_generator
   end
 
+  def _evaluate_assigns_and_ivars() end
+
   def test_insert_html_with_string
     assert_equal 'Element.insert("element", { top: "\\u003Cp\\u003EThis is a test\\u003C/p\\u003E" });',
       @generator.insert_html(:top, 'element', '<p>This is a test</p>')
@@ -328,28 +332,28 @@ class JavaScriptGeneratorTest < PrototypeHelperBaseTest
   def test_remove
     assert_equal 'Element.remove("foo");',
       @generator.remove('foo')
-    assert_equal '["foo", "bar", "baz"].each(Element.remove);',
+    assert_equal '["foo","bar","baz"].each(Element.remove);',
       @generator.remove('foo', 'bar', 'baz')
   end
 
   def test_show
     assert_equal 'Element.show("foo");',
       @generator.show('foo')
-    assert_equal '["foo", "bar", "baz"].each(Element.show);',
+    assert_equal '["foo","bar","baz"].each(Element.show);',
       @generator.show('foo', 'bar', 'baz')
   end
 
   def test_hide
     assert_equal 'Element.hide("foo");',
       @generator.hide('foo')
-    assert_equal '["foo", "bar", "baz"].each(Element.hide);',
+    assert_equal '["foo","bar","baz"].each(Element.hide);',
       @generator.hide('foo', 'bar', 'baz')
   end
 
   def test_toggle
     assert_equal 'Element.toggle("foo");',
       @generator.toggle('foo')
-    assert_equal '["foo", "bar", "baz"].each(Element.toggle);',
+    assert_equal '["foo","bar","baz"].each(Element.toggle);',
       @generator.toggle('foo', 'bar', 'baz')
   end
 
@@ -386,7 +390,7 @@ class JavaScriptGeneratorTest < PrototypeHelperBaseTest
     assert_equal <<-EOS.chomp, @generator.to_s
 Element.insert("element", { top: "\\u003Cp\\u003EThis is a test\\u003C/p\\u003E" });
 Element.insert("element", { bottom: "\\u003Cp\\u003EThis is a test\\u003C/p\\u003E" });
-["foo", "bar"].each(Element.remove);
+["foo","bar"].each(Element.remove);
 Element.update("baz", "\\u003Cp\\u003EThis is a test\\u003C/p\\u003E");
     EOS
   end
@@ -555,8 +559,8 @@ return (value.className == "welcome");
     end
 
     assert_equal <<-EOS.strip, @generator.to_s
-var a = [1, 2, 3].zip([4, 5, 6], [7, 8, 9]);
-var b = [1, 2, 3].zip([4, 5, 6], [7, 8, 9], function(array) {
+var a = [1, 2, 3].zip([4,5,6], [7,8,9]);
+var b = [1, 2, 3].zip([4,5,6], [7,8,9], function(array) {
 return array.reverse();
 });
     EOS
@@ -607,7 +611,7 @@ return value.reverse();
 
   def test_literal
     literal = @generator.literal("function() {}")
-    assert_equal "function() {}", literal.to_json
+    assert_equal "function() {}", ActiveSupport::JSON.encode(literal)
     assert_equal "", @generator.to_s
   end
 
diff --git a/actionpack/test/template/render_test.rb b/actionpack/test/template/render_test.rb
index 8843f6fdd7..a56d7aee75 100644
--- a/actionpack/test/template/render_test.rb
+++ b/actionpack/test/template/render_test.rb
@@ -29,23 +29,19 @@ module RenderTestCases
   end
 
   def test_render_file_with_localization
-    pending do
-      begin
-        old_locale = I18n.locale
-        I18n.locale = :da
-        assert_equal "Hey verden", @view.render(:file => "test/hello_world")
-      ensure
-        I18n.locale = old_locale
-      end
+    begin
+      old_locale = I18n.locale
+      I18n.locale = :da
+      assert_equal "Hey verden", @view.render(:file => "test/hello_world")
+    ensure
+      I18n.locale = old_locale
     end
   end
 
   def test_render_file_with_dashed_locale
     old_locale = I18n.locale
-    pending do
-      I18n.locale = :"pt-BR"
-      assert_equal "Ola mundo", @view.render(:file => "test/hello_world")
-    end
+    I18n.locale = :"pt-BR"
+    assert_equal "Ola mundo", @view.render(:file => "test/hello_world")
   ensure
     I18n.locale = old_locale
   end
@@ -95,10 +91,6 @@ module RenderTestCases
     assert_equal "The secret is in the sauce\n", @view.render(:file => "test/dot.directory/render_file_with_ivar")
   end
 
-  def test_render_has_access_current_template
-    assert_equal "test/template.erb", @view.render(:file => "test/template.erb")
-  end
-
   def test_render_update
     # TODO: You should not have to stub out template because template is self!
     @view.instance_variable_set(:@template, @view)
@@ -244,10 +236,6 @@ module RenderTestCases
     end
   end
 
-  def test_template_with_malformed_template_handler_is_reachable_through_its_exact_filename
-    assert_equal "Don't render me!", @view.render(:file => 'test/malformed/malformed.html.erb~')
-  end
-
   def test_render_with_layout
     assert_equal %(<title></title>\nHello world!\n),
       @view.render(:file => "test/hello_world.erb", :layout => "layouts/yield")
@@ -261,7 +249,7 @@ module RenderTestCases
   if '1.9'.respond_to?(:force_encoding)
     def test_render_utf8_template
       result = @view.render(:file => "test/utf8.html.erb", :layouts => "layouts/yield")
-      assert_equal "Русский текст\n日本語のテキスト", result
+      assert_equal "Русский текст\nUTF-8\nUTF-8\nUTF-8\n", result
       assert_equal Encoding::UTF_8, result.encoding
     end
   end
@@ -273,7 +261,7 @@ class CachedViewRenderTest < ActiveSupport::TestCase
   # Ensure view path cache is primed
   def setup
     view_paths = ActionController::Base.view_paths
-    assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+    assert_equal ActionView::Template::FileSystemPathWithFallback, view_paths.first.class
     setup_view(view_paths)
   end
 end
@@ -284,9 +272,9 @@ class LazyViewRenderTest < ActiveSupport::TestCase
   # Test the same thing as above, but make sure the view path
   # is not eager loaded
   def setup
-    path = ActionView::Template::FileSystemPath.new(FIXTURE_LOAD_PATH)
+    path = ActionView::Template::FileSystemPathWithFallback.new(FIXTURE_LOAD_PATH)
     view_paths = ActionView::Base.process_view_paths(path)
-    assert_equal ActionView::Template::FileSystemPath, view_paths.first.class
+    assert_equal ActionView::Template::FileSystemPathWithFallback, view_paths.first.class
     setup_view(view_paths)
   end
 end
diff --git a/actionpack/test/template/text_helper_test.rb b/actionpack/test/template/text_helper_test.rb
index be7163888e..706b5085f4 100644
--- a/actionpack/test/template/text_helper_test.rb
+++ b/actionpack/test/template/text_helper_test.rb
@@ -49,6 +49,9 @@ class TextHelperTest < ActionView::TestCase
     assert_equal "This is a string that wil[...]", truncate("This is a string that will go longer then the default truncate length of 30", :omission => "[...]")
     assert_equal "Hello W...", truncate("Hello World!", :length => 10)
     assert_equal "Hello[...]", truncate("Hello World!", :omission => "[...]", :length => 10)
+    assert_equal "Hello[...]", truncate("Hello Big World!", :omission => "[...]", :length => 13, :separator => ' ')
+    assert_equal "Hello Big[...]", truncate("Hello Big World!", :omission => "[...]", :length => 14, :separator => ' ')
+    assert_equal "Hello Big[...]", truncate("Hello Big World!", :omission => "[...]", :length => 15, :separator => ' ')
   end
 
   if RUBY_VERSION < '1.9.0'
@@ -401,6 +404,13 @@ class TextHelperTest < ActionView::TestCase
       auto_link("Welcome to my new blog at http://www.myblog.com/. Please e-mail me at me@email.com.",
                 :link => :all, :html => { :class => "menu", :target => "_blank" })
   end
+  
+  def test_auto_link_with_multiple_trailing_punctuations
+    url = "http://youtube.com"
+    url_result = generate_result(url)
+    assert_equal url_result, auto_link(url)
+    assert_equal "(link: #{url_result}).", auto_link("(link: #{url}).")
+  end
 
   def test_cycle_class
     value = Cycle.new("one", 2, "3")