actionview 6.0.6.1 → 6.1.7.4

data/lib/action_view/renderer/partial_renderer/collection_caching.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActionView
   module CollectionCaching # :nodoc:
     extend ActiveSupport::Concern
@@ -11,13 +13,19 @@ module ActionView
     end
 
     private
-      def cache_collection_render(instrumentation_payload, view, template)
-        return yield unless @options[:cached] && view.controller.respond_to?(:perform_caching) && view.controller.perform_caching
+      def will_cache?(options, view)
+        options[:cached] && view.controller.respond_to?(:perform_caching) && view.controller.perform_caching
+      end
+
+      def cache_collection_render(instrumentation_payload, view, template, collection)
+        return yield(collection) unless will_cache?(@options, view)
+
+        collection_iterator = collection
 
         # Result is a hash with the key represents the
         # key used for cache lookup and the value is the item
         # on which the partial is being rendered
-        keyed_collection, ordered_keys = collection_by_cache_keys(view, template)
+        keyed_collection, ordered_keys = collection_by_cache_keys(view, template, collection)
 
         # Pull all partials from cache
         # Result is a hash, key matches the entry in
@@ -27,17 +35,9 @@ module ActionView
         instrumentation_payload[:cache_hits] = cached_partials.size
 
         # Extract the items for the keys that are not found
-        # Set the uncached values to instance variable @collection
-        # which is used by the caller
-        @collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
-
-        # If all elements are already in cache then
-        # rendered partials will be an empty array
-        #
-        # If the cache is missing elements then
-        # the block will be called against the remaining items
-        # in the @collection.
-        rendered_partials = @collection.empty? ? [] : yield
+        collection = keyed_collection.reject { |key, _| cached_partials.key?(key) }.values
+
+        rendered_partials = collection.empty? ? [] : yield(collection_iterator.from_collection(collection))
 
         index = 0
         keyed_partials = fetch_or_cache_partial(cached_partials, template, order_by: keyed_collection.each_key) do
@@ -55,12 +55,12 @@ module ActionView
         @options[:cached].respond_to?(:call)
       end
 
-      def collection_by_cache_keys(view, template)
+      def collection_by_cache_keys(view, template, collection)
         seed = callable_cache_key? ? @options[:cached] : ->(i) { i }
 
         digest_path = view.digest_path_from_template(template)
 
-        @collection.each_with_object([{}, []]) do |item, (hash, ordered_keys)|
+        collection.each_with_object([{}, []]) do |item, (hash, ordered_keys)|
           key = expanded_cache_key(seed.call(item), view, template, digest_path)
           ordered_keys << key
           hash[key] = item
@@ -68,7 +68,7 @@ module ActionView
       end
 
       def expanded_cache_key(key, view, template, digest_path)
-        key = view.combined_fragment_cache_key(view.cache_fragment_name(key, virtual_path: template.virtual_path, digest_path: digest_path))
+        key = view.combined_fragment_cache_key(view.cache_fragment_name(key, digest_path: digest_path))
         key.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
       end
 
@@ -88,16 +88,15 @@ module ActionView
       # If the partial is not already cached it will also be
       # written back to the underlying cache store.
       def fetch_or_cache_partial(cached_partials, template, order_by:)
-        order_by.each_with_object({}) do |cache_key, hash|
-            hash[cache_key] =
-              if content = cached_partials[cache_key]
-                build_rendered_template(content, template)
-              else
-                yield.tap do |rendered_partial|
-                  collection_cache.write(cache_key, rendered_partial.body)
-                end
-              end
+        order_by.index_with do |cache_key|
+          if content = cached_partials[cache_key]
+            build_rendered_template(content, template)
+          else
+            yield.tap do |rendered_partial|
+              collection_cache.write(cache_key, rendered_partial.body)
+            end
           end
+        end
       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
@@ -282,281 +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(partial, context, block)
+      template = find_template(partial, template_keys(partial))
 
