manage_meta 0.0.5 → 0.0.6

data/README.markdown

@@ -33,21 +33,26 @@ defined meta tags.
 What it Adds
 ------------
 
-ManageMeta defines six (6) methods and three (3) instance variables into all classes
+ManageMeta defines seven (7) methods and three (3) instance variables into all classes
 derived from ApplicationController
 
-The methods are:
+The public 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.
-* `manage_meta_sym_to_name` - returns Content-Length when given :content_length, etc.
+
+private methods:
+
+* `_manage_meta_init` - initializes required instance variables. `_manage_meta_init` is
+called automatically from the public methods
+* `_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'.
+* `_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 three hashes:
+The instance variables are three hashes. None have readers or writers:
 
 * `@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.
@@ -106,12 +111,12 @@ Nothing bad happens if it isn't.
 `add_meta_format(format_name, format_string)` adds the `format_string` to
 `@manage_meta_format_hash` under the key `format_name`
 
-*format_name* will be converted to a symbol using `manage_meta_sym_to_name()`.
+*format_name* will be converted to a symbol using `_manage_meta_sym_to_name()`.
 
 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.
+The value used for `#{name}` result of calling `_manage_meta_sym_to_name()` on the meta element key.
 
 #### render_meta() ####
 
@@ -122,7 +127,7 @@ returns their associated format strings after replacing the `#{name}` and `#{con
 symbols with their values.
 
 `#{name}` is replaced with the meta tag key [as in `:content_type`] passed through
-`manage_meta_sym_to_name()`.
+`_manage_meta_sym_to_name()`.
 
 `#{value}` is replaced by the value assigned in `@manage_meta_meta_hash`.
 

data/lib/manage_meta/manage_meta.rb

@@ -1,55 +1,33 @@
 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
+  private
+  #- initialize instance variables
+  def _manage_meta_init
+    return if @manage_meta_meta_hash.instance_of? Hash
+    @manage_meta_meta_hash = {}
 
-    mod.helper_method :render_meta if mod.respond_to? :helper_method
+    @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}" />',
+    }
 
-    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) unless old_initialize.nil?
+    @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 }
 
-      @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 || nil
-    end
+    add_meta 'robots', 'index follow'
+    add_meta 'generator', "Rails #{Rails.version}" if defined?(Rails)
   end
   
   #--
@@ -66,8 +44,10 @@ module ManageMeta
   #    all other options keys are ignored
   #--
   def add_meta(name, opt_value = nil, options = {}, &block)
+    _manage_meta_init unless @manage_meta_meta_hash.instance_of? Hash
+    
     # make sure name is a string
-    name = manage_meta_name_to_sym name
+    name = _manage_meta_name_to_sym name
 
     # handle optional nonsense
     case
@@ -109,7 +89,9 @@ module ManageMeta
   # if _name_ is in @manage_meta_meta_hash, then it will be deleted
   #--
   def del_meta(name)
-    name = manage_meta_name_to_sym name
+    _manage_meta_init unless @manage_meta_meta_hash.instance_of? Hash
+    
+    name = _manage_meta_name_to_sym name
     @manage_meta_meta_hash.delete name if @manage_meta_meta_hash.has_key? name
   end
 
@@ -119,6 +101,8 @@ module ManageMeta
   # adds the format _format_ to @manage_meta_format_hash using the key _key_
   #--
   def add_meta_format(key, format)
+    _manage_meta_init unless @manage_meta_meta_hash.instance_of? Hash
+    
     key = key.to_sym
     @manage_meta_format_hash[key] = format
   end
@@ -130,16 +114,19 @@ module ManageMeta
   # using their name-specific formats and indented two spaces.
   #--
   def render_meta
+    _manage_meta_init unless @manage_meta_meta_hash.instance_of? Hash
+    
     '  ' + @manage_meta_meta_hash.map do |name, content|
-      @manage_meta_format_hash[@manage_meta_name_to_format[name]].sub('#{name}', manage_meta_sym_to_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)
+  private
+  def _manage_meta_sym_to_name(sym)
     sym.to_s.split(/[_-]/).map {|x| x.capitalize }.join('-')
   end
   
-  def manage_meta_name_to_sym(name)
+  def _manage_meta_name_to_sym(name)
     name.to_s.downcase.gsub(/[-_]+/, '_').to_sym
   end
 end

data/test/manage_meta_test.rb

@@ -6,11 +6,6 @@ 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
   
@@ -25,38 +20,53 @@ class ManageMetaTest < Test::Unit::TestCase
     end
   end
 
+  def test__manage_meta_init
+    refute self.instance_variables.map {|x| x.to_sym }.include?(:@manage_meta_meta_hash), "self does not contain @manage_meta_meta_hash"
+    self.send(:_manage_meta_init)
+    assert self.instance_variables.map {|x| x.to_sym }.include?(:@manage_meta_meta_hash), "self contains @manage_meta_meta_hash"
+  end
+
+  def test__manage_meta_init_is_itempotent
+    self.send(:_manage_meta_init)
+    h = {}
+    self.instance_variables.grep(/manage_meta/).each do |name|
+      h[name] = self.instance_variable_get name
+    end
+    self.send(:_manage_meta_init)
+    assert h.keys.sort == self.instance_variables.grep(/manage_meta/).sort, "no manage_meta instance variables added or removed"
+    h.each do |name, val|
+      assert h[name] == self.instance_variable_get(name), "instance variable #{name} has not changed"
+    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()"
-    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()"
+    if RUBY_VERSION =~ /^1\.9/
+      refute_respond_to self, :_manage_meta_init, "does not respond to _manage_meta_init()"
+      refute_respond_to self, :_manage_meta_sym_to_name, "does not respond to _manage_meta_sym_to_name()"
+      refute_respond_to self, :_manage_meta_name_to_sym, "does not respond to _manage_meta_name_to_sym()"
+    end
+    assert self.private_methods.grep(/_manage_meta_init/), "has private method _manage_meta_init"
+    assert self.private_methods.grep(/_manage_meta_name_to_sym/), "has private method _manage_meta_name_to_sym"
+    assert self.private_methods.grep(/_manage_meta_sym_to_name/), "has private method _manage_meta_sym_to_name"
   end
   
-  def test_manage_meta_sym_to_name
+  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}"
+      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
+  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
+      assert_equal _manage_meta_name_to_sym(key), val, "_manage_meta_name_to_sym(#{key}) == #{val}"
     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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: manage_meta
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Mike Howard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-16 00:00:00 -06:00
+date: 2011-04-17 00:00:00 -06:00
 default_executable: 
 dependencies: []