actionpack 1.8.1 → 1.9.0

data/lib/action_controller/auto_complete.rb

@@ -0,0 +1,47 @@
+module ActionController
+  module AutoComplete #:nodoc:
+    def self.append_features(base) #:nodoc:
+      super
+      base.extend(ClassMethods)
+    end
+
+    # Example:
+    #
+    #   # Controller
+    #   class BlogController < ApplicationController
+    #     auto_complete_for :post, :title
+    #   end
+    #
+    #   # View
+    #   <%= text_field_with_auto_complete :post, title %>
+    #
+    # By default, auto_complete_for limits the results to 10 entries,
+    # and sorts by the given field.
+    # 
+    # auto_complete_for takes a third parameter, an options hash to
+    # the find method used to search for the records:
+    #
+    #   auto_complete_for :post, :title, :limit => 15, :order => 'created_at DESC'
+    #
+    # For help on defining text input fields with autocompletion, 
+    # see ActionView::Helpers::JavascriptHelper.
+    #
+    # For more examples, see script.aculo.us:
+    # * http://script.aculo.us/demos/ajax/autocompleter
+    # * http://script.aculo.us/demos/ajax/autocompleter_customized
+    module ClassMethods
+      def auto_complete_for(object, method, options = {})
+        define_method("auto_complete_for_#{object}_#{method}") do
+          find_options = { 
+            :conditions => [ "LOWER(#{method}) LIKE ?", '%' + params[object][method] + '%' ], 
+            :order => "#{method} ASC",
+            :limit => 10 }.merge!(options)
+            
+          @items = object.to_s.camelize.constantize.find(:all, find_options)
+
+          render :inline => "<%= auto_complete_result @items, '#{method}' %>"
+        end
+      end
+    end
+  end
+end

data/lib/action_controller/base.rb

@@ -1,6 +1,7 @@
 require 'action_controller/request'
 require 'action_controller/response'
 require 'action_controller/routing'
+require 'action_controller/code_generation'
 require 'action_controller/url_rewriter'
 require 'drb'
 
@@ -11,7 +12,7 @@ module ActionController #:nodoc:
   end
   class MissingTemplate < ActionControllerError #:nodoc:
   end
-  class RoutingError < ActionControllerError#:nodoc:
+  class RoutingError < ActionControllerError #:nodoc:
     attr_reader :failures
     def initialize(message, failures=[])
       super(message)
@@ -24,6 +25,8 @@ module ActionController #:nodoc:
   end
   class MissingFile < ActionControllerError #:nodoc:
   end
+  class DoubleRenderError < ActionControllerError #:nodoc:
+  end
 
   # Action Controllers are made up of one or more actions that performs its purpose and then either renders a template or
   # redirects to another action. An action is defined as a public method on the controller, which will automatically be 
@@ -57,6 +60,9 @@ module ActionController #:nodoc:
   # Also note that it's the final call to <tt>process_cgi</tt> that actually initiates the action performance. It will extract
   # request and response objects from the CGI
   #
+  # When Action Pack is used inside of Rails, the template_root is automatically configured and you don't need to call process_cgi
+  # yourself.
+  #
   # == Requests
   #
   # Requests are processed by the Action Controller framework by extracting the value of the "action" key in the request parameters.
@@ -64,19 +70,19 @@ module ActionController #:nodoc:
   # request parameters, the session (if one is available), and the full request with all the http headers are made available to
   # the action through instance variables. Then the action is performed.
   #
-  # The full request object is available in @request and is primarily used to query for http headers. These queries are made by
-  # accessing the environment hash, like this:
+  # The full request object is available with the request accessor and is primarily used to query for http headers. These queries
+  # are made by accessing the environment hash, like this:
   #
   #   def hello_ip
-  #     location = @request.env["REMOTE_IP"]
+  #     location = request.env["REMOTE_IP"]
   #     render_text "Hello stranger from #{location}"
   #   end
   #
   # == Parameters
   #
-  # All request parameters whether they come from a GET or POST request, or from the URL, are available through the @params hash.
+  # All request parameters whether they come from a GET or POST request, or from the URL, are available through the params hash.
   # So an action that was performed through /weblog/list?category=All&limit=5 will include { "category" => "All", "limit" => 5 }
-  # in @params.
+  # in params.
   #
   # It's also possible to construct multi-dimensional parameter hashes by specifying keys using brackets, such as:
   #
