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

33 files changed, 758 insertions, 587 deletions

diff --git a/actionpack/lib/action_dispatch/http/cache.rb b/actionpack/lib/action_dispatch/http/cache.rb
index aaed0d750f..bea62b94d2 100644
--- a/actionpack/lib/action_dispatch/http/cache.rb
+++ b/actionpack/lib/action_dispatch/http/cache.rb
@@ -4,14 +4,18 @@ module ActionDispatch
   module Http
     module Cache
       module Request
+
+        HTTP_IF_MODIFIED_SINCE = 'HTTP_IF_MODIFIED_SINCE'.freeze
+        HTTP_IF_NONE_MATCH     = 'HTTP_IF_NONE_MATCH'.freeze
+
         def if_modified_since
-          if since = env['HTTP_IF_MODIFIED_SINCE']
+          if since = env[HTTP_IF_MODIFIED_SINCE]
             Time.rfc2822(since) rescue nil
           end
         end
 
         def if_none_match
-          env['HTTP_IF_NONE_MATCH']
+          env[HTTP_IF_NONE_MATCH]
         end
 
         def not_modified?(modified_at)
@@ -43,31 +47,35 @@ module ActionDispatch
         alias :etag? :etag
 
         def last_modified
-          if last = headers['Last-Modified']
+          if last = headers[LAST_MODIFIED]
             Time.httpdate(last)
           end
         end
 
         def last_modified?
-          headers.include?('Last-Modified')
+          headers.include?(LAST_MODIFIED)
         end
 
         def last_modified=(utc_time)
-          headers['Last-Modified'] = utc_time.httpdate
+          headers[LAST_MODIFIED] = utc_time.httpdate
         end
 
         def etag=(etag)
           key = ActiveSupport::Cache.expand_cache_key(etag)
-          @etag = self["ETag"] = %("#{Digest::MD5.hexdigest(key)}")
+          @etag = self[ETAG] = %("#{Digest::MD5.hexdigest(key)}")
         end
 
       private
 
+        LAST_MODIFIED = "Last-Modified".freeze
+        ETAG          = "ETag".freeze
+        CACHE_CONTROL = "Cache-Control".freeze
+
         def prepare_cache_control!
           @cache_control = {}
-          @etag = self["ETag"]
+          @etag = self[ETAG]
 
-          if cache_control = self["Cache-Control"]
+          if cache_control = self[CACHE_CONTROL]
             cache_control.split(/,\s*/).each do |segment|
               first, last = segment.split("=")
               @cache_control[first.to_sym] = last || true
@@ -81,28 +89,32 @@ module ActionDispatch
           end
         end
 
-        DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
+        DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
+        NO_CACHE              = "no-cache".freeze
+        PUBLIC                = "public".freeze
+        PRIVATE               = "private".freeze
+        MUST_REVALIDATE       = "must-revalidate".freeze
 
         def set_conditional_cache_control!
-          return if self["Cache-Control"].present?
+          return if self[CACHE_CONTROL].present?
 
           control = @cache_control
 
           if control.empty?
-            headers["Cache-Control"] = DEFAULT_CACHE_CONTROL
+            headers[CACHE_CONTROL] = DEFAULT_CACHE_CONTROL
           elsif control[:no_cache]
-            headers["Cache-Control"] = "no-cache"
+            headers[CACHE_CONTROL] = NO_CACHE
           else
             extras  = control[:extras]
             max_age = control[:max_age]
 
             options = []
             options << "max-age=#{max_age.to_i}" if max_age
-            options << (control[:public] ? "public" : "private")
-            options << "must-revalidate" if control[:must_revalidate]
+            options << (control[:public] ? PUBLIC : PRIVATE)
+            options << MUST_REVALIDATE if control[:must_revalidate]
             options.concat(extras) if extras
 
-            headers["Cache-Control"] = options.join(", ")
+            headers[CACHE_CONTROL] = options.join(", ")
           end
         end
       end
diff --git a/actionpack/lib/action_dispatch/http/headers.rb b/actionpack/lib/action_dispatch/http/headers.rb
index 505d5560b1..040b51e040 100644
--- a/actionpack/lib/action_dispatch/http/headers.rb
+++ b/actionpack/lib/action_dispatch/http/headers.rb
@@ -1,5 +1,3 @@
-require 'active_support/memoizable'
-
 module ActionDispatch
   module Http
     class Headers < ::Hash
diff --git a/actionpack/lib/action_dispatch/http/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index 8a9f9c4315..25affb9f50 100644
--- a/actionpack/lib/action_dispatch/http/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -103,7 +103,7 @@ module Mime
         SET << Mime.const_get(symbol.to_s.upcase)
 
         ([string] + mime_type_synonyms).each { |str| LOOKUP[str] = SET.last } unless skip_lookup
-        ([symbol.to_s] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext] = SET.last }
+        ([symbol] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext.to_s] = SET.last }
       end
 
       def parse(accept_header)
diff --git a/actionpack/lib/action_dispatch/http/parameter_filter.rb b/actionpack/lib/action_dispatch/http/parameter_filter.rb
index 1480e8f77c..490b46c990 100644
--- a/actionpack/lib/action_dispatch/http/parameter_filter.rb
+++ b/actionpack/lib/action_dispatch/http/parameter_filter.rb
@@ -20,6 +20,8 @@ module ActionDispatch
         @filters.present?
       end
 
+      FILTERED = '[FILTERED]'.freeze
+
       def compiled_filter
         @compiled_filter ||= begin
           regexps, blocks = compile_filter
@@ -29,7 +31,7 @@ module ActionDispatch
 
             original_params.each do |key, value|
               if regexps.find { |r| key =~ r }
-                value = '[FILTERED]'
+                value = FILTERED
               elsif value.is_a?(Hash)
                 value = filter(value)
               elsif value.is_a?(Array)
diff --git a/actionpack/lib/action_dispatch/http/parameters.rb b/actionpack/lib/action_dispatch/http/parameters.rb
index ef5d207b26..d9b63faf5e 100644
--- a/actionpack/lib/action_dispatch/http/parameters.rb
+++ b/actionpack/lib/action_dispatch/http/parameters.rb
@@ -41,8 +41,6 @@ module ActionDispatch
       # you'll get a weird error down the road, but our form handling
       # should really prevent that from happening
       def encode_params(params)
-        return params unless "ruby".encoding_aware?
-
         if params.is_a?(String)
           return params.force_encoding("UTF-8").encode!
         elsif !params.is_a?(Hash)
diff --git a/actionpack/lib/action_dispatch/http/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index 37d0a3e0b8..0a0ebe7fad 100644
--- a/actionpack/lib/action_dispatch/http/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -35,14 +35,6 @@ module ActionDispatch
       METHOD
     end
 
-    def self.new(env)
-      if request = env["action_dispatch.request"] && request.instance_of?(self)
-        return request
-      end
-
-      super
-    end
-
     def key?(key)
       @env.key?(key)
     end
@@ -94,31 +86,31 @@ module ActionDispatch
     end
 
     # Is this a GET (or HEAD) request?
-    # Equivalent to <tt>request.request_method == :get</tt>.
+    # Equivalent to <tt>request.request_method_symbol == :get</tt>.
     def get?
       HTTP_METHOD_LOOKUP[request_method] == :get
     end
 
     # Is this a POST request?
-    # Equivalent to <tt>request.request_method == :post</tt>.
+    # Equivalent to <tt>request.request_method_symbol == :post</tt>.
     def post?
       HTTP_METHOD_LOOKUP[request_method] == :post
     end
 
     # Is this a PUT request?
-    # Equivalent to <tt>request.request_method == :put</tt>.
+    # Equivalent to <tt>request.request_method_symbol == :put</tt>.
     def put?
       HTTP_METHOD_LOOKUP[request_method] == :put
     end
 
     # Is this a DELETE request?
-    # Equivalent to <tt>request.request_method == :delete</tt>.
+    # Equivalent to <tt>request.request_method_symbol == :delete</tt>.
     def delete?
       HTTP_METHOD_LOOKUP[request_method] == :delete
     end
 
     # Is this a HEAD request?
-    # Equivalent to <tt>request.method == :head</tt>.
+    # Equivalent to <tt>request.method_symbol == :head</tt>.
     def head?
       HTTP_METHOD_LOOKUP[method] == :head
     end
@@ -130,10 +122,18 @@ module ActionDispatch
       Http::Headers.new(@env)
     end
 
+    def original_fullpath
+      @original_fullpath ||= (env["ORIGINAL_FULLPATH"] || fullpath)
+    end
+
     def fullpath
       @fullpath ||= super
     end
 
+    def original_url
+      base_url + original_fullpath
+    end
+
     def media_type
       content_mime_type.to_s
     end
@@ -155,28 +155,21 @@ module ActionDispatch
       @ip ||= super
     end
 
-    # Which IP addresses are "trusted proxies" that can be stripped from
-    # the right-hand-side of X-Forwarded-For.
-    #
-    # http://en.wikipedia.org/wiki/Private_network#Private_IPv4_address_spaces.
-    TRUSTED_PROXIES = %r{
-      ^127\.0\.0\.1$                | # localhost
-      ^(10                          | # private IP 10.x.x.x
-        172\.(1[6-9]|2[0-9]|3[0-1]) | # private IP in the range 172.16.0.0 .. 172.31.255.255
-        192\.168                      # private IP 192.168.x.x
-       )\.
-    }x
-
-    # Determines originating IP address. REMOTE_ADDR is the standard
-    # but will fail if the user is behind a proxy. HTTP_CLIENT_IP and/or
-    # HTTP_X_FORWARDED_FOR are set by proxies so check for these if
-    # REMOTE_ADDR is a proxy. HTTP_X_FORWARDED_FOR may be a comma-
-    # delimited list in the case of multiple chained proxies; the last
-    # address which is not trusted is the originating IP.
+    # Originating IP address, usually set by the RemoteIp middleware.
     def remote_ip
       @remote_ip ||= (@env["action_dispatch.remote_ip"] || ip).to_s
     end
 
