Class: MetaTags::Renderer

Inherits:
Object show all
Defined in:
lib/meta_tags/renderer.rb,
sig/lib/meta_tags/renderer.rbs

Overview

This class is used by MetaTags gems to render HTML meta tags into page.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(meta_tags) ⇒ Renderer

Initialized a new instance of Renderer.

Parameters:



12
13
14
15
 
# File 'lib/meta_tags/renderer.rb', line 12

def initialize(meta_tags)
  @meta_tags = meta_tags
  @normalized_meta_tags = {}
end

Instance Attribute Details

#meta_tags ⇒ MetaTagsCollection (readonly)

Returns the value of attribute meta_tags.

Returns:



6
7
8
 
# File 'lib/meta_tags/renderer.rb', line 6

def meta_tags
  @meta_tags
end

#normalized_meta_tags ⇒ Hash[Symbol, meta_value] (readonly)

Returns the value of attribute normalized_meta_tags.

Returns:

  • (Hash[Symbol, meta_value]) 


6
7
8
 
# File 'lib/meta_tags/renderer.rb', line 6

def normalized_meta_tags
  @normalized_meta_tags
end

Instance Method Details

#configured_name_key(name) ⇒ Symbol

Returns meta tag property name for a give meta tag based on the configured list of property tags in MetaTags::Configuration#property_tags.

Parameters:

  • name (String, Symbol) —

    tag key.

Returns:

  • (Symbol) —

    meta tag attribute name (:property or :name).



289
290
291
292
293
294
 
# File 'lib/meta_tags/renderer.rb', line 289

