actionpack 1.12.5 → 1.13.0

data/lib/action_controller/mime_type.rb

@@ -1,5 +1,18 @@
 module Mime
-  class Type #:nodoc:
+  # Encapsulates the notion of a mime type. Can be used at render time, for example, with:
+  #
+  #   class PostsController < ActionController::Base
+  #     def show
+  #       @post = Post.find(params[:id])
+  #
+  #       respond_to do |format|
+  #         format.html
+  #         format.ics { render :text => post.to_ics, :mime_type => Mime::Type["text/calendar"]  }
+  #         format.xml { render :xml => @people.to_xml }
+  #       end
+  #     end
+  #   end
+  class Type
     # A simple helper class used in parsing the accept header
     class AcceptItem #:nodoc:
       attr_accessor :order, :name, :q
@@ -31,14 +44,20 @@ module Mime
         LOOKUP[string]
       end
 
+      def register(string, symbol, synonyms = [])
+        Mime.send :const_set, symbol.to_s.upcase, Type.new(string, symbol, synonyms)
+        SET << Mime.send(:const_get, symbol.to_s.upcase)
+        LOOKUP[string] = EXTENSION_LOOKUP[symbol.to_s] = SET.last        
+      end
+
       def parse(accept_header)
         # keep track of creation order to keep the subsequent sort stable
         index = 0
-        list = accept_header.split(/,/).
-          map! { |i| AcceptItem.new(index += 1, *i.split(/;\s*q=/)) }.sort!
+        list = accept_header.split(/,/).map! do |i| 
+          AcceptItem.new(index += 1, *i.split(/;\s*q=/))
+        end.sort!
 
         # Take care of the broken text/xml entry by renaming or deleting it
-  
         text_xml = list.index("text/xml")
         app_xml = list.index("application/xml")
 
@@ -112,31 +131,70 @@ module Mime
   end
 
   ALL   = Type.new "*/*", :all
+  TEXT  = Type.new "text/plain", :text
   HTML  = Type.new "text/html", :html, %w( application/xhtml+xml )
   JS    = Type.new "text/javascript", :js, %w( application/javascript application/x-javascript )
+  ICS   = Type.new "text/calendar", :ics
+  CSV   = Type.new "text/csv", :csv
   XML   = Type.new "application/xml", :xml, %w( text/xml application/x-xml )
   RSS   = Type.new "application/rss+xml", :rss
   ATOM  = Type.new "application/atom+xml", :atom
   YAML  = Type.new "application/x-yaml", :yaml, %w( text/yaml )
+  JSON  = Type.new "application/json", :json, %w( text/x-json )
+
+  SET   = [ ALL, TEXT, HTML, JS, ICS, XML, RSS, ATOM, YAML, JSON ]
 
-  LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) }
+  LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k == "" }
 
   LOOKUP["*/*"]                      = ALL
 
+  LOOKUP["text/plain"]               = TEXT
+
   LOOKUP["text/html"]                = HTML
   LOOKUP["application/xhtml+xml"]    = HTML
 
-  LOOKUP["application/xml"]          = XML
-  LOOKUP["text/xml"]                 = XML
-  LOOKUP["application/x-xml"]        = XML
-
   LOOKUP["text/javascript"]          = JS
   LOOKUP["application/javascript"]   = JS
   LOOKUP["application/x-javascript"] = JS
 
+  LOOKUP["text/calendar"]            = ICS
+
+  LOOKUP["text/csv"]                 = CSV
+
+  LOOKUP["application/xml"]          = XML
+  LOOKUP["text/xml"]                 = XML
+  LOOKUP["application/x-xml"]        = XML
+
   LOOKUP["text/yaml"]                = YAML
   LOOKUP["application/x-yaml"]       = YAML
 
   LOOKUP["application/rss+xml"]      = RSS
   LOOKUP["application/atom+xml"]     = ATOM
-end
+
+  LOOKUP["application/json"]         = JSON
+  LOOKUP["text/x-json"]              = JSON
+
+
+  EXTENSION_LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k == "" }
+
+  EXTENSION_LOOKUP["html"]  = HTML
+  EXTENSION_LOOKUP["xhtml"] = HTML
+
+  EXTENSION_LOOKUP["txt"]   = TEXT
+
+  EXTENSION_LOOKUP["xml"]   = XML
+
+  EXTENSION_LOOKUP["js"]    = JS
+
+  EXTENSION_LOOKUP["ics"]   = ICS
+
+  EXTENSION_LOOKUP["csv"]   = CSV
+
+  EXTENSION_LOOKUP["yml"]   = YAML
+  EXTENSION_LOOKUP["yaml"]  = YAML
+
+  EXTENSION_LOOKUP["rss"]   = RSS
+  EXTENSION_LOOKUP["atom"]  = ATOM
+
+  EXTENSION_LOOKUP["json"]  = JSON
+end

