metanol 0.0.4 → 0.0.9

data/lib/metanol/engine_controller.rb

@@ -1,114 +1,88 @@
-require File.join(File.dirname(__FILE__), 'meta/base')
-require File.join(File.dirname(__FILE__), 'meta/main')
-require File.join(File.dirname(__FILE__), 'meta/open_graph')
-require File.join(File.dirname(__FILE__), 'meta/webmaster')
 require 'active_support/dependencies'
 
 module Metanol
-
   # Engine's controller which has all methods for storing and processing meta tag's data
   module EngineController
     extend ActiveSupport::Concern
 
-    module ClassMethods
-      def metanol_options
-        @@metanol_options ||= {}
-      end
-
-      def meta(*args)
-        add_meta_tag(:main, *args)
-      end
-
-      def og_meta(*args)
-        add_meta_tag(:og, *args)
-      end
-
-      def wm_meta(*args)
-        add_meta_tag(:wm, *args)
-      end
+    included do
+      before_action :clear_metanols
+    end
 
-      def get_meta(name)
-        get_meta_by_type(:main, name)
+    module ClassMethods
+      def common_metanols
+        @@common_metanols ||= {}
       end
 
-      def get_og_meta(name)
-        get_meta_by_type(:og, name)
-      end
+      SUPPORT_GROUPS.keys.each do |method|
+        method_name = "#{method == :main ? '' : "#{method}_"}meta"
+        define_method method_name do |*args|
+          add_meta_tag(common_metanols, method, *args)
+        end
 
-      def get_wm_meta(name)
-        get_meta_by_type(:wm, name)
+        get_method_name = "get_#{method_name}"
+        define_method get_method_name do |name|
+          get_meta_tag(common_metanols, method, name)
+        end
       end
 
       private
 
-      def add_meta_tag(type, *args)
+      def add_meta_tag(repo, type, *args)
         if args[0].is_a? Hash
           filters = args[1..-1]
           args[0].each do |name, value|
-            add_meta_by_type type, name, value, filters
+            add_meta_by_type repo, type, name, value, filters
           end
         else
           name = args[0].to_sym
           value = args[1]
           filters = args[2..-1]
-          add_meta_by_type type, name, value, filters
+          add_meta_by_type repo, type, name, value, filters
         end
       end
 
-      def add_meta_by_type(type, name, value, filters=[])
-        data = meta_data(name)[type]
-        key = data[:key]
-        if metanol_options.key? key
-          metanol_options[key].value = value
-          metanol_options[key].filters = filters
-        else
-          metanol_options[key] = data[:type].new(name, value, filters)
+      def add_meta_by_type(repo, type, name, value, filters = [])
+        meta_class = SUPPORT_GROUPS[type]
+        key = get_meta_key(type, name)
+        unless repo.key? key
+          repo[key] = meta_class.new(name, value, filters)
+          return
         end
+        repo[key].value = value
+        repo[key].filters = filters
       end
 
-      def get_meta_by_type(type, name)
-        data = meta_data(name)[type]
-        key = data[:key]
-        metanol_options.key?(key) ? metanol_options[key].value : nil
+      def get_meta_tag(repo, type, name)
+        key = get_meta_key(type, name)
+        repo.key?(key) ? repo[key].value : nil
       end
 
-      def meta_data(name)
-        {
-            main: { key: name, type: Meta::Main },
-            og: { key: "og:#{name}", type: Meta::OpenGraph },
-            wm: { key: "wm:#{name}", type: Meta::Webmaster }
-        }
+      def get_meta_key(type, name)
+        "#{type}:#{name}"
       end
     end
 
-    def meta(*args)
-      self.class.meta(*args)
-    end
-
-    def og_meta(*args)
-      self.class.og_meta(*args)
-    end
-
-    def wm_meta(*args)
-      self.class.wm_meta(*args)
-    end
+    SUPPORT_GROUPS.keys.each do |method|
+      method_name = "#{method == :main ? '' : "#{method}_"}meta"
+      define_method method_name do |*args|
+        self.class.send 'add_meta_tag', action_metanols, method, *args
+      end
 
-    def metanol_options
-      self.class.metanol_options
+      get_method_name = "get_#{method_name}"
+      define_method get_method_name do |name|
+        self.class.send 'get_meta_tag', action_metanols, method, name
+      end
     end
 
-    def get_meta(name)
-      self.class.get_meta name
+    def action_metanols
+      @action_metanols ||= {}
     end
 
-    def get_og_meta(name)
-      self.class.get_og_meta name
-    end
+    private
 
-    def get_wm_meta(name)
-      self.class.get_wm_meta name
+    def clear_metanols
+      @action_metanols = {}
     end
