# class ActionView::PartialRenderer

# 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.html.erb”.

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

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

    <% @advertisements.each do |ad| %>
      <%= render :partial => "ad", :locals => { :ad => ad } %>
    <% end %>

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

## The :as and :object options¶ ↑

By default `ActionView::PartialRenderer` doesn’t have any local variables. The `:object` option can be used to pass an object to the partial. For instance:

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

would provide the +@buyer+ object to the partial, available under the local variable `account` and is equivalent to:

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

With the `:as` option we can specify a different name for said local variable. For example, if we wanted it to be `user` instead of `account` we’d do:

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

This is equivalent to

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

## 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.html.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.

You can specify a partial to be rendered between elements via the `:spacer_template` option. The following example will render `advertiser/_ad_divider.html.erb` between each ad partial:

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

If the given `:collection` is nil or empty, `render` will return nil. This will allow you to specify a text which will displayed instead by using this form:

    <%= render(:partial => "ad", :collection => @advertisements) || "There's no ad to be displayed" %>

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.html.erb” regardless of which controller this is being called from.

## Rendering objects that respond to `to_partial_path`¶ ↑

Instead of explicitly naming the location of a partial, you can also let PartialRenderer do the work and pick the proper path by checking `to_proper_path` method. If the object passed to render is a collection, all objects must return the same path.

    # @account.to_partial_path returns 'accounts/account', so it can be used to replace:
    # <%= render :partial => "accounts/account", :locals => { :account => @account} %>
    <%= render :partial => @account %>

    # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
    # that's why we can 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.to_partial_path returns 'accounts/account', so it can be used to replace:
    # <%= render :partial => "accounts/account", :locals => { :account => @account} %>
    <%= render @account %>

    # @posts is an array of Post instances, so every post record returns 'posts/post' on `to_partial_path`,
    # that's why we can 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 %>

### Constants

PARTIAL_NAMES

### Public Class Methods

new(*) click to toggle source
Calls superclass method

    # File lib/action_view/renderer/partial_renderer.rb, line 214
    def initialize(*)
      super
      @context_prefix = @lookup_context.prefixes.first
      @partial_names = PARTIAL_NAMES[@context_prefix]
    end

### Public Instance Methods

render(context, options, block) click to toggle source

    # File lib/action_view/renderer/partial_renderer.rb, line 220
    def render(context, options, block)
      setup(context, options, block)
      identifier = (@template = find_partial) ? @template.identifier : @path

      @lookup_context.rendered_format ||= begin
        if @template && @template.formats.present?
          @template.formats.first
        else
          formats.first
        end
      end

      if @collection
        instrument(:collection, :identifier => identifier || "collection", :count => @collection.size) do
          render_collection
        end
      else
        instrument(:partial, :identifier => identifier) do
          render_partial
        end
      end
    end

render_collection() click to toggle source

    # File lib/action_view/renderer/partial_renderer.rb, line 243
    def render_collection
      return nil if @collection.blank?

      if @options.key?(:spacer_template)
        spacer = find_template(@options[:spacer_template]).render(@view, @locals)
      end

      result = @template ? collection_with_template : collection_without_template
      result.join(spacer).html_safe
    end

render_partial() click to toggle source

    # File lib/action_view/renderer/partial_renderer.rb, line 254
    def render_partial
      locals, view, block = @locals, @view, @block
      object, as = @object, @variable

      if !block && (layout = @options[:layout])
        layout = find_template(layout.to_s)
      end

      object ||= locals[as]
      locals[as] = object

      content = @template.render(view, locals) do |*name|
        view._layout_for(*name, &block)
      end

      content = layout.render(view, locals){ content } if layout
      content
    end