+    # Returns the unique request id, which is based off either the X-Request-Id header that can
+    # be generated by a firewall, load balancer, or web server or by the RequestId middleware
+    # (which sets the action_dispatch.request_id environment variable).
+    #
+    # This unique ID is useful for tracing a request from end-to-end as part of logging or debugging.
+    # This relies on the rack variable set by the ActionDispatch::RequestId middleware.
+    def uuid
+      @uuid ||= env["action_dispatch.request_id"]
+    end
+
     # Returns the lowercase name of the HTTP server software.
     def server_software
       (@env['SERVER_SOFTWARE'] && /^([a-zA-Z]+)/ =~ @env['SERVER_SOFTWARE']) ? $1.downcase : nil
@@ -196,7 +189,7 @@ module ActionDispatch
     # variable is already set, wrap it in a StringIO.
     def body
       if raw_post = @env['RAW_POST_DATA']
-        raw_post.force_encoding(Encoding::BINARY) if raw_post.respond_to?(:force_encoding)
+        raw_post.force_encoding(Encoding::BINARY)
         StringIO.new(raw_post)
       else
         @env['rack.input']
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index f1e85559a3..84732085f0 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -53,8 +53,10 @@ module ActionDispatch # :nodoc:
     # information.
     attr_accessor :charset, :content_type
 
-    CONTENT_TYPE = "Content-Type"
-
+    CONTENT_TYPE = "Content-Type".freeze
+    SET_COOKIE   = "Set-Cookie".freeze
+    LOCATION     = "Location".freeze
+ 
     cattr_accessor(:default_charset) { "utf-8" }
 
     include Rack::Response::Helpers
@@ -66,10 +68,10 @@ module ActionDispatch # :nodoc:
       @sending_file = false
       @blank = false
 
-      if content_type = self["Content-Type"]
+      if content_type = self[CONTENT_TYPE]
         type, charset = content_type.split(/;\s*charset=/)
         @content_type = Mime::Type.lookup(type)
-        @charset = charset || "UTF-8"
+        @charset = charset || self.class.default_charset
       end
 
       prepare_cache_control!
@@ -109,9 +111,9 @@ module ActionDispatch # :nodoc:
     end
 
     def body
-      str = ''
-      each { |part| str << part.to_s }
-      str
+      strings = []
+      each { |part| strings << part.to_s }
+      strings.join
     end
 
     EMPTY = " "
@@ -119,14 +121,7 @@ module ActionDispatch # :nodoc:
     def body=(body)
       @blank = true if body == EMPTY
 
-      # Explicitly check for strings. This is *wrong* theoretically
-      # but if we don't check this, the performance on string bodies
-      # is bad on Ruby 1.8 (because strings responds to each then).
-      @body = if body.respond_to?(:to_str) || !body.respond_to?(:each)
-        [body]
-      else
-        body
-      end
+      @body = body.respond_to?(:each) ? body : [body]
     end
 
     def body_parts
@@ -142,12 +137,12 @@ module ActionDispatch # :nodoc:
     end
 
     def location
-      headers['Location']
+      headers[LOCATION]
     end
     alias_method :redirect_url, :location
 
     def location=(url)
-      headers['Location'] = url
+      headers[LOCATION] = url
     end
 
     def close
@@ -158,10 +153,10 @@ module ActionDispatch # :nodoc:
       assign_default_content_type_and_charset!
       handle_conditional_get!
 
-      @header["Set-Cookie"] = @header["Set-Cookie"].join("\n") if @header["Set-Cookie"].respond_to?(:join)
+      @header[SET_COOKIE] = @header[SET_COOKIE].join("\n") if @header[SET_COOKIE].respond_to?(:join)
 
       if [204, 304].include?(@status)
-        @header.delete "Content-Type"
+        @header.delete CONTENT_TYPE
         [@status, @header, []]
       else
         [@status, @header, self]
@@ -175,7 +170,7 @@ module ActionDispatch # :nodoc:
     #   assert_equal 'AuthorOfNewPage', r.cookies['author']
     def cookies
       cookies = {}
-      if header = self["Set-Cookie"]
+      if header = self[SET_COOKIE]
         header = header.split("\n") if header.respond_to?(:to_str)
         header.each do |cookie|
           if pair = cookie.split(';').first
diff --git a/actionpack/lib/action_dispatch/http/upload.rb b/actionpack/lib/action_dispatch/http/upload.rb
index 94fa747a79..5ab99d1061 100644
--- a/actionpack/lib/action_dispatch/http/upload.rb
+++ b/actionpack/lib/action_dispatch/http/upload.rb
@@ -22,8 +22,8 @@ module ActionDispatch
       
       private
       def encode_filename(filename)
-        # Encode the filename in the utf8 encoding, unless it is nil or we're in 1.8
-        if "ruby".encoding_aware? && filename
+        # Encode the filename in the utf8 encoding, unless it is nil
+        if filename
           filename.force_encoding("UTF-8").encode!
         else
           filename
diff --git a/actionpack/lib/action_dispatch/http/url.rb b/actionpack/lib/action_dispatch/http/url.rb
index 170c68f3e0..64459836b5 100644
--- a/actionpack/lib/action_dispatch/http/url.rb
+++ b/actionpack/lib/action_dispatch/http/url.rb
@@ -45,7 +45,7 @@ module ActionDispatch
 
           rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
           rewritten_url << "?#{params.to_query}" unless params.empty?
-          rewritten_url << "##{Journey::Router::Utils.escape_uri(options[:anchor].to_param.to_s)}" if options[:anchor]
+          rewritten_url << "##{Journey::Router::Utils.escape_fragment(options[:anchor].to_param.to_s)}" if options[:anchor]
           rewritten_url
         end
 
@@ -64,13 +64,13 @@ module ActionDispatch
         end
 
         def host_or_subdomain_and_domain(options)
-          return options[:host] if options[:subdomain].nil? && options[:domain].nil?
+          return options[:host] if !named_host?(options[:host]) || (options[:subdomain].nil? && options[:domain].nil?)
 
           tld_length = options[:tld_length] || @@tld_length
 
           host = ""
           unless options[:subdomain] == false
-            host << (options[:subdomain] || extract_subdomain(options[:host], tld_length))
+            host << (options[:subdomain] || extract_subdomain(options[:host], tld_length)).to_param
             host << "."
           end
           host << (options[:domain] || extract_domain(options[:host], tld_length))
diff --git a/actionpack/lib/action_dispatch/middleware/closed_error.rb b/actionpack/lib/action_dispatch/middleware/closed_error.rb
deleted file mode 100644
index 0a4db47f4b..0000000000
--- a/actionpack/lib/action_dispatch/middleware/closed_error.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-module ActionDispatch
-  class ClosedError < StandardError #:nodoc:
-    def initialize(kind)
-      super "Cannot modify #{kind} because it was closed. This means it was already streamed back to the client or converted to HTTP headers."
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/middleware/cookies.rb b/actionpack/lib/action_dispatch/middleware/cookies.rb
index 8c4615c0c1..39ff58a447 100644
--- a/actionpack/lib/action_dispatch/middleware/cookies.rb
+++ b/actionpack/lib/action_dispatch/middleware/cookies.rb
@@ -121,10 +121,6 @@ module ActionDispatch
         @cookies = {}
       end
 
-      attr_reader :closed
-      alias :closed? :closed
-      def close!; @closed = true end
-
       def each(&block)
         @cookies.each(&block)
       end
@@ -165,7 +161,6 @@ module ActionDispatch
       # Sets the cookie named +name+. The second argument may be the very cookie
       # value, or a hash of options as documented above.
       def []=(key, options)
-        raise ClosedError, :cookies if closed?
         if options.is_a?(Hash)
           options.symbolize_keys!
           value = options[:value]
@@ -174,7 +169,7 @@ module ActionDispatch
           options = { :value => value }
         end
 
-        value = @cookies[key.to_s] = value
+        @cookies[key.to_s] = value
 
         handle_options(options)
 
@@ -243,10 +238,13 @@ module ActionDispatch
         @delete_cookies.clear
       end
 
+      mattr_accessor :always_write_cookie
+      self.always_write_cookie = false
+
       private
 
         def write_cookie?(cookie)
-          @secure || !cookie[:secure] || defined?(Rails.env) && Rails.env.development?
+          @secure || !cookie[:secure] || always_write_cookie
         end
     end
 
@@ -256,7 +254,6 @@ module ActionDispatch
       end
 
       def []=(key, options)
-        raise ClosedError, :cookies if closed?
         if options.is_a?(Hash)
           options.symbolize_keys!
         else
@@ -295,7 +292,6 @@ module ActionDispatch
       end
 
       def []=(key, options)
-        raise ClosedError, :cookies if closed?
         if options.is_a?(Hash)
           options.symbolize_keys!
           options[:value] = @verifier.generate(options[:value])
@@ -349,9 +345,6 @@ module ActionDispatch
       end
 
       [status, headers, body]