@@ -84,7 +90,7 @@ module ActionController #:nodoc:
   #   <input type="text" name="post[address]" value="hyacintvej">
   #
   # A request stemming from a form holding these inputs will include <tt>{ "post" => { "name" => "david", "address" => "hyacintvej" } }</tt>.
-  # If the address input had been named "post[address][street]", the @params would have included 
+  # If the address input had been named "post[address][street]", the params would have included 
   # <tt>{ "post" => { "address" => { "street" => "hyacintvej" } } }</tt>. There's no limit to the depth of the nesting.
   #
   # == Sessions
@@ -94,24 +100,17 @@ module ActionController #:nodoc:
   # as a User object for a system that requires login. The session should not be used, however, as a cache for objects where it's likely 
   # they could be changed unknowingly. It's usually too much work to keep it all synchronized -- something databases already excel at.
   #
-  # You can place objects in the session by using the <tt>@session</tt> hash:
+  # You can place objects in the session by using the <tt>session</tt> hash accessor:
   #
-  #   @session[:person] = Person.authenticate(user_name, password)
+  #   session[:person] = Person.authenticate(user_name, password)
   #
   # And retrieved again through the same hash:
   #
-  #   Hello #{@session[:person]}
+  #   Hello #{session[:person]}
   #
   # Any object can be placed in the session (as long as it can be Marshalled). But remember that 1000 active sessions each storing a
   # 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.
-  # 
-  # If you store a model in the session, you must also include a line like:
-  #
-  #   model :person
-  #
-  # For that particular controller. In Rails, you can also just add it in your app/controller/application.rb file (so the model is available
-  # for all controllers). This lets Action Pack know to have the model definition loaded before retrieving the object from 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
   # remove the entire session with reset_session.
@@ -128,7 +127,7 @@ module ActionController #:nodoc:
   # The controller passes objects to the view by assigning instance variables:
   #
   #   def show
-  #     @post = Post.find(@params["id"])
+  #     @post = Post.find(params[:id])
   #   end
   #
   # Which are then automatically available to the view:
@@ -139,11 +138,11 @@ module ActionController #:nodoc:
   # the manual rendering methods:
   #
   #   def search
-  #     @results = Search.find(@params["query"])
+  #     @results = Search.find(params[:query])
   #     case @results
-  #       when 0 then render "weblog/no_results"
-  #       when 1 then render_action "show"
-  #       when 2..10 then render_action "show_many"
+  #       when 0 then render :action=> "no_results"
+  #       when 1 then render :action=> "show"
+  #       when 2..10 then render :action=> "show_many"
   #     end
   #   end
   #
@@ -184,7 +183,7 @@ module ActionController #:nodoc:
   #
   #   def do_something
   #     redirect_to :action => "elsewhere"
-  #     render_action "overthere"
+  #     render :action => "overthere"
   #   end
   #
   # Only the redirect happens. The rendering call is simply ignored.
@@ -203,18 +202,17 @@ module ActionController #:nodoc:
   
     DEFAULT_RENDER_STATUS_CODE = "200 OK"
   
-    DEFAULT_SEND_FILE_OPTIONS = {
-      :type         => 'application/octet-stream'.freeze,
-      :disposition  => 'attachment'.freeze,
-      :stream       => true, 
-      :buffer_size  => 4096
-    }.freeze
-
     # Determines whether the view has access to controller internals @request, @response, @session, and @template.
     # By default, it does.
     @@view_controller_internals = true
     cattr_accessor :view_controller_internals
 
+    # 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"
+    @@asset_host = ""
+    cattr_accessor :asset_host
+
     # All requests are considered local by default, so everyone will be exposed to detailed debugging screens on errors.
     # When the application is ready to go public, this should be set to false, and the protected method <tt>local_request?</tt>
     # should instead be implemented in the controller to determine when debugging screens should be shown.
@@ -227,6 +225,12 @@ module ActionController #:nodoc:
     @@debug_routes = true
     cattr_accessor :debug_routes
 
+    # Controls whether the application is thread-safe, so multi-threaded servers like WEBrick knows whether to apply a mutex
+    # around the performance of each action. Action Pack and Active Record are by default thread-safe, but many applications
+    # may not be. Turned off by default.
+    @@allow_concurrency = false
+    cattr_accessor :allow_concurrency
+
     # Template root determines the base from which template references will be made. So a call to render("test/template")
     # will be converted to "#{template_root}/test/template.rhtml".
     class_inheritable_accessor :template_root
