anise 0.1.1 → 0.2.0

data/test/test_annotations.rb

@@ -0,0 +1,136 @@
+require 'anise/annotation'
+
+class Test_Annotation_0 < Test::Unit::TestCase
+  class X
+    include Anise::Annotation
+
+    attr :a
+
+    ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
+
+    ann :a, :class => Integer
+
+    def initialize(a)
+      @a = a
+    end
+
+    def validate
+      instance_variables.each do |iv|
+        if validator = self.class.ann(iv)[:valid]
+          value = instance_variable_get(iv)
+          unless validator.call(value)
+            raise "Invalid value #{value} for #{iv}"
+          end
+        end
+      end
+    end
+  end
+
+  def test_annotation_class
+    assert_equal(Integer, X.ann(:a, :class))
+  end
+
+  def test_annotation_validate
+    x = X.new(1)
+    assert_nothing_raised{ x.validate }
+  end
+end
+
+class Test_Annotation_1 < Test::Unit::TestCase
+  class X
+    include Anise::Annotation
+    def x1 ; end
+    ann :x1, :a=>1
+    ann :x1, :b=>2
+  end
+
+  def test_1_01
+    assert_equal( X.ann(:x1,:a), X.ann(:x1,:a) )
+    assert_equal( X.ann(:x1,:a).object_id, X.ann(:x1,:a).object_id )
+  end
+  def test_1_02
+    X.ann :x1, :a => 2
+    assert_equal( 2, X.ann(:x1,:a) )
+  end
+end
+
+class Test_Annotation_2 < Test::Unit::TestCase
+  class X
+    include Anise::Annotation
+    def x1 ; end
+    ann :x1, :a=>1
+    ann :x1, :b=>2
+  end
+  class Y < X ; end
+
+  def test_2_01
+    assert_equal( Y.ann(:x1,:a), Y.ann(:x1,:a) )
+    assert_equal( Y.ann(:x1,:a).object_id, Y.ann(:x1,:a).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
+
+class Test_Annotation_3 < Test::Unit::TestCase
+  class X
+    include Anise::Annotation
+    ann :foo, Integer
+  end
+  class Y < X
+    ann :foo, String
+  end
+
+  def test_3_01
+    assert_equal( Integer, X.ann(:foo, :class) )
+  end
+  def test_3_02
+    assert_equal( String, Y.ann(:foo, :class) )
+  end
+end
+
+class Test_Annotation_4 < Test::Unit::TestCase
+  class X
+    include Anise::Annotation
+    ann :foo, :doc => "hello"
+    ann :foo, :bar => []
+  end
+  class Y < X
+    ann :foo, :class => String, :doc => "bye"
+  end
+
+  def test_4_01
+    assert_equal( "hello", X.ann(:foo,:doc) )
+  end
+  def test_4_02
+    assert_equal( X.ann(:foo), { :doc => "hello", :bar => [] } )
+  end
+  def test_4_03
+    X.ann(:foo,:bar) << "1"
+    assert_equal( ["1"], X.ann(:foo,:bar) )
+  end
+  def test_4_04
+    assert_equal( "bye", Y.ann(:foo,:doc) )
+  end
+  def test_4_05
+    #assert_equal( nil, Y.ann(:foo,:bar) )
+    assert_equal( ["1"], Y.ann(:foo,:bar) )
+  end
+  def test_4_06
+    Y.ann(:foo, :doc => "cap")
+    assert_equal( "cap", Y.ann(:foo, :doc)  )
+  end
+  def test_4_07
+    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
+

data/test/test_annotations_toplevel.rb

@@ -0,0 +1,131 @@
+require 'anise/annotation'
+
+include Anise::Annotation
+
+class Test_Annotation_Toplevel_0 < Test::Unit::TestCase
+  class X
+    attr :a
+    ann :a, :class => Integer
+    ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
+
+    def initialize(a)
+      @a = a
+    end
+
+    def validate
+      instance_variables.each do |iv|
+        if validator = self.class.ann(iv)[:valid]
+          value = instance_variable_get(iv)
+          unless validator.call(value)
+            raise "Invalid value #{value} for #{iv}"
+          end
+        end
+      end
+    end
+  end
+
+  def test_annotation_class
+    assert_equal(Integer, X.ann(:a, :class))
+  end
+
+  def test_annotation_validate
+    x = X.new(1)
+    assert_nothing_raised{ x.validate }
+  end
+
+end
+
+class Test_Annotation_Toplevel_1 < Test::Unit::TestCase
+  class X
+    def x1 ; end
+    ann :x1, :a=>1
+    ann :x1, :b=>2
+  end
+
+  def test_1_01
+    assert_equal( X.ann(:x1,:a), X.ann(:x1,:a) )
+    assert_equal( X.ann(:x1,:a).object_id, X.ann(:x1,:a).object_id )
+  end
+  def test_1_02
+    X.ann :x1, :a => 2
+    assert_equal( 2, X.ann(:x1,:a) )
+  end
+end
+
+class Test_Annotation_Toplevel_2 < Test::Unit::TestCase
+  class X
+    def x1 ; end
+    ann :x1, :a=>1
+    ann :x1, :b=>2
+  end
+  class Y < X ; end
+
+  def test_2_01
+    assert_equal( Y.ann(:x1,:a), Y.ann(:x1,:a) )
+    assert_equal( Y.ann(:x1,:a).object_id, Y.ann(:x1,:a).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
+
+class Test_Annotation_Toplevel_3 < Test::Unit::TestCase
+  class X
+    ann :foo, Integer
+  end
+  class Y < X
+    ann :foo, String
+  end
+
+  def test_3_01
+    assert_equal( Integer, X.ann(:foo, :class) )
+  end
+  def test_3_02
+    assert_equal( String, Y.ann(:foo, :class) )
+  end
+end
+
+class Test_Annotation_Toplevel_4 < Test::Unit::TestCase
+  class X
+    ann :foo, :doc => "hello"
+    ann :foo, :bar => []
+  end
+  class Y < X
+    ann :foo, :class => String, :doc => "bye"
+  end
+
+  def test_4_01
+    assert_equal( "hello", X.ann(:foo,:doc) )
+  end
+  def test_4_02
+    assert_equal( X.ann(:foo), { :doc => "hello", :bar => [] } )
+  end
+  def test_4_03
+    X.ann(:foo,:bar) << "1"
+    assert_equal( ["1"], X.ann(:foo,:bar) )
+  end
+  def test_4_04
+    assert_equal( "bye", Y.ann(:foo,:doc) )
+  end
+  def test_4_05
+    #assert_equal( nil, Y.ann(:foo,:bar) )
+    assert_equal( ["1"], Y.ann(:foo,:bar) )
+  end
+  def test_4_06
+    Y.ann(:foo, :doc => "cap")
+    assert_equal( "cap", Y.ann(:foo, :doc)  )
+  end
+  def test_4_07
+    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
+

data/test/test_annotator.rb

@@ -0,0 +1,28 @@
+require 'anise/annotator'
+
+class Test_Annotator < Test::Unit::TestCase
+
+  class X
+    include Anise::Annotator
+
+    annotator :req
+
+    req 'r'
+
+    def a ; "a"; end
+
+    req 's'
+
+    attr :b
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['r']}, X.ann(:a) )
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['s']}, X.ann(:b) )
+  end
+
+end
+

