actionpack 1.9.1 → 1.10.1

data/lib/action_controller/base.rb

@@ -25,6 +25,9 @@ module ActionController #:nodoc:
   end
   class MissingFile < ActionControllerError #:nodoc:
   end
+  class SessionOverflowError < ActionControllerError #:nodoc:
+    DEFAULT_MESSAGE = 'Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data.'
+  end
   class DoubleRenderError < ActionControllerError #:nodoc:
     DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and only once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\". Finally, note that to cause a before filter to halt execution of the rest of the filter chain, the filter must return false, explicitly, so \"render(...) and return false\"." 
 
@@ -43,7 +46,7 @@ module ActionController #:nodoc:
   #     end
   #     
   #     def sign
-  #       Entry.create(@params["entry"])
+  #       Entry.create(params[:entry])
   #       redirect_to :action => "index"
   #     end
   #   end
@@ -80,7 +83,7 @@ module ActionController #:nodoc:
   #
   #   def hello_ip
   #     location = request.env["REMOTE_IP"]
-  #     render_text "Hello stranger from #{location}"
+  #     render :text => "Hello stranger from #{location}"
   #   end
   #
   # == Parameters
@@ -117,7 +120,7 @@ module ActionController #:nodoc:
   # 50kb object could lead to a 50MB memory overhead. In other words, think carefully about size and caching before resorting to the use
   # of the session.
   #
-  # For removing objects from the session, you can either assign a single key to nil, like <tt>@session[:person] = nil</tt>, or you can
+  # For removing objects from the session, you can either assign a single key to nil, like <tt>session[:person] = nil</tt>, or you can
   # remove the entire session with reset_session.
   #
   # == Responses
@@ -196,7 +199,9 @@ module ActionController #:nodoc:
   #   def do_something
   #     redirect_to(:action => "elsewhere") and return if monkeys.nil?
   #     render :action => "overthere" # won't be called unless monkeys is nil
-  #   end  # == Environments
+  #   end
+  #
+  # == Environments
   #
   # Action Controller works out of the box with CGI, FastCGI, and mod_ruby. CGI and mod_ruby controllers are triggered just the same using:
   #
@@ -206,8 +211,6 @@ module ActionController #:nodoc:
   #
   #   FCGI.each_cgi{ |cgi| WeblogController.process_cgi(cgi) }
   class Base
-    include ClassInheritableAttributes
-  
     DEFAULT_RENDER_STATUS_CODE = "200 OK"
   
     # Determines whether the view has access to controller internals @request, @response, @session, and @template.
@@ -215,6 +218,10 @@ module ActionController #:nodoc:
     @@view_controller_internals = true
     cattr_accessor :view_controller_internals
 
+    # Protected instance variable cache
+    @@protected_variables_cache = nil
+    cattr_accessor :protected_variables_cache
+
     # Prepends all the URL-generating helpers from AssetHelper. This makes it possible to easily move javascripts, stylesheets, 
     # and images to a dedicated asset server away from the main web server. Example: 
     #   ActionController::Base.asset_host = "http://assets.example.com"
@@ -257,7 +264,7 @@ module ActionController #:nodoc:
     # <tt>request.env["REQUEST_URI"]</tt>.
     attr_accessor :request
     
-    # Holds a hash of all the GET, POST, and Url parameters passed to the action. Accessed like <tt>@params["post_id"]</tt>
+    # Holds a hash of all the GET, POST, and Url parameters passed to the action. Accessed like <tt>params["post_id"]</tt>
     # to get the post_id. No type casts are made, so all values are returned as strings.
     attr_accessor :params
     
@@ -350,13 +357,14 @@ module ActionController #:nodoc:
         initialize_template_class(response)
         assign_shortcuts(request, response)
         initialize_current_url
-        @action_name = params[:action] || 'index'
+        @action_name = params['action'] || 'index'
+        @variables_added = nil
 
-        log_processing unless logger.nil?
+        log_processing if logger
         send(method, *arguments)
         close_session
 
-        return @response
+        @response
       end
 
       # Returns a URL that has been rewritten according to the options hash and the defined Routes. 
@@ -420,19 +428,14 @@ module ActionController #:nodoc:
       #
       #   url_for :controller => 'posts', :action => nil
       #      