-
   end
-
-end
+end

data/lib/metanol/helpers.rb

@@ -1,29 +1,34 @@
 module Metanol
   module Helpers
-
     # Render all meta tags
     def metanol_tags
-      result = metanol_main_tags
-      result << metanol_og_tags
-      result << metanol_wm_tags
-      result
+      result = ''
+      SUPPORT_GROUPS.keys.each do |type|
+        result << send("metanol_#{type}_tags")
+      end
+      result.html_safe
     end
 
     # Render OpenGraph meta tags
     def metanol_og_tags
       result = metanol_render_tags ::Metanol::Meta::OpenGraph
-      result << ::Metanol::Meta::OpenGraph.render_current_url(current_url).html_safe
-      result
+      result << ::Metanol::Meta::OpenGraph.render_current_url(current_url)
+      result.html_safe
     end
 
-    # Render Webmaster verification tags
-    def metanol_wm_tags
-      metanol_render_tags ::Metanol::Meta::Webmaster
-    end
+    SUPPORT_GROUPS.keys.each do |method|
+      get_method_name = "get_#{method == :main ? '' : "#{method}_"}meta"
+      define_method get_method_name do |name|
+        controller.__send__(get_method_name, name)
+      end
 
-    # Render main tags, such as keywords, description, etc.
-    def metanol_main_tags
-      metanol_render_tags ::Metanol::Meta::Main
+      next if method == :og
+
+      method_name = "metanol_#{method}_tags"
+      class_type = SUPPORT_GROUPS[method]
+      define_method method_name do
+        metanol_render_tags(class_type).html_safe
+      end
     end
 
     # Return a current URL
@@ -31,28 +36,17 @@ module Metanol
       request.original_url
     end
 
-    def get_meta(name)
-      self.controller.get_meta(name)
-    end
-
-    def get_og_meta(name)
-      self.controller.get_og_meta(name)
-    end
-
-    def get_wm_meta(name)
-      self.controller.get_wm_meta(name)
-    end
-
     private
 
     def metanol_render_tags(type)
-      result = ""
-      self.controller.metanol_options.each_value do |value|
+      result = ''
+      metanols = controller.class.common_metanols.merge(controller.action_metanols)
+      metanols.each_value do |value|
         next unless value.is_a? type
+
         result << value.render
       end
-      result.html_safe
+      result
     end
-
   end
-end
+end

data/lib/metanol/meta/base.rb

@@ -1,75 +1,100 @@
-module Metanol::Meta
+# frozen_string_literal: true
 
-  class Base
-    attr_reader :name
-    attr_accessor :value
+module Metanol
+  module Meta
+    class Base
+      ERR_FILTERS_WRONG_TYPE = 'The <filters> parameter must be an Array.'
+      ERR_FILTERS_WRONG_VALUE_TYPE =
+        'The <filters> parameter must include only string or symbol values.'
+      SUPPORTED_FILTERS = %i[html overspaces whitespaces clean].freeze
 
-    SUPPORTED_FILTERS = [:html, :overspaces, :whitespaces, :clean]
+      attr_writer :value
+      attr_reader :name
 
-    def initialize(name, value, filters=[])
-      raise NameError.new "The meta tag '#{name}' isn't supported.", name unless valid?(name)
-      @name = name
-      @value = value
-      self.filters = filters
-    end
+      def initialize(name, value, filters = [])
+        @name = name.to_sym
+        raise(NameError.new("The meta tag '#{@name}' isn't supported.", @name)) unless valid?(@name)
 
-    def filters=(value)
-      @filters = validate_filters(value)
-    end
+        @value = value
+        self.filters = filters
+      end
 
-    def render
-      raise StandardError.new "Please override this method in a child class"
-    end
+      def filters=(value)
+        @filters = validate_filters(value)
+      end
 
-    def self.filter_html(text)
-      text = text.gsub(/\<br\/?\>/, ' ')
-      text.gsub(/\<\/?\w+\/?\>/, '')
-    end
+      def render
+        result = value
+        return '' if result.blank?
 
-    def self.filter_overspaces(text)
-      text.gsub(/[\ ]{2,}/, ' ')
-    end
+        "<meta #{attr_name}=\"#{name}\" #{attr_value}=\"#{result}\" />"
+      end
 
-    def self.filter_whitespaces(text)
-      text.gsub(/\s/, ' ')
-    end
+      def value
+        result = @value
+        return result if @filters.blank?
 
-    protected
+        filter_overspaces(filter_whitespaces(filter_html_tags(result)))
+      end
 