-    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
+      if !block && (layout = @options[:layout])
+        layout = find_template(layout.to_s, template_keys(partial))
       end
 
-      if @collection
-        render_collection(context, template)
-      else
-        render_partial(context, template)
-      end
+      render_partial_template(context, @locals, template, layout, block)
     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
+      def template_keys(_)
+        @locals.keys
       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|
+      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]
-          build_rendered_template(content, template, layout)
-        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, 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 : []
+          build_rendered_template(content, template)
         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, layout)
-        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

data/lib/action_view/renderer/renderer.rb

@@ -62,7 +62,50 @@ module ActionView
     end
 
     def render_partial_to_object(context, options, &block) #:nodoc:
-      PartialRenderer.new(@lookup_context).render(context, options, block)
+      partial = options[:partial]
+      if String === partial
+        collection = collection_from_options(options)
+
+        if collection
+          # Collection + Partial
+          renderer = CollectionRenderer.new(@lookup_context, options)
+          renderer.render_collection_with_partial(collection, partial, context, block)
+        else
+          if options.key?(:object)
+            # Object + Partial
+            renderer = ObjectRenderer.new(@lookup_context, options)
+            renderer.render_object_with_partial(options[:object], partial, context, block)
+          else
+            # Partial
+            renderer = PartialRenderer.new(@lookup_context, options)
+            renderer.render(partial, context, block)
+          end
+        end
+      else
+        collection = collection_from_object(partial) || collection_from_options(options)
+
+        if collection
+          # Collection + Derived Partial
+          renderer = CollectionRenderer.new(@lookup_context, options)
+          renderer.render_collection_derive_partial(collection, context, block)
+        else
+          # Object + Derived Partial
+          renderer = ObjectRenderer.new(@lookup_context, options)
+          renderer.render_object_derive_partial(partial, context, block)
+        end
+      end
     end
+
+    private
+      def collection_from_options(options)
+        if options.key?(:collection)
+          collection = options[:collection]
+          collection || []
+        end
+      end
+
+      def collection_from_object(object)
+        object if object.respond_to?(:to_ary)
+      end
   end
 end

data/lib/action_view/renderer/streaming_template_renderer.rb

@@ -62,7 +62,11 @@ module ActionView
         output  = ActionView::StreamingBuffer.new(buffer)
         yielder = lambda { |*name| view._layout_for(*name) }
 
-        instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+        ActiveSupport::Notifications.instrument(
+          "render_template.action_view",
+          identifier: template.identifier,
+          layout: layout && layout.virtual_path
+        ) do
           outer_config = I18n.config
           fiber = Fiber.new do
             I18n.config = outer_config

data/lib/action_view/renderer/template_renderer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/try"
-
 module ActionView
   class TemplateRenderer < AbstractRenderer #:nodoc:
     def render(context, options)
@@ -28,8 +26,7 @@ module ActionView
           if File.exist?(options[:file])
             Template::RawFile.new(options[:file])
           else
-            ActiveSupport::Deprecation.warn "render file: should be given the absolute path to a file"
-            @lookup_context.with_fallbacks.find_template(options[:file], nil, false, keys, @details)
+            raise ArgumentError, "`render file:` should be given the absolute path to a file. '#{options[:file]}' was given instead"
           end
         elsif options.key?(:inline)
           handler = Template.handler_for_extension(options[:type] || "erb")
@@ -39,6 +36,8 @@ module ActionView
             @lookup_context.formats.first
           end
           Template::Inline.new(options[:inline], "inline template", handler, locals: keys, format: format)
+        elsif options.key?(:renderable)
+          Template::Renderable.new(options[:renderable])
         elsif options.key?(:template)
           if options[:template].respond_to?(:render)
             options[:template]
@@ -54,7 +53,11 @@ module ActionView
       # supplied as well.
       def render_template(view, template, layout_name, locals)
         render_with_layout(view, template, layout_name, locals) do |layout|