-    ensure
-      cookie_jar = ActionDispatch::Request.new(env).cookie_jar unless cookie_jar
-      cookie_jar.close!
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb b/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb
new file mode 100644
index 0000000000..b903f98761
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/debug_exceptions.rb
@@ -0,0 +1,82 @@
+require 'action_dispatch/http/request'
+require 'action_dispatch/middleware/exception_wrapper'
+
+module ActionDispatch
+  # This middleware is responsible for logging exceptions and
+  # showing a debugging page in case the request is local.
+  class DebugExceptions
+    RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      begin
+        response = @app.call(env)
+
+        if response[1]['X-Cascade'] == 'pass'
+          body = response[2]
+          body.close if body.respond_to?(:close)
+          raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
+        end
+      rescue Exception => exception
+        raise exception if env['action_dispatch.show_exceptions'] == false
+      end
+
+      exception ? render_exception(env, exception) : response
+    end
+
+    private
+
+    def render_exception(env, exception)
+      wrapper = ExceptionWrapper.new(env, exception)
+      log_error(env, wrapper)
+
+      if env['action_dispatch.show_detailed_exceptions']
+        template = ActionView::Base.new([RESCUES_TEMPLATE_PATH],
+          :request => Request.new(env),
+          :exception => wrapper.exception,
+          :application_trace => wrapper.application_trace,
+          :framework_trace => wrapper.framework_trace,
+          :full_trace => wrapper.full_trace
+        )
+
+        file = "rescues/#{wrapper.rescue_template}"
+        body = template.render(:template => file, :layout => 'rescues/layout')
+        render(wrapper.status_code, body)
+      else
+        raise exception
+      end
+    end
+
+    def render(status, body)
+      [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
+    end
+
+    def log_error(env, wrapper)
+      logger = logger(env)
+      return unless logger
+
+      exception = wrapper.exception
+
+      trace = wrapper.application_trace
+      trace = wrapper.framework_trace if trace.empty?
+
+      ActiveSupport::Deprecation.silence do
+        message = "\n#{exception.class} (#{exception.message}):\n"
+        message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
+        message << "  " << trace.join("\n  ")
+        logger.fatal("#{message}\n\n")
+      end
+    end
+
+    def logger(env)
+      env['action_dispatch.logger'] || stderr_logger
+    end
+
+    def stderr_logger
+      @stderr_logger ||= ActiveSupport::Logger.new($stderr)
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb b/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb
new file mode 100644
index 0000000000..c0532c80c4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/exception_wrapper.rb
@@ -0,0 +1,78 @@
+require 'action_controller/metal/exceptions'
+require 'active_support/core_ext/exception'
+
+module ActionDispatch
+  class ExceptionWrapper
+    cattr_accessor :rescue_responses
+    @@rescue_responses = Hash.new(:internal_server_error)
+    @@rescue_responses.merge!(
+      'ActionController::RoutingError'             => :not_found,
+      'AbstractController::ActionNotFound'         => :not_found,
+      'ActionController::MethodNotAllowed'         => :method_not_allowed,
+      'ActionController::NotImplemented'           => :not_implemented,
+      'ActionController::InvalidAuthenticityToken' => :unprocessable_entity
+    )
+
+    cattr_accessor :rescue_templates
+    @@rescue_templates = Hash.new('diagnostics')
+    @@rescue_templates.merge!(
+      'ActionView::MissingTemplate'         => 'missing_template',
+      'ActionController::RoutingError'      => 'routing_error',
+      'AbstractController::ActionNotFound'  => 'unknown_action',
+      'ActionView::Template::Error'         => 'template_error'
+    )
+
+    attr_reader :env, :exception
+
+    def initialize(env, exception)
+      @env = env
+      @exception = original_exception(exception)
+    end
+
+    def rescue_template
+      @@rescue_templates[@exception.class.name]
+    end
+
+    def status_code
+      Rack::Utils.status_code(@@rescue_responses[@exception.class.name])
+    end
+
+    def application_trace
+      clean_backtrace(:silent)
+    end
+
+    def framework_trace
+      clean_backtrace(:noise)
+    end
+
+    def full_trace
+      clean_backtrace(:all)
+    end
+
+    private
+
+    def original_exception(exception)
+      if registered_original_exception?(exception)
+        exception.original_exception
+      else
+        exception
+      end
+    end
+
+    def registered_original_exception?(exception)
+      exception.respond_to?(:original_exception) && @@rescue_responses.has_key?(exception.original_exception.class.name)
+    end
+
+    def clean_backtrace(*args)
+      if backtrace_cleaner
+        backtrace_cleaner.clean(@exception.backtrace, *args)
+      else
+        @exception.backtrace
+      end
+    end
+
+    def backtrace_cleaner
+      @backtrace_cleaner ||= @env['action_dispatch.backtrace_cleaner']
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/middleware/flash.rb b/actionpack/lib/action_dispatch/middleware/flash.rb
index 2adbce031b..cff0877030 100644
--- a/actionpack/lib/action_dispatch/middleware/flash.rb
+++ b/actionpack/lib/action_dispatch/middleware/flash.rb
@@ -70,11 +70,15 @@ module ActionDispatch
       end
     end
 
+    # Implementation detail: please do not change the signature of the
+    # FlashHash class. Doing that will likely affect all Rails apps in
+    # production as the FlashHash currently stored in their sessions will
+    # become invalid.
     class FlashHash
       include Enumerable
 
       def initialize #:nodoc:
-        @used    = Set.new
+        @discard = Set.new
         @closed  = false
         @flashes = {}
         @now     = nil
@@ -89,8 +93,7 @@ module ActionDispatch
       end
 
       def []=(k, v) #:nodoc:
-        raise ClosedError, :flash if closed?
-        keep(k)
+        @discard.delete k
         @flashes[k] = v
       end
 
@@ -99,7 +102,7 @@ module ActionDispatch
       end
 
       def update(h) #:nodoc:
-        h.keys.each { |k| keep(k) }
+        @discard.subtract h.keys
         @flashes.update h
         self
       end
@@ -113,6 +116,7 @@ module ActionDispatch
       end
 
       def delete(key)
+        @discard.delete key
         @flashes.delete key
         self
       end
@@ -126,6 +130,7 @@ module ActionDispatch
       end
 
       def clear
+        @discard.clear
         @flashes.clear
       end
 
@@ -136,7 +141,7 @@ module ActionDispatch
       alias :merge! :update
 
       def replace(h) #:nodoc:
-        @used = Set.new
+        @discard.clear
         @flashes.replace h
         self
       end
@@ -155,16 +160,13 @@ module ActionDispatch
         @now ||= FlashNow.new(self)
       end
 
-      attr_reader :closed
-      alias :closed? :closed
-      def close!; @closed = true; end
-
       # Keeps either the entire current flash or a specific flash entry available for the next action:
       #
       #    flash.keep            # keeps the entire flash
       #    flash.keep(:notice)   # keeps only the "notice" entry, the rest of the flash is discarded
       def keep(k = nil)
-        use(k, false)
+        @discard.subtract Array(k || keys)
+        k ? self[k] : self
       end
 
       # Marks the entire flash or a single flash entry to be discarded by the end of the current action:
@@ -172,24 +174,16 @@ module ActionDispatch
       #     flash.discard              # discard the entire flash at the end of the current action
       #     flash.discard(:warning)    # discard only the "warning" entry at the end of the current action
       def discard(k = nil)
-        use(k)
+        @discard.merge Array(k || keys)
+        k ? self[k] : self
       end
 
       # Mark for removal entries that were kept, and delete unkept ones.
       #
       # This method is called automatically by filters, so you generally don't need to care about it.
       def sweep #:nodoc:
-        keys.each do |k|
-          unless @used.include?(k)
-            @used << k
-          else
-            delete(k)
-            @used.delete(k)
-          end
-        end
-
-        # clean up after keys that could have been left over by calling reject! or shift on the flash
-        (@used - keys).each{ |k| @used.delete(k) }
+        @discard.each { |k| @flashes.delete k }
+        @discard.replace @flashes.keys
       end
 
       # Convenience accessor for flash[:alert]
@@ -213,22 +207,9 @@ module ActionDispatch
       end
 
       protected
-
-        def now_is_loaded?
-          !!@now
-        end
-
-        # 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)
-        # 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 ? @used << k : @used.delete(k) }
-          return key ? self[key] : self
-        end
+      def now_is_loaded?
+        @now
+      end
     end
 
     def initialize(app)
@@ -254,7 +235,6 @@ module ActionDispatch
         end
 
         env[KEY] = new_hash
-        new_hash.close!
       end
 
       if session.key?('flash') && session['flash'].empty?
diff --git a/actionpack/lib/action_dispatch/middleware/params_parser.rb b/actionpack/lib/action_dispatch/middleware/params_parser.rb
index d4208ca96e..1cb803ffb9 100644
--- a/actionpack/lib/action_dispatch/middleware/params_parser.rb
+++ b/actionpack/lib/action_dispatch/middleware/params_parser.rb
@@ -52,14 +52,9 @@ module ActionDispatch
           false
         end
       rescue Exception => e # YAML, XML or Ruby code block errors
-        logger.debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
+        logger(env).debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
 
-        raise
-          { "body"           => request.raw_post,
-            "content_type"   => request.content_mime_type,
-            "content_length" => request.content_length,
-            "exception"      => "#{e.message} (#{e.class})",
-            "backtrace"      => e.backtrace }
+        raise e
       end
 
       def content_type_from_legacy_post_data_format_header(env)
@@ -73,8 +68,8 @@ module ActionDispatch
         nil
       end
 
-      def logger
-        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
+      def logger(env)
+        env['action_dispatch.logger'] || ActiveSupport::Logger.new($stderr)
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/public_exceptions.rb b/actionpack/lib/action_dispatch/middleware/public_exceptions.rb
new file mode 100644
index 0000000000..85b8d178bf
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/public_exceptions.rb
@@ -0,0 +1,30 @@
+module ActionDispatch
+  # A simple Rack application that renders exceptions in the given public path.
+  class PublicExceptions
+    attr_accessor :public_path
+
+    def initialize(public_path)
+      @public_path = public_path
+    end
+
+    def call(env)
+      status      = env["PATH_INFO"][1..-1]
+      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
+        [404, { "X-Cascade" => "pass" }, []]
+      end
+    end
+
+    private
+
+    def render(status, body)
+      [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.to_s}, [body]]
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/middleware/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
index 29289a76b4..4f48f1c974 100644
--- a/actionpack/lib/action_dispatch/middleware/reloader.rb
+++ b/actionpack/lib/action_dispatch/middleware/reloader.rb
@@ -43,34 +43,58 @@ module ActionDispatch
 
     # Execute all prepare callbacks.
     def self.prepare!