@@ -267,6 +271,9 @@ module ActionController #:nodoc:
     # is generated by taking a snapshot of all the instance variables in the current scope just before a template is rendered.
     attr_accessor :assigns
 
+    # Returns the name of the action this controller is processing.
+    attr_accessor :action_name
+
     class << self
       # Factory for the standard create, process loop where the controller is discarded after processing.
       def process(request, response) #:nodoc:
@@ -275,20 +282,24 @@ module ActionController #:nodoc:
       
       # Converts the class name from something like "OneModule::TwoModule::NeatController" to "NeatController".
       def controller_class_name
-        Inflector.demodulize(name)
+        @controller_class_name ||= name.demodulize
       end
 
       # Converts the class name from something like "OneModule::TwoModule::NeatController" to "neat".
       def controller_name
-        Inflector.underscore(controller_class_name.sub(/Controller/, ""))
+        @controller_name ||= controller_class_name.sub(/Controller$/, '').underscore
       end
       
       # Convert the class name from something like "OneModule::TwoModule::NeatController" to "one_module/two_module/neat".
       def controller_path
-        components = self.name.to_s.split('::').collect { |name| name.underscore }
-        components[-1] = $1 if /^(.*)_controller$/ =~ components[-1]
-        components.shift if components.first == 'controllers' # Transitional conditional to accomodate root Controllers module
-        components.join('/')
+        unless @controller_path
+          components = self.name.to_s.split('::')
+          components[-1] = $1 if /^(.*)Controller$/ =~ components.last
+          # Accomodate the root Controllers module.
+          components.shift if components.first == 'Controllers'
+          @controller_path = components.map { |name| name.underscore }.join('/')
+        end
+        @controller_path
       end
 
       # Return an array containing the names of public methods that have been marked hidden from the action processor.
@@ -314,9 +325,15 @@ module ActionController #:nodoc:
       #     and find templates in /code/weblog/components/admin/parties/users/
       def uses_component_template_root
         path_of_calling_controller = File.dirname(caller[0].split(/:\d+:/).first)