-          instrument(:template, identifier: template.identifier, layout: layout.try(:virtual_path)) do
+          ActiveSupport::Notifications.instrument(
+            "render_template.action_view",
+            identifier: template.identifier,
+            layout: layout && layout.virtual_path
+          ) do
             template.render(view, locals) { |*name| view._layout_for(*name) }
           end
         end
@@ -62,15 +65,16 @@ module ActionView
 
       def render_with_layout(view, template, path, locals)
         layout  = path && find_layout(path, locals.keys, [formats.first])
-        content = yield(layout)
 
         body = if layout
-          view.view_flow.set(:layout, content)
-          layout.render(view, locals) { |*name| view._layout_for(*name) }
+          ActiveSupport::Notifications.instrument("render_layout.action_view", identifier: layout.identifier) do
+            view.view_flow.set(:layout, yield(layout))
+            layout.render(view, locals) { |*name| view._layout_for(*name) }
+          end
         else
-          content
+          yield
         end
-        build_rendered_template(body, template, layout)
+        build_rendered_template(body, template)
       end
 
       # This is the method which actually finds the layout using details in the lookup
@@ -88,8 +92,7 @@ module ActionView
         when String
           begin
             if layout.start_with?("/")
-              ActiveSupport::Deprecation.warn "Rendering layouts from an absolute path is deprecated."
-              @lookup_context.with_fallbacks.find_template(layout, nil, false, [], details)
+              raise ArgumentError, "Rendering layouts from an absolute path is not supported."
             else
               @lookup_context.find_template(layout, nil, false, [], details)
             end

data/lib/action_view/rendering.rb

@@ -33,7 +33,7 @@ module ActionView
       super
     end
 
-    # Overwrite process to setup I18n proxy.
+    # Overwrite process to set up I18n proxy.
     def process(*) #:nodoc:
       old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
       super
@@ -144,6 +144,8 @@ module ActionView
         else
           if action.respond_to?(:permitted?) && action.permitted?
             options = action
+          elsif action.respond_to?(:render_in)
+            options[:renderable] = action
           else
             options[:partial] = action
           end

data/lib/action_view/routing_url_for.rb

@@ -105,7 +105,7 @@ module ActionView
         end
       else
         method = _generate_paths_by_default ? :path : :url
-        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.send(method)
+        builder = ActionDispatch::Routing::PolymorphicRoutes::HelperMethodBuilder.public_send(method)
 
         case options
         when Symbol

data/lib/action_view/template/handlers/erb/erubi.rb

@@ -13,9 +13,11 @@ module ActionView
 
             # Dup properties so that we don't modify argument
             properties = Hash[properties]
-            properties[:preamble]   = ""
-            properties[:postamble]  = "@output_buffer.to_s"
-            properties[:bufvar]     = "@output_buffer"
+
+            properties[:bufvar]     ||= "@output_buffer"
+            properties[:preamble]   ||= ""
+            properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+
             properties[:escapefunc] = ""
 
             super
@@ -37,7 +39,7 @@ module ActionView
             if text == "\n"
               @newline_pending += 1
             else
-              src << "@output_buffer.safe_append='"
+              src << bufvar << ".safe_append='"
               src << "\n" * @newline_pending if @newline_pending > 0
               src << text.gsub(/['\\]/, '\\\\\&')
               src << "'.freeze;"
@@ -52,9 +54,9 @@ module ActionView
             flush_newline_if_pending(src)
 
             if (indicator == "==") || @escape
-              src << "@output_buffer.safe_expr_append="
+              src << bufvar << ".safe_expr_append="
             else
-              src << "@output_buffer.append="
+              src << bufvar << ".append="
             end
 
             if BLOCK_EXPR.match?(code)
@@ -76,7 +78,7 @@ module ActionView
 
           def flush_newline_if_pending(src)
             if @newline_pending > 0
-              src << "@output_buffer.safe_append='#{"\n" * @newline_pending}'.freeze;"
+              src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
               @newline_pending = 0
             end
           end