manage_meta 0.0.4

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,132 @@
+ManageMeta
+============
+
+ManageMeta is yet another meta tag manager for Rails 3.x. Its features are: recognizes tags
+should render as HTTP-EQUIV; supports the Google 'canonical' link; is extensible; is non-intrusive
+
+How it works
+-----------
+
+Include the gem by adding this to your Gemfile file
+
+`gem "manage_meta", :git => "git://github.com/mikehoward/manage_meta.git"`
+
+Then, in your controller actions, call _add_meta_ for each meta tag you want
+to define.
+
+`add_meta :author, 'Fred Fink'`
+
+If there are meta tags you don't want to define, you can use _del_meta_ to remove them.
+At present there are only two automatically defined: 'robots' and 'generator'. You may
+also redefine them by using _add_meta_ to give them new values.
+
+If there is a meta tag which requires a currently unsupported format, you may add it
+using _add_meta_format_.
+
+Finally, edit app/views/layouts/application.html.erb - or equivalent - to insert
+
+`<%= render_meta %>`
+
+into the _head_ section of your HTML output. This will render and return all of the
+defined meta tags.
+
+What it Adds
+------------
+
+ManageMeta defines four (4) methods and three (3) instance variables into all classes
+derived from ApplicationController
+
+The methods are:
+
+* add_meta - adds a meta tag
+* del_meta - which deletes a meta tag
+* add_meta_format - which adds a meta tag format
+* render_meta - which returns a string rendering all currently defined meta tags.
+
+The instance variables are:
+
+* @manage_meta_meta_hash - a Hash containing mapping defined meta tag names to content values
+* @manage_meta_format_hash - a Hash mapping known meta tag format strings to actual format strings
+* @manage_meta_name_to_format - a Hash mapping meta tag name strings to known formats
+
+The Details
+--------------
+
+Here are the ugly details
+
+### Methods in Detail ###
+
+#### add_meta ####
+
+_add_meta_ accepts values in any of three formats:
+
+`add_meta(name, value[, :format => :format_name])`
+`add_meta(name, value[, :format => :format_name]) do ... end`
+`add_meta(name[, :format => :format_name]) do ... end`
+
+* name must be something which responds to 'to_s'. It will be used for the _name_ (or _http-equiv_)
+attribute of the meta tag.
+* value must be something which responds to 'to_s' and is not a Hash. Normally it will simply
+be a string. If given, it supplies the leading part of the _content_ attribute of the meta tag
+* The single option :format must supply an existing key in @manage_meta_format_hash. It is
+used to associate a meta tag format with _name_. If not given and not currently defined in
+@manage_meta_format_hash, it will be set to _:named_. (see below for details)
+* The optional block is evaluated and the return value is used as the second [or only] part
+of the _content_ attribute of the meta tag.
+
+Three meta tag formats are defined automatically:
+
+* `:named => '<meta name="#{name}" content="#{content}" char-encoding="utf-8" />'`
+* `:http_equiv => '<meta http-equiv="#{name}" content="#{content}" char-encoding="utf-8" />'`
+* `:canonical => '<link rel="canonical" href="#{content}" />'`
+
+The _@manage_meta_name_to_format_ is populated with entries mapping known HTTP-EQUIV tags
+and the CANONICAL Google link tag to the correct format.
+
+#### del_meta ####
+
+_del_meta_ is almost useless. It's there in case you want to get ride of a default tag.
+
+`del_meta(name)`
+
+where _name_ is something which responds to 'to_s' [or is a string]. If the meta tag is
+defined in @manage_meta_meta_hash, then it will be deleted. Nothing bad happens if it isn't.
+
+#### add_meta_format_ ####
+
+`add_meta_format(format_name, format_string)`
+
+_format_name__ will be converted to a symbol.
+
+_format_string_ will be the value of @manage_meta_format_hash[_format_name.to_sym_].
+
+It's your responsibility to format the string properly.
+
+_render_meta_ will replace _name_ and _content_ with the string values given for the meta
+tag - if present. It is not an error to omit either or both _name_ and/or _content_
+
+#### render_meta ####
+
+`render_meta`
+
+simply goes through all the defined key, value pairs in @manage_meta_meta_hash and
+returns their associated format strings after replacing the _#{name}_ and _#{content}_
+symbols with their values.
+
+### Instance Variables in Detail ###
+
+#### manage_meta_format_hash ####
+
+keys are symbols,
+
+values are strings which are used to render meta tags
+
+####  manage_meta_meta_hash ####
+
+keys are strings which are used for the names of meta tags
+
+values are symbols which are keys in @manage_meta_format_hash
+
+#### manage_meta_name_to_format ####
+
+keys are strings which map meta tag names to keys in @manage_meta_format_hash

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+
+task :default => :test
+
+desc "Run ManageMeta unit tests"
+task :test do
+  require './test/manage_meta_test'
+end
+
+desc "run rdoc to create doc"
+task :doc do
+  system 'rdoc'
+end
+
+desc "build gem"
+task :gem do
+  system 'gem build manage_meta.gemspec'
+end

