actionview 4.2.11.1 → 6.0.4.8

data/lib/action_view/renderer/abstract_renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionView
   # This class defines the interface for a renderer. Each class that
   # subclasses +AbstractRenderer+ is used by the base +Renderer+ class to
@@ -15,7 +17,7 @@ module ActionView
   # that new object is called in turn. This abstracts the setup and rendering
   # into a separate classes for partials and templates.
   class AbstractRenderer #:nodoc:
-    delegate :find_template, :find_file, :template_exists?, :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
@@ -25,25 +27,81 @@ module ActionView
       raise NotImplementedError
     end
 
-    protected
+    class RenderedCollection # :nodoc:
+      def self.empty(format)
+        EmptyCollection.new format
+      end
 
-    def extract_details(options)
-      @lookup_context.registered_details.each_with_object({}) do |key, details|
-        value = options[key]
+      attr_reader :rendered_templates
 
-        details[key] = Array(value) if value
+      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
-    end
 
-    def instrument(name, options={})
-      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
+      class EmptyCollection
+        attr_reader :format
+
+        def initialize(format)
+          @format = format
+        end
+
+        def body; nil; end
+      end
     end
 
-    def prepend_formats(formats)
-      formats = Array(formats)
-      return if formats.empty? || @lookup_context.html_fallback_for_js
+    class RenderedTemplate # :nodoc:
+      attr_reader :body, :layout, :template
+
+      def initialize(body, layout, template)
+        @body = body
+        @layout = layout
+        @template = template
+      end
+
+      def format
+        template.format
+      end
 
-      @lookup_context.formats = formats | @lookup_context.formats
+      EMPTY_SPACER = Struct.new(:body).new
     end
+
+    private
+      def extract_details(options) # :doc:
+        @lookup_context.registered_details.each_with_object({}) do |key, details|
+          value = options[key]
+
+          details[key] = Array(value) if value
+        end
+      end
+
+      def instrument(name, **options) # :doc:
+        ActiveSupport::Notifications.instrument("render_#{name}.action_view", options) do |payload|
+          yield payload
+        end
+      end
+
+      def prepend_formats(formats) # :doc:
+        formats = Array(formats)
+        return if formats.empty? || @lookup_context.html_fallback_for_js
+
+        @lookup_context.formats = formats | @lookup_context.formats
+      end
+
+      def build_rendered_template(content, template, layout = nil)
+        RenderedTemplate.new content, layout, template
+      end
+
+      def build_rendered_collection(templates, spacer)
+        RenderedCollection.new templates, spacer
+      end
   end
 end

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module ActionView
+  module CollectionCaching # :nodoc:
+    extend ActiveSupport::Concern
+
+    included do
+      # Fallback cache store if Action View is used without Rails.
+      # Otherwise overridden in Railtie to use Rails.cache.
+      mattr_accessor :collection_cache, default: ActiveSupport::Cache::MemoryStore.new
+    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
+
+        # 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)
+
+        # Pull all partials from cache
+        # Result is a hash, key matches the entry in
+        # `keyed_collection` where the cache was retrieved and the
+        # value is the value that was present in the cache
+        cached_partials = collection_cache.read_multi(*keyed_collection.keys)
+        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
+
+        index = 0
+        keyed_partials = fetch_or_cache_partial(cached_partials, template, order_by: keyed_collection.each_key) do
+          # This block is called once
+          # for every cache miss while preserving order.
+          rendered_partials[index].tap { index += 1 }
+        end
+
+        ordered_keys.map do |key|
+          keyed_partials[key]
+        end
+      end
+
+      def callable_cache_key?
+        @options[:cached].respond_to?(:call)
+      end
+
+      def collection_by_cache_keys(view, template)
+        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)|
+          key = expanded_cache_key(seed.call(item), view, template, digest_path)
+          ordered_keys << key
+          hash[key] = item
+        end
+      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.frozen? ? key.dup : key # #read_multi & #write may require mutability, Dalli 2.6.0.
+      end
+
+      # `order_by` is an enumerable object containing keys of the cache,
+      # all keys are  passed in whether found already or not.
+      #
+      # `cached_partials` is a hash. If the value exists
+      # it represents the rendered partial from the cache
+      # otherwise `Hash#fetch` will take the value of its block.
+      #
+      # This method expects a block that will return the rendered
+      # partial. An example is to render all results
+      # for each element that was not found in the cache and store it as an array.
+      # Order it so that the first empty cache element in `cached_partials`
+      # corresponds to the first element in `rendered_partials`.
+      #
+      # 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
+          end
+      end
+  end
+end