-      new(nil).run_callbacks :prepare
+      new(nil).prepare!
     end
 
     # Execute all cleanup callbacks.
     def self.cleanup!
-      new(nil).run_callbacks :cleanup
+      new(nil).cleanup!
     end
 
-    def initialize(app)
+    def initialize(app, condition=nil)
       @app = app
-    end
-
-    module CleanupOnClose
-      def close
-        super if defined?(super)
-      ensure
-        ActionDispatch::Reloader.cleanup!
-      end
+      @condition = condition || lambda { true }
+      @validated = true
     end
 
     def call(env)
-      run_callbacks :prepare
+      @validated = @condition.call
+      prepare!
       response = @app.call(env)
-      response[2].extend(CleanupOnClose)
+      response[2].extend(module_hook)
       response
     rescue Exception
-      run_callbacks :cleanup
+      cleanup!
       raise
     end
+
+    def prepare! #:nodoc:
+      run_callbacks :prepare if validated?
+    end
+
+    def cleanup! #:nodoc:
+      run_callbacks :cleanup if validated?
+    ensure
+      @validated = true
+    end
+
+    private
+
+    def validated? #:nodoc:
+      @validated
+    end
+
+    def module_hook #:nodoc:
+      middleware = self
+      Module.new do
+        define_method :close do
+          begin
+            super() if defined?(super)
+          ensure
+            middleware.cleanup!
+          end
+        end
+      end
+    end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/remote_ip.rb b/actionpack/lib/action_dispatch/middleware/remote_ip.rb
index c7d710b98e..66ece60860 100644
--- a/actionpack/lib/action_dispatch/middleware/remote_ip.rb
+++ b/actionpack/lib/action_dispatch/middleware/remote_ip.rb
@@ -2,50 +2,80 @@ module ActionDispatch
   class RemoteIp
     class IpSpoofAttackError < StandardError ; end
 
-    class RemoteIpGetter
-      def initialize(env, check_ip_spoofing, trusted_proxies)
-        @env = env
-        @check_ip_spoofing = check_ip_spoofing
-        @trusted_proxies = trusted_proxies
+    # IP addresses that are "trusted proxies" that can be stripped from
+    # the comma-delimited list in the X-Forwarded-For header. See also:
+    # http://en.wikipedia.org/wiki/Private_network#Private_IPv4_address_spaces
+    TRUSTED_PROXIES = %r{
+      ^127\.0\.0\.1$                | # localhost
+      ^(10                          | # private IP 10.x.x.x
+        172\.(1[6-9]|2[0-9]|3[0-1]) | # private IP in the range 172.16.0.0 .. 172.31.255.255
+        192\.168                      # private IP 192.168.x.x
+       )\.
+    }x
+
+    attr_reader :check_ip, :proxies
+
+    def initialize(app, check_ip_spoofing = true, custom_proxies = nil)
+      @app = app
+      @check_ip = check_ip_spoofing
+      if custom_proxies
+        custom_regexp = Regexp.new(custom_proxies)
+        @proxies = Regexp.union(TRUSTED_PROXIES, custom_regexp)
+      else
+        @proxies = TRUSTED_PROXIES
       end
+    end
 
-      def remote_addrs
-        @remote_addrs ||= begin
-          list = @env['REMOTE_ADDR'] ? @env['REMOTE_ADDR'].split(/[,\s]+/) : []
-          list.reject { |addr| addr =~ @trusted_proxies }
-        end
+    def call(env)
+      env["action_dispatch.remote_ip"] = GetIp.new(env, self)
+      @app.call(env)
+    end
+
+    class GetIp
+      def initialize(env, middleware)
+        @env          = env
+        @middleware   = middleware
+        @calculated_ip = false
       end
 
-      def to_s
-        return remote_addrs.first if remote_addrs.any?
-
-        forwarded_ips = @env['HTTP_X_FORWARDED_FOR'] ? @env['HTTP_X_FORWARDED_FOR'].strip.split(/[,\s]+/) : []
-
-        if client_ip = @env['HTTP_CLIENT_IP']
-          if @check_ip_spoofing && !forwarded_ips.include?(client_ip)
-            # We don't know which came from the proxy, and which from the user
-            raise IpSpoofAttackError, "IP spoofing attack?!" \
-              "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect}" \
-              "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
-          end
-          return client_ip
+      # Determines originating IP address. REMOTE_ADDR is the standard
+      # but will be wrong if the user is behind a proxy. Proxies will set
+      # HTTP_CLIENT_IP and/or HTTP_X_FORWARDED_FOR, so we prioritize those.
+      # HTTP_X_FORWARDED_FOR may be a comma-delimited list in the case of
+      # multiple chained proxies. The last address which is not a known proxy
+      # will be the originating IP.
+      def calculate_ip
+        client_ip     = @env['HTTP_CLIENT_IP']
+        forwarded_ips = ips_from('HTTP_X_FORWARDED_FOR')
+        remote_addrs  = ips_from('REMOTE_ADDR')
+
+        check_ip = client_ip && @middleware.check_ip
+        if check_ip && !forwarded_ips.include?(client_ip)
+          # We don't know which came from the proxy, and which from the user
+          raise IpSpoofAttackError, "IP spoofing attack?!" \
+            "HTTP_CLIENT_IP=#{@env['HTTP_CLIENT_IP'].inspect}" \
+            "HTTP_X_FORWARDED_FOR=#{@env['HTTP_X_FORWARDED_FOR'].inspect}"
         end
 
-        return forwarded_ips.reject { |ip| ip =~ @trusted_proxies }.last || @env["REMOTE_ADDR"]
+        not_proxy = client_ip || forwarded_ips.last || remote_addrs.first
+
+        # Return first REMOTE_ADDR if there are no other options
+        not_proxy || ips_from('REMOTE_ADDR', :allow_proxies).first
       end
-    end
 
-    def initialize(app, check_ip_spoofing = true, trusted_proxies = nil)
-      @app = app
-      @check_ip_spoofing = check_ip_spoofing
-      regex = '(^127\.0\.0\.1$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\.)'
-      regex << "|(#{trusted_proxies})" if trusted_proxies
-      @trusted_proxies = Regexp.new(regex, "i")
-    end
+      def to_s
+        return @ip if @calculated_ip
+        @calculated_ip = true
+        @ip = calculate_ip
+      end
 
-    def call(env)
-      env["action_dispatch.remote_ip"] = RemoteIpGetter.new(env, @check_ip_spoofing, @trusted_proxies)
-      @app.call(env)
+    protected
+
+      def ips_from(header, allow_proxies = false)
+        ips = @env[header] ? @env[header].strip.split(/[,\s]+/) : []
+        allow_proxies ? ips : ips.reject{|ip| ip =~ @middleware.proxies }
+      end
     end
+
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/middleware/request_id.rb b/actionpack/lib/action_dispatch/middleware/request_id.rb
new file mode 100644
index 0000000000..d5a0b80fd5
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/request_id.rb
@@ -0,0 +1,39 @@
+require 'securerandom'
+require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/object/blank'
+
+module ActionDispatch
+  # Makes a unique request id available to the action_dispatch.request_id env variable (which is then accessible through
+  # ActionDispatch::Request#uuid) and sends the same id to the client via the X-Request-Id header.
+  #
+  # The unique request id is either based off the X-Request-Id header in the request, which would typically be generated
+  # by a firewall, load balancer, or the web server, or, if this header is not available, a random uuid. If the
+  # header is accepted from the outside world, we sanitize it to a max of 255 chars and alphanumeric and dashes only.
+  #
+  # The unique request id can be used to trace a request end-to-end and would typically end up being part of log files
+  # from multiple pieces of the stack.
+  class RequestId
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["action_dispatch.request_id"] = external_request_id(env) || internal_request_id
+      status, headers, body = @app.call(env)
+
+      headers["X-Request-Id"] = env["action_dispatch.request_id"]
+      [ status, headers, body ]
+    end
+
+    private
+      def external_request_id(env)
+        if request_id = env["HTTP_X_REQUEST_ID"].presence
+          request_id.gsub(/[^\w\-]/, "").first(255)
+        end
+      end
+
+      def internal_request_id
+        SecureRandom.uuid
+      end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/rescue.rb b/actionpack/lib/action_dispatch/middleware/rescue.rb
deleted file mode 100644
index aee672112c..0000000000
--- a/actionpack/lib/action_dispatch/middleware/rescue.rb
+++ /dev/null
@@ -1,26 +0,0 @@
-module ActionDispatch
-  class Rescue
-    def initialize(app, rescuers = {}, &block)
-      @app, @rescuers = app, {}
-      rescuers.each { |exception, rescuer| rescue_from(exception, rescuer) }
-      instance_eval(&block) if block_given?
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => exception
-      if rescuer = @rescuers[exception.class.name]
-        env['action_dispatch.rescue.exception'] = exception
-        rescuer.call(env)
-      else
-        raise exception
-      end
-    end
-
-    protected
-      def rescue_from(exception, rescuer)
-        exception = exception.class.name if exception.is_a?(Exception)
-        @rescuers[exception.to_s] = rescuer
-      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 6bcf099d2c..6a8e690d18 100644
--- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -30,7 +30,7 @@ module ActionDispatch
 
       def generate_sid
         sid = SecureRandom.hex(16)