data/lib/manage_meta.rb

@@ -0,0 +1,7 @@
+require 'manage_meta/manage_meta'
+
+if defined? Rails
+  class ApplicationController < ActionController::Base
+    include ManageMeta
+  end
+end

data/lib/manage_meta/manage_meta.rb

@@ -0,0 +1,131 @@
+module ManageMeta
+  def self.included(mod)
+    # OK this is a hack based on section 25.4 of Programming Ruby 1.9 by Dave Thomas
+    # we are using the _included_ hook from Ruby's Module module to run some code
+    # which replaces the 'initialize' routine with one which creates our required instance
+    # data.
+    # 1. We are saving the original 'initialize' as old_initialize.
+    # 2. we execute the private method 'define_method' via mod.send which has the side effect
+    #    of carrying the definition of 'old_initialize' into the closure.
+    # 3. we have to bind 'old_initialize' to the run-time value of 'self' because it is an unbound
+    #    method and 'self' will have the right value when it is run in the context of 'mod' creating
+    #    an instance
+    # 4. we then define our instance variables so that everything will work properly
+
+    mod.helper_method :render_meta if mod.respond_to? :helper_method
+
+    old_initialize = mod.instance_method :initialize
+    mod.send(:define_method, :initialize) do |*args, &block|
+      result = old_initialize.bind(self).call(*args, &block)
+      @manage_meta_meta_hash = {}
+  
+      @manage_meta_format_hash = {
+        :named => '<meta name="#{name}" content="#{content}" char-encoding="utf-8" />',
+        :http_equiv => '<meta http-equiv="#{name}" content="#{content}" char-encoding="utf-8" />',
+        :canonical => '<link rel="canonical" href="#{content}" />',
+      }
+  
+      @manage_meta_name_to_format = {}
+      #-- set up http-equiv meta tags
+      ['accept', 'accept-charset', 'accept-encoding', 'accept-language', 'accept-ranges',
+        'age',  'allow',  'authorization',  'cache-control',  'connecting', 'content-encoding',
+        'content-language', 'content-length', 'content-location', 'content-md5',  'content-range',
+        'content-type', 'date', 'etag', 'expect', 'expires',  'from', 'host', 'if-match', 'if-modified-since',
+        'if-none-match',  'if-range', 'if-unmodified-since',  'last-modified',  'location',
+        'max-forwards', 'pragma', 'proxy-authenticate', 'proxy-authorization',  'range',  'referer',
+        'retry-after',  'server', 'te', 'trailer',  'transfer-encoding',  'upgrade',  'user-agent',
+        'vary', 'via',  'warning',  'www-authenticate', ].each { |name| @manage_meta_name_to_format[name] = :http_equiv }
+      # set up Google's canonical link tag
+      ['canonical'].each { |name| @manage_meta_name_to_format[name] = :canonical }
+      # set up normal meta tags
+      ['description', 'keywords', 'language', 'robots'].each { |name| @manage_meta_name_to_format[name] = :named }
+
+      add_meta 'robots', 'index follow'
+      add_meta 'generator', "Rails #{Rails.version}" if defined?(Rails)
+      # add_meta 'canonical', request.fullpath
+      result
+    end
+  end
+  
+  #--
+  protected
+
+  #++
+  # add_meta(name, value[, options]) - adds meta tag 'name' with value 'value' to meta tags to be displayed
+  # add_meta(name[, options] &block) - does same thing, except value is the return value of &block
+  #  Note: if no both 'value' and 'block' are given, then the content of the meta tag is the concatenation
+  #         of both values.
+  #  options:
+  #    :format => symbol - where 'symbol' is one of :named, :http_equiv, :canonical, or a format
+  #       added with 'add_meta_format'
+  #    all other options keys are ignored
+  #--
+  def add_meta(name, opt_value = nil, options = {}, &block)
+    # make sure name is a string
+    name = name.to_s
+
+    # handle optional nonsense
+    case
+    when opt_value.is_a?(String)
+      value = opt_value
+      value += yield.to_s if block_given?
+    when opt_value.is_a?(Hash)
+      raise ArgumentError, "Value for meta tag #{name} missing" if !block_given?
+      value = yield.to_s
+      options = opt_value
+    when opt_value.nil?
+      raise ArgumentError, "Value for meta tag #{name} missing" if !block_given?
+      value = yield.to_s
+    when opt_value.respond_to?(:to_s)
+      value = opt_value.to_s
+      value += yield.to_s if block_given?
+    else
+      raise ArgumentError, "add_meta(name, value[, options hash]) or add_meta(name[, option hash] do ... end)"
+    end
+    @manage_meta_meta_hash[name] = value
+
+    if (options.keys - [:format]).size > 0
+      raise RuntimeError, "add_meta(#{name}, ...): illegal option key(s): #{options.keys - [:format]}"
+    end
+
+    # if format is explicitly called out or if name is not yet known
+    if options.has_key?(:format)
+      raise RuntimeError, "Unsuported Format: #{options[:format]}: formats are #{@manage_meta_format_hash.keys.join(',')}" if !@manage_meta_format_hash.has_key?(options[:format].to_sym)
+      @manage_meta_name_to_format[name] = options[:format].to_sym
+    elsif !@manage_meta_name_to_format.has_key?(name)
+      @manage_meta_name_to_format[name] = :named
+    end
+  end
+
+  #++
+  # del_meta(name) - where _name_ is a string or a symbol.
+  #
+  # if _name_ is in @manage_meta_meta_hash, then it will be deleted
+  #--
+  def del_meta(name)
+    name = name.to_s
+    @manage_meta_meta_hash.delete name if @manage_meta_meta_hash.has_key? name
+  end
+
+  #++
+  # add_meta_format(key, format)
+  #
+  # adds the format _format_ to @manage_meta_format_hash using the key _key_
+  #--
+  def add_meta_format(key, format)
+    key = key.to_sym
+    @manage_meta_format_hash[key] = format
+  end
+
+  #++
+  # render_meta
+  #
+  # returns a string consisting of all defined meta names in @manage_meta_meta_hash, formatted
+  # using their name-specific formats and indented two spaces.
+  #--
+  def render_meta
+    '  ' + @manage_meta_meta_hash.map do |name, content|
+      @manage_meta_format_hash[@manage_meta_name_to_format[name]].sub('#{name}', name).sub('#{content}', content)
+    end.join("\n  ") + "  \n"
+  end
+end

