Module: Banzai::Renderer
- Defined in:
- lib/banzai/renderer.rb
Class Method Summary collapse
-
.cache_collection_render(texts_and_contexts) ⇒ Object
Perform multiple render from an Array of Markdown String into an Array of HTML-safe String of HTML.
- .cacheless_render(text, context = {}) ⇒ Object
-
.cacheless_render_field(object, field, context = {}) ⇒ Object
Same as
render_field
, but without consulting or updating the cache field. - .full_cache_key(cache_key, pipeline_name) ⇒ Object
-
.full_cache_multi_key(cache_key, pipeline_name) ⇒ Object
To map Rails.cache.read_multi results we need to know the Rails.cache.expanded_key.
-
.post_process(html, context) ⇒ Object
Perform post-processing on an HTML String.
-
.render(text, context = {}) ⇒ Object
Convert a Markdown String into an HTML-safe String of HTML.
-
.render_field(object, field, context = {}) ⇒ Object
Convert a Markdown-containing field on an object into an HTML-safe String of HTML.
- .render_result(text, context = {}) ⇒ Object
Class Method Details
.cache_collection_render(texts_and_contexts) ⇒ Object
Perform multiple render from an Array of Markdown String into an Array of HTML-safe String of HTML.
The redis cache is completely obviated if we receive a ‘:rendered` key in the context, as it is assumed the item has been pre-rendered somewhere else and there is no need to cache it.
If no ‘:rendered` key is present in the context, 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 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] } }]
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 |
# File 'lib/banzai/renderer.rb', line 81 def self.cache_collection_render(texts_and_contexts) items_collection = texts_and_contexts.each do |item| context = item[:context] if context.key?(:rendered) item[:rendered] = context.delete(:rendered) else # If the attribute didn't come in pre-rendered, let's prepare it for caching it in redis cache_key = full_cache_multi_key(context.delete(:cache_key), context[:pipeline]) item[:cache_key] = cache_key if cache_key end end cacheable_items, non_cacheable_items = items_collection.group_by do |item| if item.key?(:rendered) # We're not really doing anything here as these don't need any processing, but leaving it just in case # as they could have a cache_key and we don't want them to be re-rendered :rendered elsif item.key?(:cache_key) :cacheable else :non_cacheable end end.values_at(:cacheable, :non_cacheable) items_in_cache = [] items_not_in_cache = [] if cacheable_items.present? 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 end (items_not_in_cache + Array.wrap(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 |
.cacheless_render(text, context = {}) ⇒ Object
158 159 160 161 162 163 164 165 166 167 168 169 |
# File 'lib/banzai/renderer.rb', line 158 def self.cacheless_render(text, context = {}) return text.to_s unless text.present? result = render_result(text, context) output = result[:output] if output.respond_to?(:to_html) output.to_html else output.to_s end end |
.cacheless_render_field(object, field, context = {}) ⇒ Object
Same as render_field
, but without consulting or updating the cache field
46 47 48 49 50 51 |
# File 'lib/banzai/renderer.rb', line 46 def self.cacheless_render_field(object, field, context = {}) text = object.__send__(field) # rubocop:disable GitlabSecurity/PublicSend context = context.reverse_merge(object.banzai_render_context(field)) if object.respond_to?(:banzai_render_context) cacheless_render(text, context) end |
.full_cache_key(cache_key, pipeline_name) ⇒ Object
171 172 173 174 175 |
# File 'lib/banzai/renderer.rb', line 171 def self.full_cache_key(cache_key, pipeline_name) return unless cache_key ["banzai", *cache_key, pipeline_name || :full] end |
.full_cache_multi_key(cache_key, pipeline_name) ⇒ Object
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.
180 181 182 183 184 |
# File 'lib/banzai/renderer.rb', line 180 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)) # rubocop:disable GitlabSecurity/PublicSend end |
.post_process(html, context) ⇒ Object
Perform post-processing on an HTML String
This method is used to perform state-dependent changes to a String of HTML, such as removing references that the current user doesn’t have permission to make (‘ReferenceRedactorFilter`).
html - String to process context - Hash of options to customize output
:pipeline - Symbol pipeline type - for context transform only, defaults to :full
:project - Project
:user - User object
:post_process_pipeline - pipeline to use for post_processing - defaults to PostProcessPipeline
Returns an HTML-safe String
145 146 147 148 149 150 151 152 153 154 155 156 |
# File 'lib/banzai/renderer.rb', line 145 def self.post_process(html, context) context = Pipeline[context[:pipeline]].transform_context(context) # Use a passed class for the pipeline or default to PostProcessPipeline pipeline = context.delete(:post_process_pipeline) || ::Banzai::Pipeline::PostProcessPipeline if context[:xhtml] pipeline.to_document(html, context).to_html(save_with: Nokogiri::XML::Node::SaveOptions::AS_XHTML) else pipeline.to_html(html, context) end.html_safe end |
.render(text, context = {}) ⇒ Object
Convert a Markdown String into an HTML-safe String of HTML
Note that while the returned HTML will have been sanitized of dangerous HTML, it may post a risk of information leakage if it’s not also passed through ‘post_process`.
Also note that the returned String is always HTML, not XHTML. Views requiring XHTML, such as Atom feeds, need to call ‘post_process` on the result, providing the appropriate `pipeline` option.
text - Markdown String context - Hash of context options passed to our HTML Pipeline
Returns an HTML-safe String
19 20 21 22 23 24 25 26 27 28 29 30 |
# File 'lib/banzai/renderer.rb', line 19 def self.render(text, context = {}) cache_key = context.delete(:cache_key) cache_key = full_cache_key(cache_key, context[:pipeline]) if cache_key Rails.cache.fetch(cache_key) do cacheless_render(text, context) end else cacheless_render(text, context) end end |
.render_field(object, field, context = {}) ⇒ Object
Convert a Markdown-containing field on an object into an HTML-safe String of HTML. This method is analogous to calling render(object.field), but it can cache the rendered HTML in the object, rather than Redis.
35 36 37 38 39 40 41 42 43 |
# File 'lib/banzai/renderer.rb', line 35 def self.render_field(object, field, context = {}) unless object.respond_to?(:cached_markdown_fields) return cacheless_render_field(object, field, context) end object.refresh_markdown_cache! unless object.cached_html_up_to_date?(field) object.cached_html_for(field) end |