-        sid.encode!('UTF-8') if sid.respond_to?(:encode!)
+        sid.encode!('UTF-8')
         sid
       end
 
@@ -74,10 +74,6 @@ module ActionDispatch
     class AbstractStore < Rack::Session::Abstract::ID
       include Compatibility
       include StaleSessionCheck
-
-      def destroy_session(env, sid, options)
-        raise '#destroy_session needs to be implemented.'
-      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/session/cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb
new file mode 100644
index 0000000000..d3b6fd12fa
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/session/cache_store.rb
@@ -0,0 +1,50 @@
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/memcache'
+
+module ActionDispatch
+  module Session
+    # Session store that uses an ActiveSupport::Cache::Store to store the sessions. This store is most useful
+    # if you don't store critical data in your sessions and you don't need them to live for extended periods
+    # of time.
+    class CacheStore < AbstractStore
+      # Create a new store. The cache to use can be passed in the <tt>:cache</tt> option. If it is
+      # not specified, <tt>Rails.cache</tt> will be used.
+      def initialize(app, options = {})
+        @cache = options[:cache] || Rails.cache
+        options[:expire_after] ||= @cache.options[:expires_in]
+        super
+      end
+
+      # Get a session from the cache.
+      def get_session(env, sid)
+        sid ||= generate_sid
+        session = @cache.read(cache_key(sid))
+        session ||= {}
+        [sid, session]
+      end
+
+      # Set a session in the cache.
+      def set_session(env, sid, session, options)
+        key = cache_key(sid)
+        if session
+          @cache.write(key, session, :expires_in => options[:expire_after])
+        else
+          @cache.delete(key)
+        end
+        sid
+      end
+
+      # Remove a session from the cache.
+      def destroy_session(env, sid, options)
+        @cache.delete(cache_key(sid))
+        generate_sid
+      end
+
+      private
+        # Turn the session id into a cache key.
+        def cache_key(sid)
+          "_session_id:#{sid}"
+        end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
index 2fa68c64c5..3d06214bf1 100644
--- a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -1,172 +1,63 @@
-require 'active_support/core_ext/exception'
-require 'action_controller/metal/exceptions'
-require 'active_support/notifications'
 require 'action_dispatch/http/request'
+require 'action_dispatch/middleware/exception_wrapper'
+require 'active_support/deprecation'
 
 module ActionDispatch
-  # This middleware rescues any exception returned by the application and renders
-  # nice exception pages if it's being rescued locally.
+  # This middleware rescues any exception returned by the application
+  # and calls an exceptions app that will wrap it in a format for the end user.
+  #
+  # The exceptions app should be passed as parameter on initialization
+  # of ShowExceptions. Everytime there is an exception, ShowExceptions will
+  # store the exception in env["action_dispatch.exception"], rewrite the
+  # PATH_INFO to the exception status code and call the rack app.
+  # 
+  # If the application returns a "X-Cascade" pass response, this middleware
+  # will send an empty response as result with the correct status code.
+  # If any exception happens inside the exceptions app, this middleware
+  # catches the exceptions and returns a FAILSAFE_RESPONSE.
   class ShowExceptions
-    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,
-      'AbstractController::ActionNotFound'         => :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',
-      'AbstractController::ActionNotFound'  => 'unknown_action',
-      'ActionView::Template::Error'         => '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)
+    def initialize(app, exceptions_app)
       @app = app
-      @consider_all_requests_local = consider_all_requests_local
+      @exceptions_app = exceptions_app
     end
 
     def call(env)
       begin
-        status, headers, body = @app.call(env)
-        exception = nil
-
-        # Only this middleware cares about RoutingError. So, let's just raise
-        # it here.
-        if headers['X-Cascade'] == 'pass'
-           raise ActionController::RoutingError, "No route matches [#{env['REQUEST_METHOD']}] #{env['PATH_INFO'].inspect}"
-        end
+        response  = @app.call(env)
       rescue Exception => exception
         raise exception if env['action_dispatch.show_exceptions'] == false
       end
 
-      exception ? render_exception(env, exception) : [status, headers, body]
+      response || render_exception(env, exception)
     end
 
     private
-      def render_exception(env, exception)
-        log_error(exception)
-        exception = original_exception(exception)
-
-        request = Request.new(env)
-        if @consider_all_requests_local || request.local?
-          rescue_action_locally(request, exception)
-        else
-          rescue_action_in_public(exception)
-        end
-      rescue Exception => failsafe_error
-        $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
-        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,
-          :application_trace => application_trace(exception),
-          :framework_trace => framework_trace(exception),
-          :full_trace => full_trace(exception)
-        )
-        file = "rescues/#{@@rescue_templates[exception.class.name]}"
-        body = template.render(:template => file, :layout => 'rescues/layout')
-        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
-
-      def status_code(exception)
-        Rack::Utils.status_code(@@rescue_responses[exception.class.name])
-      end
-
-      def render(status, body)
-        [status, {'Content-Type' => "text/html; charset=#{Response.default_charset}", 'Content-Length' => body.bytesize.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
-          message = "\n#{exception.class} (#{exception.message}):\n"
-          message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code)
-          message << "  " << application_trace(exception).join("\n  ")
-          logger.fatal("#{message}\n\n")
-        end
-      end
-
-      def application_trace(exception)
-        clean_backtrace(exception, :silent)
-      end
-
-      def framework_trace(exception)
-        clean_backtrace(exception, :noise)
-      end
-
-      def full_trace(exception)
-        clean_backtrace(exception, :all)
-      end
-
-      def clean_backtrace(exception, *args)
-        defined?(Rails) && Rails.respond_to?(:backtrace_cleaner) ?
-          Rails.backtrace_cleaner.clean(exception.backtrace, *args) :
-          exception.backtrace
-      end
-
-      def logger
-        defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
-      end
+    # Define this method because some plugins were monkey patching it.
+    # Remove this after 3.2 is out with the other deprecations in this class.
+    def status_code(*)
+    end
 
-    def original_exception(exception)
-      if registered_original_exception?(exception)
-        exception.original_exception
-      else
-        exception
-      end
+    def render_exception(env, exception)
+      wrapper = ExceptionWrapper.new(env, exception)
+      status  = wrapper.status_code
+      env["action_dispatch.exception"] = wrapper.exception
+      env["PATH_INFO"] = "/#{status}"
+      response = @exceptions_app.call(env)
+      response[1]['X-Cascade'] == 'pass' ? pass_response(status) : response
+    rescue Exception => failsafe_error
+      $stderr.puts "Error during failsafe response: #{failsafe_error}\n  #{failsafe_error.backtrace * "\n  "}"
+      FAILSAFE_RESPONSE
     end
 
-    def registered_original_exception?(exception)
-      exception.respond_to?(:original_exception) && @@rescue_responses.has_key?(exception.original_exception.class.name)
+    def pass_response(status)
+      [status, {"Content-Type" => "text/html; charset=#{Response.default_charset}", "Content-Length" => "0"}, []]
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
index 6e71fd7ddc..1a308707d1 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/layout.erb
@@ -16,6 +16,7 @@
       background-color: #eee;
       padding: 10px;
       font-size: 11px;
+      white-space: pre-wrap;
     }
 
     a { color: #000; }
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
index ccfa858cce..f06c07daa5 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/routing_error.erb
@@ -1,10 +1,15 @@
 <h1>Routing Error</h1>
 <p><pre><%=h @exception.message %></pre></p>
-<% unless @exception.failures.empty? %><p>
-  <h2>Failure reasons:</h2>
-  <ol>
-  <% @exception.failures.each do |route, reason| %>
-    <li><code><%=h route.inspect.gsub('\\', '') %></code> failed because <%=h reason.downcase %></li>
-  <% end %>
-  </ol>
-</p><% end %>
+<% unless @exception.failures.empty? %>
+  <p>
+    <h2>Failure reasons:</h2>
+    <ol>
+    <% @exception.failures.each do |route, reason| %>
+      <li><code><%=h route.inspect.gsub('\\', '') %></code> failed because <%=h reason.downcase %></li>
+    <% end %>
+    </ol>
+  </p>
+<% end %>
+<p>
+  Try running <code>rake routes</code> for more information on available routes.
+</p>
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/railtie.rb b/actionpack/lib/action_dispatch/railtie.rb
index 1af89858d1..46c06386d8 100644
--- a/actionpack/lib/action_dispatch/railtie.rb
+++ b/actionpack/lib/action_dispatch/railtie.rb
@@ -9,11 +9,27 @@ module ActionDispatch
     config.action_dispatch.best_standards_support = true
     config.action_dispatch.tld_length = 1
     config.action_dispatch.ignore_accept_header = false
-    config.action_dispatch.rack_cache = {:metastore => "rails:/", :entitystore => "rails:/", :verbose => true}
+    config.action_dispatch.rescue_templates = { }
+    config.action_dispatch.rescue_responses = { }
+
+    config.action_dispatch.rack_cache = {
+      :metastore => "rails:/",
+      :entitystore => "rails:/",
+      :verbose => true
+    }
 
     initializer "action_dispatch.configure" do |app|
       ActionDispatch::Http::URL.tld_length = app.config.action_dispatch.tld_length
       ActionDispatch::Request.ignore_accept_header = app.config.action_dispatch.ignore_accept_header
+      ActionDispatch::Response.default_charset = app.config.encoding
+
+      ActionDispatch::ExceptionWrapper.rescue_responses.merge!(config.action_dispatch.rescue_responses)
+      ActionDispatch::ExceptionWrapper.rescue_templates.merge!(config.action_dispatch.rescue_templates)
+
+      config.action_dispatch.always_write_cookie = Rails.env.development? if config.action_dispatch.always_write_cookie.nil?
+      ActionDispatch::Cookies::CookieJar.always_write_cookie = config.action_dispatch.always_write_cookie
+
+      ActionDispatch.test_app = app
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing.rb b/actionpack/lib/action_dispatch/routing.rb
index 1dcd83ceb5..fa300b4a16 100644
--- a/actionpack/lib/action_dispatch/routing.rb
+++ b/actionpack/lib/action_dispatch/routing.rb
@@ -277,7 +277,6 @@ module ActionDispatch
   #
   module Routing
     autoload :Mapper, 'action_dispatch/routing/mapper'
-    autoload :Route, 'action_dispatch/routing/route'
     autoload :RouteSet, 'action_dispatch/routing/route_set'
     autoload :RoutesProxy, 'action_dispatch/routing/routes_proxy'
     autoload :UrlFor, 'action_dispatch/routing/url_for'
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index cd59b13c42..db1e3198b3 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -16,7 +16,7 @@ module ActionDispatch
           end
         end
 
-        attr_reader :app
+        attr_reader :app, :constraints
 
         def initialize(app, constraints, request)
           @app, @constraints, @request = app, constraints, request
@@ -49,7 +49,7 @@ module ActionDispatch
       class Mapping #:nodoc:
         IGNORE_OPTIONS = [:to, :as, :via, :on, :constraints, :defaults, :only, :except, :anchor, :shallow, :shallow_path, :shallow_prefix]
         ANCHOR_CHARACTERS_REGEX = %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
-        SHORTHAND_REGEX = %r{^/[\w/]+$}
+        SHORTHAND_REGEX = %r{/[\w/]+$}
         WILDCARD_PATH = %r{\*([^/\)]+)\)?$}
 
         def initialize(set, scope, path, options)