-    def valid?(name)
-      true
-    end
+      def self.filter_html(text)
+        text = text.gsub(%r{<br/?>}, ' ')
+        text.gsub(%r{</?\w+/?>}, '')
+      end
 
-    def filtered_value
-      result = @value
-      return result unless filters?
-      result = self.class.filter_html(result) if @filters.include?(:html) || @filters.include?(:clean)
-      result = self.class.filter_whitespaces(result) if @filters.include?(:whitespaces) || @filters.include?(:clean)
-      result = self.class.filter_overspaces(result) if @filters.include?(:overspaces) || @filters.include?(:clean)
-      result
-    end
+      def self.filter_overspaces(text)
+        text.gsub(/\ {2,}/, ' ')
+      end
 
-    def filters?
-      @filters && !@filters.empty?
-    end
+      def self.filter_whitespaces(text)
+        text.gsub(/\s/, ' ')
+      end
+
+      private
 
-    private
+      def valid?(_name)
+        true
+      end
+
+      def attr_name
+        'name'
+      end
+
+      def attr_value
+        'content'
+      end
 
-    def validate_filters(filters=[])
-      result = []
-      raise StandardError.new("The filters parameter must be an Array.") unless filters.is_a?(Array)
-      begin
-        filters.each do |filter|
-          filter_value = filter.to_sym
-          StandardError.new("Only #{SUPPORTED_FILTERS.join(', ')} filters are supported.") unless SUPPORTED_FILTERS.include? filter_value
-          result << filter_value
+      def validate_filters(filters = [])
+        result = []
+        raise StandardError, ERR_FILTERS_WRONG_TYPE unless filters.is_a?(Array)
+
+        begin
+          filters.map(&:to_sym).each do |filter_value|
+            result << validate_filter(filter_value)
+          end
+        rescue NoMethodError
+          raise StandardError, ERR_FILTERS_WRONG_VALUE_TYPE
         end
-      rescue NoMethodError
-        raise StandardError.new("The filters parameter must includes only string or symbol values.")
+        result
       end
-      result
-    end
 
-  end
+      def validate_filter(filter_value)
+        return filter_value if SUPPORTED_FILTERS.include? filter_value
 
-end
+        raise(StandardError, "Only #{SUPPORTED_FILTERS.join(', ')} filters are supported.")
+      end
+
+      def filter_html_tags(result)
+        (@filters & %i[html clean]).presence ? self.class.filter_html(result) : result
+      end
+
+      def filter_whitespaces(result)
+        (@filters & %i[whitespaces clean]).presence ? self.class.filter_whitespaces(result) : result
+      end
+
+      def filter_overspaces(result)
+        (@filters & %i[overspaces clean]).presence ? self.class.filter_overspaces(result) : result
+      end
+    end
+  end
+end

data/lib/metanol/meta/main.rb

@@ -1,10 +1,13 @@
-module Metanol::Meta
+# frozen_string_literal: true
 
-  class Main < Base
-    def render
-      return "<title>#{filtered_value}</title>" if @name == :title
-      "<meta name=\"#{@name}\" content=\"#{filtered_value}\" />"
+module Metanol
+  module Meta
+    class Main < Base
+      def render
+        return (value.present? ? "<title>#{value}</title>" : '') if @name == :title
+
+        super
+      end
     end
   end
-
-end
+end

data/lib/metanol/meta/micro_data.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Metanol
+  module Meta
+    class MicroData < Base
+      protected
+
+      def attr_name
+        'itemprop'
+      end
+    end
+  end
+end

data/lib/metanol/meta/open_graph.rb

@@ -1,13 +1,23 @@
-module Metanol::Meta
+# frozen_string_literal: true
 
-  class OpenGraph < Base
-    def render
-      "<meta property=\"og:#{@name}\" content=\"#{filtered_value}\" />"
-    end
+module Metanol
+  module Meta
+    class OpenGraph < Base
+      def self.render_current_url(url)
+        return '' if url.blank?
+
+        "<meta property=\"og:url\" content=\"#{url}\" />"
+      end
+
+      def name
+        "og:#{@name}"
+      end
 
-    def self.render_current_url(url)
-      "<meta property=\"og:url\" content=\"#{url}\" />"
+      protected
+
+      def attr_name
+        'property'
+      end
     end
   end
-
-end
+end

data/lib/metanol/meta/webmaster.rb

@@ -1,22 +1,24 @@
-module Metanol::Meta
-  class Webmaster < Base
+# frozen_string_literal: true
 
