meta_tags-rails 1.0.0

data/Rakefile

@@ -0,0 +1,28 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task test: :spec
+task default: :spec
+
+desc 'Starts irb with MetaTags gem loaded'
+task :console do
+  require 'irb'
+
+  $:.unshift File.expand_path('../lib', __FILE__)
+  require 'meta_tags'
+  ARGV.clear
+  IRB.start
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new(:yard) do |t|
+  t.options = ['--title', 'MetaTags Documentation']
+  if ENV['PRIVATE']
+    t.options.concat ['--protected', '--private']
+  else
+    t.options.concat ['--protected', '--no-private']
+  end
+end

data/lib/meta_tags-rails.rb

@@ -0,0 +1,37 @@
+require 'action_controller'
+require 'action_view'
+
+# MetaTags gem namespace.
+module MetaTags
+  # Returns MetaTags gem configuration.
+  #
+  def self.config
+    @@config ||= Configuration.new
+  end
+
+  # Configures MetaTags gem.
+  #
+  # @yield [Configuration] configuration object.
+  # @example
+  #
+  #   MetaTags.configure do |config|
+  #     # config.title_limit = 100
+  #   end
+  def self.configure
+    yield config
+  end
+end
+
+require 'meta_tags-rails/version'
+
+require 'meta_tags-rails/configuration'
+require 'meta_tags-rails/controller_helper'
+require 'meta_tags-rails/meta_tags_collection'
+require 'meta_tags-rails/renderer'
+require 'meta_tags-rails/tag'
+require 'meta_tags-rails/content_tag'
+require 'meta_tags-rails/text_normalizer'
+require 'meta_tags-rails/view_helper'
+
+ActionView::Base.send :include, MetaTags::ViewHelper
+ActionController::Base.send :include, MetaTags::ControllerHelper

data/lib/meta_tags-rails/configuration.rb

@@ -0,0 +1,21 @@
+module MetaTags
+  # MetaTags configuration.
+  class Configuration
+    # How many characters to truncate title to.
+    attr_accessor :title_limit
+    # How many characters to truncate description to.
+    attr_accessor :description_limit
+    # How many characters to truncate keywords to.
+    attr_accessor :keywords_limit
+    # Keywords separator - a string to join keywords with.
+    attr_accessor :keywords_separator
+
+    # Initializes a new instance of Configuration class.
+    def initialize
+      @title_limit = 70
+      @description_limit = 160
+      @keywords_limit = 255
+      @keywords_separator = ', '
+    end
+  end
+end

data/lib/meta_tags-rails/content_tag.rb

@@ -0,0 +1,14 @@
+module MetaTags
+  # Represents an HTML meta tag with content (<tag></tag>).
+  # Content should be passed as a `:content` attribute.
+  class ContentTag < Tag
+    # Render tag into a Rails view.
+    #
+    # @param [ActionView::Base] view instance of a Rails view.
+    # @return [String] HTML string for the tag.
+    #
+    def render(view)
+      view.content_tag(name, attributes[:content], attributes.except(:content))
+    end
+  end
+end

data/lib/meta_tags-rails/controller_helper.rb

@@ -0,0 +1,44 @@
+module MetaTags
+  # Contains methods to use in controllers.
+  #
+  # You can define several instance variables to set meta tags:
+  #   @page_title = 'Member Login'
+  #   @page_description = 'Member login page.'
+  #   @page_keywords = 'Site, Login, Members'
+  #
+  # Also you can use {#set_meta_tags} method, that have the same parameters
+  # as {ViewHelper#set_meta_tags}.
+  #
+  module ControllerHelper
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :render, :meta_tags
+    end
+
+    # Processes the <tt>@page_title</tt>, <tt>@page_keywords</tt>, and
+    # <tt>@page_description</tt> instance variables and calls +render+.
+    def render_with_meta_tags(*args, &block)
+      self.meta_tags[:title]       = @page_title       if @page_title
+      self.meta_tags[:keywords]    = @page_keywords    if @page_keywords
+      self.meta_tags[:description] = @page_description if @page_description
+
+      render_without_meta_tags(*args, &block)
+    end
+    protected :render_with_meta_tags
+
+    # Set meta tags for the page.
+    #
+    # See <tt>MetaTags::ViewHelper#set_meta_tags</tt> for details.
+    def set_meta_tags(meta_tags)
+      self.meta_tags.update(meta_tags)
+    end
+    protected :set_meta_tags
+
+    # Get meta tags for the page.
+    def meta_tags
+      @meta_tags ||= MetaTagsCollection.new
+    end
+    protected :meta_tags
+  end
+end

