rails--rails/actionpack/lib/action_view/render/rendering.rb

module ActionView
  module Rendering
    # Returns the result of a render that's dictated by the options hash. The primary options are:
    #
    # * <tt>:partial</tt> - See ActionView::Partials.
    # * <tt>:update</tt> - Calls update_page with the block given.
    # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
    # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
    # * <tt>:text</tt> - Renders the text passed in out.
    #
    # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
    # as the locals hash.
    def render(options = {}, locals = {}, &block) #:nodoc:
      case options
      when Hash
        layout = options[:layout]
        options[:locals] ||= {}

        if block_given?
          return concat(_render_partial(options.merge(:partial => layout), &block))
        elsif options.key?(:partial)
          return _render_partial(options)
        end

        layout = find(layout, {:formats => formats}) if layout

        if file = options[:file]
          template = find(file, {:formats => formats})
          _render_template(template, layout, :locals => options[:locals])
        elsif inline = options[:inline]
          _render_inline(inline, layout, options)
        elsif text = options[:text]
          _render_text(text, layout, options[:locals])
        end
      when :update
        update_page(&block)
      else
        _render_partial(:partial => options, :locals => locals)
      end
    end

    # You can think of a layout as a method that is called with a block. _layout_for
    # returns the contents that are yielded to the layout. If the user calls yield
    # :some_name, the block, by default, returns content_for(:some_name). If the user
    # calls yield, the default block returns content_for(:layout).
    #
    # The user can override this default by passing a block to the layout.
    #
    # ==== Example
    #
    #   # The template
    #   <% render :layout => "my_layout" do %>Content<% end %>
    #
    #   # The layout
    #   <html><% yield %></html>
    #
    # In this case, instead of the default block, which would return content_for(:layout),
    # this method returns the block that was passed in to render layout, and the response
    # would be <html>Content</html>.
    #
    # Finally, the block can take block arguments, which can be passed in by yield.
    #
    # ==== Example
    #
    #   # The template
    #   <% render :layout => "my_layout" do |customer| %>Hello <%= customer.name %><% end %>
    #
    #   # The layout
    #   <html><% yield Struct.new(:name).new("David") %></html>
    #
    # In this case, the layout would receive the block passed into <tt>render :layout</tt>,
    # and the Struct specified in the layout would be passed into the block. The result
    # would be <html>Hello David</html>.
    def _layout_for(name = nil, &block)
      return @_content_for[name || :layout] if !block_given? || name
      capture(&block)
    end

    def _render_inline(inline, layout, options)
      locals = options[:locals]

      content = ActiveSupport::Notifications.instrument(:render_inline) do
        handler  = Template.handler_class_for_extension(options[:type] || "erb")
        template = Template.new(options[:inline], "inline template", handler, {})
        template.render(self, locals)
      end

      _render_text(content, layout, locals)
    end

    def _render_text(content, layout, locals)
      ActiveSupport::Notifications.instrument(:render_text)
      content = _render_layout(layout, locals){ content } if layout
      content
    end

    # This is the API to render a ViewContext's template from a controller.
    #
    # Internal Options:
    # _template:: The Template object to render
    # _layout::   The layout, if any, to wrap the Template in
    # _partial::  true if the template is a partial
    def render_template(options)
      _evaluate_assigns_and_ivars
      template, layout, partial = options.values_at(:_template, :_layout, :_partial)
      _render_template(template, layout, options, partial)
    end

    def _render_template(template, layout = nil, options = {}, partial = nil)
      locals = options[:locals] || {}

      content = ActiveSupport::Notifications.instrument(:render_template,
                :identifier => template.identifier, :layout => (layout ? layout.identifier : nil)) do
        partial ? _render_partial_object(template, options) : template.render(self, locals)
      end

      @_content_for[:layout] = content

      if layout
        @_layout = layout.identifier
        content  = _render_layout(layout, locals)
      end

      content
    end

    def _render_layout(layout, locals, &block)
      ActiveSupport::Notifications.instrument(:render_layout, :identifier => layout.identifier) do
        layout.render(self, locals){ |*name| _layout_for(*name, &block) }
      end
    end
  end