-    SUPPORT_TAGS = {
-        yandex: 'yandex-verification',
-        google: 'google-site-verification',
+module Metanol
+  module Meta
+    class Webmaster < Base
+      SUPPORT_TAGS = {
         bing: 'msvalidate.01',
-        alexa: 'alexaVerifyID'
-    }
+        alexa: 'alexaVerifyID',
+        yandex: 'yandex-verification',
+        google: 'google-site-verification'
+      }.freeze
 
-    def render
-      "<meta name=\"#{SUPPORT_TAGS[@name]}\" content=\"#{filtered_value}\" />"
-    end
+      def name
+        SUPPORT_TAGS[@name]
+      end
 
-    protected
+      protected
 
-    def valid?(name)
-      !SUPPORT_TAGS[name.to_sym].nil?
+      def valid?(name)
+        SUPPORT_TAGS[name].present?
+      end
     end
-
   end
-end
+end

data/lib/metanol/railtie.rb

@@ -1,8 +1,8 @@
 module Metanol
-  class Railtie < ::Rails::Railtie #:nodoc:
-    initializer 'metanolize' do |app|
-      ::ActionView::Base.send :include, Metanol::Helpers
-      ::ActionController::Base.send :include, Metanol::EngineController
+  class Railtie < ::Rails::Railtie # :nodoc:
+    initializer 'metanolize' do |_app|
+      ::ActionView::Base.include Metanol::Helpers
+      ::ActionController::Base.include Metanol::EngineController
     end
   end
-end
+end

data/lib/metanol/support.rb

@@ -0,0 +1,8 @@
+module Metanol
+  SUPPORT_GROUPS = {
+    main: Meta::Main,
+    og: Meta::OpenGraph,
+    wm: Meta::Webmaster,
+    md: Meta::MicroData
+  }.freeze
+end

data/lib/metanol/version.rb

@@ -1,3 +1,3 @@
 module Metanol
-  VERSION = "0.0.4"
+  VERSION = '0.0.9'.freeze
 end

data/lib/metanol.rb

@@ -2,6 +2,13 @@ require 'metanol/version'
 
 require 'rails'
 
+require 'metanol/meta/base'
+require 'metanol/meta/main'
+require 'metanol/meta/open_graph'
+require 'metanol/meta/webmaster'
+require 'metanol/meta/micro_data'
+
+require 'metanol/support'
 require 'metanol/helpers'
 require 'metanol/engine_controller'
 require 'metanol/railtie'

data/metanol.gemspec

@@ -1,26 +1,44 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'metanol/version'
 
-Gem::Specification.new do |gem|
-  gem.name          = "metanol"
-  gem.version       = Metanol::VERSION
-  gem.platform        = Gem::Platform::RUBY
-  gem.authors       = ["Eugene Kondratyuk"]
-  gem.email         = ["ekondr@gmail.com"]
-  gem.description   = %q{This is a meta tags plugin which helps to manage meta tags in your Rails application. It supports some OpenGraph meta tags, Webmaster's meta tags (such as Google, Bing, Yandex, Alexa verification meta tags) and other standard HTML meta tags (such as a description). It can be used by Rails 3.2+ applications}
-  gem.summary       = %q{A meta tags engine plugin for Rails 3.2+ applications}
-  gem.homepage      = "https://github.com/ekondr/metanol"
+Gem::Specification.new do |spec|
+  spec.name = 'metanol'
+  spec.version = Metanol::VERSION
+  spec.authors = ['Yevhen Kondratiuk']
+  spec.email = ['ekondr@gmail.com']
 
-  gem.rubyforge_project = 'metanol'
+  spec.summary = '<META> tags engine plugin for Ruby on Rails applications'
+  spec.description = 'This is a meta tags plugin which helps to manage meta tags in '\
+                     'your Rails application. It supports some OpenGraph meta tags, '\
+                     "Webmaster's meta tags (such as Google, Bing, Yandex, Alexa "\
+                     'verification tags), MicroData meta tags and other standard '\
+                     'HTML meta tags (such as a <description>, <title> etc). It can be used by '\
+                     'Rails 3.2+ applications.'
+  spec.homepage = 'https://github.com/ekondr/metanol'
+  spec.license = 'MIT'
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  spec.respond_to?(:metadata) ||
+    raise('RubyGems 2.0 or newer is required to protect against public gem pushes.')
 
-  gem.licenses = ['MIT']
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = 'bin'
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.3'
 
-  gem.add_dependency "rails", "~> 3.2"
+  spec.add_dependency 'rails', '>= 6.0'
+  spec.add_development_dependency 'capybara', '>= 0'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rspec', '>= 3.0'
+  spec.add_development_dependency 'rspec-rails', '>= 5.0'
+  spec.add_development_dependency 'sqlite3', '>= 0'
 end