data/lib/meta_tags-rails/meta_tags_collection.rb

@@ -0,0 +1,176 @@
+module MetaTags
+  # Class represents a collection of meta tags. Basically a wrapper around
+  # HashWithIndifferentAccess, with some additional helper methods.
+  class MetaTagsCollection
+    attr_reader :meta_tags
+
+    # Initializes a new instance of MetaTagsCollection.
+    #
+    def initialize
+      @meta_tags = HashWithIndifferentAccess.new
+    end
+
+    # Returns meta tag value by name.
+    #
+    # @param [String, Symbol] name meta tag name.
+    # @return meta tag value.
+    #
+    def [](name)
+      @meta_tags[name]
+    end
+
+    # Sets meta tag value by name.
+    #
+    # @param [String, Symbol] name meta tag name.
+    # @param value meta tag value.
+    # @return meta tag value.
+    #
+    def []=(name, value)
+      @meta_tags[name] = value
+    end
+
+    # Recursively merges a Hash of meta tag attributes into current list.
+    #
+    # @param [Hash] meta_tags meta tags Hash to merge into current list.
+    # @return [Hash] result of the merge.
+    #
+    def update(meta_tags = {})
+      @meta_tags.deep_merge! normalize_open_graph(meta_tags)
+    end
+
+    # Temporary merges defaults with current meta tags list and yields the block.
+    #
+    # @param [Hash] defaults list of default meta tag attributes.
+    # @return result of the block call.
+    #
+    def with_defaults(defaults = {})
+      old_meta_tags = @meta_tags
+      @meta_tags = normalize_open_graph(defaults).deep_merge!(self.meta_tags)
+      yield
+    ensure
+      @meta_tags = old_meta_tags
+    end
+
+    # Constructs the full title as if it would be rendered in title meta tag.
+    #
+    # @param [Hash] defaults list of default meta tag attributes.
+    # @return [String] page title.
+    #
+    def full_title(defaults = {})
+      with_defaults(defaults) { extract_full_title  }
+    end
+
+    # Deletes and returns a meta tag value by name.
+    #
+    # @param [String, Symbol] name meta tag name.
+    # @return [Object] meta tag value.
+    #
+    def extract(name)
+      @meta_tags.delete(name)
+    end
+
+    # Deletes specified meta tags.
+    #
+    # @param [Array<String, Symbol>] names a list of meta tags to delete.
+    #
+    def delete(*names)
+      names.each { |name| @meta_tags.delete(name) }
+    end
+
+    # Extracts full page title and deletes all related meta tags.
+    #
+    # @return [String] page title.
+    #
+    def extract_full_title
+      site_title = extract(:site) || ''
+      title      = extract_title || []
+      separator  = extract_separator
+      reverse    = extract(:reverse) === true
+
+      TextNormalizer.normalize_title(site_title, title, separator, reverse)
+    end
+
+    # Extracts page title as an array of segments without site title and separators.
+    #
+    # @return [Array<String>] segments of page title.
+    #
+    def extract_title
+      title = extract(:title).presence
+      return unless title
+
+      title = Array(title)
+      title.each(&:downcase!) if extract(:lowercase) === true
+      title
+    end
+
+    # Extracts title separator as a string.
+    #
+    # @return [String] page title separator.
+    #
+    def extract_separator
+      if meta_tags[:separator] === false
+        # Special case: if separator is hidden, do not display suffix/prefix
+        prefix = separator = suffix = ''
+      else
+        prefix    = extract_separator_section(:prefix, ' ')
+        separator = extract_separator_section(:separator, '|')
+        suffix    = extract_separator_section(:suffix, ' ')
+      end
+      delete(:separator, :prefix, :suffix)
+
+      TextNormalizer.safe_join([prefix, separator, suffix], '')
+    end
+
+    # Extracts noindex settings as a Hash mapping noindex tag name to value.
+    #
+    # @return [Hash<String,String>] noindex attributes.
+    #
+    def extract_noindex
+      noindex_name,  noindex_value  = extract_noindex_attribute(:noindex)
+      nofollow_name, nofollow_value = extract_noindex_attribute(:nofollow)
+
+      if noindex_name == nofollow_name
+        { noindex_name => [noindex_value, nofollow_value].compact.join(', ') }
+      else
+        { noindex_name => noindex_value, nofollow_name => nofollow_value }
+      end
+    end
+
+    protected
+
+    # Converts input hash to HashWithIndifferentAccess and renames :open_graph to :og.
+    #
+    # @param [Hash] meta_tags list of meta tags.
+    # @return [HashWithIndifferentAccess] normalized meta tags list.
+    #
+    def normalize_open_graph(meta_tags)
+      meta_tags = meta_tags.is_a?(HashWithIndifferentAccess) ? meta_tags.dup : meta_tags.with_indifferent_access
+      meta_tags[:og] = meta_tags.delete(:open_graph) if meta_tags.key?(:open_graph)
+      meta_tags
+    end
+
+    # Extracts separator segment without deleting it from meta tags list.
+    # If the value is false, empty string will be returned.
+    #
+    # @param [Symbol, String] name separator segment name.
+    # @param [String] default default value.
+    # @return [String] separator segment value.
+    #
+    def extract_separator_section(name, default)
+      meta_tags[name] === false ? '' : (meta_tags[name] || default)
+    end
+
+    # Extracts noindex attribute name and value without deleting it from meta tags list.
+    #
+    # @param [String, Symbol] name noindex attribute name.
+    # @return [Array<String>] pair of noindex attribute name and value.
+    #
+    def extract_noindex_attribute(name)
+      noindex       = extract(name)
+      noindex_name  = String === noindex ? noindex : 'robots'
+      noindex_value = noindex ? name.to_s : nil
+
+      [ noindex_name, noindex_value ]
+    end
+  end
+end