data/test/test_annotator_toplevel.rb

@@ -0,0 +1,30 @@
+require 'anise/annotator'
+
+include Anise::Annotator
+
+class Test_Annotator_Toplevel < Test::Unit::TestCase
+
+  class X
+    annotator :req
+
+    req 'r'
+
+    def a ; "a"; end
+
+    req 's'
+
+    attr :b
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['r']}, X.ann(:a) )
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['s']}, X.ann(:b) )
+  end
+
+end
+
+#annotator :req  # THIS DOES NOT WORK :(
+

data/test/test_attribute.rb

@@ -1,16 +1,37 @@
-require 'anise/attributes'
+require 'anise/attribute'
 
 class Test_Attribute < Test::Unit::TestCase
+  class X
+    include Anise::Attribute
+    attr :q
+    attr :a, :x => 1
+  end
 
-  include Anise::Annotatable::Attributes
+  def test_attr_a
+    assert_equal( {:x=>1}, X.ann(:a) )
+  end
+end
 
-  attr :q
+class Test_Attribute_Using_Attr < Test::Unit::TestCase
+  class A
+    include Anise::Attribute
+    attr :x, :cast=>"to_s"
+  end
 
-  attr :a, :x => 1
+  def test_01
+    assert_equal( "to_s", A.ann(:x,:cast) )
+  end
+end
 
