actionview 5.2.4.4 → 6.1.1

data/lib/action_view/record_identifier.rb

@@ -59,8 +59,8 @@ module ActionView
 
     include ModelNaming
 
-    JOIN = "_".freeze
-    NEW = "new".freeze
+    JOIN = "_"
+    NEW = "new"
 
     # The DOM class convention is to use the singular form of an object or class.
     #
@@ -95,7 +95,6 @@ module ActionView
     end
 
   private
-
     # Returns a string representation of the key attribute(s) that is suitable for use in an HTML DOM id.
     # This can be overwritten to customize the default generated string representation if desired.
     # If you need to read back a key from a dom_id in order to query for the underlying database record,

data/lib/action_view/renderer/abstract_renderer.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+
 module ActionView
   # This class defines the interface for a renderer. Each class that
   # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
@@ -14,10 +16,10 @@ module ActionView
   #
   # Whenever the +render+ method is called on the base +Renderer+ class, a new
   # renderer object of the correct type is created, and the +render+ method on
-  # that new object is called in turn. This abstracts the setup and rendering
+  # that new object is called in turn. This abstracts the set up and rendering
   # into a separate classes for partials and templates.
   class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :any_templates?, :with_fallbacks, :with_layout_format, :formats, to: :@lookup_context
+    delegate :template_exists?, :any_templates?, :formats, to: :@lookup_context
 
     def initialize(lookup_context)
       @lookup_context = lookup_context
@@ -27,22 +29,143 @@ module ActionView
       raise NotImplementedError
     end
 
-    private
+    module ObjectRendering # :nodoc:
+      PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
+        h[k] = Concurrent::Map.new
+      end
 
-      def extract_details(options) # :doc:
-        @lookup_context.registered_details.each_with_object({}) do |key, details|
-          value = options[key]
+      def initialize(lookup_context, options)
+        super
+        @context_prefix = lookup_context.prefixes.first
+      end
+
+      private
+        def local_variable(path)
+          if as = @options[:as]
+            raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
+            as.to_sym
+          else
+            base = path.end_with?("/") ? "" : File.basename(path)
+            raise_invalid_identifier(path) unless base =~ /\A_?(.*?)(?:\.\w+)*\z/
+            $1.to_sym
+          end
+        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, IDENTIFIER_ERROR_MESSAGE % path
+        end
+
+        def raise_invalid_option_as(as)
+          raise ArgumentError, OPTION_AS_ERROR_MESSAGE % as
+        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[@context_prefix][path] ||= merge_prefix_into_object_path(@context_prefix, path.dup)
+          else
+            path
+          end
+        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
+    end
+
+    class RenderedCollection # :nodoc:
+      def self.empty(format)
+        EmptyCollection.new format
+      end
 
-          details[key] = Array(value) if value
+      attr_reader :rendered_templates
+
+      def initialize(rendered_templates, spacer)
+        @rendered_templates = rendered_templates
+        @spacer = spacer
+      end
+
+      def body
+        @rendered_templates.map(&:body).join(@spacer.body).html_safe
+      end
+
+      def format
+        rendered_templates.first.format
+      end
+
+      class EmptyCollection
+        attr_reader :format
+
+        def initialize(format)
+          @format = format
         end
+
+        def body; nil; end
       end
+    end
 
-      def instrument(name, **options) # :doc:
-        options[:identifier] ||= (@template && @template.identifier) || @path
+    class RenderedTemplate # :nodoc:
+      attr_reader :body, :template
 
-        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
-          yield payload
+      def initialize(body, template)
+        @body = body
+        @template = template
+      end
+
+      def format
+        template.format
+      end
+
+      EMPTY_SPACER = Struct.new(:body).new
+    end
+
+    private
+      NO_DETAILS = {}.freeze
+
+      def extract_details(options) # :doc:
+        details = nil
+        @lookup_context.registered_details.each do |key|
+          value = options[key]
+
+          if value
+            (details ||= {})[key] = Array(value)
+          end
         end
+        details || NO_DETAILS
       end
 
       def prepend_formats(formats) # :doc:
@@ -51,5 +174,13 @@ module ActionView
 
         @lookup_context.formats = formats | @lookup_context.formats
       end
+
+      def build_rendered_template(content, template)
+        RenderedTemplate.new content, template
+      end
+
+      def build_rendered_collection(templates, spacer)
+        RenderedCollection.new templates, spacer
+      end
   end
 end