-        path_of_controller_root    = path_of_calling_controller.sub(/#{controller_path.split("/")[0..-2]}$/, "")
+        path_of_controller_root    = path_of_calling_controller.sub(/#{controller_path.split("/")[0..-2]}$/, "") # " (for ruby-mode)
         self.template_root = path_of_controller_root
       end
+
+      # Temporary method for enabling upload progress until it's ready to leave experimental mode
+      def enable_upload_progress # :nodoc:
+        require 'action_controller/upload_progress'
+        include ActionController::UploadProgress
+      end
     end
 
     public
@@ -325,6 +342,7 @@ module ActionController #:nodoc:
         initialize_template_class(response)
         assign_shortcuts(request, response)
         initialize_current_url
+        @action_name = params[:action] || 'index'
 
         log_processing unless logger.nil?
         send(method, *arguments)
@@ -377,7 +395,7 @@ module ActionController #:nodoc:
       # from this page.
       #
       # * <tt>url_for :action => 'bio'</tt> -- During the generation of this URL, default values will be used for the first and
-      # last components, and the action shall change. The generated URL will be, "people/david/hh/bio".
+      # last components, and the action shall change. The generated URL will be, "people/hh/david/bio".
       # * <tt>url_for :first => 'davids-little-brother'</tt> This generates the URL 'people/hh/davids-little-brother' -- note
       #   that this URL leaves out the assumed action of 'bio'.
       #
@@ -425,191 +443,211 @@ module ActionController #:nodoc:
         self.class.controller_name
       end
 
-      # Returns the name of the action this controller is processing.
-      def action_name
-        @params["action"] || "index"
-      end
-
     protected
-      # Renders the template specified by <tt>template_name</tt>, which defaults to the name of the current controller and action.
-      # So calling +render+ in WeblogController#show will attempt to render "#{template_root}/weblog/show.rhtml" or 
-      # "#{template_root}/weblog/show.rxml" (in that order). The template_root is set on the ActionController::Base class and is 
-      # shared by all controllers. It's also possible to pass a status code using the second parameter. This defaults to "200 OK", 
-      # but can be changed, such as by calling <tt>render("weblog/error", "500 Error")</tt>.
-      def render(template_name = nil, status = nil) #:doc:
-        render_file(template_name || default_template_name, status, true)
-      end
-      
-      # Works like render, but instead of requiring a full template name, you can get by with specifying the action name. So calling
-      # <tt>render_action "show_many"</tt> in WeblogController#display will render "#{template_root}/weblog/show_many.rhtml" or 
-      # "#{template_root}/weblog/show_many.rxml".
-      def render_action(action_name, status = nil) #:doc:
-        render(default_template_name(action_name), status)
-      end
-      
-      # Works like render, but disregards the template_root and requires a full path to the template that needs to be rendered. Can be
-      # used like <tt>render_file "/Users/david/Code/Ruby/template"</tt> to render "/Users/david/Code/Ruby/template.rhtml" or
-      # "/Users/david/Code/Ruby/template.rxml".
-      def render_file(template_path, status = nil, use_full_path = false) #:doc:
-        assert_existance_of_template_file(template_path) if use_full_path
-        logger.info("Rendering #{template_path} (#{status || DEFAULT_RENDER_STATUS_CODE})") unless logger.nil?
+      # Renders the content that'll be returned to the browser as the response body. This can just be as regular text, but is
+      # more often the compilation of a template.
+      #
+      # === Rendering an action
+      # 
+      # Action rendering is the most common form and the type used automatically by Action Controller when nothing else is
+      # specified. By default, actions are rendered within the current layout (if one exists).
+      #
+      #   # Renders the template for the action "goal" within the current controller
+      #   render :action => "goal"
+      #
+      #   # Renders the template for the action "explosion" from the ErrorsController
+      #   render :action => "errors/explosion", :status => 500 
+      #
+      #   # Renders the template for the action "short_goal" within the current controller,
+      #   # but without the current active layout
+      #   render :action => "short_goal", :layout => false
+      #
+      #   # Renders the template for the action "long_goal" within the current controller,
+      #   # but with a custom layout
+      #   render :action => "short_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 
+      # <tt>render_with_layout("controller/action", status = 200, layout)</tt>.
+      #
+      # === Rendering partials
+      # 
+      # Partial rendering is most commonly used together with Ajax calls that only updates one or a few elements on a page
+      # without reloading. Rendering of partials from the controller makes it possible to use the same partial template in
+      # both the full-page rendering (by calling it from within the template) and when sub-page updates happen (from the
+      # controller action responding to Ajax calls). By default, the current layout is not used.
+      #
+      #   # Renders the partial located at app/views/controller/_win.r(html|xml)
+      #   render :partial => "win"
+      #
+      #   # Renders the partial with a status code of 500 (internal error)
+      #   render :partial => "broken", :status => 500
+      #
+      #   # Renders the same partial but also makes a local variable available to it
+      #   render :partial => "win", :locals => { :name => "david" }
+      #
+      #   # Renders a collection of the same partial by making each element of @wins available through 
+      #   # the local variable "win" as it builds the complete response
+      #   render :partial => "win", :collection => @wins
+      #
+      #   # Renders the same collection of partials, but also renders the win_divider partial in between
+      #   # each win partial.
+      #   render :partial => "win", :collection => @wins, :spacer_template => "win_divider"
+      #
+      # _Deprecation_ _notice_: This used to have the signatures 
+      # <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
+      # 
+      # File rendering works just like action rendering except that it takes a complete path to the template intended
+      # for rendering and that 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"
+      #
+      #   # Renders the same template within the current layout, but with a 404 status code
+      #   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>
+      #
+      # === Rendering text
+      # 
+      # Rendering of text is usually used for tests or for rendering prepared content, such as a cache. By default, text
+      # rendering is not done within the active layout.
+      #
+      #   # Renders the clear text "hello world" with status code 200
+      #   render :text => "hello world!"
+      #
+      #   # Renders the clear text "Explosion!"  with status code 500
+      #   render :text => "Explosion!", :status => 500 
+      #
+      #   # Renders the clear text "Hi there!" within the current active layout (if one exists)
+      #   render :text => "Explosion!", :layout => true
+      #
+      #   # Renders the clear text "Hi there!" within the the layout 
+      #   # placed in "app/views/layouts/special.r(html|xml)"
+      #   render :text => "Explosion!", :layout => "special"
+      #
+      # _Deprecation_ _notice_: This used to have the signature <tt>render_text("text", status = 200)</tt>
+      #
+      # === Rendering an inline template
+      #
+      # Rendering of an inline template works as a cross between text and action rendering where the source for the template
+      # is supplied inline, like text, but its interpreted with ERb or Builder, like action. By default, ERb is used for rendering
+      # and the current layout is not used.
+      #
+      #   # Renders "hello, hello, hello, again"
+      #   render :inline => "<%= 'hello, ' * 3 + 'again' %>" 
+      #
+      #   # Renders "<p>Good seeing you!</p>" using Builder
+      #   render :inline => "xml.p { 'Good seeing you!' }", :type => :rxml
+      #
+      #   # Renders "hello david"
+      #   render :inline => "<%= 'hello ' + name %>", :locals => { :name => "david" }
+      #
+      # _Deprecation_ _notice_: This used to have the signature <tt>render_template(template, status = 200, type = :rhtml)</tt>
+      #
+      # === 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.
+      #
+      #   # 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, "Can only render or redirect once per action" if performed?
 
-        add_variables_to_assigns
-        render_text(@template.render_file(template_path, use_full_path), status)
-      end
-      
-      # Renders the +template+ string, which is useful for rendering short templates you don't want to bother having a file for. So
-      # you'd call <tt>render_template "Hello, <%= @user.name %>"</tt> to greet the current user. Or if you want to render as Builder
-      # template, you could do <tt>render_template "xml.h1 @user.name", nil, "rxml"</tt>.
-      def render_template(template, status = nil, type = "rhtml") #:doc:
-        add_variables_to_assigns
-        render_text(@template.render_template(type, template), status)
-      end
+        # Backwards compatibility
+        return render({ :template => options || default_template_name, :status => deprecated_status }) if !options.is_a?(Hash)
 
-      # Renders the +text+ string without parsing it through any template engine. Useful for rendering static information as it's
-      # considerably faster than rendering through the template engine.
-      # Use block for response body if provided (useful for deferred rendering or streaming output).
-      def render_text(text = nil, status = nil, &block) #:doc:
-        return if performed?
         add_variables_to_assigns
-        @response.headers["Status"] = status || DEFAULT_RENDER_STATUS_CODE
-        @response.body = block_given? ? block : text
-        @performed_render = true
-      end
-      
-      # Renders an empty response that can be used when the request is only interested in triggering an effect. Do note that good
-      # HTTP manners mandate that you don't use GET requests to trigger data changes.
-      def render_nothing(status = nil) #:doc:
-        render_text "", status
+        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 => "" }))
+
+        else
+          render(options.merge({ :action => action_name }))
+        end
       end
 
