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
Overrides _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

Otherwise, a partial is rendered using the second parameter as the locals hash.

passing in the current view context.
If an object responding to +render_in+ is passed, +render_in+ is called on the object,

If no options hash is passed or if :update is specified, then:

type of text/plain from ActionDispatch::Response object.
* :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
* :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
    in_rendering_context(options) do |renderer|
      if block_given?
        view_renderer.render_partial(self, options.merge(partial: options[:layout]), &block)
      else
        view_renderer.render(self, options)
      end
    end
  else
    if options.respond_to?(:render_in)
      options.render_in(self, &block)
    else
      view_renderer.render_partial(self, partial: options, locals: locals, &block)
    end
  end
end