manage_meta 0.0.4 → 0.0.5

data/README.markdown

@@ -4,24 +4,24 @@ 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
+How to use it
 -----------
 
 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
+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.
+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.
+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_.
+If there is a meta tag which requires a currently unsupported format, you may add the
+format using *add_meta_format()*, and then add the tag using *add_meta()*.
 
 Finally, edit app/views/layouts/application.html.erb - or equivalent - to insert
 
@@ -33,21 +33,28 @@ defined meta tags.
 What it Adds
 ------------
 
-ManageMeta defines four (4) methods and three (3) instance variables into all classes
+ManageMeta defines six (6) 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.
+* `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.
+* `manage_meta_sym_to_name` - returns Content-Length when given :content_length, etc.
+It works with either symbols or strings and strips extra underscores and hyphens
+* `manage_meta_name_to_sym` - returns symbol :foo_bar_baz when given a name of the form 'Foo-Bar-Baz'.
+It also works when given a symbol and strips extra underscores and hyphens.
 
-The instance variables are:
+The instance variables are three hashes:
 
-* @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
+* `@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 symbols to actual format strings.
+Contains entries such as `:content_type => :named` and `:content_length => :http_equiv`
+* `@manage_meta_name_to_format` - a Hash mapping meta tag name strings to known formats. Formats
+are initialized to the three symbols: `:named`, `:http_equiv`, and `:canonical` (see below). `add_meta_format()`
+is used to add formats to this hash.
 
 The Details
 --------------
@@ -56,22 +63,24 @@ Here are the ugly details
 
 ### Methods in Detail ###
 
-#### add_meta ####
+#### `add_meta()` ####
 
-_add_meta_ accepts values in any of three formats:
+*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`
+* `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_)
+Arguments:
+
+* *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
+* *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:
@@ -83,50 +92,64 @@ Three meta tag formats are defined automatically:
 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()` ####
 
-_del_meta_ is almost useless. It's there in case you want to get ride of a default tag.
+`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)`
+If the meta tag is defined in `@manage_meta_meta_hash`, then it will be deleted.
+Nothing bad happens if it isn't.
 
-_format_name__ will be converted to a symbol.
+#### `add_meta_format()` ####
 
-_format_string_ will be the value of @manage_meta_format_hash[_format_name.to_sym_].
+`add_meta_format(format_name, format_string)` adds the `format_string` to
+`@manage_meta_format_hash` under the key `format_name`
 
-It's your responsibility to format the string properly.
+*format_name* will be converted to a symbol using `manage_meta_sym_to_name()`.
 
-_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_
+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}`.
+The value used for `#{name}` result of calling `manage_meta_sym_to_name()` on the meta element key.
 
-#### render_meta ####
+#### render_meta() ####
 
-`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}_
+returns their associated format strings after replacing the `#{name}` and `#{content}`
 symbols with their values.
 
+`#{name}` is replaced with the meta tag key [as in `:content_type`] passed through
+`manage_meta_sym_to_name()`.
+
+`#{value}` is replaced by the value assigned in `@manage_meta_meta_hash`.
+
 ### Instance Variables in Detail ###
 
-#### manage_meta_format_hash ####
+All three hashes use symbols for keys. 
+
+#### `@manage_meta_format_hash` ####
+
+maps format keys to format strings. See `add_meta_format()` above for details
 
 keys are symbols,
 
 values are strings which are used to render meta tags
 
-####  manage_meta_meta_hash ####
+####  `@manage_meta_meta_hash` ####
+
+Maps meta tag `name` keys to values to insert into the `content` field of the meta tag
+element.
+
+keys are symbols which are used for the names of meta tags
 
-keys are strings which are used for the names of meta tags
+values are strings
 
-values are symbols which are keys in @manage_meta_format_hash
+#### `@manage_meta_name_to_format` ####
 
-#### manage_meta_name_to_format ####
+Maps meta tag name symbols to meta tag format string symbols. Contains entries
+such as `:content_length => :http_equiv`
 
-keys are strings which map meta tag names to keys in @manage_meta_format_hash
+both keys and values are symbols

data/lib/manage_meta/manage_meta.rb

@@ -14,9 +14,14 @@ module ManageMeta
 
     mod.helper_method :render_meta if mod.respond_to? :helper_method
 
-    old_initialize = mod.instance_method :initialize
+    begin
+      old_initialize = mod.instance_method(:initialize)
+    rescue
+      old_initialize = nil
+    end
     mod.send(:define_method, :initialize) do |*args, &block|