-  def test_attr_a
-    assert_equal( {:x=>1}, self.class.ann(:a) )
+class Test_Attribute_Using_Attr_Accessor < Test::Unit::TestCase
+  class A
+    include Anise::Attribute
+    attr_accessor :x, :cast=>"to_s"
   end
 
+  def test_01
+    a = A.new
+    assert_equal( [:x], A.instance_attributes )
+  end
 end
 

data/test/test_attribute_toplevel.rb

@@ -0,0 +1,64 @@
+require 'anise/attribute'
+
+include Anise::Attribute
+
+class Test_Attribute_Toplevel < Test::Unit::TestCase
+  class X
+    attr :q
+    attr :a, :x => 1
+  end
+
+  def test_attr_a
+    assert_equal( {:x=>1}, X.ann(:a) )
+  end
+end
+
+class Test_Attribute_Toplevel_Using_Attr < Test::Unit::TestCase
+  class A
+    attr :x, :cast=>"to_s"
+  end
+
+  def test_01
+    assert_equal( "to_s", A.ann(:x,:cast) )
+  end
+end
+
+class Test_Attribute_Toplevel_Using_Attr_Accessor < Test::Unit::TestCase
+  class A
+    attr_accessor :x, :cast=>"to_s"
+  end
+
+  def test_01
+    a = A.new
+    assert_equal( [:x], A.instance_attributes )
+  end
+end
+
+
+=begin
+require 'annotable/attributes'
+require 'test/unit'
+
+include Anise::Attributes
+
+$self = self
+
+attr :b, :y => 1
+
+class Test_Attribute_Toplevel < Test::Unit::TestCase
+
+  attr :q
+
+  attr :a, :x => 1
+
+  def test_attr_a
+    assert_equal( {:x=>1}, self.class.ann(:a) )
+  end
+
+  def test_attr_b
+    assert_equal( {:y=>1}, $self.class.ann(:b) )
+  end
+
+end
+=end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: anise
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - tigerops-community@rubyforge.org
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-17 00:00:00 -04:00
+date: 2008-10-28 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -37,17 +37,19 @@ extra_rdoc_files:
 - VERSION
 - COPYING
 files: 
-- MANIFEST
+- lib
+- meta
 - test
-- test/test_toplevel_attribute.rb
-- test/test_attribute.rb
-- test/test_annotatable.rb
-- test/suite.rb
-- test/test_toplevel_annotatable.rb
 - RELEASE
 - README
 - HISTORY
-- meta
+- VERSION
+- COPYING
+- lib/anise
+- lib/anise.rb
+- lib/anise/attribute.rb
+- lib/anise/annotation.rb
+- lib/anise/annotator.rb
 - meta/require
 - meta/created
 - meta/homepage
@@ -56,14 +58,16 @@ files:
 - meta/license
 - meta/authors
 - meta/contact
-- lib
-- lib/anise
-- lib/anise/attributes.rb
-- lib/anise/annotations.rb
-- lib/anise/annotatable.rb
-- lib/anise.rb
-- VERSION
-- COPYING
+- test/test_attribute.rb
+- test/test_annotator.rb
+- test/suite.rb
+- test/test_annotator_toplevel.rb
+- test/test_annotations.rb
+- test/test_attribute_toplevel.rb
+- test/test_anise.rb
+- test/test_anise_toplevel.rb
+- test/test_annotations_toplevel.rb
+- MANIFEST
 has_rdoc: true
 homepage: http://
 post_install_message: 
@@ -95,8 +99,11 @@ signing_key:
 specification_version: 2
 summary: Annable is an annotations systems for the Ruby programming lanaguage.
 test_files: 
-- test/test_toplevel_attribute.rb
 - test/test_attribute.rb
-- test/test_annotatable.rb
-- test/suite.rb
-- test/test_toplevel_annotatable.rb
+- test/test_annotator.rb
+- test/test_annotator_toplevel.rb
+- test/test_annotations.rb
+- test/test_attribute_toplevel.rb
+- test/test_anise.rb
+- test/test_anise_toplevel.rb
+- test/test_annotations_toplevel.rb

data/lib/anise/annotatable.rb