data/lib/action_controller/pagination.rb

@@ -1,6 +1,8 @@
 module ActionController
   # === Action Pack pagination for Active Record collections
   #
+  # DEPRECATION WARNING: Pagination will be separated into its own plugin with Rails 2.0.
+  #
   # The Pagination module aids in the process of paging large collections of
   # Active Record objects. It offers macro-style automatic fetching of your
   # model for multiple views, or explicit fetching for single actions. And if
@@ -104,8 +106,7 @@ module ActionController
     # ClassMethods#paginate.
     #
     # +options+ are:
-    # <tt>:singular_name</tt>:: the singular name to use, if it can't be inferred by
-    #                        singularizing the collection name
+    # <tt>:singular_name</tt>:: the singular name to use, if it can't be inferred by singularizing the collection name
     # <tt>:class_name</tt>:: the class name to use, if it can't be inferred by
     #                        camelizing the singular name
     # <tt>:per_page</tt>::   the maximum number of items to include in a 
@@ -192,7 +193,7 @@ module ActionController
 
     def paginator_and_collection_for(collection_id, options) #:nodoc:
       klass = options[:class_name].constantize
-      page  = @params[options[:parameter]]
+      page  = params[options[:parameter]]
       count = count_collection_for_pagination(klass, options)
       paginator = Paginator.new(self, count, options[:per_page], page)
       collection = find_collection_for_pagination(klass, options, paginator)

data/lib/action_controller/request.rb

@@ -13,12 +13,18 @@ module ActionController
       @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)
+    # 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 ||= @env['REQUEST_METHOD'].downcase.to_sym
+      @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 request?  Equivalent to request.method == :get
+    # Is this a GET (or HEAD) request?  Equivalent to request.method == :get
     def get?
       method == :get
     end
@@ -38,9 +44,10 @@ module ActionController
       method == :delete
     end
 
-    # Is this a HEAD request?  Equivalent to request.method == :head
+    # 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?
-      method == :head
+      @env['REQUEST_METHOD'].downcase.to_sym == :head
     end
 
     # Determine whether the body of a HTTP call is URL-encoded (default)
@@ -128,19 +135,21 @@ module ActionController
       @env['RAW_POST_DATA']
     end
 
-    # Returns the request URI correctly, taking into account the idiosyncracies
-    # of the various servers.
+    # 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']
-        (%r{^\w+\://[^/]+(/.*|$)$} =~ uri) ? $1 : uri # Remove domain, which webrick puts into the request_uri.
-      else  # REQUEST_URI is blank under IIS - get this from PATH_INFO and SCRIPT_NAME
+        # 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
-        uri
+        @env['REQUEST_URI'] = uri
       end
     end
 
@@ -159,11 +168,10 @@ module ActionController
       path = (uri = request_uri) ? uri.split('?').first : ''
 
       # Cut off the path to the installation directory if given
-      root = relative_url_root
-      path[0, root.length] = '' if root
-      path || ''
+      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

data/lib/action_controller/rescue.rb

@@ -6,12 +6,10 @@ module ActionController #:nodoc:
   #
   # You can tailor the rescuing behavior and appearance by overwriting the following two stub methods.
   module Rescue
-    def self.append_features(base) #:nodoc:
-      super
+    def self.included(base) #:nodoc:
       base.extend(ClassMethods)
       base.class_eval do
-        alias_method :perform_action_without_rescue, :perform_action
-        alias_method :perform_action, :perform_action_with_rescue
+        alias_method_chain :perform_action, :rescue
       end
     end
 
@@ -36,23 +34,26 @@ module ActionController #:nodoc:
 
       # Overwrite to implement custom logging of errors. By default logs as fatal.
       def log_error(exception) #:doc:
-        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"
-          )
+        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 then
+          when RoutingError, UnknownAction
             render_text(IO.read(File.join(RAILS_ROOT, 'public', '404.html')), "404 Not Found")
-          else render_text "<html><body><h1>Application error (Rails)</h1></body></html>"
+          else
+            render_text(IO.read(File.join(RAILS_ROOT, 'public', '500.html')), "500 Internal Error")
         end
       end
 
@@ -60,19 +61,19 @@ module ActionController #:nodoc:
       # 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
+        [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(__FILE__) + "/templates/rescues/")    
+        @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))
     
-        @headers["Content-Type"] = "text/html"
+        response.content_type = Mime::HTML
         render_file(rescues_path("layout"), response_code_for_rescue(exception))
       end
     
