anise 0.2.2 → 0.3.0

data/MANIFEST

@@ -1,6 +1,7 @@
 lib
 meta
 test
+spec
 MANIFEST
 RELEASE
 README
@@ -27,5 +28,6 @@ test/test_annotator_toplevel.rb
 test/test_annotations.rb
 test/test_attribute_toplevel.rb
 test/test_anise.rb
+test/test_annotations_module.rb
 test/test_anise_toplevel.rb
 test/test_annotations_toplevel.rb

data/RELEASE

@@ -1,13 +1,13 @@
-= Anise 0.2.2 hits the streets.
+= Anise 0.3.0
 
 Anise is a spin off the the Facets annotations.rb library.
 It includes the Annotations functionality, and adds
 a mixin, Annotator, that makes it easy to add new
 annotations on the fly.
 
-### 0.2.0 // 2008-09-23
+### 0.3.0 // 2009-02-15
 
 1 Major Enhancments
 
-  * #ann! will auto-prime any referenced annotation if it does not yet exist.
+  * Fixed some major bugs that prevented toplevel include from working.
 

data/VERSION

@@ -1 +1 @@
-anise 0.2.2 beta (2009-02-11)
+anise 0.3.0 beta (2009-02-15)

data/lib/anise/annotation.rb

@@ -71,7 +71,15 @@ module Anise
   module Annotation
 
     def self.append_features(base)
-      base.extend self
+      if base == ::Object
+        append_features(::Module)
+      elsif base == ::Module
+        unless ::Module < Annotation
+          super
+        end
+      else
+        base.extend self
+      end
     end
 
     # Lookup an annotation. Unlike +annotations[ref]+

data/lib/anise/annotator.rb

@@ -35,12 +35,30 @@ module Anise
   module Annotator
 
     def self.append_features(base)
-      #if base == Object
-      #  Module.send(:include, self)  # FIXME: Module ?
-      #else
+      if base == Object
+        append_features(::Module)
+      elsif base == ::Module
+        unless Module < Annotator
+          ::Module.module_eval do
+            include Annotation
+          end
+          # can't include b/c it seem Module intercetps the call.
+          ::Module.module_eval do
+            def method_added(sym)
+              @pending_annotations ||= []
+              @pending_annotations.each do |name, args|
+                ann sym, name => args
+              end
+              @pending_annotations = []
+              #super if defined?(super)
+            end
+          end
+          super
+        end
+      else
         base.extend Annotation #unless base.is_a?(Annotation)
         base.extend self
-      #end
+      end
     end
 
     def annotator(name)

data/lib/anise/attribute.rb

@@ -27,21 +27,36 @@ module Anise
   module Attribute
 
     def self.append_features(base)
-      base.extend Annotation
-      base.extend Attribute
-      base.module_eval do
+      if base == ::Object
+        append_features(::Module)
+      elsif base == ::Module
+        unless ::Module <= self
+          ::Module.module_eval do
+            include Annotation
+            super(::Module)
+          end
+          annotatable_attribute_method_for_module(:attr)
+          annotatable_attribute_method_for_module(:attr_reader)
+          annotatable_attribute_method_for_module(:attr_writer)
+          annotatable_attribute_method_for_module(:attr_accessor)
+          annotatable_attribute_method_for_module(:attr_setter) if defined?(attr_setter)
+        end
+      else
+        base.extend Annotation
+        base.extend Attribute
+        base = (class << base; self; end)
         #inheritor :instance_attributes, [], :|
-        annotatable_attribute_method(:attr_reader)
-        annotatable_attribute_method(:attr_writer)
-        annotatable_attribute_method(:attr_accessor)
-        annotatable_attribute_method(:attr_setter) if defined?(attr_setter)
+        annotatable_attribute_method(base, :attr)
+        annotatable_attribute_method(base, :attr_reader)
+        annotatable_attribute_method(base, :attr_writer)
+        annotatable_attribute_method(base, :attr_accessor)
+        annotatable_attribute_method(base, :attr_setter) if defined?(attr_setter)
       end
     end
 
     #
-    def annotatable_attribute_method(attr_method_name)
-      (class << self; self; end).module_eval do 
-
+    def self.annotatable_attribute_method(base, attr_method_name)
+      base.module_eval do
         define_method(attr_method_name) do |*args|
           args.flatten!
 
@@ -71,9 +86,45 @@ module Anise
             # return the names of the attributes created
             return args
           end
-
         end
+      end
+    end
+
+    #
+    def self.annotatable_attribute_method_for_module(attr_method_name)
+      ::Module.module_eval do
+        alias_method "__#{attr_method_name}", attr_method_name
+
+        define_method(attr_method_name) do |*args|
+
+          args.flatten!
+
+          harg={}; while args.last.is_a?(Hash)
+            harg.update(args.pop)
+          end
+
+          raise ArgumentError if args.empty? and harg.empty?
+
+          if args.empty?  # hash mode
+            harg.each { |a,h| __send__(attr_method_name,a,h) }
+          else
+            klass = harg[:class] = args.pop if args.last.is_a?(Class)
+
+            __send__("__#{attr_method_name}", *args)
+
+            args.each{|a| ann(a.to_sym,harg)}
+
+            instance_attributes!.concat(args)  #merge!
+
+            # Use this callback to customize for your needs.
+            if respond_to?(:attr_callback)
+              attr_callback(self, args, harg)
+            end
 
+            # return the names of the attributes created
+            return args
+          end
+        end
       end
     end
 

data/test/test_annotations_module.rb

@@ -0,0 +1,132 @@
+require 'anise/annotation'
+
+class Module
+  include Anise::Annotation
+end
+
+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_attribute_toplevel.rb

@@ -1,3 +1,4 @@
+require 'anise/annotation'
 require 'anise/attribute'
 
 include Anise::Attribute

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: anise
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors: 
 - tigerops-community@rubyforge.org
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-11 00:00:00 -05:00
+date: 2009-02-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -40,6 +40,7 @@ files:
 - lib
 - meta
 - test
+- spec
 - MANIFEST
 - RELEASE
 - README
@@ -66,6 +67,7 @@ files:
 - test/test_annotations.rb
 - test/test_attribute_toplevel.rb
 - test/test_anise.rb
+- test/test_annotations_module.rb
 - test/test_anise_toplevel.rb
 - test/test_annotations_toplevel.rb
 has_rdoc: true
@@ -105,5 +107,6 @@ test_files:
 - test/test_annotations.rb
 - test/test_attribute_toplevel.rb
 - test/test_anise.rb
+- test/test_annotations_module.rb
 - test/test_anise_toplevel.rb
 - test/test_annotations_toplevel.rb