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

43 files changed, 2066 insertions, 1752 deletions

diff --git a/actionpack/lib/action_dispatch/http/cache.rb b/actionpack/lib/action_dispatch/http/cache.rb
index e9fdf75cc8..4f4cb96a74 100644
--- a/actionpack/lib/action_dispatch/http/cache.rb
+++ b/actionpack/lib/action_dispatch/http/cache.rb
@@ -39,10 +39,11 @@ module ActionDispatch
       end
 
       module Response
-        attr_reader :cache_control
+        attr_reader :cache_control, :etag
+        alias :etag? :etag
 
         def initialize(*)
-          status, header, body = super
+          super
 
           @cache_control = {}
           @etag = self["ETag"]
@@ -50,8 +51,7 @@ module ActionDispatch
           if cache_control = self["Cache-Control"]
             cache_control.split(/,\s*/).each do |segment|
               first, last = segment.split("=")
-              last ||= true
-              @cache_control[first.to_sym] = last
+              @cache_control[first.to_sym] = last || true
             end
           end
         end
@@ -70,14 +70,6 @@ module ActionDispatch
           headers['Last-Modified'] = utc_time.httpdate
         end
 
-        def etag
-          @etag
-        end
-
-        def etag?
-          @etag
-        end
-
         def etag=(etag)
           key = ActiveSupport::Cache.expand_cache_key(etag)
           @etag = self["ETag"] = %("#{Digest::MD5.hexdigest(key)}")
@@ -88,38 +80,19 @@ module ActionDispatch
         def handle_conditional_get!
           if etag? || last_modified? || !@cache_control.empty?
             set_conditional_cache_control!
-          elsif nonempty_ok_response?
-            self.etag = body
-
-            if request && request.etag_matches?(etag)
-              self.status = 304
-              self.body = []
-            end
-
-            set_conditional_cache_control!
-          else
-            headers["Cache-Control"] = "no-cache"
           end
         end
 
-        def nonempty_ok_response?
-          @status == 200 && string_body?
-        end
-
-        def string_body?
-          !@blank && @body.respond_to?(:all?) && @body.all? { |part| part.is_a?(String) }
-        end
-
         DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate"
 
         def set_conditional_cache_control!
-          control = @cache_control
-
           return if self["Cache-Control"].present?
 
+          control = @cache_control
+
           if control.empty?
             headers["Cache-Control"] = DEFAULT_CACHE_CONTROL
-          elsif @cache_control[:no_cache]
+          elsif control[:no_cache]
             headers["Cache-Control"] = "no-cache"
           else
             extras  = control[:extras]
diff --git a/actionpack/lib/action_dispatch/http/filter_parameters.rb b/actionpack/lib/action_dispatch/http/filter_parameters.rb
index 1ab48ae04d..8dd1af7f3d 100644
--- a/actionpack/lib/action_dispatch/http/filter_parameters.rb
+++ b/actionpack/lib/action_dispatch/http/filter_parameters.rb
@@ -5,10 +5,10 @@ require 'active_support/core_ext/object/duplicable'
 module ActionDispatch
   module Http
     # Allows you to specify sensitive parameters which will be replaced from
-    # the request log by looking 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.
+    # the request log by looking in the query string of the request and all
+    # subhashes of the params hash to filter. If a block is given, each key and
+    # value of the params hash and all subhashes is passed to it, the value
+    # or key can be replaced using String#replace or similar method.
     #
     # Examples:
     #
@@ -38,6 +38,11 @@ module ActionDispatch
         @filtered_env ||= env_filter.filter(@env)
       end
 
+      # Reconstructed a path with all sensitive GET parameters replaced.
+      def filtered_path
+        @filtered_path ||= query_string.empty? ? path : "#{path}?#{filtered_query_string}"
+      end
+
     protected
 
       def parameter_filter
@@ -52,6 +57,14 @@ module ActionDispatch
         @@parameter_filter_for[filters] ||= ParameterFilter.new(filters)
       end
 
