facets 1.4.5 → 1.7.0

data/lib/facets/core/string/singular.rb

@@ -1,69 +1,98 @@
 
 class String
 
-  SINGULAR_RULES = [
-    [/(matr)ices$/i, '\1ix'],
-    [/(vert)ices$/i, '\1ex'],
-    [/^(ox)en/i, '\1'],
-    [/(alias)es$/i, '\1'],
-    [/([octop|vir])i$/i, '\1us'],
-    [/(cris|ax|test)es$/i, '\1is'],
-    [/(shoe)s$/i, '\1'],
-    [/(o)es$/i, '\1'],
-    [/(bus)es$/i, '\1'],
-    [/([m|l])ice$/i, '\1ouse'],
-    [/(x|ch|ss|sh)es$/i, '\1'],
-    [/(m)ovies$/i, '\1\2ovie'],
-    [/(s)eries$/i, '\1\2eries'],
-    [/([^aeiouy]|qu)ies$/i, '\1y'],
-    [/([lr])ves$/i, '\1f'],
-    [/(tive)s$/i, '\1'],
-    [/(hive)s$/i, '\1'],
-    [/([^f])ves$/i, '\1fe'],
-    [/(^analy)ses$/i, '\1sis'],
-    [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis'],
-    [/([ti])a$/i, '\1um'],
-    [/(p)eople$/i, '\1\2erson'],
-    [/(m)en$/i, '\1an'],
-    [/(s)tatus$/i, '\1\2tatus'],
-    [/(c)hildren$/i, '\1\2hild'],
-    [/(n)ews$/i, '\1\2ews'],
-    [/s$/i, '']
-  ]
-
-  PLURAL_RULES = [
-    [/^(ox)$/i, '\1\2en'],                 # ox
-    [/([m|l])ouse$/i, '\1ice'],            # mouse, louse
-    [/(matr|vert)ix|ex$/i, '\1ices'],      # matrix, vertex, index
-    [/(x|ch|ss|sh)$/i, '\1es'],            # search, switch, fix, box, process, address
-    [/([^aeiouy]|qu)ies$/i, '\1y'],
-    [/([^aeiouy]|qu)y$/i, '\1ies'],        # query, ability, agency
-    [/(hive)$/i, '\1s'],                   # archive, hive
-    [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'], # half, safe, wife
-    [/sis$/i, 'ses'],                      # basis, diagnosis
-    [/([ti])um$/i, '\1a'],                 # datum, medium
-    [/(p)erson$/i, '\1eople'],             # person, salesperson
-    [/(m)an$/i, '\1en'],                   # man, woman, spokesman
-    [/(c)hild$/i, '\1hildren'],            # child
-    [/(buffal|tomat|potat)o$/i, '\1\2oes'],      # buffalo, tomato
-    [/(bu)s$/i, '\1\2ses'],                # bus
-    [/(alias)/i, '\1es'],                  # alias
-    [/(octop|vir)us$/i, '\1i'],            # octopus, virus - virus has no defined plural, but viri is better than viruses/viruss
-    [/(ax|cri|test)is$/i, '\1es'],         # axis, crisis  
-    [/s$/i, 's'],                          # no change (compatibility)
-    [/$/, 's']
-  ]
+  @inflection_rules = []
 
+  def self.inflection_rule( *args ) @inflection_rules << args end
+  def self.inflection_rules() @inflection_rules end
+
+  #
+
+  def self.inflection_rules_by_singular
+    return @inflection_rules_by_singular if @inflection_rules_by_singular
+
+    sorted = inflection_rules.sort_by{ |b,s,pl| "#{b}#{s}".size }.reverse
+    @inflection_rules_by_singular = sorted.collect do |b, s, pl|
+      [ /(#{b})#{s}$/, '\1'+"#{pl}" ]
+    end
+  end
+
+  #
+
+  def self.inflection_rules_by_plural
+    return @inflection_rules_by_plural if @inflection_rules_by_plural
+
+    sorted = inflection_rules.sort_by{ |b,s,pl| "#{b}#{pl}".size }.reverse
+    @inflection_rules_by_plural = sorted.collect do |b, s, pl|
+      [ /(#{b})#{pl}$/, '\1'+"#{s}" ]
+    end
+  end
+
+  # One argument means singular and plural are the same.
+
+  inflection_rule 'equipment'
+  inflection_rule 'information'
+  inflection_rule 'money'
+  inflection_rule 'species'
+  inflection_rule 'series'
+  inflection_rule 'fish'
+  inflection_rule 'sheep'
+  inflection_rule 'moose'
+
+  # USAGE: +inflection_rule+ base, singular, plural
+  #
+  # IMPORTANT Each base+singular and base+plural should only appear once!
+
+  inflection_rule 'quiz'         , ''     , 'zes'       # quiz
+  inflection_rule 'matr'         , 'ix'   , 'ices'      # matrix
+  inflection_rule 'vert|ind'     , 'ex'   , 'ices'      # vertex, index
+  inflection_rule 'ox'           , ''     , 'en'        # ox
+  inflection_rule 'm'            , 'ouse' , 'ice'       # mouse, louse
+  inflection_rule 'l'            , 'ouse' , 'ice'       # mouse, louse
+  inflection_rule 'x'            , ''     , 'es'        # fix, box
+  inflection_rule 'ch'           , ''     , 'es'        # search, switch
+  inflection_rule 'ss'           , ''     , 'es'        # process, address
+  inflection_rule 'sh'           , ''     , 'es'        # dish, wish
+  inflection_rule 'qu'           , 'y'    , 'ies'       # query, ability, agency
+  inflection_rule 'hive'         , ''     , 's'         # archive, hive
+  inflection_rule 'sis'          , ''     , 'ses'       # basis, diagnosis
+  inflection_rule 't'            , 'um'   , 'a'         # datum, medium, forum
+  inflection_rule 'i'            , 'um'   , 'a'         # datum, medium, forum
+  inflection_rule 'r'            , 'um'   , 'a'         # datum, medium, forum
+  inflection_rule 'potat'        , 'o'    , 'oes'       # potato
+  inflection_rule 'buffal'       , 'o'    , 'oes'       # buffalo, tomato
+  inflection_rule 'tomat'        , 'o'    , 'oes'       # buffalo, tomato
+  inflection_rule 'p'            , 'erson', 'eople'     # person, salesperson
+  inflection_rule 'm'            , 'an'   , 'en'        # man, woman, spokesman
+  inflection_rule 'c'            , 'hild' , 'hildren'   # child
+  inflection_rule 'bu'           , 's'    , 'ses'       # bus
+  inflection_rule 'alias'        , ''     , 'es'        # alias
+  inflection_rule 'status'       , ''     , 'es'        # status
+  inflection_rule 'vir'          , 'us'   , 'i'         # virus
+  inflection_rule 'octop'        , 'us'   , 'i'         # octopus
+  inflection_rule 'ax'           , 'is'   , 'es'        # axis
+  inflection_rule 'cris'         , 'is'   , 'es'        # crisis
+  inflection_rule 'test'         , 'is'   , 'es'        # testis
+  inflection_rule 'l'            , 'f'    , 'ves'       # half halves
+  inflection_rule ''             , 'fe'   , 'ves'       # safe, wife
+  inflection_rule 'a'            , 'y'    , 's'         # query, ability, agency
+  inflection_rule 'e'            , 'y'    , 's'         # query, ability, agency
+  inflection_rule 'i'            , 'y'    , 's'         # query, ability, agency
+  inflection_rule 'o'            , 'y'    , 's'         # query, ability, agency
+  inflection_rule 'u'            , 'y'    , 's'         # query, ability, agency
+  inflection_rule ''             , 'y'    , 'ies'       # query, ability, agency
+  inflection_rule ''             , ''     , 's'         # --catch all--
 
   # Convert an English word from plurel to singular.
   #
   #   "boys".singular      #=> boy
   #   "tomatoes".singular  #=> tomato
   #
+
   def singular
-    result = self.to_s.dup
-    String::SINGULAR_RULES.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
+    result = self.dup
+    self.class.inflection_rules_by_plural.each do |(match, replacement)|
+      break if result.gsub!(match, replacement)
     end
     return result
   end
@@ -73,18 +102,20 @@ class String
   #   "boy".plural     #=> boys
   #   "tomato".plural  #=> tomatoes
   #
+
   def plural
-    result = self.to_s.dup
-    String::PLURAL_RULES.each do |(rule, replacement)|
-      break if result.gsub!(rule, replacement)
+    return self.dup if /s$/ =~ self
+    result = self.dup
+    self.class.inflection_rules_by_singular.each do |(match, replacement)|
+      break if result.gsub!(match, replacement)
     end
     return result
   end
 
-  # Deprecated alias for #singular.
+  # Railism alias for #singular.
   alias_method( :singularize, :singular )
 
-  # Deprecated alias for #plural.
+  # Railism alias for #plural.
   alias_method( :pluralize, :plural )
 
 end
@@ -100,16 +131,70 @@ end
 
   require 'test/unit'
 
-  class TCString < Test::Unit::TestCase
+  # Singular
+
+  class TestStringSingular < Test::Unit::TestCase
+
+    def test_singular_01
+      assert_equal "friend" , "friends".singular
+    end
+
+    def test_singular_02
+      assert_equal "man"    , "men".singular
+    end
+
+    def test_singular_03
+      assert_equal "girl"   , "girls".singular
+    end
+
+    def test_singular_04
+      assert_equal "half"   , "halves".singular
+    end
+
+    def test_singular_05
+      assert_equal "ox"     , "oxen".singular
+    end
+
+    def test_singular_06
+      assert_equal "forum"  , "fora".singular
+    end
+
+    def test_singular_07
+      assert_equal "fish"   , "fish".singular
+    end
+
+  end
+
+  # Plural
+
+  class TestStringPlural < Test::Unit::TestCase
+
+    def test_plural_01
+      assert_equal "friends" , "friend".plural
+    end
+
+    def test_plural_02
+      assert_equal "men"     , "man".plural
+    end
+
+    def test_plural_03
+      assert_equal "girls"   , "girl".plural
+    end
+
+    def test_plural_04
+      assert_equal "halves"  , "half".plural
+    end
+
+    def test_plural_05
+      assert_equal "oxen"    , "ox".plural
+    end
 
-    def test_singular
-      assert_equal( "friend", "friends".singular )
-      assert_equal( "man", "men".singular )    
+    def test_plural_06
+      assert_equal "fora"    , "forum".plural
     end
 
-    def test_plural
-      assert_equal( "friends", "friend".plural )
-      assert_equal( "men", "man".plural )
+    def test_plural_07
+      assert_equal "fish"    , "fish".plural
     end
 
   end

data/lib/facets/core/symbol/self/generate.rb

@@ -0,0 +1,18 @@
+
+class Symbol
+
+  # Generate a unique symbol. 
+  #
+  #   Symbol.generate => :<1>
+  #
+  # If +for+ is given the new symbol will be suffixed with it.
+  #
+  #   Symbol.generate(:this) => :<2>this
+  #
+  def self.generate(for=nil)
+    @generate_count ||= 0
+    ("<%X>#{for}" % @generate_count += 1).to_sym
+  end
+
+end
+

data/lib/facets/more/annattr.rb

@@ -85,18 +85,18 @@ class ::Module
           harg.each { |a,h|
             module_eval( "#{d}" % a)
             a = a.to_sym
-            define_annotation( a, h )
+            ann(a,h)
           }
-          attributes!.merge!( harg.keys )
+          attributes!.concat( harg.keys )  #merge!
           # return the names of the attributes created
           return harg.keys
         else
           args.each { |a|
             module_eval( "#{d}" % a)
             a = a.to_sym
-            define_annotation( a, harg )
+            ann(a,harg)
           }
-          attributes!.merge!( args )
+          attributes!.concat( args )  #merge!
           # return the names of the attributes created
           return args
         end

data/lib/facets/more/annotation.rb

@@ -19,10 +19,8 @@
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
 
-require 'facets/core/array/merge'
-
+require 'facets/core/hash/to_h'
 require 'facets/more/openobject'
-#require 'facets/more/inheritor'
 require 'facets/more/nullclass'
 
 # = Annotation
@@ -55,112 +53,181 @@ require 'facets/more/nullclass'
 #     end
 #
 #   end
-#
 
-class Annotation < OpenObject
+class Annotations
 
-  def initialize( set={} )
-    super( set )
+  def initialize( base )
+    @base, @ann = base, {}
   end
 
-  def inherits( base, &heritage )
-    @base = base
-    @heritage = heritage
-    self
+  def [](name)
+    @ann[name] ||= Annotation.new(@base, name)
   end
 
-  def method_missing( sym, *args, &blk )
-    name = sym.to_s.gsub(/([=!?])$/, '').to_sym
-    type = sym.to_s[-1,1]
+  def []=(name, note)
+    raise ArgumentError unless Annotation === note
+    @ann[name] = note
+  end
 
-    unless @base
-      r = super
-      return Kernel.null if r.nil? and type != '?'
-      return r
-    else
-      if type == '!'
-        unless __key__?( name )
-          parent = nil
-          @base.ancestors.each do |anc|
-            if ans = @heritage.call(anc) #anc.method_annotation[@key]
-              if parent = ans[name]
-                break
-              end
-            end
-          end
-          if parent
-            return __table__[name] = parent.dup #vs. __class__.new?
-          end
-        end
-        return super( name )
-      end
+  def ==(other) @ann == other.to_h end
 
-      iob = dup
-      super
-      return inheritance if iob != self
-      return inheritance.__send__( sym, *args, &blk )
-    end
+  def to_h() @ann end
+
+  def key?(name) @ann.key?(name) end
+
+  def each(&yld)
+    @ann.each(&yld)
   end
 
-  def [](x)
-    @base ? inheritance[x] : super
+  def update( other )
+    @ann.update( other.to_h )
+    self
   end
+  private :update
+
+#   def inheritance
+#     anns = Annotations.new(@base)
+#     @base.ancestors.each do |anc|
+#       anc.annotations.each { |k,v|
+#         next if anns.key?(k)
+#         anns[k] = v #.dup
+#       }
+#     end
+#     #@ann.each_key do |name|
+#     #  anns[name] = self[name].heritage
+#     #end
+#     return anns
+#   end
+
+  def annotated_base() @base end
 
-  def inheritance
-    return self unless @base
-    inh = @base.ancestors.collect{ |anc| @heritage.call(anc) }.compact
-    if inh
-      a = Annotation.new #( inh.pop.to_h )
-      #inh.push( a ) #.dup )
-      inh.reverse.inject(a){ |memo, i| memo.__merge__( i ) }
+  def method_missing( name, *args, &blk )
+    if key?(name)
+      self[name] #.heritage
+    else
+      if @base.ancestors.any?{|anc| anc.annotations.key?(name)}
+        return self[name].heritage
+        #ann[name].heritage
+      end
+      super
     end
   end
 
 end
 
-# This is a simple decorator for accessing a module's
-# method annotations (and it's own annotations).
+#
+
+class Annotation < OpenObject
+
+  def initialize( base, name, orig=nil )
+    @base = base
+    @name = name
+    @orig = orig || self
+    super()
+  end
 
-class Annotator < BasicObject  #:nodoc:
-  def initialize( mod ) ; @mod = mod ; end
+  def original
+    @orig
+  end
 
-  def inspect ; "#<Annotator #{@mod}>" ; end
+  #def class
+  #  self[:class]
+  #end
 
-  def self ; @mod.annotation ; end
+  def inspect
+    "#<#{object_class.name}(#{@base}##{@name}) #{super}>"
+  end
 
-  def [](sym)
-    sym == :self ? @mod.annotation : @mod.method_annotation( sym )
+  def annotation_name
+    @name
+  end
+
+  def heritage( orig=nil )
+    ah = {}
+    @base.ancestors.reverse_each do |anc|
+      if anc.annotations.key?(@name)
+        anc.annotations[@name].each { |k,v|
+          case v
+          when Module
+            ah[k] = v
+          else
+            ah[k] = v.dup rescue v
+          end
+        }
+      end
+    end
+    a = Annotation.new( @base, @name, orig || @orig )
+    a.send(:replace, ah)
+    a
   end
 
   def method_missing( sym, *args, &blk )
     type = sym.to_s[-1,1]
-    name = sym.to_s.gsub(/[=!?]$/, '').to_sym
+    key = sym.to_s.gsub(/[=!?]$/, '').to_sym
+
+    case type
+    when '='
+      @orig[key] = args[0] #, *args, &blk )
+    when '!'
+      #r = super( key, *args, &blk )
+      if self.key?(key)
+        self[key]
+      else
+        self[key] = heritage(self)[key]
+      end
+    else
+      heritage[sym]
+    end
+  end
+
+end
+
+#
 
-    return @mod.annotation if name == :self
+class Module
 
-    r = @mod.method_annotation( name )
+  def annotations
+    @annotations ||= Annotations.new(self)
+  end
 
-    return nil if type == '?' and r == Kernel.null
-    return r
+  def ann( name=nil, *options )
+    return annotations unless name
+    return name.each{|k,v| ann k,*v} if Hash === name
+    return annotations[name] if options.empty?
+    opt = {}
+    opt.update options.pop if Hash === options.last
+    opt[:class] = options.pop if Class === options.last
+    names = [name].concat options
+    names.each do |name|
+      note = annotations[name]
+      #unless options.empty?
+      #  (hopt[:tags] ||= []) << options
+      #end
+      note.send(:update,opt)
+    end 
+    names
   end
+
 end
 
+
 # Any object can be annotated.
 
-module ::Kernel
+module Kernel
+
+  #--
   # Store and retrieve annotations for an object.
-  def annotation( harg=nil )
-    @_annotation ||= Annotation.new
-    return @_annotation unless harg
-    @_annotation.__update__( harg )
-  end
+  #def annotation( harg=nil )
+  #  @_annotation ||= Annotation.new
+  #  return @_annotation unless harg
+  #  @_annotation.send(:update, harg)
+  #end
+  #++
 
   #--
   # Not sure about this.
   #++
   def ann( *args )
-    #return annotation unless harg
-    #annotation.__update__( harg )
     #if singleton_class?
       (class << self; self; end).ann( *args )
     #else
@@ -170,205 +237,199 @@ module ::Kernel
 
 end
 
-# Modules and Classes have more sifisticated annotation.
-# They differ from normal object annotation in that
-# the are inheritables.
 
-class ::Module
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
 
-  #def annotation
-  #  @_annotation ||= Annotation.new.inherits( self ){ |anc| anc.annotation }
-  #end
+=begin test
 
-  def annotation( harg=nil )
-    @_annotation ||= Annotation.new.inherits( self ){ |anc| anc.annotation }
-    return @_annotation unless harg
-    @_annotation.__update__( harg ) if harg
-  end
+  require 'test/unit'
 
-  def method_annotation( key=nil )
-    @_method_annotation ||= {}
-    return @_method_annotation unless key
-    key = key.to_sym
-    if a = @_method_annotation[key]
-      return a
-    elsif ancestors.any? { |anc| anc.method_annotation[key] }
-      @_method_annotation[key] = Annotation.new.inherits( self ){ |anc| anc.method_annotation[key] }
-    else
-      null
+  class TestAnnotation1 < Test::Unit::TestCase
+    class X
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
     end
-  end
 
-  # Does this module/class or its ancestors have any annotation
-  # for a given method?
-  def annotated?( key )
-    return annotation if self == key
-    r = method_annotation( key )
-    null == r ? nil : r
+    def test_1_01
+      assert_equal(X.ann.x1.orig.object_id, X.ann.x1.orig.object_id)
+    end
+    def test_1_02
+      X.ann.x1.a = 2
+      assert_equal(2, X.ann.x1.a)
+    end
   end
 
-  # Returns a list of all annotated methods.
-  def annotated_methods(include_ancestors=true)
-    annlist = []
-    if include_ancestors
-      ancestors.inject([]){ |memo, anc|
-        memo | anc.method_annotation.keys
-      }
-    else
-      method_annotation.keys
+  class TestAnnotation2 < Test::Unit::TestCase
+    class X
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
     end
-  end
+    class Y < X ; end
 
-  # Define annotation for a key. The note parameter must be
-  # a Hash or Hash-like object.
-  private
-  def define_annotation( key, note )
-    key = key.to_sym
-    method_annotation[key] = Annotation.new(note).inherits(self){ |anc| anc.method_annotation[key] }
-    method_annotation[key]
+    def test_2_01
+      assert_equal(Y.ann.x1.original.object_id, Y.ann.x1.original.object_id)
+    end
+    def test_2_02
+      assert_equal(1, Y.ann.x1.a)
+      assert_equal(2, Y.ann.x1.b)
+    end
+    def test_2_03
+      Y.ann.x1.a = 2
+      assert_equal(2, Y.ann.x1.a)
+      assert_equal(2, Y.ann.x1.b)
+    end
   end
 
-  public
-  def ann(*args)
-    harg = args.last.is_a?(Hash) ? args.pop : {}
-
-    #return annotator if args.empty? and harg.empty?
-    return @_ann ||= Annotator.new( self ) if args.empty? and harg.empty?
-
-    # for array of "mini-hashes" format
-    if harg.empty? and Hash === args[0]
-      args.each{|e| e.each{|k,v| harg[k]=v}}
-      args = []
-    end
-
-    # querying a single annotation
-    if harg.empty? and args.size == 1
-      return annotation if self == args[0] or :self == args[0]
-      #return args[0].annotation unless args[0].is_a?(Symbol) or args[0].is_a?(String)
-      return method_annotation( args[0] ) #.inherit
-    end
-
-    # if last element is a class (and there are more then just the one element)
-    harg[:class] = args.pop if args.last.is_a?(Class) and args.size > 1
-
-    if args.empty?  # hash format
-      harg.each do |key,hsh|
-        if key == :self
-          annotation.__update__( hsh )
-          next
-        end
-        note = annotated?( key )
-        if note and null != note
-          note.__update__( hsh )
-        else
-          define_annotation( key, hsh )
-        end
-      end
-      return harg.keys
-    else  # name, hash format
-      args.each do |key|
-        if key == :self
-          annotation.__update__( harg )
-          next
-        end
-        note = annotated?( key )
-        if note and null != note
-          note.__update__( harg )
-        else
-          define_annotation( key, harg )
-        end
-      end
-      return args
+  class TestAnnotation3 < Test::Unit::TestCase
+    class X
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+    class Y < X
+      ann :x1, :y=>'Y'
     end
 
-  end #def ann
-
-end #class ::Module
+    def test_3_01
+      assert_equal(Y.ann.x1.original.object_id, Y.ann.x1.original.object_id)
+    end
+    def test_3_02
+      assert_equal(1, Y.ann.x1.a)
+    end
+    def test_3_03
+      Y.ann.x1.a = 2
+      assert_equal(2, Y.ann.x1.a)
+    end
+  end
 
+  class TestAnnotation4 < Test::Unit::TestCase
+    module M
+      def x1 ; end
+      ann :x1, :a=>1
+      ann :x1, :b=>2
+    end
+    class X
+      include M
+    end
 
+    def test_4_01
+      assert_equal(X.ann.x1.original.object_id, X.ann.x1.original.object_id)
+    end
+    def test_4_02
+      assert_equal(1, X.ann.x1.a)
+      assert_equal(2, X.ann.x1.b)
+    end
+    def test_4_03
+      X.ann.x1.a = 2
+      assert_equal(2, X.ann.x1.a)
+    end
+  end
 
-#  _____         _
-# |_   _|__  ___| |_
-#   | |/ _ \/ __| __|
-#   | |  __/\__ \ |_
-#   |_|\___||___/\__|
-#
+  class TestAnnotation5 < Test::Unit::TestCase
+    class X
+      ann :foo, :doc => "hello"
+      ann :foo, :bar => []
+    end
+    class Y < X
+      ann :foo, :class => String, :doc => "bye"
+    end
 
-=begin testing
+    def test_5_01
+      assert_equal( "hello", X.ann(:foo).doc )
+    end
+    def test_5_02
+      assert_equal( X.ann(:foo), X.ann.foo )
+    end
+    def test_5_03
+      X.ann(:foo).bar! << "1"
+      assert_equal( ["1"], X.ann.foo.bar )
+    end
+    def test_5_04
+      assert_equal( "bye", Y.ann(:foo).doc )
+    end
+    def test_5_05
+      #assert_equal( nil, Y.ann(:foo).bar )
+      assert_equal( ["1"], Y.ann(:foo).bar )
+    end
+    def test_5_06
+      Y.ann(:foo).doc = "cap"
+      assert_equal( "cap", Y.ann(:foo).doc  )
+    end
+    def test_5_07
+      Y.ann.foo.doc = "cap2"
+      assert_equal( "cap2", Y.ann(:foo).doc  )
+    end
+    def test_5_08
+      Y.ann(:foo).bar! << "2"
+      assert_equal( ["1", "2"], Y.ann(:foo).bar )
+      assert_equal( ["1", "2"], Y.ann(:foo).bar! )
+      assert_equal( ["1"], X.ann(:foo).bar )
+    end
+  end
 
-  require 'test/unit'
+  # Test non-existent elements.
 
-  class TC01 < Test::Unit::TestCase
+  class TestAnnotation6 < Test::Unit::TestCase
     class X
       def x1 ; end
-      ann :x1, :q=>3
-      ann :x1, :a=>1
+      ann :x1, :a=>1, :b=>2
     end
 
-    def test_01_001
+    def test_6_01
       assert_equal( 1, X.ann(:x1)[:a] )
-      assert_equal( 3, X.ann(:x1)[:q] )
-      assert_equal( null, X.ann(:x2) )
+      assert_equal( 2, X.ann(:x1)[:b] )
+      assert_equal( {}, X.ann(:x2) )
     end
-    def test_01_002
+    def test_6_02
       assert_equal( 1, X.ann(:x1)[:a] )
-      assert_equal( 3, X.ann(:x1)[:q] )
+      assert_equal( 2, X.ann(:x1)[:b] )
       assert_equal( nil, X.ann(:x1)[:c] )
     end
-    def test_01_003
+    def test_6_03
       assert_equal( 1, X.ann.x1[:a] )
-      assert_equal( 3, X.ann.x1[:q] )
+      assert_equal( 2, X.ann.x1[:b] )
     end
-    def test_01_004
+    def test_6_04
       assert_equal( 1, X.ann.x1.a )
-      assert_equal( 3, X.ann.x1.q )
+      assert_equal( 2, X.ann.x1.b )
     end
-    def test_01_005
-      assert_equal( null, X.ann.x2 )
-      assert_equal( null, X.ann.x1.r )
-    end
-    def test_02_007
-      X.ann.x1.a = 2
-      assert_equal(2, X.ann.x1.a)
+    def test_6_05
+      assert_equal( {}, X.ann.x2 )
+      assert_equal( nil, X.ann.x1.r )
     end
   end
 
-  class TC02 < Test::Unit::TestCase
+  class TestAnnotation7 < Test::Unit::TestCase
     class X
       def x ; end
       ann :x, :z=>1
     end
-    class Y < X
-      #ann :x, :y=>2
-    end
+    class Y < X ; end
 
-    def test_02_001
-      assert( Y.annotated?( :x ) )
-    end
-    def test_02_002
-      #assert_equal( [:x1], Y.annotated_methods )
-    end
-    def test_02_003
-      #assert_equal( 1, Y.ann(:x).inheritance )
-      #assert_equal( 1, Y.ann(:x) )
-    end
-    def test_02_004
+    def test_7_04
       assert_equal(1, X.ann(:x)[:z])
-      assert_equal(1, Y.ann(:x)[:z])
-    end
-    def test_02_005
+      assert_equal(nil, Y.ann(:x)[:z])
       assert_equal(1, Y.ann(:x).z)
     end
-    def test_02_006
+    def test_7_05
+      assert_equal(1, X.ann.x[:z])
+      assert_equal(nil, Y.ann.x[:z])
       assert_equal(1, Y.ann.x.z)
     end
-    def test_02_007
+    def test_7_06
       Y.ann.x.z = 2
       assert_equal(2, Y.ann.x.z)
     end
   end
 
-  class TC03 < Test::Unit::TestCase
+  class TestAnnotation8 < Test::Unit::TestCase
     class X
       def n ; end
       ann :n, :v=>1
@@ -378,102 +439,104 @@ end #class ::Module
       ann :n, :b=>2
     end
 
-    def test_03_001
+    def test_08_01
       assert_equal(2, Y.ann(:n)[:b])
-      assert_equal(1, Y.ann(:n)[:v])
+      assert_equal(nil, Y.ann(:n)[:v])
+      assert_equal(1, Y.ann(:n).v)
     end
-    def test_03_002
+    def test_08_02
       assert_equal(2, Y.ann(:n).b)
     end
-    def test_03_003
+    def test_08_03
       assert_equal(2, Y.ann.n.b)
     end
-    def test_03_004
-      #assert_equal( [:n], Y.annotated_methods )
-    end
-  end
-
-  class TC04 < Test::Unit::TestCase
-    module M
-      ann :m, :c=>3
-    end
-
-    def test_04_001
-      assert_equal(3, M.ann.m.c)
-    end
   end
 
-  class TC05 < Test::Unit::TestCase
+  class TestAnnotation9 < Test::Unit::TestCase
     module M
-      ann :m, :c=>3
-    end
-    class Y ; end
-    class Z < Y
-      include M
+      ann :a, String
+      ann :b, :foo=>3
     end
 
-    def test_05_001
-      assert_equal( 3, Z.ann.m.c )
+    def test_09_01
+      assert_equal( String, M.ann.a[:class] )
     end
-  end
-
-  class TC06 < Test::Unit::TestCase
-    module M
-      ann :m, String
+    def test_09_02
+      assert_equal( String, M.ann.a.class )
     end
-
-    def test_06_001
-      assert_equal( String, M.ann.m.class )
+    def test_09_03
+      assert_equal(3, M.ann.b.foo)
     end
   end
 
-  class TC07 < Test::Unit::TestCase
-    class K
-      ann self, :oid => 'key'
-      ann :w, String
-    end
-
-    def test_07_001
-      assert_equal( String, K.ann.w.class )
-    end
-
-    def test_07_002
-      assert_equal( 'key', K.ann.self.oid )
-    end
+#   class TestAnnotation10 < Test::Unit::TestCase
+#     module M
+#       ann :this, :koko => []
+#       ann.this.koko! << 1
+#     end
+#     class C1
+#       #ann :this, :koko => []
+#       include M
+#       ann.this.koko! << 2
+#       ann.this.koko! << 3
+#     end
+#     class C2
+#       include M
+#       ann.this.koko! << 4
+#     end
+#
+#     def test_10_01
+#       assert_equal( [1], M.ann.this.koko )
+#     end
+#     def test_10_02
+#       assert_equal( [1,2,3], C1.ann.this.koko )
+#     end
+#     def test_10_03
+#       assert_equal( [1,4], C2.ann.this.koko )
+#     end
+#   end
 
-    def test_07_003
-      #assert_equal( K.ann.self, K.ann(:self) )
-      #assert_equal( K.ann(K), K.annotation )
-      #assert_equal( K.ann.self.to_h, K.ann(K).to_h )
-      #assert_equal( K.ann.self, K.ann(K) )
-    end
-  end
+#   class TC07 < Test::Unit::TestCase
+#     class K
+#       ann self, :oid => 'key'
+#       ann :w, String
+#     end
+# 
+#     def test_07_001
+#       assert_equal( String, K.ann.w.class )
+#     end
+# 
+#     def test_07_002
+#       assert_equal( 'key', K.ann.self.oid )
+#     end
+# 
+#     def test_07_003
+#       #assert_equal( K.ann.self, K.ann(:self) )
+#       #assert_equal( K.ann(K), K.annotation )
+#       #assert_equal( K.ann.self.to_h, K.ann(K).to_h )
+#       #assert_equal( K.ann.self, K.ann(K) )
+#     end
+#   end
+# 
 
-  class TC08 < Test::Unit::TestCase
-    module M
-      ann :this, :koko => []
-      ann.this.koko! << 1
-    end
-    class C1
-      #ann :this, :koko => []
-      include M
-      ann.this.koko! << 2
-      ann.this.koko! << 3
-    end
-    class C2
-      include M
-      ann.this.koko! << 4
-    end
+#  class TestAnnotation7 < Test::Unit::TestCase
 
-    def test_08_001
-      assert_equal( [1], M.ann.this.koko )
-    end
-    def test_08_002
-      assert_equal( [1,2,3], C1.ann.this.koko )
-    end
-    def test_08_003
-      assert_equal( [1,4], C2.ann.this.koko )
-    end
-  end
+#     class X
+#       def x ; end
+#       ann :x, :z=>1
+#     end
+#     class Y < X ; end
+#
+#     def test_7_01
+#       assert( Y.annotated?(:x) )
+#     end
+#     def test_7_02
+#       assert_equal( [:x1], Y.annotated_methods )
+#     end
+#     def test_7_03
+#       assert_equal( 1, Y.ann(:x).inheritance )
+#       assert_equal( 1, Y.ann(:x) )
+#     end
+#   end
 
 =end