data/lib/action_view/renderer/collection_renderer.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "action_view/renderer/partial_renderer"
+
+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
+
+  class CollectionRenderer < PartialRenderer # :nodoc:
+    include ObjectRendering
+
+    class CollectionIterator # :nodoc:
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def each(&blk)
+        @collection.each(&blk)
+      end
+
+      def size
+        @collection.size
+      end
+
+      def length
+        @collection.respond_to?(:length) ? @collection.length : size
+      end
+    end
+
+    class SameCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, path, variables)
+        super(collection)
+        @path      = path
+        @variables = variables
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables)
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        variables = [@path] + @variables
+        @collection.each { |o| yield(o, variables) }
+      end
+    end
+
+    class PreloadCollectionIterator < SameCollectionIterator # :nodoc:
+      def initialize(collection, path, variables, relation)
+        super(collection, path, variables)
+        relation.skip_preloading! unless relation.loaded?
+        @relation = relation
+      end
+
+      def from_collection(collection)
+        self.class.new(collection, @path, @variables, @relation)
+      end
+
+      def each_with_info
+        return super unless block_given?
+        @relation.preload_associations(@collection)
+        super
+      end
+    end
+
+    class MixedCollectionIterator < CollectionIterator # :nodoc:
+      def initialize(collection, paths)
+        super(collection)
+        @paths = paths
+      end
+
+      def each_with_info
+        return enum_for(:each_with_info) unless block_given?
+        @collection.each_with_index { |o, i| yield(o, @paths[i]) }
+      end
+    end
+
+    def render_collection_with_partial(collection, partial, context, block)
+      iter_vars  = retrieve_variable(partial)
+
+      collection = if collection.respond_to?(:preload_associations)
+        PreloadCollectionIterator.new(collection, partial, iter_vars, collection)
+      else
+        SameCollectionIterator.new(collection, partial, iter_vars)
+      end
+
+      template = find_template(partial, @locals.keys + iter_vars)
+
+      layout = if !block && (layout = @options[:layout])
+        find_template(layout.to_s, @locals.keys + iter_vars)
+      end
+
+      render_collection(collection, context, partial, template, layout, block)
+    end
+
+    def render_collection_derive_partial(collection, context, block)
+      paths = collection.map { |o| partial_path(o, context) }
+
+      if paths.uniq.length == 1
+        # Homogeneous
+        render_collection_with_partial(collection, paths.first, context, block)
+      else
+        if @options[:cached]
+          raise NotImplementedError, "render caching requires a template. Please specify a partial when rendering"
+        end
+
+        paths.map! { |path| retrieve_variable(path).unshift(path) }
+        collection = MixedCollectionIterator.new(collection, paths)
+        render_collection(collection, context, nil, nil, nil, block)
+      end
+    end
+
+    private
+      def retrieve_variable(path)
+        variable = local_variable(path)
+        [variable, :"#{variable}_counter", :"#{variable}_iteration"]
+      end
+
+      def render_collection(collection, view, path, template, layout, block)
+        identifier = (template && template.identifier) || path
+        ActiveSupport::Notifications.instrument(
+          "render_collection.action_view",
+          identifier: identifier,
+          layout: layout && layout.virtual_path,
+          count: collection.length
+        ) do |payload|
+          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, collection) do |filtered_collection|
+              collection_with_template(view, template, layout, filtered_collection)
+            end
+          else
+            collection_with_template(view, nil, layout, collection)
+          end
+
+          return RenderedCollection.empty(@lookup_context.formats.first) if collection_body.empty?
+
+          build_rendered_collection(collection_body, spacer)
+        end
+      end
+
+      def collection_with_template(view, template, layout, collection)
+        locals = @locals
+        cache = {}
+
+        partial_iteration = PartialIteration.new(collection.size)
+
+        collection.each_with_info.map do |object, (path, as, counter, iteration)|
+          index = partial_iteration.index
+
+          locals[as]        = object
+          locals[counter]   = index
+          locals[iteration] = partial_iteration
+
+          _template = (cache[path] ||= (template || find_template(path, @locals.keys + [as, counter, iteration])))
+
+          content = _template.render(view, locals)
+          content = layout.render(view, locals) { content } if layout
+          partial_iteration.iterate!
+          build_rendered_template(content, _template)
+        end
+      end
+  end
+end

