actionpack 3.0.20 → 3.1.0.beta1

data/lib/action_controller/caching.rb

@@ -3,7 +3,7 @@ require 'uri'
 require 'set'
 
 module ActionController #:nodoc:
-  # Caching is a cheap way of speeding up slow applications by keeping the result of
+  # \Caching is a cheap way of speeding up slow applications by keeping the result of
   # calculations, renderings, and database calls around for subsequent requests.
   # Action Controller affords you three approaches in varying levels of granularity:
   # Page, Action, Fragment.
@@ -14,7 +14,7 @@ module ActionController #:nodoc:
   # Note: To turn off all caching and sweeping, set
   #   config.action_controller.perform_caching = false.
   #
-  # == Caching stores
+  # == \Caching stores
   #
   # All the caching stores from ActiveSupport::Cache are available to be used as backends
   # for Action Controller caching. This setting only affects action and fragment caching

data/lib/action_controller/caching/actions.rb

@@ -31,8 +31,8 @@ module ActionController #:nodoc:
     # the subdomain-as-account-key pattern.
     #
     # Different representations of the same resource, e.g.
-    # <tt>http://david.somewhere.com/lists</tt> and
-    # <tt>http://david.somewhere.com/lists.xml</tt>
+    # <tt>http://david.example.com/lists</tt> and
+    # <tt>http://david.example.com/lists.xml</tt>
     # are treated like separate requests and so are cached separately.
     # Keep in mind when expiring an action cache that
     # <tt>:action => 'lists'</tt> is not the same as
@@ -56,19 +56,18 @@ module ActionController #:nodoc:
     #
     #     caches_page :public
     #
-    #     caches_action :index, :if => proc do |c|
-    #       !c.request.format.json?  # cache if is not a JSON request
+    #     caches_action :index, :if => proc do
+    #       !request.format.json?  # cache if is not a JSON request
     #     end
     #
     #     caches_action :show, :cache_path => { :project => 1 },
     #       :expires_in => 1.hour
     #
-    #     caches_action :feed, :cache_path => proc do |c|
-    #       if c.params[:user_id]
-    #         c.send(:user_list_url,
-    #           c.params[:user_id], c.params[:id])
+    #     caches_action :feed, :cache_path => proc do
+    #       if params[:user_id]
+    #         user_list_url(params[:user_id, params[:id])
     #       else
-    #         c.send(:list_url, c.params[:id])
+    #         list_url(params[:id])
     #       end
     #     end
     #   end
@@ -80,7 +79,7 @@ module ActionController #:nodoc:
     # header the Content-Type of the cached response could be wrong because
     # no information about the MIME type is stored in the cache key. So, if
     # you first ask for MIME type M in the Accept header, a cache entry is
-    # created, and then perform a second resquest to the same resource asking
+    # created, and then perform a second request to the same resource asking
     # for a different MIME type, you'd get the content cached for M.
     #
     # The <tt>:format</tt> parameter is taken into account though. The safest
@@ -160,7 +159,7 @@ module ActionController #:nodoc:
         attr_reader :path, :extension
 
         # If +infer_extension+ is true, the cache path extension is looked up from the request's
-        # path & format. This is desirable when reading and writing the cache, but not when
+        # path and format. This is desirable when reading and writing the cache, but not when
         # expiring the cache - expire_action should expire the same files regardless of the
         # request format.
         def initialize(controller, options = {}, infer_extension = true)
@@ -177,7 +176,7 @@ module ActionController #:nodoc:
         def normalize!(path)
           path << 'index' if path[-1] == ?/
           path << ".#{extension}" if extension and !path.ends_with?(extension)
-          URI.unescape(path)
+          URI.parser.unescape(path)
         end
       end
     end

data/lib/action_controller/caching/fragments.rb

@@ -1,52 +1,72 @@
 module ActionController #:nodoc:
   module Caching
-    # Fragment caching is used for caching various blocks within templates without caching the entire action as a whole. This is useful when
-    # certain elements of an action change frequently or depend on complicated state while other parts rarely change or can be shared amongst multiple
-    # parties. The caching is done using the cache helper available in the Action View. A template with caching might look something like:
+    # Fragment caching is used for caching various blocks within 
+    # views without caching the entire action as a whole. This is
+    # useful when certain elements of an action change frequently or 
+    # depend on complicated state while other parts rarely change or 
+    # can be shared amongst multiple parties. The caching is done using
+    # the <tt>cache</tt> helper available in the Action View. A 
+    # template with fragment caching might look like:
     #
     #   <b>Hello <%= @name %></b>