-      result = old_initialize.bind(self).call(*args, &block)
+      result = old_initialize.bind(self).call(*args, &block) unless old_initialize.nil?
+
       @manage_meta_meta_hash = {}
   
       @manage_meta_format_hash = {
@@ -27,23 +32,23 @@ module ManageMeta
   
       @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 }
+      [: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 }
+      [: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 }
+      [: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
+      result || nil
     end
   end
   
@@ -62,7 +67,7 @@ module ManageMeta
   #--
   def add_meta(name, opt_value = nil, options = {}, &block)
     # make sure name is a string
-    name = name.to_s
+    name = manage_meta_name_to_sym name
 
     # handle optional nonsense
     case
@@ -90,7 +95,8 @@ module ManageMeta
 
     # 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)
+      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
@@ -103,7 +109,7 @@ module ManageMeta
   # if _name_ is in @manage_meta_meta_hash, then it will be deleted
   #--
   def del_meta(name)
-    name = name.to_s
+    name = manage_meta_name_to_sym name
     @manage_meta_meta_hash.delete name if @manage_meta_meta_hash.has_key? name
   end
 
@@ -125,7 +131,15 @@ module ManageMeta
   #--
   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)
+      @manage_meta_format_hash[@manage_meta_name_to_format[name]].sub('#{name}', manage_meta_sym_to_name(name)).sub('#{content}', content)
     end.join("\n  ") + "  \n"
   end
+  
+  def manage_meta_sym_to_name(sym)
+    sym.to_s.split(/[_-]/).map {|x| x.capitalize }.join('-')
+  end
+  
+  def manage_meta_name_to_sym(name)
+    name.to_s.downcase.gsub(/[-_]+/, '_').to_sym
+  end
 end

data/test/manage_meta_test.rb

@@ -2,12 +2,18 @@ $LOAD_PATH << File.expand_path("../../lib",  __FILE__)
 require 'test/unit'
 require 'manage_meta'
 
+class NoToS
+end
+NoToS.send( :undef_method, :to_s )
+
+class NoInitializer
+  undef_method :initialize if methods.include? :initialize
+  include ManageMeta
+end
+
 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)
@@ -25,6 +31,32 @@ class ManageMetaTest < Test::Unit::TestCase
     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()"
+    assert_respond_to self, :manage_meta_sym_to_name, "responds to manage_meta_sym_to_name()"
+    assert_respond_to self, :manage_meta_name_to_sym, "responds to manage_meta_name_to_sym()"
+  end
+  
+  def test_manage_meta_sym_to_name
+    {:foo => 'Foo', :foo_bar => "Foo-Bar", :foo_bar_baz => "Foo-Bar-Baz", "Foo-Bar" => "Foo-Bar",
+      "Foo_bar" => "Foo-Bar" }.each do |key, val|
+      assert_equal manage_meta_sym_to_name(key), val, "manage_meta_sym_to_name(#{key}) == #{val}"
+    end
+  end
+  
+  def test_manage_meta_name_to_sym
+    { 'Foo'  => :foo, 'Foo-Bar' => :foo_bar, 'Foo--Bar_Baz' => :foo_bar_baz,
+      :foo_bar_baz => :foo_bar_baz, :foo____bar => :foo_bar }.each do |key, val|
+      assert_equal manage_meta_name_to_sym(key), val, "manage_meta_name_to_sym(#{key}) == #{val}"
+    end
+  end
+
+  def test_works_wo_initialize
+    refute NoInitializer.methods.include?(:initialize), "NoInitializer does not have an initialize method"
+    foo = nil
+    assert_nothing_raised(Exception, "instantiating a class w/o an initialize method should work") do
+      foo = NoInitializer.new
+    end
+    assert foo.instance_of?(NoInitializer), "foo is an instance of NoInitializer"
+    refute foo.methods.include?(:initialize), "foo does not have an initialize method"
   end
 
   # add_meta tests
@@ -47,24 +79,24 @@ class ManageMetaTest < Test::Unit::TestCase
   # 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'),
+    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',
+    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'),
+    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',
+    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',
+    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',
+    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
 
@@ -79,12 +111,12 @@ class ManageMetaTest < Test::Unit::TestCase
   # 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'),
+    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',
+    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'),
+    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
   
@@ -105,11 +137,11 @@ class ManageMetaTest < Test::Unit::TestCase
   
   # 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" \
+    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 /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
   

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: manage_meta
 version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: 
-  version: 0.0.4
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Mike Howard
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-13 00:00:00 -06:00
+date: 2011-04-16 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -43,12 +48,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
 requirements: []