-      # Returns the result of the render as a string.
-      def render_to_string(template_name = default_template_name) #:doc:
-        add_variables_to_assigns
-        @template.render_file(template_name)
+      # 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:
+        result = render(options)
+        erase_render_results
+        return result
       end
       
-      # Renders the partial specified by <tt>partial_path</tt>, which by default is the name of the action itself. Example:
-      #
-      #   class WeblogController < ActionController::Base
-      #     def show
-      #       render_partial # renders "weblog/_show.r(xml|html)"
-      #     end
-      #   end
-      def render_partial(partial_path = default_template_name, object = nil, local_assigns = {}) #:doc:
-        add_variables_to_assigns
-        render_text(@template.render_partial(partial_path, object, local_assigns))
-      end
-
-      # Renders a collection of partials using <tt>partial_name</tt> to iterate over the +collection+.
-      def render_partial_collection(partial_name, collection, partial_spacer_template = nil, local_assigns = {})#:doc:
-        add_variables_to_assigns
-        render_text(@template.render_collection_of_partials(partial_name, collection, partial_spacer_template, local_assigns))
-      end
-
-      # Sends the file by streaming it 4096 bytes at a time. This way the
-      # whole file doesn't need to be read into memory at once.  This makes
-      # it feasible to send even large files.
-      #
-      # Be careful to sanitize the path parameter if it coming from a web
-      # page.  send_file(@params['path']) allows a malicious user to
-      # download any file on your server.
-      #
-      # Options:
-      # * <tt>:filename</tt> - suggests a filename for the browser to use.
-      #   Defaults to File.basename(path).
-      # * <tt>:type</tt> - specifies an HTTP content type.
-      #   Defaults to 'application/octet-stream'.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
-      #   Valid values are 'inline' and 'attachment' (default).
-      # * <tt>:streaming</tt> - whether to send the file to the user agent as it is read (true)
-      #   or to read the entire file before sending (false). Defaults to true.
-      # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used to stream the file.
-      #   Defaults to 4096.
-      #
-      # The default Content-Type and Content-Disposition headers are
-      # set to download arbitrary binary files in as many browsers as
-      # possible.  IE versions 4, 5, 5.5, and 6 are all known to have
-      # a variety of quirks (especially when downloading over SSL).
-      #
-      # Simple download:
-      #   send_file '/path/to.zip'
-      #
-      # Show a JPEG in browser:
-      #   send_file '/path/to.jpeg', :type => 'image/jpeg', :disposition => 'inline'
-      #
-      # Read about the other Content-* HTTP headers if you'd like to
-      # provide the user with more information (such as Content-Description).
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11
-      #
-      # Also be aware that the document may be cached by proxies and browsers.
-      # The Pragma and Cache-Control headers declare how the file may be cached
-      # by intermediaries.  They default to require clients to validate with
-      # the server before releasing cached responses.  See
-      # http://www.mnot.net/cache_docs/ for an overview of web caching and
-      # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
-      # for the Cache-Control header spec.
-      def send_file(path, options = {}) #:doc:
-        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
-
-        options[:length]   ||= File.size(path)
-        options[:filename] ||= File.basename(path)
-        send_file_headers! options
 