+      KV_RE   = '[^&;=]+'
+      PAIR_RE = %r{(#{KV_RE})=(#{KV_RE})}
+      def filtered_query_string
+        query_string.gsub(PAIR_RE) do |_|
+          parameter_filter.filter([[$1, $2]]).first.join("=")
+        end
+      end
+
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/http/mime_negotiation.rb b/actionpack/lib/action_dispatch/http/mime_negotiation.rb
index 4082770b85..68ba1a81b5 100644
--- a/actionpack/lib/action_dispatch/http/mime_negotiation.rb
+++ b/actionpack/lib/action_dispatch/http/mime_negotiation.rb
@@ -32,23 +32,25 @@ module ActionDispatch
         end
       end
 
-      # Returns the Mime type for the \format used in the request.
+      # Returns the MIME type for the \format used in the request.
       #
       #   GET /posts/5.xml   | request.format => Mime::XML
       #   GET /posts/5.xhtml | request.format => Mime::HTML
-      #   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>
+      #   GET /posts/5       | request.format => Mime::HTML or MIME::JS, or request.accepts.first
       #
       def format(view_path = [])
         formats.first
       end
 
+      BROWSER_LIKE_ACCEPTS = /,\s*\*\/\*|\*\/\*\s*,/
+
       def formats
         accept = @env['HTTP_ACCEPT']
 
         @env["action_dispatch.request.formats"] ||=
           if parameters[:format]
             Array(Mime[parameters[:format]])
-          elsif xhr? || (accept && accept !~ /,\s*\*\/\*/)
+          elsif xhr? || (accept && accept !~ BROWSER_LIKE_ACCEPTS)
             accepts
           else
             [Mime::HTML]
diff --git a/actionpack/lib/action_dispatch/http/mime_type.rb b/actionpack/lib/action_dispatch/http/mime_type.rb
index c6fc582851..7c9ebe7c7b 100644
--- a/actionpack/lib/action_dispatch/http/mime_type.rb
+++ b/actionpack/lib/action_dispatch/http/mime_type.rb
@@ -80,6 +80,9 @@ module Mime
     end
 
     class << self
+
+      TRAILING_STAR_REGEXP = /(text|application)\/\*/
+
       def lookup(string)
         LOOKUP[string]
       end
@@ -105,15 +108,28 @@ module Mime
 
       def parse(accept_header)
         if accept_header !~ /,/
-          [Mime::Type.lookup(accept_header)]
+          if accept_header =~ TRAILING_STAR_REGEXP
+            parse_data_with_trailing_star($1)
+          else
+            [Mime::Type.lookup(accept_header)]
+          end
         else
           # keep track of creation order to keep the subsequent sort stable
-          list = []
-          accept_header.split(/,/).each_with_index do |header, index| 
-            params, q = header.split(/;\s*q=/)       
-            if params
-              params.strip!          
-              list << AcceptItem.new(index, params, q) unless params.empty?
+          list, index = [], 0
+          accept_header.split(/,/).each do |header|
+            params, q = header.split(/;\s*q=/)
+            if params.present?
+              params.strip!
+
+              if params =~ TRAILING_STAR_REGEXP
+                parse_data_with_trailing_star($1).each do |m|
+                  list << AcceptItem.new(index, m.to_s, q)
+                  index += 1
+                end
+              else
+                list << AcceptItem.new(index, params, q)
+                index += 1
+              end
             end
           end
           list.sort!
@@ -160,23 +176,51 @@ module Mime
           list
         end
       end
+
+      # input: 'text'
+      # returned value:  [Mime::JSON, Mime::XML, Mime::ICS, Mime::HTML, Mime::CSS, Mime::CSV, Mime::JS, Mime::YAML, Mime::TEXT]
+      #
+      # input: 'application'
+      # returned value: [Mime::HTML, Mime::JS, Mime::XML, Mime::YAML, Mime::ATOM, Mime::JSON, Mime::RSS, Mime::URL_ENCODED_FORM]
+      def parse_data_with_trailing_star(input)
+        Mime::SET.select { |m| m =~ input }
+      end
+
+      # This method is opposite of register method.
+      #
+      # Usage:
+      #
+      # Mime::Type.unregister(:mobile)
+      def unregister(symbol)
+        symbol = symbol.to_s.upcase
+        mime = Mime.const_get(symbol)
+        Mime.instance_eval { remove_const(symbol) }
+
+        SET.delete_if { |v| v.eql?(mime) }
+        LOOKUP.delete_if { |k,v| v.eql?(mime) }
+        EXTENSION_LOOKUP.delete_if { |k,v| v.eql?(mime) }
+      end
     end
-    
+
     def initialize(string, symbol = nil, synonyms = [])
       @symbol, @synonyms = symbol, synonyms
       @string = string
     end
-    
+
     def to_s
       @string
     end
-    
+
     def to_str
       to_s
     end
-    
+
     def to_sym
-      @symbol || @string.to_sym
+      @symbol
+    end
+
+    def ref
+      to_sym || to_s
     end
 
     def ===(list)
@@ -186,11 +230,11 @@ module Mime
         super
       end
     end
-    
+
     def ==(mime_type)
       return false if mime_type.blank?
-      (@synonyms + [ self ]).any? do |synonym| 
-        synonym.to_s == mime_type.to_s || synonym.to_sym == mime_type.to_sym 
+      (@synonyms + [ self ]).any? do |synonym|
+        synonym.to_s == mime_type.to_s || synonym.to_sym == mime_type.to_sym
       end
     end
 
diff --git a/actionpack/lib/action_dispatch/http/parameters.rb b/actionpack/lib/action_dispatch/http/parameters.rb
index add8cab2ab..ef5d207b26 100644
--- a/actionpack/lib/action_dispatch/http/parameters.rb
+++ b/actionpack/lib/action_dispatch/http/parameters.rb
@@ -15,14 +15,14 @@ module ActionDispatch
       alias :params :parameters
 
       def path_parameters=(parameters) #:nodoc:
-        @env.delete("action_dispatch.request.symbolized_path_parameters")
+        @symbolized_path_params = nil
         @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
-        @env["action_dispatch.request.symbolized_path_parameters"] ||= path_parameters.symbolize_keys
+        @symbolized_path_params ||= path_parameters.symbolize_keys
       end
 
       # Returns a hash with the \parameters used to form the \path of the request.
diff --git a/actionpack/lib/action_dispatch/http/rack_cache.rb b/actionpack/lib/action_dispatch/http/rack_cache.rb
new file mode 100644
index 0000000000..b5c1435903
--- /dev/null
+++ b/actionpack/lib/action_dispatch/http/rack_cache.rb
@@ -0,0 +1,58 @@
+require "rack/cache"
+require "rack/cache/context"
+require "active_support/cache"
+
+module ActionDispatch
+  class RailsMetaStore < Rack::Cache::MetaStore
+    def self.resolve(uri)
+      new
+    end
+
+    # TODO: Finally deal with the RAILS_CACHE global
+    def initialize(store = RAILS_CACHE)
+      @store = store
+    end
+
+    def read(key)
+      @store.read(key) || []
+    end
+
+    def write(key, value)
+      @store.write(key, value)
+    end
+
+    ::Rack::Cache::MetaStore::RAILS = self
+  end
+
+  class RailsEntityStore < Rack::Cache::EntityStore
+    def self.resolve(uri)
+      new
+    end
+
+    def initialize(store = RAILS_CACHE)
+      @store = store
+    end
+
+    def exist?(key)
+      @store.exist?(key)
+    end
+
+    def open(key)
+      @store.read(key)
+    end
+
+    def read(key)
+      body = open(key)
+      body.join if body
+    end
+
+    def write(body)
+      buf = []
+      key, size = slurp(body) { |part| buf << part }
+      @store.write(key, buf)
+      [key, size]
+    end
+
+    ::Rack::Cache::EntityStore::RAILS = self
+  end
+end
diff --git a/actionpack/lib/action_dispatch/http/request.rb b/actionpack/lib/action_dispatch/http/request.rb
index fd23b1df79..f07ac44f7a 100644
--- a/actionpack/lib/action_dispatch/http/request.rb
+++ b/actionpack/lib/action_dispatch/http/request.rb
@@ -2,8 +2,10 @@ require 'tempfile'
 require 'stringio'
 require 'strscan'
 
+require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/hash/indifferent_access'
 require 'active_support/core_ext/string/access'
+require 'active_support/inflector'
 require 'action_dispatch/http/headers'
 
 module ActionDispatch
@@ -15,6 +17,8 @@ module ActionDispatch
     include ActionDispatch::Http::Upload
     include ActionDispatch::Http::URL
 
+    LOCALHOST = [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/].freeze
+
     %w[ AUTH_TYPE GATEWAY_INTERFACE
         PATH_TRANSLATED REMOTE_HOST
         REMOTE_IDENT REMOTE_USER REMOTE_ADDR
@@ -42,8 +46,24 @@ module ActionDispatch
       @env.key?(key)
     end
 
-    HTTP_METHODS = %w(get head put post delete options)
-    HTTP_METHOD_LOOKUP = HTTP_METHODS.inject({}) { |h, m| h[m] = h[m.upcase] = m.to_sym; h }
+    # List of HTTP request methods from the following RFCs:
+    # Hypertext Transfer Protocol -- HTTP/1.1 (http://www.ietf.org/rfc/rfc2616.txt)
+    # HTTP Extensions for Distributed Authoring -- WEBDAV (http://www.ietf.org/rfc/rfc2518.txt)
+    # Versioning Extensions to WebDAV (http://www.ietf.org/rfc/rfc3253.txt)
+    # Ordered Collections Protocol (WebDAV) (http://www.ietf.org/rfc/rfc3648.txt)
+    # Web Distributed Authoring and Versioning (WebDAV) Access Control Protocol (http://www.ietf.org/rfc/rfc3744.txt)
+    # Web Distributed Authoring and Versioning (WebDAV) SEARCH (http://www.ietf.org/rfc/rfc5323.txt)
+    # PATCH Method for HTTP (http://www.ietf.org/rfc/rfc5789.txt)
+    RFC2616 = %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT)
+    RFC2518 = %w(PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK)
+    RFC3253 = %w(VERSION-CONTROL REPORT CHECKOUT CHECKIN UNCHECKOUT MKWORKSPACE UPDATE LABEL MERGE BASELINE-CONTROL MKACTIVITY)
+    RFC3648 = %w(ORDERPATCH)
+    RFC3744 = %w(ACL)
+    RFC5323 = %w(SEARCH)
+    RFC5789 = %w(PATCH)
+
+    HTTP_METHODS = RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC5789
+    HTTP_METHOD_LOOKUP = Hash.new { |h, m| h[m] = m.underscore.to_sym if HTTP_METHODS.include?(m) }
 
     # Returns the HTTP \method that the application should see.
     # In the case where the \method was overridden by a middleware
@@ -52,11 +72,7 @@ module ActionDispatch
     # the application should use), this \method returns the overridden
     # value, not the original.
     def request_method
-      @request_method ||= begin
-        method = env["REQUEST_METHOD"]
-        HTTP_METHOD_LOOKUP[method] || raise(ActionController::UnknownHttpMethod, "#{method}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
-        method
-      end
+      @request_method ||= check_method(env["REQUEST_METHOD"])
     end
 
     # Returns a symbol form of the #request_method
@@ -68,11 +84,7 @@ module ActionDispatch
     # even if it was overridden by middleware. See #request_method for
     # more information.
     def method
-      @method ||= begin
-        method = env["rack.methodoverride.original_method"] || env['REQUEST_METHOD']
-        HTTP_METHOD_LOOKUP[method] || raise(ActionController::UnknownHttpMethod, "#{method}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
-        method
-      end
+      @method ||= check_method(env["rack.methodoverride.original_method"] || env['REQUEST_METHOD'])
     end
 
     # Returns a symbol form of the #method
@@ -122,8 +134,9 @@ module ActionDispatch
     end
 
     def forgery_whitelisted?
-      get? || xhr? || content_mime_type.nil? || !content_mime_type.verify_request?
+      get?
     end
+    deprecate :forgery_whitelisted? => "it is just an alias for 'get?' now, update your code"
 
     def media_type
       content_mime_type.to_s
@@ -134,11 +147,11 @@ module ActionDispatch
       super.to_i
     end
 
-    # Returns true if the request's "X-Requested-With" header contains
-    # "XMLHttpRequest". (The Prototype Javascript library sends this header with
-    # every Ajax request.)
+    # Returns true if the "X-Requested-With" header contains "XMLHttpRequest"
+    # (case-insensitive). All major JavaScript libraries send this header with
+    # every Ajax request.
     def xml_http_request?
-      !(@env['HTTP_X_REQUESTED_WITH'] !~ /XMLHttpRequest/i)
+      @env['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i
     end
     alias :xhr? :xml_http_request?
 
@@ -147,8 +160,16 @@ module ActionDispatch
     end
 
     # Which IP addresses are "trusted proxies" that can be stripped from
-    # the right-hand-side of X-Forwarded-For
-    TRUSTED_PROXIES = /^127\.0\.0\.1$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\./i
+    # 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
@@ -197,7 +218,7 @@ module ActionDispatch
     # TODO This should be broken apart into AD::Request::Session and probably
     # be included by the session middleware.
     def reset_session
-      session.destroy if session
+      session.destroy if session && session.respond_to?(:destroy)
       self.session = {}
       @env['action_dispatch.request.flash_hash'] = nil
     end
@@ -212,13 +233,13 @@ module ActionDispatch
 
     # Override Rack's GET method to support indifferent access
     def GET
-      @env["action_dispatch.request.query_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.query_parameters"] ||= (normalize_parameters(super) || {})
     end
     alias :query_parameters :GET
 
     # Override Rack's POST method to support indifferent access
     def POST
-      @env["action_dispatch.request.request_parameters"] ||= normalize_parameters(super)
+      @env["action_dispatch.request.request_parameters"] ||= (normalize_parameters(super) || {})
     end
     alias :request_parameters :POST
 
@@ -231,5 +252,17 @@ module ActionDispatch
       @env['X_HTTP_AUTHORIZATION'] ||
       @env['REDIRECT_X_HTTP_AUTHORIZATION']
     end
+
+    # True if the request came from localhost, 127.0.0.1.
+    def local?
+      LOCALHOST.any? { |local_ip| local_ip === remote_addr && local_ip === remote_ip }
+    end
+
+    private
+
+    def check_method(name)
+      HTTP_METHOD_LOOKUP[name] || raise(ActionController::UnknownHttpMethod, "#{name}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
+      name
+    end
   end
 end
diff --git a/actionpack/lib/action_dispatch/http/response.rb b/actionpack/lib/action_dispatch/http/response.rb
index 3b85a98576..8e03a7879f 100644
--- a/actionpack/lib/action_dispatch/http/response.rb
+++ b/actionpack/lib/action_dispatch/http/response.rb
@@ -4,27 +4,26 @@ require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/class/attribute_accessors'
 
 module ActionDispatch # :nodoc:
-  # Represents an HTTP response generated by a controller action. One can use
-  # an ActionDispatch::Response object to retrieve the current state
-  # of the response, or customize the response. An Response object can
-  # either represent a "real" HTTP response (i.e. one that is meant to be sent
-  # back to the web browser) or a test response (i.e. one that is generated
-  # from integration tests). See CgiResponse and TestResponse, respectively.
+  # Represents an HTTP response generated by a controller action. Use it to
+  # retrieve the current state of the response, or customize the response. It can
+  # either represent a real HTTP response (i.e. one that is meant to be sent
+  # back to the web browser) or a TestResponse (i.e. one that is generated
+  # from integration tests).
   #
-  # Response is mostly a Ruby on Rails framework implement detail, and
+  # \Response is mostly a Ruby on \Rails framework implementation detail, and
   # should never be used directly in controllers. Controllers should use the
   # methods defined in ActionController::Base instead. For example, if you want
   # to set the HTTP response's content MIME type, then use
   # ActionControllerBase#headers instead of Response#headers.
   #
   # Nevertheless, integration tests may want to inspect controller responses in
-  # more detail, and that's when Response can be useful for application
+  # more detail, and that's when \Response can be useful for application
   # developers. Integration test methods such as
   # ActionDispatch::Integration::Session#get and
   # ActionDispatch::Integration::Session#post return objects of type
-  # TestResponse (which are of course also of type Response).
+  # TestResponse (which are of course also of type \Response).
   #
-  # For example, the following demo integration "test" prints the body of the
+  # For example, the following demo integration test prints the body of the
   # controller response to the console:
   #
   #  class DemoControllerTest < ActionDispatch::IntegrationTest
@@ -45,8 +44,8 @@ module ActionDispatch # :nodoc:
         @block = nil
         @length = 0
 
-        @status, @header = status, header
-        self.body = body
+        @header = header
+        self.body, self.status = body, status
 
         @cookie = []
         @sending_file = false
@@ -133,7 +132,7 @@ module ActionDispatch # :nodoc:
     # information.
     attr_accessor :charset, :content_type
 
-    CONTENT_TYPE    = "Content-Type"
+    CONTENT_TYPE = "Content-Type"
 
     cattr_accessor(:default_charset) { "utf-8" }
 
@@ -141,7 +140,6 @@ module ActionDispatch # :nodoc:
       assign_default_content_type_and_charset!
       handle_conditional_get!
       self["Set-Cookie"] = self["Set-Cookie"].join("\n") if self["Set-Cookie"].respond_to?(:join)
-      self["ETag"]       = @_etag if @_etag
       super
     end
 
diff --git a/actionpack/lib/action_dispatch/http/upload.rb b/actionpack/lib/action_dispatch/http/upload.rb
index 8ee4b81cdd..37effade4f 100644
--- a/actionpack/lib/action_dispatch/http/upload.rb
+++ b/actionpack/lib/action_dispatch/http/upload.rb
@@ -1,32 +1,34 @@
-require 'active_support/core_ext/object/blank'
-
 module ActionDispatch
   module Http
-    module UploadedFile
-      def self.extended(object)
-        object.class_eval do
-          attr_accessor :original_path, :content_type
-          alias_method :local_path, :path if method_defined?(:path)
-        end
+    class UploadedFile
+      attr_accessor :original_filename, :content_type, :tempfile, :headers
+
+      def initialize(hash)
+        @original_filename = hash[:filename]
+        @content_type      = hash[:type]
+        @headers           = hash[:head]
+        @tempfile          = hash[:tempfile]
+        raise(ArgumentError, ':tempfile is required') unless @tempfile
       end
 
-      # Take the basename of the upload's original filename.
-      # This handles the full Windows paths given by Internet Explorer
-      # (and perhaps other broken user agents) without affecting
-      # those which give the lone filename.
-      # The Windows regexp is adapted from Perl's File::Basename.
-      def original_filename
-        unless defined? @original_filename
-          @original_filename =
-            unless original_path.blank?
-              if original_path =~ /^(?:.*[:\\\/])?(.*)/m
-                $1
-              else
-                File.basename original_path
-              end
-            end
-        end
-        @original_filename
+      def open
+        @tempfile.open
+      end
+
+      def path
+        @tempfile.path
+      end
+
+      def read(*args)
+        @tempfile.read(*args)
+      end
+
+      def rewind
+        @tempfile.rewind
+      end
+
+      def size
+        @tempfile.size
       end
     end
 
@@ -35,11 +37,7 @@ module ActionDispatch
       # file upload hash with UploadedFile objects
       def normalize_parameters(value)
         if Hash === value && value.has_key?(:tempfile)
-          upload = value[:tempfile]
-          upload.extend(UploadedFile)
-          upload.original_path = value[:filename]
-          upload.content_type = value[:type]
-          upload
+          UploadedFile.new(value)
         else
           super
         end
@@ -47,4 +45,4 @@ module ActionDispatch
       private :normalize_parameters
     end
   end
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/http/url.rb b/actionpack/lib/action_dispatch/http/url.rb
index b64a83c62e..ac0fd9607d 100644
--- a/actionpack/lib/action_dispatch/http/url.rb
+++ b/actionpack/lib/action_dispatch/http/url.rb
@@ -1,6 +1,81 @@
 module ActionDispatch
   module Http
     module URL
+      mattr_accessor :tld_length
+      self.tld_length = 1
+
+      class << self
+        def extract_domain(host, tld_length = @@tld_length)
+          return nil unless named_host?(host)
+          host.split('.').last(1 + tld_length).join('.')
+        end
+
+        def extract_subdomains(host, tld_length = @@tld_length)
+          return [] unless named_host?(host)
+          parts = host.split('.')
+          parts[0..-(tld_length+2)]
+        end
+
+        def extract_subdomain(host, tld_length = @@tld_length)
+          extract_subdomains(host, tld_length).join('.')
+        end
+
+        def url_for(options = {})
+          unless options[:host].present? || options[:only_path].present?
+            raise ArgumentError, 'Missing host to link to! Please provide the :host parameter, set default_url_options[:host], or set :only_path to true'
+          end
+
+          rewritten_url = ""
+
+          unless options[:only_path]
+            unless options[:protocol] == false
+              rewritten_url << (options[:protocol] || "http")
+              rewritten_url << ":" unless rewritten_url.match(%r{:|//})
+            end
+            rewritten_url << "//" unless rewritten_url.match("//")
+            rewritten_url << rewrite_authentication(options)
+            rewritten_url << host_or_subdomain_and_domain(options)
+            rewritten_url << ":#{options.delete(:port)}" if options[:port]
+          end
+
+          path = options.delete(:path) || ''
+
+          params = options[:params] || {}
+          params.reject! {|k,v| v.to_param.nil? }
+
+          rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
+          rewritten_url << "?#{params.to_query}" unless params.empty?
+          rewritten_url << "##{Rack::Mount::Utils.escape_uri(options[:anchor].to_param.to_s)}" if options[:anchor]
+          rewritten_url
+        end
+
+        private
+
+        def named_host?(host)
+          !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+        end
+
+        def rewrite_authentication(options)
+          if options[:user] && options[:password]
+            "#{Rack::Utils.escape(options[:user])}:#{Rack::Utils.escape(options[:password])}@"
+          else
+            ""
+          end
+        end
+
+        def host_or_subdomain_and_domain(options)
+          return options[:host] unless options[:subdomain] || options[:domain]
+
+          tld_length = options[:tld_length] || @@tld_length
+
+          host = ""
+          host << (options[:subdomain] || extract_subdomain(options[:host], tld_length))
+          host << "."
+          host << (options[:domain]    || extract_domain(options[:host], tld_length))
+          host
+        end
+      end
+
       # Returns the complete URL used for this request.
       def url
         protocol + host_with_port + fullpath
@@ -8,12 +83,7 @@ module ActionDispatch
 
       # Returns 'https://' if this is an SSL request and 'http://' otherwise.
       def protocol
-        ssl? ? 'https://' : 'http://'
-      end
-
-      # Is this an SSL request?
-      def ssl?
-        @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https'
+        @protocol ||= ssl? ? 'https://' : 'http://'
       end
 
       # Returns the \host for this request, such as "example.com".
@@ -38,10 +108,12 @@ module ActionDispatch
 
       # Returns the port number of this request as an integer.
       def port
-        if raw_host_with_port =~ /:(\d+)$/
-          $1.to_i
-        else
-          standard_port
+        @port ||= begin
+          if raw_host_with_port =~ /:(\d+)$/
+            $1.to_i
+          else
+            standard_port
+          end
         end
       end
 
@@ -53,10 +125,21 @@ module ActionDispatch
         end
       end
 
-      # Returns a \port suffix like ":8080" if the \port number of this request
+      # Returns whether this request is using the standard port
+      def standard_port?
+        port == standard_port
+      end
+
+      # Returns a number \port suffix like 8080 if the \port number of this request
       # is not the default HTTP \port 80 or HTTPS \port 443.
+      def optional_port
+        standard_port? ? nil : port
+      end
+
+      # Returns a string \port suffix, including colon, like ":8080" if the \port
+      # number of this request is not the default HTTP \port 80 or HTTPS \port 443.
       def port_string
-        port == standard_port ? '' : ":#{port}"
+        standard_port? ? '' : ":#{port}"
       end
 
       def server_port
@@ -65,38 +148,25 @@ module ActionDispatch
 
       # 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)
-        return nil unless named_host?(host)
-
-        host.split('.').last(1 + tld_length).join('.')
+      def domain(tld_length = @@tld_length)
+        ActionDispatch::Http::URL.extract_domain(host, tld_length)
       end
 
       # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
       # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
       # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
       # in "www.rubyonrails.co.uk".
-      def subdomains(tld_length = 1)
-        return [] unless named_host?(host)
-        parts = host.split('.')
-        parts[0..-(tld_length+2)]
-      end
-
-      def subdomain(tld_length = 1)
-        subdomains(tld_length).join('.')
-      end
-
-      # Returns the request URI, accounting for server idiosyncrasies.
-      # WEBrick includes the full URL. IIS leaves REQUEST_URI blank.
-      def request_uri
-        ActiveSupport::Deprecation.warn "Using #request_uri is deprecated. Use fullpath instead.", caller
-        fullpath
+      def subdomains(tld_length = @@tld_length)
+        ActionDispatch::Http::URL.extract_subdomains(host, tld_length)
       end
 
-    private
-
-      def named_host?(host)
-        !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+      # Returns all the \subdomains as a string, so <tt>"dev.www"</tt> would be
+      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
+      # such as 2 to catch <tt>["www"]</tt> instead of <tt>"www.rubyonrails"</tt>
+      # in "www.rubyonrails.co.uk".
+      def subdomain(tld_length = @@tld_length)
+        subdomains(tld_length)
       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
index e4ae480bfb..1bb2ad7f67 100644
--- a/actionpack/lib/action_dispatch/middleware/callbacks.rb
+++ b/actionpack/lib/action_dispatch/middleware/callbacks.rb
@@ -1,30 +1,14 @@
+require 'active_support/core_ext/module/delegation'
+
 module ActionDispatch
   # Provide callbacks to be executed before and after the request dispatch.
-  #
-  # It also provides a to_prepare callback, which is performed in all requests
-  # in development by only once in production and notification callback for async
-  # operations.
-  #
   class Callbacks
     include ActiveSupport::Callbacks
 
     define_callbacks :call, :rescuable => true
-    define_callbacks :prepare, :scope => :name
 
-    # Add a preparation callback. Preparation callbacks are run before every
-    # request in development mode, and before the first request in production mode.
-    #
-    # If a symbol with a block is given, the symbol is used as an identifier.
-    # That allows to_prepare to 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(*args, &block)
-      if args.first.is_a?(Symbol) && block_given?
-        define_method :"__#{args.first}", &block
-        set_callback(:prepare, :"__#{args.first}")
-      else
-        set_callback(:prepare, *args, &block)
-      end
+    class << self
+      delegate :to_prepare, :to_cleanup, :to => "ActionDispatch::Reloader"
     end
 
     def self.before(*args, &block)
@@ -35,14 +19,13 @@ module ActionDispatch
       set_callback(:call, :after, *args, &block)
     end
 
-    def initialize(app, prepare_each_request = false)
-      @app, @prepare_each_request = app, prepare_each_request
-      _run_prepare_callbacks
+    def initialize(app, unused = nil)
+      ActiveSupport::Deprecation.warn "Passing a second argument to ActionDispatch::Callbacks.new is deprecated." unless unused.nil?
+      @app = app
     end
 
     def call(env)
-      _run_call_callbacks do
-        _run_prepare_callbacks if @prepare_each_request
+      run_callbacks :call do
         @app.call(env)
       end
     end
diff --git a/actionpack/lib/action_dispatch/middleware/cookies.rb b/actionpack/lib/action_dispatch/middleware/cookies.rb
index 4d33cd3b0c..7ac608f0a8 100644
--- a/actionpack/lib/action_dispatch/middleware/cookies.rb
+++ b/actionpack/lib/action_dispatch/middleware/cookies.rb
@@ -7,7 +7,7 @@ module ActionDispatch
     end
   end
 
-  # Cookies are read and written through ActionController#cookies.
+  # \Cookies are read and written through ActionController#cookies.
   #
   # The cookies being read are the ones received along with the request, the cookies
   # being written will be sent out with the response. Reading a cookie does not get
@@ -16,15 +16,31 @@ module ActionDispatch
   # Examples for writing:
   #
   #   # Sets a simple session cookie.
+  #   # This cookie will be deleted when the user's browser is closed.
   #   cookies[:user_name] = "david"
   #
+  #   # Assign an array of values to a cookie.
+  #   cookies[:lat_lon] = [47.68, -122.37]
+  #
   #   # Sets a cookie that expires in 1 hour.
   #   cookies[:login] = { :value => "XJ-122", :expires => 1.hour.from_now }
   #
+  #   # Sets a signed cookie, which prevents a user from tampering with its value.
+  #   # The cookie is signed by your app's <tt>config.secret_token</tt> value.
+  #   # Rails generates this value by default when you create a new Rails app.
+  #   cookies.signed[:user_id] = current_user.id
+  #
+  #   # Sets a "permanent" cookie (which expires in 20 years from now).
+  #   cookies.permanent[:login] = "XJ-122"
+  #
+  #   # You can also chain these methods:
+  #   cookies.permanent.signed[:login] = "XJ-122"
+  #
   # Examples for reading:
   #
   #   cookies[:user_name] # => "david"
   #   cookies.size        # => 2
+  #   cookies[:lat_lon]   # => [47.68, -122.37]
   #
   # Example for deleting:
   #
@@ -55,7 +71,7 @@ module ActionDispatch
   #     :domain => :all # Allow the cookie for the top most level
   #                       domain and subdomains.
   #
-  # * <tt>:expires</tt> - The time at which this cookie expires, as a Time object.
+  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time object.
   # * <tt>:secure</tt> - Whether this cookie is a only transmitted to HTTPS servers.
   #   Default is +false+.
   # * <tt>:httponly</tt> - Whether this cookie is accessible via scripting or
@@ -69,27 +85,36 @@ module ActionDispatch
 
     class CookieJar < Hash #:nodoc:
 
-      # This regular expression is used to split the levels of a domain
-      # So www.example.co.uk gives:
-      # $1 => www.
-      # $2 => example
-      # $3 => co.uk
-      DOMAIN_REGEXP = /^(.*\.)*(.*)\.(...|...\...|....|..\...|..)$/
+      # This regular expression is used to split the levels of a domain.
+      # The top level domain can be any string without a period or
+      # **.**, ***.** style TLDs like co.uk or com.au
+      #
+      # www.example.co.uk gives:
+      # $& => example.co.uk
+      #
+      # example.com gives:
+      # $& => example.com
+      #
+      # lots.of.subdomains.example.local gives:
+      # $& => example.local
+      DOMAIN_REGEXP = /[^.]*\.([^.]*|..\...|...\...)$/
 
       def self.build(request)
         secret = request.env[TOKEN_KEY]
-        host = request.env["HTTP_HOST"]
+        host = request.host
+        secure = request.ssl?
 
-        new(secret, host).tap do |hash|
+        new(secret, host, secure).tap do |hash|
           hash.update(request.cookies)
         end
       end
 
-      def initialize(secret = nil, host = nil)
+      def initialize(secret = nil, host = nil, secure = false)
         @secret = secret
         @set_cookies = {}
         @delete_cookies = {}
         @host = host
+        @secure = secure
 
         super()
       end
@@ -103,8 +128,17 @@ module ActionDispatch
         options[:path] ||= "/"
 
         if options[:domain] == :all
-          @host =~ DOMAIN_REGEXP
-          options[:domain] = ".#{$2}.#{$3}"
+          # if there is a provided tld length then we use it otherwise default domain regexp
+          domain_regexp = options[:tld_length] ? /([^.]+\.?){#{options[:tld_length]}}$/ : DOMAIN_REGEXP
+
+          # if host is not ip and matches domain regexp
+          # (ip confirms to domain regexp so we explicitly check for ip)
+          options[:domain] = if (@host !~ /^[\d.]+$/) && (@host =~ domain_regexp)
+            ".#{$&}"
+          end
+        elsif options[:domain].is_a? Array
+          # if host matches one of the supplied domains without a dot in front of it
+          options[:domain] = options[:domain].find {|domain| @host.include? domain[/^\.?(.*)$/, 1] }
         end
       end
 
@@ -174,9 +208,15 @@ module ActionDispatch
       end
 
       def write(headers)
-        @set_cookies.each { |k, v| ::Rack::Utils.set_cookie_header!(headers, k, v) }
+        @set_cookies.each { |k, v| ::Rack::Utils.set_cookie_header!(headers, k, v) if write_cookie?(v) }
         @delete_cookies.each { |k, v| ::Rack::Utils.delete_cookie_header!(headers, k, v) }
       end
+
+      private
+
+        def write_cookie?(cookie)
+          @secure || !cookie[:secure] || defined?(Rails.env) && Rails.env.development?
+        end
     end
 
     class PermanentCookieJar < CookieJar #:nodoc:
@@ -248,7 +288,7 @@ module ActionDispatch
             "integrity hash for cookie session data. Use " +
             "config.secret_token = \"some secret phrase of at " +
             "least #{SECRET_MIN_LENGTH} characters\"" +
-            "in config/application.rb"
+            "in config/initializers/secret_token.rb"
         end
 
         if secret.length < SECRET_MIN_LENGTH
diff --git a/actionpack/lib/action_dispatch/middleware/flash.rb b/actionpack/lib/action_dispatch/middleware/flash.rb
index bfa30cf5af..21aeeb217a 100644
--- a/actionpack/lib/action_dispatch/middleware/flash.rb
+++ b/actionpack/lib/action_dispatch/middleware/flash.rb
@@ -10,13 +10,13 @@ module ActionDispatch
 
   # The flash provides a way to pass temporary objects between actions. Anything you place in the flash will be exposed
   # to the very next action and then cleared out. This is a great way of doing notices and alerts, such as a create
-  # action that sets <tt>flash[:notice] = "Successfully created"</tt> before redirecting to a display action that can
+  # action that sets <tt>flash[:notice] = "Post successfully created"</tt> before redirecting to a display action that can
   # then expose the flash to its template. Actually, that exposure is automatically done. Example:
   #
   #   class PostsController < ActionController::Base
   #     def create
   #       # save post
-  #       flash[:notice] = "Successfully created post"
+  #       flash[:notice] = "Post successfully created"
   #       redirect_to posts_path(@post)
   #     end
   #
@@ -30,6 +30,11 @@ module ActionDispatch
   #       <div class="notice"><%= flash[:notice] %></div>
   #     <% end %>
   #
+  # Since the +notice+ and +alert+ keys are a common idiom, convenience accessors are available:
+  #
+  #   flash.alert = "You must be logged in"
+  #   flash.notice = "Post successfully created"
+  #
   # This example just places a string in the flash, but you can put any object in there. And of course, you can put as
   # many as you like at a time too. Just remember: They'll be gone by the time the next action has been performed.
   #
diff --git a/actionpack/lib/action_dispatch/middleware/reloader.rb b/actionpack/lib/action_dispatch/middleware/reloader.rb
new file mode 100644
index 0000000000..29289a76b4
--- /dev/null
+++ b/actionpack/lib/action_dispatch/middleware/reloader.rb
@@ -0,0 +1,76 @@
+module ActionDispatch
+  # ActionDispatch::Reloader provides prepare and cleanup callbacks,
+  # intended to assist with code reloading during development.
+  #
+  # Prepare callbacks are run before each request, and cleanup callbacks
+  # after each request. In this respect they are analogs of ActionDispatch::Callback's
+  # before and after callbacks. However, cleanup callbacks are not called until the
+  # request is fully complete -- that is, after #close has been called on
+  # the response body. This is important for streaming responses such as the
+  # following:
+  #
+  #     self.response_body = lambda { |response, output|
+  #       # code here which refers to application models
+  #     }
+  #
+  # Cleanup callbacks will not be called until after the response_body lambda
+  # is evaluated, ensuring that it can refer to application models and other
+  # classes before they are unloaded.
+  #
+  # By default, ActionDispatch::Reloader is included in the middleware stack
+  # only in the development environment; specifically, when config.cache_classes
+  # is false. Callbacks may be registered even when it is not included in the
+  # middleware stack, but are executed only when +ActionDispatch::Reloader.prepare!+
+  # or +ActionDispatch::Reloader.cleanup!+ are called manually.
+  #
+  class Reloader
+    include ActiveSupport::Callbacks
+
+    define_callbacks :prepare, :scope => :name
+    define_callbacks :cleanup, :scope => :name
+
+    # Add a prepare callback. Prepare callbacks are run before each request, prior
+    # to ActionDispatch::Callback's before callbacks.
+    def self.to_prepare(*args, &block)
+      set_callback(:prepare, *args, &block)
+    end
+
+    # Add a cleanup callback. Cleanup callbacks are run after each request is
+    # complete (after #close is called on the response body).
+    def self.to_cleanup(*args, &block)
+      set_callback(:cleanup, *args, &block)
+    end
+
+    # Execute all prepare callbacks.
+    def self.prepare!
+      new(nil).run_callbacks :prepare
+    end
+
+    # Execute all cleanup callbacks.
+    def self.cleanup!
+      new(nil).run_callbacks :cleanup
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    module CleanupOnClose
+      def close
+        super if defined?(super)
+      ensure
+        ActionDispatch::Reloader.cleanup!
+      end
+    end
+
+    def call(env)
+      run_callbacks :prepare
+      response = @app.call(env)
+      response[2].extend(CleanupOnClose)
+      response
+    rescue Exception
+      run_callbacks :cleanup
+      raise
+    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 dd82294644..64d3a87fd0 100644
--- a/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/abstract_store.rb
@@ -1,5 +1,6 @@
 require 'rack/utils'
 require 'rack/request'
+require 'rack/session/abstract/id'
 require 'action_dispatch/middleware/cookies'
 require 'active_support/core_ext/object/blank'
 
@@ -8,249 +9,76 @@ module ActionDispatch
     class SessionRestoreError < StandardError #:nodoc:
     end
 
-    class AbstractStore
-      ENV_SESSION_KEY = 'rack.session'.freeze
-      ENV_SESSION_OPTIONS_KEY = 'rack.session.options'.freeze
-
-      # thin wrapper around Hash that allows us to lazily
-      # load session id into session_options
-      class OptionsHash < Hash
-        def initialize(by, env, default_options)
-          @by = by
-          @env = env
-          @session_id_loaded = false
-          merge!(default_options)
-        end
-
-        def [](key)
-          if key == :id
-            load_session_id! unless key?(:id) || has_session_id?
-          end
-          super
-        end
-
-      private
-
-        def has_session_id?
-          @session_id_loaded
-        end
-
-        def load_session_id!
-          self[:id] = @by.send(:extract_session_id, @env)
-          @session_id_loaded = true
-        end
-      end
-
-      class SessionHash < Hash
-        def initialize(by, env)
-          super()
-          @by = by
-          @env = env
-          @loaded = false
-        end
-
-        def [](key)
-          load_for_read!
-          super(key.to_s)
-        end
-
-        def has_key?(key)
-          load_for_read!
-          super(key.to_s)
-        end
-
-        def []=(key, value)
-          load_for_write!
-          super(key.to_s, value)
-        end
-
-        def clear
-          load_for_write!
-          super
-        end
-
-        def to_hash
-          load_for_read!
-          h = {}.replace(self)
-          h.delete_if { |k,v| v.nil? }
-          h
-        end
-
-        def update(hash)
-          load_for_write!
-          super(hash.stringify_keys)
-        end
-
-        def delete(key)
-          load_for_write!
-          super(key.to_s)
-        end
-
-        def inspect
-          load_for_read!
-          super
-        end
-
-        def exists?
-          return @exists if instance_variable_defined?(:@exists)
-          @exists = @by.send(:exists?, @env)
-        end
-
-        def loaded?
-          @loaded
-        end
-
-        def destroy
-          clear
-          @by.send(:destroy, @env) if @by
-          @env[ENV_SESSION_OPTIONS_KEY][:id] = nil if @env && @env[ENV_SESSION_OPTIONS_KEY]
-          @loaded = false
-        end
-
-        private
-
-          def load_for_read!
-            load! if !loaded? && exists?
-          end
-
-          def load_for_write!
-            load! unless loaded?
-          end
-
-          def load!
-            id, session = @by.send(:load_session, @env)
-            @env[ENV_SESSION_OPTIONS_KEY][:id] = id
-            replace(session.stringify_keys)
-            @loaded = true
-          end
-
+    module DestroyableSession
+      def destroy
+        clear
+        options = @env[Rack::Session::Abstract::ENV_SESSION_OPTIONS_KEY] if @env
+        options ||= {}
+        @by.send(:destroy_session, @env, options[:id], options) if @by
+        options[:id] = nil
+        @loaded = false
       end
+    end
 
-      DEFAULT_OPTIONS = {
-        :key =>           '_session_id',
-        :path =>          '/',
-        :domain =>        nil,
-        :expire_after =>  nil,
-        :secure =>        false,
-        :httponly =>      true,
-        :cookie_only =>   true
-      }
+    ::Rack::Session::Abstract::SessionHash.send :include, DestroyableSession
 
+    module Compatibility
       def initialize(app, options = {})
-        @app = app
-        @default_options = DEFAULT_OPTIONS.merge(options)
-        @key = @default_options.delete(:key).freeze
-        @cookie_only = @default_options.delete(:cookie_only)
-        ensure_session_key!
+        options[:key] ||= '_session_id'
+        super
       end
 
-      def call(env)
-        prepare!(env)
-        response = @app.call(env)
-
-        session_data = env[ENV_SESSION_KEY]
-        options = env[ENV_SESSION_OPTIONS_KEY]
-
-        if !session_data.is_a?(AbstractStore::SessionHash) || session_data.loaded? || options[:expire_after]
-          session_data.send(:load!) if session_data.is_a?(AbstractStore::SessionHash) && !session_data.loaded?
-
-          sid = options[:id] || generate_sid
-          session_data = session_data.to_hash
-
-          value = set_session(env, sid, session_data)
-          return response unless value
-
-          cookie = { :value => value }
-          unless options[:expire_after].nil?
-            cookie[:expires] = Time.now + options.delete(:expire_after)
-          end
-
-          request = ActionDispatch::Request.new(env)
-          set_cookie(request, cookie.merge!(options))
-        end
-
-        response
+      def generate_sid
+        ActiveSupport::SecureRandom.hex(16)
       end
 
-      private
-
-        def prepare!(env)
-          env[ENV_SESSION_KEY] = SessionHash.new(self, env)
-          env[ENV_SESSION_OPTIONS_KEY] = OptionsHash.new(self, env, @default_options)
-        end
-
-        def generate_sid
-          ActiveSupport::SecureRandom.hex(16)
-        end
-
-        def set_cookie(request, options)
-          if request.cookie_jar[@key] != options[:value] || !options[:expires].nil?
-            request.cookie_jar[@key] = options
-          end
-        end
-
-        def load_session(env)
-          stale_session_check! do
-            sid = current_session_id(env)
-            sid, session = get_session(env, sid)
-            [sid, session]
-          end
-        end
+    protected
 
-        def extract_session_id(env)
-          stale_session_check! do
-            request = ActionDispatch::Request.new(env)
-            sid = request.cookies[@key]
-            sid ||= request.params[@key] unless @cookie_only
-            sid
-          end
-        end
+      def initialize_sid
+        @default_options.delete(:sidbits)
+        @default_options.delete(:secure_random)
+      end
+    end
 
-        def current_session_id(env)
-          env[ENV_SESSION_OPTIONS_KEY][:id]
-        end
+    module StaleSessionCheck
+      def load_session(env)
+        stale_session_check! { super }
+      end
 
-        def ensure_session_key!
-          if @key.blank?
-            raise ArgumentError, 'A key is required to write a ' +
-              'cookie containing the session data. Use ' +
-              'config.session_store SESSION_STORE, { :key => ' +
-              '"_myapp_session" } in config/application.rb'
-          end
-        end
+      def extract_session_id(env)
+        stale_session_check! { super }
+      end
 
-        def stale_session_check!
-          yield
-        rescue ArgumentError => argument_error
-          if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
-            begin
-              # Note that the regexp does not allow $1 to end with a ':'
-              $1.constantize
-            rescue LoadError, NameError => const_error
-              raise ActionDispatch::Session::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
-          else
-            raise
+      def stale_session_check!
+        yield
+      rescue ArgumentError => argument_error
+        if argument_error.message =~ %r{undefined class/module ([\w:]*\w)}
+          begin
+            # Note that the regexp does not allow $1 to end with a ':'
+            $1.constantize
+          rescue LoadError, NameError => const_error
+            raise ActionDispatch::Session::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
+        else
+          raise
         end
+      end
+    end
 
-        def exists?(env)
-          current_session_id(env).present?
-        end
-
-        def get_session(env, sid)
-          raise '#get_session needs to be implemented.'
-        end
+    class AbstractStore < Rack::Session::Abstract::ID
+      include Compatibility
+      include StaleSessionCheck
 
-        def set_session(env, sid, session_data)
-          raise '#set_session needs to be implemented and should return ' <<
-            'the value to be stored in the cookie (usually the sid)'
-        end
+      def destroy_session(env, sid, options)
+        ActiveSupport::Deprecation.warn "Implementing #destroy in session stores is deprecated. " <<
+          "Please implement destroy_session(env, session_id, options) instead."
+        destroy(env)
+      end
 
-        def destroy(env)
-          raise '#destroy needs to be implemented.'
-        end
+      def destroy(env)
+        raise '#destroy needs to be implemented.'
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
index ca1494425f..9c9ccc62f5 100644
--- a/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/cookie_store.rb
@@ -1,5 +1,7 @@
 require 'active_support/core_ext/hash/keys'
 require 'active_support/core_ext/object/blank'
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/cookie'
 
 module ActionDispatch
   module Session
@@ -38,58 +40,32 @@ module ActionDispatch
     # "rake secret" and set the key in config/initializers/secret_token.rb.
     #
     # Note that changing digest or secret invalidates all existing sessions!
-    class CookieStore < AbstractStore
-
-      def initialize(app, options = {})
-        super(app, options.merge!(:cookie_only => true))
-        freeze
-      end
+    class CookieStore < Rack::Session::Cookie
+      include Compatibility
+      include StaleSessionCheck
 
       private
 
-        def load_session(env)
-          data = unpacked_cookie_data(env)
-          data = persistent_session_id!(data)
-          [data["session_id"], data]
-        end
-
-        def extract_session_id(env)
-          if data = unpacked_cookie_data(env)
-            data["session_id"]
-          else
-            nil
-          end
-        end
-
-        def unpacked_cookie_data(env)
-          env["action_dispatch.request.unsigned_session_cookie"] ||= begin
-            stale_session_check! do
-              request = ActionDispatch::Request.new(env)
-              if data = request.cookie_jar.signed[@key]
-                data.stringify_keys!
-              end
-              data || {}
+      def unpacked_cookie_data(env)
+        env["action_dispatch.request.unsigned_session_cookie"] ||= begin
+          stale_session_check! do
+            request = ActionDispatch::Request.new(env)
+            if data = request.cookie_jar.signed[@key]
+              data.stringify_keys!
             end
+            data || {}
           end
         end
+      end
 
-        def set_cookie(request, options)
-          request.cookie_jar.signed[@key] = options
-        end
-
-        def set_session(env, sid, session_data)
-          persistent_session_id!(session_data, sid)
-        end
-
-        def destroy(env)
-          # session data is stored on client; nothing to do here
-        end
+      def set_session(env, sid, session_data, options)
+        persistent_session_id!(session_data, sid)
+      end
 
-        def persistent_session_id!(data, sid=nil)
-          data ||= {}
-          data["session_id"] ||= sid || generate_sid
-          data
-        end
+      def set_cookie(env, session_id, cookie)
+        request = ActionDispatch::Request.new(env)
+        request.cookie_jar.signed[@key] = cookie
+      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
index 28e3dbd732..4dd9a946c2 100644
--- a/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
+++ b/actionpack/lib/action_dispatch/middleware/session/mem_cache_store.rb
@@ -1,56 +1,17 @@
+require 'action_dispatch/middleware/session/abstract_store'
+require 'rack/session/memcache'
+
 module ActionDispatch
   module Session
-    class MemCacheStore < AbstractStore
+    class MemCacheStore < Rack::Session::Memcache
+      include Compatibility
+      include StaleSessionCheck
+
       def initialize(app, options = {})
         require 'memcache'
-
-        # Support old :expires option
         options[:expire_after] ||= options[:expires]
-
-        super
-
-        @default_options = {
-          :namespace => 'rack:session',
-          :memcache_server => 'localhost:11211'
-        }.merge(@default_options)
-
-        @pool = options[:cache] || MemCache.new(@default_options[:memcache_server], @default_options)
-        unless @pool.servers.any? { |s| s.alive? }
-          raise "#{self} unable to find server during initialization."
-        end
-        @mutex = Mutex.new
-
         super
       end
-
-      private
-        def get_session(env, sid)
-          sid ||= generate_sid
-          begin
-            session = @pool.get(sid) || {}
-          rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-            session = {}
-          end
-          [sid, session]
-        end
-
-        def set_session(env, sid, session_data)
-          options = env['rack.session.options']
-          expiry  = options[:expire_after] || 0
-          @pool.set(sid, session_data, expiry)
-          sid
-        rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-          false
-        end
-
-        def destroy(env)
-          if sid = current_session_id(env)
-            @pool.delete(sid)
-          end
-        rescue MemCache::MemCacheError, Errno::ECONNREFUSED
-          false
-        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 e095b51342..dbe3206808 100644
--- a/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
+++ b/actionpack/lib/action_dispatch/middleware/show_exceptions.rb
@@ -6,8 +6,6 @@ module ActionDispatch
   # This middleware rescues any exception returned by the application and renders
   # nice exception pages if it's being rescued locally.
   class ShowExceptions
-    LOCALHOST = [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/].freeze
-
     RESCUES_TEMPLATE_PATH = File.join(File.dirname(__FILE__), 'templates')
 
     cattr_accessor :rescue_responses
@@ -45,28 +43,29 @@ module ActionDispatch
     end
 
     def call(env)
-      status, headers, body = @app.call(env)
-
-      # Only this middleware cares about RoutingError. So, let's just raise
-      # it here.
-      # TODO: refactor this middleware to handle the X-Cascade scenario without
-      # having to raise an exception.
-      if headers['X-Cascade'] == 'pass'
-        raise ActionController::RoutingError, "No route matches #{env['PATH_INFO'].inspect}"
+      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['PATH_INFO'].inspect}"
+        end
+      rescue Exception => exception
+        raise exception if env['action_dispatch.show_exceptions'] == false
       end
 
-      [status, headers, body]
-    rescue Exception => exception
-      raise exception if env['action_dispatch.show_exceptions'] == false
-      render_exception(env, exception)
+      exception ? render_exception(env, exception) : [status, headers, body]
     end
 
     private
       def render_exception(env, exception)
         log_error(exception)
+        exception = original_exception(exception)
 
         request = Request.new(env)
-        if @consider_all_requests_local || local_request?(request)
+        if @consider_all_requests_local || request.local?
           rescue_action_locally(request, exception)
         else
           rescue_action_in_public(exception)
@@ -112,11 +111,6 @@ module ActionDispatch
         end
       end
 
-      # True if the request came from localhost, 127.0.0.1.
-      def local_request?(request)
-        LOCALHOST.any? { |local_ip| local_ip === request.remote_addr && local_ip === request.remote_ip }
-      end
-
       def status_code(exception)
         Rack::Utils.status_code(@@rescue_responses[exception.class.name])
       end
@@ -134,7 +128,7 @@ module ActionDispatch
 
         ActiveSupport::Deprecation.silence do
           message = "\n#{exception.class} (#{exception.message}):\n"
-          message << exception.annoted_source_code if exception.respond_to?(:annoted_source_code)
+          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
@@ -161,5 +155,17 @@ module ActionDispatch
       def logger
         defined?(Rails.logger) ? Rails.logger : Logger.new($stderr)
       end
+
+    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
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/stack.rb b/actionpack/lib/action_dispatch/middleware/stack.rb
index 41078eced7..a4308f528c 100644
--- a/actionpack/lib/action_dispatch/middleware/stack.rb
+++ b/actionpack/lib/action_dispatch/middleware/stack.rb
@@ -1,17 +1,27 @@
 require "active_support/inflector/methods"
+require "active_support/dependencies"
 
 module ActionDispatch
-  class MiddlewareStack < Array
+  class MiddlewareStack
     class Middleware
-      attr_reader :args, :block
+      attr_reader :args, :block, :name, :classcache
 
       def initialize(klass_or_name, *args, &block)
-        @ref = ActiveSupport::Dependencies::Reference.new(klass_or_name)
+        @klass = nil
+
+        if klass_or_name.respond_to?(:name)
+          @klass = klass_or_name
+          @name  = @klass.name
+        else
+          @name  = klass_or_name.to_s
+        end
+
+        @classcache = ActiveSupport::Dependencies::Reference
         @args, @block = args, block
       end
 
       def klass
-        @ref.get
+        @klass || classcache[@name]
       end
 
       def ==(middleware)
@@ -21,7 +31,7 @@ module ActionDispatch
         when Class
           klass == middleware
         else
-          normalize(@ref.name) == normalize(middleware)
+          normalize(@name) == normalize(middleware)
         end
       end
 
@@ -40,15 +50,39 @@ module ActionDispatch
       end
     end
 
-    def initialize(*args, &block)
-      super(*args)
-      block.call(self) if block_given?
+    include Enumerable
+
+    attr_accessor :middlewares
+
+    def initialize(*args)
+      @middlewares = []
+      yield(self) if block_given?
+    end
+
+    def each
+      @middlewares.each { |x| yield x }
+    end
+
+    def size
+      middlewares.size
+    end
+
+    def last
+      middlewares.last
+    end
+
+    def [](i)
+      middlewares[i]
+    end
+
+    def initialize_copy(other)
+      self.middlewares = other.middlewares.dup
     end
 
     def insert(index, *args, &block)
       index = assert_index(index, :before)
       middleware = self.class::Middleware.new(*args, &block)
-      super(index, middleware)
+      middlewares.insert(index, middleware)
     end
 
     alias_method :insert_before, :insert
@@ -63,26 +97,25 @@ module ActionDispatch
       delete(target)
     end
 
-    def use(*args, &block)
-      middleware = self.class::Middleware.new(*args, &block)
-      push(middleware)
+    def delete(target)
+      middlewares.delete target
     end
 
-    def active
-      ActiveSupport::Deprecation.warn "All middlewares in the chain are active since the laziness " << 
-        "was removed from the middleware stack", caller
+    def use(*args, &block)
+      middleware = self.class::Middleware.new(*args, &block)
+      middlewares.push(middleware)
     end
 
     def build(app = nil, &block)
       app ||= block
       raise "MiddlewareStack#build requires an app" unless app
-      reverse.inject(app) { |a, e| e.build(a) }
+      middlewares.reverse.inject(app) { |a, e| e.build(a) }
     end
 
   protected
 
     def assert_index(index, where)
-      i = index.is_a?(Integer) ? index : self.index(index)
+      i = index.is_a?(Integer) ? index : middlewares.index(index)
       raise "No such middleware to insert #{where}: #{index.inspect}" unless i
       i
     end
diff --git a/actionpack/lib/action_dispatch/middleware/static.rb b/actionpack/lib/action_dispatch/middleware/static.rb
index d7e88a54e4..c57f694c4d 100644
--- a/actionpack/lib/action_dispatch/middleware/static.rb
+++ b/actionpack/lib/action_dispatch/middleware/static.rb
@@ -1,12 +1,47 @@
 require 'rack/utils'
 
 module ActionDispatch
+  class FileHandler
+    def initialize(at, root)
+      @at, @root     = at.chomp('/'), root.chomp('/')
+      @compiled_at   = @at.blank? ? nil : /^#{Regexp.escape(at)}/
+      @compiled_root = /^#{Regexp.escape(root)}/
+      @file_server   = ::Rack::File.new(@root)
+    end
+
+    def match?(path)
+      path = path.dup
+      if !@compiled_at || path.sub!(@compiled_at, '')
+        full_path = path.empty? ? @root : File.join(@root, ::Rack::Utils.unescape(path))
+        paths = "#{full_path}#{ext}"
+
+        matches = Dir[paths]
+        match = matches.detect { |m| File.file?(m) }
+        if match
+          match.sub!(@compiled_root, '')
+          match
+        end
+      end
+    end
+
+    def call(env)
+      @file_server.call(env)
+    end
+
+    def ext
+      @ext ||= begin
+        ext = ::ActionController::Base.page_cache_extension
+        "{,#{ext},/index#{ext}}"
+      end
+    end
+  end
+
   class Static
     FILE_METHODS = %w(GET HEAD).freeze
 
-    def initialize(app, root)
+    def initialize(app, roots)
       @app = app
-      @file_server = ::Rack::File.new(root)
+      @file_handlers = create_file_handlers(roots)
     end
 
     def call(env)
@@ -14,15 +49,10 @@ module ActionDispatch
       method = env['REQUEST_METHOD']
 
       if FILE_METHODS.include?(method)
-        if file_exist?(path)
-          return @file_server.call(env)
-        else
-          cached_path = directory_exist?(path) ? "#{path}/index" : path
-          cached_path += ::ActionController::Base.page_cache_extension
-
-          if file_exist?(cached_path)
-            env['PATH_INFO'] = cached_path
-            return @file_server.call(env)
+        @file_handlers.each do |file_handler|
+          if match = file_handler.match?(path)
+            env["PATH_INFO"] = match
+            return file_handler.call(env)
           end
         end
       end
@@ -31,14 +61,12 @@ module ActionDispatch
     end
 
     private
-      def file_exist?(path)
-        full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
-        File.file?(full_path) && File.readable?(full_path)
-      end
+      def create_file_handlers(roots)
+        roots = { '' => roots } unless roots.is_a?(Hash)
 
-      def directory_exist?(path)
-        full_path = File.join(@file_server.root, ::Rack::Utils.unescape(path))
-        File.directory?(full_path) && File.readable?(full_path)
+        roots.map do |at, root|
+          FileHandler.new(at, root) if File.exist?(root)
+        end.compact
       end
   end
 end
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
index e963b04524..97f7cf0bbe 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_request_and_response.erb
@@ -14,7 +14,7 @@
 
   def debug_hash(hash)
     hash.sort_by { |k, v| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
-  end
+  end unless self.class.method_defined?(:debug_hash)
 %>
 
 <h2 style="margin-top: 30px">Request</h2>
@@ -28,4 +28,4 @@
 
 
 <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 defined?(@response) ? @response.headers.inspect.gsub(',', ",\n") : 'None' %></pre></p>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
index d18b162a93..8771b5fd6d 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.erb
@@ -12,14 +12,14 @@
 <div id="traces">
   <% names.each do |name| %>
     <%
-      show = "document.getElementById('#{name.gsub /\s/, '-'}').style.display='block';"
-      hide = (names - [name]).collect {|hide_name| "document.getElementById('#{hide_name.gsub /\s/, '-'}').style.display='none';"}
+      show = "document.getElementById('#{name.gsub(/\s/, '-')}').style.display='block';"
+      hide = (names - [name]).collect {|hide_name| "document.getElementById('#{hide_name.gsub(/\s/, '-')}').style.display='none';"}
     %>
     <a href="#" onclick="<%= hide.join %><%= show %>; return false;"><%= name %></a> <%= '|' unless names.last == name %>
   <% end %>
 
   <% traces.each do |name, trace| %>
-    <div id="<%= name.gsub /\s/, '-' %>" style="display: <%= name == "Application Trace" ? 'block' : 'none' %>;">
+    <div id="<%= name.gsub(/\s/, '-') %>" style="display: <%= (name == "Application Trace") ? 'block' : 'none' %>;">
       <pre><code><%=h trace.join "\n" %></code></pre>
     </div>
   <% end %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
index bd6ffbab5d..50d8ca9484 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.erb
@@ -6,5 +6,5 @@
 </h1>
 <pre><%=h @exception.message %></pre>
 
-<%= render :file => "rescues/_trace.erb" %>
-<%= render :file => "rescues/_request_and_response.erb" %>
+<%= render :template => "rescues/_trace" %>
+<%= render :template => "rescues/_request_and_response" %>
diff --git a/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
index 02fa18211d..c658559be9 100644
--- a/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
+++ b/actionpack/lib/action_dispatch/middleware/templates/rescues/template_error.erb
@@ -13,9 +13,5 @@
 
 <p><%=h @exception.sub_template_message %></p>
 
-<% @real_exception = @exception
-   @exception = @exception.original_exception || @exception %>
-<%= render :file => "rescues/_trace.erb" %>
-<% @exception = @real_exception %>
-
-<%= render :file => "rescues/_request_and_response.erb" %>
+<%= render :template => "rescues/_trace" %>
+<%= render :template => "rescues/_request_and_response" %>
diff --git a/actionpack/lib/action_dispatch/railtie.rb b/actionpack/lib/action_dispatch/railtie.rb
index a3af37947a..0a3bd5fe40 100644
--- a/actionpack/lib/action_dispatch/railtie.rb
+++ b/actionpack/lib/action_dispatch/railtie.rb
@@ -8,10 +8,11 @@ module ActionDispatch
     config.action_dispatch.ip_spoofing_check = true
     config.action_dispatch.show_exceptions = true
     config.action_dispatch.best_standards_support = true
+    config.action_dispatch.tld_length = 1
+    config.action_dispatch.rack_cache = {:metastore => "rails:/", :entitystore => "rails:/", :verbose => true}
 
-    # Prepare dispatcher callbacks and run 'prepare' callbacks
-    initializer "action_dispatch.prepare_dispatcher" do |app|
-      ActionDispatch::Callbacks.to_prepare { app.routes_reloader.execute_if_updated }
+    initializer "action_dispatch.configure" do |app|
+      ActionDispatch::Http::URL.tld_length = app.config.action_dispatch.tld_length
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing.rb b/actionpack/lib/action_dispatch/routing.rb
index 683dd72555..43fd93adf6 100644
--- a/actionpack/lib/action_dispatch/routing.rb
+++ b/actionpack/lib/action_dispatch/routing.rb
@@ -2,31 +2,11 @@ require 'active_support/core_ext/object/to_param'
 require 'active_support/core_ext/regexp'
 
 module ActionDispatch
-  # = Routing
-  #
   # The routing module provides URL rewriting in native Ruby. It's a way to
   # redirect incoming requests to controllers and actions. This replaces
-  # mod_rewrite rules. Best of all, Rails' Routing works with any web server.
+  # mod_rewrite rules. Best of all, Rails' \Routing works with any web server.
   # Routes are defined in <tt>config/routes.rb</tt>.
   #
-  # Consider the following route, which you will find commented out at the
-  # bottom of your generated <tt>config/routes.rb</tt>:
-  #
-  #   match ':controller(/:action(/:id(.:format)))'
-  #
-  # This route states that it expects requests to consist of a
-  # <tt>:controller</tt> followed optionally by an <tt>:action</tt> that in 
-  # turn is followed optionally by an <tt>:id</tt>, which in turn is followed
-  # optionally by a <tt>:format</tt>
-  #
-  # Suppose you get an incoming request for <tt>/blog/edit/22</tt>, you'll end
-  # up with:
-  #
-  #   params = { :controller => 'blog',
-  #              :action     => 'edit',
-  #              :id         => '22'
-  #           }
-  #
   # Think of creating routes as drawing a map for your requests. The map tells
   # them where to go based on some predefined pattern:
   #
@@ -43,6 +23,51 @@ module ActionDispatch
   #
   # Other names simply map to a parameter as in the case of <tt>:id</tt>.
   #
+  # == Resources
+  #
+  # Resource routing allows you to quickly declare all of the common routes
+  # for a given resourceful controller. Instead of declaring separate routes
+  # for your +index+, +show+, +new+, +edit+, +create+, +update+ and +destroy+
+  # actions, a resourceful route declares them in a single line of code:
+  #
+  #  resources :photos
+  #
+  # Sometimes, you have a resource that clients always look up without
+  # referencing an ID. A common example, /profile always shows the profile of
+  # the currently logged in user. In this case, you can use a singular resource
+  # to map /profile (rather than /profile/:id) to the show action.
+  #
+  #  resource :profile
+  #
+  # It's common to have resources that are logically children of other
+  # resources:
+  #
+  #   resources :magazines do
+  #     resources :ads
+  #   end
+  #
+  # You may wish to organize groups of controllers under a namespace. Most
+  # commonly, you might group a number of administrative controllers under
+  # an +admin+ namespace. You would place these controllers under the
+  # app/controllers/admin directory, and you can group them together in your
+  # router:
+  #
+  #   namespace "admin" do
+  #     resources :posts, :comments
+  #   end
+  #
+  # Alternately, you can add prefixes to your path without using a separate
+  # directory by using +scope+. +scope+ takes additional options which
+  # apply to all enclosed routes.
+  #
+  #   scope :path => "/cpanel", :as => 'admin' do
+  #     resources :posts, :comments
+  #   end
+  #
+  # For more, see <tt>Routing::Mapper::Resources#resources</tt>,
+  # <tt>Routing::Mapper::Scoping#namespace</tt>, and
+  # <tt>Routing::Mapper::Scoping#scope</tt>.
+  #
   # == Named routes
   #
   # Routes can be named by passing an <tt>:as</tt> option,
@@ -131,11 +156,35 @@ module ActionDispatch
   # Encoding regular expression modifiers are silently ignored. The
   # match will always use the default encoding or ASCII.
   #
+  # == Default route
+  #
+  # Consider the following route, which you will find commented out at the
+  # bottom of your generated <tt>config/routes.rb</tt>:
+  #
+  #   match ':controller(/:action(/:id(.:format)))'
+  #
+  # This route states that it expects requests to consist of a
+  # <tt>:controller</tt> followed optionally by an <tt>:action</tt> that in
+  # turn is followed optionally by an <tt>:id</tt>, which in turn is followed
+  # optionally by a <tt>:format</tt>.
+  #
+  # Suppose you get an incoming request for <tt>/blog/edit/22</tt>, you'll end
+  # up with:
+  #
+  #   params = { :controller => 'blog',
+  #              :action     => 'edit',
+  #              :id         => '22'
+  #           }
+  #
+  # By not relying on default routes, you improve the security of your
+  # application since not all controller actions, which includes actions you
+  # might add at a later time, are exposed by default.
+  #
   # == HTTP Methods
   #
   # Using the <tt>:via</tt> option when specifying a route allows you to restrict it to a specific HTTP method.
-  # Possible values are <tt>:post</tt>, <tt>:get</tt>, <tt>:put</tt>, <tt>:delete</tt> and <tt>:any</tt>. 
-  # If your route needs to respond to more than one method you can use an array, e.g. <tt>[ :get, :post ]</tt>. 
+  # Possible values are <tt>:post</tt>, <tt>:get</tt>, <tt>:put</tt>, <tt>:delete</tt> and <tt>:any</tt>.
+  # If your route needs to respond to more than one method you can use an array, e.g. <tt>[ :get, :post ]</tt>.
   # The default value is <tt>:any</tt> which means that the route will respond to any of the HTTP methods.
   #
   # Examples:
@@ -144,7 +193,7 @@ module ActionDispatch
   #   match 'post/:id' => "posts#create_comment', :via => :post
   #
   # Now, if you POST to <tt>/posts/:id</tt>, it will route to the <tt>create_comment</tt> action. A GET on the same
-  # URL will route to the <tt>show</tt> action. 
+  # URL will route to the <tt>show</tt> action.
   #
   # === HTTP helper methods
   #
@@ -160,6 +209,20 @@ module ActionDispatch
   # however if your route needs to respond to more than one HTTP method (or all methods) then using the
   # <tt>:via</tt> option on <tt>match</tt> is preferable.
   #
+  # == External redirects
+  #
+  # You can redirect any path to another path using the redirect helper in your router:
+  #
+  #   match "/stories" => redirect("/posts")
+  #
+  # == Routing to Rack Applications
+  #
+  # Instead of a String, like <tt>posts#index</tt>, which corresponds to the
+  # index action in the PostsController, you can specify any Rack application
+  # as the endpoint for a matcher:
+  #
+  #   match "/application.js" => Sprockets
+  #
   # == Reloading routes
   #
   # You can reload routes if you feel you must:
@@ -208,13 +271,15 @@ module ActionDispatch
   #
   # == View a list of all your routes
   #
-  # Run <tt>rake routes</tt>.
+  #   rake routes
+  #
+  # Target specific controllers by prefixing the command with <tt>CONTROLLER=x</tt>.
   #
   module Routing
-    autoload :DeprecatedMapper, 'action_dispatch/routing/deprecated_mapper'
     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'
     autoload :PolymorphicRoutes, 'action_dispatch/routing/polymorphic_routes'
 
diff --git a/actionpack/lib/action_dispatch/routing/deprecated_mapper.rb b/actionpack/lib/action_dispatch/routing/deprecated_mapper.rb
deleted file mode 100644
index e04062ce8b..0000000000
--- a/actionpack/lib/action_dispatch/routing/deprecated_mapper.rb
+++ /dev/null
@@ -1,525 +0,0 @@
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/object/with_options'
-require 'active_support/core_ext/object/try'
-
-module ActionDispatch
-  module Routing
-    class RouteSet
-      attr_accessor :controller_namespaces
-
-      CONTROLLER_REGEXP = /[_a-zA-Z0-9]+/
-
-      def controller_constraints
-        @controller_constraints ||= begin
-          namespaces = controller_namespaces + in_memory_controller_namespaces
-          source = namespaces.map { |ns| "#{Regexp.escape(ns)}/#{CONTROLLER_REGEXP.source}" }
-          source << CONTROLLER_REGEXP.source
-          Regexp.compile(source.sort.reverse.join('|'))
-        end
-      end
-
-      def in_memory_controller_namespaces
-        namespaces = Set.new
-        ActionController::Base.descendants.each do |klass|
-          next if klass.anonymous?
-          namespaces << klass.name.underscore.split('/')[0...-1].join('/')
-        end
-        namespaces.delete('')
-        namespaces
-      end
-    end
-
-    class DeprecatedMapper #:nodoc:
-      def initialize(set) #:nodoc:
-        ActiveSupport::Deprecation.warn "You are using the old router DSL which will be removed in Rails 3.1. " <<
-          "Please check how to update your routes file at: http://www.engineyard.com/blog/2010/the-lowdown-on-routes-in-rails-3/"
-        @set = set
-      end
-
-      def connect(path, options = {})
-        options = options.dup
-
-        if conditions = options.delete(:conditions)
-          conditions = conditions.dup
-          method = [conditions.delete(:method)].flatten.compact
-          method.map! { |m|
-            m = m.to_s.upcase
-
-            if m == "HEAD"
-              raise ArgumentError, "HTTP method HEAD is invalid in route conditions. Rails processes HEAD requests the same as GETs, returning just the response headers"
-            end
-
-            unless HTTP_METHODS.include?(m.downcase.to_sym)
-              raise ArgumentError, "Invalid HTTP method specified in route conditions"
-            end
-
-            m
-          }
-
-          if method.length > 1
-            method = Regexp.union(*method)
-          elsif method.length == 1
-            method = method.first
-          else
-            method = nil
-          end
-        end
-
-        path_prefix = options.delete(:path_prefix)
-        name_prefix = options.delete(:name_prefix)
-        namespace  = options.delete(:namespace)
-
-        name = options.delete(:_name)
-        name = "#{name_prefix}#{name}" if name_prefix
-
-        requirements = options.delete(:requirements) || {}
-        defaults = options.delete(:defaults) || {}
-        options.each do |k, v|
-          if v.is_a?(Regexp)
-            if value = options.delete(k)
-              requirements[k.to_sym] = value
-            end
-          else
-            value = options.delete(k)
-            defaults[k.to_sym] = value.is_a?(Symbol) ? value : value.to_param
-          end
-        end
-
-        requirements.each do |_, requirement|
-          if requirement.source =~ %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
-            raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
-          end
-          if requirement.multiline?
-            raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
-          end
-        end
-
-        requirements[:controller] ||= @set.controller_constraints
-
-        if defaults[:controller]
-          defaults[:action] ||= 'index'
-          defaults[:controller] = defaults[:controller].to_s
-          defaults[:controller] = "#{namespace}#{defaults[:controller]}" if namespace
-        end
-
-        if defaults[:action]
-          defaults[:action] = defaults[:action].to_s
-        end
-
-        if path.is_a?(String)
-          path = "#{path_prefix}/#{path}" if path_prefix
-          path = path.gsub('.:format', '(.:format)')
-          path = optionalize_trailing_dynamic_segments(path, requirements, defaults)
-          glob = $1.to_sym if path =~ /\/\*(\w+)$/
-          path = ::Rack::Mount::Utils.normalize_path(path)
-
-          if glob && !defaults[glob].blank?
-            raise ActionController::RoutingError, "paths cannot have non-empty default values"
-          end
-        end
-
-        app = Routing::RouteSet::Dispatcher.new(:defaults => defaults, :glob => glob)
-
-        conditions = {}
-        conditions[:request_method] = method if method
-        conditions[:path_info] = path if path
-
-        @set.add_route(app, conditions, requirements, defaults, name)
-      end
-
-      def optionalize_trailing_dynamic_segments(path, requirements, defaults) #:nodoc:
-        path = (path =~ /^\//) ? path.dup : "/#{path}"
-        optional, segments = true, []
-
-        required_segments = requirements.keys
-        required_segments -= defaults.keys.compact
-
-        old_segments = path.split('/')
-        old_segments.shift
-        length = old_segments.length
-
-        old_segments.reverse.each_with_index do |segment, index|
-          required_segments.each do |required|
-            if segment =~ /#{required}/
-              optional = false
-              break
-            end
-          end
-
-          if optional
-            if segment == ":id" && segments.include?(":action")
-              optional = false
-            elsif segment == ":controller" || segment == ":action" || segment == ":id"
-              # Ignore
-            elsif !(segment =~ /^:\w+$/) &&
-                !(segment =~ /^:\w+\(\.:format\)$/)
-              optional = false
-            elsif segment =~ /^:(\w+)$/
-              if defaults.has_key?($1.to_sym)
-                defaults.delete($1.to_sym) if defaults[$1.to_sym].nil?
-              else
-                optional = false
-              end
-            end
-          end
-
-          if optional && index < length - 1
-            segments.unshift('(/', segment)
-            segments.push(')')
-          elsif optional
-            segments.unshift('/(', segment)
-            segments.push(')')
-          else
-            segments.unshift('/', segment)
-          end
-        end
-
-        segments.join
-      end
-      private :optionalize_trailing_dynamic_segments
-
-      # Creates a named route called "root" for matching the root level request.
-      def root(options = {})
-        if options.is_a?(Symbol)
-          if source_route = @set.named_routes.routes[options]
-            options = source_route.defaults.merge({ :conditions => source_route.conditions })
-          end
-        end
-        named_route("root", '', options)
-      end
-
-      def named_route(name, path, options = {}) #:nodoc:
-        options[:_name] = name
-        connect(path, options)
-      end
-
-      def namespace(name, options = {}, &block)
-        if options[:namespace]
-          with_options({:path_prefix => "#{options.delete(:path_prefix)}/#{name}", :name_prefix => "#{options.delete(:name_prefix)}#{name}_", :namespace => "#{options.delete(:namespace)}#{name}/" }.merge(options), &block)
-        else
-          with_options({:path_prefix => name, :name_prefix => "#{name}_", :namespace => "#{name}/" }.merge(options), &block)
-        end
-      end
-
-      def method_missing(route_name, *args, &proc) #:nodoc:
-        super unless args.length >= 1 && proc.nil?
-        named_route(route_name, *args)
-      end
-
-      INHERITABLE_OPTIONS = :namespace, :shallow
-
-      class Resource #:nodoc:
-        DEFAULT_ACTIONS = :index, :create, :new, :edit, :show, :update, :destroy
-
-        attr_reader :collection_methods, :member_methods, :new_methods
-        attr_reader :path_prefix, :name_prefix, :path_segment
-        attr_reader :plural, :singular
-        attr_reader :options, :defaults
-
-        def initialize(entities, options, defaults)
-          @plural   ||= entities
-          @singular ||= options[:singular] || plural.to_s.singularize
-          @path_segment = options.delete(:as) || @plural
-
-          @options = options
-          @defaults = defaults
-
-          arrange_actions
-          add_default_actions
-          set_allowed_actions
-          set_prefixes
-        end
-
-        def controller
-          @controller ||= "#{options[:namespace]}#{(options[:controller] || plural).to_s}"
-        end
-
-        def requirements(with_id = false)
-          @requirements   ||= @options[:requirements] || {}
-          @id_requirement ||= { :id => @requirements.delete(:id) || /[^#{Routing::SEPARATORS.join}]+/ }
-
-          with_id ? @requirements.merge(@id_requirement) : @requirements
-        end
-
-        def conditions
-          @conditions ||= @options[:conditions] || {}
-        end
-
-        def path
-          @path ||= "#{path_prefix}/#{path_segment}"
-        end
-
-        def new_path
-          new_action   = self.options[:path_names][:new] if self.options[:path_names]
-          new_action ||= self.defaults[:path_names][:new]
-          @new_path  ||= "#{path}/#{new_action}"
-        end
-
-        def shallow_path_prefix
-          @shallow_path_prefix ||= @options[:shallow] ? @options[:namespace].try(:sub, /\/$/, '') : path_prefix
-        end
-
-        def member_path
-          @member_path ||= "#{shallow_path_prefix}/#{path_segment}/:id"
-        end
-
-        def nesting_path_prefix
-          @nesting_path_prefix ||= "#{shallow_path_prefix}/#{path_segment}/:#{singular}_id"
-        end
-
-        def shallow_name_prefix
-          @shallow_name_prefix ||= @options[:shallow] ? @options[:namespace].try(:gsub, /\//, '_') : name_prefix
-        end
-
-        def nesting_name_prefix
-          "#{shallow_name_prefix}#{singular}_"
-        end
-
-        def action_separator
-          @action_separator ||= ActionController::Base.resource_action_separator
-        end
-
-        def uncountable?
-          @singular.to_s == @plural.to_s
-        end
-
-        def has_action?(action)
-          !DEFAULT_ACTIONS.include?(action) || action_allowed?(action)
-        end
-
-        protected
-          def arrange_actions
-            @collection_methods = arrange_actions_by_methods(options.delete(:collection))
-            @member_methods     = arrange_actions_by_methods(options.delete(:member))
-            @new_methods        = arrange_actions_by_methods(options.delete(:new))
-          end
-
-          def add_default_actions
-            add_default_action(member_methods, :get, :edit)
-            add_default_action(new_methods, :get, :new)
-          end
-
-          def set_allowed_actions
-            only, except = @options.values_at(:only, :except)
-            @allowed_actions ||= {}
-
-            if only == :all || except == :none
-              only = nil
-              except = []
-            elsif only == :none || except == :all
-              only = []
-              except = nil
-            end
-
-            if only
-              @allowed_actions[:only] = Array(only).map {|a| a.to_sym }
-            elsif except
-              @allowed_actions[:except] = Array(except).map {|a| a.to_sym }
-            end
-          end
-
-          def action_allowed?(action)
-            only, except = @allowed_actions.values_at(:only, :except)
-            (!only || only.include?(action)) && (!except || !except.include?(action))
-          end
-
-          def set_prefixes
-            @path_prefix = options.delete(:path_prefix)
-            @name_prefix = options.delete(:name_prefix)
-          end
-
-          def arrange_actions_by_methods(actions)
-            (actions || {}).inject({}) do |flipped_hash, (key, value)|
-              (flipped_hash[value] ||= []) << key
-              flipped_hash
-            end
-          end
-
-          def add_default_action(collection, method, action)
-            (collection[method] ||= []).unshift(action)
-          end
-      end
-
-      class SingletonResource < Resource #:nodoc:
-        def initialize(entity, options, defaults)
-          @singular = @plural = entity
-          options[:controller] ||= @singular.to_s.pluralize
-          super
-        end
-
-        alias_method :shallow_path_prefix, :path_prefix
-        alias_method :shallow_name_prefix, :name_prefix
-        alias_method :member_path,         :path
-        alias_method :nesting_path_prefix, :path
-      end
-
-      def resources(*entities, &block)
-        options = entities.extract_options!
-        entities.each { |entity| map_resource(entity, options.dup, &block) }
-      end
-
-      def resource(*entities, &block)
-        options = entities.extract_options!
-        entities.each { |entity| map_singleton_resource(entity, options.dup, &block) }
-      end
-
-      private
-        def map_resource(entities, options = {}, &block)
-          resource = Resource.new(entities, options, :path_names => @set.resources_path_names)
-
-          with_options :controller => resource.controller do |map|
-            map_associations(resource, options)
-
-            if block_given?
-              with_options(options.slice(*INHERITABLE_OPTIONS).merge(:path_prefix => resource.nesting_path_prefix, :name_prefix => resource.nesting_name_prefix), &block)
-            end
-
-            map_collection_actions(map, resource)
-            map_default_collection_actions(map, resource)
-            map_new_actions(map, resource)
-            map_member_actions(map, resource)
-          end
-        end
-
-        def map_singleton_resource(entities, options = {}, &block)
-          resource = SingletonResource.new(entities, options, :path_names => @set.resources_path_names)
-
-          with_options :controller => resource.controller do |map|
-            map_associations(resource, options)
-
-            if block_given?
-              with_options(options.slice(*INHERITABLE_OPTIONS).merge(:path_prefix => resource.nesting_path_prefix, :name_prefix => resource.nesting_name_prefix), &block)
-            end
-
-            map_collection_actions(map, resource)
-            map_new_actions(map, resource)
-            map_member_actions(map, resource)
-            map_default_singleton_actions(map, resource)
-          end
-        end
-
-        def map_associations(resource, options)
-          map_has_many_associations(resource, options.delete(:has_many), options) if options[:has_many]
-
-          path_prefix = "#{options.delete(:path_prefix)}#{resource.nesting_path_prefix}"
-          name_prefix = "#{options.delete(:name_prefix)}#{resource.nesting_name_prefix}"
-
-          Array(options[:has_one]).each do |association|
-            resource(association, options.slice(*INHERITABLE_OPTIONS).merge(:path_prefix => path_prefix, :name_prefix => name_prefix))
-          end
-        end
-
-        def map_has_many_associations(resource, associations, options)
-          case associations
-          when Hash
-            associations.each do |association,has_many|
-              map_has_many_associations(resource, association, options.merge(:has_many => has_many))
-            end
-          when Array
-            associations.each do |association|
-              map_has_many_associations(resource, association, options)
-            end
-          when Symbol, String
-            resources(associations, options.slice(*INHERITABLE_OPTIONS).merge(:path_prefix => resource.nesting_path_prefix, :name_prefix => resource.nesting_name_prefix, :has_many => options[:has_many]))
-          else
-          end
-        end
-
-        def map_collection_actions(map, resource)
-          resource.collection_methods.each do |method, actions|
-            actions.each do |action|
-              [method].flatten.each do |m|
-                action_path = resource.options[:path_names][action] if resource.options[:path_names].is_a?(Hash)
-                action_path ||= action
-
-                map_resource_routes(map, resource, action, "#{resource.path}#{resource.action_separator}#{action_path}", "#{action}_#{resource.name_prefix}#{resource.plural}", m)
-              end
-            end
-          end
-        end
-
-        def map_default_collection_actions(map, resource)
-          index_route_name = "#{resource.name_prefix}#{resource.plural}"
-
-          if resource.uncountable?
-            index_route_name << "_index"
-          end
-
-          map_resource_routes(map, resource, :index, resource.path, index_route_name)
-          map_resource_routes(map, resource, :create, resource.path, index_route_name)
-        end
-
-        def map_default_singleton_actions(map, resource)
-          map_resource_routes(map, resource, :create, resource.path, "#{resource.shallow_name_prefix}#{resource.singular}")
-        end
-
-        def map_new_actions(map, resource)
-          resource.new_methods.each do |method, actions|
-            actions.each do |action|
-              route_path = resource.new_path
-              route_name = "new_#{resource.name_prefix}#{resource.singular}"
-
-              unless action == :new
-                route_path = "#{route_path}#{resource.action_separator}#{action}"
-                route_name = "#{action}_#{route_name}"
-              end
-
-              map_resource_routes(map, resource, action, route_path, route_name, method)
-            end
-          end
-        end
-
-        def map_member_actions(map, resource)
-          resource.member_methods.each do |method, actions|
-            actions.each do |action|
-              [method].flatten.each do |m|
-                action_path = resource.options[:path_names][action] if resource.options[:path_names].is_a?(Hash)
-                action_path ||= @set.resources_path_names[action] || action
-
-                map_resource_routes(map, resource, action, "#{resource.member_path}#{resource.action_separator}#{action_path}", "#{action}_#{resource.shallow_name_prefix}#{resource.singular}", m, { :force_id => true })
-              end
-            end
-          end
-
-          route_path = "#{resource.shallow_name_prefix}#{resource.singular}"
-          map_resource_routes(map, resource, :show, resource.member_path, route_path)
-          map_resource_routes(map, resource, :update, resource.member_path, route_path)
-          map_resource_routes(map, resource, :destroy, resource.member_path, route_path)
-        end
-
-        def map_resource_routes(map, resource, action, route_path, route_name = nil, method = nil, resource_options = {} )
-          if resource.has_action?(action)
-            action_options = action_options_for(action, resource, method, resource_options)
-            formatted_route_path = "#{route_path}.:format"
-
-            if route_name && @set.named_routes[route_name.to_sym].nil?
-              map.named_route(route_name, formatted_route_path, action_options)
-            else
-              map.connect(formatted_route_path, action_options)
-            end
-          end
-        end
-
-        def add_conditions_for(conditions, method)
-          {:conditions => conditions.dup}.tap do |options|
-            options[:conditions][:method] = method unless method == :any
-          end
-        end
-
-        def action_options_for(action, resource, method = nil, resource_options = {})
-          default_options = { :action => action.to_s }
-          require_id = !resource.kind_of?(SingletonResource)
-          force_id = resource_options[:force_id] && !resource.kind_of?(SingletonResource)
-
-          case default_options[:action]
-            when "index", "new"; default_options.merge(add_conditions_for(resource.conditions, method || :get)).merge(resource.requirements)
-            when "create";       default_options.merge(add_conditions_for(resource.conditions, method || :post)).merge(resource.requirements)
-            when "show", "edit"; default_options.merge(add_conditions_for(resource.conditions, method || :get)).merge(resource.requirements(require_id))
-            when "update";       default_options.merge(add_conditions_for(resource.conditions, method || :put)).merge(resource.requirements(require_id))
-            when "destroy";      default_options.merge(add_conditions_for(resource.conditions, method || :delete)).merge(resource.requirements(require_id))
-            else                 default_options.merge(add_conditions_for(resource.conditions, method)).merge(resource.requirements(force_id))
-          end
-        end
-    end
-  end
-end
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index c118c72440..14c424f24b 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -1,6 +1,8 @@
 require 'erb'
 require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/object/blank'
+require 'active_support/inflector'
+require 'action_dispatch/routing/redirection'
 
 module ActionDispatch
   module Routing
@@ -20,27 +22,37 @@ module ActionDispatch
           @app, @constraints, @request = app, constraints, request
         end
 
-        def call(env)
+        def matches?(env)
           req = @request.new(env)
 
           @constraints.each { |constraint|
             if constraint.respond_to?(:matches?) && !constraint.matches?(req)
-              return [ 404, {'X-Cascade' => 'pass'}, [] ]
-            elsif constraint.respond_to?(:call) && !constraint.call(req)
-              return [ 404, {'X-Cascade' => 'pass'}, [] ]
+              return false
+            elsif constraint.respond_to?(:call) && !constraint.call(*constraint_args(constraint, req))
+              return false
             end
           }
 
-          @app.call(env)
+          return true
+        end
+
+        def call(env)
+          matches?(env) ? @app.call(env) : [ 404, {'X-Cascade' => 'pass'}, [] ]
         end
+
+        private
+          def constraint_args(constraint, request)
+            constraint.arity == 1 ? [request] : [request.symbolized_path_parameters, request]
+          end
       end
 
       class Mapping #:nodoc:
         IGNORE_OPTIONS = [:to, :as, :via, :on, :constraints, :defaults, :only, :except, :anchor, :shallow, :shallow_path, :shallow_prefix]
 
-        def initialize(set, scope, args)
-          @set, @scope    = set, scope
-          @path, @options = extract_path_and_options(args)
+        def initialize(set, scope, path, options)
+          @set, @scope = set, scope
+          @options = (@scope[:options] || {}).merge(options)
+          @path = normalize_path(path)
           normalize_options!
         end
 
@@ -49,28 +61,6 @@ module ActionDispatch
         end
 
         private
-          def extract_path_and_options(args)
-            options = args.extract_options!
-
-            if using_to_shorthand?(args, options)
-              path, to = options.find { |name, value| name.is_a?(String) }
-              options.merge!(:to => to).delete(path) if path
-            else
-              path = args.first
-            end
-
-            if path.match(':controller')
-              raise ArgumentError, ":controller segment is not allowed within a namespace block" if @scope[:module]
-
-              # Add a default constraint for :controller path segments that matches namespaced
-              # controllers with default routes like :controller/:action/:id(.:format), e.g:
-              # GET /admin/products/show/1
-              # => { :controller => 'admin/products', :action => 'show', :id => '1' }
-              options.reverse_merge!(:controller => /.+?/)
-            end
-
-            [ normalize_path(path), options ]
-          end
 
           def normalize_options!
             path_without_format = @path.sub(/\(\.:format\)$/, '')
@@ -78,15 +68,21 @@ 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[:as] ||= path_without_format[1..-1].gsub("/", "_")
             end
 
             @options.merge!(default_controller_and_action(to_shorthand))
-          end
 
-          # match "account" => "account#index"
-          def using_to_shorthand?(args, options)
-            args.empty? && options.present?
+            requirements.each do |name, requirement|
+              # segment_keys.include?(k.to_s) || k == :controller
+              next unless Regexp === requirement && !constraints[name]
+
+              if requirement.source =~ %r{\A(\\A|\^)|(\\Z|\\z|\$)\Z}
+                raise ArgumentError, "Regexp anchor characters are not allowed in routing requirements: #{requirement.inspect}"
+              end
+              if requirement.multiline?
+                raise ArgumentError, "Regexp multiline option not allowed in routing requirements: #{requirement.inspect}"
+              end
+            end
           end
 
           # match "account/overview"
@@ -95,8 +91,27 @@ module ActionDispatch
           end
 
           def normalize_path(path)
-            raise ArgumentError, "path is required" if @scope[:path].blank? && path.blank?
-            Mapper.normalize_path("#{@scope[:path]}/#{path}")
+            raise ArgumentError, "path is required" if path.blank?
+            path = Mapper.normalize_path(path)
+
+            if path.match(':controller')
+              raise ArgumentError, ":controller segment is not allowed within a namespace block" if @scope[:module]
+
+              # Add a default constraint for :controller path segments that matches namespaced
+              # controllers with default routes like :controller/:action/:id(.:format), e.g:
+              # GET /admin/products/show/1
+              # => { :controller => 'admin/products', :action => 'show', :id => '1' }
+              @options.reverse_merge!(:controller => /.+?/)
+            end
+
+            if @options[:format] == false
+              @options.delete(:format)
+              path
+            elsif path.include?(":format") || path.end_with?('/') || path.match(/^\/?\*/)
+              path
+            else
+              "#{path}(.:format)"
+            end
           end
 
           def app
@@ -142,6 +157,10 @@ module ActionDispatch
                 controller = [@scope[:module], controller].compact.join("/").presence
               end
 
+              if controller.is_a?(String) && controller =~ %r{\A/}
+                raise ArgumentError, "controller name should not start with a slash"
+              end
+
               controller = controller.to_s unless controller.is_a?(Regexp)
               action     = action.to_s     unless action.is_a?(Regexp)
 
@@ -153,21 +172,21 @@ module ActionDispatch
                 raise ArgumentError, "missing :action"
               end
 
-              { :controller => controller, :action => action }.tap do |hash|
-                hash.delete(:controller) if hash[:controller].blank?
-                hash.delete(:action)     if hash[:action].blank?
-              end
+              hash = {}
+              hash[:controller] = controller unless controller.blank?
+              hash[:action]     = action unless action.blank?
+              hash
             end
           end
 
           def blocks
+            block = @scope[:blocks] || []
+
             if @options[:constraints].present? && !@options[:constraints].is_a?(Hash)
-              block = @options[:constraints]
-            else
-              block = nil
+              block << @options[:constraints]
             end
 
-            ((@scope[:blocks] || []) + [ block ]).compact
+            block
           end
 
           def constraints
@@ -176,8 +195,8 @@ module ActionDispatch
 
           def request_method_condition
             if via = @options[:via]
-              via = Array(via).map { |m| m.to_s.upcase }
-              { :request_method => Regexp.union(*via) }
+              list = Array(via).map { |m| m.to_s.dasherize.upcase }
+              { :request_method => list }
             else
               { }
             end
@@ -219,21 +238,165 @@ module ActionDispatch
         path
       end
 
-      module Base
-        def initialize(set) #:nodoc:
-          @set = set
-        end
+      def self.normalize_name(name)
+        normalize_path(name)[1..-1].gsub("/", "_")
+      end
 
+      module Base
+        # You can specify what Rails should route "/" to with the root method:
+        #
+        #   root :to => 'pages#main'
+        #
+        # For options, see +match+, as +root+ uses it internally.
+        #
+        # You should put the root route at the top of <tt>config/routes.rb</tt>,
+        # because this means it will be matched first. As this is the most popular route
+        # of most Rails applications, this is beneficial.
         def root(options = {})
           match '/', options.reverse_merge(:as => :root)
         end
 
-        def match(*args)
-          mapping = Mapping.new(@set, @scope, args).to_route
-          @set.add_route(*mapping)
+        # Matches a url pattern to one or more routes. Any symbols in a pattern
+        # are interpreted as url query parameters and thus available as +params+
+        # in an action:
+        #
+        #   # sets :controller, :action and :id in params
+        #   match ':controller/:action/:id'
+        #
+        # Two of these symbols are special, +:controller+ maps to the controller
+        # and +:action+ to the controller's action. A pattern can also map
+        # wildcard segments (globs) to params:
+        #
+        #   match 'songs/*category/:title' => 'songs#show'
+        #
+        #   # 'songs/rock/classic/stairway-to-heaven' sets
+        #   #  params[:category] = 'rock/classic'
+        #   #  params[:title] = 'stairway-to-heaven'
+        #
+        # When a pattern points to an internal route, the route's +:action+ and
+        # +:controller+ should be set in options or hash shorthand. Examples:
+        #
+        #   match 'photos/:id' => 'photos#show'
+        #   match 'photos/:id', :to => 'photos#show'
+        #   match 'photos/:id', :controller => 'photos', :action => 'show'
+        #
+        # 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' => PhotoRackApp
+        #   # Yes, controller actions are just rack endpoints
+        #   match 'photos/:id' => PhotosController.action(:show)
+        #
+        # === Options
+        #
+        # Any options not seen here are passed on as params with the url.
+        #
+        # [:controller]
+        #   The route's controller.
+        #
+        # [:action]
+        #   The route's action.
+        #
+        # [:path]
+        #   The path prefix for the routes.
+        #
+        # [:module]
+        #   The namespace for :controller.
+        #
+        #     match 'path' => 'c#a', :module => 'sekret', :controller => 'posts'
+        #     #=> Sekret::PostsController
+        #
+        #   See <tt>Scoping#namespace</tt> for its scope equivalent.
+        #
+        # [:as]
+        #   The name used to generate routing helpers.
+        #
+        # [:via]
+        #   Allowed HTTP verb(s) for route.
+        #
+        #      match 'path' => 'c#a', :via => :get
+        #      match 'path' => 'c#a', :via => [:get, :post]
+        #
+        # [:to]
+        #   Points to a +Rack+ endpoint. Can be an object that responds to
+        #   +call+ or a string representing a controller's action.
+        #
+        #      match 'path', :to => 'controller#action'
+        #      match 'path', :to => lambda { [200, {}, "Success!"] }
+        #      match 'path', :to => RackApp
+        #
+        # [:on]
+        #   Shorthand for wrapping routes in a specific RESTful context. Valid
+        #   values are :member, :collection, and :new.  Only use within
+        #   <tt>resource(s)</tt> block. For example:
+        #
+        #      resource :bar do
+        #        match 'foo' => 'c#a', :on => :member, :via => [:get, :post]
+        #      end
+        #
+        #   Is equivalent to:
+        #
+        #      resource :bar do
+        #        member do
+        #          match 'foo' => 'c#a', :via => [:get, :post]
+        #        end
+        #      end
+        #
+        # [:constraints]
+        #   Constrains parameters with a hash of regular expressions or an
+        #   object that responds to #matches?
+        #
+        #     match 'path/:id', :constraints => { :id => /[A-Z]\d{5}/ }
+        #
+        #     class Blacklist
+        #       def matches?(request) request.remote_ip == '1.2.3.4' end
+        #     end
+        #     match 'path' => 'c#a', :constraints => Blacklist.new
+        #
+        #   See <tt>Scoping#constraints</tt> for more examples with its scope
+        #   equivalent.
+        #
+        # [:defaults]
+        #   Sets defaults for parameters
+        #
+        #     # Sets params[:format] to 'jpg' by default
+        #     match 'path' => 'c#a', :defaults => { :format => 'jpg' }
+        #
+        #   See <tt>Scoping#defaults</tt> for its scope equivalent.
+        #
+        # [:anchor]
+        #   Boolean to anchor a #match pattern. Default is true. When set to
+        #   false, the pattern matches any request prefixed with the given path.
+        #
+        #     # 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.
+        #
+        #   mount SomeRackApp, :at => "some_route"
+        #
+        # Alternatively:
+        #
+        #   mount(SomeRackApp => "some_route")
+        #
+        # For options, see +match+, as +mount+ uses it internally.
+        #
+        # All mounted applications come with routing helpers to access them.
+        # These are named after the class specified, so for the above example
+        # the helper is either +some_rack_app_path+ or +some_rack_app_url+.
+        # To customize this helper's name, use the +:as+ option:
+        #
+        #   mount(SomeRackApp => "some_route", :as => "exciting")
+        #
+        # This will generate the +exciting_path+ and +exciting_url+ helpers
+        # which can be used to navigate to this mounted app.
         def mount(app, options = nil)
           if options
             path = options.delete(:at)
@@ -245,7 +408,11 @@ module ActionDispatch
 
           raise "A rack application must be specified" unless path
 
-          match(path, options.merge(:to => app, :anchor => false))
+          options[:as] ||= app_name(app)
+
+          match(path, options.merge(:to => app, :anchor => false, :format => false))
+
+          define_generate_prefix(app, options[:as])
           self
         end
 
@@ -253,55 +420,83 @@ module ActionDispatch
           @set.default_url_options = options
         end
         alias_method :default_url_options, :default_url_options=
+
+        def with_default_scope(scope, &block)
+          scope(scope) do
+            instance_exec(&block)
+          end
+        end
+
+        private
+          def app_name(app)
+            return unless app.respond_to?(:routes)
+
+            if app.respond_to?(:railtie_name)
+              app.railtie_name
+            else
+              class_name = app.class.is_a?(Class) ? app.name : app.class.name
+              ActiveSupport::Inflector.underscore(class_name).gsub("/", "_")
+            end
+          end
+
+          def define_generate_prefix(app, name)
+            return unless app.respond_to?(:routes) && app.routes.respond_to?(:define_mounted_helper)
+
+            _route = @set.named_routes.routes[name.to_sym]
+            _routes = @set
+            app.routes.define_mounted_helper(name)
+            app.routes.class_eval do
+              define_method :_generate_prefix do |options|
+                prefix_options = options.slice(*_route.segment_keys)
+                # we must actually delete prefix segment keys to avoid passing them to next url_for
+                _route.segment_keys.each { |k| options.delete(k) }
+                _routes.url_helpers.send("#{name}_path", prefix_options)
+              end
+            end
+          end
       end
 
       module HttpHelpers
+        # Define a route that only recognizes HTTP GET.
+        # For supported arguments, see <tt>Base#match</tt>.
+        #
+        # Example:
+        #
+        # get 'bacon', :to => 'food#bacon'
         def get(*args, &block)
           map_method(:get, *args, &block)
         end
 
+        # Define a route that only recognizes HTTP POST.
+        # For supported arguments, see <tt>Base#match</tt>.
+        #
+        # Example:
+        #
+        # post 'bacon', :to => 'food#bacon'
         def post(*args, &block)
           map_method(:post, *args, &block)
         end
 
+        # Define a route that only recognizes HTTP PUT.
+        # For supported arguments, see <tt>Base#match</tt>.
+        #
+        # Example:
+        #
+        # put 'bacon', :to => 'food#bacon'
         def put(*args, &block)
           map_method(:put, *args, &block)
         end
 
+        # Define a route that only recognizes HTTP PUT.
+        # For supported arguments, see <tt>Base#match</tt>.
+        #
+        # Example:
+        #
+        # delete 'broccoli', :to => 'food#broccoli'
         def delete(*args, &block)
           map_method(:delete, *args, &block)
         end
 
-        def redirect(*args, &block)
-          options = args.last.is_a?(Hash) ? args.pop : {}
-
-          path      = args.shift || block
-          path_proc = path.is_a?(Proc) ? path : proc { |params| path % params }
-          status    = options[:status] || 301
-
-          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.port == 80
-
-            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
-
         private
           def map_method(method, *args, &block)
             options = args.extract_options!
@@ -312,28 +507,98 @@ module ActionDispatch
           end
       end
 
+      # You may wish to organize groups of controllers under a namespace.
+      # Most commonly, you might group a number of administrative controllers
+      # under an +admin+ namespace. You would place these controllers under
+      # the app/controllers/admin directory, and you can group them together
+      # in your router:
+      #
+      #   namespace "admin" do
+      #     resources :posts, :comments
+      #   end
+      #
+      # This will create a number of routes for each of the posts and comments
+      # controller. For Admin::PostsController, Rails will create:
+      #
+      #   GET	    /admin/posts
+      #   GET	    /admin/posts/new
+      #   POST	  /admin/posts
+      #   GET	    /admin/posts/1
+      #   GET	    /admin/posts/1/edit
+      #   PUT	    /admin/posts/1
+      #   DELETE  /admin/posts/1
+      #
+      # If you want to route /posts (without the prefix /admin) to
+      # Admin::PostsController, you could use
+      #
+      #   scope :module => "admin" do
+      #     resources :posts
+      #   end
+      #
+      # or, for a single case
+      #
+      #   resources :posts, :module => "admin"
+      #
+      # If you want to route /admin/posts to PostsController
+      # (without the Admin:: module prefix), you could use
+      #
+      #   scope "/admin" do
+      #     resources :posts
+      #   end
+      #
+      # or, for a single case
+      #
+      #   resources :posts, :path => "/admin"
+      #
+      # In each of these cases, the named routes remain the same as if you did
+      # not use scope. In the last case, the following paths map to
+      # PostsController:
+      #
+      #   GET	    /admin/posts
+      #   GET	    /admin/posts/new
+      #   POST	  /admin/posts
+      #   GET	    /admin/posts/1
+      #   GET	    /admin/posts/1/edit
+      #   PUT	    /admin/posts/1
+      #   DELETE  /admin/posts/1
       module Scoping
-        def initialize(*args) #:nodoc:
-          @scope = {}
-          super
-        end
-
+        # Scopes a set of routes to the given default options.
+        #
+        # Take the following route definition as an example:
+        #
+        #   scope :path => ":account_id", :as => "account" do
+        #     resources :projects
+        #   end
+        #
+        # This generates helpers such as +account_projects_path+, just like +resources+ does.
+        # The difference here being that the routes generated are like /rails/projects/2,
+        # rather than /accounts/rails/projects/2.
+        #
+        # === Options
+        #
+        # Takes same options as <tt>Base#match</tt> and <tt>Resources#resources</tt>.
+        #
+        # === Examples
+        #
+        #   # route /posts (without the prefix /admin) to Admin::PostsController
+        #   scope :module => "admin" do
+        #     resources :posts
+        #   end
+        #
+        #   # prefix the posts resource's requests with '/admin'
+        #   scope :path => "/admin" do
+        #     resources :posts
+        #   end
+        #
+        #   # prefix the routing helper name: sekret_posts_path instead of posts_path
+        #   scope :as => "sekret" do
+        #     resources :posts
+        #   end
         def scope(*args)
           options = args.extract_options!
           options = options.dup
 
-          if name_prefix = options.delete(:name_prefix)
-            options[:as] ||= name_prefix
-            ActiveSupport::Deprecation.warn ":name_prefix was deprecated in the new router syntax. Use :as instead.", caller
-          end
-
-          case args.first
-          when String
-            options[:path] = args.first
-          when Symbol
-            options[:controller] = args.first
-          end
-
+          options[:path] = args.first if args.first.is_a?(String)
           recover = {}
 
           options[:constraints] ||= {}
@@ -365,10 +630,57 @@ module ActionDispatch
           @scope[:blocks]  = recover[:block]
         end
 
-        def controller(controller)
-          scope(controller.to_sym) { yield }
+        # Scopes routes to a specific controller
+        #
+        # Example:
+        #   controller "food" do
+        #     match "bacon", :action => "bacon"
+        #   end
+        def controller(controller, options={})
+          options[:controller] = controller
+          scope(options) { yield }
         end
 
+        # Scopes routes to a specific namespace. For example:
+        #
+        #   namespace :admin do
+        #     resources :posts
+        #   end
+        #
+        # This generates the following routes:
+        #
+        #       admin_posts GET    /admin/posts(.:format)          {:action=>"index", :controller=>"admin/posts"}
+        #       admin_posts POST   /admin/posts(.:format)          {:action=>"create", :controller=>"admin/posts"}
+        #    new_admin_post GET    /admin/posts/new(.:format)      {:action=>"new", :controller=>"admin/posts"}
+        #   edit_admin_post GET    /admin/posts/:id/edit(.:format) {:action=>"edit", :controller=>"admin/posts"}
+        #        admin_post GET    /admin/posts/:id(.:format)      {:action=>"show", :controller=>"admin/posts"}
+        #        admin_post PUT    /admin/posts/:id(.:format)      {:action=>"update", :controller=>"admin/posts"}
+        #        admin_post DELETE /admin/posts/:id(.:format)      {:action=>"destroy", :controller=>"admin/posts"}
+        #
+        # === Options
+        #
+        # The +:path+, +:as+, +:module+, +:shallow_path+ and +:shallow_prefix+
+        # options all default to the name of the namespace.
+        #
+        # For options, see <tt>Base#match</tt>. For +:shallow_path+ option, see
+        # <tt>Resources#resources</tt>.
+        #
+        # === Examples
+        #
+        #   # accessible through /sekret/posts rather than /admin/posts
+        #   namespace :admin, :path => "sekret" do
+        #     resources :posts
+        #   end
+        #
+        #   # maps to Sekret::PostsController rather than Admin::PostsController
+        #   namespace :admin, :module => "sekret" do
+        #     resources :posts
+        #   end
+        #
+        #   # generates sekret_posts_path rather than admin_posts_path
+        #   namespace :admin, :as => "sekret" do
+        #     resources :posts
+        #   end
         def namespace(path, options = {})
           path = path.to_s
           options = { :path => path, :as => path, :module => path,
@@ -376,95 +688,178 @@ module ActionDispatch
           scope(options) { yield }
         end
 
+        # === Parameter Restriction
+        # 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
+        #     resources :posts
+        #   end
+        #
+        # Now routes such as +/posts/1+ will no longer be valid, but +/posts/1.1+ will be.
+        # The +id+ parameter must match the constraint passed in for this example.
+        #
+        # You may use this to also restrict other parameters:
+        #
+        #   resources :posts do
+        #     constraints(:post_id => /\d+\.\d+) do
+        #       resources :comments
+        #     end
+        #
+        # === Restricting based on IP
+        #
+        # Routes can also be constrained to an IP or a certain range of IP addresses:
+        #
+        #   constraints(:ip => /192.168.\d+.\d+/) do
+        #     resources :posts
+        #   end
+        #
+        # Any user connecting from the 192.168.* range will be able to see this resource,
+        # where as any user connecting outside of this range will be told there is no such route.
+        #
+        # === Dynamic request matching
+        #
+        # Requests to routes can be constrained based on specific criteria:
+        #
+        #    constraints(lambda { |req| req.env["HTTP_USER_AGENT"] =~ /iPhone/ }) do
+        #      resources :iphones
+        #    end
+        #
+        # You are able to move this logic out into a class if it is too complex for routes.
+        # This class must have a +matches?+ method defined on it which either returns +true+
+        # if the user should be given access to that route, or +false+ if the user should not.
+        #
+        #    class Iphone
+        #      def self.matches(request)
+        #        request.env["HTTP_USER_AGENT"] =~ /iPhone/
+        #      end
+        #    end
+        #
+        # An expected place for this code would be +lib/constraints+.
+        #
+        # This class is then used like this:
+        #
+        #    constraints(Iphone) do
+        #      resources :iphones
+        #    end
         def constraints(constraints = {})
           scope(:constraints => constraints) { yield }
         end
 
+        # Allows you to set default parameters for a route, such as this:
+        #   defaults :id => 'home' do
+        #     match 'scoped_pages/(:id)', :to => 'pages#show'
+        #   end
+        # Using this, the +:id+ parameter here will default to 'home'.
         def defaults(defaults = {})
           scope(:defaults => defaults) { yield }
         end
 
-        def match(*args)
-          options = args.extract_options!
-
-          options = (@scope[:options] || {}).merge(options)
-
-          if @scope[:as] && !options[:as].blank?
-            options[:as] = "#{@scope[:as]}_#{options[:as]}"
-          elsif @scope[:as] && options[:as] == ""
-            options[:as] = @scope[:as].to_s
-          end
-
-          args.push(options)
-          super(*args)
-        end
-
         private
-          def scope_options
+          def scope_options #:nodoc:
             @scope_options ||= private_methods.grep(/^merge_(.+)_scope$/) { $1.to_sym }
           end
 
-          def merge_path_scope(parent, child)
+          def merge_path_scope(parent, child) #:nodoc:
             Mapper.normalize_path("#{parent}/#{child}")
           end
 
-          def merge_shallow_path_scope(parent, child)
+          def merge_shallow_path_scope(parent, child) #:nodoc:
             Mapper.normalize_path("#{parent}/#{child}")
           end
 
-          def merge_as_scope(parent, child)
+          def merge_as_scope(parent, child) #:nodoc:
             parent ? "#{parent}_#{child}" : child
           end
 
-          def merge_shallow_prefix_scope(parent, child)
+          def merge_shallow_prefix_scope(parent, child) #:nodoc:
             parent ? "#{parent}_#{child}" : child
           end
 
-          def merge_module_scope(parent, child)
+          def merge_module_scope(parent, child) #:nodoc:
             parent ? "#{parent}/#{child}" : child
           end
 
-          def merge_controller_scope(parent, child)
+          def merge_controller_scope(parent, child) #:nodoc:
             child
           end
 
-          def merge_path_names_scope(parent, child)
+          def merge_path_names_scope(parent, child) #:nodoc:
             merge_options_scope(parent, child)
           end
 
-          def merge_constraints_scope(parent, child)
+          def merge_constraints_scope(parent, child) #:nodoc:
             merge_options_scope(parent, child)
           end
 
-          def merge_defaults_scope(parent, child)
+          def merge_defaults_scope(parent, child) #:nodoc:
             merge_options_scope(parent, child)
           end
 
-          def merge_blocks_scope(parent, child)
+          def merge_blocks_scope(parent, child) #:nodoc:
             merged = parent ? parent.dup : []
             merged << child if child
             merged
           end
 
-          def merge_options_scope(parent, child)
+          def merge_options_scope(parent, child) #:nodoc:
             (parent || {}).except(*override_keys(child)).merge(child)
           end
 
-          def merge_shallow_scope(parent, child)
+          def merge_shallow_scope(parent, child) #:nodoc:
             child ? true : false
           end
 
-          def override_keys(child)
+          def override_keys(child) #:nodoc:
             child.key?(:only) || child.key?(:except) ? [:only, :except] : []
           end
       end
 
+      # Resource routing allows you to quickly declare all of the common routes
+      # for a given resourceful controller. Instead of declaring separate routes
+      # for your +index+, +show+, +new+, +edit+, +create+, +update+ and +destroy+
+      # actions, a resourceful route declares them in a single line of code:
+      #
+      #  resources :photos
+      #
+      # Sometimes, you have a resource that clients always look up without
+      # referencing an ID. A common example, /profile always shows the profile of
+      # the currently logged in user. In this case, you can use a singular resource
+      # to map /profile (rather than /profile/:id) to the show action.
+      #
+      #  resource :profile
+      #
+      # It's common to have resources that are logically children of other
+      # resources:
+      #
+      #   resources :magazines do
+      #     resources :ads
+      #   end
+      #
+      # You may wish to organize groups of controllers under a namespace. Most
+      # commonly, you might group a number of administrative controllers under
+      # an +admin+ namespace. You would place these controllers under the
+      # app/controllers/admin directory, and you can group them together in your
+      # router:
+      #
+      #   namespace "admin" do
+      #     resources :posts, :comments
+      #   end
+      #
+      # By default the :id parameter doesn't accept dots. If you need to
+      # use dots as part of the :id parameter add a constraint which
+      # overrides this restriction, e.g:
+      #
+      #   resources :articles, :id => /[^\/]+/
+      #
+      # This allows any character other than a slash as part of your :id.
+      #
       module Resources
         # CANONICAL_ACTIONS holds all actions that does not need a prefix or
         # a path appended since they fit properly in their scope level.
-        VALID_ON_OPTIONS = [:new, :collection, :member]
-        CANONICAL_ACTIONS = [:index, :create, :new, :show, :update, :destroy]
-        RESOURCE_OPTIONS = [:as, :controller, :path, :only, :except]
+        VALID_ON_OPTIONS  = [:new, :collection, :member]
+        RESOURCE_OPTIONS  = [:as, :controller, :path, :only, :except]
+        CANONICAL_ACTIONS = %w(index create new show update destroy)
 
         class Resource #:nodoc:
           DEFAULT_ACTIONS = [:index, :create, :new, :show, :update, :destroy, :edit]
@@ -473,7 +868,7 @@ module ActionDispatch
 
           def initialize(entities, options = {})
             @name       = entities.to_s
-            @path       = options.delete(:path) || @name
+            @path       = (options.delete(:path) || @name).to_s
             @controller = (options.delete(:controller) || @name).to_s
             @as         = options.delete(:as)
             @options    = options
@@ -498,18 +893,17 @@ module ActionDispatch
           end
 
           def plural
-            name.to_s.pluralize
+            @plural ||= name.to_s
           end
 
           def singular
-            name.to_s.singularize
+            @singular ||= name.to_s.singularize
           end
 
-          def member_name
-            singular
-          end
+          alias :member_name :singular
 
-          # Checks for uncountable plurals, and appends "_index" if they're.
+          # Checks for uncountable plurals, and appends "_index" if the plural 
+          # and singular form are the same.
           def collection_name
             singular == plural ? "#{plural}_index" : plural
           end
@@ -518,9 +912,7 @@ module ActionDispatch
             { :controller => controller }
           end
 
-          def collection_scope
-            path
-          end
+          alias :collection_scope :path
 
           def member_scope
             "#{path}/:id"
@@ -540,33 +932,54 @@ module ActionDispatch
           DEFAULT_ACTIONS = [:show, :create, :update, :destroy, :new, :edit]
 
           def initialize(entities, options)
+            @as         = nil
             @name       = entities.to_s
-            @path       = options.delete(:path) || @name
+            @path       = (options.delete(:path) || @name).to_s
             @controller = (options.delete(:controller) || plural).to_s
             @as         = options.delete(:as)
             @options    = options
           end
 
-          def member_name
-            name
+          def plural
+            @plural ||= name.to_s.pluralize
           end
-          alias :collection_name :member_name
 
-          def member_scope
-            path
+          def singular
+            @singular ||= name.to_s
           end
-          alias :nested_scope :member_scope
-        end
 
-        def initialize(*args) #:nodoc:
-          super
-          @scope[:path_names] = @set.resources_path_names
+          alias :member_name :singular
+          alias :collection_name :singular
+
+          alias :member_scope :path
+          alias :nested_scope :path
         end
 
         def resources_path_names(options)
           @scope[:path_names].merge!(options)
         end
 
+        # Sometimes, you have a resource that clients always look up without
+        # referencing an ID. A common example, /profile always shows the
+        # profile of the currently logged in user. In this case, you can use
+        # a singular resource to map /profile (rather than /profile/:id) to
+        # the show action:
+        #
+        #   resource :geocoder
+        #
+        # creates six different routes in your application, all mapping to
+        # the GeoCoders controller (note that the controller is named after
+        # the plural):
+        #
+        #   GET     /geocoder/new
+        #   POST    /geocoder
+        #   GET     /geocoder
+        #   GET     /geocoder/edit
+        #   PUT     /geocoder
+        #   DELETE  /geocoder
+        #
+        # === Options
+        # Takes same options as +resources+.
         def resource(*resources, &block)
           options = resources.extract_options!
 
@@ -577,25 +990,121 @@ module ActionDispatch
           resource_scope(SingletonResource.new(resources.pop, options)) do
             yield if block_given?
 
-            collection_scope do
+            collection do
               post :create
             end if parent_resource.actions.include?(:create)
 
-            new_scope do
+            new do
               get :new
             end if parent_resource.actions.include?(:new)
 
-            member_scope  do
+            member do
+              get    :edit if parent_resource.actions.include?(:edit)
               get    :show if parent_resource.actions.include?(:show)
               put    :update if parent_resource.actions.include?(:update)
               delete :destroy if parent_resource.actions.include?(:destroy)
-              get    :edit if parent_resource.actions.include?(:edit)
             end
           end
 
           self
         end
 
+        # In Rails, a resourceful route provides a mapping between HTTP verbs
+        # and URLs and controller actions. By convention, each action also maps
+        # to particular CRUD operations in a database. A single entry in the
+        # routing file, such as
+        #
+        #   resources :photos
+        #
+        # creates seven different routes in your application, all mapping to
+        # the Photos controller:
+        #
+        #   GET     /photos/new
+        #   POST    /photos
+        #   GET     /photos/:id
+        #   GET     /photos/:id/edit
+        #   PUT     /photos/:id
+        #   DELETE  /photos/:id
+        #
+        # Resources can also be nested infinitely by using this block syntax:
+        #
+        #   resources :photos do
+        #     resources :comments
+        #   end
+        #
+        # This generates the following comments routes:
+        #
+        #   GET     /photos/:id/comments/new
+        #   POST    /photos/:id/comments
+        #   GET     /photos/:id/comments/:id
+        #   GET     /photos/:id/comments/:id/edit
+        #   PUT     /photos/:id/comments/:id
+        #   DELETE  /photos/:id/comments/:id
+        #
+        # === Options
+        # 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.
+        #
+        #     resources :posts, :path_names => { :new => "brand_new" }
+        #
+        #   The above example will now change /posts/new to /posts/brand_new
+        #
+        # [:only]
+        #   Only generate routes for the given actions.
+        #
+        #     resources :cows, :only => :show
+        #     resources :cows, :only => [:show, :index]
+        #
+        # [:except]
+        #   Generate all routes except for the given actions.
+        #
+        #     resources :cows, :except => :show
+        #     resources :cows, :except => [:show, :index]
+        #
+        # [:shallow]
+        #   Generates shallow routes for nested resource(s). When placed on a parent resource,
+        #   generates shallow routes for all nested resources.
+        #
+        #     resources :posts, :shallow => true do
+        #       resources :comments
+        #     end
+        #
+        #   Is the same as:
+        #
+        #     resources :posts do
+        #       resources :comments
+        #     end
+        #     resources :comments
+        #
+        # [:shallow_path]
+        #   Prefixes nested shallow routes with the specified path.
+        #
+        #   scope :shallow_path => "sekret" do
+        #     resources :posts do
+        #       resources :comments, :shallow => true
+        #     end
+        #   end
+        #
+        #   The +comments+ resource here will have the following routes generated for it:
+        #
+        #     post_comments    GET    /sekret/posts/:post_id/comments(.:format)
+        #     post_comments    POST   /sekret/posts/:post_id/comments(.:format)
+        #     new_post_comment GET    /sekret/posts/:post_id/comments/new(.:format)
+        #     edit_comment     GET    /sekret/comments/:id/edit(.:format)
+        #     comment          GET    /sekret/comments/:id(.:format)
+        #     comment          PUT    /sekret/comments/:id(.:format)
+        #     comment          DELETE /sekret/comments/:id(.:format)
+        #
+        # === Examples
+        #
+        #   # routes call Admin::PostsController
+        #   resources :posts, :module => "admin"
+        #
+        #   # resource actions are at /admin/posts.
+        #   resources :posts, :path => "admin"
         def resources(*resources, &block)
           options = resources.extract_options!
 
@@ -606,43 +1115,70 @@ module ActionDispatch
           resource_scope(Resource.new(resources.pop, options)) do
             yield if block_given?
 
-            collection_scope do
+            collection do
               get  :index if parent_resource.actions.include?(:index)
               post :create if parent_resource.actions.include?(:create)
             end
 
-            new_scope do
+            new do
               get :new
             end if parent_resource.actions.include?(:new)
 
-            member_scope  do
+            member do
+              get    :edit if parent_resource.actions.include?(:edit)
               get    :show if parent_resource.actions.include?(:show)
               put    :update if parent_resource.actions.include?(:update)
               delete :destroy if parent_resource.actions.include?(:destroy)
-              get    :edit if parent_resource.actions.include?(:edit)
             end
           end
 
           self
         end
 
+        # To add a route to the collection:
+        #
+        #   resources :photos do
+        #     collection do
+        #       get 'search'
+        #     end
+        #   end
+        #
+        # This will enable Rails to recognize paths such as <tt>/photos/search</tt>
+        # with GET, and route to the search action of PhotosController. It will also
+        # create the <tt>search_photos_url</tt> and <tt>search_photos_path</tt>
+        # route helpers.
         def collection
-          unless @scope[:scope_level] == :resources
-            raise ArgumentError, "can't use collection outside resources scope"
+          unless resource_scope?
+            raise ArgumentError, "can't use collection outside resource(s) scope"
           end
 
-          collection_scope do
-            yield
+          with_scope_level(:collection) do
+            scope(parent_resource.collection_scope) do
+              yield
+            end
           end
         end
 
+        # To add a member route, add a member block into the resource block:
+        #
+        #   resources :photos do
+        #     member do
+        #       get 'preview'
+        #     end
+        #   end
+        #
+        # This will recognize <tt>/photos/1/preview</tt> with GET, and route to the
+        # preview action of PhotosController. It will also create the
+        # <tt>preview_photo_url</tt> and <tt>preview_photo_path</tt> helpers.
         def member
           unless resource_scope?
             raise ArgumentError, "can't use member outside resource(s) scope"
           end
 
-          member_scope do
-            yield
+          with_scope_level(:member) do
+            scope(parent_resource.member_scope) do
+              yield
+            end
           end
         end
 
@@ -651,8 +1187,10 @@ module ActionDispatch
             raise ArgumentError, "can't use new outside resource(s) scope"
           end
 
-          new_scope do
-            yield
+          with_scope_level(:new) do
+            scope(parent_resource.new_scope(action_path(:new))) do
+              yield
+            end
           end
         end
 
@@ -678,6 +1216,7 @@ module ActionDispatch
           end
         end
 
+        # See ActionDispatch::Routing::Mapper::Scoping#namespace
         def namespace(path, options = {})
           if resource_scope?
             nested { super }
@@ -687,7 +1226,7 @@ module ActionDispatch
         end
 
         def shallow
-          scope(:shallow => true) do
+          scope(:shallow => true, :shallow_path => @scope[:path]) do
             yield
           end
         end
@@ -713,46 +1252,36 @@ module ActionDispatch
             raise ArgumentError, "Unknown scope #{on.inspect} given to :on"
           end
 
-          if @scope[:scope_level] == :resource
+          if @scope[:scope_level] == :resources
+            args.push(options)
+            return nested { match(*args) }
+          elsif @scope[:scope_level] == :resource
             args.push(options)
             return member { match(*args) }
           end
 
-          path = options.delete(:path)
           action = args.first
+          path = path_for_action(action, options.delete(:path))
 
-          if action.is_a?(Symbol)
-            path = path_for_action(action, path)
-            options[:to] ||= action
-            options[:as]   = name_for_action(action, options[:as])
-
-            with_exclusive_scope do
-              return super(path, options)
-            end
-          elsif resource_method_scope?
-            path = path_for_custom_action
-            options[:as] = name_for_action(options[:as]) if options[:as]
-            args.push(options)
-
-            with_exclusive_scope do
-              scope(path) do
-                return super
-              end
-            end
+          if action.to_s =~ /^[\w\/]+$/
+            options[:action] ||= action unless action.to_s.include?("/")
+          else
+            action = nil
           end
 
-          if resource_scope?
-            raise ArgumentError, "can't define route directly in resource(s) scope"
+          if options.key?(:as) && !options[:as]
+            options.delete(:as)
+          else
+            options[:as] = name_for_action(options[:as], action)
           end
 
-          args.push(options)
-          super
+          super(path, options)
         end
 
         def root(options={})
           if @scope[:scope_level] == :resources
-            with_scope_level(:nested) do
-              scope(parent_resource.path, :as => parent_resource.collection_name) do
+            with_scope_level(:root) do
+              scope(parent_resource.path) do
                 super(options)
               end
             end
@@ -767,12 +1296,21 @@ module ActionDispatch
             @scope[:scope_level_resource]
           end
 
-          def apply_common_behavior_for(method, resources, options, &block)
+          def apply_common_behavior_for(method, resources, options, &block) #:nodoc:
             if resources.length > 1
               resources.each { |r| send(method, r, options, &block) }
               return true
             end
 
+            if resource_scope?
+              nested { send(method, resources.pop, options, &block) }
+              return true
+            end
+
+            options.keys.each do |k|
+              (options[:constraints] ||= {})[k] = options.delete(k) if options[k].is_a?(Regexp)
+            end
+
             scope_options = options.slice!(*RESOURCE_OPTIONS)
             unless scope_options.empty?
               scope(scope_options) do
@@ -785,33 +1323,26 @@ module ActionDispatch
               options.merge!(scope_action_options) if scope_action_options?
             end
 
-            if resource_scope?
-              nested do
-                send(method, resources.pop, options, &block)
-              end
-              return true
-            end
-
             false
           end
 
-          def action_options?(options)
+          def action_options?(options) #:nodoc:
             options[:only] || options[:except]
           end
 
-          def scope_action_options?
+          def scope_action_options? #:nodoc:
             @scope[:options].is_a?(Hash) && (@scope[:options][:only] || @scope[:options][:except])
           end
 
-          def scope_action_options
+          def scope_action_options #:nodoc:
             @scope[:options].slice(:only, :except)
           end
 
-          def resource_scope?
+          def resource_scope? #:nodoc:
             [:resource, :resources].include?(@scope[:scope_level])
           end
 
-          def resource_method_scope?
+          def resource_method_scope? #:nodoc:
             [:collection, :member, :new].include?(@scope[:scope_level])
           end
 
@@ -837,7 +1368,7 @@ module ActionDispatch
             @scope[:scope_level_resource] = old_resource
           end
 
-          def resource_scope(resource)
+          def resource_scope(resource) #:nodoc:
             with_scope_level(resource.is_a?(SingletonResource) ? :resource : :resources, resource) do
               scope(parent_resource.resource_scope) do
                 yield
@@ -845,116 +1376,108 @@ module ActionDispatch
             end
           end
 
-          def new_scope
-            with_scope_level(:new) do
-              scope(parent_resource.new_scope(action_path(:new))) do
-                yield
-              end
-            end
-          end
-
-          def collection_scope
-            with_scope_level(:collection) do
-              scope(parent_resource.collection_scope) do
-                yield
-              end
-            end
-          end
-
-          def member_scope
-            with_scope_level(:member) do
-              scope(parent_resource.member_scope) do
-                yield
-              end
-            end
-          end
-
-          def nested_options
+          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
           end
 
-          def id_constraint?
-            @scope[:id].is_a?(Regexp) || (@scope[:constraints] && @scope[:constraints][:id].is_a?(Regexp))
+          def id_constraint? #:nodoc:
+            @scope[:constraints] && @scope[:constraints][:id].is_a?(Regexp)
           end
 
-          def id_constraint
-            @scope[:id] || @scope[:constraints][:id]
+          def id_constraint #:nodoc:
+            @scope[:constraints][:id]
           end
 
-          def canonical_action?(action, flag)
-            flag && CANONICAL_ACTIONS.include?(action)
+          def canonical_action?(action, flag) #:nodoc:
+            flag && resource_method_scope? && CANONICAL_ACTIONS.include?(action.to_s)
           end
 
-          def shallow_scoping?
+          def shallow_scoping? #:nodoc:
             shallow? && @scope[:scope_level] == :member
           end
 
-          def path_for_action(action, path)
+          def path_for_action(action, path) #:nodoc:
             prefix = shallow_scoping? ?
               "#{@scope[:shallow_path]}/#{parent_resource.path}/:id" : @scope[:path]
 
-            if canonical_action?(action, path.blank?)
-              "#{prefix}(.:format)"
-            else
-              "#{prefix}/#{action_path(action, path)}(.:format)"
-            end
-          end
-
-          def path_for_custom_action
-            if shallow_scoping?
-              "#{@scope[:shallow_path]}/#{parent_resource.path}/:id"
+            path = if canonical_action?(action, path.blank?)
+              prefix.to_s
             else
-              @scope[:path]
+              "#{prefix}/#{action_path(action, path)}"
             end
           end
 
-          def action_path(name, path = nil)
+          def action_path(name, path = nil) #:nodoc:
             path || @scope[:path_names][name.to_sym] || name.to_s
           end
 
-          def prefix_name_for_action(action, as)
-            if as.present?
-              "#{as}_"
-            elsif as
-              ""
+          def prefix_name_for_action(as, action) #:nodoc:
+            if as
+              as.to_s
             elsif !canonical_action?(action, @scope[:scope_level])
-              "#{action}_"
+              action.to_s
             end
           end
 
-          def name_for_action(action, as=nil)
-            prefix = prefix_name_for_action(action, as)
+          def name_for_action(as, action) #:nodoc:
+            prefix = prefix_name_for_action(as, action)
+            prefix = Mapper.normalize_name(prefix) if prefix
             name_prefix = @scope[:as]
 
             if parent_resource
+              return nil if as.nil? && action.nil?
+
               collection_name = parent_resource.collection_name
               member_name = parent_resource.member_name
-              name_prefix = "#{name_prefix}_" if name_prefix.present?
             end
 
-            case @scope[:scope_level]
+            name = case @scope[:scope_level]
+            when :nested
+              [name_prefix, prefix]
             when :collection
-              "#{prefix}#{name_prefix}#{collection_name}"
+              [prefix, name_prefix, collection_name]
             when :new
-              "#{prefix}new_#{name_prefix}#{member_name}"
+              [prefix, :new, name_prefix, member_name]
+            when :member
+              [prefix, shallow_scoping? ? @scope[:shallow_prefix] : name_prefix, member_name]
+            when :root
+              [name_prefix, collection_name, prefix]
             else
-              if shallow_scoping?
-                shallow_prefix = "#{@scope[:shallow_prefix]}_" if @scope[:shallow_prefix].present?
-                "#{prefix}#{shallow_prefix}#{member_name}"
-              else
-                "#{prefix}#{name_prefix}#{member_name}"
-              end
+              [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(*args)
+          if args.size == 1 && args.last.is_a?(Hash)
+            options  = args.pop
+            path, to = options.find { |name, value| name.is_a?(String) }
+            options.merge!(:to => to).delete(path)
+            super(path, options)
+          else
+            super
           end
+        end
+      end
+
+      def initialize(set) #:nodoc:
+        @set = set
+        @scope = { :path_names => @set.resources_path_names }
       end
 
       include Base
       include HttpHelpers
+      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 31dba835ac..82c4fadb50 100644
--- a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
+++ b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
@@ -17,7 +17,7 @@ module ActionDispatch
     #
     # == Usage within the framework
     #
-    # Polymorphic URL helpers are used in a number of places throughout the Rails framework:
+    # Polymorphic URL helpers are used in a number of places throughout the \Rails framework:
     #
     # * <tt>url_for</tt>, so you can use it with a record as the argument, e.g.
     #   <tt>url_for(@article)</tt>;
@@ -42,6 +42,18 @@ module ActionDispatch
     #
     #   edit_polymorphic_path(@post)              # => "/posts/1/edit"
     #   polymorphic_path(@post, :format => :pdf)  # => "/posts/1.pdf"
+    #
+    # == Using with mounted engines
+    #
+    # If you use mounted engine, there is a possibility that you will need to use
+    # polymorphic_url pointing at engine's routes. To do that, just pass proxy used
+    # to reach engine's routes as a first argument:
+    #
+    # For example:
+    #
+    # polymorphic_url([blog, @post])  # it will call blog.post_path(@post)
+    # form_for([blog, @post])         # => "/blog/posts/1
+    #
     module PolymorphicRoutes
       # Constructs a call to a named RESTful route for the given record and returns the
       # resulting URL string. For example:
@@ -78,19 +90,20 @@ module ActionDispatch
       def polymorphic_url(record_or_hash_or_array, options = {})
         if record_or_hash_or_array.kind_of?(Array)
           record_or_hash_or_array = record_or_hash_or_array.compact
+          if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
+            proxy = record_or_hash_or_array.shift
+          end
           record_or_hash_or_array = record_or_hash_or_array[0] if record_or_hash_or_array.size == 1
         end
 
         record = extract_record(record_or_hash_or_array)
         record = record.to_model if record.respond_to?(:to_model)
 
-        args = case record_or_hash_or_array
-          when Hash;  [ record_or_hash_or_array ]
-          when Array; record_or_hash_or_array.dup
-          else        [ record_or_hash_or_array ]
-        end
+        args = Array === record_or_hash_or_array ?
+          record_or_hash_or_array.dup :
+          [ record_or_hash_or_array ]
 
-        inflection = if options[:action].to_s == "new"
+        inflection = if options[:action] && options[:action].to_s == "new"
           args.pop
           :singular
         elsif (record.respond_to?(:persisted?) && !record.persisted?)
@@ -111,7 +124,14 @@ module ActionDispatch
           args.last.kind_of?(Hash) ? args.last.merge!(url_options) : args << url_options
         end
 
-        send(named_route, *args)
+        if proxy
+          proxy.send(named_route, *args)
+        else
+          # we need to use url_for, because polymorphic_url can be used in context of other than
+          # current routes (e.g. engine's routes). As named routes from engine are not included
+          # calling engine's named route directly would fail.
+          url_for _routes.url_helpers.__send__("hash_for_#{named_route}", *args)
+        end
       end
 
       # Returns the path component of a URL for the given record. It uses
@@ -146,31 +166,31 @@ module ActionDispatch
         end
 
         def build_named_route_call(records, inflection, options = {})
-          unless records.is_a?(Array)
-            record = extract_record(records)
-            route  = ''
-          else
+          if records.is_a?(Array)
             record = records.pop
-            route = records.inject("") do |string, parent|
+            route = records.map do |parent|
               if parent.is_a?(Symbol) || parent.is_a?(String)
-                string << "#{parent}_"
+                parent
               else
-                string << ActiveModel::Naming.plural(parent).singularize
-                string << "_"
+                ActiveModel::Naming.route_key(parent).singularize
               end
             end
+          else
+            record = extract_record(records)
+            route  = []
           end
 
           if record.is_a?(Symbol) || record.is_a?(String)
-            route << "#{record}_"
+            route << record
           else
-            route << ActiveModel::Naming.plural(record)
-            route = route.singularize if inflection == :singular
-            route << "_"
-            route << "index_" if ActiveModel::Naming.uncountable?(record) && inflection == :plural
+            route << ActiveModel::Naming.route_key(record)
+            route = [route.join("_").singularize] if inflection == :singular
+            route << "index" if ActiveModel::Naming.uncountable?(record) && inflection == :plural
           end
 
-          action_prefix(options) + route + routing_type(options).to_s
+          route << routing_type(options)
+
+          action_prefix(options) + route.join("_")
         end
 
         def extract_record(record_or_hash_or_array)
diff --git a/actionpack/lib/action_dispatch/routing/redirection.rb b/actionpack/lib/action_dispatch/routing/redirection.rb
new file mode 100644
index 0000000000..804991ad5f
--- /dev/null
+++ b/actionpack/lib/action_dispatch/routing/redirection.rb
@@ -0,0 +1,110 @@
+require 'action_dispatch/http/request'
+
+module ActionDispatch
+  module Routing
+    module Redirection
+
+      # Redirect any path to another path:
+      #
+      #   match "/stories" => redirect("/posts")
+      #
+      # You can also use interpolation in the supplied redirect argument:
+      #
+      #   match 'docs/:article', :to => redirect('/wiki/%{article}')
+      #
+      # Alternatively you can use one of the other syntaxes:
+      #
+      # The block version of redirect allows for the easy encapsulation of any logic associated with
+      # the redirect in question. Either the params and request are supplied as arguments, or just
+      # params, depending of how many arguments your block accepts. A string is required as a
+      # return value.
+      #
+      #   match 'jokes/:number', :to => redirect do |params, request|
+      #     path = (params[:number].to_i.even? ? "/wheres-the-beef" : "/i-love-lamp")
+      #     "http://#{request.host_with_port}/#{path}"
+      #   end
+      #
+      # The options version of redirect allows you to supply only the parts of the url which need
+      # to change, it also supports interpolation of the path similar to the first example.
+      #
+      #   match 'stores/:name',       :to => redirect(:subdomain => 'stores', :path => '/%{name}')
+      #   match 'stores/:name(*all)', :to => redirect(:subdomain => 'stores', :path => '/%{name}%{all}')
+      #
+      # Finally, an object which responds to call can be supplied to redirect, allowing you to reuse
+      # common redirect routes. The call method must accept two arguments, params and request, and return
+      # a string.
+      #
+      #   match 'accounts/:name' => redirect(SubdomainRedirector.new('api'))
+      #
+      def redirect(*args, &block)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        status  = options.delete(:status) || 301
+
+        path = args.shift
+
+        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
+
+      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
+
+    end
+  end
+end
\ No newline at end of file
diff --git a/actionpack/lib/action_dispatch/routing/route.rb b/actionpack/lib/action_dispatch/routing/route.rb
index aefebf8f80..a049510182 100644
--- a/actionpack/lib/action_dispatch/routing/route.rb
+++ b/actionpack/lib/action_dispatch/routing/route.rb
@@ -1,3 +1,5 @@
+require 'active_support/core_ext/module/deprecation'
+
 module ActionDispatch
   module Routing
     class Route #:nodoc:
@@ -10,6 +12,8 @@ module ActionDispatch
         @defaults = defaults
         @name = name
 
+        # FIXME: we should not be doing this much work in a constructor.
+
         @requirements = requirements.merge(defaults)
         @requirements.delete(:controller) if @requirements[:controller].is_a?(Regexp)
         @requirements.delete_if { |k, v|
@@ -21,24 +25,22 @@ module ActionDispatch
           conditions[:path_info] = ::Rack::Mount::Strexp.compile(path, requirements, SEPARATORS, anchor)
         end
 
-        @conditions = conditions.inject({}) { |h, (k, v)|
-          h[k] = Rack::Mount::RegexpWithNamedGroups.new(v)
-          h
-        }
+        @verbs = conditions[:request_method] || []
 
+        @conditions = conditions.dup
+
+        # Rack-Mount requires that :request_method be a regular expression.
+        # :request_method represents the HTTP verb that matches this route.
+        #
+        # Here we munge values before they get sent on to rack-mount.
+        @conditions[:request_method] = %r[^#{verb}$] unless @verbs.empty?
+        @conditions[:path_info] = Rack::Mount::RegexpWithNamedGroups.new(@conditions[:path_info]) if @conditions[:path_info]
         @conditions.delete_if{ |k,v| k != :path_info && !valid_condition?(k) }
         @requirements.delete_if{ |k,v| !valid_condition?(k) }
       end
 
       def verb
-        if method = conditions[:request_method]
-          case method
-          when Regexp
-            method.source.upcase
-          else
-            method.to_s.upcase
-          end
-        end
+        @verbs.join '|'
       end
 
       def segment_keys
@@ -48,6 +50,7 @@ module ActionDispatch
       def to_a
         [@app, @conditions, @defaults, @name]
       end
+      deprecate :to_a
 
       def to_s
         @to_s ||= begin
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index d23b580d97..b28f6c2297 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -1,7 +1,8 @@
 require 'rack/mount'
 require 'forwardable'
+require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/to_query'
-require 'action_dispatch/routing/deprecated_mapper'
+require 'active_support/core_ext/hash/slice'
 
 module ActionDispatch
   module Routing
@@ -50,12 +51,13 @@ module ActionDispatch
       private
 
         def controller_reference(controller_param)
+          controller_name = "#{controller_param.camelize}Controller"
+
           unless controller = @controllers[controller_param]
-            controller_name = "#{controller_param.camelize}Controller"
             controller = @controllers[controller_param] =
-              ActiveSupport::Dependencies.ref(controller_name)
+              ActiveSupport::Dependencies.reference(controller_name)
           end
-          controller.get
+          controller.get(controller_name)
         end
 
         def dispatch(controller, action, env)
@@ -67,7 +69,7 @@ module ActionDispatch
         end
 
         def split_glob_param!(params)
-          params[@glob_param] = params[@glob_param].split('/').map { |v| URI.unescape(v) }
+          params[@glob_param] = params[@glob_param].split('/').map { |v| URI.parser.unescape(v) }
         end
       end
 
@@ -158,10 +160,18 @@ module ActionDispatch
 
             # We use module_eval to avoid leaks
             @module.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
-              def #{selector}(options = nil)                                      # def hash_for_users_url(options = nil)
-                options ? #{options.inspect}.merge(options) : #{options.inspect}  #   options ? {:only_path=>false}.merge(options) : {:only_path=>false}
-              end                                                                 # end
-              protected :#{selector}                                              # protected :hash_for_users_url
+              remove_method :#{selector} if method_defined?(:#{selector})
+              def #{selector}(*args)
+                options = args.extract_options!
+
+                if args.any?
+                  options[:_positional_args] = args
+                  options[:_positional_keys] = #{route.segment_keys.inspect}
+                end
+
+                options ? #{options.inspect}.merge(options) : #{options.inspect}
+              end
+              protected :#{selector}
             END_EVAL
             helpers << selector
           end
@@ -184,22 +194,16 @@ module ActionDispatch
             hash_access_method = hash_access_name(name, kind)
 
             @module.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+              remove_method :#{selector} if method_defined?(:#{selector})
               def #{selector}(*args)
-                options =  #{hash_access_method}(args.extract_options!)
-
-                if args.any?
-                  options[:_positional_args] = args
-                  options[:_positional_keys] = #{route.segment_keys.inspect}
-                end
-
-                url_for(options)
+                url_for(#{hash_access_method}(*args))
               end
             END_EVAL
             helpers << selector
           end
       end
 
-      attr_accessor :set, :routes, :named_routes
+      attr_accessor :set, :routes, :named_routes, :default_scope
       attr_accessor :disable_clear_and_finalize, :resources_path_names
       attr_accessor :default_url_options, :request_class, :valid_conditions
 
@@ -211,7 +215,6 @@ module ActionDispatch
         self.routes = []
         self.named_routes = NamedRouteCollection.new
         self.resources_path_names = self.class.default_resources_path_names.dup
-        self.controller_namespaces = Set.new
         self.default_url_options = {}
 
         self.request_class = request_class
@@ -219,27 +222,35 @@ module ActionDispatch
         self.valid_conditions.delete(:id)
         self.valid_conditions.push(:controller, :action)
 
+        @append = []
         @disable_clear_and_finalize = false
         clear!
       end
 
       def draw(&block)
         clear! unless @disable_clear_and_finalize
+        eval_block(block)
+        finalize! unless @disable_clear_and_finalize
 
+        nil
+      end
+
+      def append(&block)
+        @append << block
+      end
+
+      def eval_block(block)
         mapper = Mapper.new(self)
-        if block.arity == 1
-          mapper.instance_exec(DeprecatedMapper.new(self), &block)
+        if default_scope
+          mapper.with_default_scope(default_scope, &block)
         else
           mapper.instance_exec(&block)
         end
-
-        finalize! unless @disable_clear_and_finalize
-
-        nil
       end
 
       def finalize!
         return if @finalized
+        @append.each { |blk| eval_block(blk) }
         @finalized = true
         @set.freeze
       end
@@ -261,6 +272,31 @@ module ActionDispatch
         named_routes.install(destinations, regenerate_code)
       end
 
+      module MountedHelpers
+      end
+
+      def mounted_helpers(name = :main_app)
+        define_mounted_helper(name) if name
+        MountedHelpers
+      end
+
+      def define_mounted_helper(name)
+        return if MountedHelpers.method_defined?(name)
+
+        routes = self
+        MountedHelpers.class_eval do
+          define_method "_#{name}" do
+            RoutesProxy.new(routes, self._routes_context)
+          end
+        end
+
+        MountedHelpers.class_eval <<-RUBY
+          def #{name}
+            @#{name} ||= _#{name}
+          end
+        RUBY
+      end
+
       def url_helpers
         @url_helpers ||= begin
           routes = self
@@ -269,9 +305,9 @@ module ActionDispatch
             extend ActiveSupport::Concern
             include UrlFor
 
-            @routes = routes
+            @_routes = routes
             class << self
-              delegate :url_for, :to => '@routes'
+              delegate :url_for, :to => '@_routes'
             end
             extend routes.named_routes.module
 
@@ -280,10 +316,10 @@ module ActionDispatch
             # Yes plz - JP
             included do
               routes.install_helpers(self)
-              singleton_class.send(:define_method, :_routes) { routes }
+              singleton_class.send(:redefine_method, :_routes) { routes }
             end
 
-            define_method(:_routes) { routes }
+            define_method(:_routes) { @_routes || routes }
           end
 
           helpers
@@ -295,18 +331,31 @@ module ActionDispatch
       end
 
       def add_route(app, conditions = {}, requirements = {}, defaults = {}, name = nil, anchor = true)
+        raise ArgumentError, "Invalid route name: '#{name}'" unless name.blank? || name.to_s.match(/^[_a-z]\w*$/i)
         route = Route.new(self, app, conditions, requirements, defaults, name, anchor)
-        @set.add_route(*route)
+        @set.add_route(route.app, route.conditions, route.defaults, route.name)
         named_routes[name] = route if name
         routes << route
         route
       end
 
       class Generator #:nodoc:
-        attr_reader :options, :recall, :set, :script_name, :named_route
+        PARAMETERIZE = {
+          :parameterize => lambda do |name, value|
+            if name == :controller
+              value
+            elsif value.is_a?(Array)
+              value.map { |v| Rack::Mount::Utils.escape_uri(v.to_param) }.join('/')
+            else
+              return nil unless param = value.to_param
+              param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
+            end
+          end
+        }
+
+        attr_reader :options, :recall, :set, :named_route
 
         def initialize(options, recall, set, extras = false)
-          @script_name = options.delete(:script_name)
           @named_route = options.delete(:use_route)
           @options     = options.dup
           @recall      = recall.dup
@@ -392,36 +441,19 @@ module ActionDispatch
         end
 
         def generate
-          path, params = @set.set.generate(:path_info, named_route, options, recall, opts)
+          path, params = @set.set.generate(:path_info, named_route, options, recall, PARAMETERIZE)
 
           raise_routing_error unless path
 
-          params.reject! {|k,v| !v }
-
           return [path, params.keys] if @extras
 
-          path << "?#{params.to_query}" if params.any?
-          "#{script_name}#{path}"
+          [path, params]
         rescue Rack::Mount::RoutingError
           raise_routing_error
         end
 
-        def opts
-          parameterize = lambda do |name, value|
-            if name == :controller
-              value
-            elsif value.is_a?(Array)
-              value.map { |v| Rack::Mount::Utils.escape_uri(v.to_param) }.join('/')
-            else
-              return nil unless param = value.to_param
-              param.split('/').map { |v| Rack::Mount::Utils.escape_uri(v) }.join("/")
-            end
-          end
-          {:parameterize => parameterize}
-        end
-
         def raise_routing_error
-          raise ActionController::RoutingError.new("No route matches #{options.inspect}")
+          raise ActionController::RoutingError, "No route matches #{options.inspect}"
         end
 
         def different_controller?
@@ -453,7 +485,12 @@ module ActionDispatch
         Generator.new(options, recall, self, extras).generate
       end
 
-      RESERVED_OPTIONS = [:anchor, :params, :only_path, :host, :protocol, :port, :trailing_slash]
+      RESERVED_OPTIONS = [:host, :protocol, :port, :subdomain, :domain, :tld_length,
+                          :trailing_slash, :anchor, :params, :only_path, :script_name]
+
+      def _generate_prefix(options = {})
+        nil
+      end
 
       def url_for(options)
         finalize!
@@ -461,30 +498,24 @@ module ActionDispatch
 
         handle_positional_args(options)
 
-        rewritten_url = ""
-
-        path_segments = options.delete(:_path_segments)
-
-        unless options[:only_path]
-          rewritten_url << (options[:protocol] || "http")
-          rewritten_url << "://" unless rewritten_url.match("://")
-          rewritten_url << rewrite_authentication(options)
-
-          raise "Missing host to link to! Please provide :host parameter or set default_url_options[:host]" unless options[:host]
+        user, password = extract_authentication(options)
+        path_segments  = options.delete(:_path_segments)
+        script_name    = options.delete(:script_name)
 
-          rewritten_url << options[:host]
-          rewritten_url << ":#{options.delete(:port)}" if options.key?(:port)
-        end
+        path = (script_name.blank? ? _generate_prefix(options) : script_name.chomp('/')).to_s
 
         path_options = options.except(*RESERVED_OPTIONS)
         path_options = yield(path_options) if block_given?
-        path = generate(path_options, path_segments || {})
 
-        # ROUTES TODO: This can be called directly, so script_name should probably be set in the routes
-        rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
-        rewritten_url << "##{Rack::Mount::Utils.escape_uri(options[:anchor].to_param.to_s)}" if options[:anchor]
+        path_addition, params = generate(path_options, path_segments || {})
+        path << path_addition
 
-        rewritten_url
+        ActionDispatch::Http::URL.url_for(options.merge({
+          :path => path,
+          :params => params,
+          :user => user,
+          :password => password
+        }))
       end
 
       def call(env)
@@ -494,7 +525,7 @@ module ActionDispatch
 
       def recognize_path(path, environment = {})
         method = (environment[:method] || "GET").to_s.upcase
-        path = Rack::Mount::Utils.normalize_path(path)
+        path = Rack::Mount::Utils.normalize_path(path) unless path =~ %r{://}
 
         begin
           env = Rack::MockRequest.env_for(path, {:method => method})
@@ -502,17 +533,19 @@ module ActionDispatch
           raise ActionController::RoutingError, e.message
         end
 
-        req = Rack::Request.new(env)
+        req = @request_class.new(env)
         @set.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?
-              params[key] = URI.unescape(value)
+              params[key] = URI.parser.unescape(value)
             end
           end
 
           dispatcher = route.app
-          dispatcher = dispatcher.app while dispatcher.is_a?(Mapper::Constraints)
+          while dispatcher.is_a?(Mapper::Constraints) && dispatcher.matches?(env) do
+            dispatcher = dispatcher.app
+          end
 
           if dispatcher.is_a?(Dispatcher) && dispatcher.controller(params, false)
             dispatcher.prepare_params!(params)
@@ -524,28 +557,25 @@ module ActionDispatch
       end
 
       private
+
+        def extract_authentication(options)
+          if options[:user] && options[:password]
+            [options.delete(:user), options.delete(:password)]
+          else
+            nil
+          end
+        end
+
         def handle_positional_args(options)
           return unless args = options.delete(:_positional_args)
 
           keys = options.delete(:_positional_keys)
           keys -= options.keys if args.size < keys.size - 1 # take format into account
 
-          args = args.zip(keys).inject({}) do |h, (v, k)|
-            h[k] = v
-            h
-          end
-
           # Tell url_for to skip default_url_options
-          options.merge!(args)
+          options.merge!(Hash[args.zip(keys).map { |v, k| [k, v] }])
         end
 
-        def rewrite_authentication(options)
-          if options[:user] && options[:password]
-            "#{Rack::Utils.escape(options.delete(:user))}:#{Rack::Utils.escape(options.delete(:password))}@"
-          else
-            ""
-          end
-        end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/routes_proxy.rb b/actionpack/lib/action_dispatch/routing/routes_proxy.rb
new file mode 100644
index 0000000000..f7d5f6397d
--- /dev/null
+++ b/actionpack/lib/action_dispatch/routing/routes_proxy.rb
@@ -0,0 +1,35 @@
+module ActionDispatch
+  module Routing
+    class RoutesProxy #:nodoc:
+      include ActionDispatch::Routing::UrlFor
+
+      attr_accessor :scope, :routes
+      alias :_routes :routes
+
+      def initialize(routes, scope)
+        @routes, @scope = routes, scope
+      end
+
+      def url_options
+        scope.send(:_with_routes, routes) do
+          scope.url_options
+        end
+      end
+
+      def method_missing(method, *args)
+        if routes.url_helpers.respond_to?(method)
+          self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{method}(*args)
+              options = args.extract_options!
+              args << url_options.merge((options || {}).symbolize_keys)
+              routes.url_helpers.#{method}(*args)
+            end
+          RUBY
+          send(method, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end
diff --git a/actionpack/lib/action_dispatch/routing/url_for.rb b/actionpack/lib/action_dispatch/routing/url_for.rb
index ba93ff8630..d4db78a25a 100644
--- a/actionpack/lib/action_dispatch/routing/url_for.rb
+++ b/actionpack/lib/action_dispatch/routing/url_for.rb
@@ -1,6 +1,6 @@
 module ActionDispatch
   module Routing
-    # In <b>routes.rb</b> one defines URL-to-controller mappings, but the reverse
+    # In <tt>config/routes.rb</tt> you define URL-to-controller mappings, but the reverse
     # is also possible: an URL can be generated from one of your routing definitions.
     # URL generation functionality is centralized in this module.
     #
@@ -12,15 +12,14 @@ module ActionDispatch
     #
     # == URL generation from parameters
     #
-    # As you may know, some functions - such as ActionController::Base#url_for
+    # As you may know, some functions, such as ActionController::Base#url_for
     # and ActionView::Helpers::UrlHelper#link_to, can generate URLs given a set
     # of parameters. For example, you've probably had the chance to write code
     # like this in one of your views:
     #
     #   <%= link_to('Click here', :controller => 'users',
     #           :action => 'new', :message => 'Welcome!') %>
-    #
-    #   # Generates a link to /users/new?message=Welcome%21
+    #   # => "/users/new?message=Welcome%21"
     #
     # link_to, and all other functions that require URL generation functionality,
     # actually use ActionController::UrlFor under the hood. And in particular,
@@ -61,7 +60,7 @@ module ActionDispatch
     #
     # UrlFor also allows one to access methods that have been auto-generated from
     # named routes. For example, suppose that you have a 'users' resource in your
-    # <b>routes.rb</b>:
+    # <tt>config/routes.rb</tt>:
     #
     #   resources :users
     #
@@ -99,6 +98,11 @@ module ActionDispatch
         end
       end
 
+      def initialize(*)
+        @_routes = nil
+        super
+      end
+
       def url_options
         default_url_options
       end
@@ -111,6 +115,13 @@ module ActionDispatch
       # * <tt>:host</tt> - Specifies the host the link should be targeted at.
       #   If <tt>:only_path</tt> is false, this option must be
       #   provided either explicitly, or via +default_url_options+.
+      # * <tt>:subdomain</tt> - Specifies the subdomain of the link, using the +tld_length+
+      #   to split the domain from the host.
+      # * <tt>:domain</tt> - Specifies the domain of the link, using the +tld_length+
+      #   to split the subdomain from the host.
+      # * <tt>:tld_length</tt> - Number of labels the TLD id composed of, only used if
+      #   <tt>:subdomain</tt> or <tt>:domain</tt> are supplied. Defaults to
+      #   <tt>ActionDispatch::Http::URL.tld_length</tt>, which in turn defaults to 1.
       # * <tt>:port</tt> - Optionally specify the port to connect to.
       # * <tt>:anchor</tt> - An anchor name to be appended to the path.
       # * <tt>:trailing_slash</tt> - If true, adds a trailing slash, as in "/archive/2009/"
@@ -134,6 +145,18 @@ module ActionDispatch
           polymorphic_url(options)
         end
       end
+
+      protected
+        def _with_routes(routes)
+          old_routes, @_routes = @_routes, routes
+          yield
+        ensure
+          @_routes = old_routes
+        end
+
+        def _routes_context
+          self
+        end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/testing/assertions/dom.rb b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
index 9c215de743..47c84742aa 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/dom.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/dom.rb
@@ -3,7 +3,7 @@ require 'action_controller/vendor/html-scanner'
 module ActionDispatch
   module Assertions
     module DomAssertions
-      # Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
+      # \Test two HTML strings for equivalency (e.g., identical up to reordering of attributes)
       #
       # ==== Examples
       #
diff --git a/actionpack/lib/action_dispatch/testing/assertions/response.rb b/actionpack/lib/action_dispatch/testing/assertions/response.rb
index ec5e9efe44..77a15f3e97 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/response.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/response.rb
@@ -1,6 +1,6 @@
 module ActionDispatch
   module Assertions
-    # A small suite of assertions that test responses from Rails applications.
+    # A small suite of assertions that test responses from \Rails applications.
     module ResponseAssertions
       extend ActiveSupport::Concern
 
@@ -18,9 +18,9 @@ module ActionDispatch
       # * <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.
+      # You can also pass an explicit status number like <tt>assert_response(501)</tt>
+      # or its symbolic equivalent <tt>assert_response(:not_implemented)</tt>.
+      # See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list.
       #
       # ==== Examples
       #
@@ -45,8 +45,8 @@ module ActionDispatch
       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.
+      # This match can be partial, such that <tt>assert_redirected_to(:controller => "weblog")</tt> will also
+      # match the redirection of <tt>redirect_to(:controller => "weblog", :action => "show")</tt> and so on.
       #
       # ==== Examples
       #
@@ -81,14 +81,10 @@ module ActionDispatch
 
         def normalize_argument_to_redirection(fragment)
           case fragment
-          when %r{^\w[\w\d+.-]*:.*}
+          when %r{^\w[A-Za-z\d+.-]*:.*}
             fragment
           when String
-            if fragment =~ %r{^\w[\w\d+.-]*:.*}
-              fragment
-            else
-              @request.protocol + @request.host_with_port + fragment
-            end
+            @request.protocol + @request.host_with_port + fragment
           when :back
             raise RedirectBackError unless refer = @request.headers["Referer"]
             refer
diff --git a/actionpack/lib/action_dispatch/testing/assertions/routing.rb b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
index 9338fa9e70..11e8c63fa0 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/routing.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/routing.rb
@@ -1,12 +1,13 @@
+require 'uri'
 require 'active_support/core_ext/hash/diff'
 require 'active_support/core_ext/hash/indifferent_access'
 
 module ActionDispatch
   module Assertions
-    # Suite of assertions to test routes generated by Rails and the handling of requests made to them.
+    # Suite of assertions to test routes generated by \Rails and the handling of requests made to them.
     module RoutingAssertions
       # Asserts that the routing of the given +path+ was handled correctly and that the parsed options (given in the +expected_options+ hash)
-      # match +path+.  Basically, it asserts that Rails recognizes the route given by +expected_options+.
+      # match +path+.  Basically, it asserts that \Rails recognizes the route given by +expected_options+.
       #
       # Pass a hash in the second argument (+path+) to specify the request method.  This is useful for routes
       # requiring a specific HTTP method.  The hash should contain a :path with the incoming request path
@@ -36,18 +37,8 @@ module ActionDispatch
       #
       #   # Test a custom route
       #   assert_recognizes({:controller => 'items', :action => 'show', :id => '1'}, 'view/item1')
-      #
-      #   # Check a Simply RESTful generated route
-      #   assert_recognizes list_items_url, 'items/list'
       def assert_recognizes(expected_options, path, extras={}, message=nil)
-        if path.is_a? Hash
-          request_method = path[:method]
-          path           = path[:path]
-        else
-          request_method = nil
-        end
-
-        request = recognized_request_for(path, request_method)
+        request = recognized_request_for(path)
 
         expected_options = expected_options.clone
         extras.each_key { |key| expected_options.delete key } unless extras.nil?
@@ -77,7 +68,16 @@ module ActionDispatch
       #   # 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)
-        expected_path = "/#{expected_path}" unless expected_path[0] == ?/
+        if expected_path =~ %r{://}
+          begin
+            uri = URI.parse(expected_path)
+            expected_path = uri.path.to_s.empty? ? "/" : uri.path
+          rescue URI::InvalidURIError => e
+            raise ActionController::RoutingError, e.message
+          end
+        else
+          expected_path = "/#{expected_path}" unless expected_path.first == '/'
+        end
         # Load routes.rb if it hasn't been loaded.
 
         generated_path, extra_keys = @routes.generate_extras(options, defaults)
@@ -121,7 +121,8 @@ module ActionDispatch
           options[:controller] = "/#{controller}"
         end
 
-        assert_generates(path.is_a?(Hash) ? path[:path] : path, options, defaults, extras, message)
+        generate_options = options.dup.delete_if{ |k,v| defaults.key?(k) }
+        assert_generates(path.is_a?(Hash) ? path[:path] : path, generate_options, defaults, extras, message)
       end
 
       # A helper to make it easier to test different route configurations.
@@ -143,16 +144,16 @@ module ActionDispatch
       #
       def with_routing
         old_routes, @routes = @routes, ActionDispatch::Routing::RouteSet.new
-        old_controller, @controller = @controller, @controller.clone if @controller
-        _routes = @routes
-
-        # Unfortunately, there is currently an abstraction leak between AC::Base
-        # and AV::Base which requires having the URL helpers in both AC and AV.
-        # To do this safely at runtime for tests, we need to bump up the helper serial
-        # to that the old AV subclass isn't cached.
-        #
-        # TODO: Make this unnecessary
-        if @controller
+        if defined?(@controller) && @controller
+          old_controller, @controller = @controller, @controller.clone
+          _routes = @routes
+
+          # Unfortunately, there is currently an abstraction leak between AC::Base
+          # and AV::Base which requires having the URL helpers in both AC and AV.
+          # To do this safely at runtime for tests, we need to bump up the helper serial
+          # to that the old AV subclass isn't cached.
+          #
+          # TODO: Make this unnecessary
           @controller.singleton_class.send(:include, _routes.url_helpers)
           @controller.view_context_class = Class.new(@controller.view_context_class) do
             include _routes.url_helpers
@@ -161,14 +162,14 @@ module ActionDispatch
         yield @routes
       ensure
         @routes = old_routes
-        if @controller
+        if defined?(@controller) && @controller
           @controller = old_controller
         end
       end
 
       # ROUTES TODO: These assertions should really work in an integration context
       def method_missing(selector, *args, &block)
-        if @controller && @routes && @routes.named_routes.helpers.include?(selector)
+        if defined?(@controller) && @controller && @routes && @routes.named_routes.helpers.include?(selector)
           @controller.send(selector, *args, &block)
         else
           super
@@ -177,15 +178,35 @@ module ActionDispatch
 
       private
         # Recognizes the route for a given path.
-        def recognized_request_for(path, request_method = nil)
-          path = "/#{path}" unless path.first == '/'
+        def recognized_request_for(path)
+          if path.is_a?(Hash)
+            method = path[:method]
+            path   = path[:path]
+          else
+            method = :get
+          end
 
           # Assume given controller
           request = ActionController::TestRequest.new
-          request.env["REQUEST_METHOD"] = request_method.to_s.upcase if request_method
-          request.path = path
 
-          params = @routes.recognize_path(path, { :method => request.method })
+          if path =~ %r{://}
+            begin
+              uri = URI.parse(path)
+              request.env["rack.url_scheme"] = uri.scheme || "http"
+              request.host = uri.host if uri.host
+              request.port = uri.port if uri.port
+              request.path = uri.path.to_s.empty? ? "/" : uri.path
+            rescue URI::InvalidURIError => e
+              raise ActionController::RoutingError, e.message
+            end
+          else
+            path = "/#{path}" unless path.first == "/"
+            request.path = path
+          end
+
+          request.request_method = method if method
+
+          params = @routes.recognize_path(path, { :method => method })
           request.path_parameters = params.with_indifferent_access
 
           request
diff --git a/actionpack/lib/action_dispatch/testing/assertions/selector.rb b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
index 2fc9e2b7d6..2b862fb7d6 100644
--- a/actionpack/lib/action_dispatch/testing/assertions/selector.rb
+++ b/actionpack/lib/action_dispatch/testing/assertions/selector.rb
@@ -24,10 +24,6 @@ module ActionDispatch
     #
     # Also see HTML::Selector to learn how to use selectors.
     module SelectorAssertions
-      # :call-seq:
-      #   css_select(selector) => array
-      #   css_select(element, selector) => array
-      #
       # Select and return all matching elements.
       #
       # If called with a single argument, uses that argument as a selector
@@ -71,7 +67,7 @@ module ActionDispatch
           arg = args.shift
         elsif arg == nil
           raise ArgumentError, "First argument is either selector or element to select, but nil found. Perhaps you called assert_select with an element that does not exist?"
-        elsif @selected
+        elsif defined?(@selected) && @selected
           matches = []
 
           @selected.each do |selected|
@@ -99,10 +95,6 @@ module ActionDispatch
         selector.select(root)
       end
 
-      # :call-seq:
-      #   assert_select(selector, equality?, message?)
-      #   assert_select(element, selector, equality?, message?)
-      #
       # An assertion that selects elements and makes one or more equality tests.
       #
       # If the first argument is an element, selects all matching elements
@@ -195,6 +187,7 @@ module ActionDispatch
       def assert_select(*args, &block)
         # Start with optional element followed by mandatory selector.
         arg = args.shift
+        @selected ||= nil
 
         if arg.is_a?(HTML::Node)
           # First argument is a node (tag or text, but also HTML root),
@@ -332,11 +325,6 @@ module ActionDispatch
         end
       end
 
-      # :call-seq:
-      #   assert_select_rjs(id?) { |elements| ... }
-      #   assert_select_rjs(statement, id?) { |elements| ... }
-      #   assert_select_rjs(:insert, position, id?) { |elements| ... }
-      #
       # Selects content from the RJS response.
       #
       # === Narrowing down
@@ -455,6 +443,7 @@ module ActionDispatch
           assert_block("") { true } # to count the assertion
           if block_given? && !([:remove, :show, :hide, :toggle].include? rjs_type)
             begin
+              @selected ||= nil
               in_scope, @selected = @selected, matches
               yield matches
             ensure
@@ -474,9 +463,6 @@ module ActionDispatch
         end
       end
 
-      # :call-seq:
-      #   assert_select_encoded(element?) { |elements| ... }
-      #
       # Extracts the content of an element, treats it as encoded HTML and runs
       # nested assertion on it.
       #
@@ -529,8 +515,8 @@ module ActionDispatch
           node.content.gsub(/<!\[CDATA\[(.*)(\]\]>)?/m) { Rack::Utils.escapeHTML($1) }
         end
 
-        selected = elements.map do |element|
-          text = element.children.select{ |c| not c.tag? }.map{ |c| fix_content[c] }.join
+        selected = elements.map do |_element|
+          text = _element.children.select{ |c| not c.tag? }.map{ |c| fix_content[c] }.join
           root = HTML::Document.new(CGI.unescapeHTML("<encoded>#{text}</encoded>")).root
           css_select(root, "encoded:root", &block)[0]
         end
@@ -543,9 +529,6 @@ module ActionDispatch
         end
       end
 
-      # :call-seq:
-      #   assert_select_email { }
-      #
       # Extracts the body of an email and runs nested assertions on it.
       #
       # You must enable deliveries for this assertion to work, use:
diff --git a/actionpack/lib/action_dispatch/testing/integration.rb b/actionpack/lib/action_dispatch/testing/integration.rb
index b52795c575..5c6416a19e 100644
--- a/actionpack/lib/action_dispatch/testing/integration.rb
+++ b/actionpack/lib/action_dispatch/testing/integration.rb
@@ -115,8 +115,8 @@ module ActionDispatch
       end
     end
 
-    # An integration Session instance represents a set of requests and responses
-    # performed sequentially by some virtual user. Because you can instantiate
+    # An instance of this class represents a set of requests and responses
+    # performed sequentially by a test process. Because you can instantiate
     # multiple sessions and run them side-by-side, you can also mimic (to some
     # limited extent) multiple simultaneous users interacting with your system.
     #
@@ -171,6 +171,7 @@ module ActionDispatch
 
       # Create and initialize a new Session instance.
       def initialize(app)
+        super()
         @app = app
 
         # If the app is a Rails app, make url_helpers available on the session
@@ -182,6 +183,7 @@ module ActionDispatch
         reset!
       end
 
+      remove_method :default_url_options
       def default_url_options
         { :host => host, :protocol => https? ? "https" : "http" }
       end
@@ -233,9 +235,7 @@ module ActionDispatch
       # Set the host name to use in the next request.
       #
       #   session.host! "www.example.com"
-      def host!(name)
-        @host = name
-      end
+      alias :host! :host=
 
       private
         def _mock_session
@@ -257,12 +257,14 @@ module ActionDispatch
             end
           end
 
+          hostname, port = host.split(':')
+
           env = {
             :method => method,
             :params => parameters,
 
-            "SERVER_NAME"     => host.split(':')[0],
-            "SERVER_PORT"     => (https? ? "443" : "80"),
+            "SERVER_NAME"     => hostname,
+            "SERVER_PORT"     => port || (https? ? "443" : "80"),
             "HTTPS"           => https? ? "on" : "off",
             "rack.url_scheme" => https? ? "https" : "http",
 
@@ -305,7 +307,7 @@ module ActionDispatch
       include ActionDispatch::Assertions
 
       def app
-        @app
+        @app ||= nil
       end
 
       # Reset the current session. This is useful for testing multiple sessions
@@ -317,10 +319,10 @@ module ActionDispatch
       %w(get post put head delete cookies assigns
          xml_http_request xhr get_via_redirect post_via_redirect).each do |method|
         define_method(method) do |*args|
-          reset! unless @integration_session
+          reset! unless integration_session
           # reset the html_document variable, but only for new get/post calls
           @html_document = nil unless %w(cookies assigns).include?(method)
-          @integration_session.__send__(method, *args).tap do
+          integration_session.__send__(method, *args).tap do
             copy_session_variables!
           end
         end
@@ -345,7 +347,7 @@ module ActionDispatch
       # Copy the instance variables from the current session instance into the
       # test instance.
       def copy_session_variables! #:nodoc:
-        return unless @integration_session
+        return unless integration_session
         %w(controller response request).each do |var|
           instance_variable_set("@#{var}", @integration_session.__send__(var))
         end
@@ -355,35 +357,44 @@ module ActionDispatch
       include ActionDispatch::Routing::UrlFor
 
       def url_options
-        reset! unless @integration_session
-        @integration_session.url_options
+        reset! unless integration_session
+        integration_session.url_options
+      end
+
+      def respond_to?(method, include_private = false)
+        integration_session.respond_to?(method, include_private) || super
       end
 
       # Delegate unhandled messages to the current session instance.
       def method_missing(sym, *args, &block)
-        reset! unless @integration_session
-        if @integration_session.respond_to?(sym)
-          @integration_session.__send__(sym, *args, &block).tap do
+        reset! unless integration_session
+        if integration_session.respond_to?(sym)
+          integration_session.__send__(sym, *args, &block).tap do
             copy_session_variables!
           end
         else
           super
         end
       end
+
+      private
+        def integration_session
+          @integration_session ||= nil
+        end
     end
   end
 
-  # An IntegrationTest is one that spans multiple controllers and actions,
+  # An test that spans multiple controllers and actions,
   # tying them all together to ensure they work together as expected. It tests
   # more completely than either unit or functional tests do, exercising the
   # entire stack, from the dispatcher to the database.
   #
-  # At its simplest, you simply extend IntegrationTest and write your tests
+  # At its simplest, you simply extend <tt>IntegrationTest</tt> and write your tests
   # using the get/post methods:
   #
   #   require "test_helper"
   #
-  #   class ExampleTest < ActionController::IntegrationTest
+  #   class ExampleTest < ActionDispatch::IntegrationTest
   #     fixtures :people
   #
   #     def test_login
@@ -403,11 +414,11 @@ module ActionDispatch
   # However, you can also have multiple session instances open per test, and
   # even extend those instances with assertions and methods to create a very
   # powerful testing DSL that is specific for your application. You can even
-  # reference any named routes you happen to have defined!
+  # reference any named routes you happen to have defined.
   #
   #   require "test_helper"
   #
-  #   class AdvancedTest < ActionController::IntegrationTest
+  #   class AdvancedTest < ActionDispatch::IntegrationTest
   #     fixtures :people, :rooms
   #
   #     def test_login_and_speak
diff --git a/actionpack/lib/action_dispatch/testing/performance_test.rb b/actionpack/lib/action_dispatch/testing/performance_test.rb
index 33a5c68b9d..e7aeb45fb3 100644
--- a/actionpack/lib/action_dispatch/testing/performance_test.rb
+++ b/actionpack/lib/action_dispatch/testing/performance_test.rb
@@ -1,5 +1,4 @@
 require 'active_support/testing/performance'
-require 'active_support/testing/default'
 
 begin
   module ActionDispatch
@@ -11,9 +10,8 @@ begin
     # formats are written, so you'll have two output files per test method.
     class PerformanceTest < ActionDispatch::IntegrationTest
       include ActiveSupport::Testing::Performance
-      include ActiveSupport::Testing::Default
     end
   end
 rescue NameError
   $stderr.puts "Specify ruby-prof as application's dependency in Gemfile to run benchmarks."
-end
\ No newline at end of file
+end
diff --git a/actionpack/lib/action_dispatch/testing/test_process.rb b/actionpack/lib/action_dispatch/testing/test_process.rb
index c56ebc6438..d430691429 100644
--- a/actionpack/lib/action_dispatch/testing/test_process.rb
+++ b/actionpack/lib/action_dispatch/testing/test_process.rb
@@ -22,7 +22,7 @@ module ActionDispatch
     end
 
     def cookies
-      @request.cookies.merge(@response.cookies)
+      @request.cookies.merge(@response.cookies).with_indifferent_access
     end
 
     def redirect_to_url
diff --git a/actionpack/lib/action_dispatch/testing/test_request.rb b/actionpack/lib/action_dispatch/testing/test_request.rb
index b3e67f6e36..822adb6a47 100644
--- a/actionpack/lib/action_dispatch/testing/test_request.rb
+++ b/actionpack/lib/action_dispatch/testing/test_request.rb
@@ -1,5 +1,6 @@
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/hash/reverse_merge'
+require 'rack/utils'
 
 module ActionDispatch
   class TestRequest < Request
@@ -10,9 +11,10 @@ module ActionDispatch
     end
 
     def initialize(env = {})
-      env = Rails.application.env_defaults.merge(env) if defined?(Rails.application)
+      env = Rails.application.env_config.merge(env) if defined?(Rails.application)
       super(DEFAULT_ENV.merge(env))
 
+      @cookies = nil
       self.host        = 'test.host'
       self.remote_addr = '0.0.0.0'
       self.user_agent  = 'Rails Testing'
@@ -66,7 +68,7 @@ module ActionDispatch
 
     def accept=(mime_types)
       @env.delete('action_dispatch.request.accepts')
-      @env['HTTP_ACCEPT'] = Array(mime_types).collect { |mime_types| mime_types.to_s }.join(",")
+      @env['HTTP_ACCEPT'] = Array(mime_types).collect { |mime_type| mime_type.to_s }.join(",")
     end
 
     def cookies
@@ -76,10 +78,14 @@ module ActionDispatch
     private
       def write_cookies!
         unless @cookies.blank?
-          @env['HTTP_COOKIE'] = @cookies.map { |name, value| "#{name}=#{value};" }.join(' ')
+          @env['HTTP_COOKIE'] = @cookies.map { |name, value| escape_cookie(name, value) }.join('; ')
         end
       end
 
+      def escape_cookie(name, value)
+        "#{Rack::Utils.escape(name)}=#{Rack::Utils.escape(value)}"
+      end
+
       def delete_nil_values!
         @env.delete_if { |k, v| v.nil? }
       end
diff --git a/actionpack/lib/action_dispatch/testing/test_response.rb b/actionpack/lib/action_dispatch/testing/test_response.rb
index 44fb1bde99..82039e72e7 100644
--- a/actionpack/lib/action_dispatch/testing/test_response.rb
+++ b/actionpack/lib/action_dispatch/testing/test_response.rb
@@ -14,123 +14,16 @@ module ActionDispatch
       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 redirected_to
-        ::ActiveSupport::Deprecation.warn("response.redirected_to is deprecated. Use response.redirect_url instead", caller)
-        redirect_url
-      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 template.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 template.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
+    alias_method :success?, :successful?
 
     # Was the URL not found?
-    def missing?
-      response_code == 404
-    end
+    alias_method :missing?, :not_found?
 
     # Were we redirected?
-    def redirect?
-      (300..399).include?(response_code)
-    end
+    alias_method :redirect?, :redirection?
 
     # 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
+    alias_method :error?, :server_error?
   end
 end