data/test/manage_meta_test.rb

@@ -0,0 +1,116 @@
+$LOAD_PATH << File.expand_path("../../lib",  __FILE__)
+require 'test/unit'
+require 'manage_meta'
+
+class ManageMetaTest < Test::Unit::TestCase
+  include ManageMeta
+  
+  class NoToS ; end
+  NoToS.send :undef_method, :to_s
+  
+  # add refute methods for ruby 1.8.7
+  if !self.instance_methods.include? :refute_respond_to
+    def refute_respond_to(obj, func, msg = nil)
+      assert ! obj.respond_to?( func, msg )
+    end
+    
+    def refute(expr, msg = nil)
+      assert ! expr, msg
+    end
+  end
+
+  # test 'existence of add_meta method' do
+  def test_methods_exist
+    assert_respond_to self, :add_meta, "responds to add_meta()"
+    assert_respond_to self, :del_meta, "responds to del_meta()"
+    assert_respond_to self, :add_meta_format, "responds to add_meta_format()"
+    assert_respond_to self, :render_meta, "responds to render_meta()"
+  end
+
+  # add_meta tests
+  # test "add_meta argument edge cases" do
+  def test_add_meta_edge_cases
+
+    assert_raise(ArgumentError, "name of meta must be present") { add_meta }
+    assert_raise(ArgumentError, "value must be present") { add_meta :foo }
+    assert_raise(ArgumentError, "value must not be nil") { add_meta :foo, nil }
+    assert_raise(ArgumentError, "value must not be a hash") { add_meta :foo, :hash => true }
+
+    # make sure fails if value does not respond to :to_s
+    no_to_s = NoToS.new
+    refute_respond_to no_to_s, :to_s, "no_to_s must not respond to 'to_s'"
+    assert_raise(ArgumentError, "value must respond to to_s") { add_meta :no_to_s, no_to_s }
+    
+    assert_raise(RuntimeError, "illegal option must raise an error") { add_meta :foo, 'value', :bad_opt => 'stuff'}
+  end
+  
+  # test "add_meta adds methods to meta_hash" do
+  def test_add_meta_adds_meta
+    assert_nothing_raised(Exception, "add_meta foo, bar is ok") { add_meta :foo, "bar" }
+    assert self.instance_variable_get("@manage_meta_meta_hash").key?('foo'),
+      "meta variable 'foo' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+    assert self.instance_variable_get("@manage_meta_meta_hash")['foo'] == 'bar',
+      "meta variable 'foo' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+    assert_nothing_raised(Exception, "add_meta(bar) {'value'}") { add_meta( :bar ) { 'value' }}
+    assert self.instance_variable_get("@manage_meta_meta_hash").key?('bar'),
+      "meta variable 'bar' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+    assert self.instance_variable_get("@manage_meta_meta_hash")['bar'] == 'value',
+      "meta variable 'bar' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+  end
+  
+  # test "add_meta concatenates value and output of block" do
+  def test_add_meta_concats_value_and_block
+    add_meta(:foo, 'arg value') { ' block value' }
+    assert_equal self.instance_variable_get("@manage_meta_meta_hash")['foo'], 'arg value block value',
+      "add meta must concatenate value of both arg value and output of block"
+      add_meta(:foo, 'arg value', :format => :canonical) { ' block value' }
+    assert_equal self.instance_variable_get("@manage_meta_meta_hash")['foo'], 'arg value block value',
+      "add meta must concatenate value of both arg value and output of block with option present"
+  end
+
+  # test "add_meta with :format argument" do
+  def test_add_meta_format_works
+    # bad format option
+    assert_raise(RuntimeError, "Must not accept undefined format") { add_meta :foo, 'value', :format => :bad_key }
+    # good format options
+    assert_nothing_raised("Must accept format arg as string") { add_meta :foo, 'value', :format => 'named' }
+  end
+  
+  # test ' del_meta' do
+  def test_del_meta_deletes_meta_tag
+    assert_nothing_raised(Exception, "add_meta foo, bar is ok") { add_meta :foo, "bar" }
+    assert self.instance_variable_get("@manage_meta_meta_hash").key?('foo'),
+      "meta variable 'foo' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+    assert self.instance_variable_get("@manage_meta_meta_hash")['foo'] == 'bar',
+      "meta variable 'foo' not defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+    del_meta(:foo)
+    refute self.instance_variable_get("@manage_meta_meta_hash").key?('foo'),
+      "meta variable 'foo' should not be defined #{self.instance_variable_get('@manage_meta_meta_hash')}"
+  end
+  
+  # test 'add_meta_format' do
+  def test_add_meta_format_adds_a_format
+    format = '<meta foo-type="#{name}" content="#{content}"'
+    add_meta_format(:foo, format)
+    assert self.instance_variable_get("@manage_meta_format_hash").key?(:foo),
+      "add_meta_format adds key to format_hash using symbol"
+    assert self.instance_variable_get("@manage_meta_format_hash")[:foo] == format,
+      "add_meta_format adds format properly"
+    add_meta_format('bar', format)
+    assert self.instance_variable_get("@manage_meta_format_hash").key?(:bar),
+      "add_meta_format adds key to format_hash using string"
+    assert self.instance_variable_get("@manage_meta_format_hash")[:bar] == format,
+      "add_meta_format adds format properly"
+  end
+  
+  # test 'render_meta' do
+  def test_render_meta_renders_meta
+    assert_match /name="robots"/, render_meta, "render_meta contains robots meta tag"
+    assert_match /name="generator"/, render_meta, "render_meta contains generator meta tag" \
+      if defined? Rails
+    add_meta :foo, 'a value'
+    assert_match /name="foo"/, render_meta, "render_meta contains 'foo' meta tag"
+    assert_match /content="a value"/, render_meta, "render_meta tag for foo has content 'a value'"
+  end
+  
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: manage_meta
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Mike Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-13 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Provides (semi-)intellegent management of meta tags for Rails 3
+email: mike@clove.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/manage_meta/manage_meta.rb
+- lib/manage_meta.rb
+- test/manage_meta_test.rb
+- MIT-LICENSE
+- Rakefile
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/mikehoward/manage_meta
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: ManageMeta - Yet Another Meta Tag manager for Rails 3
+test_files: []
+