-      # Instead of passing an options hash, you can also pass a method reference in the form of a symbol. Consider this example:
-      #
-      #   class WeblogController < ActionController::Base
-      #     def update
-      #       # do some update
-      #       redirect_to :dashboard_url
-      #     end
-      #     
-      #     protected
-      #       def dashboard_url
-      #         url_for :controller => (@project.active? ? "project" : "account"), :action => "dashboard"
-      #       end
-      #   end
+      # If you explicitly want to create a URL that's almost the same as the current URL, you can do so using the
+      # :overwrite_params options. Say for your posts you have different views for showing and printing them.
+      # Then, in the show view, you get the URL for the print view like this
+      #
+      #   url_for :overwrite_params => { :action => 'print' }
+      #
+      # This takes the current URL as is and only exchanges the action. In contrast, <tt>url_for :action => 'print'</tt>
+      # would have slashed-off the path components are the changed action.
       def url_for(options = {}, *parameters_for_method_reference) #:doc:
         case options
           when String then options
@@ -469,7 +472,7 @@ module ActionController #:nodoc:
       #
       #   # Renders the template for the action "long_goal" within the current controller,
       #   # but with a custom layout
-      #   render :action => "short_goal", :layout => "spectacular"
+      #   render :action => "long_goal", :layout => "spectacular"
       #
       # _Deprecation_ _notice_: This used to have the signatures <tt>render_action("action", status = 200)</tt>,
       # <tt>render_without_layout("controller/action", status = 200)</tt>, and 
@@ -503,19 +506,24 @@ module ActionController #:nodoc:
       # <tt>render_partial(partial_path = default_template_name, object = nil, local_assigns = {})</tt> and
       # <tt>render_partial_collection(partial_name, collection, partial_spacer_template = nil, local_assigns = {})</tt>.
       #
-      # === Rendering a file
+      # === Rendering a template
       # 
-      # File rendering works just like action rendering except that it takes a path relative to the template root or an absolute
-      # path if use_full_path is passed as true. The current layout is not applied automatically.
+      # Template rendering works just like action rendering except that it takes a path relative to the template root. 
+      # The current layout is automatically applied.
       #
       #   # Renders the template located in [TEMPLATE_ROOT]/weblog/show.r(html|xml) (in Rails, app/views/weblog/show.rhtml)
-      #   render :file => "weblog/show"
+      #   render :template => "weblog/show"
+      #
+      # === Rendering a file
+      # 
+      # File rendering works just like action rendering except that it takes an absolute path. 
+      # The current layout is not applied automatically.
       #
       #   # Renders the template located in /path/to/some/template.r(html|xml)
-      #   render :file => "/path/to/some/template", :use_full_path => false
+      #   render :file => "/path/to/some/template"
       #
       #   # Renders the same template within the current layout, but with a 404 status code
-      #   render :file => "/path/to/some/template", :use_full_path => false, :layout => true, :status => 404
+      #   render :file => "/path/to/some/template", :layout => true, :status => 404
       #
       # _Deprecation_ _notice_: This used to have the signature <tt>render_file(path, status = 200)</tt>
       #
@@ -559,86 +567,115 @@ module ActionController #:nodoc:
       # === Rendering nothing
       #
       # Rendering nothing is often convenient in combination with Ajax calls that perform their effect client-side or
-      # when you just want to communicate a status code.
+      # when you just want to communicate a status code. Due to a bug in Safari, nothing actually means a single space.
       #
       #   # Renders an empty response with status code 200
       #   render :nothing => true
       #
       #   # Renders an empty response with status code 401 (access denied)
       #   render :nothing => true, :status => 401
-      def render(options = {}, deprecated_status = nil) #:doc:
-        # puts "Rendering: #{options.inspect}"
-        raise DoubleRenderError if performed?
+      def render(options = nil, deprecated_status = nil) #:doc:
+        raise DoubleRenderError, "Can only render or redirect once per action" if performed?
 
         # Backwards compatibility
-        return render({ :template => options || default_template_name, :status => deprecated_status }) if !options.is_a?(Hash)
+        unless options.is_a?(Hash)
+          return render_file(options || default_template_name, deprecated_status, true)
+        end
 
-        add_variables_to_assigns
-        options[:status] = (options[:status] || DEFAULT_RENDER_STATUS_CODE).to_s
-
-        if options[:text]
-          @response.headers["Status"] = options[:status]
-          @response.body = options[:text]
-          @performed_render = true
-          return options[:text]
-
-        elsif options[:file]
-          assert_existance_of_template_file(options[:file]) if options[:use_full_path]
-          logger.info("Rendering #{options[:file]} (#{options[:status]})") unless logger.nil?
-          render(options.merge({ :text => @template.render_file(options[:file], options[:use_full_path])}))
-
-        elsif options[:template]
-          render(options.merge({ :file => options[:template], :use_full_path => true }))
-
-        elsif options[:inline]
-          render(options.merge({
-            :text =>
-              @template.render_template(
-                options[:type] || :rhtml,
-                options[:inline],
-                options[:locals] || {}
-              )
-          }))
-
-        elsif options[:action]
-          render(options.merge({ :template => default_template_name(options[:action]) }))
-
-        elsif options[:partial] && options[:collection]
-          render(options.merge({ 
-            :text => (
-              @template.render_partial_collection(
-                options[:partial] == true ? default_template_name : options[:partial],
-                options[:collection], options[:spacer_template],
-                options[:locals] || {}
-              ) || ''
-            )
-          }))
-
-        elsif options[:partial]
-          render(options.merge({ :text => @template.render_partial(
-            options[:partial] == true ? default_template_name : options[:partial],
-            options[:object], options[:locals] || {}
-          ) }))
-          
-        elsif options[:nothing]
-          render(options.merge({ :text => "" }))
+        if text = options[:text]
+          render_text(text, options[:status])
 
         else
