module ActionView::Helpers::RenderingHelper

Hello David


would be
and the struct specified would be passed into the block as an argument. The result
In this case, the layout would receive the block passed into render :layout,


<%= yield Struct.new(:name).new("David") %>

# The layout

<% end %>
Hello <%= customer.name %>
<%= render layout: "my_layout" do |customer| %>
# The template

Finally, the block can take block arguments, which can be passed in by +yield+:


Content


would be
this method returns the block that was passed in to render :layout, and the response
In this case, instead of the default block, which would return content_for(:layout),


<%= yield %>

# The layout

<% end %>
Content
<%= render layout: "my_layout" do %>
# The template

The user can override this default by passing a block to the layout:

If the user calls simply +yield+, the default block returns content_for(:layout).
yield :some_name, the block, by default, returns content_for(:some_name).
You can think of a layout as a method that is called with a block. If the user calls

name or a block.
passed to a partial. Returns the contents that are yielded to a layout, given a
Overwrites _layout_for in the context object so it supports the case a block is

def _layout_for(*args, &block)
  name = args.first
  if block && !name.is_a?(Symbol)
    capture(*args, &block)
  else
    super
  end
end

as the locals hash.
If no options hash is passed or :update specified, the default is to render a partial and use the second parameter

object.
type of text/plain from ActionDispatch::Response
* :body - Renders the text passed in, and inherits the content
text/html.
performs HTML escape on the string first. Setting the content type as
* :html - Renders the HTML safe string passed in out, otherwise
type as text/plain.
* :plain - Renders the text passed in out. Setting the content
* :text - Renders the text passed in out.
* :inline - Renders an inline template similar to how it's done in the controller.
* :file - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
* :partial - See ActionView::PartialRenderer.

Returns the result of a render that's dictated by the options hash. The primary options are:

def render(options = {}, locals = {}, &block)
  case options
  when Hash
    if block_given?
      view_renderer.render_partial(self, options.merge(:partial => options[:layout]), &block)
    else
      view_renderer.render(self, options)
    end
  else
    view_renderer.render_partial(self, :partial => options, :locals => locals, &block)
  end
end