@@ -70,7 +70,7 @@ module ActionDispatch
 
             if using_match_shorthand?(path_without_format, @options)
               to_shorthand    = @options[:to].blank?
-              @options[:to] ||= path_without_format[1..-1].sub(%r{/([^/]*)$}, '#\1')
+              @options[:to] ||= path_without_format.gsub(/\(.*\)/, "")[1..-1].sub(%r{/([^/]*)$}, '#\1')
             end
 
             @options.merge!(default_controller_and_action(to_shorthand))
@@ -90,7 +90,7 @@ module ActionDispatch
 
           # match "account/overview"
           def using_match_shorthand?(path, options)
-            path && options.except(:via, :anchor, :to, :as).empty? && path =~ SHORTHAND_REGEX
+            path && (options[:to] || options[:action]).nil? && path =~ SHORTHAND_REGEX
           end
 
           def normalize_path(path)
@@ -285,7 +285,7 @@ module ActionDispatch
         # A pattern can also point to a +Rack+ endpoint i.e. anything that
         # responds to +call+:
         #
-        #   match 'photos/:id' => lambda {|hash| [200, {}, "Coming soon" }
+        #   match 'photos/:id' => lambda {|hash| [200, {}, "Coming soon"] }
         #   match 'photos/:id' => PhotoRackApp
         #   # Yes, controller actions are just rack endpoints
         #   match 'photos/:id' => PhotosController.action(:show)
@@ -374,10 +374,6 @@ module ActionDispatch
         #     # Matches any request starting with 'path'
         #     match 'path' => 'c#a', :anchor => false
         def match(path, options=nil)
-          mapping = Mapping.new(@set, @scope, path, options || {})
-          app, conditions, requirements, defaults, as, anchor = mapping.to_route
-          @set.add_route(app, conditions, requirements, defaults, as, anchor)
-          self
         end
 
         # Mount a Rack-based application to be used within the application.
@@ -696,7 +692,7 @@ module ActionDispatch
         # Allows you to constrain the nested routes based on a set of rules.
         # For instance, in order to change the routes to allow for a dot character in the +id+ parameter:
         #
-        #   constraints(:id => /\d+\.\d+) do
+        #   constraints(:id => /\d+\.\d+/) do
         #     resources :posts
         #   end
         #
@@ -706,7 +702,7 @@ module ActionDispatch
         # You may use this to also restrict other parameters:
         #
         #   resources :posts do
-        #     constraints(:post_id => /\d+\.\d+) do
+        #     constraints(:post_id => /\d+\.\d+/) do
         #       resources :comments
         #     end
         #   end
@@ -735,7 +731,7 @@ module ActionDispatch
         # if the user should be given access to that route, or +false+ if the user should not.
         #
         #    class Iphone
-        #      def self.matches(request)
+        #      def self.matches?(request)
         #        request.env["HTTP_USER_AGENT"] =~ /iPhone/
         #      end
         #    end
@@ -867,8 +863,6 @@ module ActionDispatch
         CANONICAL_ACTIONS = %w(index create new show update destroy)
 
         class Resource #:nodoc:
-          DEFAULT_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit]
-
           attr_reader :controller, :path, :options
 
           def initialize(entities, options = {})
@@ -880,7 +874,7 @@ module ActionDispatch
           end
 
           def default_actions
-            self.class::DEFAULT_ACTIONS
+            [:index, :create, :new, :show, :update, :destroy, :edit]
           end
 
           def actions
@@ -934,16 +928,17 @@ module ActionDispatch
         end
 
         class SingletonResource < Resource #:nodoc:
-          DEFAULT_ACTIONS = [:show, :create, :update, :destroy, :new, :edit]
-
           def initialize(entities, options)
             super
-
             @as         = nil
             @controller = (options[:controller] || plural).to_s
             @as         = options[:as]
           end
 
+          def default_actions
+            [:show, :create, :update, :destroy, :new, :edit]
+          end
+
           def plural
             @plural ||= name.to_s.pluralize
           end
@@ -991,7 +986,7 @@ module ActionDispatch
             return self
           end
 
-          resource_scope(SingletonResource.new(resources.pop, options)) do
+          resource_scope(:resource, SingletonResource.new(resources.pop, options)) do
             yield if block_given?
 
             collection do
@@ -1023,6 +1018,7 @@ module ActionDispatch
         # creates seven different routes in your application, all mapping to
         # the +Photos+ controller:
         #
+        #   GET     /photos
         #   GET     /photos/new
         #   POST    /photos
         #   GET     /photos/:id
@@ -1038,6 +1034,7 @@ module ActionDispatch
         #
         # This generates the following comments routes:
         #
+        #   GET     /photos/:photo_id/comments
         #   GET     /photos/:photo_id/comments/new
         #   POST    /photos/:photo_id/comments
         #   GET     /photos/:photo_id/comments/:id
@@ -1049,13 +1046,20 @@ module ActionDispatch
         # Takes same options as <tt>Base#match</tt> as well as:
         #
         # [:path_names]
-        #   Allows you to change the paths of the seven default actions.
-        #   Paths not specified are not changed.
+        #   Allows you to change the segment component of the +edit+ and +new+ actions.
+        #   Actions not specified are not changed.
         #
         #     resources :posts, :path_names => { :new => "brand_new" }
         #
         #   The above example will now change /posts/new to /posts/brand_new
         #
+        # [:path]
+        #   Allows you to change the path prefix for the resource.
+        #
+        #     resources :posts, :path => 'postings'
+        #
+        #   The resource and all segments will now route to /postings instead of /posts
+        #
         # [:only]
         #   Only generate routes for the given actions.
         #
@@ -1120,7 +1124,7 @@ module ActionDispatch
             return self
           end
 
-          resource_scope(Resource.new(resources.pop, options)) do
+          resource_scope(:resources, Resource.new(resources.pop, options)) do
             yield if block_given?
 
             collection do
@@ -1243,32 +1247,44 @@ module ActionDispatch
           parent_resource.instance_of?(Resource) && @scope[:shallow]
         end
 
-        def match(*args)
-          options = args.extract_options!.dup
-          options[:anchor] = true unless options.key?(:anchor)
-
-          if args.length > 1
-            args.each { |path| match(path, options.dup) }
-            return self
+        def match(path, *rest)
+          if rest.empty? && Hash === path
+            options  = path
+            path, to = options.find { |name, value| name.is_a?(String) }
+            options[:to] = to
+            options.delete(path)
+            paths = [path]
+          else
+            options = rest.pop || {}
+            paths = [path] + rest
           end
 
