radiant 0.5.2 → 0.6.0

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

@@ -0,0 +1,265 @@
+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/vendor/rails/actionpack/lib/action_controller/rescue.rb

@@ -0,0 +1,142 @@
+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/vendor/rails/actionpack/lib/action_controller/resources.rb

@@ -0,0 +1,405 @@
+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