# frozen_string_literal: true require "concurrent/map" require "action_view/renderer/partial_renderer/collection_caching" module ActionView class PartialIteration # The number of iterations that will be done by the partial. attr_reader :size # The current iteration of the partial. attr_reader :index def initialize(size) @size = size @index = 0 end # Check if this is the first iteration of the partial. def first? index == 0 end # Check if this is the last iteration of the partial. def last? index == size - 1 end def iterate! # :nodoc: @index += 1 end end # = 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 object will automatically be made available to the template with a name of the form # +partial_name_iteration+. The iteration object has knowledge about which index the current object has in # the collection and the total size of the collection. The iteration object also has two convenience methods, # +first?+ and +last?+. In the case of the example above, the template would be fed +ad_iteration+. # For backwards compatibility the +partial_name_counter+ is still present and is mapped to the iteration's # +index+ method. # # 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 be 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_partial_path+ method. # # # @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 %> #
# Budget: $<%= user.budget %> # <%= yield %> #
# # <%# app/views/users/_editor.html.erb %> #
# Deadline: <%= user.deadline %> # <%= yield %> #
# # ...this will return: # # Here's the administrator: #
# Budget: $<%= user.budget %> # Name: <%= user.name %> #
# # Here's the editor: #
# Deadline: <%= user.deadline %> # Name: <%= user.name %> #
# # If a collection is given, the layout will be rendered once for each item in # the collection. For example, these two snippets have the same output: # # <%# app/views/users/_user.html.erb %> # Name: <%= user.name %> # # <%# app/views/users/index.html.erb %> # <%# This does not use layouts %> # # # <%# app/views/users/_li_layout.html.erb %> #
  • # <%= yield %> #
  • # # <%# app/views/users/index.html.erb %> # # # Given two users whose names are Alice and Bob, these snippets return: # # # # The current object being rendered, as well as the object_counter, will be # available as local variables inside the layout template under the same names # as available in the partial. # # 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: # #
    # Budget: $<%= user.budget %> # Title: <%= chief.name %> #
    # # 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 %> #
    # Budget: $<%= user.budget %> # <%= yield user %> #
    # # <%# 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 %> #
    # <%= yield user, :header %> # Budget: $<%= user.budget %> # <%= yield user, :footer %> #
    # # <%# 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 %> class PartialRenderer < AbstractRenderer include CollectionCaching PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k| h[k] = Concurrent::Map.new end def initialize(*) super @context_prefix = @lookup_context.prefixes.first end def render(context, options, block) as = as_variable(options) setup(context, options, as, block) if @path if @has_object || @collection @variable, @variable_counter, @variable_iteration = retrieve_variable(@path, as) @template_keys = retrieve_template_keys(@variable) else @template_keys = @locals.keys end template = find_partial(@path, @template_keys) @variable ||= template.variable else if options[:cached] raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering" end template = nil end if @collection render_collection(context, template) else render_partial(context, template) end end private def render_collection(view, template) identifier = (template && template.identifier) || @path instrument(:collection, identifier: identifier, count: @collection.size) do |payload| return RenderedCollection.empty(@lookup_context.formats.first) if @collection.blank? spacer = if @options.key?(:spacer_template) spacer_template = find_template(@options[:spacer_template], @locals.keys) build_rendered_template(spacer_template.render(view, @locals), spacer_template) else RenderedTemplate::EMPTY_SPACER end collection_body = if template cache_collection_render(payload, view, template) do collection_with_template(view, template) end else collection_without_template(view) end build_rendered_collection(collection_body, spacer) end end def render_partial(view, template) instrument(:partial, identifier: template.identifier) do |payload| locals, block = @locals, @block object, as = @object, @variable if !block && (layout = @options[:layout]) layout = find_template(layout.to_s, @template_keys) end object = locals[as] if object.nil? # Respect object when object is false locals[as] = object if @has_object content = template.render(view, locals) do |*name| view._layout_for(*name, &block) end content = layout.render(view, locals) { content } if layout payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path] build_rendered_template(content, template) end end # Sets up instance variables needed for rendering a partial. This method # finds the options and details and extracts them. The method also contains # logic that handles the type of object passed in as the partial. # # If +options[:partial]+ is a string, then the @path instance variable is # set to that string. Otherwise, the +options[:partial]+ object must # respond to +to_partial_path+ in order to setup the path. def setup(context, options, as, block) @options = options @block = block @locals = options[:locals] || {} @details = extract_details(options) partial = options[:partial] if String === partial @has_object = options.key?(:object) @object = options[:object] @collection = collection_from_options @path = partial else @has_object = true @object = partial @collection = collection_from_object || collection_from_options if @collection paths = @collection_data = @collection.map { |o| partial_path(o, context) } if paths.uniq.length == 1 @path = paths.first else paths.map! { |path| retrieve_variable(path, as).unshift(path) } @path = nil end else @path = partial_path(@object, context) end end self end def as_variable(options) if as = options[:as] raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s) as.to_sym end end def collection_from_options if @options.key?(:collection) collection = @options[:collection] collection ? collection.to_a : [] end end def collection_from_object @object.to_ary if @object.respond_to?(:to_ary) end def find_partial(path, template_keys) find_template(path, template_keys) end def find_template(path, locals) prefixes = path.include?(?/) ? [] : @lookup_context.prefixes @lookup_context.find_template(path, prefixes, true, locals, @details) end def collection_with_template(view, template) locals = @locals as, counter, iteration = @variable, @variable_counter, @variable_iteration if layout = @options[:layout] layout = find_template(layout, @template_keys) end partial_iteration = PartialIteration.new(@collection.size) locals[iteration] = partial_iteration @collection.map do |object| locals[as] = object locals[counter] = partial_iteration.index content = template.render(view, locals) content = layout.render(view, locals) { content } if layout partial_iteration.iterate! build_rendered_template(content, template) end end def collection_without_template(view) locals, collection_data = @locals, @collection_data cache = {} keys = @locals.keys partial_iteration = PartialIteration.new(@collection.size) @collection.map do |object| index = partial_iteration.index path, as, counter, iteration = collection_data[index] locals[as] = object locals[counter] = index locals[iteration] = partial_iteration template = (cache[path] ||= find_template(path, keys + [as, counter, iteration])) content = template.render(view, locals) partial_iteration.iterate! build_rendered_template(content, template) end end # Obtains the path to where the object's partial is located. If the object # responds to +to_partial_path+, then +to_partial_path+ will be called and # will provide the path. If the object does not respond to +to_partial_path+, # then an +ArgumentError+ is raised. # # If +prefix_partial_path_with_controller_namespace+ is true, then this # method will prefix the partial paths with a namespace. def partial_path(object, view) object = object.to_model if object.respond_to?(:to_model) path = if object.respond_to?(:to_partial_path) object.to_partial_path else raise ArgumentError.new("'#{object.inspect}' is not an ActiveModel-compatible object. It must implement :to_partial_path.") end if view.prefix_partial_path_with_controller_namespace prefixed_partial_names[path] ||= merge_prefix_into_object_path(@context_prefix, path.dup) else path end end def prefixed_partial_names @prefixed_partial_names ||= PREFIXED_PARTIAL_NAMES[@context_prefix] end def merge_prefix_into_object_path(prefix, object_path) if prefix.include?(?/) && object_path.include?(?/) prefixes = [] prefix_array = File.dirname(prefix).split("/") object_path_array = object_path.split("/")[0..-3] # skip model dir & partial prefix_array.each_with_index do |dir, index| break if dir == object_path_array[index] prefixes << dir end (prefixes << object_path).join("/") else object_path end end def retrieve_template_keys(variable) keys = @locals.keys keys << variable if @collection keys << @variable_counter keys << @variable_iteration end keys end def retrieve_variable(path, as) variable = as || begin base = path[-1] == "/" ? "" : File.basename(path) raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/ $1.to_sym end if @collection variable_counter = :"#{variable}_counter" variable_iteration = :"#{variable}_iteration" end [variable, variable_counter, variable_iteration] end IDENTIFIER_ERROR_MESSAGE = "The partial name (%s) is not a valid Ruby identifier; " \ "make sure your partial name starts with underscore." OPTION_AS_ERROR_MESSAGE = "The value (%s) of the option `as` is not a valid Ruby identifier; " \ "make sure it starts with lowercase letter, " \ "and is followed by any combination of letters, numbers and underscores." def raise_invalid_identifier(path) raise ArgumentError.new(IDENTIFIER_ERROR_MESSAGE % (path)) end def raise_invalid_option_as(as) raise ArgumentError.new(OPTION_AS_ERROR_MESSAGE % (as)) end end end