-          on = options.delete(:on)
-          if VALID_ON_OPTIONS.include?(on)
-            args.push(options)
-            return send(on){ match(*args) }
-          elsif on
+          options[:anchor] = true unless options.key?(:anchor)
+
+          if options[:on] && !VALID_ON_OPTIONS.include?(options[:on])
             raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
           end
 
-          if @scope[:scope_level] == :resources
-            args.push(options)
-            return nested { match(*args) }
-          elsif @scope[:scope_level] == :resource
-            args.push(options)
-            return member { match(*args) }
+          paths.each { |_path| decomposed_match(_path, options.dup) }
+          self
+        end
+
+        def decomposed_match(path, options) # :nodoc:
+          if on = options.delete(:on)
+            send(on) { decomposed_match(path, options) }
+          else
+            case @scope[:scope_level]
+            when :resources
+              nested { decomposed_match(path, options) }
+            when :resource
+              member { decomposed_match(path, options) }
+            else
+              add_route(path, options)
+            end
           end
+        end
 
-          action = args.first
+        def add_route(action, options) # :nodoc:
           path = path_for_action(action, options.delete(:path))
 
           if action.to_s =~ /^[\w\/]+$/
@@ -1277,13 +1293,15 @@ module ActionDispatch
             action = nil
           end
 
-          if options.key?(:as) && !options[:as]
+          if !options.fetch(:as, true)
             options.delete(:as)
           else
             options[:as] = name_for_action(options[:as], action)
           end
 
-          super(path, options)
+          mapping = Mapping.new(@set, @scope, path, options)
+          app, conditions, requirements, defaults, as, anchor = mapping.to_route
+          @set.add_route(app, conditions, requirements, defaults, as, anchor)
         end
 
         def root(options={})
@@ -1339,7 +1357,7 @@ module ActionDispatch
           end
 
           def scope_action_options? #:nodoc:
-            @scope[:options].is_a?(Hash) && (@scope[:options][:only] || @scope[:options][:except])
+            @scope[:options] && (@scope[:options][:only] || @scope[:options][:except])
           end
 
           def scope_action_options #:nodoc:
@@ -1347,11 +1365,11 @@ module ActionDispatch
           end
 
           def resource_scope? #:nodoc:
-            @scope[:scope_level].in?([:resource, :resources])
+            [:resource, :resources].include? @scope[:scope_level]
           end
 
           def resource_method_scope? #:nodoc:
-            @scope[:scope_level].in?([:collection, :member, :new])
+            [:collection, :member, :new].include? @scope[:scope_level]
           end
 
           def with_exclusive_scope
@@ -1376,8 +1394,8 @@ module ActionDispatch
             @scope[:scope_level_resource] = old_resource
           end
 
-          def resource_scope(resource) #:nodoc:
-            with_scope_level(resource.is_a?(SingletonResource) ? :resource : :resources, resource) do
+          def resource_scope(kind, resource) #:nodoc:
+            with_scope_level(kind, resource) do
               scope(parent_resource.resource_scope) do
                 yield
               end
@@ -1385,10 +1403,12 @@ module ActionDispatch
           end
 
           def nested_options #:nodoc:
-            {}.tap do |options|
-              options[:as] = parent_resource.member_name
-              options[:constraints] = { "#{parent_resource.singular}_id".to_sym => id_constraint } if id_constraint?
-            end
+            options = { :as => parent_resource.member_name }
+            options[:constraints] = {
+              :"#{parent_resource.singular}_id" => id_constraint
+            } if id_constraint?
+
+            options
           end
 
           def id_constraint? #:nodoc:
@@ -1419,8 +1439,7 @@ module ActionDispatch
           end
 
           def action_path(name, path = nil) #:nodoc:
-            # Ruby 1.8 can't transform empty strings to symbols
-            name = name.to_sym if name.is_a?(String) && !name.empty?
+            name = name.to_sym if name.is_a?(String)
             path || @scope[:path_names][name] || name.to_s
           end
 
@@ -1459,22 +1478,17 @@ module ActionDispatch
               [name_prefix, member_name, prefix]
             end
 
-            candidate = name.select(&:present?).join("_").presence
-            candidate unless as.nil? && @set.routes.find { |r| r.name == candidate }
-          end
-      end
-
-      module Shorthand #:nodoc:
-        def match(path, *rest)
-          if rest.empty? && Hash === path
-            options  = path
-            path, to = options.find { |name, value| name.is_a?(String) }
-            options.merge!(:to => to).delete(path)
-            super(path, options)
-          else
-            super
+            if candidate = name.select(&:present?).join("_").presence
+              # If a name was not explicitly given, we check if it is valid
+              # and return nil in case it isn't. Otherwise, we pass the invalid name
+              # forward so the underlying router engine treats it and raises an exception.
+              if as.nil?
+                candidate unless @set.routes.find { |r| r.name == candidate } || candidate !~ /\A[_a-z]/i
+              else
+                candidate
+              end
+            end
           end
-        end
       end
 
       def initialize(set) #:nodoc:
@@ -1487,7 +1501,6 @@ module ActionDispatch
       include Redirection
       include Scoping
       include Resources
-      include Shorthand
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
index e989a38d8b..013cf93dbc 100644
--- a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
+++ b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
@@ -165,7 +165,7 @@ module ActionDispatch
               if parent.is_a?(Symbol) || parent.is_a?(String)
                 parent
               else
-                ActiveModel::Naming.route_key(parent).singularize
+                ActiveModel::Naming.singular_route_key(parent)
               end
             end
           else
@@ -176,9 +176,11 @@ module ActionDispatch
           if record.is_a?(Symbol) || record.is_a?(String)
             route << record
           elsif record
-            route << ActiveModel::Naming.route_key(record)
-            route = [route.join("_").singularize] if inflection == :singular
-            route << "index" if ActiveModel::Naming.uncountable?(record) && inflection == :plural
+            if inflection == :singular
+              route << ActiveModel::Naming.singular_route_key(record)
+            else
+              route << ActiveModel::Naming.route_key(record)
+            end
           else
             raise ArgumentError, "Nil location provided. Can't build URI."
           end
diff --git a/actionpack/lib/action_dispatch/routing/redirection.rb b/actionpack/lib/action_dispatch/routing/redirection.rb
index 804991ad5f..617b24b46a 100644
--- a/actionpack/lib/action_dispatch/routing/redirection.rb
+++ b/actionpack/lib/action_dispatch/routing/redirection.rb
@@ -2,6 +2,54 @@ require 'action_dispatch/http/request'
 
 module ActionDispatch
   module Routing
+    class Redirect # :nodoc:
+      attr_reader :status, :block
+
+      def initialize(status, block)
+        @status = status
+        @block  = block
+      end
+
+      def call(env)
+        req = Request.new(env)
+
+        uri = URI.parse(path(req.symbolized_path_parameters, req))
+        uri.scheme ||= req.scheme
+        uri.host   ||= req.host
+        uri.port   ||= req.port unless req.standard_port?
+
+        body = %(<html><body>You are being <a href="#{ERB::Util.h(uri.to_s)}">redirected</a>.</body></html>)
+
+        headers = {
+          'Location' => uri.to_s,
+          'Content-Type' => 'text/html',
+          'Content-Length' => body.length.to_s
+        }
+
+        [ status, headers, [body] ]
+      end
+
+      def path(params, request)
+        block.call params, request
+      end
+    end
+
+    class OptionRedirect < Redirect # :nodoc:
+      alias :options :block
+
+      def path(params, request)
+        url_options = {
+          :protocol => request.protocol,
+          :host     => request.host,
+          :port     => request.optional_port,
+          :path     => request.path,
+          :params   => request.query_parameters
+        }.merge options
+
+        ActionDispatch::Http::URL.url_for url_options
+      end
+    end
+
     module Redirection
 
       # Redirect any path to another path:
@@ -40,71 +88,18 @@ module ActionDispatch
         options = args.last.is_a?(Hash) ? args.pop : {}
         status  = options.delete(:status) || 301
 
-        path = args.shift
+        return OptionRedirect.new(status, options) if options.any?
 
-        path_proc = if path.is_a?(String)
-          proc { |params| (params.empty? || !path.match(/%\{\w*\}/)) ? path : (path % params) }
-        elsif options.any?
-          options_proc(options)
-        elsif path.respond_to?(:call)
-          proc { |params, request| path.call(params, request) }
-        elsif block
-          block
-        else
-          raise ArgumentError, "redirection argument not supported"
-        end
-
-        redirection_proc(status, path_proc)
-      end
+        path = args.shift
 
-      private
-
-        def options_proc(options)
-          proc do |params, request|
-            path = if options[:path].nil?
-              request.path
-            elsif params.empty? || !options[:path].match(/%\{\w*\}/)
-              options.delete(:path)
-            else
-              (options.delete(:path) % params)
-            end
-
-            default_options = {
-              :protocol => request.protocol,
-              :host => request.host,
-              :port => request.optional_port,
-              :path => path,
-              :params => request.query_parameters
-            }
-
-            ActionDispatch::Http::URL.url_for(options.reverse_merge(default_options))
-          end
-        end
-
-        def redirection_proc(status, path_proc)
-          lambda do |env|
-            req = Request.new(env)
-
-            params = [req.symbolized_path_parameters]
-            params << req if path_proc.arity > 1
-
-            uri = URI.parse(path_proc.call(*params))
-            uri.scheme ||= req.scheme
-            uri.host   ||= req.host
-            uri.port   ||= req.port unless req.standard_port?
-
-            body = %(<html><body>You are being <a href="#{ERB::Util.h(uri.to_s)}">redirected</a>.</body></html>)
-
-            headers = {
-              'Location' => uri.to_s,
-              'Content-Type' => 'text/html',
-              'Content-Length' => body.length.to_s
-            }
-
-            [ status, headers, [body] ]
-          end
-        end
+        block = lambda { |params, request|
+          (params.empty? || !path.match(/%\{\w*\}/)) ? path : (path % params)
+        } if String === path
 
