render

Renders the content that will be returned to the browser as the response body.

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 "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 => "long_goal", :layout => "spectacular" 

Rendering partials

Partial rendering in a controller is most commonly used together with Ajax calls that only update 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 same partial with a local variable. render :partial => "person", :locals => { :name => "david" } # Renders the partial, making @new_person available through # the local variable 'person' render :partial => "person", :object => @new_person # Renders a collection of the same partial by making each element # of @winners available through the local variable "person" as it # builds the complete response. render :partial => "person", :collection => @winners # Renders a collection of partials but with a custom local variable name render :partial => "admin_person", :collection => @winners, :as => :person # Renders the same collection of partials, but also renders the # person_divider partial between each person partial. render :partial => "person", :collection => @winners, :spacer_template => "person_divider" # Renders a collection of partials located in a view subfolder # outside of our current controller. In this example we will be # rendering app/views/shared/_note.r(html|xml) Inside the partial # each element of @new_notes is available as the local var "note". render :partial => "shared/note", :collection => @new_notes # Renders the partial with a status code of 500 (internal error). render :partial => "broken", :status => 500 

Note that the partial filename must also be a valid Ruby variable name, so e.g. 2005 and register-user are invalid.

Automatic etagging

Rendering will automatically insert the etag header on 200 OK responses. The etag is calculated using MD5 of the response body. If a request comes in that has a matching etag, the response will be changed to a 304 Not Modified and the response body will be set to an empty string. No etag header will be inserted if it’s already set.

Rendering a template

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.erb) render :template => "weblog/show" # Renders the template with a local variable render :template => "weblog/show", :locals => {:customer => Customer.new} 

Rendering a file

File rendering works just like action rendering except that it takes a filesystem path. By default, the path is assumed to be absolute, and the current layout is not applied.

 # Renders the template located at the absolute filesystem path render :file => "/path/to/some/template.erb" render :file => "c:/path/to/some/template.erb" # Renders a template within the current layout, and with a 404 status code render :file => "/path/to/some/template.erb", :layout => true, :status => 404 render :file => "c:/path/to/some/template.erb", :layout => true, :status => 404 

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 => "Hi there!", :layout => true # Renders the clear text "Hi there!" within the layout # placed in "app/views/layouts/special.r(html|xml)" render :text => "Hi there!", :layout => "special" 

Streaming data and/or controlling the page generation

The :text option can also accept a Proc object, which can be used to:

1. stream on-the-fly generated data to the browser. Note that you should use the methods provided by ActionController::Steaming instead if you want to stream a buffer or a file.
2. manually control the page generation. This should generally be avoided, as it violates the separation between code and content, and because almost everything that can be done with this method can also be done more cleanly using one of the other rendering methods, most notably templates.

Two arguments are passed to the proc, a response object and an output object. The response object is equivalent to the return value of the ActionController::Base#response method, and can be used to control various things in the HTTP response, such as setting the Content-Type header. The output object is an writable IO-like object, so one can call write and flush on it.

The following example demonstrates how one can stream a large amount of on-the-fly generated data to the browser:

 # Streams about 180 MB of generated data to the browser. render :text => proc { |response, output| 10_000_000.times do |i| output.write("This is line #{i}\n") end } 

Another example:

 # Renders "Hello from code!" render :text => proc { |response, output| output.write("Hello from code!") } 

Rendering XML

Rendering XML sets the content type to application/xml.

 # Renders '<name>David</name>' render :xml => {:name => "David"}.to_xml 

It’s not necessary to call to_xml on the object you want to render, since render will automatically do that for you:

 # Also renders '<name>David</name>' render :xml => {:name => "David"} 

Rendering JSON

Rendering JSON sets the content type to application/json and optionally wraps the JSON in a callback. It is expected that the response will be parsed (or eval’d) for use as a data structure.

 # Renders '{"name": "David"}' render :json => {:name => "David"}.to_json 