end
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`module ActionView`
			`module Rendering`
			`# Returns the result of a render that's dictated by the options hash. The primary options are:`
			`#`
			`# * <tt>:partial</tt> - See ActionView::Partials.`
			`# * <tt>:update</tt> - Calls update_page with the block given.`
			`# * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.`
			`# * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.`
			`# * <tt>:text</tt> - Renders the text passed in out.`
			`#`
			`# If no options hash is passed or :update specified, the default is to render a partial and use the second parameter`
			`# as the locals hash.`
Some more AV work: * rename _render_partial to _render_partial_unknown_type to reflect that for this call, we don't know the type. * Merge _render_partial_with_block and _render_partial_with_layout to _render_partial * TODO: Check to see if any more logic can be shared * TODO: See about streamlining block path so we can get rid of @_proc_for_layout * Remove @exempt_from_layout as it is no longer needed 2009-08-07 06:48:28 +00:00			`def render(options = {}, locals = {}, &block) #:nodoc:`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`case options`
			`when Hash`
			`layout = options[:layout]`
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`options[:locals] \|\|= {}`
Whitespace 2009-08-07 09:32:54 +00:00
Continue reworking the partial path. * TODO: Review ActionController calling render_template for certain partials. Might we be able to save logic by always delegating to AV's render_partial? 2009-08-07 09:32:17 +00:00			`if block_given?`
			`return concat(_render_partial(options.merge(:partial => layout), &block))`
			`elsif options.key?(:partial)`
First pass at making partial rendering an Object. More cleanup to come. 2009-08-08 15:26:58 +00:00			`return _render_partial(options)`
Some more AV work: * rename _render_partial to _render_partial_unknown_type to reflect that for this call, we don't know the type. * Merge _render_partial_with_block and _render_partial_with_layout to _render_partial * TODO: Check to see if any more logic can be shared * TODO: See about streamlining block path so we can get rid of @_proc_for_layout * Remove @exempt_from_layout as it is no longer needed 2009-08-07 06:48:28 +00:00			`end`
Whitespace 2009-08-07 09:32:54 +00:00
Rename find_by_parts and find_by_parts? to find and exists? 2009-08-07 18:00:12 +00:00			`layout = find(layout, {:formats => formats}) if layout`
Whitespace 2009-08-07 09:32:54 +00:00
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`if file = options[:file]`
Rename find_by_parts and find_by_parts? to find and exists? 2009-08-07 18:00:12 +00:00			`template = find(file, {:formats => formats})`
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`_render_template(template, layout, :locals => options[:locals])`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`elsif inline = options[:inline]`
			`_render_inline(inline, layout, options)`
			`elsif text = options[:text]`
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`_render_text(text, layout, options[:locals])`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`
			`when :update`
			`update_page(&block)`
Clean up ActionView some: * Call _evaluate_assigns_and_ivars at the two entry points so we don't have to do a check at every render. * Make template.render viable without having to go through a wrapper method * Remove old TemplateHandler#render(template, local_assigns) path so we don't have to set self.template every time we render a template. * Move Template rescuing code to Template#render so it gets caught every time. * Pull in some tests from Pratik that test render @object in ActionView 2009-08-11 22:02:05 +00:00			`else`
			`_render_partial(:partial => options, :locals => locals)`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`
			`end`

Modify various partial methods to carry along the block that can be passed in with render * _render_single_template, which renders a template without layout * _render_partial_unknown_type, which renders a partial of unknown type (the entry method for most partial rendering; supports strings, objects, and collections) * _render_partial_object, which renders a partial for a single object. * extracted _render_partial_path so it can be used to render the spacer without going through the public render :partial 2009-08-07 08:40:01 +00:00			`# You can think of a layout as a method that is called with a block. _layout_for`
			`# returns the contents that are yielded to the layout. If the user calls yield`
			`# :some_name, the block, by default, returns content_for(:some_name). If the user`
			`# calls yield, the default block returns content_for(:layout).`