@@ -80,8 +81,8 @@ module ActionController #:nodoc:
       def perform_action_with_rescue #:nodoc:
         begin
           perform_action_without_rescue
-        rescue Object => exception
-          if defined?(Breakpoint) && @params["BP-RETRY"]
+        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
@@ -89,7 +90,7 @@ module ActionController #:nodoc:
               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
+                  params["BP-RETRY"] = false
 
                   callstack = caller
                   callstack.slice!(0) if callstack.first["rescue.rb"]
@@ -127,8 +128,10 @@ module ActionController #:nodoc:
       
       def response_code_for_rescue(exception)
         case exception
-          when UnknownAction, RoutingError then "404 Page Not Found"
-          else "500 Internal Error"
+          when UnknownAction, RoutingError 
+            "404 Page Not Found"
+          else
+            "500 Internal Error"
         end
       end
       

data/lib/action_controller/resources.rb

@@ -0,0 +1,302 @@
+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
+        (options[:controller] || plural).to_s
+      end
+      
+      def path
+        "#{path_prefix}/#{plural}"
+      end
+      
+      def new_path
+        "#{path}/new"
+      end
+      
+      def member_path
+        "#{path}/:id"
+      end
+      
+      def nesting_path_prefix
+        "#{path}/:#{singular}_id"
+      end
+      
+      private
+        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
+    
+    # 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, 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
+
+    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_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|
+          route_options = requirements_for(method)
+
+          actions.each do |action|
+            map.named_route(
+              "#{resource.name_prefix}#{action}_#{resource.plural}", 
+              "#{resource.path};#{action}", 
+              route_options.merge(:action => action.to_s)
+            )
+
+            map.named_route(
+              "formatted_#{resource.name_prefix}#{action}_#{resource.plural}",
+              "#{resource.path}.:format;#{action}",
+              route_options.merge(:action => action.to_s)
+            )
+          end
+        end
+
+        map.named_route("#{resource.name_prefix}#{resource.plural}", resource.path, :action => "index", :conditions => { :method => :get })
+        map.named_route("formatted_#{resource.name_prefix}#{resource.plural}", "#{resource.path}.:format", :action => "index", :conditions => { :method => :get })
+
+        map.connect(resource.path, :action => "create", :conditions => { :method => :post })
+        map.connect("#{resource.path}.:format", :action => "create", :conditions => { :method => :post })
+      end
+
+      def map_new_actions(map, resource)
+        resource.new_methods.each do |method, actions|
+          route_options = requirements_for(method)
+          actions.each do |action|
+            if action == :new
+              map.named_route("#{resource.name_prefix}new_#{resource.singular}", resource.new_path, route_options.merge(:action => "new"))
+              map.named_route("formatted_#{resource.name_prefix}new_#{resource.singular}", "#{resource.new_path}.:format", route_options.merge(:action => "new"))
+            else
+              map.named_route("#{resource.name_prefix}#{action}_new_#{resource.singular}", "#{resource.new_path};#{action}", route_options.merge(:action => action.to_s))
+              map.named_route("formatted_#{resource.name_prefix}#{action}_new_#{resource.singular}", "#{resource.new_path}.:format;#{action}", route_options.merge(:action => action.to_s))
+            end
+          end
+        end
+      end
+      
+      def map_member_actions(map, resource)
+        resource.member_methods.each do |method, actions|
+          route_options = requirements_for(method)
+
+          actions.each do |action|
+            map.named_route("#{resource.name_prefix}#{action}_#{resource.singular}", "#{resource.member_path};#{action}", route_options.merge(:action => action.to_s))
+            map.named_route("formatted_#{resource.name_prefix}#{action}_#{resource.singular}", "#{resource.member_path}.:format;#{action}", route_options.merge(:action => action.to_s))
+          end
+        end
+
+        map.named_route("#{resource.name_prefix}#{resource.singular}", resource.member_path, :action => "show", :conditions => { :method => :get })
+        map.named_route("formatted_#{resource.name_prefix}#{resource.singular}", "#{resource.member_path}.:format", :action => "show", :conditions => { :method => :get })
+
+        map.connect(resource.member_path, :action => "update", :conditions => { :method => :put })
+        map.connect("#{resource.member_path}.:format", :action => "update", :conditions => { :method => :put })
+
+        map.connect(resource.member_path, :action => "destroy", :conditions => { :method => :delete })
+        map.connect("#{resource.member_path}.:format", :action => "destroy", :conditions => { :method => :delete })
+      end
+    
+      def requirements_for(method)
+        method == :any ? {} : { :conditions => { :method => method } }
+      end
+  end
+end
+
+ActionController::Routing::RouteSet::Mapper.send :include, ActionController::Resources