-          render(options.merge({ :action => action_name }))
+          if file = options[:file]
+            render_file(file, options[:status], options[:use_full_path])
+
+          elsif template = options[:template]
+            render_file(template, options[:status], true)
+            
+          elsif inline = options[:inline]
+            render_template(inline, options[:status], options[:type], options[:locals] || {})
+            
+          elsif action_name = options[:action]
+            render_action(action_name, options[:status], options[:layout]) 
+            
+          elsif partial = options[:partial]
+            partial = default_template_name if partial == true
+            if collection = options[:collection]
+              render_partial_collection(partial, collection, options[:spacer_template], options[:locals], options[:status])
+            else
+              render_partial(partial, ActionView::Base::ObjectWrapper.new(options[:object]), options[:locals], options[:status])
+            end
+
+          elsif options[:nothing]
+            # Safari doesn't pass the headers of the return if the response is zero length
+            render_text(" ", options[:status])
+            
+          else
+            render_file(default_template_name, options[:status], true)
+            
+          end
         end
       end
 
       # Renders according to the same rules as <tt>render</tt>, but returns the result in a string instead
       # of sending it as the response body to the browser.
-      def render_to_string(options = {}) #:doc:
+      def render_to_string(options = nil) #:doc:
         result = render(options)
         erase_render_results
-        return result
+        result
+      end    
+
+      def render_action(action_name, status = nil, with_layout = true)
+        if with_layout
+          render_with_layout(default_template_name(action_name), status)
+        else
+          render_with_no_layout(default_template_name(action_name), status)
+        end
+      end
+
+      def render_file(template_path, status = nil, use_full_path = false)
+        add_variables_to_assigns
+        assert_existance_of_template_file(template_path) if use_full_path
+        logger.info("Rendering #{template_path}" + (status ? " (#{status})" : '')) if logger
+        render_text(@template.render_file(template_path, use_full_path), status)
+      end
+
+      def render_template(template, status = nil, type = :rhtml, local_assigns = {})
+        add_variables_to_assigns
+        render_text(@template.render_template(type, template, nil, local_assigns), status)
+      end
+
+      def render_text(text = nil, status = nil)
+        @performed_render = true
+        @response.headers['Status'] = (status || DEFAULT_RENDER_STATUS_CODE).to_s
+        @response.body = text
       end
-      
+
+      def render_nothing(status = nil)
+        render_text(' ', status)
+      end
+
+      def render_partial(partial_path = default_template_name, object = nil, local_assigns = nil, status = nil)
+        add_variables_to_assigns
+        render_text(@template.render_partial(partial_path, object, local_assigns), status)
+      end
+
+      def render_partial_collection(partial_name, collection, partial_spacer_template = nil, local_assigns = nil, status = nil)
+        add_variables_to_assigns
+        render_text(@template.render_partial_collection(partial_name, collection, partial_spacer_template, local_assigns), status)
+      end
+
+      def render_with_layout(template_name = default_template_name, status = nil, layout = nil)
+        render_with_a_layout(template_name, status, layout)
+      end
+
+      def render_without_layout(template_name = default_template_name, status = nil)
+        render_with_no_layout(template_name, status)
+      end
+
 
       # Clears the rendered results, allowing for another render to be performed.
-      def erase_render_results #:nodoc:
+      def erase_render_results
         @response.body = nil
         @performed_render = false
       end
@@ -647,7 +684,7 @@ module ActionController #:nodoc:
       # the URL that was used to redirect or nil if there was no redirected URL
       # Note that +redirect_to+ will change the body of the response to indicate a redirection.
       # The response body is not reset here, see +erase_render_results+
-      def erase_redirect_results #:nodoc:
+      def erase_redirect_results
         @performed_redirect = false
         response.redirected_to = nil
         response.redirected_to_method_params = nil