+    #
     #   <% cache do %>
     #     All the topics in the system:
     #     <%= render :partial => "topic", :collection => Topic.find(:all) %>
     #   <% end %>
     #
-    # This cache will bind to the name of the action that called it, so if this code was part of the view for the topics/list action, you would
-    # be able to invalidate it using <tt>expire_fragment(:controller => "topics", :action => "list")</tt>.
+    # This cache will bind the name of the action that called it, so if
+    # this code was part of the view for the topics/list action, you 
+    # would be able to invalidate it using:
+    #   
+    #   expire_fragment(:controller => "topics", :action => "list")
     #
-    # This default behavior is of limited use if you need to cache multiple fragments per action or if the action itself is cached using
-    # <tt>caches_action</tt>, so we also have the option to qualify the name of the cached fragment with something like:
+    # This default behavior is limited if you need to cache multiple 
+    # fragments per action or if the action itself is cached using 
+    # <tt>caches_action</tt>. To remedy this, there is an option to 
+    # qualify the name of the cached fragment by using the 
+    # <tt>:action_suffix</tt> option:
     #
     #   <% cache(:action => "list", :action_suffix => "all_topics") do %>
     #
-    # That would result in a name such as "/topics/list/all_topics", avoiding conflicts with the action cache and with any fragments that use a
-    # different suffix. Note that the URL doesn't have to really exist or be callable - the url_for system is just used to generate unique
-    # cache names that we can refer to when we need to expire the cache.
+    # That would result in a name such as 
+    # <tt>/topics/list/all_topics</tt>, avoiding conflicts with the 
+    # action cache and with any fragments that use a different suffix.
+    # Note that the URL doesn't have to really exist or be callable
+    # - the url_for system is just used to generate unique cache names
+    # that we can refer to when we need to expire the cache.
     #
     # The expiration call for this example is:
     #
-    #   expire_fragment(:controller => "topics", :action => "list", :action_suffix => "all_topics")
+    #   expire_fragment(:controller => "topics", 
+    #                   :action => "list", 
+    #                   :action_suffix => "all_topics")
     module Fragments
-      # Given a key (as described in <tt>expire_fragment</tt>), returns a key suitable for use in reading,
-      # writing, or expiring a cached fragment. If the key is a hash, the generated key is the return
-      # value of url_for on that hash (without the protocol). All keys are prefixed with "views/" and uses
+      # Given a key (as described in <tt>expire_fragment</tt>), returns
+      # a key suitable for use in reading, writing, or expiring a 
+      # cached fragment. If the key is a hash, the generated key is the
+      # return value of url_for on that hash (without the protocol). 
+      # All keys are prefixed with <tt>views/</tt> and uses
       # ActiveSupport::Cache.expand_cache_key for the expansion.
       def fragment_cache_key(key)
         ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
       end
 
-      # Writes <tt>content</tt> to the location signified by <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats)
+      # Writes <tt>content</tt> to the location signified by 
+      # <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats).
       def write_fragment(key, content, options = nil)
         return content unless cache_configured?
 
         key = fragment_cache_key(key)
         instrument_fragment_cache :write_fragment, key do
-          content = content.html_safe.to_str if content.respond_to?(:html_safe)
+          content = content.to_str
           cache_store.write(key, content, options)
         end
         content
       end
 
-      # Reads a cached fragment from the location signified by <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats)
+      # Reads a cached fragment from the location signified by <tt>key</tt>
+      # (see <tt>expire_fragment</tt> for acceptable formats).
       def read_fragment(key, options = nil)
         return unless cache_configured?
 
@@ -57,7 +77,8 @@ module ActionController #:nodoc:
         end
       end
 
-      # Check if a cached fragment from the location signified by <tt>key</tt> exists (see <tt>expire_fragment</tt> for acceptable formats)
+      # Check if a cached fragment from the location signified by 
+      # <tt>key</tt> exists (see <tt>expire_fragment</tt> for acceptable formats)
       def fragment_exist?(key, options = nil)
         return unless cache_configured?
         key = fragment_cache_key(key)
@@ -70,8 +91,9 @@ module ActionController #:nodoc:
       # Removes fragments from the cache.
       #
       # +key+ can take one of three forms:
+      #
       # * String - This would normally take the form of a path, like
-      #   <tt>"pages/45/notes"</tt>.
+      #   <tt>pages/45/notes</tt>.
       # * Hash - Treated as an implicit call to +url_for+, like
       #   <tt>{:controller => "pages", :action => "notes", :id => 45}</tt>
       # * Regexp - Will remove any fragment that matches, so

data/lib/action_controller/caching/pages.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'uri'
 require 'active_support/core_ext/class/attribute_accessors'
 
 module ActionController #:nodoc:
@@ -99,7 +98,7 @@ module ActionController #:nodoc:
 
         private
           def page_cache_file(path, extension)
-            name = (path.empty? || path == "/") ? "/index" : URI.unescape(path.chomp('/'))
+            name = (path.empty? || path == "/") ? "/index" : URI.parser.unescape(path.chomp('/'))
             unless (name.split('/').last || name).include? '.'
               name << (extension || self.page_cache_extension)
             end
@@ -107,7 +106,7 @@ module ActionController #:nodoc:
           end
 
           def page_cache_path(path, extension = nil)
-            page_cache_directory + page_cache_file(path, extension)
+            page_cache_directory.to_s + page_cache_file(path, extension)
           end
 
           def instrument_page_cache(name, path)
@@ -137,7 +136,7 @@ module ActionController #:nodoc:
       # If no options are provided, the requested url is used. Example:
       #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
       def cache_page(content = nil, options = nil)
-        return unless self.class.perform_caching && caching_allowed
+        return unless self.class.perform_caching && caching_allowed?
 
         path = case options
           when Hash
@@ -148,7 +147,6 @@ module ActionController #:nodoc:
             request.path
         end
 
-
         if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
           extension = ".#{type_symbol}"
         end
@@ -156,10 +154,6 @@ module ActionController #:nodoc:
         self.class.cache_page(content || response.body, path, extension)
       end
 
-      private
-        def caching_allowed
-          request.get? && response.status.to_i == 200
-        end
     end
   end
 end

data/lib/action_controller/caching/sweeping.rb

@@ -61,7 +61,6 @@ module ActionController #:nodoc:
         end
 
         def after(controller)
-          self.controller = controller
           callback(:after) if controller.perform_caching
           # Clean up, so that the controller can be collected after this request
           self.controller = nil

data/lib/action_controller/deprecated.rb

@@ -1,3 +1,3 @@
 ActionController::AbstractRequest = ActionController::Request = ActionDispatch::Request
 ActionController::AbstractResponse = ActionController::Response = ActionDispatch::Response
-ActionController::Routing = ActionDispatch::Routing
+ActionController::Routing = ActionDispatch::Routing

data/lib/action_controller/log_subscriber.rb

@@ -46,7 +46,7 @@ module ActionController
         def #{method}(event)
           key_or_path = event.payload[:key] || event.payload[:path]
           human_name  = #{method.to_s.humanize.inspect}
-          info("\#{human_name} \#{key_or_path} (%.1fms)" % event.duration)
+          info("\#{human_name} \#{key_or_path} \#{"(%.1fms)" % event.duration}")
         end
       METHOD
     end

data/lib/action_controller/metal.rb

@@ -36,35 +36,88 @@ module ActionController
       action = action.to_s
       raise "MiddlewareStack#build requires an app" unless app
 
-      reverse.inject(app) do |a, middleware|
+      middlewares.reverse.inject(app) do |a, middleware|
         middleware.valid?(action) ?
           middleware.build(a) : a
       end
     end
   end
 
-  # ActionController::Metal provides a way to get a valid Rack application from a controller.
+  # <tt>ActionController::Metal</tt> is the simplest possible controller, providing a
+  # valid Rack interface without the additional niceties provided by
+  # <tt>ActionController::Base</tt>.
+  #
+  # A sample metal controller might look like this:
+  #
+  #   class HelloController < ActionController::Metal
+  #     def index
+  #       self.response_body = "Hello World!"
+  #     end
+  #   end
+  #
+  # And then to route requests to your metal controller, you would add
+  # something like this to <tt>config/routes.rb</tt>:
+  #
+  #   match 'hello', :to => HelloController.action(:index)
+  #
+  # The +action+ method returns a valid Rack application for the \Rails
+  # router to dispatch to.
+  #
+  # == Rendering Helpers
+  #
+  # <tt>ActionController::Metal</tt> by default provides no utilities for rendering
+  # views, partials, or other responses aside from explicitly calling of
+  # <tt>response_body=</tt>, <tt>content_type=</tt>, and <tt>status=</tt>. To
+  # add the render helpers you're used to having in a normal controller, you
+  # can do the following:
+  #
+  #   class HelloController < ActionController::Metal
+  #     include ActionController::Rendering
+  #     append_view_path "#{Rails.root}/app/views"
+  #
+  #     def index
+  #       render "hello/index"
+  #     end
+  #   end
+  #
+  # == Redirection Helpers
+  #
+  # To add redirection helpers to your metal controller, do the following:
+  #
+  #   class HelloController < ActionController::Metal
+  #     include ActionController::Redirecting
+  #     include Rails.application.routes.url_helpers
+  #
+  #     def index
+  #       redirect_to root_url
+  #     end
+  #   end
+  #
+  # == Other Helpers
+  #
+  # You can refer to the modules included in <tt>ActionController::Base</tt> to see
+  # other features you can bring into your metal controller.
   #