It’s not necessary to call to_json on the object you want to render, since render will automatically do that for you:

 # Also renders '{"name": "David"}' render :json => {:name => "David"} 

Sometimes the result isn’t handled directly by a script (such as when the request comes from a SCRIPT tag), so the :callback option is provided for these cases.

 # Renders 'show({"name": "David"})' render :json => {:name => "David"}.to_json, :callback => 'show' 

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 => :builder # Renders "hello david" render :inline => "<%= 'hello ' + name %>", :locals => { :name => "david" } 

Rendering inline JavaScriptGenerator page updates

In addition to rendering JavaScriptGenerator page updates with Ajax in RJS templates (see ActionView::Base for details), you can also pass the :update parameter to render, along with a block, to render page updates inline.

 render :update do |page| page.replace_html 'user_list', :partial => 'user', :collection => @users page.visual_effect :highlight, 'user_list' end 

Rendering vanilla JavaScript

In addition to using RJS with render :update, you can also just render vanilla JavaScript with :js.

 # Renders "alert('hello')" and sets the mime type to text/javascript render :js => "alert('hello')" 

Rendering with status and location headers

All renders take the :status and :location options and turn them into headers. They can even be used together:

 render :xml => post.to_xml, :status => :created, :location => post_url(post) 

# File actionpack/lib/action_controller/base.rb, line 890 def render(options = nil, extra_options = {}, &block) #:doc: raise DoubleRenderError, "Can only render or redirect once per action" if performed? validate_render_arguments(options, extra_options, block_given?) if options.nil? options = { :template => default_template, :layout => true } elsif options == :update options = extra_options.merge({ :update => true }) elsif options.is_a?(String) || options.is_a?(Symbol) case options.to_s.index('/') when 0 extra_options[:file] = options when nil extra_options[:action] = options else extra_options[:template] = options end options = extra_options elsif !options.is_a?(Hash) extra_options[:partial] = options options = extra_options end layout = pick_layout(options) response.layout = layout.path_without_format_and_extension if layout logger.info("Rendering template within #{layout.path_without_format_and_extension}") if logger && layout if content_type = options[:content_type] response.content_type = content_type.to_s end if location = options[:location] response.headers["Location"] = url_for(location) end if options.has_key?(:text) text = layout ? @template.render(options.merge(:text => options[:text], :layout => layout)) : options[:text] render_for_text(text, options[:status]) else if file = options[:file] render_for_file(file, options[:status], layout, options[:locals] || {}) elsif template = options[:template] render_for_file(template, options[:status], layout, options[:locals] || {}) elsif inline = options[:inline] render_for_text(@template.render(options.merge(:layout => layout)), options[:status]) elsif action_name = options[:action] render_for_file(default_template(action_name.to_s), options[:status], layout) elsif xml = options[:xml] response.content_type ||= Mime::XML render_for_text(xml.respond_to?(:to_xml) ? xml.to_xml : xml, options[:status]) elsif js = options[:js] response.content_type ||= Mime::JS render_for_text(js, options[:status]) elsif options.include?(:json) json = options[:json] json = ActiveSupport::JSON.encode(json) unless json.is_a?(String) json = "#{options[:callback]}(#{json})" unless options[:callback].blank? response.content_type ||= Mime::JSON render_for_text(json, options[:status]) elsif options[:partial] options[:partial] = default_template_name if options[:partial] == true if layout render_for_text(@template.render(:text => @template.render(options), :layout => layout), options[:status]) else render_for_text(@template.render(options), options[:status]) end elsif options[:update] @template.send(:_evaluate_assigns_and_ivars) generator = ActionView::Helpers::PrototypeHelper::JavaScriptGenerator.new(@template, &block) response.content_type = Mime::JS render_for_text(generator.to_s, options[:status]) elsif options[:nothing] render_for_text(nil, options[:status]) else render_for_file(default_template, options[:status], layout) end end end