data/lib/action_view/renderer/object_renderer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionView
+  class ObjectRenderer < PartialRenderer # :nodoc:
+    include ObjectRendering
+
+    def initialize(lookup_context, options)
+      super
+      @object     = nil
+      @local_name = nil
+    end
+
+    def render_object_with_partial(object, partial, context, block)
+      @object     = object
+      @local_name = local_variable(partial)
+      render(partial, context, block)
+    end
+
+    def render_object_derive_partial(object, context, block)
+      path = partial_path(object, context)
+      render_object_with_partial(object, path, context, block)
+    end
+
+    private
+      def template_keys(path)
+        super + [@local_name]
+      end
+
+      def render_partial_template(view, locals, template, layout, block)
+        locals[@local_name || template.variable] = @object
+        super(view, locals, template, layout, block)
+      end
+  end
+end

data/lib/action_view/renderer/partial_renderer.rb

@@ -1,36 +1,8 @@
 # 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
@@ -105,9 +77,6 @@ module ActionView
   #
   #   <%= 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:
@@ -285,268 +254,47 @@ module ActionView
   class PartialRenderer < AbstractRenderer
     include CollectionCaching
 
-    PREFIXED_PARTIAL_NAMES = Concurrent::Map.new do |h, k|
-      h[k] = Concurrent::Map.new
+    def initialize(lookup_context, options)
+      super(lookup_context)
+      @options = options
+      @locals  = @options[:locals] || {}
+      @details = extract_details(@options)
     end
 
-    def initialize(*)
-      super
-      @context_prefix = @lookup_context.prefixes.first
-    end
-
-    def render(context, options, block)
-      setup(context, options, block)
-      @template = find_partial
+    def render(partial, context, block)
+      template = find_template(partial, template_keys(partial))
 
-      @lookup_context.rendered_format ||= begin
-        if @template && @template.formats.present?
-          @template.formats.first
-        else
-          formats.first
-        end
+      if !block && (layout = @options[:layout])
+        layout = find_template(layout.to_s, template_keys(partial))
       end
 
-      if @collection
-        render_collection
-      else
-        render_partial
-      end
+      render_partial_template(context, @locals, template, layout, block)
     end
 
     private
-
-      def render_collection
-        instrument(:collection, count: @collection.size) do |payload|
-          return nil if @collection.blank?
-
-          if @options.key?(:spacer_template)
-            spacer = find_template(@options[:spacer_template], @locals.keys).render(@view, @locals)
-          end
-
-          cache_collection_render(payload) do
-            @template ? collection_with_template : collection_without_template
-          end.join(spacer).html_safe
-        end
+      def template_keys(_)
+        @locals.keys
       end
 
-      def render_partial
-        instrument(:partial) do |payload|
-          view, locals, block = @view, @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|
+      def render_partial_template(view, locals, template, layout, block)
+        ActiveSupport::Notifications.instrument(
+          "render_partial.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path
+        ) do |payload|
+          content = template.render(view, locals, add_to_stack: !block) 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]
-          content
-        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 <tt>@path</tt> 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, block)
-        @view = context
-        @options = options
-        @block   = block
-
-        @locals  = options[:locals] || {}
-        @details = extract_details(options)
-
-        prepend_formats(options[:formats])
-
-        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) }
-            @path = paths.uniq.one? ? paths.first : nil
-          else
-            @path = partial_path
-          end
+          payload[:cache_hit] = view.view_renderer.cache_hits[template.virtual_path]
+          build_rendered_template(content, template)
         end
-
-        if as = options[:as]
-          raise_invalid_option_as(as) unless /\A[a-z_]\w*\z/.match?(as.to_s)
-          as = as.to_sym
-        end
-
-        if @path
-          @variable, @variable_counter, @variable_iteration = retrieve_variable(@path, as)
-          @template_keys = retrieve_template_keys
-        else
-          paths.map! { |path| retrieve_variable(path, as).unshift(path) }
-        end
-
-        self
-      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
-        find_template(@path, @template_keys) if @path
       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, locals, template = @view, @locals, @template
-        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!
-          content
-        end
-      end
-
-      def collection_without_template
-        view, locals, collection_data = @view, @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!
-          content
-        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 = @object)
-        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
-        keys = @locals.keys
-        keys << @variable if @has_object || @collection
-        if @collection
-          keys << @variable_counter
-          keys << @variable_iteration
-        end
-        keys
-      end
-
-      def retrieve_variable(path, as)
-        variable = as || begin
-          base = path[-1] == "/".freeze ? "".freeze : 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