rq 3.4.0 → 3.5.0

data/rails/vendor/rails/actionpack/lib/action_controller/request.rb

@@ -1,265 +0,0 @@
-module ActionController
-  # Subclassing AbstractRequest makes these methods available to the request objects used in production and testing,
-  # CgiRequest and TestRequest
-  class AbstractRequest
-    cattr_accessor :relative_url_root
-
-    # Returns the hash of environment variables for this request,
-    # such as { 'RAILS_ENV' => 'production' }.
-    attr_reader :env
-
-    # Returns both GET and POST parameters in a single hash.
-    def parameters
-      @parameters ||= request_parameters.update(query_parameters).update(path_parameters).with_indifferent_access
-    end
-
-    # Returns the HTTP request method as a lowercase symbol (:get, for example). Note, HEAD is returned as :get
-    # since the two are supposedly to be functionaly equivilent for all purposes except that HEAD won't return a response
-    # body (which Rails also takes care of elsewhere).
-    def method
-      @request_method ||= (!parameters[:_method].blank? && @env['REQUEST_METHOD'] == 'POST') ?
-        parameters[:_method].to_s.downcase.to_sym :
-        @env['REQUEST_METHOD'].downcase.to_sym
-      
-      @request_method == :head ? :get : @request_method
-    end
-
-    # Is this a GET (or HEAD) request?  Equivalent to request.method == :get
-    def get?
-      method == :get
-    end
-
-    # Is this a POST request?  Equivalent to request.method == :post
-    def post?
-      method == :post
-    end
-
-    # Is this a PUT request?  Equivalent to request.method == :put
-    def put?
-      method == :put
-    end
-
-    # Is this a DELETE request?  Equivalent to request.method == :delete
-    def delete?
-      method == :delete
-    end
-
-    # Is this a HEAD request?  HEAD is mapped as :get for request.method, so here we ask the 
-    # REQUEST_METHOD header directly. Thus, for head, both get? and head? will return true.
-    def head?
-      @env['REQUEST_METHOD'].downcase.to_sym == :head
-    end
-
-    # Determine whether the body of a HTTP call is URL-encoded (default)
-    # or matches one of the registered param_parsers. 
-    #
-    # For backward compatibility, the post format is extracted from the
-    # X-Post-Data-Format HTTP header if present.
-    def content_type
-      @content_type ||=
-        begin
-          content_type = @env['CONTENT_TYPE'].to_s.downcase
-          
-          if x_post_format = @env['HTTP_X_POST_DATA_FORMAT']
-            case x_post_format.to_s.downcase
-            when 'yaml'
-              content_type = 'application/x-yaml'
-            when 'xml'
-              content_type = 'application/xml'
-            end
-          end
-          
-          Mime::Type.lookup(content_type)
-        end
-    end
-
-    # Returns the accepted MIME type for the request
-    def accepts
-      @accepts ||=
-        if @env['HTTP_ACCEPT'].to_s.strip.empty?
-          [ content_type, Mime::ALL ]
-        else
-          Mime::Type.parse(@env['HTTP_ACCEPT'])
-        end
-    end
-
-    # Returns true if the request's "X-Requested-With" header contains
-    # "XMLHttpRequest". (The Prototype Javascript library sends this header with
-    # every Ajax request.)
-    def xml_http_request?
-      not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
-    end
-    alias xhr? :xml_http_request?
-
-    # Determine originating IP address.  REMOTE_ADDR is the standard
-    # but will fail if the user is behind a proxy.  HTTP_CLIENT_IP and/or
-    # HTTP_X_FORWARDED_FOR are set by proxies so check for these before
-    # falling back to REMOTE_ADDR.  HTTP_X_FORWARDED_FOR may be a comma-
-    # delimited list in the case of multiple chained proxies; the first is
-    # the originating IP.
-    def remote_ip
-      return @env['HTTP_CLIENT_IP'] if @env.include? 'HTTP_CLIENT_IP'
-
-      if @env.include? 'HTTP_X_FORWARDED_FOR' then
-        remote_ips = @env['HTTP_X_FORWARDED_FOR'].split(',').reject do |ip|
-            ip =~ /^unknown$|^(10|172\.(1[6-9]|2[0-9]|30|31)|192\.168)\./i
-        end
-
-        return remote_ips.first.strip unless remote_ips.empty?
-      end
-
-      @env['REMOTE_ADDR']
-    end
-
-    # Returns the domain part of a host, such as rubyonrails.org in "www.rubyonrails.org". You can specify
-    # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
-    def domain(tld_length = 1)
-      return nil if !/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/.match(host).nil? or host.nil?
-
-      host.split('.').last(1 + tld_length).join('.')
-    end
-
-    # Returns all the subdomains as an array, so ["dev", "www"] would be returned for "dev.www.rubyonrails.org".
-    # You can specify a different <tt>tld_length</tt>, such as 2 to catch ["www"] instead of ["www", "rubyonrails"]
-    # in "www.rubyonrails.co.uk".
-    def subdomains(tld_length = 1)
-      return [] unless host
-      parts = host.split('.')
-      parts[0..-(tld_length+2)]
-    end
-
-    # Receive the raw post data.
-    # This is useful for services such as REST, XMLRPC and SOAP
-    # which communicate over HTTP POST but don't use the traditional parameter format.
-    def raw_post
-      @env['RAW_POST_DATA']
-    end
-
-    # Return the request URI, accounting for server idiosyncracies.
-    # WEBrick includes the full URL. IIS leaves REQUEST_URI blank.
-    def request_uri
-      if uri = @env['REQUEST_URI']
-        # Remove domain, which webrick puts into the request_uri.
-        (%r{^\w+\://[^/]+(/.*|$)$} =~ uri) ? $1 : uri
-      else
-        # Construct IIS missing REQUEST_URI from SCRIPT_NAME and PATH_INFO.
-        script_filename = @env['SCRIPT_NAME'].to_s.match(%r{[^/]+$})
-        uri = @env['PATH_INFO']
-        uri = uri.sub(/#{script_filename}\//, '') unless script_filename.nil?
-        unless (env_qs = @env['QUERY_STRING']).nil? || env_qs.empty?
-          uri << '?' << env_qs
-        end
-        @env['REQUEST_URI'] = uri
-      end
-    end
-
-    # Return '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'
-    end
-
-    # Returns the interpreted path to requested resource after all the installation directory of this application was taken into account
-    def path
-      path = (uri = request_uri) ? uri.split('?').first : ''
-
-      # Cut off the path to the installation directory if given
-      path.sub!(%r/^#{relative_url_root}/, '')
-      path || ''      
-    end
-    
-    # Returns the path minus the web server relative installation directory.
-    # This can be set with the environment variable RAILS_RELATIVE_URL_ROOT.
-    # It can be automatically extracted for Apache setups. If the server is not
-    # Apache, this method returns an empty string.
-    def relative_url_root
-      @@relative_url_root ||= case
-        when @env["RAILS_RELATIVE_URL_ROOT"]
-          @env["RAILS_RELATIVE_URL_ROOT"]
-        when server_software == 'apache'
-          @env["SCRIPT_NAME"].to_s.sub(/\/dispatch\.(fcgi|rb|cgi)$/, '')
-        else
-          ''
-      end
-    end
-
-    # Returns the port number of this request as an integer.
-    def port
-      @port_as_int ||= @env['SERVER_PORT'].to_i
-    end
-
-    # Returns the standard port number for this request's protocol
-    def standard_port
-      case protocol
-        when 'https://' then 443
-        else 80
-      end
-    end
-
-    # Returns a port suffix 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}"
-    end
-
-    # Returns a host:port string for this request, such as example.com or
-    # example.com:8080.
-    def host_with_port
-      host + port_string
-    end
-
-    def path_parameters=(parameters) #:nodoc:
-      @path_parameters = parameters
-      @symbolized_path_parameters = @parameters = nil
-    end
-
-    # The same as <tt>path_parameters</tt> with explicitly symbolized keys 
-    def symbolized_path_parameters 
-      @symbolized_path_parameters ||= path_parameters.symbolize_keys
-    end
-
-    # Returns a hash with the parameters used to form the path of the request 
-    #
-    # Example: 
-    #
-    #   {:action => 'my_action', :controller => 'my_controller'}
-    def path_parameters
-      @path_parameters ||= {}
-    end
-
-    # Returns the lowercase name of the HTTP server software.
-    def server_software
-      (@env['SERVER_SOFTWARE'] && /^([a-zA-Z]+)/ =~ @env['SERVER_SOFTWARE']) ? $1.downcase : nil
-    end
-
-    #--
-    # Must be implemented in the concrete request
-    #++
-    def query_parameters #:nodoc:
-    end
-
-    def request_parameters #:nodoc:
-    end
-
-    # Returns the host for this request, such as example.com.
-    def host
-    end
-
-    def cookies #:nodoc:
-    end
-
-    def session #:nodoc:
-    end
-
-    def session=(session) #:nodoc:
-      @session = session
-    end
-
-    def reset_session #:nodoc:
-    end
-  end
-end

data/rails/vendor/rails/actionpack/lib/action_controller/rescue.rb

@@ -1,142 +0,0 @@
-module ActionController #:nodoc:
-  # Actions that fail to perform as expected throw exceptions. These exceptions can either be rescued for the public view 
-  # (with a nice user-friendly explanation) or for the developers view (with tons of debugging information). The developers view
-  # is already implemented by the Action Controller, but the public view should be tailored to your specific application. So too
-  # could the decision on whether something is a public or a developer request.
-  #
-  # You can tailor the rescuing behavior and appearance by overwriting the following two stub methods.
-  module Rescue
-    def self.included(base) #:nodoc:
-      base.extend(ClassMethods)
-      base.class_eval do
-        alias_method_chain :perform_action, :rescue
-      end
-    end
-
-    module ClassMethods #:nodoc:
-      def process_with_exception(request, response, exception)
-        new.process(request, response, :rescue_action, exception)
-      end
-    end
-
-    protected
-      # Exception handler called when the performance of an action raises an exception.
-      def rescue_action(exception)
-        log_error(exception) if logger
-        erase_results if performed?
-
-        if consider_all_requests_local || local_request?
-          rescue_action_locally(exception)
-        else
-          rescue_action_in_public(exception)
-        end
-      end
-
-      # Overwrite to implement custom logging of errors. By default logs as fatal.
-      def log_error(exception) #:doc:
-        ActiveSupport::Deprecation.silence do
-          if ActionView::TemplateError === exception
-            logger.fatal(exception.to_s)
-          else
-            logger.fatal(
-              "\n\n#{exception.class} (#{exception.message}):\n    " +
-              clean_backtrace(exception).join("\n    ") +
-              "\n\n"
-            )
-          end
-        end
-      end
-
-      # Overwrite to implement public exception handling (for requests answering false to <tt>local_request?</tt>).
-      def rescue_action_in_public(exception) #:doc:
-        case exception
-          when RoutingError, UnknownAction
-            render_text(IO.read(File.join(RAILS_ROOT, 'public', '404.html')), "404 Not Found")
-          else
-            render_text(IO.read(File.join(RAILS_ROOT, 'public', '500.html')), "500 Internal Error")
-        end
-      end
-
-      # Overwrite to expand the meaning of a local request in order to show local rescues on other occurrences than
-      # the remote IP being 127.0.0.1. For example, this could include the IP of the developer machine when debugging
-      # remotely.
-      def local_request? #:doc:
-        [request.remote_addr, request.remote_ip] == ["127.0.0.1"] * 2
-      end
-
-      # Renders a detailed diagnostics screen on action exceptions. 
-      def rescue_action_locally(exception)
-        add_variables_to_assigns
-        @template.instance_variable_set("@exception", exception)
-        @template.instance_variable_set("@rescues_path", File.dirname(rescues_path("stub")))    
-        @template.send(:assign_variables_from_controller)
-
-        @template.instance_variable_set("@contents", @template.render_file(template_path_for_local_rescue(exception), false))
-    
-        response.content_type = Mime::HTML
-        render_file(rescues_path("layout"), response_code_for_rescue(exception))
-      end
-    
-    private
-      def perform_action_with_rescue #:nodoc:
-        begin
-          perform_action_without_rescue
-        rescue Exception => exception  # errors from action performed
-          if defined?(Breakpoint) && params["BP-RETRY"]
-            msg = exception.backtrace.first
-            if md = /^(.+?):(\d+)(?::in `(.+)')?$/.match(msg) then
-              origin_file, origin_line = md[1], md[2].to_i
-
-              set_trace_func(lambda do |type, file, line, method, context, klass|
-                if file == origin_file and line == origin_line then
-                  set_trace_func(nil)
-                  params["BP-RETRY"] = false
-
-                  callstack = caller
-                  callstack.slice!(0) if callstack.first["rescue.rb"]
-                  file, line, method = *callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
-
-                  message = "Exception at #{file}:#{line}#{" in `#{method}'" if method}." # `� ( for ruby-mode)
-
-                  Breakpoint.handle_breakpoint(context, message, file, line)
-                end
-              end)
-
-              retry
-            end
-          end
-
-          rescue_action(exception)
-        end
-      end
-
-      def rescues_path(template_name)
-        File.dirname(__FILE__) + "/templates/rescues/#{template_name}.rhtml"
-      end
-
-      def template_path_for_local_rescue(exception)
-        rescues_path(
-          case exception
-            when MissingTemplate then "missing_template"
-            when RoutingError then "routing_error"
-            when UnknownAction   then "unknown_action"
-            when ActionView::TemplateError then "template_error"
-            else "diagnostics"
-          end
-        )
-      end
-      
-      def response_code_for_rescue(exception)
-        case exception
-          when UnknownAction, RoutingError 
-            "404 Page Not Found"
-          else
-            "500 Internal Error"
-        end
-      end
-      
-      def clean_backtrace(exception)
-        exception.backtrace.collect { |line| Object.const_defined?(:RAILS_ROOT) ? line.gsub(RAILS_ROOT, "") : line }
-      end
-  end
-end

data/rails/vendor/rails/actionpack/lib/action_controller/resources.rb

@@ -1,405 +0,0 @@
-module ActionController
-  module Resources
-    class Resource #:nodoc:
-      attr_reader :collection_methods, :member_methods, :new_methods
-      attr_reader :path_prefix, :name_prefix
-      attr_reader :plural, :singular
-      attr_reader :options
-
-      def initialize(entities, options)
-        @plural   = entities
-        @singular = options[:singular] || plural.to_s.singularize
-        
-        @options = options
-
-        arrange_actions
-        add_default_actions
-        set_prefixes
-      end
-      
-      def controller
-        @controller ||= (options[:controller] || plural).to_s
-      end
-      
-      def path
-        @path ||= "#{path_prefix}/#{plural}"
-      end
-      
-      def new_path
-        @new_path ||= "#{path}/new"
-      end
-      
-      def member_path
-        @member_path ||= "#{path}/:id"
-      end
-      
-      def nesting_path_prefix
-        @nesting_path_prefix ||= "#{path}/:#{singular}_id"
-      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_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)
-        @plural = @singular = entity
-        @options = options
-        arrange_actions
-        add_default_actions
-        set_prefixes
-      end
-
-      alias_method :member_path,         :path
-      alias_method :nesting_path_prefix, :path
-    end
-
-    # Creates named routes for implementing verb-oriented controllers. This is
-    # useful for implementing REST API's, where a single resource has different
-    # behavior based on the HTTP verb (method) used to access it.
-    # 
-    # Example:
-    #
-    #   map.resources :messages 
-    #
-    #   class MessagesController < ActionController::Base
-    #     # GET messages_url
-    #     def index
-    #       # return all messages
-    #     end
-    # 
-    #     # GET new_message_url
-    #     def new
-    #       # return an HTML form for describing a new message
-    #     end
-    # 
-    #     # POST messages_url
-    #     def create
-    #       # create a new message
-    #     end
-    # 
-    #     # GET message_url(:id => 1)
-    #     def show
-    #       # find and return a specific message
-    #     end
-    # 
-    #     # GET edit_message_url(:id => 1)
-    #     def edit
-    #       # return an HTML form for editing a specific message
-    #     end
-    # 
-    #     # PUT message_url(:id => 1)
-    #     def update
-    #       # find and update a specific message
-    #     end
-    # 
-    #     # DELETE message_url(:id => 1)
-    #     def destroy
-    #       # delete a specific message
-    #     end
-    #   end
-    # 
-    # The #resources method sets HTTP method restrictions on the routes it generates. For example, making an
-    # HTTP POST on <tt>new_message_url</tt> will raise a RoutingError exception. The default route in 
-    # <tt>config/routes.rb</tt> overrides this and allows invalid HTTP methods for resource routes.
-    # 
-    # Along with the routes themselves, #resources generates named routes for use in
-    # controllers and views. <tt>map.resources :messages</tt> produces the following named routes and helpers:
-    # 
-    #   Named Route   Helpers
-    #   messages      messages_url, hash_for_messages_url, 
-    #                 messages_path, hash_for_messages_path
-    #   message       message_url(id), hash_for_message_url(id), 
-    #                 message_path(id), hash_for_message_path(id)
-    #   new_message   new_message_url, hash_for_new_message_url, 
-    #                 new_message_path, hash_for_new_message_path
-    #   edit_message  edit_message_url(id), hash_for_edit_message_url(id),
-    #                 edit_message_path(id), hash_for_edit_message_path(id)
-    #
-    # You can use these helpers instead of #url_for or methods that take #url_for parameters:
-    # 
-    #   redirect_to :controller => 'messages', :action => 'index'
-    #   # becomes
-    #   redirect_to messages_url
-    #
-    #   <%= link_to "edit this message", :controller => 'messages', :action => 'edit', :id => @message.id %>
-    #   # becomes
-    #   <%= link_to "edit this message", edit_message_url(@message) # calls @message.id automatically
-    #
-    # Since web browsers don't support the PUT and DELETE verbs, you will need to add a parameter '_method' to your
-    # form tags. The form helpers make this a little easier. For an update form with a <tt>@message</tt> object:
-    #
-    #   <%= form_tag message_path(@message), :method => :put %>
-    #   
-    # or 
-    #   
-    #   <% form_for :message, @message, :url => message_path(@message), :html => {:method => :put} do |f| %>
-    # 
-    # The #resources method accepts various options, too, to customize the resulting
-    # routes:
-    # * <tt>:controller</tt> -- specify the controller name for the routes.
-    # * <tt>:singular</tt> -- specify the singular name used in the member routes.
-    # * <tt>:path_prefix</tt> -- set a prefix to the routes with required route variables.
-    #   Weblog comments usually belong to a post, so you might use resources like:
-    #
-    #     map.resources :articles
-    #     map.resources :comments, :path_prefix => '/articles/:article_id'
-    #
-    #   You can nest resources calls to set this automatically:
-    #
-    #     map.resources :articles do |article|
-    #       article.resources :comments
-    #     end
-    #
-    #   The comment resources work the same, but must now include a value for :article_id.
-    #   
-    #     comments_url(@article)
-    #     comment_url(@article, @comment)
-    #
-    #     comments_url(:article_id => @article)
-    #     comment_url(:article_id => @article, :id => @comment)
-    #
-    # * <tt>:name_prefix</tt> -- define a prefix for all generated routes, usually ending in an underscore.
-    #   Use this if you have named routes that may clash.
-    #
-    #     map.resources :tags, :path_prefix => '/books/:book_id', :name_prefix => 'book_'
-    #     map.resources :tags, :path_prefix => '/toys/:toy_id',   :name_prefix => 'toy_'
-    #
-    # * <tt>:collection</tt> -- add named routes for other actions that operate on the collection.
-    #   Takes a hash of <tt>#{action} => #{method}</tt>, where method is <tt>:get</tt>/<tt>:post</tt>/<tt>:put</tt>/<tt>:delete</tt>
-    #   or <tt>:any</tt> if the method does not matter.  These routes map to a URL like /messages;rss, with a route of rss_messages_url.
-    # * <tt>:member</tt> -- same as :collection, but for actions that operate on a specific member.
-    # * <tt>:new</tt> -- same as :collection, but for actions that operate on the new resource action.
-    #
-    # If <tt>map.resources</tt> is called with multiple resources, they all get the same options applied.
-    #
-    # Examples:
-    # 
-    #   map.resources :messages, :path_prefix => "/thread/:thread_id"
-    #   # --> GET /thread/7/messages/1
-    #  
-    #   map.resources :messages, :collection => { :rss => :get }
-    #   # --> GET /messages;rss (maps to the #rss action)
-    #   #     also adds a named route called "rss_messages"
-    # 
-    #   map.resources :messages, :member => { :mark => :post }
-    #   # --> POST /messages/1;mark (maps to the #mark action)
-    #   #     also adds a named route called "mark_message"
-    # 
-    #   map.resources :messages, :new => { :preview => :post }
-    #   # --> POST /messages/new;preview (maps to the #preview action)
-    #   #     also adds a named route called "preview_new_message"
-    # 
-    #   map.resources :messages, :new => { :new => :any, :preview => :post }
-    #   # --> POST /messages/new;preview (maps to the #preview action)
-    #   #     also adds a named route called "preview_new_message"
-    #   # --> /messages/new can be invoked via any request method
-    # 
-    #   map.resources :messages, :controller => "categories",
-    #         :path_prefix => "/category/:category_id",
-    #         :name_prefix => "category_"
-    #   # --> GET /categories/7/messages/1
-    #   #     has named route "category_message"
-    def resources(*entities, &block)
-      options = entities.last.is_a?(Hash) ? entities.pop : { }
-      entities.each { |entity| map_resource entity, options.dup, &block }
-    end
-
-    # Creates named routes for implementing verb-oriented controllers for a singleton resource. 
-    # A singleton resource is global to the current user visiting the application, such as a user's
-    # /account profile.
-    # 
-    # See map.resources for general conventions.  These are the main differences:
-    #   - a singular name is given to map.resource.  The default controller name is taken from the singular name.
-    #   - To specify a custom plural name, use the :plural option.  There is no :singular option
-    #   - No default index, new, or create routes are created for the singleton resource controller.
-    #   - When nesting singleton resources, only the singular name is used as the path prefix (example: 'account/messages/1')
-    #
-    # Example:
-    #
-    #   map.resource :account 
-    #
-    #   class AccountController < ActionController::Base
-    #     # POST account_url
-    #     def create
-    #       # create an account
-    #     end
-    #
-    #     # GET new_account_url
-    #     def new
-    #       # return an HTML form for describing the new account
-    #     end
-    #
-    #     # GET account_url
-    #     def show
-    #       # find and return the account
-    #     end
-    #
-    #     # GET edit_account_url
-    #     def edit
-    #       # return an HTML form for editing the account
-    #     end
-    #
-    #     # PUT account_url
-    #     def update
-    #       # find and update the account
-    #     end
-    #
-    #     # DELETE account_url
-    #     def destroy
-    #       # delete the account
-    #     end
-    #   end
-    #
-    # Along with the routes themselves, #resource generates named routes for use in
-    # controllers and views. <tt>map.resource :account</tt> produces the following named routes and helpers:
-    # 
-    #   Named Route   Helpers
-    #   account       account_url, hash_for_account_url, 
-    #                 account_path, hash_for_account_path
-    #   edit_account  edit_account_url, hash_for_edit_account_url,
-    #                 edit_account_path, hash_for_edit_account_path
-    def resource(*entities, &block)
-      options = entities.last.is_a?(Hash) ? entities.pop : { }
-      entities.each { |entity| map_singleton_resource entity, options.dup, &block }
-    end
-
-    private
-      def map_resource(entities, options = {}, &block)
-        resource = Resource.new(entities, options)
-
-        with_options :controller => resource.controller do |map|
-          map_collection_actions(map, resource)
-          map_default_collection_actions(map, resource)
-          map_new_actions(map, resource)
-          map_member_actions(map, resource)
-
-          if block_given?
-            with_options(:path_prefix => resource.nesting_path_prefix, &block)
-          end
-        end
-      end
-
-      def map_singleton_resource(entities, options = {}, &block)
-        resource = SingletonResource.new(entities, options)
-
-        with_options :controller => resource.controller do |map|
-          map_collection_actions(map, resource)
-          map_default_singleton_actions(map, resource)
-          map_new_actions(map, resource)
-          map_member_actions(map, resource)
-
-          if block_given?
-            with_options(:path_prefix => resource.nesting_path_prefix, &block)
-          end
-        end
-      end
-
-      def map_collection_actions(map, resource)
-        resource.collection_methods.each do |method, actions|
-          actions.each do |action|
-            action_options = action_options_for(action, resource, method)
-            map.named_route("#{resource.name_prefix}#{action}_#{resource.plural}", "#{resource.path};#{action}", action_options)
-            map.named_route("formatted_#{resource.name_prefix}#{action}_#{resource.plural}", "#{resource.path}.:format;#{action}", action_options)
-          end
-        end
-      end
-
-      def map_default_collection_actions(map, resource)
-        index_action_options = action_options_for("index", resource)
-        map.named_route("#{resource.name_prefix}#{resource.plural}", resource.path, index_action_options)
-        map.named_route("formatted_#{resource.name_prefix}#{resource.plural}", "#{resource.path}.:format", index_action_options)
-
-        create_action_options = action_options_for("create", resource)
-        map.connect(resource.path, create_action_options)
-        map.connect("#{resource.path}.:format", create_action_options)
-      end
-
-      def map_default_singleton_actions(map, resource)
-        create_action_options = action_options_for("create", resource)
-        map.connect(resource.path, create_action_options)
-        map.connect("#{resource.path}.:format", create_action_options)
-      end
-
-      def map_new_actions(map, resource)
-        resource.new_methods.each do |method, actions|
-          actions.each do |action|
-            action_options = action_options_for(action, resource, method)
-            if action == :new
-              map.named_route("#{resource.name_prefix}new_#{resource.singular}", resource.new_path, action_options)
-              map.named_route("formatted_#{resource.name_prefix}new_#{resource.singular}", "#{resource.new_path}.:format", action_options)
-            else
-              map.named_route("#{resource.name_prefix}#{action}_new_#{resource.singular}", "#{resource.new_path};#{action}", action_options)
-              map.named_route("formatted_#{resource.name_prefix}#{action}_new_#{resource.singular}", "#{resource.new_path}.:format;#{action}", action_options)
-            end
-          end
-        end
-      end
-
-      def map_member_actions(map, resource)
-        resource.member_methods.each do |method, actions|
-          actions.each do |action|
-            action_options = action_options_for(action, resource, method)
-            map.named_route("#{resource.name_prefix}#{action}_#{resource.singular}", "#{resource.member_path};#{action}", action_options)
-            map.named_route("formatted_#{resource.name_prefix}#{action}_#{resource.singular}", "#{resource.member_path}.:format;#{action}",action_options)
-          end
-        end
-
-        show_action_options = action_options_for("show", resource)
-        map.named_route("#{resource.name_prefix}#{resource.singular}", resource.member_path, show_action_options)
-        map.named_route("formatted_#{resource.name_prefix}#{resource.singular}", "#{resource.member_path}.:format", show_action_options)
-
-        update_action_options = action_options_for("update", resource)
-        map.connect(resource.member_path, update_action_options)
-        map.connect("#{resource.member_path}.:format", update_action_options)
-
-        destroy_action_options = action_options_for("destroy", resource)
-        map.connect(resource.member_path, destroy_action_options)
-        map.connect("#{resource.member_path}.:format", destroy_action_options)
-      end
-
-      def conditions_for(method)
-        { :conditions => method == :any ? {} : { :method => method } }
-      end
-
-      def action_options_for(action, resource, method = nil)
-        default_options = { :action => action.to_s }
-        require_id = resource.kind_of?(SingletonResource) ? {} : { :requirements => { :id => Regexp.new("[^#{Routing::SEPARATORS.join}]+") } }
-        case default_options[:action]
-          when "index", "new" : default_options.merge(conditions_for(method || :get))
-          when "create"       : default_options.merge(conditions_for(method || :post))
-          when "show", "edit" : default_options.merge(conditions_for(method || :get)).merge(require_id)
-          when "update"       : default_options.merge(conditions_for(method || :put)).merge(require_id)
-          when "destroy"      : default_options.merge(conditions_for(method || :delete)).merge(require_id)
-          else                  default_options.merge(conditions_for(method))
-        end
-      end
-  end
-end
-
-ActionController::Routing::RouteSet::Mapper.send :include, ActionController::Resources