@@ -1,60 +0,0 @@
-module Anise
-  require 'anise/annotations.rb'
-
-  # = Annotatable
-  #
-  # Annotatable allows for the create of dynamic
-  # method annotations which attach to the next
-  # method defined.
-  #
-  #   class X
-  #     include Anise::Annotatable
-  #
-  #     annotation :doc
-  #
-  #     doc "See waht I mean?"
-  #     def see
-  #       # ...
-  #     end
-  #   end
-  #
-  #   X.ann(:see, :doc) #=> "See what I mean?"
-  #
-  # TODO: This must work when included in a module or
-  #       class and also when included at the toplevel.
-  #
-  module Annotatable
-
-    def self.append_features(base)
-      if base == Object
-        Module.send(:include, self)  # FIXME: Module ?
-      else
-        base.extend self
-      end
-    end
-
-    def pending_annotations
-      @pending_annotations ||= []
-    end
-
-    def annotation(name)
-      (class << self; self; end).instance_eval do
-        define_method(name) do |*args|
-          pending_annotations << [name, args]
-        end
-      end
-    end
-
-    def method_added(sym)
-      pending_annotations.each do |name, args|
-        ann sym, name => args
-      end
-      @pending_annotations = []
-    end
-
-  end
-
-end
-
-# Copyright (c) 2005, 2008 TigerOps
-

data/lib/anise/annotations.rb

@@ -1,114 +0,0 @@
-require 'facets/hash/rekey' # FIXME: remove dependency
-require 'facets/hash/op'    # FIXME: remove dependency
-
-# = Annotations
-#
-# Annotations allows you to annontate objects, including methods with arbitrary
-# "metadata". These annotations don't do anything in themselves. They are
-# merely data. But you can put them to use. For instance an attribute
-# validator might check for an annotation called :valid and test against it.
-#
-# == Synopsis
-#
-#   class X
-#     attr :a
-#     ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
-#
-#     def validate
-#       instance_variables.each do |iv|
-#         if validator = self.class.ann(iv)[:valid]
-#           value = instance_variable_get(iv)
-#           unless validator.call(vale)
-#             raise "Invalid value #{value} for #{iv}"
-#           end
-#         end
-#       end
-#     end
-#
-#   end
-#
-#--
-# By using a global veriable rather the definining a class instance variable
-# for each class/module, it is possible to quicky scan all annotations for the
-# entire system. To do the same without this would require scanning through
-# the ObjectSpace. (Still which is better?)
-#
-#$annotations = Hash.new { |h,k| h[k] = {} }
-#++
-#
-# TODO: The ann(x).name notation is kind of nice. Would like to add that
-#       back-in if reasonable. Basically this require heritage to be an
-#       OpenObject rather than just a hash.
-#
-#--
-# History Note
-#
-# * 2006-11-07 trans  Created this ultra-concise version of annotations.
-#++
-
-class ::Module
-
-  def annotations
-    #$annotations[self]
-    @annotations ||= {}
-  end
-
-  def heritage(ref)
-    ref = ref.to_sym
-    ancestors.inject({}) { |memo, ancestor|
-      ancestor.annotations[ref] ||= {}
-      ancestor.annotations[ref] + memo
-    }
-  end
-
-  # Set or read annotations.
-
-  def ann( ref, keys_or_class=nil, keys=nil )
-    return heritage(ref) unless keys_or_class or keys
-
-    if Class === keys_or_class
-      keys ||= {}
-      keys[:class] = keys_or_class
-    else
-      keys = keys_or_class
-    end
-
-    if Hash === keys
-      ref = ref.to_sym
-      annotations[ref] ||= {}
-      annotations[ref].update(keys.rekey)
-    else
-      key = keys.to_sym
-      heritage(ref)[key]
-    end
-  end
-
-  # To change an annotation's value in place for a given class or module
-  # it first must be duplicated, otherwise the change may effect annotations
-  # in the class or module's ancestors.
-
-  def ann!( ref, keys_or_class=nil, keys=nil )
-    #return heritage(ref) unless keys_or_class or keys
-    return annotations[ref] unless keys_or_class or keys
-
-    if Class === keys_or_class
-      keys ||= {}
-      keys[:class] = keys_or_class
-    else
-      keys = keys_or_class
-    end
-
-    if Hash === keys
-      ref = ref.to_sym
-      annotations[ref] ||= {}
-      annotations[ref].update(keys.rekey)
-    else
-      key = keys.to_sym
-      annotations[ref][key] = heritage(ref)[key].dup
-    end
-  end
-
-end
-
-# Copyright (c) 2005, 2008 TigerOps
-