def configured_name_key(name)
  is_property_tag = MetaTags.config.property_tags.any? do |tag_name|
    name.to_s.match(/^#{Regexp.escape(tag_name.to_s)}\b/)
  end
  is_property_tag ? :property : :name
end

#process_array(tags, property, content, **opts) ⇒ void

This method returns an undefined value.

Recursive method to process a hash with meta tags

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • property (String, Symbol) —

    a Hash or a String to render as meta tag.

  • content (Array) —

    array of nested meta tag attributes or values.

  • opts (Object) 


266
267
268
 
# File 'lib/meta_tags/renderer.rb', line 266

def process_array(tags, property, content, **opts)
  content.each { |v| process_tree(tags, property, v, **opts) }
end

#process_hash(tags, property, content, **opts) ⇒ void

This method returns an undefined value.

Recursive method to process a hash with meta tags

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • property (String, Symbol) —

    a Hash or a String to render as meta tag.

  • content (Hash) —

    nested meta tag attributes.

  • opts (Object) 


241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
 
# File 'lib/meta_tags/renderer.rb', line 241

def process_hash(tags, property, content, **opts)
  itemprop = content.delete(:itemprop)
  content.each do |key, value|
    if key.to_s == "_"
      iprop = itemprop
      key = property
    else
      key = "#{property}:#{key}"
    end

    normalized_value = if value.is_a?(Symbol)
      normalized_meta_tags[value]
    else
      value
    end
    process_tree(tags, key, normalized_value, **opts.merge(itemprop: iprop))
  end
end

#process_tree(tags, property, content, itemprop: nil, **opts) ⇒ void

This method returns an undefined value.

Recursive method to process all the hashes and arrays on meta tags

top-level meta tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • property (String, Symbol) —

    a Hash or a String to render as meta tag.

  • content (Hash, Array, String, Symbol) —

    text content or a symbol reference to

  • itemprop: (meta_key? itemprop) (defaults to: nil)
  • opts (Object) 


222
223
224
225
226
227
228
229
230
231
232
233
 
# File 'lib/meta_tags/renderer.rb', line 222

def process_tree(tags, property, content, itemprop: nil, **opts)
  method = case content
  when Hash
    :process_hash
  when Array
    :process_array
  else
    iprop = itemprop
    :render_tag
  end
  __send__(method, tags, property, content, itemprop: iprop, **opts)
end

#render(view) ⇒ String

Renders meta tags on the page.

Parameters:

  • view (ActionView::Base) —

    Rails view object.

Returns:

  • (String) 


20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/meta_tags/renderer.rb', line 20

def render(view)
  tags = [] # : Array[Tag]

  render_charset(tags)
  render_title(tags)
  render_icon(tags)
  render_with_normalization(tags, :description)
  render_with_normalization(tags, :keywords)
  render_refresh(tags)
  render_canonical_link(tags)
  render_noindex(tags)
  render_alternate(tags)
  render_open_search(tags)
  render_links(tags)

  render_hashes(tags)
  render_custom(tags)

  rendered_tags = tags.tap(&:compact!).map { |tag| tag.render(view) }
  view.safe_join rendered_tags, MetaTags.config.minify_output ? "" : "\n"
end

#render_alternate(tags) ⇒ void

This method returns an undefined value.

Renders alternate link tags.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/meta_tags/renderer.rb', line 123

def render_alternate(tags)
  alternate = meta_tags.extract(:alternate)
  return unless alternate

  if alternate.is_a?(Hash)
    alternate.each do |hreflang, href|
      tags << Tag.new(:link, rel: "alternate", href: href, hreflang: hreflang) if href.present?
    end
  elsif alternate.is_a?(Array)
    alternate.each do |link_params|
      tags << Tag.new(:link, {rel: "alternate"}.with_indifferent_access.merge(link_params))
    end
  end
end

#render_canonical_link(tags) ⇒ void

This method returns an undefined value.

Renders canonical link

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



171
172
173
174
175
176
177
178
 
# File 'lib/meta_tags/renderer.rb', line 171

def render_canonical_link(tags)
  href = meta_tags.extract(:canonical) # extract, so its not used anywhere else
  return if MetaTags.config.skip_canonical_links_on_noindex && meta_tags[:noindex]
  return if href.blank?

  @normalized_meta_tags[:canonical] = href
  tags << Tag.new(:link, rel: :canonical, href: href)
end

#render_charset(tags) ⇒ void

This method returns an undefined value.

Renders charset tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



48
49
50
51
 
# File 'lib/meta_tags/renderer.rb', line 48

def render_charset(tags)
  charset = meta_tags.extract(:charset)
  tags << Tag.new(:meta, charset: charset) if charset.present?
end

#render_custom(tags) ⇒ void

This method returns an undefined value.

Renders custom meta tags.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



206
207
208
209
210
211
212
213
 
# File 'lib/meta_tags/renderer.rb', line 206

def render_custom(tags)
  meta_tags.meta_tags.each do |name, data|
    Array(data).each do |val|
      tags << Tag.new(:meta, configured_name_key(name) => name, :content => val)
    end
    meta_tags.extract(name)
  end
end

#render_hash(tags, key, **opts) ⇒ void

This method returns an undefined value.

Renders a complex hash object by key.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • key (Object)
  • opts (Object) 


194
195
196
197
198
199
200
 
# File 'lib/meta_tags/renderer.rb', line 194

def render_hash(tags, key, **opts)
  data = meta_tags.meta_tags[key]
  return unless data.is_a?(Hash)

  process_hash(tags, key, data, **opts)
  meta_tags.extract(key)
end

#render_hashes(tags, **opts) ⇒ void

This method returns an undefined value.

Renders complex hash objects.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • opts (Object) 


184
185
186
187
188
 
# File 'lib/meta_tags/renderer.rb', line 184

def render_hashes(tags, **opts)
  meta_tags.meta_tags.each_key do |property|
    render_hash(tags, property, **opts)
  end
end

#render_icon(tags) ⇒ void

This method returns an undefined value.

Renders icon(s) tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/meta_tags/renderer.rb', line 73

def render_icon(tags)
  icon = meta_tags.extract(:icon)
  return unless icon

  # String? Value is an href
  icon = [{href: icon}] if icon.is_a?(String)
  # Hash? Single icon instead of a list of icons
  icon = [icon] if icon.is_a?(Hash)

  icon.each do |icon_params|
    icon_params = {rel: "icon", type: "image/x-icon"}.with_indifferent_access.merge(icon_params)
    tags << Tag.new(:link, icon_params)
  end
end

#render_links(tags) ⇒ void

This method returns an undefined value.

Renders links.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



157
158
159
160
161
162
163
164
165
 
# File 'lib/meta_tags/renderer.rb', line 157

def render_links(tags)
  [:amphtml, :prev, :next, :image_src, :manifest].each do |tag_name|
    href = meta_tags.extract(tag_name)
    if href.present?
      @normalized_meta_tags[tag_name] = href
      tags << Tag.new(:link, rel: tag_name, href: href)
    end
  end
end

#render_noindex(tags) ⇒ void

This method returns an undefined value.

Renders noindex and nofollow meta tags.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



104
105
106
107
108
 
# File 'lib/meta_tags/renderer.rb', line 104

def render_noindex(tags)
  meta_tags.extract_robots.each do |name, content|
    tags << Tag.new(:meta, name: name, content: content) if content.present?
  end
end

#render_open_search(tags) ⇒ void

This method returns an undefined value.

Renders open_search link tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



142
143
144
145
146
147
148
149
150
151
 
# File 'lib/meta_tags/renderer.rb', line 142

def render_open_search(tags)
  open_search = meta_tags.extract(:open_search)
  return unless open_search

  href = open_search[:href]
  title = open_search[:title]

  type = "application/opensearchdescription+xml"
  tags << Tag.new(:link, rel: "search", type: type, href: href, title: title) if href.present?
end

#render_refresh(tags) ⇒ void

This method returns an undefined value.

Renders refresh meta tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



114
115
116
117
 
# File 'lib/meta_tags/renderer.rb', line 114

def render_refresh(tags)
  refresh = meta_tags.extract(:refresh)
  tags << Tag.new(:meta, "http-equiv" => "refresh", :content => refresh.to_s) if refresh.present?
end

#render_tag(tags, name, value, itemprop: nil) ⇒ void

This method returns an undefined value.

Recursive method to process a hash with meta tags

top-level meta tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • name (String, Symbol) —

    a Hash or a String to render as meta tag.

  • value (String, Symbol) —

    text content or a symbol reference to

  • itemprop (String, Symbol) (defaults to: nil) —

    value of the itemprop attribute.

  • itemprop: (meta_key? itemprop) (defaults to: nil) 


278
279
280
281
 
# File 'lib/meta_tags/renderer.rb', line 278

def render_tag(tags, name, value, itemprop: nil)
  name_key ||= configured_name_key(name)
  tags << Tag.new(:meta, name_key => name.to_s, :content => value, :itemprop => itemprop) if value.present?
end

#render_title(tags) ⇒ void

This method returns an undefined value.

Renders title tag.

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/meta_tags/renderer.rb', line 57

def render_title(tags)
  normalized_meta_tags[:title] = meta_tags.page_title
  normalized_meta_tags[:site] = meta_tags[:site]
  title = meta_tags.extract_full_title
  normalized_meta_tags[:full_title] = title
  default_attributes = MetaTags.config.title_tag_attributes || {}

  if title.present?
    tags << ContentTag.new(:title, {content: title}.with_defaults(default_attributes))
  end
end

#render_with_normalization(tags, name) ⇒ void

This method returns an undefined value.

Renders meta tag with normalization (should have a corresponding normalize_ method in TextNormalizer).

Parameters:

  • tags (Array<Tag>) —

    a buffer object to store tag in.

  • name (Symbol)

See Also:



94
95
96
97
98
 
# File 'lib/meta_tags/renderer.rb', line 94

def render_with_normalization(tags, name)
  value = TextNormalizer.public_send(:"normalize_#{name}", meta_tags.extract(name))
  normalized_meta_tags[name] = value
  tags << Tag.new(:meta, name: name, content: value) if value.present?
end