Module: ActionView::Partials

Extended by:
ActiveSupport::Concern
Included in:
Base
Defined in:
lib/action_view/render/partials.rb

Overview

Action View Partials

There’s also a convenience method for rendering sub templates within the current controller that depends on a single object (we call this kind of sub templates for partials). It relies on the fact that partials should follow the naming convention of being prefixed with an underscore – as to separate them from regular templates that could be rendered on their own.

In a template for Advertiser#account:

<%= render :partial => "account" %>

This would render “advertiser/_account.erb” and pass the instance variable @account in as a local variable account to the template for display.

In another template for Advertiser#buy, we could have:

<%= render :partial => "account", :locals => { :account => @buyer } %>

<% for ad in @advertisements %>
  <%= render :partial => "ad", :locals => { :ad => ad } %>
<% end %>

This would first render “advertiser/_account.erb” with @buyer passed in as the local variable account, then render “advertiser/_ad.erb” and pass the local variable ad to the template for display.

The :as and :object options

By default PartialRenderer uses the template name for the local name of the object passed into the template. These examples are effectively the same:

<%= render :partial => "contract", :locals => { :contract  => @contract } %>

<%= render :partial => "contract" %>

By specifying the :as option we can change the way the local variable is namedin the template. These examples are effectively the same:

<%= render :partial => "contract", :as => :agreement

<%= render :partial => "contract", :locals => { :agreement => @contract }

The :object option can be used to directly specify which object is rendered into the partial.

Revisiting a previous example we could have written this code.

<%= render :partial => "account", :object => @buyer %>

<% for ad in @advertisements %>
  <%= render :partial => "ad", :object => ad %>
<% end %>

The :object and :as options can be used together. We might have a partial which we have named genericly, such as ‘form’. Using :object and :as together helps us.

<%= render :partial => "form", :object => @contract, :as => :contract %>

Rendering a collection of partials

The example of partial use describes a familiar pattern where a template needs to iterate over an array and render a sub template for each of the elements. This pattern has been implemented as a single method that accepts an array and renders a partial by the same name as the elements contained within. So the three-lined example in “Using partials” can be rewritten with a single line:

<%= render :partial => "ad", :collection => @advertisements %>

This will render “advertiser/_ad.erb” and pass the local variable ad to the template for display. An iteration counter will automatically be made available to the template with a name of the form partial_name_counter. In the case of the example above, the template would be fed ad_counter.

The :as option may be used when rendering partials.

Also, you can specify a partial which will be render as a spacer between each element by passing partial name to :spacer_template. The following example will render “advertiser/_ad_divider.erb” between each ad partial.

<%= render :partial => "ad", :collection => @advertisements, :spacer_template => "ad_divider" %>

NOTE: Due to backwards compatibility concerns, the collection can’t be one of hashes. Normally you’d also just keep domain objects, like Active Records, in there.

Rendering shared partials

Two controllers can share a set of partials and render them like this:

<%= render :partial => "advertisement/ad", :locals => { :ad => @advertisement } %>

This will render the partial “advertisement/_ad.erb” regardless of which controller this is being called from.

Rendering objects with the RecordIdentifier

Instead of explicitly naming the location of a partial, you can also let the RecordIdentifier do the work if you’re following its conventions for RecordIdentifier#partial_path. Examples:

# @account is an Account instance, so it uses the RecordIdentifier to replace
# <%= render :partial => "accounts/account", :locals => { :account => @account} %>
<%= render :partial => @account %>

# @posts is an array of Post instances, so it uses the RecordIdentifier to replace
# <%= render :partial => "posts/post", :collection => @posts %>
<%= render :partial => @posts %>

Rendering the default case

If you’re not going to be using any of the options like collections or layouts, you can also use the short-hand defaults of render to render partials. Examples:

# Instead of <%= render :partial => "account" %>
<%= render "account" %>

# Instead of <%= render :partial => "account", :locals => { :account => @buyer } %>
<%= render "account", :account => @buyer %>

# @account is an Account instance, so it uses the RecordIdentifier to replace
# <%= render :partial => "accounts/account", :locals => { :account => @account } %>
<%= render(@account) %>

# @posts is an array of Post instances, so it uses the RecordIdentifier to replace
# <%= render :partial => "posts/post", :collection => @posts %>
<%= render(@posts) %>

Rendering partials with layouts

Partials can have their own layouts applied to them. These layouts are different than the ones that are specified globally for the entire action, but they work in a similar fashion. Imagine a list with two types of users:

<%# app/views/users/index.html.erb &>
Here's the administrator:
<%= render :partial => "user", :layout => "administrator", :locals => { :user => administrator } %>

Here's the editor:
<%= render :partial => "user", :layout => "editor", :locals => { :user => editor } %>

<%# app/views/users/_user.html.erb &>
Name: <%= user.name %>

<%# app/views/users/_administrator.html.erb &>
<div id="administrator">
  Budget: $<%= user.budget %>
  <%= yield %>
</div>

<%# app/views/users/_editor.html.erb &>
<div id="editor">
  Deadline: <%= user.deadline %>
  <%= yield %>
</div>

…this will return:

Here's the administrator:
<div id="administrator">
  Budget: $<%= user.budget %>
  Name: <%= user.name %>
</div>

Here's the editor:
<div id="editor">
  Deadline: <%= user.deadline %>
  Name: <%= user.name %>
</div>

You can also apply a layout to a block within any template:

<%# app/views/users/_chief.html.erb &>
<%= render(:layout => "administrator", :locals => { :user => chief }) do %>
  Title: <%= chief.title %>
<% end %>

…this will return:

<div id="administrator">
  Budget: $<%= user.budget %>
  Title: <%= chief.name %>
</div>

As you can see, the :locals hash is shared between both the partial and its layout.

If you pass arguments to “yield” then this will be passed to the block. One way to use this is to pass an array to layout and treat it as an enumerable.

<%# app/views/users/_user.html.erb &>
<div class="user">
  Budget: $<%= user.budget %>
  <%= yield user %>
</div>

<%# app/views/users/index.html.erb &>
<%= render :layout => @users do |user| %>
  Title: <%= user.title %>
<% end %>

This will render the layout for each user and yield to the block, passing the user, each time.

You can also yield multiple times in one layout and use block arguments to differentiate the sections.

<%# app/views/users/_user.html.erb &>
<div class="user">
  <%= yield user, :header %>
  Budget: $<%= user.budget %>
  <%= yield user, :footer %>
</div>

<%# app/views/users/index.html.erb &>
<%= render :layout => @users do |user, section| %>
  <%- case section when :header -%>
    Title: <%= user.title %>
  <%- when :footer -%>
    Deadline: <%= user.deadline %>
  <%- end -%>
<% end %>

Defined Under Namespace

Classes: PartialRenderer

Instance Method Summary collapse

Instance Method Details

#_render_partial(options, &block) ⇒ Object

:nodoc:



371
372
373
374
375
376
377
378
379
 
# File 'lib/action_view/render/partials.rb', line 371

def _render_partial(options, &block) #:nodoc:
  if defined?(@renderer)
    @renderer.setup(options, block)
  else
    @renderer = PartialRenderer.new(self, options, block)
  end

  @renderer.render
end