Extract the layout proc into a method, and write documentation explaining what the proc does in various cases. 2009-06-18 01:55:10 +00:00			`#`
			`# The user can override this default by passing a block to the layout.`
			`#`
			`# ==== Example`
			`#`
			`# # The template`
			`# <% render :layout => "my_layout" do %>Content<% end %>`
			`#`
			`# # The layout`
			`# <html><% yield %></html>`
			`#`
			`# In this case, instead of the default block, which would return content_for(:layout),`
			`# this method returns the block that was passed in to render layout, and the response`
			`# would be <html>Content</html>.`
			`#`
			`# Finally, the block can take block arguments, which can be passed in by yield.`
			`#`
			`# ==== Example`
			`#`
			`# # The template`
Fix typo 2009-06-18 18:14:44 +00:00			`# <% render :layout => "my_layout" do \|customer\| %>Hello <%= customer.name %><% end %>`
Extract the layout proc into a method, and write documentation explaining what the proc does in various cases. 2009-06-18 01:55:10 +00:00			`#`
			`# # The layout`
			`# <html><% yield Struct.new(:name).new("David") %></html>`
			`#`
			`# In this case, the layout would receive the block passed into <tt>render :layout</tt>,`
			`# and the Struct specified in the layout would be passed into the block. The result`
			`# would be <html>Hello David</html>.`
When rendering layouts with blocks, use #capture to avoid assuming that the return value is the block's content. Signed-off-by: Yehuda Katz <wycats@Yehuda-Katz.local> 2009-11-06 04:07:14 +00:00			`def _layout_for(name = nil, &block)`
More cleanup of ActionView and reduction in need for blocks in some cases: * only one of partial_name or :as will be available as a local * `object` is removed * Simplify _layout_for in most cases. * Remove <% render :partial do \|args\| %> * <% render :partial do %> still works fine 2009-08-12 06:43:15 +00:00			`return @_content_for[name \|\| :layout] if !block_given? \|\| name`
When rendering layouts with blocks, use #capture to avoid assuming that the return value is the block's content. Signed-off-by: Yehuda Katz <wycats@Yehuda-Katz.local> 2009-11-06 04:07:14 +00:00			`capture(&block)`
Extract the layout proc into a method, and write documentation explaining what the proc does in various cases. 2009-06-18 01:55:10 +00:00			`end`

Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`def _render_inline(inline, layout, options)`
Break instrumentation into several end-points so rendering of partials can be optimized. 2009-12-25 22:37:16 +00:00			`locals = options[:locals]`
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00
Break instrumentation into several end-points so rendering of partials can be optimized. 2009-12-25 22:37:16 +00:00			`content = ActiveSupport::Notifications.instrument(:render_inline) do`
			`handler = Template.handler_class_for_extension(options[:type] \|\| "erb")`
			`template = Template.new(options[:inline], "inline template", handler, {})`
			`template.render(self, locals)`
			`end`
Dont introspect inline templates for the logger and cleanup a few styling issues 2009-12-22 00:03:04 +00:00
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`_render_text(content, layout, locals)`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`

Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`def _render_text(content, layout, locals)`
Break instrumentation into several end-points so rendering of partials can be optimized. 2009-12-25 22:37:16 +00:00			`ActiveSupport::Notifications.instrument(:render_text)`
Wrap layout rendering in one method: _render_layout (this should make partial instrumentation easier). 2009-12-25 19:25:18 +00:00			`content = _render_layout(layout, locals){ content } if layout`
Fix a bug where render :text could not handle yield :symbol. Fixes guides generation 2009-10-10 10:30:25 +00:00			`content`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`

Start cleaning up partial path 2009-08-07 04:51:50 +00:00			`# This is the API to render a ViewContext's template from a controller.`
			`#`
			`# Internal Options:`
			`# _template:: The Template object to render`
			`# _layout:: The layout, if any, to wrap the Template in`
			`# _partial:: true if the template is a partial`
			`def render_template(options)`
