Object renderer read_multi rendered entries from Cacheread-multi-rendered-objects

3 files changed, 72 insertions, 11 deletions

diff --git a/lib/banzai.rb b/lib/banzai.rb
index 093382261ae..9ebe379f454 100644
--- a/lib/banzai.rb
+++ b/lib/banzai.rb
@@ -3,6 +3,10 @@ module Banzai
     Renderer.render(text, context)
   end
 
+  def self.cache_collection_render(texts_and_contexts)
+    Renderer.cache_collection_render(texts_and_contexts)
+  end
+
   def self.render_result(text, context = {})
     Renderer.render_result(text, context)
   end
diff --git a/lib/banzai/object_renderer.rb b/lib/banzai/object_renderer.rb
index dc83b87a6c1..9aef807c152 100644
--- a/lib/banzai/object_renderer.rb
+++ b/lib/banzai/object_renderer.rb
@@ -39,9 +39,7 @@ module Banzai
 
     # Renders the attribute of every given object.
     def render_objects(objects, attribute)
-      objects.map do |object|
-        render_attribute(object, attribute)
-      end
+      render_attributes(objects, attribute)
     end
 
     # Redacts the list of documents.
@@ -64,16 +62,21 @@ module Banzai
       context
     end
 
-    # Renders the attribute of an object.
+    # Renders the attributes of a set of objects.
     #
-    # Returns a `Nokogiri::HTML::Document`.
-    def render_attribute(object, attribute)
-      context = context_for(object, attribute)
+    # Returns an Array of `Nokogiri::HTML::Document`.
+    def render_attributes(objects, attribute)
+      strings_and_contexts = objects.map do |object|
+        context = context_for(object, attribute)
+
+        string = object.__send__(attribute)
 
-      string = object.__send__(attribute)
-      html = Banzai.render(string, context)
+        { text: string, context: context }
+      end
 
-      Banzai::Pipeline[:relative_link].to_document(html, context)
+      Banzai.cache_collection_render(strings_and_contexts).each_with_index.map do |html, index|
+        Banzai::Pipeline[:relative_link].to_document(html, strings_and_contexts[index][:context])
+      end
     end
 
     def base_context
diff --git a/lib/banzai/renderer.rb b/lib/banzai/renderer.rb
index 6718acdef7e..ea10b06439b 100644
--- a/lib/banzai/renderer.rb
+++ b/lib/banzai/renderer.rb
@@ -10,7 +10,7 @@ module Banzai
     # requiring XHTML, such as Atom feeds, need to call `post_process` on the
     # result, providing the appropriate `pipeline` option.
     #
-    # markdown - Markdown String
+    # text     - Markdown String
     # context  - Hash of context options passed to our HTML Pipeline
     #
     # Returns an HTML-safe String
@@ -29,6 +29,52 @@ module Banzai
       end
     end
 
+    # Perform multiple render from an Array of Markdown String into an
+    # Array of HTML-safe String of HTML.
+    #
+    # As the rendered Markdown String can be already cached read all the data
+    # from the cache using Rails.cache.read_multi operation. If the Markdown String
+    # is not in the cache or it's not cacheable (no cache_key entry is provided in
+    # the context) the Markdown String is rendered and stored in the cache so the
+    # next render call gets the rendered HTML-safe String from the cache.
+    #
+    # For further explanation see #render method comments.
+    #
+    # texts_and_contexts - An Array of Hashes that contains the Markdown String (:text)
+    #                      an options passed to our HTML Pipeline (:context)
+    #
+    # If on the :context you specify a :cache_key entry will be used to retrieve it
+    # and cache the result of rendering the Markdown String.
+    #
+    # Returns an Array containing HTML-safe String instances.
+    #
+    # Example:
+    #    texts_and_contexts
+    #    => [{ text: '### Hello',
+    #          context: { cache_key: [note, :note] } }]
+    def self.cache_collection_render(texts_and_contexts)
+      items_collection = texts_and_contexts.each_with_index do |item, index|
+        context = item[:context]
+        cache_key = full_cache_multi_key(context.delete(:cache_key), context[:pipeline])
+
+        item[:cache_key] = cache_key if cache_key
+      end
+
+      cacheable_items, non_cacheable_items = items_collection.partition { |item| item.key?(:cache_key) }
+      items_in_cache = Rails.cache.read_multi(*cacheable_items.map { |item| item[:cache_key] })
+      items_not_in_cache = cacheable_items.reject do |item|
+        item[:rendered] = items_in_cache[item[:cache_key]]
+        items_in_cache.key?(item[:cache_key])
+      end
+
+      (items_not_in_cache + non_cacheable_items).each do |item|
+        item[:rendered] = render(item[:text], item[:context])
+        Rails.cache.write(item[:cache_key], item[:rendered]) if item[:cache_key]
+      end
+
+      items_collection.map { |item| item[:rendered] }
+    end
+
     def self.render_result(text, context = {})
       text = Pipeline[:pre_process].to_html(text, context) if text
 
@@ -78,5 +124,13 @@ module Banzai
       return unless cache_key
       ["banzai", *cache_key, pipeline_name || :full]
     end
+
+    # To map Rails.cache.read_multi results we need to know the Rails.cache.expanded_key.
+    # Other option will be to generate stringified keys on our side and don't delegate to Rails.cache.expanded_key
+    # method.
+    def self.full_cache_multi_key(cache_key, pipeline_name)
+      return unless cache_key
+      Rails.cache.send(:expanded_key, full_cache_key(cache_key, pipeline_name))
+    end
   end
 end