@@ -655,6 +692,11 @@ module ActionController #:nodoc:
         response.headers.delete('location')
       end
 
+      # Erase both render and redirect results
+      def erase_results
+        erase_render_results
+        erase_redirect_results
+      end
 
       def rewrite_options(options)
         if defaults = default_url_options(options)
@@ -711,6 +753,29 @@ module ActionController #:nodoc:
             end
         end
       end
+      
+      # Sets a HTTP 1.1 Cache-Control header. Defaults to issuing a "private" instruction, so that
+      # intermediate caches shouldn't cache the response.
+      #
+      # Examples:
+      #   expires_in 20.minutes
+      #   expires_in 3.hours, :private => false
+      #   expires in 3.hours, 'max-stale' => 5.hours, :private => nil, :public => true
+      # 
+      # This method will overwrite an existing Cache-Control header.
+      # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
+      def expires_in(seconds, options = {}) #:doc:
+        cache_options = { 'max-age' => seconds, 'private' => true }.symbolize_keys.merge!(options.symbolize_keys)
+        cache_options.delete_if { |k,v| v.nil? or v == false }
+        cache_control = cache_options.map{ |k,v| v == true ? k.to_s : "#{k.to_s}=#{v.to_s}"}
+        @response.headers["Cache-Control"] = cache_control.join(', ')
+      end
+      
+      # Sets a HTTP 1.1 Cache-Control header of "no-cache" so no caching should occur by the browser or
+      # intermediate caches (like caching proxy servers).
+      def expires_now #:doc:
+        @response.headers["Cache-Control"] = "no-cache"
+      end
 
       # Resets the session by clearing out all the objects stored within and initializing a new session object.
       def reset_session #:doc:
@@ -720,13 +785,23 @@ module ActionController #:nodoc:
       end
     
     private
-      def initialize_template_class(response)
-        begin
-          response.template = template_class.new(template_root, {}, self)
-        rescue
-          raise "You must assign a template class through ActionController.template_class= before processing a request"
+      def self.view_class
+        unless @view_class
+          # create a new class based on the default template class and include helper methods
+          @view_class = Class.new(ActionView::Base)
+          @view_class.send(:include, master_helper_module)
         end
+        @view_class
+      end
+
+      def self.view_root
+        @view_root ||= template_root
+      end
+
+      def initialize_template_class(response)
+        raise "You must assign a template class through ActionController.template_class= before processing a request" unless @@template_class
         
+        response.template = self.class.view_class.new(self.class.view_root, {}, self)
         @performed_render = @performed_redirect = false
       end
     
@@ -747,12 +822,12 @@ module ActionController #:nodoc:
       end
 
       def log_processing
-        logger.info "\n\nProcessing #{controller_class_name}\##{action_name} (for #{request_origin})"
+        logger.info "\n\nProcessing #{controller_class_name}\##{action_name} (for #{request_origin}) [#{request.method.to_s.upcase}]"
         logger.info "  Parameters: #{@params.inspect}"
       end
     
       def perform_action
-        if action_methods.include?(action_name) || action_methods.include?('method_missing')
+        if self.class.action_methods.include?(action_name) || self.class.action_methods.include?('method_missing')
           send(action_name)
           render unless performed?
         elsif template_exists? && template_public?
@@ -767,17 +842,24 @@ module ActionController #:nodoc:
       end
 
       def action_methods
-        @action_methods ||= (self.class.public_instance_methods - self.class.hidden_actions)
+        self.class.action_methods
       end
 
+      def self.action_methods
+        #puts "action method: #{public_instance_methods.inspect}"
+        @action_methods ||= (public_instance_methods - hidden_actions).inject({}) { |h, k| h[k] = true; h }
+      end
 
       def add_variables_to_assigns
-        add_instance_variables_to_assigns
-        add_class_variables_to_assigns if view_controller_internals
+        unless @variables_added
+          add_instance_variables_to_assigns
+          add_class_variables_to_assigns if view_controller_internals
+          @variables_added = true
+        end
       end
 
       def add_instance_variables_to_assigns
-        @@protected_variables_cache = protected_instance_variables.inject({}) { |h, k| h[k] = true; h }
+        @@protected_variables_cache ||= protected_instance_variables.inject({}) { |h, k| h[k] = true; h }
         instance_variables.each do |var|
           next if @@protected_variables_cache.include?(var)
           @assigns[var[1..-1]] = instance_variable_get(var)
@@ -800,7 +882,7 @@ module ActionController #:nodoc:
 
 
       def request_origin
-        "#{@request.remote_ip} at #{Time.now.to_s}"
+        "#{@request.remote_ip} at #{Time.now.to_s(:db)}"
       end
       
       def complete_request_uri