Clean up ActionView some: * Call _evaluate_assigns_and_ivars at the two entry points so we don't have to do a check at every render. * Make template.render viable without having to go through a wrapper method * Remove old TemplateHandler#render(template, local_assigns) path so we don't have to set self.template every time we render a template. * Move Template rescuing code to Template#render so it gets caught every time. * Pull in some tests from Pratik that test render @object in ActionView 2009-08-11 22:02:05 +00:00			`_evaluate_assigns_and_ivars`
Start cleaning up partial path 2009-08-07 04:51:50 +00:00			`template, layout, partial = options.values_at(:_template, :_layout, :_partial)`
Replace _render_template_with_layout with _render_template since the layout is optional 2009-08-07 06:18:45 +00:00			`_render_template(template, layout, options, partial)`
Implemented redirects and partial rendering in new base. 2009-05-12 23:21:34 +00:00			`end`

Replace _render_template_with_layout with _render_template since the layout is optional 2009-08-07 06:18:45 +00:00			`def _render_template(template, layout = nil, options = {}, partial = nil)`
Break instrumentation into several end-points so rendering of partials can be optimized. 2009-12-25 22:37:16 +00:00			`locals = options[:locals] \|\| {}`

			`content = ActiveSupport::Notifications.instrument(:render_template,`
			`:identifier => template.identifier, :layout => (layout ? layout.identifier : nil)) do`
			`partial ? _render_partial_object(template, options) : template.render(self, locals)`
			`end`

Clean up ActionView some: * Call _evaluate_assigns_and_ivars at the two entry points so we don't have to do a check at every render. * Make template.render viable without having to go through a wrapper method * Remove old TemplateHandler#render(template, local_assigns) path so we don't have to set self.template every time we render a template. * Move Template rescuing code to Template#render so it gets caught every time. * Pull in some tests from Pratik that test render @object in ActionView 2009-08-11 22:02:05 +00:00			`@_content_for[:layout] = content`

			`if layout`
			`@_layout = layout.identifier`
Remove ActionView inline logging to ActiveSupport::Notifications and create ActionController::Base#log_event, so everything can be logged within one listener. Also expose log_process_action as a hook for different modules to include their own information during the action processing. This allow ActiveRecord to hook and any other ORM. Finally, this commit changes 'Processing' and 'Rendering' in logs to 'Processed' and 'Rendered' because at the point it's logged, everying already happened. 2009-12-26 19:28:53 +00:00			`content = _render_layout(layout, locals)`
Clean up ActionView some: * Call _evaluate_assigns_and_ivars at the two entry points so we don't have to do a check at every render. * Make template.render viable without having to go through a wrapper method * Remove old TemplateHandler#render(template, local_assigns) path so we don't have to set self.template every time we render a template. * Move Template rescuing code to Template#render so it gets caught every time. * Pull in some tests from Pratik that test render @object in ActionView 2009-08-11 22:02:05 +00:00			`end`
Dont introspect inline templates for the logger and cleanup a few styling issues 2009-12-22 00:03:04 +00:00
Clean up ActionView some: * Call _evaluate_assigns_and_ivars at the two entry points so we don't have to do a check at every render. * Make template.render viable without having to go through a wrapper method * Remove old TemplateHandler#render(template, local_assigns) path so we don't have to set self.template every time we render a template. * Move Template rescuing code to Template#render so it gets caught every time. * Pull in some tests from Pratik that test render @object in ActionView 2009-08-11 22:02:05 +00:00			`content`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`
Wrap layout rendering in one method: _render_layout (this should make partial instrumentation easier). 2009-12-25 19:25:18 +00:00
			`def _render_layout(layout, locals, &block)`
Break instrumentation into several end-points so rendering of partials can be optimized. 2009-12-25 22:37:16 +00:00			`ActiveSupport::Notifications.instrument(:render_layout, :identifier => layout.identifier) do`
			`layout.render(self, locals){ \|name\| _layout_for(name, &block) }`
			`end`
Wrap layout rendering in one method: _render_layout (this should make partial instrumentation easier). 2009-12-25 19:25:18 +00:00			`end`
Begin unifying the interface between ActionController and ActionView 2009-01-22 22:18:10 +00:00			`end`
Remove ActionMailer helpers and rely on AbstractController one. 2009-10-18 22:20:14 +00:00			`end`