Module: Banzai::Renderer

Defined in:
lib/banzai/renderer.rb

Class Method Summary collapse

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 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] } }]



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

.render_result(text, context = {}) ⇒ Object 



125
126
127
128
129
 
# File 'lib/banzai/renderer.rb', line 125

def self.render_result(text, context = {})
  text = Pipeline[:pre_process].to_html(text, context) if text

  Pipeline[context[:pipeline]].call(text, context)
end