-  # In AbstractController, dispatching is triggered directly by calling #process on a new controller.
-  # ActionController::Metal provides an #action method that returns a valid Rack application for a
-  # given action. Other rack builders, such as Rack::Builder, Rack::URLMap, and the Rails router,
-  # can dispatch directly to the action returned by FooController.action(:index).
   class Metal < AbstractController::Base
     abstract!
 
-    attr_internal :env
+    attr_internal_writer :env
+
+    def env
+      @_env ||= {}
+    end
 
     # Returns the last part of the controller's name, underscored, without the ending
-    # "Controller". For instance, MyApp::MyPostsController would return "my_posts" for
-    # controller_name
+    # <tt>Controller</tt>. For instance, PostsController returns <tt>posts</tt>.
+    # Namespaces are left out, so Admin::PostsController returns <tt>posts</tt> as well.
     #
     # ==== Returns
-    # String
+    # * <tt>string</tt>
     def self.controller_name
       @controller_name ||= self.name.demodulize.sub(/Controller$/, '').underscore
     end
 
-    # Delegates to the class' #controller_name
+    # Delegates to the class' <tt>controller_name</tt>
     def controller_name
       self.class.controller_name
     end
@@ -78,9 +131,12 @@ module ActionController
     attr_internal :headers, :response, :request
     delegate :session, :to => "@_request"
 
-    def initialize(*)
+    def initialize
       @_headers = {"Content-Type" => "text/html"}
       @_status = 200
+      @_request = nil
+      @_response = nil
+      @_routes = nil
       super
     end
 
@@ -126,12 +182,11 @@ module ActionController
     end
 
     def response_body=(val)
-      body = val.respond_to?(:each) ? val : [val]
+      body = val.nil? ? nil : (val.respond_to?(:each) ? val : [val])
       super body
     end
 
-    # :api: private
-    def dispatch(name, request)
+    def dispatch(name, request) #:nodoc:
       @_request = request
       @_env = request.env
       @_env['action_controller.instance'] = self
@@ -139,27 +194,30 @@ module ActionController
       to_a
     end
 
-    # :api: private
-    def to_a
+    def to_a #:nodoc:
       response ? response.to_a : [status, headers, response_body]
     end
 
     class_attribute :middleware_stack
     self.middleware_stack = ActionController::MiddlewareStack.new
 
-    def self.inherited(base)
+    def self.inherited(base) #nodoc:
       base.middleware_stack = self.middleware_stack.dup
       super
     end
 
+    # Adds given middleware class and its args to bottom of middleware_stack
     def self.use(*args, &block)
       middleware_stack.use(*args, &block)
     end
 
+    # Alias for middleware_stack
     def self.middleware
       middleware_stack
     end
 
+    # Makes the controller a rack endpoint that points to the action in
+    # the given env's action_dispatch.request.path_parameters key.
     def self.call(env)
       action(env['action_dispatch.request.path_parameters'][:action]).call(env)
     end
@@ -169,10 +227,10 @@ module ActionController
     # for the same action.
     #
     # ==== Parameters
-    # action<#to_s>:: An action name
+    # * <tt>action</tt> - An action name
     #
     # ==== Returns
-    # Proc:: A rack application
+    # * <tt>proc</tt> - A rack application
     def self.action(name, klass = ActionDispatch::Request)
       middleware_stack.build(name.to_s) do |env|
         new.dispatch(name, klass.new(env))

data/lib/action_controller/metal/compatibility.rb

@@ -5,9 +5,6 @@ module ActionController
     class ::ActionController::ActionControllerError < StandardError #:nodoc:
     end
 
-    module ClassMethods
-    end
-
     # Temporary hax
     included do
       ::ActionController::UnknownAction = ::AbstractController::ActionNotFound
@@ -39,12 +36,6 @@ module ActionController
     def assign_shortcuts(*) end
 
     def _normalize_options(options)
-      if options[:action] && options[:action].to_s.include?(?/)
-        ActiveSupport::Deprecation.warn "Giving a path to render :action is deprecated. " <<
-          "Please use render :template instead", caller
-        options[:template] = options.delete(:action)
-      end
-
       options[:text] = nil if options.delete(:nothing) == true
       options[:text] = " " if options.key?(:text) && options[:text].nil?
       super