data/lib/meta_tags-rails/renderer.rb

@@ -0,0 +1,253 @@
+module MetaTags
+  # This class is used by MetaTags gems to render HTML meta tags into page.
+  class Renderer
+    attr_reader :meta_tags, :normalized_meta_tags
+
+    # Initialized a new instance of Renderer.
+    #
+    # @param [MetaTagsCollection] meta_tags meta tags object to render.
+    #
+    def initialize(meta_tags)
+      @meta_tags = meta_tags
+      @normalized_meta_tags = {}
+    end
+
+    # Renders meta tags on the page.
+    #
+    # @param [ActionView::Base] view Rails view object.
+    def render(view)
+      tags = []
+
+      render_charset(tags)
+      render_title(tags)
+      render_icon(tags)
+      render_with_normalization(tags, :description)
+      render_with_normalization(tags, :keywords)
+      render_refresh(tags)
+      render_noindex(tags)
+      render_alternate(tags)
+      render_open_search(tags)
+      render_links(tags)
+
+      render_hash(tags, :og, name_key: :property)
+      render_hashes(tags)
+      render_custom(tags)
+
+      tags.compact.map { |tag| tag.render(view) }.join("\n").html_safe
+    end
+
+    protected
+
+
+    # Renders charset tag.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_charset(tags)
+      if charset = meta_tags.extract(:charset)
+        tags << Tag.new(:meta, charset: charset) if charset.present?
+      end
+    end
+
+    # Renders title tag.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_title(tags)
+      title = meta_tags.extract_full_title
+      normalized_meta_tags[:title] = title
+      tags << ContentTag.new(:title, content: title) if title.present?
+    end
+
+    # Renders icon(s) tag.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_icon(tags)
+      if icon = meta_tags.extract(:icon)
+        if String === icon
+          tags << Tag.new(:link, rel: 'icon', href: icon, type: 'image/x-icon')
+        else
+          icon = [icon] if Hash === icon
+          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
+      end
+    end
+
+    # Renders meta tag with normalization (should have a corresponding normalize_
+    # method in TextNormalizer).
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    # @see TextNormalizer
+    #
+    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
+
+    # Renders noindex and nofollow meta tags.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_noindex(tags)
+      meta_tags.extract_noindex.each do |name, content|
+        tags << Tag.new(:meta, name: name, content: content) if content.present?
+      end
+    end
+
+    # Renders refresh meta tag.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_refresh(tags)
+      if refresh = meta_tags.extract(:refresh)
+        tags << Tag.new(:meta, 'http-equiv' => 'refresh', content: refresh.to_s) if refresh.present?
+      end
+    end
+
+    # Renders alternate link tags.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_alternate(tags)
+      if alternate = meta_tags.extract(:alternate)
+        if Hash === alternate
+          alternate.each do |hreflang, href|
+            tags << Tag.new(:link, rel: 'alternate', href: href, hreflang: hreflang) if href.present?
+          end
+        elsif Array === alternate
+          alternate.each do |link_params|
+            tags << Tag.new(:link, { rel: 'alternate' }.with_indifferent_access.merge(link_params))
+          end
+        end
+      end
+    end
+
+    # Renders open_search link tag.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_open_search(tags)
+      if open_search = meta_tags.extract(:open_search)
+        href = open_search[:href]
+        title = open_search[:title]
+        if href.present?
+          type = "application/opensearchdescription+xml"
+          tags << Tag.new(:link, rel: 'search', type: type, href: href, title: title)
+        end
+      end
+    end
+
+    # Renders links.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_links(tags)
+      [ :canonical, :prev, :next, :author, :publisher ].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
+
+    # Renders complex hash objects.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_hashes(tags, options = {})
+      meta_tags.meta_tags.each do |property, data|
+        if data.is_a?(Hash)
+          process_hash(tags, property, data, options)
+          meta_tags.extract(property)
+        end
+      end
+    end
+
+    # Renders a complex hash object by key.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_hash(tags, key, options = {})
+      data = meta_tags.meta_tags[key]
+      if data.is_a?(Hash)
+        process_hash(tags, key, data, options)
+        meta_tags.extract(key)
+      end
+    end
+
+    # Renders custom meta tags.
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    #
+    def render_custom(tags)
+      meta_tags.meta_tags.each do |name, data|
+        Array(data).each do |val|
+          tags << Tag.new(:meta, name: name, content: val)
+        end
+        meta_tags.extract(name)
+      end
+    end
+
+    # Recursive method to process all the hashes and arrays on meta tags
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    # @param [String, Symbol] property a Hash or a String to render as meta tag.
+    # @param [Hash, Array, String, Symbol] content text content or a symbol reference to
+    # top-level meta tag.
+    #
+    def process_tree(tags, property, content, options = {})
+      method = case content
+      when Hash
+        :process_hash
+      when Array
+        :process_array
+      else
+        :render_tag
+      end
+      send(method, tags, property, content, options)
+    end
+
+    # Recursive method to process a hash with meta tags
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    # @param [String, Symbol] property a Hash or a String to render as meta tag.
+    # @param [Hash] content nested meta tag attributes.
+    #
+    def process_hash(tags, property, content, options = {})
+      content.each do |key, value|
+        key = key.to_s == '_' ? property : "#{property}:#{key}"
+        value = normalized_meta_tags[value] if value.is_a?(Symbol)
+        process_tree(tags, key, value, options)
+      end
+    end
+
+    # Recursive method to process a hash with meta tags
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    # @param [String, Symbol] property a Hash or a String to render as meta tag.
+    # @param [Array] content array of nested meta tag attributes or values.
+    #
+    def process_array(tags, property, content, options = {})
+      content.each { |v| process_tree(tags, property, v, options) }
+    end
+
+    # Recursive method to process a hash with meta tags
+    #
+    # @param [Array<Tag>] tags a buffer object to store tag in.
+    # @param [String, Symbol] name a Hash or a String to render as meta tag.
+    # @param [String, Symbol] value text content or a symbol reference to
+    # top-level meta tag.
+    #
+    def render_tag(tags, name, value, options = {})
+      name_key = options.fetch(:name_key, :name)
+      value_key = options.fetch(:value_key, :content)
+      tags << Tag.new(:meta, name_key => name.to_s, value_key => value) unless value.blank?
+    end
+  end
+end