+        block = path if path.respond_to? :call
+        raise ArgumentError, "redirection argument not supported" unless block
+        Redirect.new status, block
+      end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index e921269331..10b3e212e6 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -1,4 +1,4 @@
-require 'journey/router'
+require 'journey'
 require 'forwardable'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/to_query'
@@ -37,7 +37,7 @@ module ActionDispatch
 
         # If this is a default_controller (i.e. a controller specified by the user)
         # we should raise an error in case it's not found, because it usually means
-        # an user error. However, if the controller was retrieved through a dynamic
+        # a user error. However, if the controller was retrieved through a dynamic
         # segment, as in :controller(/:action), we should simply return nil and
         # delegate the control back to Rack cascade. Besides, if this is not a default
         # controller, it means we should respect the @scope[:module] parameter.
@@ -83,7 +83,9 @@ module ActionDispatch
         attr_reader :routes, :helpers, :module
 
         def initialize
-          clear!
+          @routes  = {}
+          @helpers = []
+          @module  = Module.new
         end
 
         def helper_names
@@ -91,12 +93,8 @@ module ActionDispatch
         end
 
         def clear!
-          @routes = {}
-          @helpers = []
-
-          @module ||= Module.new do
-            instance_methods.each { |selector| remove_method(selector) }
-          end
+          @routes.clear
+          @helpers.clear
         end
 
         def add(name, route)
@@ -125,19 +123,9 @@ module ActionDispatch
           routes.length
         end
 
-        def reset!
-          old_routes = routes.dup
-          clear!
-          old_routes.each do |name, route|
-            add(name, route)
-          end
-        end
-
-        def install(destinations = [ActionController::Base, ActionView::Base], regenerate = false)
-          reset! if regenerate
-          Array(destinations).each do |dest|
-            dest.__send__(:include, @module)
-          end
+        def install(destinations = [ActionController::Base, ActionView::Base])
+          helper = @module
+          destinations.each { |d| d.module_eval { include helper } }
         end
 
         private
@@ -160,22 +148,23 @@ module ActionDispatch
           def define_hash_access(route, name, kind, options)
             selector = hash_access_name(name, kind)
 
-            # We use module_eval to avoid leaks
-            @module.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-              remove_possible_method :#{selector}
-              def #{selector}(*args)
-                options = args.extract_options!
-                result = #{options.inspect}
+            @module.module_eval do
+              remove_possible_method selector
+
+              define_method(selector) do |*args|
+                inner_options = args.extract_options!
+                result = options.dup
 
                 if args.any?
                   result[:_positional_args] = args
-                  result[:_positional_keys] = #{route.segment_keys.inspect}
+                  result[:_positional_keys] = route.segment_keys
                 end
 
-                result.merge(options)
+                result.merge(inner_options)
               end
-              protected :#{selector}
-            END_EVAL
+
+              protected selector
+            end
             helpers << selector
           end
 
@@ -287,9 +276,9 @@ module ActionDispatch
         @prepend.each { |blk| eval_block(blk) }
       end
 
-      def install_helpers(destinations = [ActionController::Base, ActionView::Base], regenerate_code = false)
-        Array(destinations).each { |d| d.module_eval { include Helpers } }
-        named_routes.install(destinations, regenerate_code)
+      def install_helpers(destinations)
+        destinations.each { |d| d.module_eval { include Helpers } }
+        named_routes.install(destinations)
       end
 
       module MountedHelpers
@@ -317,32 +306,29 @@ module ActionDispatch
       end
 
       def url_helpers
-        @url_helpers ||= begin
-          routes = self
+        routes = self
 
-          helpers = Module.new do
-            extend ActiveSupport::Concern
-            include UrlFor
+        @url_helpers ||= Module.new {
+          extend ActiveSupport::Concern
+          include UrlFor
 
-            @_routes = routes
-            class << self
-              delegate :url_for, :to => '@_routes'
-            end
-            extend routes.named_routes.module
-
-            # ROUTES TODO: install_helpers isn't great... can we make a module with the stuff that
-            # we can include?
-            # Yes plz - JP
-            included do
-              routes.install_helpers(self)
-              singleton_class.send(:redefine_method, :_routes) { routes }
-            end
+          @_routes = routes
+          def self.url_for(options)
+            @_routes.url_for options
+          end
+
+          extend routes.named_routes.module
 
-            define_method(:_routes) { @_routes || routes }
+          # ROUTES TODO: install_helpers isn't great... can we make a module with the stuff that
+          # we can include?
+          # Yes plz - JP
+          included do
+            routes.install_helpers([self])
+            singleton_class.send(:redefine_method, :_routes) { routes }
           end
 
-          helpers
-        end
+          define_method(:_routes) { @_routes || routes }
+        }
       end
 
       def empty?
@@ -356,7 +342,7 @@ module ActionDispatch
         conditions = build_conditions(conditions, valid_conditions, path.names.map { |x| x.to_sym })
 
         route = @set.add_route(app, path, conditions, defaults, name)
-        named_routes[name] = route if name
+        named_routes[name] = route if name && !named_routes[name]
         route
       end
 
@@ -394,10 +380,9 @@ module ActionDispatch
           if name == :controller
             value
           elsif value.is_a?(Array)
-            value.map { |v| Journey::Router::Utils.escape_uri(v.to_param) }.join('/')
-          else
-            return nil unless param = value.to_param
-            param.split('/').map { |v| Journey::Router::Utils.escape_uri(v) }.join("/")
+            value.map { |v| v.to_param }.join('/')
+          elsif param = value.to_param
+            param
           end
         end
 
@@ -558,7 +543,7 @@ module ActionDispatch
         path_addition, params = generate(path_options, path_segments || {})
         path << path_addition
 
-        ActionDispatch::Http::URL.url_for(options.merge({
+        ActionDispatch::Http::URL.url_for(options.merge!({
           :path => path,
           :params => params,
           :user => user,
@@ -585,7 +570,7 @@ module ActionDispatch
         @router.recognize(req) do |route, matches, params|
           params.each do |key, value|
             if value.is_a?(String)
-              value = value.dup.force_encoding(Encoding::BINARY) if value.encoding_aware?
+              value = value.dup.force_encoding(Encoding::BINARY)
               params[key] = URI.parser.unescape(value)
             end
           end
diff --git a/actionpack/lib/action_dispatch/routing/url_for.rb b/actionpack/lib/action_dispatch/routing/url_for.rb
index 8fc8dc191b..6c2a98ab15 100644
--- a/actionpack/lib/action_dispatch/routing/url_for.rb
+++ b/actionpack/lib/action_dispatch/routing/url_for.rb
@@ -42,7 +42,7 @@ module ActionDispatch
     #   url_for(:controller => 'users',
     #           :action => 'new',
     #           :message => 'Welcome!',
-    #           :host => 'www.example.com')        # Changed this.
+    #           :host => 'www.example.com')
     #   # => "http://www.example.com/users/new?message=Welcome%21"
     #
     # By default, all controllers and views have access to a special version of url_for,
@@ -52,7 +52,7 @@ module ActionDispatch
     #
     # For convenience reasons, mailers provide a shortcut for ActionController::UrlFor#url_for.
     # So within mailers, you only have to type 'url_for' instead of 'ActionController::UrlFor#url_for'
-    # in full. However, mailers don't have hostname information, and what's why you'll still
+    # in full. However, mailers don't have hostname information, and that's why you'll still
     # have to specify the <tt>:host</tt> argument when generating URLs in mailers.
     #
     #
@@ -90,8 +90,7 @@ module ActionDispatch
           if respond_to?(:class_attribute)
             class_attribute :default_url_options
           else
-            mattr_accessor :default_url_options
-            remove_method :default_url_options
+            mattr_writer :default_url_options
           end
 
           self.default_url_options = {}
@@ -145,7 +144,7 @@ module ActionDispatch
         when String
           options
         when nil, Hash
-          _routes.url_for((options || {}).reverse_merge(url_options).symbolize_keys)
+          _routes.url_for((options || {}).symbolize_keys.reverse_merge!(url_options))
         else
           polymorphic_url(options)
         end
diff --git a/actionpack/lib/action_dispatch/testing/integration.rb b/actionpack/lib/action_dispatch/testing/integration.rb
index 0f1bb9f260..26db8662a8 100644
--- a/actionpack/lib/action_dispatch/testing/integration.rb
+++ b/actionpack/lib/action_dispatch/testing/integration.rb
@@ -463,9 +463,12 @@ module ActionDispatch
     @@app = nil
 
     def self.app
-      # DEPRECATE Rails application fallback
-      # This should be set by the initializer
-      @@app || (defined?(Rails.application) && Rails.application) || nil
+      if !@@app && !ActionDispatch.test_app
+        ActiveSupport::Deprecation.warn "Rails application fallback is deprecated " \
+          "and no longer works, please set ActionDispatch.test_app", caller
+      end
+
+      @@app || ActionDispatch.test_app
     end
 
     def self.app=(app)