+      # Clears the rendered results, allowing for another render to be performed.
+      def erase_render_results #:nodoc:
+        @response.body = nil
         @performed_render = false
-
-        if options[:stream]
-          render_text do
-            logger.info "Streaming file #{path}" unless logger.nil?
-            len = options[:buffer_size] || 4096
-            File.open(path, 'rb') do |file|
-              if $stdout.respond_to?(:syswrite)
-                begin
-                  while true
-                    $stdout.syswrite file.sysread(len)
-                  end
-                rescue EOFError
-                end
-              else
-                while buf = file.read(len)
-                  $stdout.write buf
-                end
-              end
-            end
-          end
-        else
-          logger.info "Sending file #{path}" unless logger.nil?
-          File.open(path, 'rb') { |file| render_text file.read }
-        end
       end
 
-      # Send binary data to the user as a file download.  May set content type, apparent file name,
-      # and specify whether to show data inline or download as an attachment.
-      #
-      # Options:
-      # * <tt>:filename</tt> - Suggests a filename for the browser to use.
-      # * <tt>:type</tt> - specifies an HTTP content type.
-      #   Defaults to 'application/octet-stream'.
-      # * <tt>:disposition</tt> - specifies whether the file will be shown inline or downloaded.  
-      #   Valid values are 'inline' and 'attachment' (default).
-      #
-      # Generic data download:
-      #   send_data buffer
-      #
-      # Download a dynamically-generated tarball:
-      #   send_data generate_tgz('dir'), :filename => 'dir.tgz'
-      #
-      # Display an image Active Record in the browser:
-      #   send_data image.data, :type => image.content_type, :disposition => 'inline'
-      #
-      # See +send_file+ for more information on HTTP Content-* headers and caching.
-      def send_data(data, options = {}) #:doc:
-        logger.info "Sending data #{options[:filename]}" unless logger.nil?
-        send_file_headers! options.merge(:length => data.size)
-        @performed_render = false
-        render_text data
+      # Clears the redirected results from the headers, resetting the status to 200 and returns 
+      # 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:
+        @performed_redirect = false
+        response.redirected_to = nil
+        response.redirected_to_method_params = nil
+        response.headers['Status'] = DEFAULT_RENDER_STATUS_CODE
+        response.headers.delete('location')
       end
 
+
       def rewrite_options(options)
         if defaults = default_url_options(options)
           defaults.merge(options)
@@ -631,33 +669,40 @@ module ActionController #:nodoc:
       def default_url_options(options) #:doc:
       end
       
-      # Redirects the browser to an URL that has been rewritten according to the hash of +options+ using a "302 Moved" HTTP header.
-      # See url_for for a description of the valid options.
+      # Redirects the browser to the target specified in +options+. This parameter can take one of three forms:
+      #
+      # * <tt>Hash</tt>: The URL will be generated by calling url_for with the +options+.
+      # * <tt>String starting with protocol:// (like http://)</tt>: Is passed straight through as the target for redirection.
+      # * <tt>String not containing a protocol</tt>: The current current protocol and host is prepended to the string.
+      # 
+      # Examples:
+      #   redirect_to :action => "show", :id => 5
+      #   redirect_to "http://www.rubyonrails.org"
+      #   redirect_to "/images/screenshot.jpg"
+      #
+      # The redirection happens as a "302 Moved" header.
       def redirect_to(options = {}, *parameters_for_method_reference) #:doc:
-        if parameters_for_method_reference.empty?
-          @response.redirected_to = options
-          redirect_to_url(url_for(options))
-        else
-          @response.redirected_to, @response.redirected_to_method_params = options, parameters_for_method_reference
-          redirect_to_url(url_for(options, *parameters_for_method_reference))
+        case options
+          when %r{^\w+://.*}
+            raise DoubleRenderError, "Can only render or redirect once per action" if performed?
+            logger.info("Redirected to #{options}") unless logger.nil?
+            response.redirect(options)
+            response.redirected_to = options
+            @performed_redirect = true
+
+          when String
+            redirect_to(request.protocol + request.host_with_port + options)
+
+          else
+            if parameters_for_method_reference.empty?
+              redirect_to(url_for(options))
+              response.redirected_to = options
+            else
+              redirect_to(url_for(options, *parameters_for_method_reference))
+              response.redirected_to, response.redirected_to_method_params = options, parameters_for_method_reference
+            end
         end
       end
-      
-      # Redirects the browser to the specified <tt>path</tt> within the current host (specified with a leading /). Used to sidestep
-      # the URL rewriting and go directly to a known path. Example: <tt>redirect_to_path "/images/screenshot.jpg"</tt>.
-      def redirect_to_path(path) #:doc:
-        redirect_to_url(@request.protocol + @request.host_with_port + path)
-      end
-
-      # Redirects the browser to the specified <tt>url</tt>. Used to redirect outside of the current application. Example:
-      # <tt>redirect_to_url "http://www.rubyonrails.org"</tt>. If the resource has moved permanently, it's possible to pass true as the
-      # second parameter and the browser will get "301 Moved Permanently" instead of "302 Found".
-      def redirect_to_url(url, permanently = false) #:doc:
-        return if performed?
-        logger.info("Redirected to #{url}") unless logger.nil?
-        @response.redirect(url, permanently)
-        @performed_redirect = true
-      end
 
       # Resets the session by clearing out all the objects stored within and initializing a new session object.
       def reset_session #:doc:
@@ -666,11 +711,6 @@ module ActionController #:nodoc:
         @response.session = @session
       end
     
-      # Deprecated cookie writer method
-      def cookie(*options)
-        @response.headers["cookie"] << CGI::Cookie.new(*options)
-      end
-
     private
       def initialize_template_class(response)
         begin
@@ -721,16 +761,17 @@ module ActionController #:nodoc:
       def action_methods
         @action_methods ||= (self.class.public_instance_methods - self.class.hidden_actions)
       end
-      
+
+
       def add_variables_to_assigns
         add_instance_variables_to_assigns
         add_class_variables_to_assigns if view_controller_internals
       end
 
       def add_instance_variables_to_assigns
-        protected_variables_cache = protected_instance_variables
+        @@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)
+          next if @@protected_variables_cache.include?(var)
           @assigns[var[1..-1]] = instance_variable_get(var)
         end
       end
@@ -749,13 +790,19 @@ module ActionController #:nodoc:
         end
       end
 
+
       def request_origin
         "#{@request.remote_ip} at #{Time.now.to_s}"
       end
       
+      def complete_request_uri
+        request.protocol + request.host + request.request_uri
+      end
+
       def close_session
         @session.close unless @session.nil? || Hash === @session
       end
+
       
       def template_exists?(template_name = default_template_name)
         @template.file_exists?(template_name)
@@ -773,23 +820,6 @@ module ActionController #:nodoc:
         end
       end
 
-      def send_file_headers!(options)
-        options.update(DEFAULT_SEND_FILE_OPTIONS.merge(options))
-        [:length, :type, :disposition].each do |arg|
-          raise ArgumentError, ":#{arg} option required" if options[arg].nil?
-        end
-
-        disposition = options[:disposition].dup || 'attachment'
-        disposition <<= %(; filename="#{options[:filename]}") if options[:filename]
-
-        @headers.update(
-          'Content-Length'            => options[:length],
-          'Content-Type'              => options[:type].strip,  # fixes a problem with extra '\r' with some browsers
-          'Content-Disposition'       => disposition,
-          'Content-Transfer-Encoding' => 'binary'
-        );
-      end
-
       def default_template_name(default_action_name = action_name)
         "#{self.class.controller_path}/#{default_action_name}"
       end